catherd-cli 1.3.0 → 1.4.0

package/src/services/doctor-backends.ts

@@ -1,12 +1,13 @@
+import type { OrchestrationHost } from "../domain/host.ts";
 import type { Probe } from "../adapters/backend.ts";
 import { adapterFor } from "../adapters/registry.ts";
 import "../adapters/all.ts";
 import { ADAPTER_IDS, tryParseRung } from "../domain/ids.ts";
 import type { Profile } from "../domain/profile.ts";
 import { ROLES, type Role } from "../domain/roles.ts";
-import { probeBackend } from "./backends.ts";
+import { standInFor, probeBackend } from "./backends.ts";
 import { refreshDiscovery } from "./catalog-service.ts";
-import { type Check, errText, fixOf } from "./doctor-checks.ts";
+import { type Check, errText, fixOf, hostFlag } from "./doctor-checks.ts";
 
 // The backend rows of `catherd doctor` (spec §10.3) and the backends the linked profiles use.
 
@@ -22,7 +23,12 @@ export function usedBackends(profiles: Profile[]): Map<string, "role" | "failove
   };
   for (const p of profiles) {
     for (const role of ROLES) if (p.roles[role].enabled) for (const r of p.roles[role].rungs) note(r, "role");
-    for (const to of Object.values(p.failover)) note(to, "failover");
+    for (const role of ROLES)
+      if (p.roles[role].enabled)
+        for (const r of p.roles[role].rungs) {
+          const to = standInFor(p.failover, r);
+          if (to) note(to, "failover");
+        }
   }
   return used;
 }
@@ -52,10 +58,16 @@ const shellWord = (w: string): string => (/^[\w./:=@,+-]+$/.test(w) ? w : `'${w.
  * each linked profile, any default rung the new ladder would not hold reset first. The artist draws, which only Codex does, so
  * off Codex it is turned off instead.
  */
-export function moveRolesFix(install: string, id: string, to: string, profiles: Profile[]): string {
+export function moveRolesFix(
+  install: string,
+  id: string,
+  to: string,
+  profiles: Profile[],
+  host: OrchestrationHost = "unknown",
+): string {
   const onIt = (r: string | undefined) => r !== undefined && backendOf(r) === id;
   const set = (p: Profile, path: string, v: string) =>
-    `catherd profile set ${path} ${shellWord(v)} --profile ${shellWord(p.name)}`;
+    `catherd profile set ${path} ${shellWord(v)} --profile ${shellWord(p.name)}${hostFlag(host)}`;
   const stuck = new Set<Role>();
   const commands: string[] = [];
   for (const p of profiles)
@@ -87,10 +99,21 @@ export async function backendChecks(
   used: Map<string, "role" | "failover">,
   profiles: Profile[],
   installed?: Set<string>,
+  host: OrchestrationHost = "unknown",
 ): Promise<Check[]> {
   const checks: Check[] = [];
   const ready: string[] = [];
   for (const id of ADAPTER_IDS) {
+    if (host === "codex" && id === "claude-code" && !used.has(id)) {
+      checks.push({
+        id: `backend:${id}`,
+        label: id,
+        state: "skip",
+        word: "not required",
+        detail: "not probed: the selected profile has no headless Claude role or reachable failover",
+      });
+      continue;
+    }
     const a = adapterFor(id);
     if (!a) continue;
     const probe: Probe = await probeBackend(a).catch((e: unknown) => ({
@@ -124,7 +147,7 @@ export async function backendChecks(
               state: "warn",
               word: "billing",
               detail: `${detail} · profile ${billed.name} bills ${id} as ${billed.billing[id]}, but this login is ${probe.billing}`,
-              fix: `catherd profile set billing.${id} ${probe.billing} --profile ${billed.name}`,
+              fix: `catherd profile set billing.${id} ${probe.billing} --profile ${billed.name}${hostFlag(host)}`,
             }
           : { id: `backend:${id}`, label: id, state: "ok", word: "ready", detail },
       );
@@ -147,7 +170,7 @@ export async function backendChecks(
   for (const c of checks) {
     const id = c.id.slice("backend:".length);
     if (to && c.state === "fail" && c.word === PROBLEM_WORD.E_BACKEND_MISSING && c.fix && id !== to)
-      c.fix = moveRolesFix(c.fix, id, to, profiles);
+      c.fix = moveRolesFix(c.fix, id, to, profiles, host);
   }
   // spec §5.2: doctor refreshes discovery; a listing that fails keeps the last one
   let refreshed: Awaited<ReturnType<typeof refreshDiscovery>> = [];

package/src/services/doctor-checks.ts

@@ -1,3 +1,4 @@
+import type { OrchestrationHost } from "../domain/host.ts";
 import { readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { errorMessage, isCatherdError } from "../domain/errors.ts";
@@ -131,9 +132,13 @@ export function locksCheck(): Check {
   }
 }
 
-export function agentsCheck(): Check {
+export function agentsCheck(
+  host: OrchestrationHost,
+  selected?: string[],
+  relink = `catherd profile use ${activeName()}`,
+): Check {
   const base = { id: "agents", label: "Claude agents" };
-  const links = agentLinkState();
+  const links = agentLinkState(host, selected);
   const broken = [...links.missing, ...links.stale];
   if (broken.length)
     return {
@@ -141,13 +146,19 @@ export function agentsCheck(): Check {
       state: "fail",
       word: links.missing.length ? "missing" : "stale",
       detail: broken.join(", "),
-      fix: `catherd profile use ${activeName()}`,
+      fix: relink,
     };
   return links.ok.length
     ? { ...base, state: "ok", word: "ready", detail: `${links.ok.length} linked` }
     : { ...base, state: "skip", word: "none", detail: "no profile uses a native Claude rung" };
 }
 
+/**
+ * ` --host <host>` for a fix doctor prints, when it judged on a known host: run from a plain terminal, the fix
+ * must judge the profile the same way (omitted architect/verifier rungs resolve per host).
+ */
+export const hostFlag = (host: OrchestrationHost): string => (host === "unknown" ? "" : ` --host ${host}`);
+
 /** The browser CLI the ui-reviewer's prompt takes its screenshots with. */
 const UI_BROWSER = "agent-browser";
 
@@ -155,7 +166,11 @@ const UI_BROWSER = "agent-browser";
  * The ui-reviewer takes screenshots with agent-browser: a profile that turns it on, on a machine without it,
  * dispatches a role that cannot do its job. Nothing to say when it is on PATH or no profile turns the role on.
  */
-export function uiBrowserCheck(profiles: Profile[], onPath: (bin: string) => string | null): Check | null {
+export function uiBrowserCheck(
+  profiles: Profile[],
+  onPath: (bin: string) => string | null,
+  host: OrchestrationHost = "unknown",
+): Check | null {
   const on = profiles.filter((p) => p.roles["ui-reviewer"].enabled).map((p) => p.name);
   if (!on.length || onPath(UI_BROWSER)) return null;
   return {
@@ -167,7 +182,7 @@ export function uiBrowserCheck(profiles: Profile[], onPath: (bin: string) => str
     fix: [
       `npm i -g ${UI_BROWSER}`,
       "or turn the role off:",
-      ...on.map((n) => `catherd profile set roles.ui-reviewer.enabled false --profile ${n}`),
+      ...on.map((n) => `catherd profile set roles.ui-reviewer.enabled false --profile ${n}${hostFlag(host)}`),
     ].join("\n"),
   };
 }

package/src/services/doctor-push.ts

@@ -1,109 +1,88 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import type { HostContext } from "../domain/host.ts";
 import { envelope } from "../domain/notice.ts";
 import { readSessionEnv, sessionFileFor } from "../infra/claude-session.ts";
-import { claudeHome } from "../infra/paths.ts";
+import { sendToCodexQueue } from "../infra/codex-queue.ts";
 import { sendToInbox } from "../infra/peer-inbox.ts";
 import type { Check } from "./doctor-checks.ts";
 
-/**
- * Spec §3.9 `doctor`'s `push` row: run from inside a Claude Code session (its Bash tool), send that session one
- * `later` message and look for the enqueue line its transcript gets when the message is accepted
- * (docs/research/2026-09-28-cross-session-messaging.md §7).
- */
-
-export type PushOutcome = "ok" | "no-session" | "held" | "unconfirmed" | "failed";
-
+export type PushOutcome = "ok" | "no-session" | "unconfirmed" | "failed";
 export interface PushProbe {
   outcome: PushOutcome;
   detail: string;
+  enqueue: "accepted" | "ambiguous" | "not-submitted" | "no-session";
+  processing: "observed" | "unconfirmed";
+  msgId: string | null;
 }
 
-/** How long the probe looks for the enqueue line; tests shorten it. */
-export const pushLimits = { waitMs: 5_000, pollMs: 100 };
-
-/** The session's transcript, found by globbing `projects/*` (a git worktree logs under its main checkout's slug). */
-function transcriptOf(sessionId: string): string | null {
-  const projects = join(claudeHome(), "projects");
-  if (!existsSync(projects)) return null;
-  for (const d of readdirSync(projects)) {
-    const f = join(projects, d, `${sessionId}.jsonl`);
-    if (existsSync(f)) return f;
-  }
-  return null;
-}
-
-const enqueued = (file: string, nonce: string): boolean => {
-  try {
-    return readFileSync(file, "utf8")
-      .split("\n")
-      .some((l) => l.includes('"operation":"enqueue"') && l.includes(nonce));
-  } catch {
-    return false;
-  }
-};
-
-export async function probePush(env: Record<string, string | undefined> = process.env): Promise<PushProbe> {
-  const s = readSessionEnv(env);
-  if (!s?.socketPath)
-    return { outcome: "no-session", detail: "run catherd doctor from a Claude Code session to test push" };
-  const sessionId = sessionFileFor(s)?.sessionId ?? s.sessionId;
-  const nonce = crypto.randomUUID().slice(0, 8);
-  const r = await sendToInbox(s, envelope(`catherd doctor: push test ${nonce}, no action needed`), "later");
-  // a socket that is gone or refuses is a shell that outlived its session, not a protocol change
-  if (r.outcome === "no-session" || r.outcome === "refused")
+/** Explicit smoke only: native receipts prove acceptance, never model processing or result collection. */
+export async function probePush(
+  host: HostContext,
+  env: Record<string, string | undefined>,
+): Promise<PushProbe> {
+  const target = host.session;
+  if (host.conflict || !target || host.host === "unknown" || target.host !== host.host)
     return {
       outcome: "no-session",
-      detail: `this session's inbox is not reachable (${r.reason ?? r.outcome}); run catherd doctor from a live Claude Code session to test push`,
-    };
-  if (r.outcome !== "sent")
-    return {
-      outcome: "failed",
-      detail: `catherd cannot notify this Claude Code version; peek still works (${r.reason ?? r.outcome})`,
+      enqueue: "no-session",
+      processing: "unconfirmed",
+      msgId: null,
+      detail:
+        "No validated live host session; run doctor --test-push from the original conversation. Terminal --host selects checks only. Use peek/result.",
     };
-  const deadline = Date.now() + pushLimits.waitMs;
-  let file: string | null = null;
-  for (;;) {
-    file = sessionId ? transcriptOf(sessionId) : null;
-    if (file && enqueued(file, nonce))
-      return { outcome: "ok", detail: "a test message reached this session" };
-    if (Date.now() > deadline) break;
-    await Bun.sleep(pushLimits.pollMs);
-  }
-  return file
-    ? {
-        outcome: "held",
-        detail: `the test message was sent but not accepted within ${pushLimits.waitMs / 1000} s: a crossSessionInbound setting holds or refuses it`,
-      }
-    : {
-        outcome: "unconfirmed",
-        detail: "sent; no transcript of this session was found to confirm it arrived",
-      };
-}
-
-/** The probe as a `doctor` row. */
-export function pushCheck(p: PushProbe): Check {
-  const base = { id: "push", label: "push to Claude Code", detail: p.detail };
-  switch (p.outcome) {
-    case "ok":
-      return { ...base, state: "ok", word: "ready" };
-    case "no-session":
-      return { ...base, state: "skip", word: "no session" };
-    case "held":
+  const content = envelope(`catherd doctor: push test ${crypto.randomUUID().slice(0, 8)}, no action needed`);
+  let enqueue: PushProbe["enqueue"];
+  let msgId: string | null = null;
+  if (host.host === "codex") {
+    const sent = await sendToCodexQueue(target, content, env);
+    enqueue = sent.outcome;
+    if (sent.outcome === "accepted") msgId = sent.msgId;
+  } else {
+    const s = readSessionEnv(env);
+    const liveId = s ? (sessionFileFor(s)?.sessionId ?? s.sessionId) : null;
+    if (!s || liveId !== target.sessionId)
       return {
-        ...base,
-        state: "warn",
-        word: "held",
-        fix: `set "crossSessionInbound": "accept" in ${join(claudeHome(), "settings.json")}, or remove a project setting that sets it to hold or refuse`,
+        outcome: "no-session",
+        enqueue: "no-session",
+        processing: "unconfirmed",
+        msgId: null,
+        detail: "Claude inbox identity does not match the validated live session; use peek/result.",
       };
-    case "unconfirmed":
-      return { ...base, state: "warn", word: "not confirmed" };
-    case "failed":
+    const sent = await sendToInbox(s, content, "later");
+    if (sent.outcome === "no-session" || sent.outcome === "refused")
       return {
-        ...base,
-        state: "fail",
-        word: "failed",
-        fix: "update catherd (and Claude Code); meanwhile peek(run) shows each role and each unread record",
+        outcome: "no-session",
+        enqueue: "not-submitted",
+        processing: "unconfirmed",
+        msgId: null,
+        detail:
+          "This session's inbox is not reachable; run doctor --test-push from a live Claude Code session. Use peek/result.",
       };
+    enqueue = sent.outcome === "sent" && sent.msgId ? "accepted" : "ambiguous";
+    if (enqueue === "accepted") msgId = sent.msgId ?? null;
   }
+  return {
+    outcome: enqueue === "accepted" ? "ok" : enqueue === "ambiguous" ? "unconfirmed" : "failed",
+    enqueue,
+    processing: "unconfirmed",
+    msgId,
+    detail:
+      enqueue === "accepted"
+        ? "Smoke enqueue accepted; processing unconfirmed. Unloaded, interrupted or restarted hosts may retain queued input. Use peek/result for durable unread results."
+        : enqueue === "ambiguous"
+          ? "Smoke has no verified queue receipt; processing unconfirmed. Retrying may duplicate input. Use peek/result."
+          : "Smoke was not submitted; check native queue support and the existing endpoint. Use peek/result.",
+  };
+}
+
+export function pushCheck(p: PushProbe): Check {
+  const base = { id: "push", label: "host completion push", detail: p.detail };
+  if (p.enqueue === "accepted") return { ...base, state: "ok", word: "enqueue accepted" };
+  if (p.outcome === "no-session") return { ...base, state: "skip", word: "no session" };
+  if (p.enqueue === "ambiguous") return { ...base, state: "warn", word: "ambiguous" };
+  return {
+    ...base,
+    state: "fail",
+    word: "not submitted",
+    fix: "Check native host transport; peek/result keeps the unread record available.",
+  };
 }

package/src/services/doctor.ts

@@ -1,3 +1,5 @@
+import { queueCapability, type QueueCapability } from "../infra/codex-queue.ts";
+import type { HostContext } from "../domain/host.ts";
 import { existsSync, statSync } from "node:fs";
 import { adapterFor } from "../adapters/registry.ts";
 import "../adapters/all.ts";
@@ -8,10 +10,11 @@ import type { JevTransport } from "../infra/jev-client.ts";
 import { linkedProfiles } from "./agent-links.ts";
 import { accessChecks } from "./doctor-access.ts";
 import { backendChecks, usedBackends } from "./doctor-backends.ts";
-import { type PushProbe, pushCheck } from "./doctor-push.ts";
+import { type PushProbe, pushCheck, probePush } from "./doctor-push.ts";
 import { sourcesCheck, standInsToConfirmIn } from "./doctor-sources.ts";
 import {
   agentsCheck,
+  hostFlag,
   type Check,
   errText,
   fixOf,
@@ -31,9 +34,13 @@ import {
   readProjects,
   validateNamed,
 } from "./profile-store.ts";
+import { inspectionHost } from "./run-debug.ts";
 import { listRuns } from "./run-store.ts";
 
 export interface DoctorReport {
+  host: HostContext;
+  queue: QueueCapability | null;
+  push: PushProbe | null;
   /** false when any check failed: `catherd doctor` exits 3 */
   ready: boolean;
   version: string;
@@ -49,13 +56,17 @@ export interface Handshake {
 }
 
 export interface DoctorDeps {
+  host: HostContext;
+  repo: string | null;
   bunVersion: string;
   /** the package version, which the Claude Code plugin must pin */
   version: string;
   /** starts the MCP server as the plugin does (its launcher) over stdio and asks it for tools/list */
   handshake: () => Promise<Handshake>;
-  /** spec §3.9: sends this Claude Code session a test message; without it (the dashboard) there is no `push` row */
+  /** Explicit smoke test injection; default doctor never invokes it. */
   push?: () => Promise<PushProbe>;
+  testPush?: boolean;
+  env?: Record<string, string | undefined>;
   jev?: JevTransport;
 }
 
@@ -78,13 +89,15 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
       : { id: "bun", label: "Bun", state: "ok", word: "ready", detail: d.bunVersion },
   );
 
+  // every fix names the host doctor judged with: run elsewhere (a plain terminal), it must judge the same way
+  const onHost = hostFlag(d.host.host);
   let profiles: Profile[] = [];
   let linked: string[] = [];
   let active: Profile | null = null;
   try {
     readConfig();
     readProjects();
-    active = getProfile(activeName());
+    active = getProfile(activeName(d.repo), d.host.host);
     linked = linkedProfiles();
     checks.push({
       id: "config",
@@ -106,7 +119,7 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
   // one unreadable linked profile must not hide the others' backends: its own row below reports it
   profiles = linked.flatMap((n) => {
     try {
-      return [getProfile(n)];
+      return [getProfile(n, d.host.host)];
     } catch {
       return [];
     }
@@ -118,7 +131,7 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
         checks.push({
           id: `binding:${repo}`,
           label: `binding ${repo}`,
-          state: "fail",
+          state: repo === d.repo ? "fail" : "warn",
           word: "missing",
           detail: `bound to profile ${name}, which does not exist`,
           fix: `cd ${repo} && catherd profile use --repo --clear`,
@@ -131,30 +144,32 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
   const names = active ? [active.name, ...linked.filter((n) => n !== active?.name)] : [];
   for (const name of names) {
     const id = name === active?.name ? "profile" : `profile:${name}`;
-    const validate = `catherd profile validate ${name}`;
+    const validate = `catherd profile validate ${name}${onHost}`;
     const named = (fix: string) =>
-      fix.replaceAll("catherd profile set ", `catherd profile set --profile ${name} `);
-    checks.push(
-      guarded(id, `profile ${name}`, validate, () => {
-        const v = validateNamed(name);
-        const first = v.errors[0] ?? v.warnings[0];
-        return {
-          id,
-          label: `profile ${name}`,
-          state: v.errors.length ? "fail" : v.warnings.length ? "warn" : "ok",
-          word: v.errors.length ? "invalid" : v.warnings.length ? "warning" : "ready",
-          detail: first
-            ? `${first.path}: ${first.message}${v.errors.length + v.warnings.length > 1 ? " (and more)" : ""}`
-            : "valid",
-          ...(first ? { fix: first.fix ? named(first.fix) : validate } : {}),
-        };
-      }),
-    );
+      fix.replaceAll("catherd profile set ", `catherd profile set --profile ${name}${onHost} `);
+    const row = guarded(id, `profile ${name}`, validate, () => {
+      const v = validateNamed(name, d.repo, d.host.host);
+      const first = v.errors[0] ?? v.warnings[0];
+      return {
+        id,
+        label: `profile ${name}`,
+        state: v.errors.length ? "fail" : v.warnings.length ? "warn" : "ok",
+        word: v.errors.length ? "invalid" : v.warnings.length ? "warning" : "ready",
+        detail: first
+          ? `${first.path}: ${first.message}${v.errors.length + v.warnings.length > 1 ? " (and more)" : ""}`
+          : "valid",
+        ...(first ? { fix: first.fix ? named(first.fix) : validate } : {}),
+      };
+    });
+    if (name !== active?.name && row.state === "fail") row.state = "warn";
+    checks.push(row);
   }
 
+  const diagnostics = profiles;
+  profiles = active ? [active] : [];
   const used = usedBackends(profiles);
   const installed = new Set<string>();
-  checks.push(...(await backendChecks(used, profiles, installed)));
+  checks.push(...(await backendChecks(used, profiles, installed, d.host.host)));
 
   if (active && [active, ...profiles].every((p) => p.jev.use === "off"))
     checks.push({
@@ -194,18 +209,44 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
 
   // spec 1.2 §9: the public sources' ages and errors, the Artificial Analysis key, and the active and linked
   // profiles' stand-ins to confirm
-  const mine = [...(active ? [active] : []), ...profiles.filter((p) => p.name !== active?.name)];
+  const mine = [...(active ? [active] : []), ...diagnostics.filter((p) => p.name !== active?.name)];
   checks.push(
     guarded("sources", "sources", "catherd catalog sync --force", () =>
       sourcesCheck(Date.now(), standInsToConfirmIn(mine)),
     ),
   );
 
-  checks.push(pluginCheck(d.version));
+  const native = used.get("claude");
+  const plugin = pluginCheck(d.version);
+  if (d.host.host !== "claude-code" && native !== "role") {
+    plugin.state = native === "failover" ? "warn" : "skip";
+    plugin.word = native === "failover" ? "optional" : "not required";
+  }
+  checks.push(plugin);
 
+  // relinks the profile doctor checked: this repo's binding when it has one, else the active profile
+  let bound = false;
+  try {
+    bound = d.repo !== null && readProjects().bindings[d.repo] === active?.name;
+  } catch {
+    // the config row above already reports an unreadable projects.json
+  }
+  const relink = active
+    ? `${bound ? `cd ${d.repo} && ` : ""}catherd profile use ${active.name}${bound ? " --repo" : ""}${onHost}`
+    : "";
   checks.push(
     active
-      ? guarded("agents", "Claude agents", `catherd profile use ${activeName()}`, agentsCheck)
+      ? guarded("agents", "Claude agents", relink, () =>
+          native
+            ? agentsCheck(d.host.host, [active!.name], relink)
+            : {
+                id: "agents",
+                label: "Claude agents",
+                state: "skip",
+                word: "not required",
+                detail: "selected profile has no native Claude roles",
+              },
+        )
       : {
           id: "agents",
           label: "Claude agents",
@@ -215,15 +256,39 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
         },
   );
 
+  const agents = checks.find((c) => c.id === "agents");
+  if (native === "failover" && agents?.state === "fail") agents.state = "warn";
+
   const h = await d
     .handshake()
     .catch((e: unknown): Handshake => ({ ok: false, tools: [], error: errText(e) }));
   checks.push(mcpCheck(h, d.version));
 
-  if (d.push)
-    checks.push(
-      pushCheck(await d.push().catch((e: unknown): PushProbe => ({ outcome: "failed", detail: errText(e) }))),
-    );
+  const queue =
+    d.host.host === "codex" && !d.host.conflict ? await queueCapability(d.env ?? process.env) : null;
+  if (queue)
+    checks.push({
+      id: "push-capability",
+      label: "native Codex queue",
+      state:
+        !queue.cli || queue.server === "unsupported" ? "fail" : queue.server === "unverified" ? "warn" : "ok",
+      word: !queue.cli ? "unavailable" : queue.server,
+      detail: queue.reason ?? "Native server advertises queue support",
+      ...(!queue.cli || queue.server === "unsupported"
+        ? { fix: "Update native Codex/server; use peek/result while push is unavailable." }
+        : {}),
+    });
+  let push: PushProbe | null = null;
+  if (d.testPush) {
+    push = await (d.push ?? (() => probePush(d.host, d.env ?? process.env)))().catch((): PushProbe => ({
+      outcome: "failed",
+      enqueue: "ambiguous",
+      processing: "unconfirmed",
+      msgId: null,
+      detail: "Smoke has no verified receipt; retry may duplicate input. Use peek/result.",
+    }));
+    checks.push(pushCheck(push));
+  }
 
   checks.push(locksCheck());
   // spec §5 and §12: which codex sandbox form runs, and the five access probes per workspace-write backend
@@ -322,7 +387,7 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
       detail: "the plugin's MCP launcher runs bunx when no global catherd is installed",
       fix: "put Bun's bin folder (~/.bun/bin) on PATH",
     });
-  const browser = uiBrowserCheck(mine, onPath);
+  const browser = uiBrowserCheck(mine, onPath, d.host.host);
   if (browser) checks.push(browser);
   let corrupt: ReturnType<typeof listRuns>["corrupt"] = [];
   try {
@@ -347,5 +412,12 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
       fix: `fix or delete ${corrupt[0]?.dir}`,
     });
 
-  return { ready: !checks.some((c) => c.state === "fail"), version: d.version, checks };
+  return {
+    host: inspectionHost(d.host),
+    queue,
+    push,
+    ready: !checks.some((c) => c.state === "fail"),
+    version: d.version,
+    checks,
+  };
 }

package/src/services/finalize.ts

@@ -226,7 +226,7 @@ async function compute(run: Run, d: Dispatch): Promise<RunRecord> {
     images: o.images,
     error: o.error,
     replyPath: relative(run.dir, p.reply),
-    ...(a.sessionId ? { sessionId: a.sessionId } : {}),
+    ...(a.sessionId ? { sessionId: a.sessionId, host: a.host ?? "claude-code" } : {}),
   };
 }
 

package/src/services/lane-service.ts

@@ -88,6 +88,7 @@ export async function route(
   const lane = i.laneFile === undefined ? null : readLaneFile(run, i.laneFile);
   const profile = deps.profiles.forRepo(run.meta.repo);
   const a = await deps.routing.route({
+    host: deps.host.host,
     runDir: run.dir,
     repo: run.meta.repo,
     profile,