catherd-cli 1.3.0 → 1.5.0

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";
@@ -5,13 +7,17 @@ import { BUILTIN_ROLES, type Profile } from "../domain/profile.ts";
 import { DEFAULT_ACCESS, ROLES } from "../domain/roles.ts";
 import { bunTooOld, MIN_BUN } from "../domain/runtime.ts";
 import type { JevTransport } from "../infra/jev-client.ts";
+import type { RoleServerStart } from "../infra/role-mcp.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 { cachesCheck, dockerChecks } from "./doctor-docker.ts";
+import { roleMcpChecks } from "./doctor-role-mcp.ts";
 import {
   agentsCheck,
+  hostFlag,
   type Check,
   errText,
   fixOf,
@@ -31,9 +37,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,20 +59,43 @@ 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;
+  /** plan 23: `--docker`: run the Docker host probes (a compose network by service name, the free disk) */
+  docker?: boolean;
+  env?: Record<string, string | undefined>;
   jev?: JevTransport;
+  /** spec 1.5 plan 21: a cold start of the role server, timed; absent, doctor does not probe it */
+  roleServerStart?: () => Promise<RoleServerStart>;
 }
 
 /**
  * Spec §10.3: the readiness report. Reads and probes; it writes discovery and a lock probe itself, and the
  * handshake starts `catherd mcp`, which reconciles runs as it starts. A check that throws becomes a `fail` row.
  */
+/**
+ * Where the access probes look for a per-repo sandbox: the current repo and each repo bound to a checked
+ * profile. A repo bound to another profile never runs these roles, so its settings must not decide the probes.
+ */
+export function accessRepos(
+  repo: string | null,
+  bindings: Record<string, string>,
+  checked: string[],
+): string[] {
+  const bound = Object.entries(bindings)
+    .filter(([, name]) => checked.includes(name))
+    .map(([r]) => r);
+  return [...new Set([...(repo ? [repo] : []), ...bound])];
+}
+
 export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
   const checks: Check[] = [];
   checks.push(
@@ -75,16 +108,24 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
           detail: `${d.bunVersion}, needs ${MIN_BUN}`,
           fix: "bun upgrade",
         }
-      : { id: "bun", label: "Bun", state: "ok", word: "ready", detail: d.bunVersion },
+      : {
+          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 +147,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 +159,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 +172,33 @@ 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)));
+  checks.push(...roleMcpChecks(active, await d.roleServerStart?.()));
 
   if (active && [active, ...profiles].every((p) => p.jev.use === "off"))
     checks.push({
@@ -179,7 +223,13 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
       const ok = await testJevKey(key, d.jev).catch(() => false);
       checks.push(
         ok
-          ? { id: "jev", label: "Jev", state: "ok", word: "ready", detail: "the key answers" }
+          ? {
+              id: "jev",
+              label: "Jev",
+              state: "ok",
+              word: "ready",
+              detail: "the key answers",
+            }
           : {
               id: "jev",
               label: "Jev",
@@ -194,18 +244,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,19 +291,58 @@ 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());
+  // plan 23: the toolchain caches workers write, and Docker as a gate sees it (before the access probes)
+  checks.push(cachesCheck());
+  checks.push(...(await dockerChecks({ probe: d.docker === true })));
   // spec §5 and §12: which codex sandbox form runs, and the five access probes per workspace-write backend
-  checks.push(...(await accessChecks(profiles, installed)));
+  let repos: string[] = d.repo ? [d.repo] : [];
+  try {
+    repos = accessRepos(
+      d.repo,
+      readProjects().bindings,
+      profiles.map((p) => p.name),
+    );
+  } catch {
+    // the config row above already reports an unreadable projects.json
+  }
+  checks.push(...(await accessChecks(profiles, installed, repos)));
 
   // spec 1.1 §13: what the shipped defaults do is info; a warning only for what a profile changed
   const full = { changed: [] as string[], shipped: [] as string[] };
@@ -264,7 +379,13 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
           word: "warning",
           detail: `${what}: ${rows.changed.join(", ")}${shipped ? `; as shipped: ${shipped}` : ""}`,
         }
-      : { id, label, state: "info", word: "default", detail: `${what}: ${shipped}` };
+      : {
+          id,
+          label,
+          state: "info",
+          word: "default",
+          detail: `${what}: ${shipped}`,
+        };
   };
   for (const row of [
     accessRow("access:full", "full access", full, "no sandbox for"),
@@ -307,7 +428,13 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
               detail: unreadable.message,
               fix: unreadable.fix ?? `fix or delete ${creds}, then catherd init`,
             }
-          : { id: "credentials", label: "credentials.json", state: "ok", word: "ready", detail: "mode 600" },
+          : {
+              id: "credentials",
+              label: "credentials.json",
+              state: "ok",
+              word: "ready",
+              detail: "mode 600",
+            },
     );
   }
 
@@ -322,7 +449,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 +474,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/end-push.ts

@@ -0,0 +1,157 @@
+import { readFileSync } from "node:fs";
+import { errorMessage } from "../domain/errors.ts";
+import type { HostSessionRef } from "../domain/host.ts";
+import { envelope, formatNotices } from "../domain/notice.ts";
+import { type QueueSendResult, sendToCodexQueue } from "../infra/codex-queue.ts";
+import {
+  type DeliveryAttempt,
+  deliveryState,
+  ROLE_THREAD_REFUSAL,
+  writeDeliveryAttempt,
+} from "../infra/delivery.ts";
+import { awaitsCollect, dispatchPaths } from "../infra/dispatch-dir.ts";
+import { tryLock } from "../infra/filelock.ts";
+import { log } from "../infra/log.ts";
+import { admitPath, listDispatches, roleThreadOf } from "./dispatches.ts";
+import { finalizeDispatch } from "./finalize.ts";
+import { finishedNotice, recoverSubmission } from "./notifier.ts";
+import { findRun } from "./run-store.ts";
+import { runOwner } from "./sessions.ts";
+
+/**
+ * How long the supervisor leaves the owner's MCP server to push first (the fast path: its watcher finalizes,
+ * settles and sends within the notifier's coalescing window). Either path sends under the same per-event receipt,
+ * so a late server or a late supervisor finds the event accepted and sends nothing.
+ */
+export const END_PUSH_GRACE_MS = 20_000;
+
+/** `CATHERD_END_PUSH_GRACE_MS` (a test of the spawned supervisor shortens it), else END_PUSH_GRACE_MS. */
+function graceFromEnv(): number {
+  const ms = Number(process.env.CATHERD_END_PUSH_GRACE_MS);
+  return process.env.CATHERD_END_PUSH_GRACE_MS !== undefined && Number.isFinite(ms) && ms >= 0
+    ? ms
+    : END_PUSH_GRACE_MS;
+}
+
+export interface EndPushOptions {
+  graceMs?: number;
+  /** the sender; tests replace it */
+  sendCodex?: (target: HostSessionRef, content: string) => Promise<QueueSendResult>;
+  now?: () => number;
+}
+
+/** Why the supervisor pushed nothing, or the receipt's status when it did. */
+export type EndPushOutcome =
+  | "off"
+  | "not-a-run"
+  | "not-codex"
+  | "limit"
+  | "read"
+  | "busy"
+  | "delivered"
+  | DeliveryAttempt["status"];
+
+/** The run's owner, when it is a Codex thread: the supervisor's push targets it. */
+function codexOwner(runId: string): HostSessionRef | null {
+  const owner = runOwner(findRun(runId));
+  return owner?.host === "codex"
+    ? { host: "codex", sessionId: owner.sessionId, hostSessionId: null, name: null }
+    : null;
+}
+
+/**
+ * Plan 22, push from where a role ends: the detached supervisor of a dispatch whose run a Codex thread owns, once
+ * its worker exited, queues the role's notice to that thread with `codex queue --remote unix:// --thread <owner>`.
+ * Codex's app-server keeps queued input for an unloaded thread, so a result reaches a coordinator whose MCP
+ * server the daemon stopped (no client attached) at its next attach. The notice is the server's own text, and it
+ * goes under the same per-event receipt (`delivery.json`, the dispatch's notify lock), so the two paths never
+ * double-deliver. A usage limit is left to the owner's server, which fails it over before it announces it.
+ * `CATHERD_NO_END_PUSH=1` turns it off (the test preload sets it). Never throws.
+ */
+export async function pushFromEnd(dispatchDir: string, o: EndPushOptions = {}): Promise<EndPushOutcome> {
+  if (process.env.CATHERD_NO_END_PUSH === "1") return "off";
+  try {
+    const runId = (JSON.parse(readFileSync(admitPath(dispatchDir), "utf8")) as { runId?: unknown }).runId;
+    if (typeof runId !== "string") return "not-a-run";
+    // read before the grace: a run no Codex thread owns costs the supervisor nothing
+    if (!codexOwner(runId)) return "not-codex";
+    await Bun.sleep(o.graceMs ?? graceFromEnv());
+    const run = findRun(runId);
+    const d = listDispatches(run).find((x) => x.dir === dispatchDir);
+    if (!d) return "not-a-run";
+    const record = await finalizeDispatch(run, d);
+    if (record.status === "limit") return "limit";
+    // the owner of record now, which a claim may have changed during the grace
+    const target = codexOwner(runId);
+    if (!target) return "not-codex";
+    if (!awaitsCollect(d.dir)) return "read";
+    const notice = finishedNotice(run, d, record);
+    const release = tryLock(dispatchPaths(d.dir).notified);
+    if (!release) return "busy";
+    try {
+      recoverSubmission(d.dir, notice.eventId);
+      if (deliveryState(d.dir, target, notice.eventId) !== "pending") return "delivered";
+      // spec 1.5 plan 21: never to a role's own thread (a `codex exec` thread exits after its turn, so what is
+      // queued there is lost); it fails loudly, with the notifier's reason, which `status` shows
+      const role = roleThreadOf(run, target.sessionId);
+      if (role !== null) {
+        const reason = `${ROLE_THREAD_REFUSAL} (${role}, ${target.host} ${target.sessionId}), not the orchestrator's; peek(run) from the orchestrator's session takes the run back`;
+        log("error", "notify", { from: "supervisor", run: run.id, dispatch: notice.dispatchId, reason });
+        writeDeliveryAttempt(d.dir, {
+          attemptId: crypto.randomUUID(),
+          target,
+          eventIds: [notice.eventId],
+          at: new Date((o.now ?? Date.now)()).toISOString(),
+          status: "failed",
+          msgId: null,
+          reason,
+        });
+        return "failed";
+      }
+      const attempt: DeliveryAttempt = {
+        attemptId: crypto.randomUUID(),
+        target,
+        eventIds: [notice.eventId],
+        at: new Date((o.now ?? Date.now)()).toISOString(),
+        status: "submitting",
+        msgId: null,
+        reason: null,
+      };
+      writeDeliveryAttempt(d.dir, attempt);
+      let sent: QueueSendResult;
+      try {
+        sent = await (o.sendCodex ?? ((t, c) => sendToCodexQueue(t, c, process.env)))(
+          target,
+          envelope(formatNotices([notice])),
+        );
+      } catch {
+        sent = { outcome: "ambiguous", reason: "Sender ended without a verified receipt; use peek/result." };
+      }
+      const receipt: DeliveryAttempt = {
+        ...attempt,
+        status:
+          sent.outcome === "accepted"
+            ? "accepted"
+            : sent.outcome === "not-submitted"
+              ? "failed"
+              : "ambiguous",
+        msgId: sent.outcome === "accepted" ? sent.msgId : null,
+        reason: sent.outcome === "accepted" ? null : sent.reason,
+      };
+      writeDeliveryAttempt(d.dir, receipt);
+      log(receipt.status === "accepted" ? "info" : "warn", "notify", {
+        from: "supervisor",
+        outcome: receipt.status,
+        msgId: receipt.msgId,
+        reason: receipt.reason,
+        dispatches: [notice.dispatchId],
+      });
+      return receipt.status;
+    } finally {
+      release();
+    }
+  } catch (e) {
+    log("warn", "notify", { from: "supervisor", dispatch: dispatchDir, error: errorMessage(e) });
+    return "not-a-run";
+  }
+}

package/src/services/finalize.ts

@@ -8,6 +8,7 @@ import { isCatherdError } from "../domain/errors.ts";
 import { parseRung } from "../domain/ids.ts";
 import {
   type ExitInfo,
+  parseReplyEnvironment,
   parseReplyStatus,
   type RunRecord,
   THREAD_HEAVY_INPUT,
@@ -25,6 +26,7 @@ import {
   writeTextAtomic,
 } from "../infra/store.ts";
 import { type Dispatch, dispatchState, listDispatches, readProc } from "./dispatches.ts";
+import { currentOwns } from "./lane-edit.ts";
 import { tail } from "./run-debug.ts";
 import { appendRecord, readRecords, recordsOnThread, type Run, runPaths } from "./run-store.ts";
 
@@ -75,7 +77,7 @@ function othersOwns(run: Run, self: Dispatch, start: number, end: number): strin
       const to = ended.get(d.admit.dispatchId) ?? (Date.parse(readExit(d.dir)?.endedAt ?? "") || Date.now());
       return from <= end && to >= start;
     })
-    .flatMap((d) => d.admit.owns);
+    .flatMap((d) => [...d.admit.owns, ...(d.admit.ownsImplicit ?? [])]);
 }
 
 /** The tree after the run, or null when git cannot say: the record is still written, its changes unknown. */
@@ -186,13 +188,20 @@ async function compute(run: Run, d: Dispatch): Promise<RunRecord> {
   const { changedOwned, violations } = after
     ? splitChanges(
         changedPaths(a.before, after),
-        a.owns,
+        // spec 1.5 owns_add: paths the lane gained while it ran are its own, not violations; a laneless
+        // writer is held to its implicit docs lane (plan 21)
+        a.lane !== null
+          ? [...new Set([...a.owns, ...currentOwns(run, a.lane)])]
+          : a.owns.length
+            ? a.owns
+            : (a.ownsImplicit ?? []),
         // from admission, when the before-snapshot was taken, not from the worker's start
         othersOwns(run, d, Date.parse(a.admittedAt), end),
         a.lane !== null || a.access === "read-only",
       )
     : { changedOwned: [], violations: [] };
   const reported = parseReplyStatus(replyText);
+  const environment = parseReplyEnvironment(replyText);
   return {
     schema: 1,
     runId: run.id,
@@ -219,6 +228,7 @@ async function compute(run: Run, d: Dispatch): Promise<RunRecord> {
     ...(after ? {} : { gitUnavailable: true }),
     replyStatus: reported.status,
     replyWhy: reported.why,
+    ...(environment ? { environment } : {}),
     threadHeavy: o.tokens.input >= THREAD_HEAVY_INPUT,
     access: a.access,
     isolated: a.isolated,
@@ -226,7 +236,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" } : {}),
   };
 }