fix: avoid imessage rpc restart loop

src/imessage/monitor/monitor-provider.ts

@@ -472,6 +472,9 @@ export async function monitorIMessageProvider(opts: MonitorIMessageOpts = {}): P
     check: async () => {
       const probe = await probeIMessage(2000, { cliPath, dbPath, runtime });
       if (probe.ok) return { ok: true };
+      if (probe.fatal) {
+        throw new Error(probe.error ?? "imsg rpc unavailable");
+      }
       return { ok: false, error: probe.error ?? "unreachable" };
     },
   });

src/imessage/probe.test.ts

@@ -0,0 +1,41 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { probeIMessage } from "./probe.js";
+
+const detectBinaryMock = vi.hoisted(() => vi.fn());
+const runCommandWithTimeoutMock = vi.hoisted(() => vi.fn());
+const createIMessageRpcClientMock = vi.hoisted(() => vi.fn());
+
+vi.mock("../commands/onboard-helpers.js", () => ({
+  detectBinary: (...args: unknown[]) => detectBinaryMock(...args),
+}));
+
+vi.mock("../process/exec.js", () => ({
+  runCommandWithTimeout: (...args: unknown[]) => runCommandWithTimeoutMock(...args),
+}));
+
+vi.mock("./client.js", () => ({
+  createIMessageRpcClient: (...args: unknown[]) => createIMessageRpcClientMock(...args),
+}));
+
+beforeEach(() => {
+  detectBinaryMock.mockReset().mockResolvedValue(true);
+  runCommandWithTimeoutMock.mockReset().mockResolvedValue({
+    stdout: "",
+    stderr: 'unknown command "rpc" for "imsg"',
+    code: 1,
+    signal: null,
+    killed: false,
+  });
+  createIMessageRpcClientMock.mockReset();
+});
+
+describe("probeIMessage", () => {
+  it("marks unknown rpc subcommand as fatal", async () => {
+    const result = await probeIMessage(1000, { cliPath: "imsg" });
+    expect(result.ok).toBe(false);
+    expect(result.fatal).toBe(true);
+    expect(result.error).toMatch(/rpc/i);
+    expect(createIMessageRpcClientMock).not.toHaveBeenCalled();
+  });
+});

src/imessage/probe.ts

@@ -1,11 +1,13 @@
 import { detectBinary } from "../commands/onboard-helpers.js";
 import { loadConfig } from "../config/config.js";
+import { runCommandWithTimeout } from "../process/exec.js";
 import type { RuntimeEnv } from "../runtime.js";
 import { createIMessageRpcClient } from "./client.js";
 
 export type IMessageProbe = {
   ok: boolean;
   error?: string | null;
+  fatal?: boolean;
 };
 
 export type IMessageProbeOptions = {
@@ -14,6 +16,44 @@ export type IMessageProbeOptions = {
   runtime?: RuntimeEnv;
 };
 
+type RpcSupportResult = {
+  supported: boolean;
+  error?: string;
+  fatal?: boolean;
+};
+
+const rpcSupportCache = new Map<string, RpcSupportResult>();
+
+async function probeRpcSupport(cliPath: string): Promise<RpcSupportResult> {
+  const cached = rpcSupportCache.get(cliPath);
+  if (cached) return cached;
+  try {
+    const result = await runCommandWithTimeout([cliPath, "rpc", "--help"], { timeoutMs: 2000 });
+    const combined = `${result.stdout}\n${result.stderr}`.trim();
+    const normalized = combined.toLowerCase();
+    if (normalized.includes("unknown command") && normalized.includes("rpc")) {
+      const fatal = {
+        supported: false,
+        fatal: true,
+        error: 'imsg CLI does not support the "rpc" subcommand (update imsg)',
+      };
+      rpcSupportCache.set(cliPath, fatal);
+      return fatal;
+    }
+    if (result.code === 0) {
+      const supported = { supported: true };
+      rpcSupportCache.set(cliPath, supported);
+      return supported;
+    }
+    return {
+      supported: false,
+      error: combined || `imsg rpc --help failed (code ${String(result.code ?? "unknown")})`,
+    };
+  } catch (err) {
+    return { supported: false, error: String(err) };
+  }
+}
+
 export async function probeIMessage(
   timeoutMs = 2000,
   opts: IMessageProbeOptions = {},
@@ -26,6 +66,15 @@ export async function probeIMessage(
     return { ok: false, error: `imsg not found (${cliPath})` };
   }
 
+  const rpcSupport = await probeRpcSupport(cliPath);
+  if (!rpcSupport.supported) {
+    return {
+      ok: false,
+      error: rpcSupport.error ?? "imsg rpc unavailable",
+      fatal: rpcSupport.fatal,
+    };
+  }
+
   const client = await createIMessageRpcClient({
     cliPath,
     dbPath,