@cabane/companion 0.6.187 → 0.6.189

package/dist/cli.js

@@ -788,7 +788,15 @@ var init_config = __esm({
       // and an agent with no folder of its own and no prepare hook works there
       // (`turn-execution.ts`, `prepareEnvironment`). Default `~/.cabane/work`: hidden, so pairing a
       // laptop creates no new visible folder; set it to make the work visible.
-      root: z2.string().min(1).refine(isRootPath, { message: "must be an absolute path, or start with ~/" }).optional()
+      root: z2.string().min(1).refine(isRootPath, { message: "must be an absolute path, or start with ~/" }).optional(),
+      // An argv prefix the operator puts in front of every turn's runner: the companion starts
+      // `<prefix…> <its own run-turn command…>` instead of the runner bare. What the prefix does
+      // is the operator's (a box of their own making, ENG225); the companion knows nothing of it
+      // beyond handing the runner over, with the turn's inputs in its environment and the
+      // credential and secrets on its stdin (`runner/launch.ts`, `boxed`).
+      runner: z2.object({
+        command: z2.array(z2.string().min(1)).min(1)
+      }).strict().optional()
     });
     legacyOfferSchema = z2.object({
       claudeCode: z2.object({ enabled: z2.boolean().optional() }).passthrough().optional(),
@@ -1014,6 +1022,142 @@ var init_bundled_binaries = __esm({
   }
 });
 
+// src/harness-versions.ts
+function parseVersionToken(raw) {
+  if (!raw) return null;
+  const m = raw.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/);
+  return m ? m[0] : null;
+}
+async function probeOpencodeVersion(serverUrl, fetchImpl = fetch) {
+  try {
+    const base = serverUrl.endsWith("/") ? serverUrl.slice(0, -1) : serverUrl;
+    const res = await fetchImpl(`${base}/global/health`, {
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) return null;
+    return extractOpencodeVersion(await res.json());
+  } catch {
+    return null;
+  }
+}
+function extractOpencodeVersion(json) {
+  if (!json || typeof json !== "object") return null;
+  const obj = json;
+  const candidates = [obj.version];
+  for (const v of Object.values(obj)) {
+    if (v && typeof v === "object") candidates.push(v.version);
+  }
+  for (const c of candidates) {
+    if (typeof c === "string") {
+      const parsed = parseVersionToken(c);
+      if (parsed) return parsed;
+    }
+  }
+  return null;
+}
+function emptyHarnessVersions() {
+  return { ...EMPTY };
+}
+var EMPTY;
+var init_harness_versions = __esm({
+  "src/harness-versions.ts"() {
+    "use strict";
+    EMPTY = { claudeCode: null, opencode: null, codex: null };
+  }
+});
+
+// src/harness-usable.ts
+import { spawn as spawn2 } from "child_process";
+function apiKeyVariable(runtime, env = process.env) {
+  return API_KEY_VARIABLES[runtime].find((name) => !!env[name]?.trim()) ?? null;
+}
+async function checkHarnessUsable(runtime, deps = {}) {
+  const env = deps.env ?? process.env;
+  const resolveBundled = deps.resolveBundled ?? ((r) => resolveBundledBinary(r));
+  const run = deps.run ?? runBounded;
+  const resolution = resolveBundled(runtime);
+  if (resolution.status !== "present" || !resolution.path) {
+    return {
+      status: "bundle_missing",
+      bundled: resolution.status === "present" ? "executable_missing" : resolution.status
+    };
+  }
+  const path = resolution.path;
+  const version = run(path, ["--version"], env).then(
+    (r) => r.code === 0 ? parseVersionToken(r.output) : null
+  );
+  const variable = apiKeyVariable(runtime, env);
+  if (variable) return { status: "api_key", variable, version: await version };
+  const statusArgs = runtime === "codex" ? ["login", "status"] : ["auth", "status", "--json"];
+  const [answer, v] = await Promise.all([run(path, statusArgs, env), version]);
+  if (answer.error) return { status: "check_failed", reason: answer.error };
+  const signedIn = runtime === "codex" ? readCodexStatus(answer) : readClaudeStatus(answer);
+  if (typeof signedIn === "string") return { status: "check_failed", reason: signedIn };
+  return signedIn ? { status: "signed_in", version: v } : { status: "signed_out", version: v };
+}
+function readClaudeStatus(answer) {
+  const start2 = answer.output.indexOf("{");
+  const end = answer.output.lastIndexOf("}");
+  if (start2 < 0 || end < start2) return "unreadable";
+  try {
+    const parsed = JSON.parse(answer.output.slice(start2, end + 1));
+    const loggedIn = parsed?.loggedIn;
+    return typeof loggedIn === "boolean" ? loggedIn : "unreadable";
+  } catch {
+    return "unreadable";
+  }
+}
+function readCodexStatus(answer) {
+  if (answer.code === 0) return true;
+  if (/not logged in/i.test(answer.output)) return false;
+  if (/config/i.test(answer.output)) return "config";
+  return "unreadable";
+}
+function runBounded(path, args, env) {
+  return new Promise((resolve2) => {
+    let settled = false;
+    let out = "";
+    const done = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2(result);
+    };
+    let child;
+    try {
+      child = spawn2(path, args, { stdio: ["ignore", "pipe", "pipe"], env });
+    } catch {
+      resolve2({ code: null, output: "", error: "spawn" });
+      return;
+    }
+    const capture = (chunk) => {
+      if (out.length < 8192) out += chunk.toString();
+    };
+    child.stdout?.on("data", capture);
+    child.stderr?.on("data", capture);
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      done({ code: null, output: out, error: "timeout" });
+    }, CHECK_TIMEOUT_MS);
+    timer.unref?.();
+    child.once("error", () => done({ code: null, output: out, error: "spawn" }));
+    child.once("close", (code) => done({ code, output: out }));
+  });
+}
+var API_KEY_VARIABLES, CHECK_TIMEOUT_MS;
+var init_harness_usable = __esm({
+  "src/harness-usable.ts"() {
+    "use strict";
+    init_bundled_binaries();
+    init_harness_versions();
+    API_KEY_VARIABLES = {
+      "claude-code": ["ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN"],
+      codex: ["CODEX_API_KEY"]
+    };
+    CHECK_TIMEOUT_MS = 5e3;
+  }
+});
+
 // packages/agent-runtime/src/failure.ts
 import { z as z4 } from "zod";
 function encodeFailureReason(failure) {
@@ -7365,6 +7509,14 @@ function required(env, name) {
   if (!value) throw new Error(`runner: ${name} is not set`);
   return value;
 }
+function runnerPlace(env) {
+  const workRoot2 = env[PLACE_ENV.workRoot];
+  const transcriptDir = env[PLACE_ENV.transcriptDir];
+  return {
+    ...workRoot2 ? { workRoot: workRoot2 } : {},
+    ...transcriptDir ? { transcriptDir } : {}
+  };
+}
 function parseRunnerInput(env, stdin) {
   const dispatch = dispatchSchema.parse(JSON.parse(required(env, RUNNER_ENV.dispatch)));
   const spec = runnerSpecSchema.parse(JSON.parse(required(env, RUNNER_ENV.spec)));
@@ -7372,10 +7524,12 @@ function parseRunnerInput(env, stdin) {
   return {
     baseUrl: required(env, RUNNER_ENV.url),
     credential: credentials.credential,
+    ...credentials.secrets ? { secrets: credentials.secrets } : {},
     dispatch,
     turnId: required(env, RUNNER_ENV.turnId),
     resumed: env[RUNNER_ENV.resumed] === "1",
-    spec
+    spec,
+    place: runnerPlace(env)
   };
 }
 function runnerEnv(input) {
@@ -7388,7 +7542,10 @@ function runnerEnv(input) {
   };
 }
 function runnerStdin(input) {
-  return `${JSON.stringify({ credential: input.credential })}
+  return `${JSON.stringify({
+    credential: input.credential,
+    ...input.secrets ? { secrets: input.secrets } : {}
+  })}
 `;
 }
 function encodeLauncherMessage(message2) {
@@ -7418,7 +7575,7 @@ function decodeRunnerEvent(line) {
   if (!value || typeof value !== "object" || !("cabaneRunner" in value)) return null;
   return value;
 }
-var RUNNER_ENV, runtimeHealthSchema, runnerSpecSchema, dispatchSchema, credentialsSchema;
+var RUNNER_ENV, PLACE_ENV, runtimeHealthSchema, runnerSpecSchema, dispatchSchema, credentialsSchema;
 var init_protocol = __esm({
   "src/runner/protocol.ts"() {
     "use strict";
@@ -7437,6 +7594,10 @@ var init_protocol = __esm({
       // Everything else the turn is constructed from, as JSON: see `RunnerSpec`.
       spec: "CABANE_RUNNER_SPEC"
     };
+    PLACE_ENV = {
+      workRoot: "CABANE_WORK_ROOT",
+      transcriptDir: "CABANE_TRANSCRIPT_DIR"
+    };
     runtimeHealthSchema = z14.object({
       quotaState: z14.enum(["ok", "limited", "auth_expired", "unknown"]),
       limitedUntil: z14.string().nullable(),
@@ -7486,7 +7647,8 @@ var init_protocol = __esm({
       episode: z14.number().int().optional()
     });
     credentialsSchema = z14.object({
-      credential: z14.string().startsWith("cabrn_")
+      credential: z14.string().startsWith("cabrn_"),
+      secrets: z14.record(z14.string(), z14.string()).optional()
     });
   }
 });
@@ -7498,6 +7660,19 @@ function selfRunnerCommand() {
   if (!script) throw new Error("runner: cannot tell which script started this companion");
   return [process.execPath, ...process.execArgv, script, "run-turn"];
 }
+function wrappedRunnerCommand(prefix, own) {
+  return [...prefix ?? [], ...own];
+}
+function runnerExecEnv(base, boxed) {
+  const env = {};
+  for (const [k, v] of Object.entries(base)) {
+    if (v === void 0) continue;
+    if (boxed && (BOXED_ENV_DROPPED.includes(k) || k.startsWith(BOXED_ENV_DROPPED_PREFIX)))
+      continue;
+    env[k] = v;
+  }
+  return env;
+}
 function healthSnapshot(store) {
   const out = {};
   for (const r of store?.reports() ?? []) {
@@ -7694,13 +7869,12 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
     return { ok: false, durationMs: durationMs2, reason: reason2 };
   }
   try {
-    const env = {};
-    for (const [k, v] of Object.entries(launch.env ?? process.env)) {
-      if (v !== void 0) env[k] = v;
-    }
+    const boxed = launch.boxed === true;
+    const env = runnerExecEnv(launch.env ?? process.env, boxed);
     const input = {
       baseUrl: opts.baseUrl,
       credential: minted.credential,
+      ...boxed ? { secrets: launch.secrets?.() ?? {} } : {},
       dispatch: payload,
       turnId,
       resumed: handleOpts.resumed,
@@ -7772,7 +7946,7 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
           locks?.release(lockOwner(event.id));
           return;
         case "process_group":
-          groups.push(event.pgid);
+          if (!boxed) groups.push(event.pgid);
           return;
         case "remote_session":
           remote.push({ serverUrl: event.serverUrl, sessionId: event.sessionId });
@@ -7793,7 +7967,8 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   }
   if (result) return result;
   const durationMs = Date.now() - startedAt;
-  const reason = thrown !== void 0 ? `runner_failed: ${thrown}` : `runner_exited: ${code}`;
+  const stopped = controller.signal.aborted && thrown === void 0;
+  const reason = stopped ? "cancelled" : thrown !== void 0 ? `runner_failed: ${thrown}` : `runner_exited: ${code}`;
   await child?.reap(groups);
   const reaped = await (launch.reapTurn ?? reapTurnScopes)(turnId).catch((err) => ({
     failures: [err instanceof Error ? err.message : String(err)]
@@ -7808,8 +7983,7 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
     await opts.api.setActiveRun(opts.workspaceId, payload.conversationId, payload.agentId, {
       activeRunStartedAt: null,
       turnId,
-      outcome: "failed",
-      errorReason: reason.slice(0, ERROR_REASON_MAX),
+      ...stopped ? { outcome: "interrupted" } : { outcome: "failed", errorReason: reason.slice(0, ERROR_REASON_MAX) },
       readThrough: payload.messageId
     });
   } catch (err) {
@@ -7827,11 +8001,12 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
     reason: "exited"
   });
   if (thrown !== void 0) throw new Error(thrown);
-  log2.warn({ turnId, code }, "runner: exited without reporting a result");
+  if (stopped) log2.info({ turnId, code }, "runner: stopped before it could report");
+  else log2.warn({ turnId, code }, "runner: exited without reporting a result");
   duties.notifyEnd({ id: payload.messageId, ok: false, durationMs, reason });
   return { ok: false, durationMs, reason };
 }
-var PINO_LEVELS;
+var BOXED_ENV_DROPPED, BOXED_ENV_DROPPED_PREFIX, PINO_LEVELS;
 var init_launch = __esm({
   "src/runner/launch.ts"() {
     "use strict";
@@ -7842,6 +8017,16 @@ var init_launch = __esm({
     init_boot_id();
     init_turn_containment();
     init_protocol();
+    BOXED_ENV_DROPPED = [
+      "ANTHROPIC_API_KEY",
+      "CLAUDE_CODE_OAUTH_TOKEN",
+      "CODEX_API_KEY",
+      "GH_TOKEN",
+      "GITHUB_TOKEN",
+      "DBUS_SESSION_BUS_ADDRESS",
+      "XDG_RUNTIME_DIR"
+    ];
+    BOXED_ENV_DROPPED_PREFIX = "CABANE_GATE_";
     PINO_LEVELS = {
       10: "trace",
       20: "debug",
@@ -8456,9 +8641,9 @@ import { z as z16 } from "zod";
 function secretsPath() {
   return join19(cabaneDir(), "secrets.json");
 }
-function loadSecretStore() {
+function loadSecretValues() {
   const path = secretsPath();
-  if (!existsSync10(path)) return makeStore({});
+  if (!existsSync10(path)) return {};
   let raw;
   try {
     raw = readFileSync8(path, "utf8");
@@ -8467,7 +8652,7 @@ function loadSecretStore() {
       `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  if (raw.trim().length === 0) return makeStore({});
+  if (raw.trim().length === 0) return {};
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -8482,14 +8667,17 @@ function loadSecretStore() {
       `${path} must be a flat object mapping secret names to string values (e.g. { "GITHUB_TOKEN": "ghp_\u2026" }).`
     );
   }
-  return makeStore(result.data);
+  return result.data;
 }
 function loadSecretStoreTolerant(onWarn) {
+  return makeStore(loadSecretValuesTolerant(onWarn));
+}
+function loadSecretValuesTolerant(onWarn) {
   try {
-    return loadSecretStore();
+    return loadSecretValues();
   } catch (err) {
     onWarn?.(err instanceof Error ? err.message : String(err));
-    return makeStore({});
+    return {};
   }
 }
 function makeStore(map) {
@@ -8581,6 +8769,31 @@ var init_secrets = __esm({
   }
 });
 
+// src/turn-env.ts
+function harnessLoginEnv(store, runtime) {
+  const names = [
+    ...runtime in API_KEY_VARIABLES ? API_KEY_VARIABLES[runtime] : [],
+    GITHUB_TOKEN_NAME
+  ];
+  const env = {};
+  for (const name of names) {
+    const value = store.get(name);
+    if (value) env[name] = value;
+  }
+  return env;
+}
+function turnIdentityEnv(ids) {
+  return { CABANE_CONVERSATION_ID: ids.conversationId, CABANE_AGENT_ID: ids.agentId };
+}
+var GITHUB_TOKEN_NAME;
+var init_turn_env = __esm({
+  "src/turn-env.ts"() {
+    "use strict";
+    init_harness_usable();
+    GITHUB_TOKEN_NAME = "GH_TOKEN";
+  }
+});
+
 // src/transcript-writer.ts
 import { appendFileSync, chmodSync as chmodSync4, copyFileSync, mkdirSync as mkdirSync8, readdirSync, rmSync as rmSync6 } from "fs";
 import { basename as basename3, dirname as dirname7, join as join20 } from "path";
@@ -8971,6 +9184,7 @@ var init_turn_execution = __esm({
     init_prepare_failure();
     init_prepared();
     init_secrets();
+    init_turn_env();
     init_turn_control_tools();
     init_transcript_writer();
     init_turn_containment();
@@ -9038,6 +9252,7 @@ var init_turn_execution = __esm({
       // The harness's secret environment for this turn. Only ever handed to the
       // adapter; never logged, never merged into `process.env`.
       secretEnv = {};
+      secretStore;
       effectiveCwd;
       hookEnv;
       turnEnv;
@@ -9326,7 +9541,8 @@ var init_turn_execution = __esm({
           throw this.concluded(reason, reason);
         }
         this.resolvedMcpServers = resolvedMcpServers;
-        this.secretEnv = secretEnv;
+        this.secretEnv = { ...secretEnv, ...harnessLoginEnv(secretStore, this.turnContext.runtime) };
+        this.secretStore = secretStore;
       }
       async prepareEnvironment() {
         const { payload, workspaceId, turnId, turnLog } = this;
@@ -9477,6 +9693,10 @@ var init_turn_execution = __esm({
         }
         const turnEnv = {
           ...hookEnv,
+          ...turnIdentityEnv({
+            conversationId: this.payload.conversationId,
+            agentId: this.payload.agentId
+          }),
           CABANE_COMPANION_HOME: agentCompanionHome()
         };
         this.codexLocal = this.turnContext.runtime === "codex" ? { configSetsSandboxMode: await readCodexConfigSetsSandboxMode() } : void 0;
@@ -10551,8 +10771,14 @@ function runnerTurnOptions(input, log2, emit, extras = {}) {
     agentUsername: spec.agentUsername,
     credential: input.credential,
     local: spec.local,
-    workRoot: spec.workRoot,
+    // The place the runner stands in names its own root and transcript
+    // directory when it has them (`PLACE_ENV`); the launcher's host-computed
+    // values are what a runner on the person's own machine gets.
+    workRoot: input.place?.workRoot ?? spec.workRoot,
     runConfig: spec.runConfig,
+    // The launcher's copy of the device's secrets, when it sent one: a runner
+    // in a box has no `secrets.json` to read.
+    ...input.secrets ? { secretStore: makeStore(input.secrets) } : {},
     log: log2,
     ...queryFn ? { queryFn } : {},
     ...spec.opencodeServerUrl ? { opencodeServerUrl: spec.opencodeServerUrl } : {},
@@ -10562,7 +10788,7 @@ function runnerTurnOptions(input, log2, emit, extras = {}) {
     ...spec.totalTimeoutMs !== void 0 ? { totalTimeoutMs: spec.totalTimeoutMs } : {},
     ...spec.leaseRenewalMs !== void 0 ? { leaseRenewalMs: spec.leaseRenewalMs } : {},
     ...spec.preparingRowDelayMs !== void 0 ? { preparingRowDelayMs: spec.preparingRowDelayMs } : {},
-    ...spec.transcripts ? { transcriptDir: transcriptsDir() } : {},
+    ...spec.transcripts ? { transcriptDir: input.place?.transcriptDir ?? transcriptsDir() } : {},
     connectorHealth,
     inRunner: {
       bootId: spec.bootId,
@@ -10697,6 +10923,7 @@ var init_run_turn = __esm({
     init_exec_shim();
     init_launcher_channel();
     init_opencode_lock();
+    init_secrets();
     init_transcript_writer();
     init_turn_execution();
     init_protocol();
@@ -11134,133 +11361,8 @@ function spaced(sentence) {
 
 // src/harness-detect.ts
 init_config();
-
-// src/harness-usable.ts
-init_bundled_binaries();
-import { spawn as spawn2 } from "child_process";
-
-// src/harness-versions.ts
-var EMPTY = { claudeCode: null, opencode: null, codex: null };
-function parseVersionToken(raw) {
-  if (!raw) return null;
-  const m = raw.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/);
-  return m ? m[0] : null;
-}
-async function probeOpencodeVersion(serverUrl, fetchImpl = fetch) {
-  try {
-    const base = serverUrl.endsWith("/") ? serverUrl.slice(0, -1) : serverUrl;
-    const res = await fetchImpl(`${base}/global/health`, {
-      headers: { accept: "application/json" }
-    });
-    if (!res.ok) return null;
-    return extractOpencodeVersion(await res.json());
-  } catch {
-    return null;
-  }
-}
-function extractOpencodeVersion(json) {
-  if (!json || typeof json !== "object") return null;
-  const obj = json;
-  const candidates = [obj.version];
-  for (const v of Object.values(obj)) {
-    if (v && typeof v === "object") candidates.push(v.version);
-  }
-  for (const c of candidates) {
-    if (typeof c === "string") {
-      const parsed = parseVersionToken(c);
-      if (parsed) return parsed;
-    }
-  }
-  return null;
-}
-function emptyHarnessVersions() {
-  return { ...EMPTY };
-}
-
-// src/harness-usable.ts
-var API_KEY_VARIABLES = {
-  "claude-code": ["ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN"],
-  codex: ["CODEX_API_KEY"]
-};
-function apiKeyVariable(runtime, env = process.env) {
-  return API_KEY_VARIABLES[runtime].find((name) => !!env[name]?.trim()) ?? null;
-}
-var CHECK_TIMEOUT_MS = 5e3;
-async function checkHarnessUsable(runtime, deps = {}) {
-  const env = deps.env ?? process.env;
-  const resolveBundled = deps.resolveBundled ?? ((r) => resolveBundledBinary(r));
-  const run = deps.run ?? runBounded;
-  const resolution = resolveBundled(runtime);
-  if (resolution.status !== "present" || !resolution.path) {
-    return {
-      status: "bundle_missing",
-      bundled: resolution.status === "present" ? "executable_missing" : resolution.status
-    };
-  }
-  const path = resolution.path;
-  const version = run(path, ["--version"], env).then(
-    (r) => r.code === 0 ? parseVersionToken(r.output) : null
-  );
-  const variable = apiKeyVariable(runtime, env);
-  if (variable) return { status: "api_key", variable, version: await version };
-  const statusArgs = runtime === "codex" ? ["login", "status"] : ["auth", "status", "--json"];
-  const [answer, v] = await Promise.all([run(path, statusArgs, env), version]);
-  if (answer.error) return { status: "check_failed", reason: answer.error };
-  const signedIn = runtime === "codex" ? readCodexStatus(answer) : readClaudeStatus(answer);
-  if (typeof signedIn === "string") return { status: "check_failed", reason: signedIn };
-  return signedIn ? { status: "signed_in", version: v } : { status: "signed_out", version: v };
-}
-function readClaudeStatus(answer) {
-  const start2 = answer.output.indexOf("{");
-  const end = answer.output.lastIndexOf("}");
-  if (start2 < 0 || end < start2) return "unreadable";
-  try {
-    const parsed = JSON.parse(answer.output.slice(start2, end + 1));
-    const loggedIn = parsed?.loggedIn;
-    return typeof loggedIn === "boolean" ? loggedIn : "unreadable";
-  } catch {
-    return "unreadable";
-  }
-}
-function readCodexStatus(answer) {
-  if (answer.code === 0) return true;
-  if (/not logged in/i.test(answer.output)) return false;
-  if (/config/i.test(answer.output)) return "config";
-  return "unreadable";
-}
-function runBounded(path, args, env) {
-  return new Promise((resolve2) => {
-    let settled = false;
-    let out = "";
-    const done = (result) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve2(result);
-    };
-    let child;
-    try {
-      child = spawn2(path, args, { stdio: ["ignore", "pipe", "pipe"], env });
-    } catch {
-      resolve2({ code: null, output: "", error: "spawn" });
-      return;
-    }
-    const capture = (chunk) => {
-      if (out.length < 8192) out += chunk.toString();
-    };
-    child.stdout?.on("data", capture);
-    child.stderr?.on("data", capture);
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL");
-      done({ code: null, output: out, error: "timeout" });
-    }, CHECK_TIMEOUT_MS);
-    timer.unref?.();
-    child.once("error", () => done({ code: null, output: out, error: "spawn" }));
-    child.once("close", (code) => done({ code, output: out }));
-  });
-}
-
-// src/harness-detect.ts
+init_harness_usable();
+init_harness_versions();
 var DEFAULT_OPENCODE_SERVER_URL = "http://127.0.0.1:4096";
 var DEFAULT_OPENCODE_PROBE_MS = 1e3;
 var CONFIGURED_OPENCODE_PROBE_MS = 4e3;
@@ -12420,14 +12522,19 @@ var DeviceApi = class {
     return parsed;
   }
   // Pull the agents this device should run, across all the owner's workspaces.
-  getAssignments() {
-    return this.request("GET", "/api/companion/assignments");
+  getAssignments(signal) {
+    return this.request("GET", "/api/companion/assignments", void 0, requestSignal(signal));
   }
   // Ask again for the credential of an agent assigned to this device, when the saved copy is
   // gone. The previous credential stops working; any agent not assigned here is a 404, and a
   // second ask inside a minute a 429.
-  reissueAgentCredential(agentId) {
-    return this.request("POST", `/api/companion/agents/${encodeURIComponent(agentId)}/credential`);
+  reissueAgentCredential(agentId, signal) {
+    return this.request(
+      "POST",
+      `/api/companion/agents/${encodeURIComponent(agentId)}/credential`,
+      void 0,
+      requestSignal(signal, 3e4)
+    );
   }
   getRuns(cursor) {
     const query = new URLSearchParams({ limit: "100", order: "asc" });
@@ -12467,6 +12574,10 @@ function errorMessage2(status2, body) {
   if (typeof body === "string" && body.length > 0) return `${status2} ${body.slice(0, 200)}`;
   return `${status2} error`;
 }
+function requestSignal(signal, timeoutMs = 5e3) {
+  const deadline = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, deadline]) : deadline;
+}
 
 // src/supervisor.ts
 init_config();
@@ -12976,6 +13087,10 @@ function runtimeIssuesFor(gates) {
   return issues;
 }
 
+// src/supervisor.ts
+init_harness_versions();
+init_harness_usable();
+
 // src/opencode-models.ts
 var OPENCODE_RUNTIME = "opencode";
 function mapOpencodeProviders(json) {
@@ -13842,6 +13957,7 @@ var CompanionSupervisor = class {
   pollTimer = null;
   refreshing = false;
   stopped = false;
+  reconciliationAbort = new AbortController();
   // The version-skew warning is logged once, not every heartbeat.
   versionSkewWarned = false;
   // This device's id, captured from the heartbeat / assignments response. The SSE
@@ -13887,6 +14003,7 @@ var CompanionSupervisor = class {
   // heartbeat + poll loops. A companion with no device token (logged out) does
   // nothing but say so.
   async start() {
+    if (this.stopped) return;
     this.log.info(
       { protocolVersion: TURN_PROTOCOL_VERSION, version: COMPANION_VERSION },
       `Companion ${COMPANION_VERSION} starting on ${this.config.deviceLabel ?? hostname2()}`
@@ -13971,6 +14088,7 @@ var CompanionSupervisor = class {
     });
     this.updater.start();
     await this.refreshAssignments();
+    if (this.stopped) return;
     this.deviceSub.start();
     this.heartbeatTimer = setInterval(() => this.kickHeartbeat(), HEARTBEAT_INTERVAL_MS);
     this.heartbeatTimer.unref?.();
@@ -14083,10 +14201,12 @@ var CompanionSupervisor = class {
         let items;
         let device;
         try {
-          const resp = await this.deviceApi.getAssignments();
+          const resp = await this.deviceApi.getAssignments(this.reconciliationAbort.signal);
+          if (this.stopped) return;
           items = resp.assignments;
           device = resp.device;
         } catch (err) {
+          if (this.stopped) return;
           this.log.error(
             { ...apiErrorLogFields(err) },
             "Couldn't load the assigned agents. Check that this device is active in Cabane; trying again shortly."
@@ -14105,6 +14225,7 @@ var CompanionSupervisor = class {
           if (it.credential) setCredential(device.id, it.agentId, it.credential);
         }
         items = await this.restoreMissingCredentials(device.id, items);
+        if (this.stopped) return;
         this.uncredentialed = new Set(
           items.filter((it) => !it.credential && !getCredential(device.id, it.agentId)).map((it) => `${it.workspaceId}|${it.agentId}`)
         );
@@ -14117,6 +14238,7 @@ var CompanionSupervisor = class {
         for (const wsId of [...this.workspaces.keys()]) {
           if (!byWorkspace.has(wsId)) await this.removeWorkspace(wsId);
         }
+        if (this.stopped) return;
         for (const [wsId, list] of byWorkspace) this.reconcileWorkspace(device.id, wsId, list);
         const pruned = pruneCredentials(
           device.id,
@@ -14148,6 +14270,7 @@ var CompanionSupervisor = class {
   async restoreMissingCredentials(deviceId, items) {
     const restored = [];
     for (const it of items) {
+      if (this.stopped) return restored;
       if (it.credential || getCredential(deviceId, it.agentId)) {
         restored.push(it);
         continue;
@@ -14159,7 +14282,11 @@ var CompanionSupervisor = class {
         continue;
       }
       try {
-        const { credential } = await this.deviceApi.reissueAgentCredential(it.agentId);
+        const { credential } = await this.deviceApi.reissueAgentCredential(
+          it.agentId,
+          this.reconciliationAbort.signal
+        );
+        if (this.stopped) return restored;
         setCredential(deviceId, it.agentId, credential);
         this.log.info(
           { agentId: it.agentId, agentName: it.agentDisplayName },
@@ -14452,7 +14579,16 @@ var CompanionSupervisor = class {
       },
       runner: {
         provider: this.runnerProvider,
-        command: this.runnerCommand ?? selfRunnerCommand(),
+        command: wrappedRunnerCommand(
+          this.config.runner?.command,
+          this.runnerCommand ?? selfRunnerCommand()
+        ),
+        ...this.config.runner?.command ? {
+          boxed: true,
+          secrets: () => loadSecretValuesTolerant(
+            (m) => this.log.warn({ err: m }, "Could not read the secrets file for a boxed turn.")
+          )
+        } : {},
         ...this.runnerEnv ? { env: this.runnerEnv } : {},
         reportRunnerGone: (report) => this.reportRunnerGone(report),
         connectorHealth: this.connectorHealth,
@@ -15034,6 +15170,7 @@ var CompanionSupervisor = class {
   // ---- control actions ----
   async shutdown() {
     this.stopped = true;
+    this.reconciliationAbort.abort();
     this.updater?.stop();
     if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
     if (this.detectTimer) clearInterval(this.detectTimer);
@@ -15311,33 +15448,46 @@ async function createCompanionRuntime(opts = {}) {
   });
   let restartForUpdate = async () => {
   };
-  const supervisor = new CompanionSupervisor({
-    config: cfg,
-    log: log2,
-    hub,
-    ...opts.checkHarness ? { checkHarness: opts.checkHarness } : {},
-    ...embeddedRunner({
-      electron: Boolean(process.versions.electron),
-      execPath: process.execPath,
-      moduleUrl: import.meta.url,
-      env: process.env
-    }) ?? {},
-    restartForUpdate: () => restartForUpdate()
-  });
-  await supervisor.start();
+  let supervisor;
   let control = null;
   let dashboard = null;
+  let stopped = false;
+  const stop2 = async () => {
+    if (stopped) return;
+    stopped = true;
+    clearRuntimeStateIfOurs(instanceId);
+    process.removeListener("exit", clearRuntimeOnExit);
+    await Promise.allSettled([
+      ...supervisor ? [supervisor.shutdown()] : [],
+      ...control ? [control.close()] : [],
+      ...dashboard ? [dashboard.close()] : []
+    ]);
+  };
   try {
+    supervisor = new CompanionSupervisor({
+      config: cfg,
+      log: log2,
+      hub,
+      ...opts.checkHarness ? { checkHarness: opts.checkHarness } : {},
+      ...embeddedRunner({
+        electron: Boolean(process.versions.electron),
+        execPath: process.execPath,
+        moduleUrl: import.meta.url,
+        env: process.env
+      }) ?? {},
+      restartForUpdate: () => restartForUpdate()
+    });
+    const active2 = supervisor;
     control = await startControlServer({
       status: () => ({
         ...hub.statusJson(),
-        ...supervisor.lastHeartbeat(),
-        detection: supervisor.currentDetection()
+        ...active2.lastHeartbeat(),
+        detection: active2.currentDetection()
       }),
-      detect: () => supervisor.redetect(),
-      allow: (runtime) => supervisor.allowHarness(runtime),
-      update: (auto) => supervisor.update(auto),
-      stop: () => void supervisor.requestStop()
+      detect: () => active2.redetect(),
+      allow: (runtime) => active2.allowHarness(runtime),
+      update: (auto) => active2.update(auto),
+      stop: () => void stop2().then(() => active2.requestStop())
     });
     if (opts.dashboard) {
       const preferredPort = opts.port ?? cfg.dashboardPort;
@@ -15348,6 +15498,7 @@ async function createCompanionRuntime(opts = {}) {
       });
       hub.setDashboardUrl(dashboard.url);
     }
+    if (stopped) throw new Error("The companion was stopped during startup.");
     writeRuntimeState({
       pid: process.pid,
       socket: control.path,
@@ -15365,7 +15516,7 @@ async function createCompanionRuntime(opts = {}) {
     clearRuntimeStateIfOurs(instanceId);
     process.removeListener("exit", clearRuntimeOnExit);
     await Promise.allSettled([
-      supervisor.shutdown(),
+      ...supervisor ? [supervisor.shutdown()] : [],
       ...control ? [control.close()] : [],
       ...dashboard ? [dashboard.close()] : []
     ]);
@@ -15377,22 +15528,17 @@ async function createCompanionRuntime(opts = {}) {
     });
     throw err;
   }
-  let stopped = false;
-  const stop2 = async () => {
-    if (stopped) return;
-    stopped = true;
-    clearRuntimeStateIfOurs(instanceId);
-    process.removeListener("exit", clearRuntimeOnExit);
-    try {
-      await supervisor.shutdown();
-      await closeSurfaces(control, dashboard);
-    } catch {
-    }
-  };
+  const active = supervisor;
   restartForUpdate = async () => {
     await stop2();
     process.exit(0);
   };
+  void active.start().catch(async (err) => {
+    log2.error({ err }, "Couldn't initialize the companion.");
+    recordCrash({ reason: String(err), origin: "startup", at: (/* @__PURE__ */ new Date()).toISOString() });
+    await stop2();
+    process.exitCode = 1;
+  });
   return {
     ok: true,
     runtime: {
@@ -15400,15 +15546,38 @@ async function createCompanionRuntime(opts = {}) {
       socketPath: control.path,
       config: cfg,
       stop: stop2,
-      heartbeatNow: () => supervisor.heartbeatNow(),
+      heartbeatNow: () => active.heartbeatNow(),
       harnesses: () => hub.statusJson().harnesses ?? [],
-      detect: () => supervisor.redetect()
+      detect: () => active.redetect()
     }
   };
 }
-async function closeSurfaces(control, dashboard) {
-  await control.close();
-  if (dashboard) await dashboard.close();
+
+// src/start-observation.ts
+init_cabane_command();
+async function observeStart(deps = {}) {
+  const read2 = deps.readState ?? readLiveRuntimeState;
+  const verify = deps.verify ?? verifyRuntime;
+  const now = deps.now ?? Date.now;
+  const sleep3 = deps.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const deadline = now() + 8e3;
+  for (; ; ) {
+    const state = await read2();
+    if (state?.socket && await verify(state) === "ours") return state;
+    if (now() >= deadline) return null;
+    await sleep3(Math.min(150, Math.max(0, deadline - now())));
+  }
+}
+function markLaunchRequester() {
+  process.title = "cabane-launcher";
+}
+function unconfirmedStartLines(service2) {
+  return [
+    "Cabane's start was requested, but readiness isn't confirmed yet. It may still finish starting in the background.",
+    `Check: ${cabane("status")}`,
+    ...service2 ? [`Service: ${cabane("service status")}`] : [],
+    `Log: ${cabane("logs")}`
+  ];
 }
 
 // src/commands/start.ts
@@ -15817,15 +15986,11 @@ init_config();
 import { spawn as spawn7 } from "child_process";
 import { closeSync as closeSync3, mkdirSync as mkdirSync17, openSync as openSync4 } from "fs";
 init_config();
-var STARTUP_TIMEOUT_MS = 8e3;
-var POLL_INTERVAL_MS = 150;
 async function startDaemon(opts = {}, deps = {}) {
   const ensureRuntime = deps.ensureRuntime ?? warnAboutHarnessReadiness;
   const readState = deps.readState ?? readLiveRuntimeState;
   const verify = deps.verify ?? ((s) => verifyRuntime(s));
   const spawnDetached = deps.spawnDetached ?? defaultSpawnDetached;
-  const sleep3 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  const now = deps.now ?? (() => Date.now());
   const quiet = opts.report === "failures" || opts.report === "silent";
   const cfg = (deps.requireCfg ?? requireConfig)();
   ensureRuntime(cfg, {
@@ -15837,7 +16002,18 @@ async function startDaemon(opts = {}, deps = {}) {
   });
   const existing = readState();
   if (existing) {
-    if (await verify(existing) !== "stale") {
+    const verdict = await verify(existing);
+    if (verdict !== "stale") {
+      if (verdict !== "ours") {
+        const state2 = await observeStart({ ...deps, readState, verify });
+        if (!state2) {
+          if (opts.report !== "silent")
+            process.stdout.write(unconfirmedStartLines(false).join("\n") + "\n");
+          process.exitCode = 1;
+          return { started: false, state: null, unconfirmed: true };
+        }
+        return { started: false, state: state2 };
+      }
       if (opts.report !== "silent")
         process.stdout.write(alreadyRunningLines(existing.pid).join("\n") + "\n");
       return { started: false, state: existing };
@@ -15855,28 +16031,21 @@ async function startDaemon(opts = {}, deps = {}) {
     spawned.unref();
     return spawned;
   };
-  const ready = (s) => !!s && !!s.socket;
-  const waitForReady = async () => {
-    const deadline = now() + STARTUP_TIMEOUT_MS;
-    let seen = readState();
-    while (!ready(seen) && now() < deadline) {
-      await sleep3(POLL_INTERVAL_MS);
-      seen = readState();
-    }
-    return ready(seen) ? seen : null;
-  };
+  markLaunchRequester();
   const child = launchDetached();
-  const state = await waitForReady();
+  const state = await observeStart({ ...deps, readState, verify });
   if (!state) {
-    const error = `The background process (pid ${child?.pid ?? "?"}) did not report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.`;
+    const error = child.failure?.();
+    if (error) {
+      if (opts.report !== "silent") process.stdout.write(`Cabane couldn't start: ${error}
+`);
+      process.exitCode = 1;
+      return { started: false, state: null, error };
+    }
     if (opts.report !== "silent")
-      process.stdout.write(
-        `Cabane Companion was launched (pid ${child?.pid ?? "?"}) but didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.
-Check ${companionLogPath()} for errors, or run \`${cabane("status")}\`.
-`
-      );
+      process.stdout.write(unconfirmedStartLines(false).join("\n") + "\n");
     process.exitCode = 1;
-    return { started: false, state: null, error };
+    return { started: false, state: null, unconfirmed: true };
   }
   if (quiet) return { started: true, state };
   process.stdout.write(
@@ -15896,11 +16065,19 @@ function defaultSpawnDetached(args) {
   mkdirSync17(cabaneDir(), { recursive: true });
   const logFd = openSync4(companionLogPath(), "a");
   try {
-    return spawn7(process.execPath, [cliPath, ...args], {
+    const child = spawn7(process.execPath, [cliPath, ...args], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       env: { ...process.env, CABANE_COMPANION_DAEMON: "1" }
     });
+    let failure;
+    child.once("error", (err) => {
+      failure = err.message;
+    });
+    child.once("exit", (code, signal) => {
+      failure = `The background process exited (${signal ?? code}). Check cabane logs.`;
+    });
+    return { pid: child.pid, unref: () => child.unref(), failure: () => failure };
   } finally {
     closeSync3(logFd);
   }
@@ -16020,8 +16197,10 @@ async function start(opts = {}, deps = {}) {
   try {
     return await startScript(opts, deps);
   } catch (err) {
-    for (const line of startFailure(err instanceof Error ? err.message : String(err), reloadLine()))
-      write(line);
+    const reason = err instanceof Error ? err.message : String(err);
+    if (process.env.CABANE_COMPANION_SUPERVISED === "1")
+      getLogger().error({ err }, `Cabane couldn't start: ${reason}`);
+    for (const line of startFailure(reason, reloadLine())) write(line);
     process.exitCode = 1;
     return null;
   } finally {
@@ -16057,23 +16236,41 @@ async function startScript(opts, deps) {
         mode = "attached";
       }
     } else if (installed) {
-      const result = await startService();
-      if (!result.ok) throw new Error(result.lines.join(" "));
-      const deadline = Date.now() + 8e3;
-      while (!running?.socket && Date.now() < deadline) {
-        running = await (deps.live ?? liveCompanionState)();
-        if (!running?.socket) await new Promise((resolve2) => setTimeout(resolve2, 150));
+      markLaunchRequester();
+      const before = await serviceState();
+      if (!serviceLaunchPending(before)) {
+        const result = await startService();
+        if (!result.ok) {
+          running = await observeStart({ ...deps, readState: deps.live });
+          const current2 = await serviceState();
+          if (!running && !serviceLaunchPending(current2)) throw new Error(result.lines.join(" "));
+        }
       }
-      if (!running?.socket) throw new Error("The service did not report ready within 8s.");
-      mode = "service";
+      running ??= await observeStart({ ...deps, readState: deps.live });
+      if (!running) {
+        const current2 = await serviceState();
+        if (!current2.nodeOk || current2.state === "failed")
+          throw new Error(
+            !current2.nodeOk ? "The service Node executable is missing." : "The service failed. Check cabane logs."
+          );
+        return reportUnconfirmed(true);
+      }
+      const current = await serviceState();
+      mode = current.state === "running" && current.pid === running.pid ? "service" : "existing";
     } else {
       const result = await startDaemon({ ...opts, report: "silent" });
+      if (result.unconfirmed) return reportUnconfirmed(false);
       if (!result.state)
         throw new Error(result.error ?? "The background process did not report ready.");
       running = result.state;
       mode = result.started ? "background" : "existing";
     }
   }
+  if (!runtime && mode === "existing") {
+    running = await observeStart({ ...deps, readState: deps.live });
+    if (!running) return reportUnconfirmed(installed);
+  }
+  const attached = runtime ? runAttached(runtime) : null;
   const socket = runtime?.socketPath ?? running?.socket;
   let status2 = await (deps.waitAck ?? waitForAcknowledgement)(socket);
   let detection = status2.detection ?? null;
@@ -16087,6 +16284,26 @@ async function startScript(opts, deps) {
     const latest = await readTerminalStatus(socket);
     if (latest.lastHeartbeatAckAt || latest.lastHeartbeatRefused) status2 = latest;
   }
+  if (!runtime) {
+    const current = await (deps.live ?? liveCompanionState)();
+    if (!current || await (deps.verify ?? verifyRuntime)(current) !== "ours") {
+      if (installed) {
+        const service2 = await serviceState();
+        if (!service2.pid && ["not loaded", "dead", "inactive", "failed"].includes(service2.state))
+          throw new Error("The service stopped before startup completed.");
+      }
+      return reportUnconfirmed(installed);
+    }
+    if (current.pid !== running?.pid || current.instanceId !== running?.instanceId) {
+      status2 = await readTerminalStatus(current.socket);
+      detection = status2.detection ?? null;
+    }
+    running = current;
+    if (mode === "service") {
+      const service2 = await serviceState();
+      if (service2.state !== "running" || service2.pid !== current.pid) mode = "existing";
+    }
+  }
   const personalUrl = `${cfg.baseUrl.replace(/\/$/, "")}/settings/devices`;
   const address = opts.pairing ? opts.pairing.devicesUrl : personalUrl;
   if (!daemon)
@@ -16103,10 +16320,18 @@ async function startScript(opts, deps) {
       write(line);
   if (runtime) {
     setConsoleLogging(true);
-    await runAttached(runtime);
+    await attached;
   }
   return detection;
 }
+function serviceLaunchPending(state) {
+  return !!state.pid || ["running", "activating", "auto-restart"].includes(state.state) || state.platform === "launchd" && state.installed && !["not loaded", "unknown", "failed"].includes(state.state);
+}
+function reportUnconfirmed(service2) {
+  for (const line of unconfirmedStartLines(service2)) write(line);
+  process.exitCode = 1;
+  return null;
+}
 async function detectOverSocket(socket) {
   const body = await controlRequest(socket, { cmd: "detect" }, 15e3);
   return body.detection;
@@ -16480,7 +16705,7 @@ init_term();
 
 // src/commands/stop.ts
 var TERM_GRACE_MS = 6e3;
-var POLL_INTERVAL_MS2 = 150;
+var POLL_INTERVAL_MS = 150;
 async function stop(deps = {}) {
   if ((deps.serviceInstalled ?? serviceInstalled)()) {
     const outcome = await (deps.stopService ?? stopService)();
@@ -16526,7 +16751,7 @@ async function stop(deps = {}) {
       process.stdout.write("companion: stopped.\n");
       return;
     }
-    await sleep3(POLL_INTERVAL_MS2);
+    await sleep3(POLL_INTERVAL_MS);
   }
   process.stdout.write(
     `companion: didn't exit within ${TERM_GRACE_MS / 1e3}s, sending SIGKILL.
@@ -16683,7 +16908,10 @@ function row2(label, value) {
 async function status(deps = {}) {
   const out = (line) => void process.stdout.write(`${line}
 `);
-  const running = await liveState();
+  const candidate = readLiveRuntimeState({ sweep: false });
+  const verdict = candidate ? await verifyRuntime(candidate) : null;
+  const running = verdict === "stale" ? null : candidate;
+  const service2 = await serviceState();
   for (const line of pathLines(reloadLine())) out(line);
   const strays = strayStatusLines(running, deps.strays);
   out(`  ${versionLine()}`);
@@ -16705,7 +16933,7 @@ async function status(deps = {}) {
   out(row2("Paired with", `${cfg.baseUrl}${cfg.deviceLabel ? ` as ${cfg.deviceLabel}` : ""}`));
   let detection = null;
   if (running) {
-    const mode = running.daemon ? "in the background" : "in a terminal";
+    const mode = verdict !== "ours" ? "identity unconfirmed" : runningMode(running, service2);
     const uptime = formatUptime(running.startedAt);
     out(row2("Running", `${mode} (pid ${running.pid}${uptime ? `, up ${uptime}` : ""})`));
     detection = await runningDetection(running);
@@ -16723,7 +16951,6 @@ async function status(deps = {}) {
     )
   );
   for (const line of strays) out(line);
-  const service2 = await serviceState();
   for (const line of serviceRows(service2)) out(line);
   for (const line of updateRows(readUpdateState(), cfg.update?.auto, {
     version: false,
@@ -16793,10 +17020,13 @@ function otherInstall(install, own) {
   const ownAlias = own ? real(join30(dirname13(own), "cabane-companion")) : null;
   return real(found) === ownAlias ? null : dirname13(found);
 }
-async function liveState() {
-  const running = readLiveRuntimeState({ sweep: false });
-  if (running && await verifyRuntime(running) === "stale") return null;
-  return running;
+function runningMode(running, service2) {
+  if (service2.installed) {
+    if (service2.state === "running" && service2.pid === running.pid) return "as a service";
+    if (service2.state === "unknown" || service2.pid === running.pid || service2.state === "running" && !service2.pid)
+      return "run mode unconfirmed";
+  }
+  return running.daemon ? "in the background" : "in a terminal";
 }
 async function runningDetection(running) {
   if (!running.socket) return null;
@@ -16994,7 +17224,7 @@ init_errors();
 init_src();
 init_transcript_writer();
 import { existsSync as existsSync19, readFileSync as readFileSync17, readdirSync as readdirSync6 } from "fs";
-import { isAbsolute as isAbsolute2, join as join31 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute2, join as join31 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -17117,13 +17347,28 @@ async function followTranscripts(dir2) {
     follower.tick();
   });
 }
-function listFiles(dir2) {
+function listTranscriptFiles(dir2) {
+  let entries;
   try {
-    return readdirSync6(dir2).filter((f) => f.endsWith(".jsonl")).sort().reverse();
+    entries = readdirSync6(dir2, { withFileTypes: true });
   } catch {
     return [];
   }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) files.push(entry.name);
+    if (!entry.isDirectory() || entry.name === "anomalies") continue;
+    let inner;
+    try {
+      inner = readdirSync6(join31(dir2, entry.name));
+    } catch {
+      continue;
+    }
+    for (const name of inner) if (name.endsWith(".jsonl")) files.push(`${entry.name}/${name}`);
+  }
+  return files.sort((a, b) => basename4(a) < basename4(b) ? 1 : basename4(a) > basename4(b) ? -1 : 0);
 }
+var listFiles = listTranscriptFiles;
 function printList(dir2) {
   const files = listFiles(dir2);
   if (files.length === 0) {
@@ -17170,6 +17415,7 @@ function peek(path) {
 function resolveTarget(dir2, target) {
   if (isAbsolute2(target) || target.includes("/")) {
     if (existsSync19(target)) return target;
+    if (!isAbsolute2(target) && existsSync19(join31(dir2, target))) return join31(dir2, target);
     throw new CompanionError(`no transcript at ${target}.`);
   }
   const exact = join31(dir2, target);