@cabane/companion 0.6.19 → 0.6.21

package/dist/cli.js

@@ -295,6 +295,26 @@ var companionConfigSchema = z2.object({
   opencode: z2.object({
     serverUrl: z2.string().url()
   }).strict().optional(),
+  // CT1082: the Claude Code runtime, when the user connected it on this machine.
+  // The change this task exists for: Claude Code used to be the one harness a
+  // device exposed with no configuration — a `claude --version` exit-0 was taken as
+  // consent — and it is now the third config-driven harness, opted into exactly
+  // like codex. `claude` on PATH is still required (you can't run what isn't
+  // installed), but presence alone no longer exposes anything: the manifest
+  // advertises claude-code only when this block says so AND the binary is there.
+  //
+  // The block's PRESENCE is also the migration marker (see `migrateConnectedHarnesses`).
+  // Absent means the config predates this task — a device whose user was never
+  // asked — and the migration grandfathers it on first start. So every config
+  // written from here on carries the block explicitly, including a freshly-paired
+  // one, which starts at `enabled: false`: a new device is connected to nothing
+  // until its user says otherwise.
+  //
+  // Not to be confused with the per-agent `agents.<key>.claudeCode.autoMemory`
+  // above — that's one agent's memory switch, this is the device's connected set.
+  claudeCode: z2.object({
+    enabled: z2.boolean().optional()
+  }).strict().optional(),
   // CT481: the codex runtime, when the operator runs Codex on this machine. Unlike
   // opencode (a long-lived `opencode serve` addressed by URL), Codex is a local CLI
   // the `@openai/codex-sdk` spawns per turn — so the config is just an opt-in flag,
@@ -311,19 +331,26 @@ var companionConfigSchema = z2.object({
 function isCodexEnabled(cfg) {
   return !!cfg.codex && cfg.codex.enabled !== false;
 }
+function isClaudeCodeConnected(cfg) {
+  return !!cfg.claudeCode && cfg.claudeCode.enabled !== false;
+}
+function migrateConnectedHarnesses(cfg, claudeOnPath2) {
+  if (cfg.claudeCode !== void 0) return null;
+  return { ...cfg, claudeCode: { enabled: claudeOnPath2 } };
+}
 function localAgentConfig(cfg, agent) {
   const map = cfg.agents ?? {};
   return map[agent.agentId] ?? map[agent.agentUsername] ?? map[`${agent.workspaceSlug}/${agent.agentUsername}`] ?? {};
 }
 function loadConfig() {
-  const path3 = configPath();
-  if (!existsSync(path3)) return null;
+  const path = configPath();
+  if (!existsSync(path)) return null;
   let raw;
   try {
-    raw = readFileSync(path3, "utf8");
+    raw = readFileSync(path, "utf8");
   } catch (err) {
     throw new ConfigError(
-      `couldn't read ${path3}: ${err instanceof Error ? err.message : String(err)}`
+      `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
     );
   }
   if (raw.trim().length === 0) return null;
@@ -332,7 +359,7 @@ function loadConfig() {
     parsed = JSON.parse(raw);
   } catch (err) {
     throw new ConfigError(
-      `${path3} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+      `${path} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
     );
   }
   const result = companionConfigSchema.safeParse(parsed);
@@ -340,43 +367,50 @@ function loadConfig() {
     const agentIssue = result.error.issues.find((i) => i.path[0] === "agents");
     if (agentIssue) {
       throw new ConfigError(
-        `${path3}: invalid "agents" config at \`${agentIssue.path.join(".")}\` \u2014 ${agentIssue.message}. Fix the agents block in the config and retry.`
+        `${path}: invalid "agents" config at \`${agentIssue.path.join(".")}\` \u2014 ${agentIssue.message}. Fix the agents block in the config and retry.`
       );
     }
     throw new ConfigError(
-      `${path3} is from an incompatible or older version of the companion, or was hand-edited. Run \`cabane-companion pair\` to re-pair, or \`cabane-companion logout --purge\` to reset.`
+      `${path} is from an incompatible or older version of the companion, or was hand-edited. Run \`cabane-companion pair\` to re-pair, or \`cabane-companion logout --purge\` to reset.`
     );
   }
   return result.data;
 }
 function loadConfigTolerant() {
-  const path3 = configPath();
+  const path = configPath();
   const empty = {};
-  if (!existsSync(path3)) return { local: empty, note: null };
+  const fresh = { local: empty, note: null, hadPriorConfig: false };
+  if (!existsSync(path)) return fresh;
   let raw;
   try {
-    raw = readFileSync(path3, "utf8");
+    raw = readFileSync(path, "utf8");
   } catch {
-    return { local: empty, note: null };
+    return fresh;
   }
-  if (raw.trim().length === 0) return { local: empty, note: null };
+  if (raw.trim().length === 0) return fresh;
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    return { local: empty, note: `${path3} was unreadable (invalid JSON) and has been reset.` };
+    return {
+      local: empty,
+      note: `${path} was unreadable (invalid JSON) and has been reset.`,
+      hadPriorConfig: true
+    };
   }
   const strict = companionConfigSchema.safeParse(parsed);
   if (strict.success) {
-    const { agents: agents2, dashboardPort, autoOpen, logLevel } = strict.data;
+    const { agents: agents2, dashboardPort, autoOpen, logLevel, claudeCode: claudeCode2 } = strict.data;
     return {
       local: {
         ...agents2 !== void 0 ? { agents: agents2 } : {},
         ...dashboardPort !== void 0 ? { dashboardPort } : {},
         ...autoOpen !== void 0 ? { autoOpen } : {},
-        ...logLevel !== void 0 ? { logLevel } : {}
+        ...logLevel !== void 0 ? { logLevel } : {},
+        ...claudeCode2 !== void 0 ? { claudeCode: claudeCode2 } : {}
       },
-      note: null
+      note: null,
+      hadPriorConfig: true
     };
   }
   const obj = parsed && typeof parsed === "object" ? parsed : {};
@@ -388,26 +422,29 @@ function loadConfigTolerant() {
   if (obj.logLevel === "warn" || obj.logLevel === "info" || obj.logLevel === "debug") {
     local.logLevel = obj.logLevel;
   }
+  const claudeCode = companionConfigSchema.shape.claudeCode.safeParse(obj.claudeCode);
+  if (claudeCode.success && claudeCode.data !== void 0) local.claudeCode = claudeCode.data;
   return {
     local,
-    note: `the existing ${path3} was from an older or incompatible companion; re-pairing rewrote it.`
+    note: `the existing ${path} was from an older or incompatible companion; re-pairing rewrote it.`,
+    hadPriorConfig: true
   };
 }
 function saveConfig(cfg) {
-  const path3 = configPath();
-  mkdirSync(dirname(path3), { recursive: true });
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true });
   try {
     chmodSync(cabaneDir(), 448);
   } catch {
   }
-  const tmp = `${path3}.${process.pid}.tmp`;
+  const tmp = `${path}.${process.pid}.tmp`;
   try {
     writeFileSync(tmp, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
     try {
       chmodSync(tmp, 384);
     } catch {
     }
-    renameSync(tmp, path3);
+    renameSync(tmp, path);
   } catch (err) {
     try {
       rmSync(tmp, { force: true });
@@ -426,9 +463,9 @@ function requireConfig() {
   return cfg;
 }
 function deleteConfig() {
-  const path3 = configPath();
-  if (existsSync(path3)) {
-    writeFileSync(path3, "", { mode: 384 });
+  const path = configPath();
+  if (existsSync(path)) {
+    writeFileSync(path, "", { mode: 384 });
   }
 }
 
@@ -462,8 +499,8 @@ function consoleMessageFormat(log, messageKey) {
 var cached = null;
 function getLogger() {
   if (cached) return cached;
-  const path3 = companionLogPath();
-  mkdirSync2(dirname2(path3), { recursive: true });
+  const path = companionLogPath();
+  mkdirSync2(dirname2(path), { recursive: true });
   const streams = [];
   if (process.env.CABANE_COMPANION_DAEMON !== "1") {
     const consoleStream = pretty({
@@ -473,7 +510,7 @@ function getLogger() {
     });
     streams.push({ level: "info", stream: consoleStream });
   }
-  streams.push({ level: "debug", stream: createWriteStream(path3, { flags: "a" }) });
+  streams.push({ level: "debug", stream: createWriteStream(path, { flags: "a" }) });
   cached = pino({ level: "debug" }, pino.multistream(streams));
   return cached;
 }
@@ -592,26 +629,43 @@ async function codexOnPath() {
   ]);
   return version !== null;
 }
-async function ensureRuntimeAvailable(cfg, deps = {}) {
+async function requireStartConfig(deps = {}) {
+  const requireCfg = deps.requireCfg ?? requireConfig;
+  const probeClaude = deps.probeClaude ?? claudeOnPath;
+  const save2 = deps.save ?? saveConfig;
+  const cfg = requireCfg();
+  const claudeOnPathResult = await probeClaude();
+  const migrated = migrateConnectedHarnesses(cfg, claudeOnPathResult);
+  if (!migrated) return { cfg, claudeOnPath: claudeOnPathResult };
+  save2(migrated);
+  deps.onMigrated?.(migrated, claudeOnPathResult);
+  return { cfg: migrated, claudeOnPath: claudeOnPathResult };
+}
+async function warnAboutHarnessReadiness(cfg, deps = {}) {
   const probeClaude = deps.probeClaude ?? claudeOnPath;
   const probeCodex = deps.probeCodex ?? codexOnPath;
   const warn = deps.warn ?? ((message) => process.stderr.write(`${message}
 `));
-  if (await probeClaude()) return;
-  const alternates = [
-    ...cfg.opencode ? ["opencode"] : [],
-    ...isCodexEnabled(cfg) ? ["codex"] : []
+  const connected = [
+    ...isClaudeCodeConnected(cfg) ? ["Claude Code"] : [],
+    ...isCodexEnabled(cfg) ? ["Codex"] : [],
+    ...cfg.opencode ? ["opencode"] : []
   ];
-  if (alternates.length > 0) {
-    const exposed = alternates.join(" + ");
-    warn(
-      `warning: Claude Code isn\u2019t on your PATH, so this device exposes ${exposed} only \u2014 it advertises nothing else, so a Claude-model agent won\u2019t be routed here. Assign it agents on models ${exposed} can run, or install Claude Code (\`npm i -g @anthropic-ai/claude-code\`) and log in if you want this device to run Claude models too.`
-    );
+  if (connected.length > 0) {
+    if (isClaudeCodeConnected(cfg) && !await probeClaude()) {
+      warn(
+        "warning: Claude Code is connected on this device but `claude` isn\u2019t on your PATH, so it advertises nothing and a Claude-model agent won\u2019t be routed here. Install it (`npm i -g @anthropic-ai/claude-code`) and log in, or disconnect it."
+      );
+    }
     return;
   }
-  const installedButUnexposed = await probeCodex() ? 'Codex is installed on this machine but not exposed \u2014 enable it with `{ "codex": { "enabled": true } }` in ~/.cabane/config.json. Otherwise, expose a harness:\n' : "Expose at least one:\n";
-  throw new CompanionError(
-    "This device exposes no harness, so no agent turn can run here. " + installedButUnexposed + '  \u2022 Claude Code \u2014 install it (`npm i -g @anthropic-ai/claude-code`) and log in (`claude`, then follow the prompts); it\u2019s exposed automatically once `claude` is on your PATH.\n  \u2022 Codex \u2014 install the Codex CLI and log in (`codex login`), then add `{ "codex": { "enabled": true } }` to ~/.cabane/config.json.\n  \u2022 opencode \u2014 run `opencode serve --port 4096`, then add `{ "opencode": { "serverUrl": "http://127.0.0.1:4096" } }` to ~/.cabane/config.json.\nThen run `cabane-companion start` again (see the companion README).'
+  const [claudeInstalled, codexInstalled] = await Promise.all([probeClaude(), probeCodex()]);
+  const installed = [
+    ...claudeInstalled ? ["Claude Code"] : [],
+    ...codexInstalled ? ["Codex"] : []
+  ];
+  warn(
+    "No harness is connected on this device yet, so no agent turn can run here. " + (installed.length > 0 ? `We found ${installed.join(" and ")} on this machine \u2014 connect ${installed.length > 1 ? "one" : "it"} in the Companion dashboard (or in cabane, Settings \u2192 Devices) and turns start routing here.` : "Install a harness and sign in \u2014 Claude Code (`npm i -g @anthropic-ai/claude-code`), the Codex CLI (`codex login`), or `opencode serve` \u2014 then connect it in the Companion dashboard.")
   );
 }
 
@@ -634,9 +688,9 @@ function serialize(state) {
   return JSON.stringify(state, null, 2) + "\n";
 }
 function writeRuntimeState(state) {
-  const path3 = runtimePath();
+  const path = runtimePath();
   mkdirSync3(cabaneDir(), { recursive: true });
-  writeFileSync2(path3, serialize(state), "utf8");
+  writeFileSync2(path, serialize(state), "utf8");
 }
 function acquireRuntimeState(state) {
   const live = readLiveRuntimeState();
@@ -656,15 +710,15 @@ function acquireRuntimeState(state) {
   return { acquired: true };
 }
 function clearRuntimeState() {
-  const path3 = runtimePath();
-  if (existsSync2(path3)) rmSync2(path3, { force: true });
+  const path = runtimePath();
+  if (existsSync2(path)) rmSync2(path, { force: true });
 }
 function readLiveRuntimeState() {
-  const path3 = runtimePath();
-  if (!existsSync2(path3)) return null;
+  const path = runtimePath();
+  if (!existsSync2(path)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync2(path3, "utf8"));
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
   } catch {
     return null;
   }
@@ -709,15 +763,28 @@ function trimSlash(s) {
 var STARTUP_TIMEOUT_MS = 8e3;
 var POLL_INTERVAL_MS = 150;
 async function startDaemon(opts = {}, deps = {}) {
-  const ensureRuntime = deps.ensureRuntime ?? ensureRuntimeAvailable;
-  const requireCfg = deps.requireCfg ?? requireConfig;
+  const ensureRuntime = deps.ensureRuntime ?? warnAboutHarnessReadiness;
   const readState = deps.readState ?? readLiveRuntimeState;
   const verify = deps.verify ?? ((s) => verifyRuntime(s));
   const spawnDetached = deps.spawnDetached ?? defaultSpawnDetached;
   const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = deps.now ?? (() => Date.now());
-  const cfg = requireCfg();
-  await ensureRuntime(cfg);
+  const { cfg, claudeOnPath: claudeOnPath2 } = await requireStartConfig({
+    // Unset → `requireStartConfig`'s own `requireConfig`, the real one.
+    ...deps.requireCfg ? { requireCfg: deps.requireCfg } : {},
+    ...deps.probeClaude ? { probeClaude: deps.probeClaude } : {},
+    ...deps.save ? { save: deps.save } : {},
+    // The child won't log it (the block is written by then), and this process owns
+    // the user's terminal — so the one-time record is one line, here.
+    onMigrated: (_migrated, onPath) => {
+      if (onPath) {
+        process.stdout.write(
+          "Carried Claude Code over as a connected harness on this device \u2014 connectors are chosen now, not detected.\n"
+        );
+      }
+    }
+  });
+  await ensureRuntime(cfg, { probeClaude: async () => claudeOnPath2 });
   const existing = readState();
   if (existing) {
     if (await verify(existing) !== "stale") {
@@ -795,11 +862,11 @@ function credentialsPath() {
 }
 var credentialStoreSchema = z3.record(z3.string(), z3.string());
 function load() {
-  const path3 = credentialsPath();
-  if (!existsSync3(path3)) return {};
+  const path = credentialsPath();
+  if (!existsSync3(path)) return {};
   let raw;
   try {
-    raw = readFileSync3(path3, "utf8");
+    raw = readFileSync3(path, "utf8");
   } catch {
     return {};
   }
@@ -812,20 +879,20 @@ function load() {
   }
 }
 function save(map) {
-  const path3 = credentialsPath();
-  mkdirSync5(dirname3(path3), { recursive: true });
+  const path = credentialsPath();
+  mkdirSync5(dirname3(path), { recursive: true });
   try {
     chmodSync2(cabaneDir(), 448);
   } catch {
   }
-  const tmp = `${path3}.${process.pid}.tmp`;
+  const tmp = `${path}.${process.pid}.tmp`;
   try {
     writeFileSync3(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
     try {
       chmodSync2(tmp, 384);
     } catch {
     }
-    renameSync2(tmp, path3);
+    renameSync2(tmp, path);
   } catch (err) {
     try {
       rmSync3(tmp, { force: true });
@@ -857,8 +924,8 @@ function pruneCredentials(keepAgentIds) {
   return removed;
 }
 function clearCredentials() {
-  const path3 = credentialsPath();
-  if (existsSync3(path3)) writeFileSync3(path3, "", { mode: 384 });
+  const path = credentialsPath();
+  if (existsSync3(path)) writeFileSync3(path, "", { mode: 384 });
 }
 
 // src/commands/logout.ts
@@ -897,10 +964,10 @@ async function logout(opts = {}) {
 function trimBase(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
 }
-async function postJson(baseUrl, path3, body) {
+async function postJson(baseUrl, path, body) {
   let res;
   try {
-    res = await fetch(`${trimBase(baseUrl)}${path3}`, {
+    res = await fetch(`${trimBase(baseUrl)}${path}`, {
       method: "POST",
       headers: { "content-type": "application/json", accept: "application/json" },
       body: JSON.stringify(body)
@@ -920,7 +987,7 @@ async function postJson(baseUrl, path3, body) {
     }
   }
   if (res.status >= 400) {
-    if (res.status === 404 && path3.endsWith("/code")) {
+    if (res.status === 404 && path.endsWith("/code")) {
       throw new CompanionError(
         `no device-flow pairing endpoint at ${baseUrl}. Either that server predates \`cabane-companion pair\`, or it isn't a Cabane API origin \u2014 the hosted app is https://app.cabane.ai (pass \`--server <url>\` for your own instance).`
       );
@@ -992,8 +1059,16 @@ function resolvePairBaseUrl(server) {
   return raw;
 }
 function writePairedConfig(paired) {
-  const { local, note } = loadConfigTolerant();
+  const { local, note, hadPriorConfig } = loadConfigTolerant();
   const config = {
+    // CT1082: a device pairs connected to NOTHING — `claudeCode: { enabled: false }`
+    // written explicitly, not left absent, because absence is exactly what marks a
+    // pre-CT1082 config for the grandfathering migration. Omit it and a brand-new
+    // device gets auto-connected on its first start by the behaviour this task
+    // removes; stamp it on a RE-pair and an upgrading user's working device gets
+    // disconnected instead. So it's written only when there was no config here
+    // before. `local` spreads after, so a re-pair keeps the answer already given.
+    ...hadPriorConfig ? {} : { claudeCode: { enabled: false } },
     ...local,
     baseUrl: paired.baseUrl,
     deviceToken: paired.deviceToken,
@@ -1390,6 +1465,11 @@ function registerRoutes(app, deps) {
   app.post("/api/harnesses/enable", async (c) => {
     const body = await readJson(c);
     const runtime = body.runtime;
+    if (runtime === "claude-code") {
+      const result = await supervisor.enableHarness({ runtime: "claude-code" });
+      if (!result.ok) return c.json({ error: result.error }, 400);
+      return c.json({ ok: true, status: hub.statusJson() });
+    }
     if (runtime === "codex") {
       const result = await supervisor.enableHarness({ runtime: "codex" });
       if (!result.ok) return c.json({ error: result.error }, 400);
@@ -1458,12 +1538,12 @@ function clampLimit(raw, fallback, max = 200) {
   if (!Number.isFinite(n) || n <= 0) return fallback;
   return Math.min(Math.floor(n), max);
 }
-function tailFile(path3, lines) {
-  if (!existsSync4(path3)) return [];
+function tailFile(path, lines) {
+  if (!existsSync4(path)) return [];
   const MAX_BYTES = 256 * 1024;
   let fd;
   try {
-    fd = openSync3(path3, "r");
+    fd = openSync3(path, "r");
     const size = fstatSync(fd).size;
     const start2 = Math.max(0, size - MAX_BYTES);
     const len = size - start2;
@@ -1574,8 +1654,8 @@ var CabaneApi = class {
   // One HTTP attempt — no retry. Throws `ApiError` on a 4xx/5xx response and
   // rethrows transport errors (fetch reject) unchanged so the caller's retry
   // logic can classify them.
-  async attempt(method, path3, body, signal) {
-    const res = await fetch(`${this.base}${path3}`, {
+  async attempt(method, path, body, signal) {
+    const res = await fetch(`${this.base}${path}`, {
       method,
       headers: {
         Authorization: `Bearer ${this.opts.token}`,
@@ -1601,12 +1681,12 @@ var CabaneApi = class {
     }
     return parsed;
   }
-  async request(method, path3, body, opts = {}) {
+  async request(method, path, body, opts = {}) {
     const { signal, retry = false } = opts;
     const maxAttempts = retry ? RETRY_BACKOFF_MS.length + 1 : 1;
     for (let attempt = 1; ; attempt++) {
       try {
-        return await this.attempt(method, path3, body, signal);
+        return await this.attempt(method, path, body, signal);
       } catch (err) {
         if (attempt >= maxAttempts || signal?.aborted || !isRetryable(err)) throw err;
         await sleep2(RETRY_BACKOFF_MS[attempt - 1], signal);
@@ -1632,9 +1712,9 @@ var CabaneApi = class {
   //     delivers it once the API returns. `(turnId, seq)` is the server's
   //     idempotency key, so a replay whose original POST's fate is unknown
   //     converges instead of duplicating.
-  async durableCommit(kind, path3, body, turnId, seq, signal) {
+  async durableCommit(kind, path, body, turnId, seq, signal) {
     try {
-      await this.request("POST", path3, body, {
+      await this.request("POST", path, body, {
         retry: true,
         ...signal ? { signal } : {}
       });
@@ -1643,7 +1723,7 @@ var CabaneApi = class {
       if (!outbox) throw err;
       if (signal?.aborted || isAbortError(err)) throw err;
       if (!isRetryable(err)) throw err;
-      outbox.persist({ enqueuedAt: Date.now(), turnId, seq, method: "POST", path: path3, body, kind });
+      outbox.persist({ enqueuedAt: Date.now(), turnId, seq, method: "POST", path, body, kind });
       this.opts.log?.warn(
         { kind, turnId, seq, err: err instanceof Error ? err.message : String(err) },
         "companion: commit queued to outbox after transient failure (will drain when the API returns)"
@@ -1795,12 +1875,12 @@ var CabaneApi = class {
   // left best-effort: it's lower-stakes and self-heals on the next turn, so it
   // stays a single-shot PATCH and is deliberately out of CT93's scope.
   setActiveRun(workspaceId, conversationId, agentId, body) {
-    const path3 = `/api/workspaces/${workspaceId}/conversations/${conversationId}/participants/agents/${agentId}/active-run`;
+    const path = `/api/workspaces/${workspaceId}/conversations/${conversationId}/participants/agents/${agentId}/active-run`;
     const touchesFlag = Object.prototype.hasOwnProperty.call(body, "activeRunStartedAt");
     if (touchesFlag && this.opts.outbox) {
-      return this.durableActiveRunWrite(path3, conversationId, agentId, body);
+      return this.durableActiveRunWrite(path, conversationId, agentId, body);
     }
-    return this.request("PATCH", path3, body);
+    return this.request("PATCH", path, body);
   }
   // CT93: send-or-enqueue for an active-run flag write, with last-writer-wins
   // across the (conversation, agent) pair. Mirrors `durableCommit`, with two
@@ -1814,11 +1894,11 @@ var CabaneApi = class {
   //     later and clobber the state we just wrote (the cross-turn race: turn N's
   //     queued clear vs. turn N+1's live set). Combined with persist-overwrites-
   //     by-key, this is the full last-writer-wins guarantee.
-  async durableActiveRunWrite(path3, conversationId, agentId, body) {
+  async durableActiveRunWrite(path, conversationId, agentId, body) {
     const outbox = this.opts.outbox;
     const key = activeRunOutboxKey(conversationId, agentId);
     try {
-      await this.request("PATCH", path3, body, { retry: true });
+      await this.request("PATCH", path, body, { retry: true });
       outbox?.remove(key, ACTIVE_RUN_OUTBOX_SEQ);
     } catch (err) {
       if (!outbox) throw err;
@@ -1831,7 +1911,7 @@ var CabaneApi = class {
         turnId: key,
         seq: ACTIVE_RUN_OUTBOX_SEQ,
         method: "PATCH",
-        path: path3,
+        path,
         body,
         kind: "active-run"
       });
@@ -1919,8 +1999,8 @@ var CabaneApi = class {
   // shared resolver the in-app path uses. Omitting it (older call sites) returns
   // the agent default — graceful degradation, no version coupling.
   getAgentSelf(conversationId) {
-    const path3 = conversationId ? `/api/agent/me?conversationId=${encodeURIComponent(conversationId)}` : `/api/agent/me`;
-    return this.request("GET", path3);
+    const path = conversationId ? `/api/agent/me?conversationId=${encodeURIComponent(conversationId)}` : `/api/agent/me`;
+    return this.request("GET", path);
   }
   // The companion fetches the triggering message body by listing the
   // conversation's messages and finding the one with `id === messageId`.
@@ -1975,8 +2055,8 @@ var DeviceApi = class {
   get base() {
     return this.opts.baseUrl.endsWith("/") ? this.opts.baseUrl.slice(0, -1) : this.opts.baseUrl;
   }
-  async request(method, path3, body) {
-    const res = await fetch(`${this.base}${path3}`, {
+  async request(method, path, body) {
+    const res = await fetch(`${this.base}${path}`, {
       method,
       headers: {
         Authorization: `Bearer ${this.opts.deviceToken}`,
@@ -2030,15 +2110,15 @@ function pathFor(workspaceId) {
   return join7(cabaneDir(), "cursors", encodeURIComponent(workspaceId));
 }
 function readCursor(workspaceId) {
-  const path3 = pathFor(workspaceId);
-  if (!existsSync5(path3)) return null;
-  const raw = readFileSync4(path3, "utf8").trim();
+  const path = pathFor(workspaceId);
+  if (!existsSync5(path)) return null;
+  const raw = readFileSync4(path, "utf8").trim();
   return raw.length > 0 ? raw : null;
 }
 function writeCursor(workspaceId, eventId) {
-  const path3 = pathFor(workspaceId);
+  const path = pathFor(workspaceId);
   mkdirSync6(join7(cabaneDir(), "cursors"), { recursive: true });
-  writeFileSync4(path3, eventId + "\n", "utf8");
+  writeFileSync4(path, eventId + "\n", "utf8");
 }
 
 // src/cursor-tracker.ts
@@ -2091,10 +2171,10 @@ function pathFor2(log, workspaceId) {
   return join8(dir(log), encodeURIComponent(workspaceId));
 }
 function readIds(log, workspaceId) {
-  const path3 = pathFor2(log, workspaceId);
-  if (!existsSync6(path3)) return [];
+  const path = pathFor2(log, workspaceId);
+  if (!existsSync6(path)) return [];
   try {
-    return readFileSync5(path3, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+    return readFileSync5(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
   } catch {
     return [];
   }
@@ -2131,10 +2211,10 @@ function resumePathFor(workspaceId) {
 }
 function readResumeCounts(workspaceId) {
   const out = /* @__PURE__ */ new Map();
-  const path3 = resumePathFor(workspaceId);
-  if (!existsSync6(path3)) return out;
+  const path = resumePathFor(workspaceId);
+  if (!existsSync6(path)) return out;
   try {
-    for (const line of readFileSync5(path3, "utf8").split("\n")) {
+    for (const line of readFileSync5(path, "utf8").split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
       const tab = trimmed.lastIndexOf("	");
@@ -5072,536 +5152,10 @@ function isStringRecord2(v) {
   return !!v && typeof v === "object" && Object.values(v).every((x) => typeof x === "string");
 }
 
-// node_modules/.pnpm/@openai+codex-sdk@0.147.0/node_modules/@openai/codex-sdk/dist/index.js
-import { promises as fs } from "fs";
-import os from "os";
-import path from "path";
-import { spawn as spawn6 } from "child_process";
-import { statSync } from "fs";
-import path2 from "path";
-import readline from "readline";
-import { createRequire } from "module";
-async function createOutputSchemaFile(schema) {
-  if (schema === void 0) {
-    return { cleanup: async () => {
-    } };
-  }
-  if (!isJsonObject(schema)) {
-    throw new Error("outputSchema must be a plain JSON object");
-  }
-  const schemaDir = await fs.mkdtemp(path.join(os.tmpdir(), "codex-output-schema-"));
-  const schemaPath = path.join(schemaDir, "schema.json");
-  const cleanup = async () => {
-    try {
-      await fs.rm(schemaDir, { recursive: true, force: true });
-    } catch {
-    }
-  };
-  try {
-    await fs.writeFile(schemaPath, JSON.stringify(schema), "utf8");
-    return { schemaPath, cleanup };
-  } catch (error) {
-    await cleanup();
-    throw error;
-  }
-}
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var Thread = class {
-  _exec;
-  _options;
-  _id;
-  _threadOptions;
-  /** Returns the ID of the thread. Populated after the first turn starts. */
-  get id() {
-    return this._id;
-  }
-  /* @internal */
-  constructor(exec, options, threadOptions, id = null) {
-    this._exec = exec;
-    this._options = options;
-    this._id = id;
-    this._threadOptions = threadOptions;
-  }
-  /** Provides the input to the agent and streams events as they are produced during the turn. */
-  async runStreamed(input, turnOptions = {}) {
-    return { events: this.runStreamedInternal(input, turnOptions) };
-  }
-  async *runStreamedInternal(input, turnOptions = {}) {
-    const { schemaPath, cleanup } = await createOutputSchemaFile(turnOptions.outputSchema);
-    const options = this._threadOptions;
-    const { prompt, images } = normalizeInput(input);
-    const generator = this._exec.run({
-      input: prompt,
-      baseUrl: this._options.baseUrl,
-      apiKey: this._options.apiKey,
-      threadId: this._id,
-      images,
-      model: options?.model,
-      sandboxMode: options?.sandboxMode,
-      workingDirectory: options?.workingDirectory,
-      skipGitRepoCheck: options?.skipGitRepoCheck,
-      outputSchemaFile: schemaPath,
-      modelReasoningEffort: options?.modelReasoningEffort,
-      signal: turnOptions.signal,
-      networkAccessEnabled: options?.networkAccessEnabled,
-      webSearchMode: options?.webSearchMode,
-      webSearchEnabled: options?.webSearchEnabled,
-      approvalPolicy: options?.approvalPolicy,
-      additionalDirectories: options?.additionalDirectories
-    });
-    try {
-      for await (const item of generator) {
-        let parsed;
-        try {
-          parsed = JSON.parse(item);
-        } catch (error) {
-          throw new Error(`Failed to parse item: ${item}`, { cause: error });
-        }
-        if (parsed.type === "thread.started") {
-          this._id = parsed.thread_id;
-        } else if (parsed.type === "turn.completed") {
-          parsed.usage.cache_write_input_tokens ??= 0;
-        }
-        yield parsed;
-      }
-    } finally {
-      await cleanup();
-    }
-  }
-  /** Provides the input to the agent and returns the completed turn. */
-  async run(input, turnOptions = {}) {
-    const generator = this.runStreamedInternal(input, turnOptions);
-    const items = [];
-    let finalResponse = "";
-    let usage = null;
-    let turnFailure = null;
-    for await (const event of generator) {
-      if (event.type === "item.completed") {
-        if (event.item.type === "agent_message") {
-          finalResponse = event.item.text;
-        }
-        items.push(event.item);
-      } else if (event.type === "turn.completed") {
-        usage = event.usage;
-      } else if (event.type === "turn.failed") {
-        turnFailure = event.error;
-        break;
-      }
-    }
-    if (turnFailure) {
-      throw new Error(turnFailure.message);
-    }
-    return { items, finalResponse, usage };
-  }
-};
-function normalizeInput(input) {
-  if (typeof input === "string") {
-    return { prompt: input, images: [] };
-  }
-  const promptParts = [];
-  const images = [];
-  for (const item of input) {
-    if (item.type === "text") {
-      promptParts.push(item.text);
-    } else if (item.type === "local_image") {
-      images.push(item.path);
-    }
-  }
-  return { prompt: promptParts.join("\n\n"), images };
-}
-var INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE";
-var TYPESCRIPT_SDK_ORIGINATOR = "codex_sdk_ts";
-var CODEX_NPM_NAME = "@openai/codex";
-var PLATFORM_PACKAGE_BY_TARGET = {
-  "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
-  "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
-  "x86_64-apple-darwin": "@openai/codex-darwin-x64",
-  "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
-  "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
-  "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64"
-};
-var moduleRequire = createRequire(import.meta.url);
-var CodexExec = class {
-  executablePath;
-  pathDirs;
-  envOverride;
-  configOverrides;
-  constructor(executablePath = null, env, configOverrides) {
-    if (executablePath) {
-      this.executablePath = executablePath;
-      this.pathDirs = [];
-    } else {
-      const resolved = findCodexPath();
-      this.executablePath = resolved.executablePath;
-      this.pathDirs = resolved.pathDirs;
-    }
-    this.envOverride = env;
-    this.configOverrides = configOverrides;
-  }
-  async *run(args) {
-    const commandArgs = ["exec", "--experimental-json"];
-    if (this.configOverrides) {
-      for (const override of serializeConfigOverrides(this.configOverrides)) {
-        commandArgs.push("--config", override);
-      }
-    }
-    if (args.baseUrl) {
-      commandArgs.push(
-        "--config",
-        `openai_base_url=${toTomlValue(args.baseUrl, "openai_base_url")}`
-      );
-    }
-    if (args.model) {
-      commandArgs.push("--model", args.model);
-    }
-    if (args.sandboxMode) {
-      commandArgs.push("--sandbox", args.sandboxMode);
-    }
-    if (args.workingDirectory) {
-      commandArgs.push("--cd", args.workingDirectory);
-    }
-    if (args.additionalDirectories?.length) {
-      for (const dir2 of args.additionalDirectories) {
-        commandArgs.push("--add-dir", dir2);
-      }
-    }
-    if (args.skipGitRepoCheck) {
-      commandArgs.push("--skip-git-repo-check");
-    }
-    if (args.outputSchemaFile) {
-      commandArgs.push("--output-schema", args.outputSchemaFile);
-    }
-    if (args.modelReasoningEffort) {
-      commandArgs.push("--config", `model_reasoning_effort="${args.modelReasoningEffort}"`);
-    }
-    if (args.networkAccessEnabled !== void 0) {
-      commandArgs.push(
-        "--config",
-        `sandbox_workspace_write.network_access=${args.networkAccessEnabled}`
-      );
-    }
-    if (args.webSearchMode) {
-      commandArgs.push("--config", `web_search="${args.webSearchMode}"`);
-    } else if (args.webSearchEnabled === true) {
-      commandArgs.push("--config", `web_search="live"`);
-    } else if (args.webSearchEnabled === false) {
-      commandArgs.push("--config", `web_search="disabled"`);
-    }
-    if (args.approvalPolicy) {
-      commandArgs.push("--config", `approval_policy="${args.approvalPolicy}"`);
-    }
-    if (args.threadId) {
-      commandArgs.push("resume", args.threadId);
-    }
-    if (args.images?.length) {
-      for (const image of args.images) {
-        commandArgs.push("--image", image);
-      }
-    }
-    const env = {};
-    if (this.envOverride) {
-      Object.assign(env, this.envOverride);
-    } else {
-      for (const [key, value] of Object.entries(process.env)) {
-        if (value !== void 0) {
-          env[key] = value;
-        }
-      }
-    }
-    if (!env[INTERNAL_ORIGINATOR_ENV]) {
-      env[INTERNAL_ORIGINATOR_ENV] = TYPESCRIPT_SDK_ORIGINATOR;
-    }
-    if (args.apiKey) {
-      env.CODEX_API_KEY = args.apiKey;
-    }
-    if (this.pathDirs.length > 0) {
-      prependPathDirs(env, this.pathDirs);
-    }
-    const child = spawn6(this.executablePath, commandArgs, {
-      env,
-      signal: args.signal
-    });
-    let spawnError = null;
-    child.once("error", (err) => spawnError = err);
-    if (!child.stdin) {
-      child.kill();
-      throw new Error("Child process has no stdin");
-    }
-    child.stdin.write(args.input);
-    child.stdin.end();
-    if (!child.stdout) {
-      child.kill();
-      throw new Error("Child process has no stdout");
-    }
-    const stderrChunks = [];
-    if (child.stderr) {
-      child.stderr.on("data", (data) => {
-        stderrChunks.push(data);
-      });
-    }
-    const exitPromise = new Promise(
-      (resolve) => {
-        child.once("exit", (code, signal) => {
-          resolve({ code, signal });
-        });
-      }
-    );
-    const rl = readline.createInterface({
-      input: child.stdout,
-      crlfDelay: Infinity
-    });
-    try {
-      for await (const line of rl) {
-        yield line;
-      }
-      if (spawnError) throw spawnError;
-      const { code, signal } = await exitPromise;
-      if (code !== 0 || signal) {
-        const stderrBuffer = Buffer.concat(stderrChunks);
-        const detail = signal ? `signal ${signal}` : `code ${code ?? 1}`;
-        throw new Error(`Codex Exec exited with ${detail}: ${stderrBuffer.toString("utf8")}`);
-      }
-    } finally {
-      rl.close();
-      child.removeAllListeners();
-      try {
-        if (!child.killed) child.kill();
-      } catch {
-      }
-    }
-  }
-};
-function serializeConfigOverrides(configOverrides) {
-  const overrides = [];
-  flattenConfigOverrides(configOverrides, "", overrides);
-  return overrides;
-}
-function flattenConfigOverrides(value, prefix, overrides) {
-  if (!isPlainObject(value)) {
-    if (prefix) {
-      overrides.push(`${prefix}=${toTomlValue(value, prefix)}`);
-      return;
-    } else {
-      throw new Error("Codex config overrides must be a plain object");
-    }
-  }
-  const entries = Object.entries(value);
-  if (!prefix && entries.length === 0) {
-    return;
-  }
-  if (prefix && entries.length === 0) {
-    overrides.push(`${prefix}={}`);
-    return;
-  }
-  for (const [key, child] of entries) {
-    if (!key) {
-      throw new Error("Codex config override keys must be non-empty strings");
-    }
-    if (child === void 0) {
-      continue;
-    }
-    const path3 = prefix ? `${prefix}.${key}` : key;
-    if (isPlainObject(child)) {
-      flattenConfigOverrides(child, path3, overrides);
-    } else {
-      overrides.push(`${path3}=${toTomlValue(child, path3)}`);
-    }
-  }
-}
-function toTomlValue(value, path3) {
-  if (typeof value === "string") {
-    return JSON.stringify(value);
-  } else if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error(`Codex config override at ${path3} must be a finite number`);
-    }
-    return `${value}`;
-  } else if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  } else if (Array.isArray(value)) {
-    const rendered = value.map((item, index) => toTomlValue(item, `${path3}[${index}]`));
-    return `[${rendered.join(", ")}]`;
-  } else if (isPlainObject(value)) {
-    const parts = [];
-    for (const [key, child] of Object.entries(value)) {
-      if (!key) {
-        throw new Error("Codex config override keys must be non-empty strings");
-      }
-      if (child === void 0) {
-        continue;
-      }
-      parts.push(`${formatTomlKey(key)} = ${toTomlValue(child, `${path3}.${key}`)}`);
-    }
-    return `{${parts.join(", ")}}`;
-  } else if (value === null) {
-    throw new Error(`Codex config override at ${path3} cannot be null`);
-  } else {
-    const typeName = typeof value;
-    throw new Error(`Unsupported Codex config override value at ${path3}: ${typeName}`);
-  }
-}
-var TOML_BARE_KEY = /^[A-Za-z0-9_-]+$/;
-function formatTomlKey(key) {
-  return TOML_BARE_KEY.test(key) ? key : JSON.stringify(key);
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function findCodexPath() {
-  const { platform: platform2, arch } = process;
-  let targetTriple = null;
-  switch (platform2) {
-    case "linux":
-    case "android":
-      switch (arch) {
-        case "x64":
-          targetTriple = "x86_64-unknown-linux-musl";
-          break;
-        case "arm64":
-          targetTriple = "aarch64-unknown-linux-musl";
-          break;
-        default:
-          break;
-      }
-      break;
-    case "darwin":
-      switch (arch) {
-        case "x64":
-          targetTriple = "x86_64-apple-darwin";
-          break;
-        case "arm64":
-          targetTriple = "aarch64-apple-darwin";
-          break;
-        default:
-          break;
-      }
-      break;
-    case "win32":
-      switch (arch) {
-        case "x64":
-          targetTriple = "x86_64-pc-windows-msvc";
-          break;
-        case "arm64":
-          targetTriple = "aarch64-pc-windows-msvc";
-          break;
-        default:
-          break;
-      }
-      break;
-    default:
-      break;
-  }
-  if (!targetTriple) {
-    throw new Error(`Unsupported platform: ${platform2} (${arch})`);
-  }
-  const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
-  if (!platformPackage) {
-    throw new Error(`Unsupported target triple: ${targetTriple}`);
-  }
-  let vendorRoot;
-  try {
-    const codexPackageJsonPath = moduleRequire.resolve(`${CODEX_NPM_NAME}/package.json`);
-    const codexRequire = createRequire(codexPackageJsonPath);
-    const platformPackageJsonPath = codexRequire.resolve(`${platformPackage}/package.json`);
-    vendorRoot = path2.join(path2.dirname(platformPackageJsonPath), "vendor");
-  } catch {
-    throw new Error(
-      `Unable to locate Codex CLI binaries. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`
-    );
-  }
-  const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
-  const nativePackage = resolveNativePackage(vendorRoot, targetTriple, codexBinaryName);
-  if (!nativePackage) {
-    throw new Error(
-      `Unable to locate Codex CLI binaries for ${targetTriple}. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`
-    );
-  }
-  return nativePackage;
-}
-function resolveNativePackage(vendorRoot, targetTriple, codexBinaryName) {
-  const packageRoot = path2.join(vendorRoot, targetTriple);
-  const packageBinaryPath = path2.join(packageRoot, "bin", codexBinaryName);
-  if (isFile(packageBinaryPath) && isFile(path2.join(packageRoot, "codex-package.json"))) {
-    return {
-      executablePath: packageBinaryPath,
-      pathDirs: existingDirs(path2.join(packageRoot, "codex-path"))
-    };
-  }
-  const legacyBinaryPath = path2.join(packageRoot, "codex", codexBinaryName);
-  if (isFile(legacyBinaryPath)) {
-    return {
-      executablePath: legacyBinaryPath,
-      pathDirs: existingDirs(path2.join(packageRoot, "path"))
-    };
-  }
-  return null;
-}
-function existingDirs(...dirs) {
-  return dirs.filter(isDirectory);
-}
-function prependPathDirs(env, pathDirs, platform2 = process.platform) {
-  const pathKey = pathEnvKey(env, platform2);
-  if (platform2 === "win32") {
-    for (const key of Object.keys(env)) {
-      if (key.toLowerCase() === "path" && key !== pathKey) {
-        delete env[key];
-      }
-    }
-  }
-  const existingEntries = (env[pathKey] ?? "").split(path2.delimiter).filter((entry) => entry.length > 0 && !pathDirs.includes(entry));
-  env[pathKey] = [...pathDirs, ...existingEntries].join(path2.delimiter);
-}
-function pathEnvKey(env, platform2) {
-  if (platform2 !== "win32") {
-    return "PATH";
-  }
-  const matchingKeys = Object.keys(env).filter((key) => key.toLowerCase() === "path");
-  return matchingKeys.includes("Path") ? "Path" : matchingKeys.at(-1) ?? "PATH";
-}
-function isFile(filePath) {
-  try {
-    return statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function isDirectory(filePath) {
-  try {
-    return statSync(filePath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-var Codex = class {
-  exec;
-  options;
-  constructor(options = {}) {
-    const { codexPathOverride, env, config } = options;
-    this.exec = new CodexExec(codexPathOverride, env, config);
-    this.options = options;
-  }
-  /**
-   * Starts a new conversation with an agent.
-   * @returns A new thread instance.
-   */
-  startThread(options = {}) {
-    return new Thread(this.exec, this.options, options);
-  }
-  /**
-   * Resumes a conversation with an agent based on the thread id.
-   * Threads are persisted in ~/.codex/sessions.
-   *
-   * @param id The id of the thread to resume.
-   * @returns A new thread instance.
-   */
-  resumeThread(id, options = {}) {
-    return new Thread(this.exec, this.options, options, id);
-  }
-};
-
 // packages/agent-runtime/src/codex/transport.ts
+import {
+  Codex
+} from "@openai/codex-sdk";
 function buildSdkThreadOptions(spec) {
   return {
     ...spec.model ? { model: spec.model } : {},
@@ -6393,7 +5947,7 @@ var ConnectorHealthStore = class {
 
 // src/dispatcher.ts
 import { randomUUID } from "crypto";
-import { appendFileSync as appendFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync10, statSync as statSync2 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync10, statSync } from "fs";
 import { join as join13 } from "path";
 
 // src/summon.ts
@@ -6731,10 +6285,10 @@ import { join as join9 } from "path";
 var PREFIX = "cabane-codex-instructions-";
 async function writeCodexInstructionsFile(contents) {
   const dir2 = await mkdtemp(join9(tmpdir(), PREFIX));
-  const path3 = join9(dir2, "instructions.md");
-  await writeFile(path3, contents, { encoding: "utf8", mode: 384 });
+  const path = join9(dir2, "instructions.md");
+  await writeFile(path, contents, { encoding: "utf8", mode: 384 });
   return {
-    path: path3,
+    path,
     cleanup: async () => {
       await rm(dir2, { recursive: true, force: true });
     }
@@ -6754,10 +6308,10 @@ function pathFor3(workspaceId, conversationId, agentId) {
   return join10(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
 }
 function readPrepared(workspaceId, conversationId, agentId) {
-  const path3 = pathFor3(workspaceId, conversationId, agentId);
-  if (!existsSync7(path3)) return null;
+  const path = pathFor3(workspaceId, conversationId, agentId);
+  if (!existsSync7(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync6(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
     if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
       return {
         cwd: parsed.cwd,
@@ -6791,14 +6345,14 @@ function secretsPath() {
 }
 var secretStoreSchema = z13.record(z13.string(), z13.string());
 function loadSecretStore() {
-  const path3 = secretsPath();
-  if (!existsSync8(path3)) return makeStore({});
+  const path = secretsPath();
+  if (!existsSync8(path)) return makeStore({});
   let raw;
   try {
-    raw = readFileSync7(path3, "utf8");
+    raw = readFileSync7(path, "utf8");
   } catch (err) {
     throw new ConfigError(
-      `couldn't read ${path3}: ${err instanceof Error ? err.message : String(err)}`
+      `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
     );
   }
   if (raw.trim().length === 0) return makeStore({});
@@ -6807,13 +6361,13 @@ function loadSecretStore() {
     parsed = JSON.parse(raw);
   } catch (err) {
     throw new ConfigError(
-      `${path3} is not valid JSON: ${err instanceof Error ? err.message : String(err)}. It must be a flat object of "NAME": "value" secret pairs.`
+      `${path} is not valid JSON: ${err instanceof Error ? err.message : String(err)}. It must be a flat object of "NAME": "value" secret pairs.`
     );
   }
   const result = secretStoreSchema.safeParse(parsed);
   if (!result.success) {
     throw new ConfigError(
-      `${path3} must be a flat object mapping secret names to string values (e.g. { "GITHUB_TOKEN": "ghp_\u2026" }).`
+      `${path} must be a flat object mapping secret names to string values (e.g. { "GITHUB_TOKEN": "ghp_\u2026" }).`
     );
   }
   return makeStore(result.data);
@@ -7249,7 +6803,7 @@ function checkoutState(cwd) {
   if (!existsSync9(gitPath)) return { ok: false, reason: `${cwd} holds no git metadata` };
   let stat;
   try {
-    stat = statSync2(gitPath);
+    stat = statSync(gitPath);
   } catch (error) {
     return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
   }
@@ -8197,7 +7751,9 @@ var LABELS = {
 function deriveHarnessSnapshot(signals) {
   const advertised = new Set(
     buildCompanionManifest({
-      claudeCode: signals.claudeOnPath,
+      // CT1082: connected AND installed — the manifest's own rule, restated here
+      // through the same function rather than re-decided.
+      claudeCode: signals.claudeCodeConnected && signals.claudeOnPath,
       opencode: signals.opencodeConfigured,
       codex: signals.codexEnabled
     }).runtimes.map((r) => r.name)
@@ -8210,20 +7766,40 @@ function deriveHarnessSnapshot(signals) {
   return { harnesses, anyExposed: harnesses.some((h) => h.state === "exposed") };
 }
 function deriveClaudeCode(signals, manifestHas) {
-  const base = { runtime: "claude-code", label: LABELS["claude-code"], enable: null };
+  const base = { runtime: "claude-code", label: LABELS["claude-code"] };
   if (manifestHas) {
     return {
       ...base,
       state: "exposed",
       version: signals.claudeVersion,
-      detail: "Claude Code is installed and exposed to Cabane."
+      detail: "Claude Code is connected and exposed to Cabane.",
+      enable: null
+    };
+  }
+  if (signals.claudeCodeConnected) {
+    return {
+      ...base,
+      state: "needs_attention",
+      version: null,
+      detail: "Connected, but the `claude` CLI isn\u2019t on your PATH. Install it (`npm i -g @anthropic-ai/claude-code`) and sign in, or disconnect it.",
+      enable: null
+    };
+  }
+  if (signals.claudeOnPath) {
+    return {
+      ...base,
+      state: "detected_not_exposed",
+      version: signals.claudeVersion,
+      detail: "Claude Code is installed here but not connected yet. Connect it to let Cabane run Claude Code on this device.",
+      enable: "claude-code"
     };
   }
   return {
     ...base,
     state: "not_detected",
     version: null,
-    detail: "Not detected. Install Claude Code (`npm i -g @anthropic-ai/claude-code`) and sign in with `claude`, then it appears here."
+    detail: "Not detected. Install Claude Code (`npm i -g @anthropic-ai/claude-code`) and sign in with `claude`, then connect it here.",
+    enable: null
   };
 }
 function deriveCodex(signals, manifestHas) {
@@ -8291,6 +7867,9 @@ function deriveOpencode(signals, manifestHas) {
     enable: "opencode"
   };
 }
+function detectedRuntimesFor(snapshot) {
+  return snapshot.harnesses.filter((h) => h.state === "detected_not_exposed").map((h) => ({ runtime: h.runtime, version: h.version }));
+}
 var PROBE_TIMEOUT_MS2 = 4e3;
 async function probeHarnessSignals(cfg, deps = {}) {
   const probeClaudePresence = deps.probeClaudePresence ?? claudeOnPath;
@@ -8307,6 +7886,9 @@ async function probeHarnessSignals(cfg, deps = {}) {
   return {
     claudeOnPath: claudeOnPathResult,
     claudeVersion,
+    // CT1082: the user's opt-in. Presence alone exposes nothing now, so this is
+    // the manifest gate and the probe above is only a suggestion.
+    claudeCodeConnected: isClaudeCodeConnected(cfg),
     // A parseable `codex --version` is our presence signal (presence alone never
     // exposes codex; its config flag is the manifest gate either way).
     codexOnPath: codexVersion !== null,
@@ -8680,8 +8262,8 @@ function sleep3(ms) {
 }
 
 // src/version.ts
-import { createRequire as createRequire2 } from "module";
-var pkg = createRequire2(import.meta.url)("../package.json");
+import { createRequire } from "module";
+var pkg = createRequire(import.meta.url)("../package.json");
 var COMPANION_VERSION = pkg.version;
 
 // src/supervisor.ts
@@ -8715,6 +8297,10 @@ var CompanionSupervisor = class {
   // can never disagree with what the manifest advertises. Null until the first
   // probe (the heartbeat then falls back to the boot `claudeCode`).
   harnessSignals = null;
+  // CT1082: the fresh PATH probe the claude-code connect vets with. Deliberately
+  // NOT the cached beat signal — someone connecting right after installing Claude
+  // Code shouldn't be refused by a snapshot up to a heartbeat old.
+  probeClaudePresence;
   exitFn;
   reexecFn;
   dispatcherFactory;
@@ -8745,6 +8331,7 @@ var CompanionSupervisor = class {
     this.log = opts.log;
     this.hub = opts.hub;
     this.claudeCode = opts.claudeCode ?? true;
+    this.probeClaudePresence = opts.probeClaudePresence ?? claudeOnPath;
     this.harnessVersions = opts.harnessVersions ?? emptyHarnessVersions();
     this.exitFn = opts.exit ?? ((code) => process.exit(code));
     this.reexecFn = opts.reexec ?? defaultReexec;
@@ -8807,11 +8394,10 @@ var CompanionSupervisor = class {
         // claude-code when `claude` is on PATH, CT270 opencode when the operator
         // configured an `opencode serve`.
         manifest: buildCompanionManifest({
-          // CT586: prefer the live re-probe's presence; fall back to the boot probe
-          // until the first re-probe lands. Same exit-0 `claude --version` signal
-          // either way, so the manifest's claude-code advertising is unchanged in
-          // meaning — just refreshed on the beat instead of frozen at boot.
-          claudeCode: this.claudeCodePresent(),
+          // CT1082: connected AND installed. Presence is the live re-probe (CT586),
+          // falling back to the boot probe until the first one lands; consent is the
+          // user's `claudeCode.enabled`. Claude Code no longer rides presence alone.
+          claudeCode: this.claudeCodeOffered(),
           opencode: !!this.config.opencode?.serverUrl,
           // CT481: advertise codex when the operator enabled it (config-gated,
           // like opencode — the CLI's presence is the operator's responsibility;
@@ -8829,7 +8415,13 @@ var CompanionSupervisor = class {
         // CT584: include enumerated models only when the probe SUCCEEDED (non-null).
         // A null (probe failed / no opencode) omits the field, and the server then
         // leaves this device's stored availability untouched.
-        ...opencodeModels !== null ? { models: opencodeModels } : {}
+        ...opencodeModels !== null ? { models: opencodeModels } : {},
+        // CT1082: what this machine has that the user hasn't connected, so the web
+        // UI can offer it without a companion round-trip. Sent only once a probe has
+        // actually landed (`harnessSignals` non-null) — an absent field means "we
+        // didn't look this beat" and leaves the server's stored suggestion alone,
+        // the same fail-soft contract `models` keeps.
+        ...this.harnessSignals ? { detectedRuntimes: detectedRuntimesFor(deriveHarnessSnapshot(this.harnessSignals)) } : {}
       });
       this.hub.setDevice({ deviceId: res.deviceId });
       this.deviceId = res.deviceId;
@@ -9034,13 +8626,19 @@ var CompanionSupervisor = class {
       "companion: stopped agent (unassigned)"
     );
   }
-  // CT833: is Claude Code on this machine right now? The ONE signal both the
-  // heartbeat manifest and the dispatcher's adapter registry read, so what the
-  // device advertises and what it can actually select can't disagree. Live (the
-  // per-beat re-probe), falling back to the boot probe until the first one lands.
+  // CT833: is Claude Code on this machine right now? Live (the per-beat re-probe),
+  // falling back to the boot probe until the first one lands. Presence ONLY —
+  // CT1082 split presence from exposure, so nothing routes on this directly.
   claudeCodePresent() {
     return this.harnessSignals?.claudeOnPath ?? this.claudeCode;
   }
+  // CT1082: does this device OFFER claude-code — connected by its user and actually
+  // installed? The ONE signal both the heartbeat manifest and the dispatcher's
+  // adapter registry read, so what the device advertises and what it can select
+  // can't disagree (the CT833 invariant, now with consent in front of it).
+  claudeCodeOffered() {
+    return isClaudeCodeConnected(this.config) && this.claudeCodePresent();
+  }
   buildDispatcher(ctx) {
     if (this.dispatcherFactory) return this.dispatcherFactory(ctx);
     return new Dispatcher({
@@ -9058,10 +8656,12 @@ var CompanionSupervisor = class {
       }),
       runConfig: ctx.runConfig,
       log: this.log,
-      // CT833: register the claude-code adapter only when `claude` is actually on
-      // this machine — read per turn (not captured here), so a harness installed
-      // after boot works on the next turn exactly as it appears on the next beat.
-      claudeCodeAvailable: () => this.claudeCodePresent(),
+      // CT833: register the claude-code adapter only when this device actually
+      // offers claude-code — read per turn (not captured here), so a harness
+      // installed or connected after boot works on the next turn exactly as it
+      // appears on the next beat. CT1082: "offers" now means connected as well as
+      // installed, so a disconnected harness can't be selected either.
+      claudeCodeAvailable: () => this.claudeCodeOffered(),
       // CT270: the opencode server URL (operator-configured), when this device
       // offers the opencode runtime. Threaded so an opencode turn selects the
       // opencode adapter; unset leaves the device claude-code-only.
@@ -9367,9 +8967,12 @@ var CompanionSupervisor = class {
   async recheckHarnesses() {
     await this.refreshHarnessStatuses();
   }
-  // Friendly enable for the two config-driven harnesses — flip the flag the app
-  // owns in `~/.cabane/config.json`, no hand-edited JSON. This is enable/expose
-  // ONLY: it never installs a binary and never drives a login (BYO — Decided).
+  // Friendly enable for the config-driven harnesses — flip the flag the app owns in
+  // `~/.cabane/config.json`, no hand-edited JSON. This is enable/expose ONLY: it
+  // never installs a binary and never drives a login (BYO — Decided).
+  //   - claude-code (CT1082): set `claudeCode.enabled`, after checking `claude` is
+  //     on PATH. This is the callable the terminal offer ("We found Claude Code.
+  //     Connect it? [Y/n]") and the web pairing flow both wire to.
   //   - codex: set `codex.enabled` (the CLI + `codex login` remain the user's).
   //   - opencode: set `opencode.serverUrl` — but ONLY after health-probing the URL,
   //     so we never advertise a serve that isn't there. An unreachable URL is a
@@ -9379,7 +8982,15 @@ var CompanionSupervisor = class {
   // reachable/valid input).
   async enableHarness(input) {
     let next;
-    if (input.runtime === "codex") {
+    if (input.runtime === "claude-code") {
+      if (!await this.probeClaudePresence()) {
+        return {
+          ok: false,
+          error: "Couldn\u2019t find `claude` on this machine\u2019s PATH. Install Claude Code (`npm i -g @anthropic-ai/claude-code`) and sign in, then connect it."
+        };
+      }
+      next = { ...this.config, claudeCode: { enabled: true } };
+    } else if (input.runtime === "codex") {
       next = { ...this.config, codex: { enabled: true } };
     } else {
       const serverUrl = input.serverUrl.trim();
@@ -9485,9 +9096,9 @@ var CompanionSupervisor = class {
 };
 function defaultReexec() {
   clearRuntimeState();
-  void import("child_process").then(({ spawn: spawn7 }) => {
+  void import("child_process").then(({ spawn: spawn6 }) => {
     try {
-      const child = spawn7(process.execPath, process.argv.slice(1), {
+      const child = spawn6(process.execPath, process.argv.slice(1), {
         stdio: "inherit",
         detached: false
       });
@@ -9571,8 +9182,8 @@ function recordCrash(rec2) {
 }
 function clearCrash() {
   try {
-    const path3 = crashMarkerPath();
-    if (existsSync11(path3)) rmSync7(path3, { force: true });
+    const path = crashMarkerPath();
+    if (existsSync11(path)) rmSync7(path, { force: true });
   } catch {
   }
 }
@@ -9581,13 +9192,17 @@ function clearCrash() {
 async function createCompanionRuntime(opts = {}) {
   const log = getLogger();
   installProcessSafetyNet(log);
-  const probeClaude = opts.probeClaude ?? claudeOnPath;
   let cfg;
   let claudeCode;
   try {
-    cfg = requireConfig();
-    claudeCode = await probeClaude();
-    await ensureRuntimeAvailable(cfg, { probeClaude: async () => claudeCode });
+    ({ cfg, claudeOnPath: claudeCode } = await requireStartConfig({
+      ...opts.probeClaude ? { probeClaude: opts.probeClaude } : {},
+      onMigrated: (migrated, onPath) => log.info(
+        { claudeCode: isClaudeCodeConnected(migrated) },
+        onPath ? "companion: carried Claude Code over as a connected harness on this device (connectors are now chosen, not detected)" : "companion: no Claude Code on PATH, so this device starts with it disconnected (connectors are now chosen, not detected)"
+      )
+    }));
+    await warnAboutHarnessReadiness(cfg, { probeClaude: async () => claudeCode });
   } catch (err) {
     recordCrash({
       reason: err instanceof Error ? err.message : String(err),
@@ -9599,7 +9214,9 @@ async function createCompanionRuntime(opts = {}) {
   }
   if (cfg.logLevel) log.level = cfg.logLevel;
   const harnessVersions = await probeHarnessVersions({
-    claudeCode,
+    // CT1082: versions are probed for the runtimes this device OFFERS, and
+    // claude-code is offered only when connected as well as installed.
+    claudeCode: claudeCode && isClaudeCodeConnected(cfg),
     opencodeServerUrl: cfg.opencode?.serverUrl,
     codex: isCodexEnabled(cfg)
   });
@@ -10071,11 +9688,11 @@ function printList(dir2) {
     "render one:  cabane-companion transcript <file>   (or `--last` for the newest)\n"
   );
 }
-function peek(path3) {
+function peek(path) {
   let meta;
   let outcome;
   try {
-    for (const line of readFileSync10(path3, "utf8").split("\n")) {
+    for (const line of readFileSync10(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       const o = safeParse(line);
       const t = str2(rec(o)?.type);
@@ -10105,13 +9722,13 @@ function resolveTarget(dir2, target) {
 ` + matches.slice(0, 10).map((m) => `  ${m}`).join("\n")
   );
 }
-function renderFile(path3) {
+function renderFile(path) {
   let content;
   try {
-    content = readFileSync10(path3, "utf8");
+    content = readFileSync10(path, "utf8");
   } catch (err) {
     throw new CompanionError(
-      `couldn't read ${path3}: ${err instanceof Error ? err.message : String(err)}`
+      `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
     );
   }
   return renderTranscript(content.split("\n"));