tmux-ide 2.7.0 → 2.8.0

package/packages/daemon/src/control/server.ts

@@ -0,0 +1,237 @@
+/**
+ * The control-socket server — `tmux-ide serve` (M23.3).
+ *
+ * NDJSON frames over a local Unix socket (default `~/.tmux-ide/control.sock`,
+ * mode 0600). Agent loops connect once and drive the fleet — request/response
+ * verbs plus PUSHED agent-status events after `subscribe` — instead of
+ * spawning a CLI process per call. Protocol schemas live in
+ * `@tmux-ide/contracts` (control.ts); verb handlers in `./verbs.ts` call the
+ * SAME data layer the CLI cases do.
+ *
+ * HOST DECISION (the tradeoff, considered before building):
+ *   (a) `tmux-ide serve` — an EXPLICIT foreground process. Costs the user a
+ *       deliberate start, dies with them, trivially restartable after a code
+ *       change, and its lifetime states its purpose.
+ *   (b) piggyback on the `_tmux-ide-chrome` updater tick — always running for
+ *       adopted fleets, but chrome-lifecycle-coupled: unadopting the last
+ *       session would kill the API mid-conversation, `adopt` would grow a
+ *       network-ish responsibility, and the updater's contract ("never let a
+ *       bad tick break the bars") is the wrong place for a protocol surface.
+ *   (c) socket-activated per-connection handlers — zero resident cost, but
+ *       every connection pays a full node boot (the latency the socket exists
+ *       to remove) and no resident process means no push events and no
+ *       persistent status tracker (the cross-tick `done` needs history).
+ *   CHOSEN: (a), deliberately WITHOUT auto-start. The old command-center HTTP
+ *   server is the cautionary tale: an implicitly-running daemon accretes
+ *   scope. This surface stays minimal — session-control verbs only, no feed,
+ *   no chat, no network listener — and the CLI only uses the socket
+ *   OPPORTUNISTICALLY (`--socket` fast-paths fall back to polling when no
+ *   server is up). An agent that wants the socket runs `tmux-ide serve`
+ *   itself; the process it spawned is the process it owns.
+ *
+ * SECURITY: local user only. The socket is chmod 0600, there is no network
+ * transport, no tokens (filesystem permissions ARE the auth). The #90 bridge
+ * that exposes this to a native app layers a WS server ON TOP later — each
+ * NDJSON frame maps 1:1 to a WS text message, so that bridge is mechanical
+ * and this file never grows remote scope.
+ *
+ * EVENTS: while at least one connection is subscribed, a detection tick
+ * (same cadence and diff as the chrome updater, one persistent tracker)
+ * computes the fleet and pushes session-level status transitions. No
+ * subscribers → no tick → an idle server does nothing. The tick does NOT
+ * write events.jsonl — the chrome updater owns the log; this stream is
+ * transport, not history.
+ */
+import { chmodSync, existsSync, mkdirSync, statSync, unlinkSync } from "node:fs";
+import { createServer, connect, type Server, type Socket } from "node:net";
+import { dirname, join } from "node:path";
+import { CONTROL_PROTOCOL_VERSION, type AgentStatusEvent } from "@tmux-ide/contracts";
+import { IdeError } from "../lib/errors.ts";
+import { tuiStateHome } from "../lib/tui-binary.ts";
+import { createStatusTracker, type AgentStatus } from "../tui/detect/classify.ts";
+import { diffFleet } from "../tui/chrome/events.ts";
+import { fleetStatuses, TICK_MS } from "../tui/chrome/updater.ts";
+import { listTeamProjects } from "../tui/team/projects.ts";
+import { dispatchLine } from "./dispatch.ts";
+import { createFanout } from "./fanout.ts";
+import { createFrameSplitter, encodeFrame } from "./frames.ts";
+import { createVerbHandlers } from "./verbs.ts";
+
+/** The default socket path — under the state home so `TMUX_IDE_HOME` scopes
+ *  tests away from the real user socket. */
+export function defaultControlSocketPath(): string {
+  return join(tuiStateHome(), "control.sock");
+}
+
+export interface ControlServerOptions {
+  socketPath?: string;
+  /** Diagnostics sink (the CLI passes stderr). Default: silent. */
+  log?: (message: string) => void;
+  /** Event-tick cadence override (tests); defaults to the updater's TICK_MS. */
+  tickMs?: number;
+}
+
+export interface ControlServer {
+  socketPath: string;
+  close(): Promise<void>;
+}
+
+/**
+ * Claim `path`: refuse anything that exists and is not a socket (NEVER
+ * unlink a foreign file), refuse a socket another live server answers on,
+ * and unlink a stale socket left by a dead server.
+ */
+async function claimSocketPath(path: string): Promise<void> {
+  if (!existsSync(path)) return;
+  if (!statSync(path).isSocket()) {
+    throw new IdeError(
+      `${path} exists and is not a socket — refusing to remove it. ` +
+        `Pass a different --socket path.`,
+      { code: "USAGE", exitCode: 1 },
+    );
+  }
+  const alive = await new Promise<boolean>((resolve) => {
+    const probe: Socket = connect(path);
+    const done = (result: boolean) => {
+      probe.destroy();
+      resolve(result);
+    };
+    probe.once("connect", () => done(true));
+    probe.once("error", () => done(false));
+    probe.setTimeout(500, () => done(false));
+  });
+  if (alive) {
+    throw new IdeError(`another server is already listening on ${path}`, {
+      code: "USAGE",
+      exitCode: 1,
+    });
+  }
+  unlinkSync(path); // stale socket from a dead server — safe to rebind
+}
+
+/** Start the server. Resolves once the socket is listening (mode 0600). */
+export async function startControlServer(opts: ControlServerOptions = {}): Promise<ControlServer> {
+  const socketPath = opts.socketPath ?? defaultControlSocketPath();
+  const log = opts.log ?? (() => {});
+  const tickMs = opts.tickMs ?? TICK_MS;
+
+  mkdirSync(dirname(socketPath), { recursive: true });
+  await claimSocketPath(socketPath);
+
+  // ONE tracker for the server's lifetime, shared by the verbs and the event
+  // tick — cross-tick `done` (working→idle) is only observable with history.
+  const tracker = createStatusTracker();
+  const handlers = createVerbHandlers({ tracker });
+
+  // The event tick: runs ONLY while subscribers exist (fanout edges), diffs
+  // the fleet exactly like the chrome updater, pushes transitions.
+  const prevState = new Map<string, AgentStatus>();
+  let timer: ReturnType<typeof setInterval> | null = null;
+  const tick = (): void => {
+    try {
+      const { events, state } = diffFleet(prevState, fleetStatuses(listTeamProjects(tracker)));
+      prevState.clear();
+      for (const [name, status] of state) prevState.set(name, status);
+      const ts = new Date().toISOString();
+      for (const ev of events) fanout.emit({ ts, ...ev });
+    } catch (err) {
+      log(`event tick failed: ${(err as Error).message}`);
+    }
+  };
+  const fanout = createFanout<AgentStatusEvent>({
+    onFirst: () => {
+      tick(); // seed immediately — the first events carry the current fleet (from: null)
+      timer = setInterval(tick, tickMs);
+    },
+    onLast: () => {
+      if (timer) clearInterval(timer);
+      timer = null;
+      prevState.clear();
+    },
+  });
+
+  const connections = new Set<Socket>();
+  const server: Server = createServer((conn) => {
+    connections.add(conn);
+    conn.setEncoding("utf8");
+    const split = createFrameSplitter();
+    let unsubscribe: (() => void) | null = null;
+
+    const push = (ev: AgentStatusEvent): void => {
+      // One write per frame — JSON.stringify never contains a raw newline,
+      // so frames from concurrent requests can never interleave mid-message.
+      conn.write(encodeFrame({ v: CONTROL_PROTOCOL_VERSION, event: "agent-status", data: ev }));
+    };
+    const ctx = {
+      subscribe: () => {
+        unsubscribe ??= fanout.add(push);
+      },
+    };
+
+    conn.on("data", (chunk: string) => {
+      let lines: string[];
+      try {
+        lines = split(chunk);
+      } catch {
+        conn.destroy(); // frame overflow — a broken client, not a slow one
+        return;
+      }
+      for (const line of lines) {
+        // Handled CONCURRENTLY: a long `wait` must not block this
+        // connection's other requests (responses correlate by id).
+        void dispatchLine(line, handlers, ctx).then((response) => {
+          if (!conn.destroyed) conn.write(encodeFrame(response));
+        });
+      }
+    });
+    conn.on("close", () => {
+      unsubscribe?.();
+      connections.delete(conn);
+    });
+    conn.on("error", () => {
+      // close follows; nothing to do — never let a client error kill serve
+    });
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", (err: NodeJS.ErrnoException) => {
+      // Unix sockets cap the path at ~104 bytes (macOS sun_path) — surfaced
+      // as a bare EINVAL. Say what actually went wrong and how to fix it.
+      if ((err.code === "EINVAL" || err.code === "ENAMETOOLONG") && socketPath.length > 100) {
+        reject(
+          new IdeError(
+            `socket path is too long for a Unix socket (${socketPath.length} chars; the OS caps it around 104): ${socketPath}\n` +
+              `Pass a shorter path: tmux-ide serve --socket /tmp/tmux-ide-control.sock`,
+            { code: "USAGE", exitCode: 1 },
+          ),
+        );
+        return;
+      }
+      reject(err);
+    });
+    server.listen(socketPath, () => {
+      server.removeAllListeners("error");
+      resolve();
+    });
+  });
+  chmodSync(socketPath, 0o600);
+  log(`listening on ${socketPath}`);
+
+  return {
+    socketPath,
+    close: () =>
+      new Promise<void>((resolve) => {
+        if (timer) clearInterval(timer);
+        timer = null;
+        for (const conn of connections) conn.destroy(); // clients see EOF
+        server.close(() => {
+          try {
+            unlinkSync(socketPath);
+          } catch {
+            // already gone
+          }
+          resolve();
+        });
+      }),
+  };
+}

package/packages/daemon/src/control/verbs.ts

@@ -0,0 +1,118 @@
+/**
+ * The v1 verb handlers — each one a THIN adapter from validated params to
+ * the SAME data-layer functions the CLI cases call (report/sessions/wait/
+ * send/agent-explain/lifecycle). No fleet logic lives here; if a verb needs
+ * logic a CLI case has inline, the logic moves to the data layer and both
+ * point at it (that's how `wait` and `send` got their shared cores).
+ */
+import {
+  agentsParamsSchema,
+  explainParamsSchema,
+  restartAgentParamsSchema,
+  sendParamsSchema,
+  spawnParamsSchema,
+  stopAgentParamsSchema,
+  waitParamsSchema,
+} from "@tmux-ide/contracts";
+import type { ZodType } from "zod";
+import { buildReport } from "../agent-explain.ts";
+import { deliverMessage } from "../send.ts";
+import type { StatusTracker } from "../tui/detect/classify.ts";
+import { toFleetJson } from "../tui/team/report.ts";
+import { listTeamProjects } from "../tui/team/projects.ts";
+import { listTeamSessions } from "../tui/team/sessions.ts";
+import { waitForAgentStatus, waitForOutputMatch } from "../tui/team/wait.ts";
+import { ControlVerbError, type VerbHandler } from "./dispatch.ts";
+import { resolveLaunchCommand, restartAgent, spawnAgent, stopAgent } from "./lifecycle.ts";
+
+/** Validate `params` against a verb's schema, or answer `bad-request`. */
+function parse<T>(schema: ZodType<T>, params: unknown): T {
+  const result = schema.safeParse(params);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    const at = issue?.path?.length ? ` at ${issue.path.join(".")}` : "";
+    throw new ControlVerbError("bad-request", `invalid params${at}: ${issue?.message ?? "?"}`);
+  }
+  return result.data;
+}
+
+/**
+ * Build the handler map. `tracker` is the server's ONE persistent status
+ * tracker (shared with the event tick) so `fleet`/`agents` see the
+ * cross-tick `done` transition exactly like the chrome updater does —
+ * a fresh tracker per call could never observe working→idle.
+ */
+export function createVerbHandlers(ctx: { tracker: StatusTracker }): Record<string, VerbHandler> {
+  return {
+    fleet: () => toFleetJson(listTeamProjects(ctx.tracker)),
+
+    agents: (params) => {
+      const p = parse(agentsParamsSchema, params);
+      const sessions = listTeamSessions(ctx.tracker);
+      const scoped = p.session ? sessions.filter((s) => s.name === p.session) : sessions;
+      if (p.session && scoped.length === 0) {
+        throw new ControlVerbError("not-found", `no session "${p.session}"`);
+      }
+      return { agents: scoped.flatMap((s) => s.agents ?? []) };
+    },
+
+    send: (params) => {
+      const p = parse(sendParamsSchema, params);
+      return deliverMessage(p);
+    },
+
+    wait: async (params) => {
+      const p = parse(waitParamsSchema, params);
+      if (p.kind === "output") {
+        try {
+          new RegExp(p.match);
+        } catch (err) {
+          throw new ControlVerbError(
+            "bad-request",
+            `invalid match regex: ${(err as Error).message}`,
+          );
+        }
+      }
+      const result =
+        p.kind === "agent-status"
+          ? await waitForAgentStatus(p.session, p.status, { timeoutMs: p.timeoutMs })
+          : await waitForOutputMatch(p.target, p.match, { timeoutMs: p.timeoutMs });
+      if (!result.ok) {
+        const what =
+          p.kind === "agent-status"
+            ? `"${p.session}" to reach status "${p.status}"`
+            : `${p.target} output to match /${p.match}/`;
+        throw new ControlVerbError(
+          "timeout",
+          `timed out after ${result.timedOutAfterMs}ms waiting for ${what}`,
+        );
+      }
+      return result;
+    },
+
+    spawn: (params) => {
+      const p = parse(spawnParamsSchema, params);
+      return spawnAgent({ ...p, command: resolveLaunchCommand(p) });
+    },
+
+    "restart-agent": (params) => {
+      const p = parse(restartAgentParamsSchema, params);
+      return restartAgent(p.paneId, resolveLaunchCommand(p));
+    },
+
+    "stop-agent": (params) => {
+      const p = parse(stopAgentParamsSchema, params);
+      return stopAgent(p.paneId);
+    },
+
+    explain: (params) => {
+      const p = parse(explainParamsSchema, params);
+      return buildReport(p.target);
+    },
+
+    subscribe: (_params, verbCtx) => {
+      verbCtx.subscribe();
+      return { subscribed: true, events: ["agent-status"] };
+    },
+  };
+}

package/packages/daemon/src/doctor.ts

@@ -1,11 +1,13 @@
 import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { accessSync, constants, existsSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getCurrentVersion, getUpdateStatus } from "./lib/update-check.ts";
 import { installedSkillVersion } from "./lib/skill-sync.ts";
 import { discoverAgents, presentAgents, type DiscoveredAgent } from "./lib/agent-discovery.ts";
 import { findCompiledTui, isBunAvailable } from "./tui/compiled.ts";
+import { claudeSettingsPath } from "./tui/integrations/claude.ts";
+import { readNotificationPrefs, resolveNativeMacosNotifierPath } from "./tui/chrome/notify.ts";
 
 interface CheckResult {
   label: string;
@@ -27,12 +29,19 @@ export function agentIntegrationRows(agents: DiscoveredAgent[]): CheckResult[] {
   return presentAgents(agents).map((agent) => {
     const label = `agent: ${agent.id}`;
     if (agent.integration) {
+      // What installing actually buys, honestly per mechanism: claude's hooks
+      // give ground-truth status (and record resume ids); opencode's plugin
+      // records resume ids only.
+      const benefit =
+        agent.capture === "hooks"
+          ? "for ground-truth status"
+          : "to record session ids for restore --resume-agents";
       return agent.installed
         ? { label, pass: true, detail: "integration installed ✓", optional: true }
         : {
             label,
             pass: false,
-            detail: `found on PATH — run \`tmux-ide integration install ${agent.id}\` for ground-truth status`,
+            detail: `found on PATH — run \`tmux-ide integration install ${agent.id}\` ${benefit}`,
             optional: true,
           };
     }
@@ -45,6 +54,59 @@ export function agentIntegrationRows(agents: DiscoveredAgent[]): CheckResult[] {
   });
 }
 
+/**
+ * PURE — the "Claude hooks target writable" row from observed facts. Both
+ * `integration install claude` and the npm postinstall write the settings
+ * file; surface a permissions problem BEFORE an install fails halfway.
+ * Optional: a machine without Claude Code shouldn't fail doctor over this.
+ */
+export function hooksTargetRow(facts: {
+  settingsPath: string;
+  fileExists: boolean;
+  writable: boolean;
+}): CheckResult {
+  const label = "Claude hooks target writable";
+  if (facts.writable) {
+    return {
+      label,
+      pass: true,
+      detail: facts.fileExists ? facts.settingsPath : `${facts.settingsPath} (will be created)`,
+      optional: true,
+    };
+  }
+  return {
+    label,
+    pass: false,
+    detail: `cannot write ${facts.settingsPath} — fix its permissions (chown/chmod), or point TMUX_IDE_CLAUDE_SETTINGS at a writable path`,
+    optional: true,
+  };
+}
+
+/**
+ * PURE — native notifier health, shown only when macOS notifications are ON.
+ * Release packages always include the helper; absence means an incomplete or
+ * old installation, which can still fall back to the unbranded AppleScript path.
+ * Optional — informational, never fails doctor.
+ */
+export function notifierRow(present: boolean): CheckResult {
+  const label = "native macOS notifications";
+  if (present) {
+    return {
+      label,
+      pass: true,
+      detail: "bundled — branded banners and click-to-jump are ready",
+      optional: true,
+    };
+  }
+  return {
+    label,
+    pass: false,
+    detail:
+      "native helper missing — reinstall tmux-ide; unbranded AppleScript banners remain available",
+    optional: true,
+  };
+}
+
 function check(
   label: string,
   fn: () => string,
@@ -67,7 +129,13 @@ export async function doctor({
 
   checks.push(
     check("tmux installed", () => {
-      execSync("which tmux", { stdio: "ignore" });
+      try {
+        execSync("which tmux", { stdio: "ignore" });
+      } catch {
+        throw new Error(
+          "not found on PATH — install it (macOS: `brew install tmux`; Debian/Ubuntu: `sudo apt install tmux`)",
+        );
+      }
       return "found";
     }),
   );
@@ -153,37 +221,49 @@ export async function doctor({
     ),
   );
 
-  checks.push(
+  // Optional tunnel CLIs: probe quietly (a missing binary must not leak
+  // "command not found" stderr into doctor's own output) and fail with a
+  // plain hint rather than execSync's raw error.
+  const tunnelCli = (label: string, cmd: string): CheckResult =>
     check(
-      "tailscale CLI",
-      () => {
-        const version = execSync("tailscale version", { encoding: "utf-8" }).trim().split("\n")[0]!;
-        return version;
-      },
-      { optional: true },
-    ),
-  );
-
-  checks.push(
-    check(
-      "ngrok CLI",
+      label,
       () => {
-        const version = execSync("ngrok version", { encoding: "utf-8" }).trim();
-        return version;
+        try {
+          return execSync(cmd, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] })
+            .trim()
+            .split("\n")[0]!;
+        } catch {
+          throw new Error("not found (optional — used for remote access tunnels)");
+        }
       },
       { optional: true },
-    ),
-  );
+    );
+  checks.push(tunnelCli("tailscale CLI", "tailscale version"));
+  checks.push(tunnelCli("ngrok CLI", "ngrok version"));
+  checks.push(tunnelCli("cloudflared CLI", "cloudflared --version"));
 
   checks.push(
-    check(
-      "cloudflared CLI",
-      () => {
-        const version = execSync("cloudflared --version", { encoding: "utf-8" }).trim();
-        return version;
-      },
-      { optional: true },
-    ),
+    (() => {
+      // Claude hooks target: the settings file `integration install claude`
+      // (and the npm postinstall) will write. Writability of the file itself
+      // when it exists, else of its nearest existing ancestor directory.
+      const settingsPath = claudeSettingsPath();
+      const fileExists = existsSync(settingsPath);
+      let probe = fileExists ? settingsPath : dirname(settingsPath);
+      while (!existsSync(probe)) {
+        const parent = dirname(probe);
+        if (parent === probe) break;
+        probe = parent;
+      }
+      let writable = false;
+      try {
+        accessSync(probe, constants.W_OK);
+        writable = true;
+      } catch {
+        // leave writable=false — the row explains the fix
+      }
+      return hooksTargetRow({ settingsPath, fileExists, writable });
+    })(),
   );
 
   checks.push(
@@ -222,6 +302,11 @@ export async function doctor({
     ),
   );
 
+  // Native branded sender: only when the macOS channel is actually on.
+  if (process.platform === "darwin" && readNotificationPrefs().macos) {
+    checks.push(notifierRow(resolveNativeMacosNotifierPath() !== null));
+  }
+
   // Agent integrations: one row per agent discovered on PATH (absent → no row).
   checks.push(...agentIntegrationRows(discoverAgents()));
 

package/packages/daemon/src/lib/agent-discovery.ts

@@ -17,6 +17,21 @@
  */
 import { execFileSync } from "node:child_process";
 import { claudeIntegrationStatus } from "../tui/integrations/claude.ts";
+import { opencodeIntegrationStatus } from "../tui/integrations/opencode.ts";
+
+/**
+ * How a kind's `@agent_session_id` (the `restore --resume-agents` key) gets
+ * captured:
+ *  - `"hooks"`  — the agent's own lifecycle hooks stamp it (claude; needs
+ *    `integration install`).
+ *  - `"plugin"` — an in-process plugin stamps it (opencode; needs
+ *    `integration install`).
+ *  - `"probe"`  — the chrome updater discovers it from the agent's own on-disk
+ *    session state (codex, cursor; automatic, nothing to install).
+ *  - `null`     — no defensible capture surface (see
+ *    {@link ../tui/detect/session-id.ts} for the per-kind evidence).
+ */
+export type CaptureMechanism = "hooks" | "plugin" | "probe" | null;
 
 /** A coding agent tmux-ide knows how to detect. */
 export interface KnownAgent {
@@ -26,19 +41,24 @@ export interface KnownAgent {
   bin: string;
   /** True → tmux-ide ships a lifecycle-integration installer for this agent. */
   integration: boolean;
+  /** How this kind's session id is captured for `restore --resume-agents`. */
+  capture: CaptureMechanism;
 }
 
 /**
  * The agents tmux-ide recognizes. `integration: true` means we HAVE an installer
- * (a real lifecycle hook → ground-truth pane state); the rest are detected via
- * screen-manifest scraping only, with no lifecycle hook yet.
+ * (claude's lifecycle hooks, opencode's plugin); the rest are detected via
+ * screen-manifest scraping only. `capture` records each kind's session-id
+ * story ({@link CaptureMechanism}).
  */
 export const KNOWN_AGENTS: readonly KnownAgent[] = [
-  { id: "claude", bin: "claude", integration: true },
-  { id: "codex", bin: "codex", integration: false },
-  { id: "opencode", bin: "opencode", integration: false },
-  { id: "gemini", bin: "gemini", integration: false },
-  { id: "aider", bin: "aider", integration: false },
+  { id: "claude", bin: "claude", integration: true, capture: "hooks" },
+  { id: "codex", bin: "codex", integration: false, capture: "probe" },
+  { id: "opencode", bin: "opencode", integration: true, capture: "plugin" },
+  { id: "gemini", bin: "gemini", integration: false, capture: null },
+  { id: "aider", bin: "aider", integration: false, capture: null },
+  { id: "cursor", bin: "cursor-agent", integration: false, capture: "probe" },
+  { id: "copilot", bin: "copilot", integration: false, capture: null },
 ];
 
 /** One probed agent: its registry facts plus what the PATH/integration probe found. */
@@ -55,6 +75,15 @@ export interface DiscoveredAgent {
    * integrate (there's nothing to install) and for any agent absent from PATH.
    */
   installed: boolean;
+  /** How this kind's session id is captured (copied from the registry). */
+  capture: CaptureMechanism;
+  /**
+   * Whether session-id capture is LIVE for this kind on this machine:
+   * `"probe"` capture is automatic whenever the binary is present; hook/plugin
+   * capture requires the integration to be installed; `null` capture is never
+   * active.
+   */
+  captureActive: boolean;
 }
 
 /** Resolve a binary to its absolute path, or null. Must never throw. */
@@ -84,14 +113,15 @@ const defaultWhich: WhichRunner = (bin) => {
 };
 
 /**
- * Default integration probe: only `claude` has an installer, so only it can be
- * "installed". Reads the real Claude settings; any failure degrades to false so
- * discovery never throws.
+ * Default integration probe: claude's hooks and opencode's plugin are the two
+ * shipped installers. Reads the real settings/plugin file; any failure degrades
+ * to false so discovery never throws.
  */
 const defaultIntegrationProbe: IntegrationProbe = (agentId) => {
-  if (agentId !== "claude") return false;
   try {
-    return claudeIntegrationStatus().installed;
+    if (agentId === "claude") return claudeIntegrationStatus().installed;
+    if (agentId === "opencode") return opencodeIntegrationStatus().installed;
+    return false;
   } catch {
     return false;
   }
@@ -111,7 +141,17 @@ export function discoverAgents(
     const path = which(agent.bin);
     const present = path !== null;
     const installed = present && agent.integration ? isInstalled(agent.id) : false;
-    return { id: agent.id, bin: agent.bin, integration: agent.integration, path, installed };
+    const captureActive =
+      agent.capture === "probe" ? present : agent.capture !== null ? installed : false;
+    return {
+      id: agent.id,
+      bin: agent.bin,
+      integration: agent.integration,
+      path,
+      installed,
+      capture: agent.capture,
+      captureActive,
+    };
   });
 }