@cabane/companion 0.6.216 → 0.6.217

package/dist/cli.js

@@ -738,9 +738,9 @@ var init_config = __esm({
       // silent roster: an agent nobody listed gets no hook and no error, and starts
       // in the operator's `$HOME`.
       prepareHook: prepareHookSchema.optional(),
-      // `dashboardPort` and `autoOpen` are IGNORED by the CLI (no port, no browser)
-      // but stay in the schema so an existing file still parses; the Electron shell
-      // reads them. `logLevel` is pino's level, live-editable.
+      // The CLI ignores both dashboard settings. Desktop uses `dashboardPort`;
+      // `autoOpen` remains parseable for older config files but no longer controls
+      // startup. `logLevel` is pino's level, live-editable.
       dashboardPort: z2.number().int().min(1).max(65535).optional(),
       autoOpen: z2.boolean().optional(),
       logLevel: z2.enum(["warn", "info", "debug"]).optional(),
@@ -2108,7 +2108,7 @@ var init_turn_diagnostics = __esm({
     turnSessionModes = ["fresh", "resumed", "degraded"];
     turnRuntimeResultKinds = ["success", "error", "no_terminal"];
     turnFinalSources = [
-      // The agent declared its answer with the `answer` turn act (CT1973).
+      // The agent declared its answer with the `answer` turn act.
       "declared",
       "runtime_text",
       "progress_promotion",
@@ -2330,23 +2330,6 @@ var init_standing = __esm({
   }
 });
 
-// packages/agent-runtime/src/conformance.ts
-import { z as z9 } from "zod";
-var conformanceFixtureSchema;
-var init_conformance = __esm({
-  "packages/agent-runtime/src/conformance.ts"() {
-    "use strict";
-    init_turn_event();
-    init_turn_request();
-    conformanceFixtureSchema = z9.object({
-      name: z9.string(),
-      request: turnRequestSchema,
-      nativeStream: z9.array(z9.unknown()),
-      expected: z9.array(turnEventSchema)
-    });
-  }
-});
-
 // packages/agent-runtime/src/transcript.ts
 function createTerminalTextBuffer() {
   return { held: null };
@@ -2905,7 +2888,7 @@ var init_mcp_secret_env = __esm({
 });
 
 // packages/agent-runtime/src/claude-code/policy.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 function withThinkingSummaries(thinking) {
   if (!thinking) return { type: "adaptive", display: "summarized" };
   if (thinking.type === "disabled") return thinking;
@@ -2942,18 +2925,18 @@ var init_policy = __esm({
       "Workflow"
     ];
     DEFAULT_WEB_TOOLS = ["WebSearch", "WebFetch"];
-    claudeCodeDialectSchema = z10.object({
-      thinking: z10.discriminatedUnion("type", [
-        z10.object({
-          type: z10.literal("adaptive"),
-          display: z10.enum(["summarized", "omitted"]).optional()
+    claudeCodeDialectSchema = z9.object({
+      thinking: z9.discriminatedUnion("type", [
+        z9.object({
+          type: z9.literal("adaptive"),
+          display: z9.enum(["summarized", "omitted"]).optional()
         }),
-        z10.object({
-          type: z10.literal("enabled"),
-          budgetTokens: z10.number().int().positive().optional(),
-          display: z10.enum(["summarized", "omitted"]).optional()
+        z9.object({
+          type: z9.literal("enabled"),
+          budgetTokens: z9.number().int().positive().optional(),
+          display: z9.enum(["summarized", "omitted"]).optional()
         }),
-        z10.object({ type: z10.literal("disabled") })
+        z9.object({ type: z9.literal("disabled") })
       ]).optional()
     }).loose();
   }
@@ -3021,7 +3004,7 @@ async function preToolUseHook(input) {
     hookSpecificOutput: {
       hookEventName: "PreToolUse",
       permissionDecision: "allow",
-      permissionDecisionReason: "headless never-prompt (CT680)",
+      permissionDecisionReason: "headless never-prompt",
       updatedInput: toolInput
     }
   };
@@ -3589,7 +3572,7 @@ async function* runWithResumeRecovery(queryFn, req, signal, initial, augmentOpti
     if (recoverResume) {
       if (signal.aborted) return;
       onWarn?.(
-        `claude-code adapter: stored session ${initial.resume} ended before system/init \u2014 starting one fresh session (CT1293 recovery)`,
+        `claude-code adapter: stored session ${initial.resume} ended before system/init \u2014 starting one fresh session`,
         {
           cwd: req.local.cwd,
           reason: "session_start_failed",
@@ -3618,7 +3601,7 @@ function createClaudeCodeAdapter(deps = {}) {
       let built = buildClaudeCodeOptions(req, deps.augmentOptions);
       if (built.freshReason === "cwd_mismatch") {
         deps.onWarn?.(
-          "claude-code adapter: stored session cwd no longer matches the current environment \u2014 starting a fresh session (SJ527 guard)",
+          "claude-code adapter: stored session cwd no longer matches the current environment \u2014 starting a fresh session",
           { cwd: req.local.cwd }
         );
       }
@@ -3668,546 +3651,6 @@ var init_claude_code = __esm({
   }
 });
 
-// packages/agent-runtime/src/claude-code/conformance.ts
-function makeRequest(overrides2 = {}) {
-  return {
-    systemPrompt: "system",
-    prompt: "hi there",
-    content: [{ type: "text", text: "hi there" }],
-    // The adapter rejects a null model, so the fixture carries a real bare SDK id.
-    config: { model: "claude-opus-4-8" },
-    session: null,
-    cabane: { mcpUrl: "https://cabane.test/api/mcp", bearer: "tok", activeConversationId: "conv" },
-    local: { cwd: CWD },
-    extra: { mcpServers: {} },
-    ...overrides2
-  };
-}
-var ABORT_SENTINEL, CWD, HEALTHY_MCP_INVENTORY, init, assistantText, assistantTextTool, toolResult, resultSuccess, resultSuccessFull, resultError, resultErrorFull, rateLimitEvent, authStatus, sessionEvent, BASE_CLAUDE_CODE_CONFORMANCE_FIXTURES, CLAUDE_CODE_CONFORMANCE_FIXTURES;
-var init_conformance2 = __esm({
-  "packages/agent-runtime/src/claude-code/conformance.ts"() {
-    "use strict";
-    init_claude_code();
-    init_session();
-    ABORT_SENTINEL = { __abortHere: true };
-    CWD = "/env/here";
-    HEALTHY_MCP_INVENTORY = {
-      initReceived: true,
-      servers: [{ name: "cabane", status: "connected" }],
-      toolCount: 1
-    };
-    init = (sessionId, model) => ({
-      type: "system",
-      subtype: "init",
-      session_id: sessionId,
-      mcp_servers: HEALTHY_MCP_INVENTORY.servers,
-      tools: ["mcp__cabane__query"],
-      ...model ? { model } : {}
-    });
-    assistantText = (text) => ({
-      type: "assistant",
-      message: { content: [{ type: "text", text }] }
-    });
-    assistantTextTool = (text, tool2) => ({
-      type: "assistant",
-      message: {
-        content: [
-          { type: "text", text },
-          { type: "tool_use", id: tool2.id, name: tool2.name, input: tool2.input }
-        ]
-      }
-    });
-    toolResult = (id, content, isError = false) => ({
-      type: "user",
-      message: { content: [{ type: "tool_result", tool_use_id: id, is_error: isError, content }] }
-    });
-    resultSuccess = (sessionId) => ({
-      type: "result",
-      subtype: "success",
-      session_id: sessionId
-    });
-    resultSuccessFull = (sessionId, extra) => ({
-      ...resultSuccess(sessionId),
-      ...extra
-    });
-    resultError = (subtype) => ({
-      type: "result",
-      subtype,
-      session_id: "s"
-    });
-    resultErrorFull = (subtype, extra = {}) => ({
-      type: "result",
-      subtype,
-      session_id: "s",
-      ...extra
-    });
-    rateLimitEvent = (status2, resetsAt, rateLimitType) => ({
-      type: "rate_limit_event",
-      rate_limit_info: {
-        status: status2,
-        ...resetsAt !== void 0 ? { resetsAt } : {},
-        ...rateLimitType !== void 0 ? { rateLimitType } : {}
-      },
-      session_id: "s"
-    });
-    authStatus = (error) => ({
-      type: "auth_status",
-      isAuthenticating: false,
-      output: [],
-      error,
-      session_id: "s"
-    });
-    sessionEvent = (sdkSessionId, cwd = CWD, degraded = false) => ({
-      type: "session",
-      state: encodeSession({ sdkSessionId, cwd }),
-      ...degraded ? { degraded: true } : {}
-    });
-    BASE_CLAUDE_CODE_CONFORMANCE_FIXTURES = [
-      {
-        // A plain text reply: the held text-only block flushes as the terminal final.
-        name: "clean turn",
-        request: makeRequest(),
-        nativeStream: [init("s1"), assistantText("Hello there."), resultSuccess("s1")],
-        expected: [
-          sessionEvent("s1"),
-          { type: "text", body: "Hello there.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Narration + a tool call + result + closing reply.
-        name: "tool turn",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          assistantTextTool("Reading your notes.", {
-            id: "tu1",
-            name: "mcp__cabane__cabane_read",
-            input: { path: "sleep.md" }
-          }),
-          toolResult("tu1", [{ type: "text", text: "sleep early" }]),
-          assistantText("Here's the summary."),
-          resultSuccess("s1")
-        ],
-        expected: [
-          sessionEvent("s1"),
-          { type: "text", body: "Reading your notes.", terminal: false },
-          {
-            type: "tool",
-            id: "tu1",
-            name: "cabane_read",
-            phase: "start",
-            summary: "sleep.md",
-            input: { path: "sleep.md" },
-            // Derived from the raw `mcp__cabane__` name.
-            mcpServer: "cabane"
-          },
-          {
-            type: "tool",
-            id: "tu1",
-            name: "cabane_read",
-            phase: "done",
-            summary: "sleep.md",
-            input: { path: "sleep.md" },
-            result: [{ type: "text", text: "sleep early" }],
-            mcpServer: "cabane"
-          },
-          { type: "text", body: "Here's the summary.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Highest risk: cancel mid-stream. The abort lands after the tool result; the adapter stops
-        // before the closing reply — no final text, no `result` event (the server writes the stopped
-        // marker).
-        name: "cancel mid-stream",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          assistantTextTool("Working on it.", {
-            id: "tu1",
-            name: "mcp__cabane__cabane_list",
-            input: {}
-          }),
-          toolResult("tu1"),
-          ABORT_SENTINEL,
-          assistantText("This reply must never be emitted."),
-          resultSuccess("s1")
-        ],
-        expected: [
-          sessionEvent("s1"),
-          { type: "text", body: "Working on it.", terminal: false },
-          {
-            type: "tool",
-            id: "tu1",
-            name: "cabane_list",
-            phase: "start",
-            summary: "",
-            input: {},
-            mcpServer: "cabane"
-          },
-          {
-            type: "tool",
-            id: "tu1",
-            name: "cabane_list",
-            phase: "done",
-            summary: "",
-            input: {},
-            result: void 0,
-            mcpServer: "cabane"
-          }
-        ]
-      },
-      {
-        // An error result: partial narration lands as `progress` (terminal:false),
-        // and the `result` event carries the machine reason.
-        name: "error result",
-        request: makeRequest(),
-        nativeStream: [init("s1"), assistantText("Partial work."), resultError("error_max_turns")],
-        expected: [
-          sessionEvent("s1"),
-          { type: "text", body: "Partial work.", terminal: false },
-          { type: "result", ok: false, reason: "result_error:error_max_turns" }
-        ]
-      },
-      {
-        // The empty-runtime anomaly's captured trace: `system/init` then a successful `result`, nothing
-        // in between. Distinct from `empty-final` (a tool ran, no speech); this produced nothing. The
-        // adapter reports faithfully — `result{ok:true}` — and the host decides that a success with no
-        // content-bearing event is a failed turn.
-        name: "zero-content success (empty runtime result)",
-        request: makeRequest(),
-        nativeStream: [init("s1"), resultSuccess("s1")],
-        expected: [sessionEvent("s1"), { type: "result", ok: true }]
-      },
-      {
-        // On resume, a completed background task can emit a notification and its own zero-token result
-        // before the prompt's frames. That result is not the turn boundary; decoding continues through
-        // the reply and real usage.
-        name: "task-notification result does not end a resumed turn",
-        request: makeRequest({ session: encodeSession({ sdkSessionId: "s1", cwd: CWD }) }),
-        nativeStream: [
-          init("s1"),
-          {
-            type: "system",
-            subtype: "task_notification",
-            task_id: "task-1",
-            status: "completed",
-            output_file: "/tmp/task-1.output",
-            summary: "Background work completed.",
-            session_id: "s1"
-          },
-          resultSuccessFull("s1", {
-            is_error: false,
-            origin: { kind: "task-notification" },
-            usage: {
-              input_tokens: 0,
-              output_tokens: 0,
-              cache_read_input_tokens: 0,
-              cache_creation_input_tokens: 0
-            }
-          }),
-          assistantTextTool("Checking the returned work.", {
-            id: "tu1",
-            name: "mcp__cabane__cabane_read",
-            input: { path: "result.md" }
-          }),
-          toolResult("tu1", [{ type: "text", text: "ready" }]),
-          assistantText("The prompt completed normally."),
-          resultSuccessFull("s1", {
-            is_error: false,
-            usage: {
-              input_tokens: 120,
-              output_tokens: 30,
-              cache_read_input_tokens: 80,
-              cache_creation_input_tokens: 10
-            }
-          })
-        ],
-        expected: [
-          { type: "text", body: "Checking the returned work.", terminal: false },
-          {
-            type: "tool",
-            id: "tu1",
-            name: "cabane_read",
-            phase: "start",
-            summary: "result.md",
-            input: { path: "result.md" },
-            mcpServer: "cabane"
-          },
-          {
-            type: "tool",
-            id: "tu1",
-            name: "cabane_read",
-            phase: "done",
-            summary: "result.md",
-            input: { path: "result.md" },
-            result: [{ type: "text", text: "ready" }],
-            mcpServer: "cabane"
-          },
-          { type: "text", body: "The prompt completed normally.", terminal: true },
-          {
-            type: "result",
-            ok: true,
-            usage: {
-              inputTokens: 210,
-              outputTokens: 30,
-              cacheReadTokens: 80,
-              cacheCreationTokens: 10
-            }
-          }
-        ]
-      },
-      {
-        // The filter is deliberately narrow: an origin-less zero-token result still ends the turn, even
-        // if more frames follow.
-        name: "origin-less result still ends a resumed turn",
-        request: makeRequest({ session: encodeSession({ sdkSessionId: "s1", cwd: CWD }) }),
-        nativeStream: [
-          init("s1"),
-          resultSuccessFull("s1", {
-            is_error: false,
-            usage: {
-              input_tokens: 0,
-              output_tokens: 0,
-              cache_read_input_tokens: 0,
-              cache_creation_input_tokens: 0
-            }
-          }),
-          assistantText("This must not be emitted."),
-          resultSuccess("s1")
-        ],
-        expected: [
-          {
-            type: "result",
-            ok: true,
-            usage: {
-              inputTokens: 0,
-              outputTokens: 0,
-              cacheReadTokens: 0,
-              cacheCreationTokens: 0
-            }
-          }
-        ]
-      },
-      {
-        // Empty-final: a clean turn that ended on a tool call with no closing text.
-        // The adapter emits NO final text — empty-final promotion is host/pump
-        // territory (this fixture pins that boundary).
-        name: "empty-final (no closing text)",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          assistantTextTool("", {
-            id: "tu1",
-            name: "mcp__cabane__cabane_write",
-            input: { path: "a.md" }
-          }),
-          toolResult("tu1"),
-          resultSuccess("s1")
-        ],
-        expected: [
-          sessionEvent("s1"),
-          {
-            type: "tool",
-            id: "tu1",
-            name: "cabane_write",
-            phase: "start",
-            summary: "a.md",
-            input: { path: "a.md" },
-            mcpServer: "cabane"
-          },
-          {
-            type: "tool",
-            id: "tu1",
-            name: "cabane_write",
-            phase: "done",
-            summary: "a.md",
-            input: { path: "a.md" },
-            result: void 0,
-            mcpServer: "cabane"
-          },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // A subscription cap. The SDK emits a rejected `rate_limit_event` with a named subscription
-        // window; the terminal error result classifies as `usage_capped`. The held provider line
-        // independently classifies to the same kind, so it lands as a runtime notice, not agent
-        // progress.
-        name: "subscription cap \u2192 usage_capped",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          assistantText("You've hit your session limit \xB7 resets 8:20pm (UTC)"),
-          rateLimitEvent("rejected", void 0, "five_hour"),
-          resultError("error_during_execution")
-        ],
-        expected: [
-          sessionEvent("s1"),
-          {
-            type: "runtime_notice",
-            body: "You've hit your session limit \xB7 resets 8:20pm (UTC)"
-          },
-          { type: "result", ok: false, reason: "usage_capped" }
-        ]
-      },
-      {
-        // A failed turn can still contain the agent's own partial narration. No text classification
-        // means no authorship rewrite, even though the structured result is the same usage cap.
-        name: "partial narration before subscription cap stays progress",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          assistantText("Partial work."),
-          rateLimitEvent("rejected", void 0, "five_hour"),
-          resultError("error_during_execution")
-        ],
-        expected: [
-          sessionEvent("s1"),
-          { type: "text", body: "Partial work.", terminal: false },
-          { type: "result", ok: false, reason: "usage_capped" }
-        ]
-      },
-      {
-        // Recognized runtime prose stays authored when its kind disagrees with the structured terminal
-        // failure.
-        name: "cap notice before server failure stays progress",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          assistantText("You've hit your session limit \xB7 resets 8:20pm (UTC)"),
-          resultErrorFull("error_during_execution", {
-            is_error: true,
-            result: '529 {"type":"error","error":{"type":"overloaded_error"}}'
-          })
-        ],
-        expected: [
-          sessionEvent("s1"),
-          {
-            type: "text",
-            body: "You've hit your session limit \xB7 resets 8:20pm (UTC)",
-            terminal: false
-          },
-          { type: "result", ok: false, reason: "server_error" }
-        ]
-      },
-      {
-        // `classifyErrorText` deliberately searches arbitrary error blobs for status tokens. Assistant
-        // narration needs the stricter whole-notice classifier, or an incidental count would be
-        // de-authored when the turn later fails with the matching provider kind.
-        name: "incidental 5xx-shaped narration before server failure stays progress",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          assistantText("Indexed 500 files. Writing the summary next."),
-          resultErrorFull("error_during_execution", {
-            is_error: true,
-            result: '529 {"type":"error","error":{"type":"overloaded_error"}}'
-          })
-        ],
-        expected: [
-          sessionEvent("s1"),
-          {
-            type: "text",
-            body: "Indexed 500 files. Writing the summary next.",
-            terminal: false
-          },
-          { type: "result", ok: false, reason: "server_error" }
-        ]
-      },
-      {
-        // A cap signalled only by the result's `terminal_reason:'blocking_limit'` (no rate-limit event)
-        // still classifies as `usage_capped`.
-        name: "blocking_limit terminal reason \u2192 usage_capped",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          resultErrorFull("error_during_execution", {
-            is_error: true,
-            terminal_reason: "blocking_limit",
-            result: "stopped"
-          })
-        ],
-        expected: [sessionEvent("s1"), { type: "result", ok: false, reason: "usage_capped" }]
-      },
-      {
-        // An expired login surfaces as an `auth_status` error frame; the failing result classifies as
-        // `auth_expired`.
-        name: "expired login \u2192 auth_expired",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          authStatus("OAuth token has expired, please run /login"),
-          resultErrorFull("error_during_execution", {
-            is_error: true,
-            result: "authentication failed"
-          })
-        ],
-        expected: [sessionEvent("s1"), { type: "result", ok: false, reason: "auth_expired" }]
-      },
-      {
-        // A transient provider outage in the terminal result text (no structured event or enum) — a 529
-        // overload — classifies as `server_error` via the text fallback. It must not read as the cap or
-        // stamp the connector `limited`.
-        name: "provider overload text \u2192 server_error",
-        request: makeRequest(),
-        nativeStream: [
-          init("s1"),
-          resultErrorFull("error_during_execution", {
-            is_error: true,
-            result: '529 {"type":"error","error":{"type":"overloaded_error"}}'
-          })
-        ],
-        expected: [sessionEvent("s1"), { type: "result", ok: false, reason: "server_error" }]
-      },
-      {
-        // The resolved model is captured off `system/init.model` and attached to the terminal `result`
-        // even on a plain resume (this fixture resumes, so no `session` event fires). What's asserted is
-        // that the concrete id the harness reported comes home.
-        name: "resolved model captured from system/init",
-        request: makeRequest({ session: encodeSession({ sdkSessionId: "s1", cwd: CWD }) }),
-        nativeStream: [init("s1", "claude-opus-4-8"), assistantText("Done."), resultSuccess("s1")],
-        expected: [
-          { type: "text", body: "Done.", terminal: true },
-          { type: "result", ok: true, resolvedModel: "claude-opus-4-8" }
-        ]
-      },
-      {
-        // Session resume echo: the stored state matches the cwd, so its SDK id is resumed and
-        // `system/init` echoes the same id — no session event fires.
-        name: "session resume (no re-emit on echo)",
-        request: makeRequest({ session: encodeSession({ sdkSessionId: "s1", cwd: CWD }) }),
-        nativeStream: [init("s1"), assistantText("Back again."), resultSuccess("s1")],
-        expected: [
-          { type: "text", body: "Back again.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Cwd-mismatch degrade: the stored state was created under another cwd, so the adapter starts
-        // fresh — `system/init` reports a new id, and the session event records the current cwd.
-        name: "session cwd-mismatch degrades to fresh",
-        request: makeRequest({ session: encodeSession({ sdkSessionId: "old", cwd: "/env/gone" }) }),
-        nativeStream: [init("fresh1"), assistantText("Fresh start."), resultSuccess("fresh1")],
-        expected: [
-          // The degrade is flagged on the session event so the host relays it on settle and the server
-          // rewinds the catch-up mark (recovering context the discarded session no longer carries).
-          sessionEvent("fresh1", CWD, true),
-          { type: "text", body: "Fresh start.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      }
-    ];
-    CLAUDE_CODE_CONFORMANCE_FIXTURES = BASE_CLAUDE_CODE_CONFORMANCE_FIXTURES.map((fixture) => ({
-      ...fixture,
-      expected: fixture.expected.map(
-        (event) => event.type === "result" ? { ...event, mcpInventory: HEALTHY_MCP_INVENTORY } : event
-      )
-    }));
-  }
-});
-
 // packages/agent-runtime/src/registry.ts
 function createAdapterRegistry(adapters) {
   const byName = /* @__PURE__ */ new Map();
@@ -4504,7 +3947,7 @@ var init_loop2 = __esm({
 });
 
 // packages/agent-runtime/src/opencode/policy.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 function opencodeTools() {
   const tools = {};
   for (const name of [...OPENCODE_SCHEDULING_TOOLS, ...OPENCODE_UI_PROMPT_TOOLS])
@@ -4521,8 +3964,8 @@ var init_policy2 = __esm({
     "use strict";
     OPENCODE_SCHEDULING_TOOLS = [];
     OPENCODE_UI_PROMPT_TOOLS = ["question"];
-    opencodeDialectSchema = z11.object({
-      agent: z11.string().min(1).optional()
+    opencodeDialectSchema = z10.object({
+      agent: z10.string().min(1).optional()
     }).loose();
   }
 });
@@ -4930,7 +4373,7 @@ function createOpencodeAdapter(deps = {}) {
       const resume = "resume" in decision ? decision.resume : null;
       if ("fresh" in decision && decision.reason === "directory_mismatch") {
         deps.onWarn?.(
-          "opencode adapter: stored session directory no longer matches the current environment \u2014 starting a fresh session (SJ527-analogue guard)",
+          "opencode adapter: stored session directory no longer matches the current environment \u2014 starting a fresh session",
           { directory }
         );
       }
@@ -4985,490 +4428,6 @@ var init_opencode = __esm({
   }
 });
 
-// packages/agent-runtime/src/opencode/conformance.ts
-function makeRequest2(overrides2 = {}) {
-  return {
-    systemPrompt: "system",
-    prompt: "hi there",
-    content: [{ type: "text", text: "hi there" }],
-    config: { model: "deepseek/deepseek-chat" },
-    session: null,
-    cabane: { mcpUrl: "https://cabane.test/api/mcp", bearer: "tok", activeConversationId: "conv" },
-    local: { cwd: DIR },
-    extra: { mcpServers: {} },
-    ...overrides2
-  };
-}
-var ABORT_SENTINEL2, NEW_SESSION_ID, BOUNDED_NOTICE, DIR, textPart, reasoningPart, toolPart, messageUpdated, echoedUserPart, idle, errored, sessionEvent2, OPENCODE_CONFORMANCE_FIXTURES;
-var init_conformance3 = __esm({
-  "packages/agent-runtime/src/opencode/conformance.ts"() {
-    "use strict";
-    init_opencode();
-    init_session2();
-    ABORT_SENTINEL2 = { __abortHere: true };
-    NEW_SESSION_ID = "sess_new";
-    BOUNDED_NOTICE = "You've hit your usage limit \xB7 ".padEnd(200, "x");
-    DIR = "/env/here";
-    textPart = (id, text) => ({
-      type: "message.part.updated",
-      properties: { part: { type: "text", id, text } }
-    });
-    reasoningPart = (id, text) => ({
-      type: "message.part.updated",
-      properties: { part: { type: "reasoning", id, text } }
-    });
-    toolPart = (id, tool2, state, callID) => ({
-      type: "message.part.updated",
-      properties: { part: { type: "tool", id, tool: tool2, state, ...callID ? { callID } : {} } }
-    });
-    messageUpdated = (role, id) => ({
-      type: "message.updated",
-      properties: { info: { role, id } }
-    });
-    echoedUserPart = (partId, messageID, text) => ({
-      type: "message.part.updated",
-      properties: { part: { type: "text", id: partId, messageID, text } }
-    });
-    idle = () => ({ type: "session.idle", properties: {} });
-    errored = (message2) => ({
-      type: "session.error",
-      properties: { error: { message: message2 } }
-    });
-    sessionEvent2 = (sessionId, directory = DIR, degraded = false) => ({
-      type: "session",
-      state: encodeSession2({ sessionId, directory }),
-      ...degraded ? { degraded: true } : {}
-    });
-    OPENCODE_CONFORMANCE_FIXTURES = [
-      {
-        // A plain text reply: the held text part seals as the terminal final at idle.
-        name: "clean turn",
-        request: makeRequest2(),
-        nativeStream: [textPart("p1", "Hello there."), idle()],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "text", body: "Hello there.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Narration + a tool call + result + closing reply. The narration part is
-        // sealed as interim (a tool follows it); the trailing text is the final.
-        name: "tool turn",
-        request: makeRequest2(),
-        nativeStream: [
-          textPart("p1", "Reading your notes."),
-          toolPart("t1", "read", { status: "running", input: { path: "sleep.md" } }, "call_1"),
-          toolPart(
-            "t1",
-            "read",
-            { status: "completed", input: { path: "sleep.md" }, output: "sleep early" },
-            "call_1"
-          ),
-          textPart("p2", "Here's the summary."),
-          idle()
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "text", body: "Reading your notes.", terminal: false },
-          {
-            type: "tool",
-            id: "call_1",
-            name: "read",
-            phase: "start",
-            summary: "sleep.md",
-            input: { path: "sleep.md" }
-          },
-          {
-            type: "tool",
-            id: "call_1",
-            name: "read",
-            phase: "done",
-            summary: "sleep.md",
-            input: { path: "sleep.md" },
-            result: "sleep early"
-          },
-          { type: "text", body: "Here's the summary.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // A streaming provider's tool input arrives late. opencode re-emits the tool part as a full
-        // snapshot as the args parse: DeepSeek sends `input: {}` on the early `pending`/`running` frame
-        // and the full args on a later one (captured on opencode 1.17: `pending {}` → `running {full}` →
-        // `completed {full}`). `start` fires off the first (empty) frame — the live card — but `done`
-        // (and the row it upserts) must carry the latest non-empty input and its summary. Every other
-        // tool fixture bakes the full input into the first snapshot, so only this one catches it.
-        name: "streaming tool input \u2014 late args refresh the done event (CT301)",
-        request: makeRequest2(),
-        nativeStream: [
-          toolPart("t1", "cabane_list", { status: "pending", input: {} }, "call_1"),
-          toolPart(
-            "t1",
-            "cabane_list",
-            { status: "running", input: { path: "/product/tasks" } },
-            "call_1"
-          ),
-          toolPart(
-            "t1",
-            "cabane_list",
-            { status: "completed", input: { path: "/product/tasks" }, output: "CT301.md" },
-            "call_1"
-          ),
-          idle()
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          // start: fires off the first (empty) snapshot — empty input + summary, by design.
-          {
-            type: "tool",
-            id: "call_1",
-            name: "cabane_list",
-            phase: "start",
-            summary: "",
-            input: {},
-            mcpServer: "cabane"
-          },
-          // done: carries the full args captured from the later snapshot, and the
-          // summary recomputed from them — NOT the first-seen `{}`.
-          {
-            type: "tool",
-            id: "call_1",
-            name: "cabane_list",
-            phase: "done",
-            summary: "/product/tasks",
-            input: { path: "/product/tasks" },
-            result: "CT301.md",
-            mcpServer: "cabane"
-          },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // The turn-control server's `answer` (CT1973). opencode names an MCP tool `<server>_<tool>`,
-        // so the installed keys split the raw id: `cabane_companion_answer` is the turn-control
-        // server's, never the workspace server's `companion_answer`. The pump binds on that.
-        name: "turn-control answer is read as the turn-control server\u2019s, not cabane\u2019s",
-        request: makeRequest2({
-          cabane: {
-            mcpUrl: "https://cabane.test/api/mcp",
-            turnControlUrl: "https://cabane.test/api/turn-control",
-            bearer: "tok",
-            activeConversationId: "conv"
-          }
-        }),
-        nativeStream: [
-          textPart("p1", "On it."),
-          toolPart("t1", "cabane_companion_answer", { status: "running", input: {} }, "call_1"),
-          toolPart(
-            "t1",
-            "cabane_companion_answer",
-            { status: "completed", input: {}, output: '{"ok":true,"kind":"answer"}' },
-            "call_1"
-          ),
-          textPart("p2", "The answer."),
-          idle()
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "text", body: "On it.", terminal: false },
-          {
-            type: "tool",
-            id: "call_1",
-            name: "cabane_companion_answer",
-            phase: "start",
-            summary: "",
-            input: {},
-            mcpServer: "cabane_companion"
-          },
-          {
-            type: "tool",
-            id: "call_1",
-            name: "cabane_companion_answer",
-            phase: "done",
-            summary: "",
-            input: {},
-            result: '{"ok":true,"kind":"answer"}',
-            mcpServer: "cabane_companion"
-          },
-          { type: "text", body: "The answer.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Highest risk: cancel mid-stream. The abort lands after the tool result; the adapter stops before
-        // the closing reply — no final text, no `result` event (the server writes the stopped marker).
-        name: "cancel mid-stream",
-        request: makeRequest2(),
-        nativeStream: [
-          textPart("p1", "Working on it."),
-          toolPart("t1", "list", { status: "running", input: {} }, "call_1"),
-          toolPart("t1", "list", { status: "completed", input: {}, output: "ok" }, "call_1"),
-          ABORT_SENTINEL2,
-          textPart("p2", "This reply must never be emitted."),
-          idle()
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "text", body: "Working on it.", terminal: false },
-          { type: "tool", id: "call_1", name: "list", phase: "start", summary: "", input: {} },
-          {
-            type: "tool",
-            id: "call_1",
-            name: "list",
-            phase: "done",
-            summary: "",
-            input: {},
-            result: "ok"
-          }
-        ]
-      },
-      {
-        // An error result: partial narration lands as `progress` (terminal:false),
-        // and the `result` event carries the machine reason.
-        name: "error result",
-        request: makeRequest2(),
-        nativeStream: [textPart("p1", "Partial work."), errored("provider exploded")],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "text", body: "Partial work.", terminal: false },
-          { type: "runtime_notice", body: "provider exploded" },
-          { type: "result", ok: false, reason: "error:provider exploded" }
-        ]
-      },
-      {
-        // A provider 429 throttle. The wrapped `RateLimitError` is unwrapped by `readSessionError` and
-        // text-classified: a bare "rate limit (429)" with no cap noun is the throttle (`rate_limited`),
-        // not the account cap.
-        name: "provider 429 \u2192 rate_limited (throttle, no reset)",
-        request: makeRequest2(),
-        nativeStream: [
-          {
-            type: "session.error",
-            properties: { error: { name: "RateLimitError", message: "rate limit exceeded (429)" } }
-          }
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "runtime_notice", body: "RateLimitError: rate limit exceeded (429)" },
-          { type: "result", ok: false, reason: "rate_limited" }
-        ]
-      },
-      {
-        // A subscription cap surfaced as text ("usage limit reached") → `usage_capped`. opencode carries
-        // no reset hint, so it's reset-less (the server says "try again later").
-        name: "usage cap text \u2192 usage_capped (no reset)",
-        request: makeRequest2(),
-        nativeStream: [
-          {
-            type: "session.error",
-            properties: { error: { name: "Error", message: "Claude usage limit reached" } }
-          }
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "runtime_notice", body: "Claude usage limit reached" },
-          { type: "result", ok: false, reason: "usage_capped" }
-        ]
-      },
-      {
-        // A transient provider outage (5xx / overload) surfaced as text → `server_error`, never the cap.
-        name: "provider overload text \u2192 server_error",
-        request: makeRequest2(),
-        nativeStream: [
-          {
-            type: "session.error",
-            properties: {
-              error: { name: "Error", message: "AI_APICallError: overloaded_error (529)" }
-            }
-          }
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "runtime_notice", body: "AI_APICallError: overloaded_error (529)" },
-          { type: "result", ok: false, reason: "server_error" }
-        ]
-      },
-      {
-        // An expired or invalid credential classifies as `auth_expired`.
-        name: "auth failure \u2192 auth_expired",
-        request: makeRequest2(),
-        nativeStream: [
-          {
-            type: "session.error",
-            properties: { error: { name: "AuthenticationError", message: "HTTP 401 Unauthorized" } }
-          }
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "runtime_notice", body: "AuthenticationError: HTTP 401 Unauthorized" },
-          { type: "result", ok: false, reason: "auth_expired" }
-        ]
-      },
-      {
-        // An unclassified failure stays informative: its provider text is visible, and the raw machine
-        // reason is unchanged.
-        name: "unclassified failure keeps a runtime notice and raw reason",
-        request: makeRequest2(),
-        nativeStream: [errored("something local broke")],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "runtime_notice", body: "something local broke" },
-          { type: "result", ok: false, reason: "error:something local broke" }
-        ]
-      },
-      {
-        name: "runtime notice is trimmed and bounded to 200 characters",
-        request: makeRequest2(),
-        nativeStream: [errored(`  ${BOUNDED_NOTICE}${"y".repeat(20)}  `)],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "runtime_notice", body: BOUNDED_NOTICE },
-          { type: "result", ok: false, reason: "usage_capped" }
-        ]
-      },
-      {
-        // Empty, whitespace-only and bare status-token failures still set the machine reason but add no
-        // empty or unhelpful transcript notice.
-        name: "empty failure text emits no runtime notice",
-        request: makeRequest2(),
-        nativeStream: [errored("")],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "result", ok: false, reason: "error:unknown" }
-        ]
-      },
-      {
-        name: "whitespace-only failure text emits no runtime notice",
-        request: makeRequest2(),
-        nativeStream: [errored("   ")],
-        expected: [sessionEvent2(NEW_SESSION_ID), { type: "result", ok: false, reason: "error:   " }]
-      },
-      {
-        name: "bare status token emits no runtime notice",
-        request: makeRequest2(),
-        nativeStream: [errored("429")],
-        expected: [sessionEvent2(NEW_SESSION_ID), { type: "result", ok: false, reason: "rate_limited" }]
-      },
-      {
-        name: "single-word provider sentence emits a runtime notice",
-        request: makeRequest2(),
-        nativeStream: [errored("Unavailable.")],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "runtime_notice", body: "Unavailable." },
-          { type: "result", ok: false, reason: "error:Unavailable." }
-        ]
-      },
-      {
-        // The zero-content success the claude-code suite pins, in opencode's vocabulary — the session
-        // goes idle having emitted no part. No opencode sample has been seen; the fixture exists because
-        // the host's classification is runtime-neutral, so a runtime that can produce this envelope must
-        // be shown producing it in the shape the classifier reads.
-        name: "zero-content success (empty runtime result)",
-        request: makeRequest2(),
-        nativeStream: [idle()],
-        expected: [sessionEvent2(NEW_SESSION_ID), { type: "result", ok: true }]
-      },
-      {
-        // Empty-final: a clean turn that ended on a tool call with no closing text.
-        // The adapter emits NO final text — empty-final promotion is host/pump
-        // territory (this fixture pins that boundary).
-        name: "empty-final (no closing text)",
-        request: makeRequest2(),
-        nativeStream: [
-          toolPart("t1", "write", { status: "running", input: { path: "a.md" } }, "call_1"),
-          toolPart("t1", "write", { status: "completed", input: { path: "a.md" } }, "call_1"),
-          idle()
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          {
-            type: "tool",
-            id: "call_1",
-            name: "write",
-            phase: "start",
-            summary: "a.md",
-            input: { path: "a.md" }
-          },
-          {
-            type: "tool",
-            id: "call_1",
-            name: "write",
-            phase: "done",
-            summary: "a.md",
-            input: { path: "a.md" },
-            result: void 0
-          },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Thinking: a reasoning part seals as a transient `thinking` when the reply
-        // text supersedes it; the text is the final.
-        name: "thinking then reply",
-        request: makeRequest2(),
-        nativeStream: [
-          reasoningPart("r1", "Let me check the notes."),
-          textPart("p1", "All set."),
-          idle()
-        ],
-        expected: [
-          sessionEvent2(NEW_SESSION_ID),
-          { type: "thinking", text: "Let me check the notes." },
-          { type: "text", body: "All set.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // The stored state matches the directory, so the adapter resumes its id and the transport reports
-        // `created:false` on the same id — no session event fires. Resume is what carries cross-turn
-        // memory.
-        name: "session resume (no re-emit on echo)",
-        request: makeRequest2({ session: encodeSession2({ sessionId: "s1", directory: DIR }) }),
-        nativeStream: [textPart("p1", "Back again."), idle()],
-        expected: [
-          { type: "text", body: "Back again.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // On resume, as on a fresh turn, the decoder learns the user-message id from the stream:
-        // `message.updated` user frame precedes the echoed part — and drops the echo, so the injected
-        // per-turn context can't leak into Steps. Only the reply surfaces; no session event.
-        name: "session resume \u2014 prompt echo filtered via stream-derived user id",
-        request: makeRequest2({ session: encodeSession2({ sessionId: "s1", directory: DIR }) }),
-        nativeStream: [
-          messageUpdated("user", "msg_u1"),
-          echoedUserPart("up1", "msg_u1", "INJECTED CONTEXT \u2014 must not leak"),
-          messageUpdated("assistant", "msg_a1"),
-          echoedUserPart("ap1", "msg_a1", "The real reply."),
-          idle()
-        ],
-        expected: [
-          { type: "text", body: "The real reply.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Directory-mismatch degrade: the stored state was created under another directory, so the
-        // adapter starts fresh — the transport creates a new session, and the session event records the
-        // current directory.
-        name: "session directory-mismatch degrades to fresh",
-        request: makeRequest2({ session: encodeSession2({ sessionId: "old", directory: "/env/gone" }) }),
-        nativeStream: [textPart("p1", "Fresh start."), idle()],
-        expected: [
-          // The degrade is flagged on the session event so the host relays it on settle and the server
-          // rewinds the catch-up mark, recovering context the discarded session dropped.
-          sessionEvent2(NEW_SESSION_ID, DIR, true),
-          { type: "text", body: "Fresh start.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      }
-    ];
-  }
-});
-
 // packages/agent-runtime/src/codex/addendum.ts
 var CODEX_ADDENDUM;
 var init_addendum3 = __esm({
@@ -5906,7 +4865,7 @@ var init_loop3 = __esm({
 });
 
 // packages/agent-runtime/src/codex/policy.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 function codexSandboxMode(local) {
   return local.codex?.configSetsSandboxMode ? null : "danger-full-access";
 }
@@ -5919,8 +4878,8 @@ var init_policy3 = __esm({
   "packages/agent-runtime/src/codex/policy.ts"() {
     "use strict";
     CODEX_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
-    codexDialectSchema = z12.object({
-      modelReasoningEffort: z12.enum(CODEX_REASONING_EFFORTS).optional()
+    codexDialectSchema = z11.object({
+      modelReasoningEffort: z11.enum(CODEX_REASONING_EFFORTS).optional()
     }).loose();
   }
 });
@@ -6248,7 +5207,7 @@ function createCodexAdapter(deps = {}) {
       let threadUsageBaseline = "resume" in decision ? decision.usageBaseline : null;
       if ("fresh" in decision && decision.reason === "cwd_mismatch") {
         deps.onWarn?.(
-          "codex adapter: stored session directory no longer matches the current environment \u2014 starting a fresh thread (SJ527-analogue guard)",
+          "codex adapter: stored session directory no longer matches the current environment \u2014 starting a fresh thread",
           { directory }
         );
       }
@@ -6293,1114 +5252,119 @@ function createCodexAdapter(deps = {}) {
         if (imageUrls.length > 0) {
           if (!deps.prepareImages) {
             deps.onWarn?.(
-              "codex adapter: no image preparer wired on this host \u2014 the turn runs without its images (CT1757)",
+              "codex adapter: no image preparer wired on this host \u2014 the turn runs without its images",
               { images: imageUrls.length }
             );
           } else {
             try {
               images = await deps.prepareImages(imageUrls, signal);
-            } catch (err) {
-              if (!signal.aborted) {
-                deps.onWarn?.(
-                  "codex adapter: preparing the images failed \u2014 the turn runs without them (CT1757)",
-                  { err: err instanceof Error ? err.message : String(err) }
-                );
-              }
-            }
-          }
-          if (signal.aborted) return;
-        }
-        for (; ; ) {
-          const spec = buildRunSpec2(req, resumeThreadId, threadStanding, images?.paths ?? []);
-          if (spec.model === null) {
-            deps.onWarn?.("Codex is using its default model because no model was resolved", {
-              model: req.config.model
-            });
-          }
-          let emitted = false;
-          try {
-            const result = await transport.run(spec, signal);
-            if (signal.aborted) return;
-            for await (const event of decodeCodexStream(result.events, {
-              signal,
-              cwd: req.local.cwd,
-              resumedThreadId: resumeThreadId,
-              degraded,
-              // Which segments the thread carries once this turn lands. A segment sent is that one —
-              // the later copy is what the model reads. One withheld is what the thread had. Read off
-              // the spec, so the record can't disagree with what was sent.
-              promptFingerprint: spec.preamble.core ? spec.fingerprints.core : threadStanding?.core ?? null,
-              conversationFingerprint: spec.preamble.conversation ? spec.fingerprints.conversation : threadStanding?.conversation ?? null,
-              compactions,
-              // What the thread held before this turn, for the write at `thread.started`.
-              heldStanding: {
-                promptFingerprint: threadStanding?.core ?? null,
-                conversationFingerprint: threadStanding?.conversation ?? null,
-                compactions: threadStanding ? compactions : null
-              },
-              storedState: req.session,
-              usageBaseline: threadUsageBaseline,
-              // Codex reports no model in-stream, so record what the thread was started with (null on the
-              // default token). Same for the reasoning effort.
-              resolvedModel: spec.model,
-              resolvedReasoningEffort: spec.modelReasoningEffort ?? null
-            })) {
-              emitted = true;
-              yield event;
-            }
-            return;
-          } catch (err) {
-            if (resumeThreadId === null || emitted || signal.aborted || !isMissingRollout(err)) {
-              throw err;
-            }
-            deps.onWarn?.(
-              "codex adapter: the stored thread has no rollout on this host \u2014 starting a fresh thread",
-              { threadId: resumeThreadId }
-            );
-            resumeThreadId = null;
-            threadUsageBaseline = null;
-            threadStanding = null;
-            compactions = 0;
-            req = { ...req, session: null };
-            degraded = true;
-            if (hooks?.fresh) {
-              const recomposed = await hooks.fresh("session_start_failed");
-              if (signal.aborted) return;
-              if (recomposed) {
-                req = { ...req, ...recomposed, session: null };
-                degraded = false;
-              }
-            }
-          }
-        }
-      } finally {
-        if (images) {
-          try {
-            await images.cleanup();
-          } catch (err) {
-            deps.onWarn?.("codex adapter: image cleanup failed (CT1757)", {
-              err: err instanceof Error ? err.message : String(err)
-            });
-          }
-        }
-      }
-    }
-  };
-}
-var codexAdapter;
-var init_codex = __esm({
-  "packages/agent-runtime/src/codex/index.ts"() {
-    "use strict";
-    init_addendum3();
-    init_loop3();
-    init_policy3();
-    init_run_spec2();
-    init_session3();
-    init_transport2();
-    init_addendum3();
-    init_loop3();
-    init_policy3();
-    init_model3();
-    init_run_spec2();
-    init_transport2();
-    init_session3();
-    init_events2();
-    codexAdapter = createCodexAdapter();
-  }
-});
-
-// packages/agent-runtime/src/codex/conformance.ts
-function makeRequest3(overrides2 = {}) {
-  return {
-    systemPrompt: PROMPT,
-    prompt: "hi there",
-    content: [{ type: "text", text: "hi there" }],
-    // The resolved model and reasoning effort ride the terminal `result` off the run spec's model.
-    // Behavioural fixtures use the model-less token (no `resolvedModel` emitted); a dedicated capture
-    // fixture sets a real model and effort.
-    config: { model: null },
-    session: null,
-    cabane: { mcpUrl: "https://cabane.test/api/mcp", bearer: "tok", activeConversationId: "conv" },
-    local: { cwd: DIR2 },
-    extra: { mcpServers: {} },
-    ...overrides2
-  };
-}
-var ABORT_SENTINEL3, NEW_THREAD_ID, BOUNDED_NOTICE2, DIR2, PROMPT, threadStarted, agentMessage, reasoning, toolFrame, turnCompleted, turnFailed, fatalError, errorItem, OP_SUCCESS, OP_FAILURE, startedSession, closingSession, CODEX_CONFORMANCE_FIXTURES;
-var init_conformance4 = __esm({
-  "packages/agent-runtime/src/codex/conformance.ts"() {
-    "use strict";
-    init_codex();
-    init_session3();
-    ABORT_SENTINEL3 = { __abortHere: true };
-    NEW_THREAD_ID = "th_new";
-    BOUNDED_NOTICE2 = "You've hit your usage limit \xB7 ".padEnd(200, "x");
-    DIR2 = "/env/here";
-    PROMPT = "system";
-    threadStarted = (threadId) => ({
-      type: "thread.started",
-      thread_id: threadId
-    });
-    agentMessage = (id, text) => ({
-      type: "item.completed",
-      item: { id, type: "agent_message", text }
-    });
-    reasoning = (id, text) => ({
-      type: "item.completed",
-      item: { id, type: "reasoning", text }
-    });
-    toolFrame = (evType, item) => ({ type: evType, item });
-    turnCompleted = (usage) => ({
-      type: "turn.completed",
-      ...usage ? { usage } : {}
-    });
-    turnFailed = (message2) => ({
-      type: "turn.failed",
-      error: { message: message2 }
-    });
-    fatalError = (message2) => ({ type: "error", message: message2 });
-    errorItem = (id, message2) => ({
-      type: "item.completed",
-      item: { id, type: "error", message: message2 }
-    });
-    OP_SUCCESS = { ok: true, result: { source: "native" } };
-    OP_FAILURE = {
-      ok: false,
-      error: {
-        kind: "output_too_large",
-        code: "output_too_large",
-        message: "files.read returned more than the result ceiling"
-      }
-    };
-    startedSession = (threadId, cwd = DIR2, degraded = false) => ({
-      type: "session",
-      state: encodeSession3({ threadId, cwd, promptFingerprint: null, usageBaseline: null }),
-      ...degraded ? { degraded: true } : {}
-    });
-    closingSession = (threadId, usageBaseline = null) => ({
-      type: "session",
-      state: encodeSession3({
-        threadId,
-        cwd: DIR2,
-        promptFingerprint: fingerprintPrompt(PROMPT),
-        usageBaseline,
-        compactions: 0
-      })
-    });
-    CODEX_CONFORMANCE_FIXTURES = [
-      {
-        // A plain text reply: the held agent message seals as the terminal final at `turn.completed`;
-        // usage rides the `result`.
-        //
-        // The counters nest — `cached_input_tokens` is a slice of `input_tokens`,
-        // `reasoning_output_tokens` a slice of `output_tokens` — so input is 100 (not 120) and output 50
-        // (not 60), with the cache read broken out beside them.
-        name: "clean turn",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          agentMessage("m1", "Hello there."),
-          turnCompleted({
-            input_tokens: 100,
-            cached_input_tokens: 20,
-            cache_write_input_tokens: 5,
-            output_tokens: 50,
-            reasoning_output_tokens: 10
-          })
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "text", body: "Hello there.", terminal: true },
-          // The closing session write — the thread's ending totals, recorded as the baseline the next turn
-          // subtracts. A fresh thread, so the `result` usage below is the frame verbatim.
-          closingSession(NEW_THREAD_ID, {
-            inputTokens: 100,
-            outputTokens: 50,
-            cacheReadTokens: 20,
-            cacheCreationTokens: 5
-          }),
-          {
-            type: "result",
-            ok: true,
-            usage: {
-              inputTokens: 100,
-              outputTokens: 50,
-              cacheReadTokens: 20,
-              cacheCreationTokens: 5
-            }
-          }
-        ]
-      },
-      {
-        // Narration + an MCP tool call + result + closing reply. The narration message
-        // is sealed as interim (a tool follows it); the trailing message is the final.
-        name: "tool turn",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          agentMessage("m1", "Reading your notes."),
-          toolFrame("item.started", {
-            id: "t1",
-            type: "mcp_tool_call",
-            server: "cabane",
-            tool: "read",
-            arguments: { path: "sleep.md" },
-            status: "in_progress"
-          }),
-          toolFrame("item.completed", {
-            id: "t1",
-            type: "mcp_tool_call",
-            server: "cabane",
-            tool: "read",
-            arguments: { path: "sleep.md" },
-            status: "completed",
-            result: { content: [{ type: "text", text: "sleep early" }] }
-          }),
-          agentMessage("m2", "Here's the summary."),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "text", body: "Reading your notes.", terminal: false },
-          {
-            type: "tool",
-            id: "t1",
-            name: "read",
-            mcpServer: "cabane",
-            phase: "start",
-            summary: "sleep.md",
-            input: { path: "sleep.md" }
-          },
-          {
-            type: "tool",
-            id: "t1",
-            name: "read",
-            mcpServer: "cabane",
-            phase: "done",
-            summary: "sleep.md",
-            input: { path: "sleep.md" },
-            result: [{ type: "text", text: "sleep early" }]
-          },
-          { type: "text", body: "Here's the summary.", terminal: true },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // The recorded MCP success shape: Codex exposes the text copy and the native object together;
-        // normalization must keep the object.
-        name: "MCP success prefers native structured content",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          toolFrame("item.started", {
-            id: "query-success",
-            type: "mcp_tool_call",
-            server: "cabane",
-            tool: "query",
-            arguments: { op: "files.read", args: { path: "/ABOUT.md" } },
-            status: "in_progress"
-          }),
-          toolFrame("item.completed", {
-            id: "query-success",
-            type: "mcp_tool_call",
-            server: "cabane",
-            tool: "query",
-            arguments: { op: "files.read", args: { path: "/ABOUT.md" } },
-            status: "completed",
-            result: {
-              content: [{ type: "text", text: JSON.stringify(OP_SUCCESS) }],
-              structured_content: OP_SUCCESS
-            }
-          }),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "tool",
-            id: "query-success",
-            name: "query",
-            mcpServer: "cabane",
-            phase: "start",
-            summary: "",
-            input: { op: "files.read", args: { path: "/ABOUT.md" } }
-          },
-          {
-            type: "tool",
-            id: "query-success",
-            name: "query",
-            mcpServer: "cabane",
-            phase: "done",
-            summary: "",
-            input: { op: "files.read", args: { path: "/ABOUT.md" } },
-            result: OP_SUCCESS
-          },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // MCP `isError` keeps the failed phase, while the raw camel-case structured payload survives
-        // instead of the generic `error` token.
-        name: "failed MCP call preserves structured receipt while remaining error phase",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          toolFrame("item.started", {
-            id: "query-failed",
-            type: "mcp_tool_call",
-            server: "cabane",
-            tool: "query",
-            arguments: { op: "files.read", args: { path: "/ABOUT.md" } },
-            status: "in_progress"
-          }),
-          toolFrame("item.completed", {
-            id: "query-failed",
-            type: "mcp_tool_call",
-            server: "cabane",
-            tool: "query",
-            arguments: { op: "files.read", args: { path: "/ABOUT.md" } },
-            status: "failed",
-            result: {
-              content: [{ type: "text", text: JSON.stringify(OP_FAILURE) }],
-              structuredContent: OP_FAILURE,
-              isError: true
-            },
-            error: { message: "error" }
-          }),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "tool",
-            id: "query-failed",
-            name: "query",
-            mcpServer: "cabane",
-            phase: "start",
-            summary: "",
-            input: { op: "files.read", args: { path: "/ABOUT.md" } }
-          },
-          {
-            type: "tool",
-            id: "query-failed",
-            name: "query",
-            mcpServer: "cabane",
-            phase: "error",
-            summary: "",
-            input: { op: "files.read", args: { path: "/ABOUT.md" } },
-            result: OP_FAILURE
-          },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // The turn-control server's `answer` (CT1973): the tool event carries the server Codex names
-        // beside the tool, which is what the pump binds the declaration to. A non-cabane server keeps
-        // its prefix on the card as before.
-        name: "turn-control answer carries its server",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          agentMessage("m1", "On it."),
-          toolFrame("item.completed", {
-            id: "answer-1",
-            type: "mcp_tool_call",
-            server: "cabane_companion",
-            tool: "answer",
-            arguments: {},
-            status: "completed",
-            result: { content: [{ type: "text", text: '{"ok":true,"kind":"answer"}' }] }
-          }),
-          agentMessage("m2", "The answer."),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "text", body: "On it.", terminal: false },
-          {
-            type: "tool",
-            id: "answer-1",
-            name: "cabane_companion.answer",
-            mcpServer: "cabane_companion",
-            phase: "start",
-            summary: "",
-            input: {}
-          },
-          {
-            type: "tool",
-            id: "answer-1",
-            name: "cabane_companion.answer",
-            mcpServer: "cabane_companion",
-            phase: "done",
-            summary: "",
-            input: {},
-            result: [{ type: "text", text: '{"ok":true,"kind":"answer"}' }]
-          },
-          { type: "text", body: "The answer.", terminal: true },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // A transport/tool failure with no MCP result payload still uses the real adapter error message,
-        // never `undefined`.
-        name: "failed MCP call without result keeps error message fallback",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          toolFrame("item.completed", {
-            id: "mcp-failed",
-            type: "mcp_tool_call",
-            server: "other",
-            tool: "lookup",
-            arguments: { q: "receipt" },
-            status: "failed",
-            result: { content: [], isError: true },
-            error: { message: "connection closed" }
-          }),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "tool",
-            id: "mcp-failed",
-            name: "other.lookup",
-            mcpServer: "other",
-            phase: "start",
-            summary: "receipt",
-            input: { q: "receipt" }
-          },
-          {
-            type: "tool",
-            id: "mcp-failed",
-            name: "other.lookup",
-            mcpServer: "other",
-            phase: "error",
-            summary: "receipt",
-            input: { q: "receipt" },
-            result: "connection closed"
-          },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // A connector's structured metadata beside an image-only MCP response: no image/base64 payload
-        // enters activity receipts.
-        name: "image-only MCP result remains empty despite structured metadata",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          toolFrame("item.completed", {
-            id: "mcp-image",
-            type: "mcp_tool_call",
-            server: "other",
-            tool: "render",
-            arguments: {},
-            status: "completed",
-            result: {
-              content: [{ type: "image", data: "base64-bytes", mimeType: "image/png" }],
-              structured_content: { image: "base64-bytes" }
-            }
-          }),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "tool",
-            id: "mcp-image",
-            name: "other.render",
-            mcpServer: "other",
-            phase: "start",
-            summary: "",
-            input: {}
-          },
-          {
-            type: "tool",
-            id: "mcp-image",
-            name: "other.render",
-            mcpServer: "other",
-            phase: "done",
-            summary: "",
-            input: {},
-            result: [{ type: "image", data: "base64-bytes", mimeType: "image/png" }]
-          },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // A streaming tool whose args arrive on a later snapshot: `item.started` carries
-        // empty args, `item.updated` fills them, `item.completed` finishes. The `start`
-        // fires off the first (empty) frame — that's the live card — but the `done` must
-        // carry the LATEST non-empty input + its recomputed summary, not the first `{}`.
-        name: "streaming tool input \u2014 late args refresh the done event",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          toolFrame("item.started", {
-            id: "t1",
-            type: "mcp_tool_call",
-            server: "cabane",
-            tool: "list",
-            arguments: {},
-            status: "in_progress"
-          }),
-          toolFrame("item.updated", {
-            id: "t1",
-            type: "mcp_tool_call",
-            server: "cabane",
-            tool: "list",
-            arguments: { path: "/product/tasks" },
-            status: "in_progress"
-          }),
-          toolFrame("item.completed", {
-            id: "t1",
-            type: "mcp_tool_call",
-            server: "cabane",
-            tool: "list",
-            arguments: { path: "/product/tasks" },
-            status: "completed",
-            result: { content: [{ type: "text", text: "CT481.md" }] }
-          }),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "tool",
-            id: "t1",
-            name: "list",
-            mcpServer: "cabane",
-            phase: "start",
-            summary: "",
-            input: {}
-          },
-          {
-            type: "tool",
-            id: "t1",
-            name: "list",
-            mcpServer: "cabane",
-            phase: "done",
-            summary: "/product/tasks",
-            input: { path: "/product/tasks" },
-            result: [{ type: "text", text: "CT481.md" }]
-          },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // web_search lifecycle. A `web_search` item carries no `status` — completion is signalled by the
-        // frame type (`item.started` → `item.completed`). The `start` fires off the first frame (empty
-        // query); the `done` must resolve off `item.completed` with the populated query, not stay
-        // "running".
-        name: "web_search lifecycle \u2014 completes off frame type, populated query on done",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          toolFrame("item.started", { id: "ws1", type: "web_search", query: "" }),
-          toolFrame("item.completed", { id: "ws1", type: "web_search", query: "best pizza in nyc" }),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "tool",
-            id: "ws1",
-            name: "web_search",
-            phase: "start",
-            summary: "",
-            input: { query: "" }
-          },
-          {
-            type: "tool",
-            id: "ws1",
-            name: "web_search",
-            phase: "done",
-            summary: "best pizza in nyc",
-            input: { query: "best pizza in nyc" }
-          },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // A non-text web action (`action.type: "other"`) legitimately completes with an empty query —
-        // Codex's own data. It must still resolve to `done`.
-        name: "web_search lifecycle \u2014 empty-query completion still resolves to done",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          toolFrame("item.started", { id: "ws2", type: "web_search", query: "" }),
-          toolFrame("item.completed", { id: "ws2", type: "web_search", query: "" }),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "tool",
-            id: "ws2",
-            name: "web_search",
-            phase: "start",
-            summary: "",
-            input: { query: "" }
-          },
-          {
-            type: "tool",
-            id: "ws2",
-            name: "web_search",
-            phase: "done",
-            summary: "",
-            input: { query: "" }
-          },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Highest risk: cancel mid-stream. The abort lands after the tool result; the adapter stops before
-        // the closing reply — no final text, no `result` event (the server writes the stopped marker).
-        name: "cancel mid-stream",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          agentMessage("m1", "Working on it."),
-          toolFrame("item.started", {
-            id: "t1",
-            type: "command_execution",
-            command: "ls",
-            status: "in_progress"
-          }),
-          toolFrame("item.completed", {
-            id: "t1",
-            type: "command_execution",
-            command: "ls",
-            aggregated_output: "ok",
-            exit_code: 0,
-            status: "completed"
-          }),
-          ABORT_SENTINEL3,
-          agentMessage("m2", "This reply must never be emitted."),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "text", body: "Working on it.", terminal: false },
-          {
-            type: "tool",
-            id: "t1",
-            name: "shell",
-            phase: "start",
-            summary: "ls",
-            input: { command: "ls" }
-          },
-          {
-            type: "tool",
-            id: "t1",
-            name: "shell",
-            phase: "done",
-            summary: "ls",
-            input: { command: "ls" },
-            result: { output: "ok", exit_code: 0 }
-          }
-        ]
-      },
-      {
-        // A failed turn: partial narration lands as `progress` (terminal:false), and the
-        // `result` event carries the machine reason off `turn.failed`.
-        name: "turn.failed result",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          agentMessage("m1", "Partial work."),
-          turnFailed("provider exploded")
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "text", body: "Partial work.", terminal: false },
-          { type: "runtime_notice", body: "provider exploded" },
-          { type: "result", ok: false, reason: "error:provider exploded" }
-        ]
-      },
-      {
-        // A fatal top-level `error` frame (distinct from `turn.failed`): held narration
-        // seals as interim, then a failed `result`.
-        name: "fatal stream error",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          agentMessage("m1", "Starting."),
-          fatalError("stream died")
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "text", body: "Starting.", terminal: false },
-          { type: "runtime_notice", body: "stream died" },
-          { type: "result", ok: false, reason: "error:stream died" }
-        ]
-      },
-      {
-        // The failure text goes through the shared classifier (Codex is text-only), so a provider 429 /
-        // outage / auth / cap failure splits into the honest taxonomy. One fixture per kind:
-        name: "turn.failed 429 \u2192 rate_limited (throttle)",
-        request: makeRequest3(),
-        nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("429 Too Many Requests")],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "runtime_notice", body: "429 Too Many Requests" },
-          { type: "result", ok: false, reason: "rate_limited" }
-        ]
-      },
-      {
-        name: "turn.failed overload \u2192 server_error",
-        request: makeRequest3(),
-        nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("503 Service Unavailable")],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "runtime_notice", body: "503 Service Unavailable" },
-          { type: "result", ok: false, reason: "server_error" }
-        ]
-      },
-      {
-        name: "turn.failed usage cap \u2192 usage_capped",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          turnFailed("You've hit your session limit \xB7 resets 8:20pm (UTC)")
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "runtime_notice",
-            body: "You've hit your session limit \xB7 resets 8:20pm (UTC)"
-          },
-          { type: "result", ok: false, reason: "usage_capped" }
-        ]
-      },
-      {
-        name: "turn.failed auth \u2192 auth_expired",
-        request: makeRequest3(),
-        nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("401 Unauthorized: invalid api key")],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "runtime_notice", body: "401 Unauthorized: invalid api key" },
-          { type: "result", ok: false, reason: "auth_expired" }
-        ]
-      },
-      {
-        // A failure text the classifier can't place keeps the raw `error:<text>` reason (the `unknown`
-        // fallback).
-        name: "turn.failed unclassified \u2192 raw error reason (unchanged)",
-        request: makeRequest3(),
-        nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("something local broke")],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "runtime_notice", body: "something local broke" },
-          { type: "result", ok: false, reason: "error:something local broke" }
-        ]
-      },
-      {
-        name: "runtime notice is trimmed and bounded to 200 characters",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          turnFailed(`  ${BOUNDED_NOTICE2}${"y".repeat(20)}  `)
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "runtime_notice", body: BOUNDED_NOTICE2 },
-          { type: "result", ok: false, reason: "usage_capped" }
-        ]
-      },
-      {
-        // Empty, whitespace-only and bare status-token failures still set the machine reason but add no
-        // empty or unhelpful transcript notice.
-        name: "empty failure text emits no runtime notice",
-        request: makeRequest3(),
-        nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("")],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "result", ok: false, reason: "error:unknown" }
-        ]
-      },
-      {
-        name: "whitespace-only failure text emits no runtime notice",
-        request: makeRequest3(),
-        nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("   ")],
-        expected: [startedSession(NEW_THREAD_ID), { type: "result", ok: false, reason: "error:   " }]
-      },
-      {
-        name: "bare status token emits no runtime notice",
-        request: makeRequest3(),
-        nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("429")],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "result", ok: false, reason: "rate_limited" }
-        ]
-      },
-      {
-        name: "single-word provider sentence emits a runtime notice",
-        request: makeRequest3(),
-        nativeStream: [threadStarted(NEW_THREAD_ID), turnFailed("Unavailable.")],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "runtime_notice", body: "Unavailable." },
-          { type: "result", ok: false, reason: "error:Unavailable." }
-        ]
-      },
-      {
-        // Fail loud on unknown model metadata. An unknown `--model` makes Codex emit an `error` item
-        // ("… Defaulting to fallback metadata …") and misbehave (the spurious tool call scripted after it
-        // must never be emitted). The adapter ends the turn when the signal lands, with a machine reason.
-        name: "unknown model metadata \u2192 fail loud (guard)",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          errorItem(
-            "e0",
-            "Model metadata for `gpt-5-codex` not found. Defaulting to fallback metadata; this can degrade performance and cause issues."
-          ),
-          // Everything after the guard fires must be dropped (the haywire the guard prevents).
-          toolFrame("item.started", {
-            id: "t1",
-            type: "web_search",
-            query: "anything",
-            status: "in_progress"
-          }),
-          agentMessage("m1", "This degraded reply must never be emitted."),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "result",
-            ok: false,
-            reason: "model_unavailable:Model metadata for `gpt-5-codex` not found. Defaulting to fallback metadata; this can degrade performance and cause issues."
-          }
-        ]
-      },
-      {
-        // A NON-metadata error item is non-fatal — it's skipped, and the turn proceeds
-        // to its normal reply (guard specificity: only the fallback-metadata phrase trips).
-        name: "non-metadata error item is skipped (non-fatal)",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          errorItem("e0", "a transient hiccup"),
-          agentMessage("m1", "All good now."),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "text", body: "All good now.", terminal: true },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // The zero-content success the claude-code suite pins, in Codex's vocabulary — the thread
-        // starts, the turn completes, nothing in between. No Codex sample has been seen; the fixture
-        // exists because the host's classification is runtime-neutral, so a runtime that can produce
-        // this envelope must be shown producing it in the shape the classifier reads.
-        name: "zero-content success (empty runtime result)",
-        request: makeRequest3(),
-        nativeStream: [threadStarted(NEW_THREAD_ID), turnCompleted()],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Empty-final: a clean turn that ended on a tool call with no closing message.
-        // The adapter emits NO final text — empty-final promotion is host/pump territory
-        // (this fixture pins that boundary).
-        name: "empty-final (no closing message)",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          toolFrame("item.started", {
-            id: "t1",
-            type: "file_change",
-            changes: [{ path: "a.md", kind: "add" }],
-            status: "in_progress"
-          }),
-          toolFrame("item.completed", {
-            id: "t1",
-            type: "file_change",
-            changes: [{ path: "a.md", kind: "add" }],
-            status: "completed"
-          }),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          {
-            type: "tool",
-            id: "t1",
-            name: "apply_patch",
-            phase: "start",
-            summary: "",
-            input: { changes: [{ path: "a.md", kind: "add" }] }
-          },
-          {
-            type: "tool",
-            id: "t1",
-            name: "apply_patch",
-            phase: "done",
-            summary: "",
-            input: { changes: [{ path: "a.md", kind: "add" }] },
-            result: [{ path: "a.md", kind: "add" }]
-          },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Thinking: a reasoning item seals as a transient `thinking`, then the reply
-        // message is the final.
-        name: "thinking then reply",
-        request: makeRequest3(),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          reasoning("r1", "Let me check the notes."),
-          agentMessage("m1", "All set."),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "thinking", text: "Let me check the notes." },
-          { type: "text", body: "All set.", terminal: true },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Codex reports no model in-stream, so the resolved model and reasoning effort come from what the
-        // thread was started with (the run spec) and ride the terminal `result`: a real model and a
-        // `runtimeOptions.codex.modelReasoningEffort` are asserted through to `resolvedModel` (bare,
-        // `openai/`-stripped) and `resolvedConfig.reasoningEffort`.
-        name: "resolved model + reasoning effort captured from run spec",
-        request: makeRequest3({
-          config: {
-            model: "openai/gpt-5-codex",
-            runtimeOptions: { codex: { modelReasoningEffort: "high" } }
+            } catch (err) {
+              if (!signal.aborted) {
+                deps.onWarn?.(
+                  "codex adapter: preparing the images failed \u2014 the turn runs without them",
+                  { err: err instanceof Error ? err.message : String(err) }
+                );
+              }
+            }
           }
-        }),
-        nativeStream: [threadStarted(NEW_THREAD_ID), agentMessage("m1", "Done."), turnCompleted()],
-        expected: [
-          startedSession(NEW_THREAD_ID),
-          { type: "text", body: "Done.", terminal: true },
-          closingSession(NEW_THREAD_ID),
-          {
-            type: "result",
-            ok: true,
-            resolvedModel: "gpt-5-codex",
-            resolvedConfig: { reasoningEffort: "high" }
+          if (signal.aborted) return;
+        }
+        for (; ; ) {
+          const spec = buildRunSpec2(req, resumeThreadId, threadStanding, images?.paths ?? []);
+          if (spec.model === null) {
+            deps.onWarn?.("Codex is using its default model because no model was resolved", {
+              model: req.config.model
+            });
           }
-        ]
-      },
-      {
-        // Session resume: the stored state matches the directory, so the thread id is resumed and
-        // `thread.started` echoes it — no session event fires. This is what carries cross-turn memory.
-        //
-        // The stored state also says the thread already holds the composed prompt, so this turn
-        // withholds the preamble and the state it would write is byte-identical: the silence proves both
-        // an unchanged id and a prompt that needed no re-send.
-        name: "session resume (no re-emit on echo)",
-        request: makeRequest3({
-          session: encodeSession3({
-            threadId: "th1",
-            cwd: DIR2,
-            promptFingerprint: fingerprintPrompt(PROMPT),
-            usageBaseline: null,
-            compactions: 0
-          })
-        }),
-        nativeStream: [threadStarted("th1"), agentMessage("m1", "Back again."), turnCompleted()],
-        expected: [
-          { type: "text", body: "Back again.", terminal: true },
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // A resumed thread whose stored state carries no `promptFingerprint` field. The adapter reads the
-        // absence as "can't say which prompt this thread holds", sends the full prompt, and re-emits the
-        // state with the fingerprint — on the same thread id. That re-emit is the upgrade path: without
-        // it a long-lived thread would re-send the whole prompt forever.
-        //
-        // This fixture fails if the standing half is withheld on a thread we have no evidence about.
-        name: "session resume with a pre-CT1075 state re-emits with the prompt fingerprint",
-        request: makeRequest3({
-          session: JSON.stringify({ threadId: "th1", cwd: DIR2 })
-        }),
-        nativeStream: [threadStarted("th1"), agentMessage("m1", "Back again."), turnCompleted()],
-        expected: [
-          startedSession("th1"),
-          { type: "text", body: "Back again.", terminal: true },
-          closingSession("th1"),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // The thread carries a different prompt than this turn composed — a charter edit, a renamed
-        // agent, a redeployed prompt body. The fingerprint doesn't match, so the new prompt is sent as on
-        // a fresh thread and the state re-recorded.
-        //
-        // This fixture fails if a stale prompt is treated as good enough; a boolean flag would pass the
-        // resume fixture above and withhold every future charter edit.
-        name: "session resume with a stale prompt fingerprint re-sends the prompt",
-        request: makeRequest3({
-          session: encodeSession3({
-            threadId: "th1",
-            cwd: DIR2,
-            promptFingerprint: fingerprintPrompt("an older composed prompt"),
-            usageBaseline: null
-          })
-        }),
-        nativeStream: [threadStarted("th1"), agentMessage("m1", "Back again."), turnCompleted()],
-        expected: [
-          startedSession("th1"),
-          { type: "text", body: "Back again.", terminal: true },
-          closingSession("th1"),
-          { type: "result", ok: true }
-        ]
-      },
-      {
-        // Directory-mismatch degrade: the stored state was created under another directory, so the
-        // adapter starts fresh — `thread.started` reports a new id, and the session event records the
-        // current directory with `degraded: true` so the host rewinds the catch-up mark.
-        //
-        // The refused resume means the new thread is empty, so the full prompt goes in even though the
-        // stored state vouched for a copy in a thread we're no longer in.
-        name: "session directory-mismatch degrades to fresh",
-        request: makeRequest3({
-          session: encodeSession3({
-            threadId: "old",
-            cwd: "/env/gone",
-            promptFingerprint: fingerprintPrompt(PROMPT),
-            usageBaseline: null
-          })
-        }),
-        nativeStream: [
-          threadStarted(NEW_THREAD_ID),
-          agentMessage("m1", "Fresh start."),
-          turnCompleted()
-        ],
-        expected: [
-          startedSession(NEW_THREAD_ID, DIR2, true),
-          { type: "text", body: "Fresh start.", terminal: true },
-          closingSession(NEW_THREAD_ID),
-          { type: "result", ok: true }
-        ]
+          let emitted = false;
+          try {
+            const result = await transport.run(spec, signal);
+            if (signal.aborted) return;
+            for await (const event of decodeCodexStream(result.events, {
+              signal,
+              cwd: req.local.cwd,
+              resumedThreadId: resumeThreadId,
+              degraded,
+              // Which segments the thread carries once this turn lands. A segment sent is that one —
+              // the later copy is what the model reads. One withheld is what the thread had. Read off
+              // the spec, so the record can't disagree with what was sent.
+              promptFingerprint: spec.preamble.core ? spec.fingerprints.core : threadStanding?.core ?? null,
+              conversationFingerprint: spec.preamble.conversation ? spec.fingerprints.conversation : threadStanding?.conversation ?? null,
+              compactions,
+              // What the thread held before this turn, for the write at `thread.started`.
+              heldStanding: {
+                promptFingerprint: threadStanding?.core ?? null,
+                conversationFingerprint: threadStanding?.conversation ?? null,
+                compactions: threadStanding ? compactions : null
+              },
+              storedState: req.session,
+              usageBaseline: threadUsageBaseline,
+              // Codex reports no model in-stream, so record what the thread was started with (null on the
+              // default token). Same for the reasoning effort.
+              resolvedModel: spec.model,
+              resolvedReasoningEffort: spec.modelReasoningEffort ?? null
+            })) {
+              emitted = true;
+              yield event;
+            }
+            return;
+          } catch (err) {
+            if (resumeThreadId === null || emitted || signal.aborted || !isMissingRollout(err)) {
+              throw err;
+            }
+            deps.onWarn?.(
+              "codex adapter: the stored thread has no rollout on this host \u2014 starting a fresh thread",
+              { threadId: resumeThreadId }
+            );
+            resumeThreadId = null;
+            threadUsageBaseline = null;
+            threadStanding = null;
+            compactions = 0;
+            req = { ...req, session: null };
+            degraded = true;
+            if (hooks?.fresh) {
+              const recomposed = await hooks.fresh("session_start_failed");
+              if (signal.aborted) return;
+              if (recomposed) {
+                req = { ...req, ...recomposed, session: null };
+                degraded = false;
+              }
+            }
+          }
+        }
+      } finally {
+        if (images) {
+          try {
+            await images.cleanup();
+          } catch (err) {
+            deps.onWarn?.("codex adapter: image cleanup failed", {
+              err: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
       }
-    ];
+    }
+  };
+}
+var codexAdapter;
+var init_codex = __esm({
+  "packages/agent-runtime/src/codex/index.ts"() {
+    "use strict";
+    init_addendum3();
+    init_loop3();
+    init_policy3();
+    init_run_spec2();
+    init_session3();
+    init_transport2();
+    init_addendum3();
+    init_loop3();
+    init_policy3();
+    init_model3();
+    init_run_spec2();
+    init_transport2();
+    init_session3();
+    init_events2();
+    codexAdapter = createCodexAdapter();
   }
 });
 
@@ -7424,17 +5388,13 @@ var init_src = __esm({
     init_failure();
     init_turn_request();
     init_standing();
-    init_conformance();
     init_transcript();
     init_transcript_sink();
     init_pump();
     init_claude_code();
-    init_conformance2();
     init_registry();
     init_opencode();
-    init_conformance3();
     init_codex();
-    init_conformance4();
     init_sdk();
   }
 });
@@ -7467,11 +5427,11 @@ function withDeviceOpencodeLock(inner, serverUrl, acquire) {
   };
 }
 function runnerOpencodeTransport(serverUrl, acquire, report) {
-  const fetchImpl = (input, init2) => {
+  const fetchImpl = (input, init) => {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
     const prompt = /\/session\/([^/]+)\/prompt_async$/.exec(new URL(url).pathname);
     if (prompt?.[1]) report(decodeURIComponent(prompt[1]));
-    return globalThis.fetch(input, init2);
+    return globalThis.fetch(input, init);
   };
   return withDeviceOpencodeLock(
     createHttpOpencodeTransport({ baseUrl: serverUrl, fetchImpl }),
@@ -7812,7 +5772,7 @@ var init_turn_containment = __esm({
 });
 
 // src/run-config.ts
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 function parseRunConfig(raw, onWarn) {
   const result = runConfigSchema.safeParse(raw ?? {});
   if (result.success) return result.data;
@@ -7825,43 +5785,43 @@ var mcpStdioServerSchema, mcpHttpServerSchema, mcpSseServerSchema, mcpServerDefS
 var init_run_config = __esm({
   "src/run-config.ts"() {
     "use strict";
-    mcpStdioServerSchema = z13.object({
-      type: z13.literal("stdio").optional(),
-      command: z13.string().min(1),
-      args: z13.array(z13.string()).optional(),
-      env: z13.record(z13.string(), z13.string()).optional(),
+    mcpStdioServerSchema = z12.object({
+      type: z12.literal("stdio").optional(),
+      command: z12.string().min(1),
+      args: z12.array(z12.string()).optional(),
+      env: z12.record(z12.string(), z12.string()).optional(),
       // Variable → the name of a `secretEnv` entry holding its value. Set by the server on a
       // room's shared browser, whose connect URL is a credential.
-      envFromEnv: z13.record(z13.string(), z13.string()).optional()
+      envFromEnv: z12.record(z12.string(), z12.string()).optional()
     });
-    mcpHttpServerSchema = z13.object({
-      type: z13.literal("http"),
-      url: z13.string().url(),
-      headers: z13.record(z13.string(), z13.string()).optional(),
+    mcpHttpServerSchema = z12.object({
+      type: z12.literal("http"),
+      url: z12.string().url(),
+      headers: z12.record(z12.string(), z12.string()).optional(),
       // Header → the name of a `secretEnv` entry holding its value. Set by
       // the server on a room connection's entry, and by `resolveMcpSecrets` on a
       // header whose `${VAR}` it resolved.
-      headersFromEnv: z13.record(z13.string(), z13.string()).optional()
+      headersFromEnv: z12.record(z12.string(), z12.string()).optional()
     });
-    mcpSseServerSchema = z13.object({
-      type: z13.literal("sse"),
-      url: z13.string().url(),
-      headers: z13.record(z13.string(), z13.string()).optional(),
+    mcpSseServerSchema = z12.object({
+      type: z12.literal("sse"),
+      url: z12.string().url(),
+      headers: z12.record(z12.string(), z12.string()).optional(),
       // Header → the name of a `secretEnv` entry holding its value. Set by
       // the server on a room connection's entry, and by `resolveMcpSecrets` on a
       // header whose `${VAR}` it resolved.
-      headersFromEnv: z13.record(z13.string(), z13.string()).optional()
+      headersFromEnv: z12.record(z12.string(), z12.string()).optional()
     });
-    mcpServerDefSchema = z13.union([mcpHttpServerSchema, mcpSseServerSchema, mcpStdioServerSchema]);
-    thinkingConfigSchema = z13.discriminatedUnion("type", [
-      z13.object({ type: z13.literal("adaptive") }),
-      z13.object({ type: z13.literal("enabled"), budgetTokens: z13.number().int().positive().optional() }),
-      z13.object({ type: z13.literal("disabled") })
+    mcpServerDefSchema = z12.union([mcpHttpServerSchema, mcpSseServerSchema, mcpStdioServerSchema]);
+    thinkingConfigSchema = z12.discriminatedUnion("type", [
+      z12.object({ type: z12.literal("adaptive") }),
+      z12.object({ type: z12.literal("enabled"), budgetTokens: z12.number().int().positive().optional() }),
+      z12.object({ type: z12.literal("disabled") })
     ]);
-    effortSchema = z13.enum(["low", "medium", "high", "xhigh", "max"]);
-    runConfigSchema = z13.object({
-      mcpServers: z13.record(z13.string(), mcpServerDefSchema).optional(),
-      model: z13.string().min(1).optional(),
+    effortSchema = z12.enum(["low", "medium", "high", "xhigh", "max"]);
+    runConfigSchema = z12.object({
+      mcpServers: z12.record(z12.string(), mcpServerDefSchema).optional(),
+      model: z12.string().min(1).optional(),
       thinking: thinkingConfigSchema.optional(),
       effort: effortSchema.optional()
     });
@@ -7870,7 +5830,7 @@ var init_run_config = __esm({
 });
 
 // src/runner/protocol.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 function required(env, name) {
   const value = env[name];
   if (!value) throw new Error(`runner: ${name} is not set`);
@@ -7969,61 +5929,61 @@ var init_protocol = __esm({
       transcriptDir: "CABANE_TRANSCRIPT_DIR",
       dedicatedRoot: "CABANE_WORK_ROOT_DEDICATED"
     };
-    runtimeHealthSchema = z14.object({
-      quotaState: z14.enum(["ok", "limited", "auth_expired", "unknown"]),
-      limitedUntil: z14.string().nullable(),
-      lastError: z14.string().nullable()
+    runtimeHealthSchema = z13.object({
+      quotaState: z13.enum(["ok", "limited", "auth_expired", "unknown"]),
+      limitedUntil: z13.string().nullable(),
+      lastError: z13.string().nullable()
     });
-    runnerSpecSchema = z14.object({
-      deviceId: z14.string().optional(),
+    runnerSpecSchema = z13.object({
+      deviceId: z13.string().optional(),
       // The launcher's boot id: the one its heartbeat carries, so a runner's lease
       // matches the device that holds it.
-      bootId: z14.string(),
-      workspaceId: z14.string(),
-      workspaceSlug: z14.string(),
-      agentId: z14.string(),
-      agentUsername: z14.string(),
-      agentName: z14.string(),
+      bootId: z13.string(),
+      workspaceId: z13.string(),
+      workspaceSlug: z13.string(),
+      agentId: z13.string(),
+      agentUsername: z13.string(),
+      agentName: z13.string(),
       local: localAgentConfigSchema,
       runConfig: runConfigSchema,
       // The device's `root`, resolved by the launcher: the pair directory the turn
       // stands in when nothing else names one lives under it (`work-dir.ts`).
-      workRoot: z14.string(),
-      opencodeServerUrl: z14.string().optional(),
-      claudeCodeAvailable: z14.boolean(),
-      codexAvailable: z14.boolean(),
-      idleTimeoutMs: z14.number().int().positive().optional(),
-      totalTimeoutMs: z14.number().int().positive().optional(),
-      leaseRenewalMs: z14.number().int().positive().optional(),
-      preparingRowDelayMs: z14.number().int().nonnegative().optional(),
+      workRoot: z13.string(),
+      opencodeServerUrl: z13.string().optional(),
+      claudeCodeAvailable: z13.boolean(),
+      codexAvailable: z13.boolean(),
+      idleTimeoutMs: z13.number().int().positive().optional(),
+      totalTimeoutMs: z13.number().int().positive().optional(),
+      leaseRenewalMs: z13.number().int().positive().optional(),
+      preparingRowDelayMs: z13.number().int().nonnegative().optional(),
       // Whether the turn writes a transcript, into the device's own directory
       // (`transcriptsDir()`).
-      transcripts: z14.boolean(),
-      logLevel: z14.string(),
+      transcripts: z13.boolean(),
+      logLevel: z13.string(),
       // The launcher's connector-health observations, by runtime, as of the start.
-      connectorHealth: z14.record(z14.string(), runtimeHealthSchema),
+      connectorHealth: z13.record(z13.string(), runtimeHealthSchema),
       // True when this (conversation, agent) pair was already told its session
       // could not be saved: the notice is once per pair, not once per process.
-      sessionWriteNoticeClaimed: z14.boolean(),
+      sessionWriteNoticeClaimed: z13.boolean(),
       // The runner's identity, minted with its credential. The start
       // PATCH carries it so the lease knows which runner holds the span.
-      runnerId: z14.string(),
+      runnerId: z13.string(),
       // Whether the server took gzip request bodies at the latest heartbeat, as of
       // the start. The launcher writes `gzip_bodies` when that changes mid-turn.
-      gzipBodies: z14.boolean().optional()
+      gzipBodies: z13.boolean().optional()
     });
-    dispatchSchema = z14.object({
-      type: z14.literal("device:dispatch_requested"),
-      agentId: z14.string(),
-      deviceId: z14.string(),
-      conversationId: z14.string(),
-      messageId: z14.string(),
-      episode: z14.number().int().optional()
+    dispatchSchema = z13.object({
+      type: z13.literal("device:dispatch_requested"),
+      agentId: z13.string(),
+      deviceId: z13.string(),
+      conversationId: z13.string(),
+      messageId: z13.string(),
+      episode: z13.number().int().optional()
     });
-    credentialsSchema = z14.object({
-      credential: z14.string().startsWith("cabrn_"),
-      secrets: z14.record(z14.string(), z14.string()).optional(),
-      grants: z14.record(z14.string(), z14.record(z14.string(), z14.string())).optional()
+    credentialsSchema = z13.object({
+      credential: z13.string().startsWith("cabrn_"),
+      secrets: z13.record(z13.string(), z13.string()).optional(),
+      grants: z13.record(z13.string(), z13.record(z13.string(), z13.string())).optional()
     });
   }
 });
@@ -8082,9 +6042,9 @@ var init_turn_responsiveness = __esm({
 });
 
 // src/grants.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join14 } from "path";
-import { z as z15 } from "zod";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { join as join12 } from "path";
+import { z as z14 } from "zod";
 function allowedGrantVariable(name) {
   return name.length <= 100 && VARIABLE_NAME_RE.test(name) && !name.startsWith("CABANE_");
 }
@@ -8092,7 +6052,7 @@ function environmentSafe(value) {
   return !value.includes("\0");
 }
 function grantsPath() {
-  return join14(cabaneDir(), "grants.json");
+  return join12(cabaneDir(), "grants.json");
 }
 function readGrants(keys, report) {
   if (keys.length === 0) return {};
@@ -8111,7 +6071,7 @@ function readGrants(keys, report) {
 }
 function loadGrantsFile(report) {
   const path = grantsPath();
-  if (!existsSync9(path)) return {};
+  if (!existsSync8(path)) return {};
   let raw;
   try {
     raw = readFileSync7(path, "utf8");
@@ -8167,15 +6127,15 @@ var init_grants = __esm({
     "use strict";
     init_config();
     VARIABLE_NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
-    grantsFileSchema = z15.record(z15.string(), z15.record(z15.string(), z15.string()));
+    grantsFileSchema = z14.record(z14.string(), z14.record(z14.string(), z14.string()));
   }
 });
 
 // src/work-dir.ts
 import { statSync as statSync3 } from "fs";
-import { join as join15 } from "path";
+import { join as join13 } from "path";
 function pairDirectory(root, pair) {
-  return join15(root, pair.workspaceSlug, pair.agentUsername, pair.conversationId);
+  return join13(root, pair.workspaceSlug, pair.agentUsername, pair.conversationId);
 }
 function chooseStandingDirectory(named, pairDir, isDirectory = directoryExists) {
   const skipped = [];
@@ -8200,7 +6160,7 @@ var init_work_dir = __esm({
 
 // src/turn-control-tools.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 function createSkipState() {
   return { skipped: false, reason: null };
 }
@@ -8251,7 +6211,7 @@ function createTurnControlMcpServer(acts, skipState) {
           SKIP_TURN_TOOL,
           TURN_CONTROL_TOOL_DESCRIPTIONS.skip_turn,
           {
-            reason: z16.string().min(1).max(MAX_SKIP_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.skip_turn.reason)
+            reason: z15.string().min(1).max(MAX_SKIP_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.skip_turn.reason)
           },
           async (args) => {
             skipState.skipped = true;
@@ -8267,22 +6227,22 @@ function createTurnControlMcpServer(acts, skipState) {
         ASK_TOOL,
         TURN_CONTROL_TOOL_DESCRIPTIONS.ask,
         {
-          targetUserId: z16.string().regex(ASK_TARGET_PATTERN, { error: ASK_TARGET_INVALID }).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.targetUserId),
-          question: z16.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.question),
-          headline: z16.string().min(1).max(MAX_ASK_HEADLINE_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.headline),
-          options: z16.array(z16.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.options),
-          questions: z16.array(
-            z16.object({
-              headline: z16.string().min(1).max(MAX_ASK_HEADLINE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.headline"]),
-              body: z16.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.body"]),
-              options: z16.array(
-                z16.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)
+          targetUserId: z15.string().regex(ASK_TARGET_PATTERN, { error: ASK_TARGET_INVALID }).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.targetUserId),
+          question: z15.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.question),
+          headline: z15.string().min(1).max(MAX_ASK_HEADLINE_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.headline),
+          options: z15.array(z15.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.options),
+          questions: z15.array(
+            z15.object({
+              headline: z15.string().min(1).max(MAX_ASK_HEADLINE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.headline"]),
+              body: z15.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.body"]),
+              options: z15.array(
+                z15.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)
               ).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.options"])
             })
           ).min(1).max(MAX_ASK_ITEMS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.questions),
-          replaces: z16.object({
-            askId: z16.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.askId"]),
-            reason: z16.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.reason"])
+          replaces: z15.object({
+            askId: z15.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.askId"]),
+            reason: z15.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.reason"])
           }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.replaces)
         },
         async (args) => {
@@ -8323,9 +6283,9 @@ function createTurnControlMcpServer(acts, skipState) {
         WAKE_ME_TOOL,
         TURN_CONTROL_TOOL_DESCRIPTIONS.wake_me,
         {
-          afterSeconds: z16.number().int().positive().optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.afterSeconds),
-          at: z16.string().datetime({ offset: true }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.at),
-          note: z16.string().min(1).max(MAX_WAKE_NOTE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.note)
+          afterSeconds: z15.number().int().positive().optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.afterSeconds),
+          at: z15.string().datetime({ offset: true }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.at),
+          note: z15.string().min(1).max(MAX_WAKE_NOTE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.note)
         },
         async (args) => {
           const hasAfter = args.afterSeconds !== void 0;
@@ -8359,8 +6319,8 @@ function createTurnControlMcpServer(acts, skipState) {
         WITHDRAW_ASK_TOOL,
         TURN_CONTROL_TOOL_DESCRIPTIONS.withdraw_ask,
         {
-          askId: z16.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.askId),
-          reason: z16.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.reason)
+          askId: z15.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.askId),
+          reason: z15.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.reason)
         },
         async (args) => performAct(acts, {
           kind: "withdraw_ask",
@@ -8464,17 +6424,17 @@ var init_build_options = __esm({
 });
 
 // src/codex-config.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { join as join16 } from "path";
+import { join as join14 } from "path";
 import { parse as parse2 } from "smol-toml";
 function codexConfigPath(env = process.env, home = homedir7()) {
-  return join16(env.CODEX_HOME || join16(home, ".codex"), "config.toml");
+  return join14(env.CODEX_HOME || join14(home, ".codex"), "config.toml");
 }
 async function readCodexConfigSetsSandboxMode(path = codexConfigPath()) {
   let text;
   try {
-    text = await readFile2(path, "utf8");
+    text = await readFile(path, "utf8");
   } catch {
     return false;
   }
@@ -8496,13 +6456,13 @@ var init_codex_config = __esm({
 // src/codex-images.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join17 } from "path";
+import { join as join15 } from "path";
 function createCodexImagePreparer(opts) {
   const doFetch = opts.fetch ?? fetch;
   const timeoutMs = opts.timeoutMs ?? FETCH_TIMEOUT_MS;
   return async (urls, signal) => {
     signal.throwIfAborted();
-    const dir2 = await mkdtemp(join17(tmpdir(), `cabane-codex-images-${opts.turnId}-`));
+    const dir2 = await mkdtemp(join15(tmpdir(), `cabane-codex-images-${opts.turnId}-`));
     const cleanup = async () => {
       try {
         await rm(dir2, { recursive: true, force: true });
@@ -8523,7 +6483,7 @@ function createCodexImagePreparer(opts) {
         const ext = EXTENSIONS[type];
         if (!ext) throw new Error(`not a vision image type: ${type || "none"}`);
         const bytes = new Uint8Array(await res.arrayBuffer());
-        const path = join17(dir2, `image-${index + 1}.${ext}`);
+        const path = join15(dir2, `image-${index + 1}.${ext}`);
         await writeFile(path, bytes, { mode: 384 });
         return path;
       } catch (err) {
@@ -8565,9 +6525,9 @@ var init_codex_images = __esm({
 import { createReadStream } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { join as join18 } from "path";
+import { join as join16 } from "path";
 import { createInterface as createInterface2 } from "readline";
-function createCodexCompactionCounter(codexHome = process.env.CODEX_HOME || join18(homedir8(), ".codex")) {
+function createCodexCompactionCounter(codexHome = process.env.CODEX_HOME || join16(homedir8(), ".codex")) {
   return async (threadId) => {
     try {
       const rollout = await findRollout(codexHome, threadId);
@@ -8584,7 +6544,7 @@ async function findRollout(codexHome, threadId) {
   const suffix = `-${threadId}.jsonl`;
   for (const offset of [0, -DAY_MS, DAY_MS]) {
     const day = new Date(createdAt + offset);
-    const dir2 = join18(
+    const dir2 = join16(
       codexHome,
       "sessions",
       String(day.getUTCFullYear()),
@@ -8598,7 +6558,7 @@ async function findRollout(codexHome, threadId) {
       continue;
     }
     const name = names.find((n) => n.startsWith("rollout-") && n.endsWith(suffix));
-    if (name) return join18(dir2, name);
+    if (name) return join16(dir2, name);
   }
   return null;
 }
@@ -8663,20 +6623,20 @@ var init_turn_seq_floor = __esm({
 });
 
 // src/prepared.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "fs";
-import { join as join19 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync9 } from "fs";
+import { join as join17 } from "path";
 function dirFor(workspaceId) {
-  return join19(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
+  return join17(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
 }
 function conversationDir(workspaceId, conversationId) {
-  return join19(dirFor(workspaceId), encodeURIComponent(conversationId));
+  return join17(dirFor(workspaceId), encodeURIComponent(conversationId));
 }
 function pathFor2(workspaceId, conversationId, agentId) {
-  return join19(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
+  return join17(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
 }
 function readPrepared(workspaceId, conversationId, agentId) {
   const path = pathFor2(workspaceId, conversationId, agentId);
-  if (!existsSync10(path)) return null;
+  if (!existsSync9(path)) return null;
   try {
     const parsed = JSON.parse(readFileSync8(path, "utf8"));
     if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
@@ -8709,15 +6669,15 @@ var init_prepared = __esm({
 });
 
 // src/secrets.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { join as join20 } from "path";
-import { z as z17 } from "zod";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { join as join18 } from "path";
+import { z as z16 } from "zod";
 function secretsPath() {
-  return join20(cabaneDir(), "secrets.json");
+  return join18(cabaneDir(), "secrets.json");
 }
 function loadSecretValues() {
   const path = secretsPath();
-  if (!existsSync11(path)) return {};
+  if (!existsSync10(path)) return {};
   let raw;
   try {
     raw = readFileSync9(path, "utf8");
@@ -8838,7 +6798,7 @@ var init_secrets = __esm({
     init_config();
     init_errors();
     PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
-    secretStoreSchema = z17.record(z17.string(), z17.string());
+    secretStoreSchema = z16.record(z16.string(), z16.string());
     SECRET_ENV_NAME = /^CABANE_MCP_(\d+)$/;
   }
 });
@@ -8870,9 +6830,9 @@ var init_turn_env = __esm({
 
 // 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 join21 } from "path";
+import { basename as basename3, dirname as dirname6, join as join19 } from "path";
 function transcriptsDir() {
-  return join21(cabaneDir(), "transcripts");
+  return join19(cabaneDir(), "transcripts");
 }
 function fileName(meta) {
   const d = new Date(meta.ts);
@@ -8898,7 +6858,7 @@ function pruneOld(dir2, retain) {
   const drop = files.sort().slice(0, files.length - retain);
   for (const f of drop) {
     try {
-      rmSync6(join21(dir2, f), { force: true });
+      rmSync6(join19(dir2, f), { force: true });
     } catch {
     }
   }
@@ -8916,7 +6876,7 @@ var init_transcript_writer = __esm({
       onWarn;
       constructor(dir2, meta, onWarn) {
         this.onWarn = onWarn;
-        this.path = join21(dir2, fileName(meta));
+        this.path = join19(dir2, fileName(meta));
         try {
           mkdirSync8(dir2, { recursive: true });
           try {
@@ -8945,10 +6905,10 @@ var init_transcript_writer = __esm({
       preserveAnomaly() {
         if (this.broken) return;
         try {
-          const dir2 = join21(dirname7(this.path), "anomalies");
+          const dir2 = join19(dirname6(this.path), "anomalies");
           mkdirSync8(dir2, { recursive: true, mode: 448 });
           chmodSync4(dir2, 448);
-          const target = join21(dir2, basename3(this.path));
+          const target = join19(dir2, basename3(this.path));
           copyFileSync(this.path, target);
           chmodSync4(target, 384);
           pruneOld(dir2, ANOMALY_RETAIN);
@@ -9205,7 +7165,7 @@ var init_turn_runtime_integrity = __esm({
 
 // src/turn-execution.ts
 import { createHash as createHash2, randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync9 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync9 } from "fs";
 function resolveIdleTimeoutMs(override) {
   return override ?? DEFAULT_AGENT_IDLE_TIMEOUT_MS;
 }
@@ -9699,7 +7659,7 @@ var init_turn_execution = __esm({
         let hookEnv;
         if (prepareHook) {
           let cached2 = readPrepared(workspaceId, payload.conversationId, payload.agentId);
-          if (cached2 && !existsSync12(cached2.cwd)) {
+          if (cached2 && !existsSync11(cached2.cwd)) {
             turnLog.debug(
               { cwd: cached2.cwd },
               "dispatcher: the prepared directory is gone \u2014 re-running the prepare hook"
@@ -10297,7 +8257,7 @@ var init_turn_execution = __esm({
                   });
                   turnLog.debug(
                     { runtime: turnRuntime, limitedUntil: health.limitedUntil },
-                    "dispatcher: idle-timeout on a capped runtime \u2014 reclassified as usage_capped (CT639)"
+                    "dispatcher: idle-timeout on a capped runtime \u2014 reclassified as usage_capped"
                   );
                 }
               }
@@ -10432,7 +8392,7 @@ var init_turn_execution = __esm({
 
 // src/outbox.ts
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync2,
   readFileSync as readFileSync11,
@@ -10440,7 +8400,7 @@ import {
   rmSync as rmSync7,
   writeFileSync as writeFileSync6
 } from "fs";
-import { join as join22 } from "path";
+import { join as join20 } from "path";
 var MAX_ENTRIES, MAX_AGE_MS, Outbox;
 var init_outbox = __esm({
   "src/outbox.ts"() {
@@ -10458,10 +8418,10 @@ var init_outbox = __esm({
       // Resolved lazily (per call) so tests that swap HOME between
       // cases route writes at the right tmpdir.
       dir() {
-        return join22(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
+        return join20(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
       }
       fileFor(turnId, seq) {
-        return join22(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+        return join20(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
       }
       // Persist a commit for later draining. Atomic (temp file + rename) so a
       // concurrent `list()` never reads a half-written entry, then enforces the
@@ -10493,7 +8453,7 @@ var init_outbox = __esm({
       // wedging the drain.
       list() {
         const dir2 = this.dir();
-        if (!existsSync14(dir2)) return [];
+        if (!existsSync13(dir2)) return [];
         let names;
         try {
           names = readdirSync2(dir2);
@@ -10503,7 +8463,7 @@ var init_outbox = __esm({
         const entries = [];
         for (const name of names) {
           if (!name.endsWith(".json")) continue;
-          const full = join22(dir2, name);
+          const full = join20(dir2, name);
           try {
             const parsed = JSON.parse(readFileSync11(full, "utf8"));
             if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
@@ -10539,7 +8499,7 @@ var init_outbox = __esm({
       // different: it is positive evidence that nothing was ever queued here.
       maxSeqForTurn(turnId) {
         const dir2 = this.dir();
-        if (!existsSync14(dir2)) return 0;
+        if (!existsSync13(dir2)) return 0;
         const names = readdirSync2(dir2);
         const prefix = `${encodeURIComponent(turnId)}__`;
         let max = 0;
@@ -10559,7 +8519,7 @@ var init_outbox = __esm({
       }
       size() {
         const dir2 = this.dir();
-        if (!existsSync14(dir2)) return 0;
+        if (!existsSync13(dir2)) return 0;
         try {
           return readdirSync2(dir2).filter((n) => n.endsWith(".json")).length;
         } catch {
@@ -10610,7 +8570,7 @@ var init_outbox = __esm({
 
 // src/runner/exec-shim.ts
 import { chmodSync as chmodSync6, mkdirSync as mkdirSync18, mkdtempSync, rmSync as rmSync13, writeFileSync as writeFileSync11 } from "fs";
-import { join as join32 } from "path";
+import { join as join30 } from "path";
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -10620,10 +8580,10 @@ function createShimDir() {
   return {
     write(argv) {
       if (!dir2) {
-        mkdirSync18(join32(cabaneDir(), "runner"), { recursive: true });
-        dir2 = mkdtempSync(join32(cabaneDir(), "runner", "turn-"));
+        mkdirSync18(join30(cabaneDir(), "runner"), { recursive: true });
+        dir2 = mkdtempSync(join30(cabaneDir(), "runner", "turn-"));
       }
-      const path = join32(dir2, `exec-${++count}`);
+      const path = join30(dir2, `exec-${++count}`);
       writeFileSync11(path, `#!/bin/sh
 exec ${argv.map(shellQuote).join(" ")} "$@"
 `);
@@ -11491,12 +9451,12 @@ async function detectHarnesses(cfg, deps = {}) {
     );
     return version !== null ? { state: "usable", via: "serve", version, url } : { state: "not_running", url };
   };
-  const [claude, codex, serve2] = await Promise.all([
+  const [claude, codex, serve] = await Promise.all([
     bundled("claude-code"),
     bundled("codex"),
     opencode()
   ]);
-  return { "claude-code": claude, codex, opencode: serve2 };
+  return { "claude-code": claude, codex, opencode: serve };
 }
 function usableRuntimes(detection) {
   return HARNESS_RUNTIMES.filter((runtime) => detection[runtime].state === "usable");
@@ -12291,20 +10251,21 @@ function isDevicePaired() {
 init_config();
 init_cabane_command();
 import { randomUUID as randomUUID7 } from "crypto";
-import { fileURLToPath as fileURLToPath6 } from "url";
-
-// src/dashboard/server.ts
-init_errors();
-import { dirname as dirname6, join as join11 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { serve } from "@hono/node-server";
-import { Hono } from "hono";
+import { fileURLToPath as fileURLToPath5 } from "url";
 
-// src/dashboard/routes.ts
-import { openSync as openSync3, readSync, closeSync as closeSync2, fstatSync, existsSync as existsSync6 } from "fs";
-import { readFile } from "fs/promises";
-import { extname, join as join10, normalize } from "path";
-import { streamSSE } from "hono/streaming";
+// src/prereqs.ts
+init_config();
+init_bundled_binaries();
+function warnAboutHarnessReadiness(cfg, deps = {}) {
+  const resolveBundled = deps.resolveBundled ?? ((runtime) => resolveBundledBinary(runtime));
+  const warn = deps.warn ?? ((message2) => process.stderr.write(`${message2}
+`));
+  for (const runtime of ["claude-code", "codex"]) {
+    if (!harnessAllowed(cfg, runtime)) continue;
+    const resolution = resolveBundled(runtime);
+    if (resolution.status !== "present") warn(startupWarning(resolution));
+  }
+}
 
 // src/state.ts
 import { EventEmitter } from "events";
@@ -12540,231 +10501,6 @@ var CompanionStateHub = class {
   }
 };
 
-// src/dashboard/routes.ts
-var CONTENT_TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon"
-};
-function registerRoutes(app, deps) {
-  const { supervisor, hub, staticDir } = deps;
-  app.get("/", async (c) => {
-    const html = await readFile(join10(staticDir, "index.html"), "utf8");
-    return c.html(html);
-  });
-  app.get("/static/:file", async (c) => {
-    const file = c.req.param("file");
-    const safe2 = normalize(file).replace(/^(\.\.[/\\])+/, "");
-    const full = join10(staticDir, safe2);
-    if (!full.startsWith(staticDir) || !existsSync6(full)) return c.notFound();
-    const body = await readFile(full);
-    const type = CONTENT_TYPES[extname(full).toLowerCase()] ?? "application/octet-stream";
-    c.header("content-type", type);
-    return c.body(body);
-  });
-  app.get("/api/status", (c) => c.json(hub.statusJson()));
-  app.get("/api/dispatches", (c) => {
-    const limit = clampLimit(c.req.query("limit"), 20);
-    return c.json({ dispatches: hub.recentDispatches(limit).map(dispatchToWire) });
-  });
-  app.get("/api/logs", async (c) => {
-    const lines2 = clampLimit(c.req.query("lines"), 200, 1e3);
-    return c.json({ lines: tailFile(companionLogPath(), lines2) });
-  });
-  app.post("/api/settings", async (c) => {
-    const body = await readJson(c);
-    const patch = {};
-    if (body.logLevel === "warn" || body.logLevel === "info" || body.logLevel === "debug") {
-      patch.logLevel = body.logLevel;
-    }
-    if (typeof body.autoOpen === "boolean") patch.autoOpen = body.autoOpen;
-    supervisor.applySettings(patch);
-    return c.json({ ok: true, status: hub.statusJson() });
-  });
-  app.post("/api/control", async (c) => {
-    const body = await readJson(c);
-    const action = body.action;
-    if (action === "stop") {
-      setTimeout(() => void supervisor.requestStop(), 50);
-      return c.json({ ok: true, action: "stop" });
-    }
-    if (action === "restart") {
-      setTimeout(() => supervisor.requestRestart(), 50);
-      return c.json({ ok: true, action: "restart" });
-    }
-    if (action === "reload-config") {
-      supervisor.reloadConfig();
-      return c.json({ ok: true, action: "reload-config" });
-    }
-    if (action === "refresh") {
-      supervisor.refresh();
-      return c.json({ ok: true, action: "refresh" });
-    }
-    return c.json({ error: `unknown action "${String(action)}"` }, 400);
-  });
-  app.post("/api/harnesses/recheck", async (c) => {
-    await supervisor.redetect();
-    return c.json({ ok: true, status: hub.statusJson() });
-  });
-  app.get(
-    "/api/events",
-    (c) => streamSSE(c, async (stream) => {
-      await stream.writeSSE({ event: "status:changed", data: JSON.stringify(hub.statusJson()) });
-      const queue = [];
-      let wake = null;
-      const unsubscribe = hub.on((ev) => {
-        queue.push(ev);
-        wake?.();
-      });
-      stream.onAbort(() => {
-        unsubscribe();
-        wake?.();
-      });
-      while (!stream.aborted) {
-        if (queue.length === 0) {
-          await Promise.race([
-            new Promise((resolve2) => {
-              wake = resolve2;
-            }),
-            stream.sleep(25e3)
-          ]);
-          wake = null;
-        }
-        if (stream.aborted) break;
-        if (queue.length === 0) {
-          await stream.writeSSE({ event: "ping", data: "" });
-          continue;
-        }
-        const ev = queue.shift();
-        await stream.writeSSE({ event: ev.type, data: JSON.stringify(ev.data) });
-      }
-      unsubscribe();
-    })
-  );
-}
-async function readJson(c) {
-  try {
-    const parsed = await c.req.json();
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function clampLimit(raw, fallback, max = 200) {
-  if (!raw) return fallback;
-  const n = Number(raw);
-  if (!Number.isFinite(n) || n <= 0) return fallback;
-  return Math.min(Math.floor(n), max);
-}
-function tailFile(path, lines2) {
-  if (!existsSync6(path)) return [];
-  const MAX_BYTES = 256 * 1024;
-  let fd;
-  try {
-    fd = openSync3(path, "r");
-    const size = fstatSync(fd).size;
-    const start2 = Math.max(0, size - MAX_BYTES);
-    const len = size - start2;
-    if (len <= 0) return [];
-    const buf = Buffer.alloc(len);
-    readSync(fd, buf, 0, len, start2);
-    const text = buf.toString("utf8");
-    const all = text.split("\n");
-    if (start2 > 0 && all.length > 0) all.shift();
-    return all.filter((l) => l.length > 0).slice(-lines2);
-  } catch {
-    return [];
-  } finally {
-    if (fd !== void 0) closeSync2(fd);
-  }
-}
-
-// src/dashboard/server.ts
-var DEFAULT_PORT = 7474;
-var PORT_FALLBACK_SPAN = 10;
-function buildDashboardApp(deps) {
-  const app = new Hono();
-  app.onError((err, c) => {
-    if (err instanceof ApiError) {
-      const status2 = err.status >= 400 && err.status < 600 ? err.status : 502;
-      return c.json({ error: err.message }, status2);
-    }
-    if (err instanceof CompanionError) {
-      return c.json({ error: err.message }, 400);
-    }
-    return c.json({ error: err instanceof Error ? err.message : "internal error" }, 500);
-  });
-  registerRoutes(app, { ...deps, staticDir: resolveStaticDir() });
-  return app;
-}
-async function startDashboard(opts) {
-  const app = buildDashboardApp({ supervisor: opts.supervisor, hub: opts.hub });
-  const preferred = opts.port ?? DEFAULT_PORT;
-  let lastErr;
-  for (let port = preferred; port < preferred + PORT_FALLBACK_SPAN; port++) {
-    try {
-      const server = await listen(app, port);
-      const url = `http://127.0.0.1:${port}`;
-      return {
-        url,
-        port,
-        close: () => new Promise((resolve2) => {
-          server.close(() => resolve2());
-          server.closeAllConnections?.();
-        })
-      };
-    } catch (err) {
-      if (isAddrInUse(err)) {
-        lastErr = err;
-        continue;
-      }
-      throw err;
-    }
-  }
-  throw new CompanionError(
-    `couldn't bind the dashboard to any port in ${preferred}\u2013${preferred + PORT_FALLBACK_SPAN - 1} (all in use). Free one up or pass --port. (last error: ${lastErr instanceof Error ? lastErr.message : String(lastErr)})`
-  );
-}
-function listen(app, port) {
-  return new Promise((resolve2, reject) => {
-    let settled = false;
-    const server = serve({ fetch: app.fetch, hostname: "127.0.0.1", port }, () => {
-      if (!settled) {
-        settled = true;
-        resolve2(server);
-      }
-    });
-    server.on("error", (err) => {
-      if (!settled) {
-        settled = true;
-        reject(err);
-      }
-    });
-  });
-}
-function isAddrInUse(err) {
-  return Boolean(err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE");
-}
-function resolveStaticDir() {
-  return join11(dirname6(fileURLToPath4(import.meta.url)), "static");
-}
-
-// src/prereqs.ts
-init_config();
-init_bundled_binaries();
-function warnAboutHarnessReadiness(cfg, deps = {}) {
-  const resolveBundled = deps.resolveBundled ?? ((runtime) => resolveBundledBinary(runtime));
-  const warn = deps.warn ?? ((message2) => process.stderr.write(`${message2}
-`));
-  for (const runtime of ["claude-code", "codex"]) {
-    if (!harnessAllowed(cfg, runtime)) continue;
-    const resolution = resolveBundled(runtime);
-    if (resolution.status !== "present") warn(startupWarning(resolution));
-  }
-}
-
 // src/supervisor.ts
 init_errors();
 
@@ -12967,27 +10703,27 @@ init_config();
 init_config();
 import {
   chmodSync as chmodSync3,
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync4,
   renameSync as renameSync3,
   rmSync as rmSync4,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join12 } from "path";
+import { join as join10 } from "path";
 import { z as z5 } from "zod";
 var credentialMapSchema = z5.record(z5.string(), z5.string());
 function credentialsDir() {
-  return join12(cabaneDir(), "credentials");
+  return join10(cabaneDir(), "credentials");
 }
 function legacyPath() {
-  return join12(cabaneDir(), "credentials.json");
+  return join10(cabaneDir(), "credentials.json");
 }
 function devicePath(deviceId) {
-  return join12(credentialsDir(), `${deviceId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+  return join10(credentialsDir(), `${deviceId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
 }
 function read(path) {
-  if (!existsSync7(path)) return null;
+  if (!existsSync6(path)) return null;
   let raw;
   try {
     raw = readFileSync4(path, "utf8");
@@ -13052,23 +10788,23 @@ function pruneCredentials(deviceId, keepAgentIds) {
 }
 function clearCredentials() {
   rmSync4(credentialsDir(), { recursive: true, force: true });
-  if (existsSync7(legacyPath())) writeFileSync3(legacyPath(), "", { mode: 384 });
+  if (existsSync6(legacyPath())) writeFileSync3(legacyPath(), "", { mode: 384 });
 }
 
 // src/dispatch-dedupe.ts
 init_config();
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync4, existsSync as existsSync8 } from "fs";
-import { join as join13 } from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync4, existsSync as existsSync7 } from "fs";
+import { join as join11 } from "path";
 var MAX_IDS = 256;
 function dir(log2) {
-  return join13(cabaneDir(), log2);
+  return join11(cabaneDir(), log2);
 }
 function pathFor(log2, workspaceId) {
-  return join13(dir(log2), encodeURIComponent(workspaceId));
+  return join11(dir(log2), encodeURIComponent(workspaceId));
 }
 function readIds(log2, workspaceId) {
   const path = pathFor(log2, workspaceId);
-  if (!existsSync8(path)) return [];
+  if (!existsSync7(path)) return [];
   try {
     return readFileSync5(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
   } catch {
@@ -13101,15 +10837,15 @@ function markCompleted(workspaceId, eventId) {
 }
 var MAX_RESUME_ATTEMPTS = 3;
 function resumeDir() {
-  return join13(cabaneDir(), "resume-attempts");
+  return join11(cabaneDir(), "resume-attempts");
 }
 function resumePathFor(workspaceId) {
-  return join13(resumeDir(), encodeURIComponent(workspaceId));
+  return join11(resumeDir(), encodeURIComponent(workspaceId));
 }
 function readResumeCounts(workspaceId) {
   const out = /* @__PURE__ */ new Map();
   const path = resumePathFor(workspaceId);
-  if (!existsSync8(path)) return out;
+  if (!existsSync7(path)) return out;
   try {
     for (const line of readFileSync5(path, "utf8").split("\n")) {
       const trimmed = line.trim();
@@ -13140,16 +10876,16 @@ function bumpResumeAttempt(workspaceId, eventId) {
   return next;
 }
 function turnDir() {
-  return join13(cabaneDir(), "turns");
+  return join11(cabaneDir(), "turns");
 }
 function turnPathFor(workspaceId) {
-  return join13(turnDir(), encodeURIComponent(workspaceId));
+  return join11(turnDir(), encodeURIComponent(workspaceId));
 }
 var TURN_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function readTurnIds(workspaceId) {
   const out = /* @__PURE__ */ new Map();
   const path = turnPathFor(workspaceId);
-  if (!existsSync8(path)) return out;
+  if (!existsSync7(path)) return out;
   try {
     for (const line of readFileSync5(path, "utf8").split("\n")) {
       const trimmed = line.trim();
@@ -13827,7 +11563,7 @@ var Dispatcher = class {
 };
 
 // src/host-report.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 import { userInfo as userInfo2 } from "os";
 function inContainer(signals) {
   if (signals.dockerenv) return true;
@@ -13842,7 +11578,7 @@ function readContainerSignals() {
   } catch {
     cgroup = null;
   }
-  return { dockerenv: existsSync13("/.dockerenv"), cgroup, env: process.env };
+  return { dockerenv: existsSync12("/.dockerenv"), cgroup, env: process.env };
 }
 function osUser() {
   try {
@@ -14252,8 +11988,8 @@ init_transcript_writer();
 
 // src/updater.ts
 import { spawn as spawn6 } from "child_process";
-import { copyFileSync as copyFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync14, renameSync as renameSync9, rmSync as rmSync10 } from "fs";
-import { dirname as dirname11, join as join26 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync15, mkdirSync as mkdirSync14, renameSync as renameSync9, rmSync as rmSync10 } from "fs";
+import { dirname as dirname10, join as join24 } from "path";
 
 // src/boot-rule.ts
 import {
@@ -14265,7 +12001,7 @@ import {
   symlinkSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { dirname as dirname8, join as join23 } from "path";
+import { dirname as dirname7, join as join21 } from "path";
 var UNCONFIRMED_WINDOW_MS = 10 * 6e4;
 var MAX_STAGE_ATTEMPTS = 3;
 function superseded(pending, ...running) {
@@ -14289,7 +12025,7 @@ function rolledBackState(state, pending, reason, now) {
 // src/install-layout.ts
 init_config();
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync14,
   lstatSync,
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync13,
@@ -14299,32 +12035,32 @@ import {
   rmSync as rmSync9,
   symlinkSync as symlinkSync2
 } from "fs";
-import { dirname as dirname9, join as join24 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { dirname as dirname8, join as join22 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function versionsDir() {
-  return join24(cabaneDir(), "versions");
+  return join22(cabaneDir(), "versions");
 }
 function currentLink() {
-  return join24(cabaneDir(), "current");
+  return join22(cabaneDir(), "current");
 }
 function bootGuardPath() {
-  return join24(cabaneDir(), "boot-guard.mjs");
+  return join22(cabaneDir(), "boot-guard.mjs");
 }
 function pinnedNodeDir() {
-  return join24(cabaneDir(), "node");
+  return join22(cabaneDir(), "node");
 }
 function pinnedNodePath() {
-  return join24(pinnedNodeDir(), "bin", "node");
+  return join22(pinnedNodeDir(), "bin", "node");
 }
 function versionPackageRoot(version) {
-  return join24(versionsDir(), version, "node_modules", "@cabane", "companion");
+  return join22(versionsDir(), version, "node_modules", "@cabane", "companion");
 }
 function ownPackageRoot(moduleUrl = import.meta.url) {
-  return dirname9(dirname9(fileURLToPath5(moduleUrl)));
+  return dirname8(dirname8(fileURLToPath4(moduleUrl)));
 }
 function packageVersion(root) {
   try {
-    const pkg2 = JSON.parse(readFileSync13(join24(root, "package.json"), "utf8"));
+    const pkg2 = JSON.parse(readFileSync13(join22(root, "package.json"), "utf8"));
     return typeof pkg2.version === "string" ? pkg2.version : null;
   } catch {
     return null;
@@ -14333,14 +12069,14 @@ function packageVersion(root) {
 function currentRoot() {
   try {
     const root = realpathSync5(currentLink());
-    return existsSync15(join24(root, "dist", "cli.js")) ? root : null;
+    return existsSync14(join22(root, "dist", "cli.js")) ? root : null;
   } catch {
     return null;
   }
 }
 function pointCurrentAt(root) {
   const link = currentLink();
-  mkdirSync12(dirname9(link), { recursive: true });
+  mkdirSync12(dirname8(link), { recursive: true });
   const fresh = `${link}.${process.pid}.${Date.now()}`;
   symlinkSync2(root, fresh);
   try {
@@ -14352,11 +12088,11 @@ function pointCurrentAt(root) {
 }
 function pruneVersions(keep) {
   const dir2 = versionsDir();
-  if (!existsSync15(dir2)) return [];
+  if (!existsSync14(dir2)) return [];
   const removed = [];
   for (const name of readdirSync3(dir2)) {
     if (keep.includes(name)) continue;
-    rmSync9(join24(dir2, name), { recursive: true, force: true });
+    rmSync9(join22(dir2, name), { recursive: true, force: true });
     removed.push(name);
   }
   return removed;
@@ -14376,31 +12112,31 @@ function compareVersions(a, b) {
 // src/update-state.ts
 init_config();
 import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, renameSync as renameSync8, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname10, join as join25 } from "path";
-import { z as z18 } from "zod";
-var resultSchema = z18.object({
-  kind: z18.enum(["updated", "rolled_back", "failed"]),
-  from: z18.string(),
-  to: z18.string(),
-  at: z18.string(),
-  reason: z18.string().optional()
+import { dirname as dirname9, join as join23 } from "path";
+import { z as z17 } from "zod";
+var resultSchema = z17.object({
+  kind: z17.enum(["updated", "rolled_back", "failed"]),
+  from: z17.string(),
+  to: z17.string(),
+  at: z17.string(),
+  reason: z17.string().optional()
 });
-var pendingSchema = z18.object({
-  from: z18.string(),
+var pendingSchema = z17.object({
+  from: z17.string(),
   // The package root `current` pointed at before the swap, so a rollback can point it back.
-  fromRoot: z18.string(),
-  to: z18.string(),
-  at: z18.string(),
-  boots: z18.number().int().nonnegative()
+  fromRoot: z17.string(),
+  to: z17.string(),
+  at: z17.string(),
+  boots: z17.number().int().nonnegative()
 });
-var stateSchema = z18.object({
-  server: z18.object({ latest: z18.string(), minimum: z18.string(), at: z18.string() }).optional(),
+var stateSchema = z17.object({
+  server: z17.object({ latest: z17.string(), minimum: z17.string(), at: z17.string() }).optional(),
   pending: pendingSchema.optional(),
   lastResult: resultSchema.optional(),
-  failed: z18.object({ version: z18.string(), attempts: z18.number().int(), at: z18.string() }).optional()
+  failed: z17.object({ version: z17.string(), attempts: z17.number().int(), at: z17.string() }).optional()
 });
 function updateStatePath(dir2 = cabaneDir()) {
-  return join25(dir2, "update.json");
+  return join23(dir2, "update.json");
 }
 function readUpdateState(path = updateStatePath()) {
   try {
@@ -14411,7 +12147,7 @@ function readUpdateState(path = updateStatePath()) {
   }
 }
 function writeUpdateState(state, path = updateStatePath()) {
-  mkdirSync13(dirname10(path), { recursive: true });
+  mkdirSync13(dirname9(path), { recursive: true });
   const tmp = `${path}.${process.pid}.tmp`;
   writeFileSync8(tmp, `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
@@ -14445,14 +12181,14 @@ function versionToStage(input) {
   return latest;
 }
 function rollBack(pending, reason, now = /* @__PURE__ */ new Date()) {
-  if (existsSync16(pending.fromRoot)) pointCurrentAt(pending.fromRoot);
+  if (existsSync15(pending.fromRoot)) pointCurrentAt(pending.fromRoot);
   return updateUpdateState((state) => rolledBackState(state, pending, reason, now));
 }
 function writeBootGuard(root = ownPackageRoot()) {
-  const built = join26(root, "dist", "boot-guard.js");
-  if (!existsSync16(built)) return false;
+  const built = join24(root, "dist", "boot-guard.js");
+  if (!existsSync15(built)) return false;
   const target = bootGuardPath();
-  mkdirSync14(dirname11(target), { recursive: true });
+  mkdirSync14(dirname10(target), { recursive: true });
   const tmp = `${target}.${process.pid}.tmp`;
   copyFileSync2(built, tmp);
   renameSync9(tmp, target);
@@ -14489,17 +12225,17 @@ var runProcess = (command, args, opts = {}) => new Promise((resolve2) => {
 async function stageVersion(version, harnesses, deps = {}) {
   const run = deps.run ?? runProcess;
   const node = deps.execPath ?? process.execPath;
-  const target = join26(versionsDir(), version);
+  const target = join24(versionsDir(), version);
   const placed = versionPackageRoot(version);
-  if (existsSync16(placed)) {
+  if (existsSync15(placed)) {
     if (!await verifyInstall(placed, version, harnesses, { run, execPath: node }))
       return { ok: true, root: placed };
   }
-  const npm = join26(dirname11(node), "npm");
-  if (!existsSync16(npm))
-    return { ok: false, reason: `there is no npm beside Node at ${dirname11(node)}` };
+  const npm = join24(dirname10(node), "npm");
+  if (!existsSync15(npm))
+    return { ok: false, reason: `there is no npm beside Node at ${dirname10(node)}` };
   mkdirSync14(versionsDir(), { recursive: true });
-  const staging = join26(versionsDir(), `.${version}.staging-${process.pid}`);
+  const staging = join24(versionsDir(), `.${version}.staging-${process.pid}`);
   rmSync10(staging, { recursive: true, force: true });
   const installed = await run(
     npm,
@@ -14516,7 +12252,7 @@ async function stageVersion(version, harnesses, deps = {}) {
     ],
     {
       // npm's install scripts run on this Node, not whichever `node` is first on PATH.
-      env: { ...process.env, PATH: `${dirname11(node)}:${process.env.PATH ?? ""}` },
+      env: { ...process.env, PATH: `${dirname10(node)}:${process.env.PATH ?? ""}` },
       timeoutMs: 15 * 6e4
     }
   );
@@ -14528,7 +12264,7 @@ async function stageVersion(version, harnesses, deps = {}) {
       return { ok: false, reason: `version ${version} isn't published yet`, unpublished: true };
     return { ok: false, reason: `npm couldn't install it: ${lastLine(installed.stderr)}` };
   }
-  const root = join26(staging, "node_modules", "@cabane", "companion");
+  const root = join24(staging, "node_modules", "@cabane", "companion");
   const verdict = await verifyInstall(root, version, harnesses, { run, execPath: node });
   if (verdict) {
     rmSync10(staging, { recursive: true, force: true });
@@ -14540,7 +12276,7 @@ async function stageVersion(version, harnesses, deps = {}) {
 }
 async function verifyInstall(root, version, harnesses, deps) {
   if (packageVersion(root) !== version) return `the installed package isn't version ${version}`;
-  const answered = await deps.run(deps.execPath, [join26(root, "dist", "bin.js"), "--version"], {
+  const answered = await deps.run(deps.execPath, [join24(root, "dist", "bin.js"), "--version"], {
     timeoutMs: 6e4,
     env: { ...process.env, CABANE_LAUNCH_SELF: "1" }
   });
@@ -14548,7 +12284,7 @@ async function verifyInstall(root, version, harnesses, deps) {
     return `it doesn't start: ${lastLine(answered.stderr) || "no version printed"}`;
   }
   if (harnesses.length === 0) return null;
-  const probed = await deps.run(deps.execPath, [join26(root, "dist", "postinstall.js"), "--json"], {
+  const probed = await deps.run(deps.execPath, [join24(root, "dist", "postinstall.js"), "--json"], {
     timeoutMs: 6e4
   });
   let resolutions = {};
@@ -16323,10 +14059,10 @@ function handleUncaught(log2, err, origin) {
 
 // src/crash-marker.ts
 init_config();
-import { existsSync as existsSync17, mkdirSync as mkdirSync15, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync9 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync15, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync9 } from "fs";
+import { join as join25 } from "path";
 function crashMarkerPath() {
-  return join27(cabaneDir(), "last-error.json");
+  return join25(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
@@ -16338,7 +14074,7 @@ function recordCrash(rec2) {
 function clearCrash() {
   try {
     const path = crashMarkerPath();
-    if (existsSync17(path)) rmSync11(path, { force: true });
+    if (existsSync16(path)) rmSync11(path, { force: true });
   } catch {
   }
 }
@@ -16347,7 +14083,7 @@ function clearCrash() {
 init_config();
 import { spawnSync } from "child_process";
 import { readFileSync as readFileSync16 } from "fs";
-import { join as join28 } from "path";
+import { join as join26 } from "path";
 var COMPANION_ENTRY = /@cabane\/companion\/|cabane-companion|(^|[\s/])cabane\s|\.cabane\/(versions|current|boot-guard)/;
 var START = /\sstart(\s|$)/;
 function companionStarts(psOutput) {
@@ -16364,7 +14100,7 @@ function companionStarts(psOutput) {
 }
 function stateDirOf(env) {
   const home = env.CABANE_COMPANION_HOME || env.HOME;
-  return home ? join28(home, ".cabane") : null;
+  return home ? join26(home, ".cabane") : null;
 }
 function envFromPsE(output, command) {
   const line = output.replace(/\n$/, "");
@@ -16434,9 +14170,10 @@ function strayCompanionLines(strays, retry) {
 }
 
 // src/runtime.ts
+init_errors();
 function embeddedRunner(host) {
   if (!host.electron) return null;
-  const cli = fileURLToPath6(new URL("./cli.js", host.moduleUrl));
+  const cli = fileURLToPath5(new URL("./cli.js", host.moduleUrl));
   return {
     runnerCommand: [host.execPath, cli, "run-turn"],
     runnerEnv: { ...host.env, ELECTRON_RUN_AS_NODE: "1" }
@@ -16531,11 +14268,12 @@ async function createCompanionRuntime(opts = {}) {
       update: (auto) => active2.update(auto),
       stop: () => void stop2().then(() => active2.requestStop())
     });
-    if (opts.dashboard) {
-      const preferredPort = opts.port ?? cfg.dashboardPort;
-      dashboard = await startDashboard({
+    if (opts.startDashboard) {
+      const preferredPort = cfg.dashboardPort;
+      dashboard = await opts.startDashboard({
         supervisor,
         hub,
+        logPath: companionLogPath(),
         ...preferredPort !== void 0 ? { port: preferredPort } : {}
       });
       hub.setDashboardUrl(dashboard.url);
@@ -16631,7 +14369,7 @@ import { createHash as createHash3 } from "crypto";
 import {
   chmodSync as chmodSync5,
   cpSync,
-  existsSync as existsSync18,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync16,
   readFileSync as readFileSync17,
   renameSync as renameSync10,
@@ -16639,7 +14377,7 @@ import {
   writeFileSync as writeFileSync10
 } from "fs";
 import { homedir as homedir9, userInfo as userInfo3 } from "os";
-import { dirname as dirname12, join as join29, sep as sep3 } from "path";
+import { dirname as dirname11, join as join27, sep as sep3 } from "path";
 function servicePlatform(platform = process.platform) {
   if (platform === "linux") return "systemd";
   if (platform === "darwin") return "launchd";
@@ -16654,18 +14392,18 @@ function launchdLabel(env = process.env) {
   return serviceName(env).replace(/^cabane-companion/, "ai.cabane.companion").replace("-", ".");
 }
 function serviceNode(execPath = process.execPath) {
-  return existsSync18(pinnedNodePath()) ? pinnedNodePath() : execPath;
+  return existsSync17(pinnedNodePath()) ? pinnedNodePath() : execPath;
 }
 function servicePaths(platform, env = process.env, home = homedir9(), node = serviceNode()) {
-  const unitFile = platform === "systemd" ? join29(
-    env.XDG_CONFIG_HOME || join29(home, ".config"),
+  const unitFile = platform === "systemd" ? join27(
+    env.XDG_CONFIG_HOME || join27(home, ".config"),
     "systemd",
     "user",
     `${serviceName(env)}.service`
-  ) : join29(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
+  ) : join27(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
   return {
     unitFile,
-    envFile: join29(cabaneDir(), "service.env"),
+    envFile: join27(cabaneDir(), "service.env"),
     node,
     entry: bootGuardPath()
   };
@@ -16732,7 +14470,7 @@ function renderLaunchdPlist(paths, env = process.env, servicePath) {
     "  <key>ThrottleInterval</key><integer>5</integer>",
     // The companion writes its own log; the console copy would only grow a second one.
     "  <key>StandardOutPath</key><string>/dev/null</string>",
-    `  <key>StandardErrorPath</key><string>${xml(join29(cabaneDir(), "service-error.log"))}</string>`,
+    `  <key>StandardErrorPath</key><string>${xml(join27(cabaneDir(), "service-error.log"))}</string>`,
     "</dict>",
     "</plist>",
     ""
@@ -16787,11 +14525,11 @@ async function installService(deps = {}) {
   rewriteScriptWrappers();
   const paths = servicePaths(platform, env, deps.home, node);
   const servicePath = await loginShellPath(run, env);
-  mkdirSync16(dirname12(paths.envFile), { recursive: true });
-  const existing = existsSync18(paths.envFile) ? readFileSync17(paths.envFile, "utf8") : "";
+  mkdirSync16(dirname11(paths.envFile), { recursive: true });
+  const existing = existsSync17(paths.envFile) ? readFileSync17(paths.envFile, "utf8") : "";
   writeFileSync10(paths.envFile, withServicePath(existing, servicePath), { mode: 384 });
   chmodSync5(paths.envFile, 384);
-  mkdirSync16(dirname12(paths.unitFile), { recursive: true });
+  mkdirSync16(dirname11(paths.unitFile), { recursive: true });
   const outcome = await writeAndStartUnit(platform, paths, env, servicePath, run);
   if (!outcome.ok) await removeUnit(platform, paths, env, run);
   return outcome;
@@ -16844,7 +14582,7 @@ async function uninstallService(deps = {}) {
   const platform = servicePlatform(deps.platform);
   if (!platform) return { ok: true, lines: [] };
   const paths = servicePaths(platform, env, deps.home);
-  if (!existsSync18(paths.unitFile)) return { ok: true, lines: ["No Cabane service is installed."] };
+  if (!existsSync17(paths.unitFile)) return { ok: true, lines: ["No Cabane service is installed."] };
   await removeUnit(platform, paths, env, run);
   return { ok: true, lines: [] };
 }
@@ -16871,16 +14609,16 @@ async function seedManagedInstall(deps) {
     return { ok: true, root: own };
   }
   const target = versionPackageRoot(version);
-  if (!existsSync18(target)) {
-    const staging = join29(versionsDir(), `.${version}.seed-${process.pid}`);
+  if (!existsSync17(target)) {
+    const staging = join27(versionsDir(), `.${version}.seed-${process.pid}`);
     rmSync12(staging, { recursive: true, force: true });
     try {
-      cpSync(own, join29(staging, "node_modules", "@cabane", "companion"), {
+      cpSync(own, join27(staging, "node_modules", "@cabane", "companion"), {
         recursive: true,
         verbatimSymlinks: true
       });
-      rmSync12(join29(versionsDir(), version), { recursive: true, force: true });
-      renameSync10(staging, join29(versionsDir(), version));
+      rmSync12(join27(versionsDir(), version), { recursive: true, force: true });
+      renameSync10(staging, join27(versionsDir(), version));
     } catch (err) {
       rmSync12(staging, { recursive: true, force: true });
       return {
@@ -16891,7 +14629,7 @@ async function seedManagedInstall(deps) {
   }
   const unrunnable = await verifyInstall(target, version, [], deps);
   if (unrunnable) {
-    rmSync12(join29(versionsDir(), version), { recursive: true, force: true });
+    rmSync12(join27(versionsDir(), version), { recursive: true, force: true });
     return { ok: false, reason: `The copy of Cabane for the service can't run: ${unrunnable}.` };
   }
   pointCurrentAt(target);
@@ -16925,9 +14663,9 @@ async function serviceState(deps = {}) {
   };
   if (!platform) return none;
   const paths = servicePaths(platform, env, deps.home);
-  if (!existsSync18(paths.unitFile)) return none;
+  if (!existsSync17(paths.unitFile)) return none;
   const node = unitNode(platform, paths.unitFile);
-  const nodeOk = node === null || existsSync18(node);
+  const nodeOk = node === null || existsSync17(node);
   if (platform === "systemd") {
     const r2 = await run(
       "systemctl",
@@ -16959,7 +14697,7 @@ async function serviceState(deps = {}) {
 function serviceInstalled(deps = {}) {
   const platform = servicePlatform(deps.platform);
   if (!platform) return false;
-  return existsSync18(servicePaths(platform, deps.env ?? process.env, deps.home).unitFile);
+  return existsSync17(servicePaths(platform, deps.env ?? process.env, deps.home).unitFile);
 }
 function writeAtomic(path, content) {
   const tmp = `${path}.${process.pid}.tmp`;
@@ -16973,9 +14711,9 @@ function userName() {
     return process.env.USER ?? "";
   }
 }
-function rewriteScriptWrappers(dir2 = join29(cabaneDir(), "bin")) {
+function rewriteScriptWrappers(dir2 = join27(cabaneDir(), "bin")) {
   for (const name of ["cabane", "cabane-companion"]) {
-    const path = join29(dir2, name);
+    const path = join27(dir2, name);
     let text;
     try {
       text = readFileSync17(path, "utf8");
@@ -17026,7 +14764,7 @@ init_cabane_command();
 init_cli_entry();
 init_config();
 import { spawn as spawn7 } from "child_process";
-import { closeSync as closeSync3, mkdirSync as mkdirSync17, openSync as openSync4 } from "fs";
+import { closeSync as closeSync2, mkdirSync as mkdirSync17, openSync as openSync3 } from "fs";
 init_config();
 async function startDaemon(opts = {}, deps = {}) {
   const ensureRuntime = deps.ensureRuntime ?? warnAboutHarnessReadiness;
@@ -17105,7 +14843,7 @@ function alreadyRunningLines(pid) {
 function defaultSpawnDetached(args) {
   const cliPath = companionCliEntry();
   mkdirSync17(cabaneDir(), { recursive: true });
-  const logFd = openSync4(companionLogPath(), "a");
+  const logFd = openSync3(companionLogPath(), "a");
   try {
     const child = spawn7(process.execPath, [cliPath, ...args], {
       detached: true,
@@ -17121,7 +14859,7 @@ function defaultSpawnDetached(args) {
     });
     return { pid: child.pid, unref: () => child.unref(), failure: () => failure };
   } finally {
-    closeSync3(logFd);
+    closeSync2(logFd);
   }
 }
 
@@ -17632,9 +15370,9 @@ async function logs(opts = {}) {
 init_cabane_command();
 init_install_kind();
 init_cabane_command();
-import { readdirSync as readdirSync4, realpathSync as realpathSync6, existsSync as existsSync19 } from "fs";
+import { readdirSync as readdirSync4, realpathSync as realpathSync6, existsSync as existsSync18 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname13, join as join30 } from "path";
+import { dirname as dirname12, join as join28 } from "path";
 init_config();
 init_secrets();
 init_term();
@@ -17918,10 +15656,10 @@ function versionLine() {
   const install = companionInstall();
   const own = installedCommandPath({ install });
   if (install === "script") {
-    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join30(homedir10(), ".cabane"))})`;
+    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join28(homedir10(), ".cabane"))})`;
   }
   if (own)
-    return `Cabane ${COMPANION_VERSION} \xB7 installed with npm (${tildePath(dirname13(dirname13(own)))})`;
+    return `Cabane ${COMPANION_VERSION} \xB7 installed with npm (${tildePath(dirname12(dirname12(own)))})`;
   return `Cabane ${COMPANION_VERSION}`;
 }
 function otherInstallLines(running) {
@@ -17944,7 +15682,7 @@ function otherInstall(install, own) {
     }
   };
   if (install === "npm") {
-    const script = join30(
+    const script = join28(
       homedir10(),
       ".cabane",
       "node",
@@ -17953,12 +15691,12 @@ function otherInstall(install, own) {
       "@cabane",
       "companion"
     );
-    return existsSync19(script) ? join30(homedir10(), ".cabane") : null;
+    return existsSync18(script) ? join28(homedir10(), ".cabane") : null;
   }
   const found = firstOnPath("cabane-companion", process.env.PATH);
   if (!found) return null;
-  const ownAlias = own ? real(join30(dirname13(own), "cabane-companion")) : null;
-  return real(found) === ownAlias ? null : dirname13(found);
+  const ownAlias = own ? real(join28(dirname12(own), "cabane-companion")) : null;
+  return real(found) === ownAlias ? null : dirname12(found);
 }
 function runningMode(running, service2) {
   if (service2.installed) {
@@ -18163,8 +15901,8 @@ init_cabane_command();
 init_errors();
 init_src();
 init_transcript_writer();
-import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "fs";
-import { basename as basename4, isAbsolute as isAbsolute2, join as join31 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "fs";
+import { basename as basename4, isAbsolute as isAbsolute2, join as join29 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -18181,7 +15919,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join31(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join29(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -18264,7 +16002,7 @@ function isComplete(content) {
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync18(join31(dir2, f), "utf8"),
+    read: (f) => readFileSync18(join29(dir2, f), "utf8"),
     write: (s) => process.stdout.write(s),
     // CSI: cursor up `n` lines, then erase from cursor to end of screen.
     clearLines: (n) => process.stdout.write(`\x1B[${n}A\x1B[0J`),
@@ -18300,7 +16038,7 @@ function listTranscriptFiles(dir2) {
     if (!entry.isDirectory() || entry.name === "anomalies") continue;
     let inner;
     try {
-      inner = readdirSync5(join31(dir2, entry.name));
+      inner = readdirSync5(join29(dir2, entry.name));
     } catch {
       continue;
     }
@@ -18319,7 +16057,7 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join31(dir2, f));
+    const { meta, outcome } = peek(join29(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
     const ws = str2(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
@@ -18354,14 +16092,14 @@ function peek(path) {
 }
 function resolveTarget(dir2, target) {
   if (isAbsolute2(target) || target.includes("/")) {
-    if (existsSync20(target)) return target;
-    if (!isAbsolute2(target) && existsSync20(join31(dir2, target))) return join31(dir2, target);
+    if (existsSync19(target)) return target;
+    if (!isAbsolute2(target) && existsSync19(join29(dir2, target))) return join29(dir2, target);
     throw new CompanionError(`no transcript at ${target}.`);
   }
-  const exact = join31(dir2, target);
-  if (existsSync20(exact)) return exact;
+  const exact = join29(dir2, target);
+  if (existsSync19(exact)) return exact;
   const matches = listFiles(dir2).filter((f) => f.includes(target));
-  if (matches.length === 1) return join31(dir2, matches[0]);
+  if (matches.length === 1) return join29(dir2, matches[0]);
   if (matches.length === 0) {
     throw new CompanionError(
       `no transcript matching "${target}" in ${dir2}. Run \`${cabane("transcript")}\` to list them.`