@cabane/companion 0.6.215 → 0.6.217

package/dist/runtime.js

@@ -1,6 +1,6 @@
 // src/runtime.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/cabane-command.ts
 import { accessSync, constants, realpathSync as realpathSync2 } from "fs";
@@ -254,9 +254,9 @@ var companionConfigSchema = z2.object({
   // 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(),
@@ -294,7 +294,10 @@ var companionConfigSchema = z2.object({
   // credential and secrets on its stdin (`runner/launch.ts`, `wrapped`). The README lists
   // what a wrapper can rely on.
   runner: z2.object({
-    command: z2.array(z2.string().min(1)).min(1)
+    command: z2.array(z2.string().min(1)).min(1),
+    // The external wrapper supplies only broker placeholders and removes
+    // credential mounts. Do not hand provider logins to that runner on stdin.
+    brokeredCredentials: z2.boolean().optional()
   }).strict().optional()
 });
 function workRoot(cfg) {
@@ -456,31 +459,199 @@ function requireConfig() {
   return cfg;
 }
 
-// src/dashboard/server.ts
-import { dirname as dirname5, join as join7 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { serve } from "@hono/node-server";
-import { Hono } from "hono";
-
-// src/dashboard/routes.ts
-import { openSync as openSync2, readSync, closeSync, fstatSync, existsSync as existsSync4 } from "fs";
-import { readFile } from "fs/promises";
-import { extname, join as join6, normalize } from "path";
-import { streamSSE } from "hono/streaming";
+// src/control-socket.ts
+import { createHash } from "crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync4, rmSync as rmSync2, mkdirSync as mkdirSync2 } from "fs";
+import { createServer, connect } from "net";
+import { join as join5 } from "path";
+var CONTROL_TIMEOUT_MS = 1e3;
+var MAX_UNIX_SOCKET_PATH_BYTES = 103;
+function controlSocketPath() {
+  const dir2 = cabaneDir();
+  const key = createHash("sha256").update(dir2).digest("hex").slice(0, 16);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\cabane-companion-${key}`;
+  }
+  const besideRuntime = join5(dir2, "companion.sock");
+  if (Buffer.byteLength(besideRuntime) <= MAX_UNIX_SOCKET_PATH_BYTES) return besideRuntime;
+  const filename = `cabane-companion-${key}.sock`;
+  const xdgPath = process.env.XDG_RUNTIME_DIR && existsSync4(process.env.XDG_RUNTIME_DIR) ? join5(process.env.XDG_RUNTIME_DIR, filename) : null;
+  return xdgPath && Buffer.byteLength(xdgPath) <= MAX_UNIX_SOCKET_PATH_BYTES ? xdgPath : join5("/tmp", filename);
+}
+async function startControlServer(handlers) {
+  const path = controlSocketPath();
+  mkdirSync2(cabaneDir(), { recursive: true });
+  if (process.platform !== "win32" && existsSync4(path)) {
+    const alive = await ping(path);
+    if (alive) throw new Error(`another companion is already listening on ${path}`);
+    rmSync2(path, { force: true });
+  }
+  const server = createServer((socket) => {
+    void serveConnection(socket, handlers);
+  });
+  server.unref();
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(path, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  if (process.platform !== "win32") {
+    try {
+      chmodSync2(path, 384);
+    } catch (err) {
+      await new Promise((resolve) => server.close(() => resolve()));
+      try {
+        rmSync2(path, { force: true });
+      } catch {
+      }
+      throw err;
+    }
+  }
+  server.on("error", () => {
+  });
+  return {
+    path,
+    close: () => new Promise((resolve) => {
+      server.close(() => {
+        if (process.platform !== "win32") rmSync2(path, { force: true });
+        resolve();
+      });
+    })
+  };
+}
+async function serveConnection(socket, handlers) {
+  socket.on("error", () => socket.destroy());
+  const line = await readLine(socket, CONTROL_TIMEOUT_MS * 5);
+  if (line === null) {
+    socket.destroy();
+    return;
+  }
+  let req;
+  try {
+    req = JSON.parse(line);
+  } catch {
+    reply(socket, { error: "malformed request" });
+    return;
+  }
+  try {
+    if (req.cmd === "status") {
+      reply(socket, handlers.status());
+      return;
+    }
+    if (req.cmd === "detect") {
+      const result = { detection: await handlers.detect() };
+      reply(socket, result);
+      return;
+    }
+    if (req.cmd === "allow") {
+      const result = { detection: await handlers.allow(req.runtime) };
+      reply(socket, result);
+      return;
+    }
+    if (req.cmd === "update") {
+      reply(socket, await handlers.update(req.auto));
+      return;
+    }
+    if (req.cmd === "stop") {
+      reply(socket, { ok: true });
+      setTimeout(() => handlers.stop(), 50).unref?.();
+      return;
+    }
+    reply(socket, { error: `unknown command "${String(req.cmd)}"` });
+  } catch (err) {
+    reply(socket, { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+function reply(socket, body) {
+  try {
+    socket.end(`${JSON.stringify(body)}
+`);
+  } catch {
+    socket.destroy();
+  }
+}
+async function controlRequest(path, req, timeoutMs = CONTROL_TIMEOUT_MS) {
+  const socket = connect(path);
+  try {
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new ControlTimeout()), timeoutMs);
+      timer.unref?.();
+      socket.once("connect", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      socket.once("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+    socket.write(`${JSON.stringify(req)}
+`);
+    const line = await readLine(socket, timeoutMs);
+    if (line === null) throw new ControlTimeout();
+    return JSON.parse(line);
+  } finally {
+    socket.destroy();
+  }
+}
+var ControlTimeout = class extends Error {
+  constructor() {
+    super("the companion did not answer its control socket in time");
+    this.name = "ControlTimeout";
+  }
+};
+function isNotListening(err) {
+  const code = err?.code;
+  return code === "ENOENT" || code === "ECONNREFUSED";
+}
+function readLine(socket, timeoutMs) {
+  return new Promise((resolve) => {
+    let buf = "";
+    let settled = false;
+    const done = (v) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.removeListener("data", onData);
+      resolve(v);
+    };
+    const timer = setTimeout(() => done(null), timeoutMs);
+    timer.unref?.();
+    const onData = (chunk) => {
+      buf += chunk.toString("utf8");
+      const nl = buf.indexOf("\n");
+      if (nl >= 0) done(buf.slice(0, nl));
+      else if (buf.length > 1e6) done(null);
+    };
+    socket.on("data", onData);
+    socket.once("close", () => done(null));
+    socket.once("error", () => done(null));
+  });
+}
+async function ping(path) {
+  try {
+    await controlRequest(path, { cmd: "status" });
+    return true;
+  } catch (err) {
+    return !isNotListening(err);
+  }
+}
 
 // src/logger.ts
 import {
   createWriteStream,
-  mkdirSync as mkdirSync2,
+  mkdirSync as mkdirSync3,
   openSync,
   renameSync as renameSync2,
   statSync
 } from "fs";
-import { dirname as dirname4, join as join5 } from "path";
+import { dirname as dirname4, join as join6 } from "path";
 import { stripVTControlCharacters } from "util";
 import pino from "pino";
 function companionLogPath() {
-  return join5(cabaneDir(), "companion.log");
+  return join6(cabaneDir(), "companion.log");
 }
 function humanText(value) {
   return stripVTControlCharacters(String(value ?? "")).replace(
@@ -588,7 +759,7 @@ function configureLogger(log, config) {
 }
 function createLogger(destinations = {}, options = {}) {
   const path = companionLogPath();
-  if (!destinations.file) mkdirSync2(dirname4(path), { recursive: true });
+  if (!destinations.file) mkdirSync3(dirname4(path), { recursive: true });
   const file = destinations.file ?? new RotatingLog(path);
   const state = { format: options.logFormat ?? "human" };
   const streams = [];
@@ -634,671 +805,46 @@ function getLogger() {
   return cached;
 }
 
-// src/state.ts
-import { EventEmitter } from "events";
-function dispatchToWire(r) {
-  return {
-    id: r.id,
-    timestamp: r.timestamp,
-    workspace_slug: r.workspaceSlug,
-    ...r.agentUsername ? { agent_username: r.agentUsername } : {},
-    message: r.message,
-    status: r.status,
-    ...r.durationMs !== void 0 ? { duration_ms: r.durationMs } : {},
-    ...r.error ? { error: r.error } : {},
-    ...r.reply ? { reply: r.reply } : {}
-  };
-}
-var MAX_DISPATCHES = 50;
-function today() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-}
-var CompanionStateHub = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.emitter.setMaxListeners(0);
+// src/bundled-binaries.ts
+import { realpathSync as realpathSync3, statSync as statSync2 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname5, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function nodeResolveSelf(specifier) {
+  const here = fileURLToPath3(import.meta.url);
+  if (typeof import.meta.resolve === "function") {
+    try {
+      return fileURLToPath3(import.meta.resolve(specifier));
+    } catch {
+    }
   }
-  opts;
-  emitter = new EventEmitter();
-  workspaces = /* @__PURE__ */ new Map();
-  dispatches = [];
-  dashboardUrl = null;
-  deviceId = null;
-  deviceLabel = null;
-  deviceError = null;
-  // The latest harness snapshot the supervisor probed, or null before the
-  // first probe (see CompanionStatusJson.harnesses).
-  harnesses = null;
-  // ---- subscription (SSE) ----
-  on(listener) {
-    this.emitter.on("event", listener);
-    return () => this.emitter.off("event", listener);
+  try {
+    return createRequire(here).resolve(specifier);
+  } catch {
   }
-  emit(type, data) {
-    this.emitter.emit("event", { type, data });
+  return walkNodeModules(specifier, here);
+}
+function walkNodeModules(pkg2, fromPath) {
+  let dir2 = dirname5(fromPath);
+  for (; ; ) {
+    const manifest = join7(dir2, "node_modules", pkg2, "package.json");
+    if (nodeIsFile(manifest)) {
+      try {
+        return realpathSync3(manifest);
+      } catch {
+        return manifest;
+      }
+    }
+    const parent = dirname5(dir2);
+    if (parent === dir2) return null;
+    dir2 = parent;
   }
-  // ---- device ----
-  setDevice(info) {
-    if (info.deviceId !== void 0) this.deviceId = info.deviceId;
-    if (info.deviceLabel !== void 0) this.deviceLabel = info.deviceLabel;
-    this.emitStatus();
-  }
-  setDeviceError(message) {
-    if (this.deviceError === message) return;
-    this.deviceError = message;
-    this.emitStatus();
-  }
-  clearDeviceError() {
-    if (this.deviceError === null) return;
-    this.deviceError = null;
-    this.emitStatus();
-  }
-  // ---- harnesses ----
-  // Replace the harness snapshot and push a status change (so the SSE feed flips
-  // the Companion's Harnesses surface live). The supervisor calls this on each
-  // heartbeat-cadence probe and on an on-demand recheck.
-  setHarnesses(harnesses) {
-    this.harnesses = harnesses;
-    this.emitStatus();
-  }
-  // ---- workspace lifecycle ----
-  registerWorkspace(ws) {
-    const existing = this.workspaces.get(ws.workspaceId);
-    if (existing) {
-      existing.slug = ws.slug;
-      existing.name = ws.name;
-      return;
-    }
-    this.workspaces.set(ws.workspaceId, {
-      workspaceId: ws.workspaceId,
-      slug: ws.slug,
-      name: ws.name,
-      connected: false,
-      authFailed: false,
-      lastEventAt: null,
-      dispatchCountToday: 0,
-      countDate: today(),
-      agents: /* @__PURE__ */ new Map()
-    });
-    this.emitStatus();
-  }
-  removeWorkspace(workspaceId) {
-    const ws = this.workspaces.get(workspaceId);
-    if (!ws) return;
-    this.workspaces.delete(workspaceId);
-    this.emit("workspace:disconnected", { slug: ws.slug });
-    this.emitStatus();
-  }
-  setConnected(workspaceId, connected) {
-    const ws = this.workspaces.get(workspaceId);
-    if (!ws || ws.connected === connected) return;
-    ws.connected = connected;
-    if (connected) ws.authFailed = false;
-    this.emitStatus();
-  }
-  setAuthFailed(workspaceId) {
-    const ws = this.workspaces.get(workspaceId);
-    if (!ws) return;
-    if (ws.authFailed && !ws.connected) return;
-    ws.authFailed = true;
-    ws.connected = false;
-    this.emitStatus();
-  }
-  recordEvent(workspaceId) {
-    const ws = this.workspaces.get(workspaceId);
-    if (!ws) return;
-    ws.lastEventAt = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  // ---- agents ----
-  // Upsert one assigned agent's observable state (called on each reconcile).
-  setAgent(workspaceId, agent) {
-    const ws = this.workspaces.get(workspaceId);
-    if (!ws) return;
-    ws.agents.set(agent.agentId, agent);
-    this.emitStatus();
-  }
-  removeAgent(workspaceId, agentId) {
-    const ws = this.workspaces.get(workspaceId);
-    if (!ws) return;
-    if (ws.agents.delete(agentId)) this.emitStatus();
-  }
-  // ---- dispatch feed ----
-  // A DispatchObserver bound to one (workspace, agent), handed to that agent's
-  // Dispatcher by the supervisor.
-  observerFor(workspaceId, agentId, slug) {
-    const username = () => this.workspaces.get(workspaceId)?.agents.get(agentId)?.username ?? "";
-    return {
-      onStart: (info) => this.dispatchStarted(workspaceId, slug, username(), info),
-      onEnd: (info) => this.dispatchEnded(slug, username(), info)
-    };
-  }
-  bumpCount(workspaceId) {
-    const ws = this.workspaces.get(workspaceId);
-    if (!ws) return;
-    const day = today();
-    if (ws.countDate !== day) {
-      ws.countDate = day;
-      ws.dispatchCountToday = 0;
-    }
-    ws.dispatchCountToday += 1;
-  }
-  dispatchStarted(workspaceId, slug, agentUsername, info) {
-    this.bumpCount(workspaceId);
-    const record = {
-      id: info.id,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      workspaceSlug: slug,
-      ...agentUsername ? { agentUsername } : {},
-      message: info.message,
-      status: "running"
-    };
-    this.upsertDispatch(record);
-    this.emit("dispatch:started", dispatchToWire(record));
-    this.emitStatus();
-  }
-  dispatchEnded(slug, agentUsername, info) {
-    const existing = this.dispatches.find((d) => d.id === info.id);
-    const record = {
-      id: info.id,
-      timestamp: existing?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-      workspaceSlug: existing?.workspaceSlug ?? slug,
-      ...existing?.agentUsername ?? agentUsername ? { agentUsername: existing?.agentUsername ?? agentUsername } : {},
-      message: existing?.message ?? "",
-      status: info.ok ? "replied" : "error",
-      durationMs: info.durationMs,
-      ...info.reason ? { error: info.reason } : {},
-      ...info.reply ? { reply: info.reply } : {}
-    };
-    this.upsertDispatch(record);
-    this.emit(info.ok ? "dispatch:completed" : "dispatch:error", dispatchToWire(record));
-  }
-  upsertDispatch(record) {
-    const idx = this.dispatches.findIndex((d) => d.id === record.id);
-    if (idx >= 0) {
-      this.dispatches[idx] = record;
-      return;
-    }
-    this.dispatches.unshift(record);
-    if (this.dispatches.length > MAX_DISPATCHES) this.dispatches.length = MAX_DISPATCHES;
-  }
-  // ---- snapshots for the HTTP routes ----
-  setDashboardUrl(url) {
-    this.dashboardUrl = url;
-  }
-  recentDispatches(limit = 20) {
-    return this.dispatches.slice(0, Math.max(0, limit));
-  }
-  statusJson() {
-    const list = [...this.workspaces.values()].sort((a, b) => a.name.localeCompare(b.name));
-    const lastOverall = list.reduce((acc, ws) => {
-      if (!ws.lastEventAt) return acc;
-      if (!acc || ws.lastEventAt > acc) return ws.lastEventAt;
-      return acc;
-    }, null);
-    return {
-      cabane_url: this.opts.baseUrl,
-      device_id: this.deviceId,
-      device_label: this.deviceLabel,
-      device_error: this.deviceError,
-      connected: list.some((ws) => ws.connected),
-      workspaces: list.map((ws) => ({
-        slug: ws.slug,
-        name: ws.name,
-        last_event_at: ws.lastEventAt,
-        dispatch_count_today: ws.dispatchCountToday,
-        connected: ws.connected,
-        auth_failed: ws.authFailed,
-        agents: [...ws.agents.values()].sort((a, b) => a.username.localeCompare(b.username)).map((a) => ({
-          agent_id: a.agentId,
-          username: a.username,
-          display_name: a.displayName,
-          has_credential: a.hasCredential,
-          missing_secrets: a.missingSecrets
-        }))
-      })),
-      last_event_at_overall: lastOverall,
-      dashboard_url: this.dashboardUrl,
-      companion_version: this.opts.companionVersion,
-      instance_id: this.opts.instanceId ?? null,
-      harnesses: this.harnesses
-    };
-  }
-  emitStatus() {
-    this.emit("status:changed", this.statusJson());
-  }
-};
-
-// 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(join6(staticDir, "index.html"), "utf8");
-    return c.html(html);
-  });
-  app.get("/static/:file", async (c) => {
-    const file = c.req.param("file");
-    const safe = normalize(file).replace(/^(\.\.[/\\])+/, "");
-    const full = join6(staticDir, safe);
-    if (!full.startsWith(staticDir) || !existsSync4(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((resolve) => {
-              wake = resolve;
-            }),
-            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 (!existsSync4(path)) return [];
-  const MAX_BYTES = 256 * 1024;
-  let fd;
-  try {
-    fd = openSync2(path, "r");
-    const size = fstatSync(fd).size;
-    const start = Math.max(0, size - MAX_BYTES);
-    const len = size - start;
-    if (len <= 0) return [];
-    const buf = Buffer.alloc(len);
-    readSync(fd, buf, 0, len, start);
-    const text = buf.toString("utf8");
-    const all = text.split("\n");
-    if (start > 0 && all.length > 0) all.shift();
-    return all.filter((l) => l.length > 0).slice(-lines2);
-  } catch {
-    return [];
-  } finally {
-    if (fd !== void 0) closeSync(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 status = err.status >= 400 && err.status < 600 ? err.status : 502;
-      return c.json({ error: err.message }, status);
-    }
-    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((resolve) => {
-          server.close(() => resolve());
-          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((resolve, reject) => {
-    let settled = false;
-    const server = serve({ fetch: app.fetch, hostname: "127.0.0.1", port }, () => {
-      if (!settled) {
-        settled = true;
-        resolve(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 join7(dirname5(fileURLToPath3(import.meta.url)), "static");
-}
-
-// src/control-socket.ts
-import { createHash } from "crypto";
-import { chmodSync as chmodSync2, existsSync as existsSync5, rmSync as rmSync2, mkdirSync as mkdirSync3 } from "fs";
-import { createServer, connect } from "net";
-import { join as join8 } from "path";
-var CONTROL_TIMEOUT_MS = 1e3;
-var MAX_UNIX_SOCKET_PATH_BYTES = 103;
-function controlSocketPath() {
-  const dir2 = cabaneDir();
-  const key = createHash("sha256").update(dir2).digest("hex").slice(0, 16);
-  if (process.platform === "win32") {
-    return `\\\\.\\pipe\\cabane-companion-${key}`;
-  }
-  const besideRuntime = join8(dir2, "companion.sock");
-  if (Buffer.byteLength(besideRuntime) <= MAX_UNIX_SOCKET_PATH_BYTES) return besideRuntime;
-  const filename = `cabane-companion-${key}.sock`;
-  const xdgPath = process.env.XDG_RUNTIME_DIR && existsSync5(process.env.XDG_RUNTIME_DIR) ? join8(process.env.XDG_RUNTIME_DIR, filename) : null;
-  return xdgPath && Buffer.byteLength(xdgPath) <= MAX_UNIX_SOCKET_PATH_BYTES ? xdgPath : join8("/tmp", filename);
-}
-async function startControlServer(handlers) {
-  const path = controlSocketPath();
-  mkdirSync3(cabaneDir(), { recursive: true });
-  if (process.platform !== "win32" && existsSync5(path)) {
-    const alive = await ping(path);
-    if (alive) throw new Error(`another companion is already listening on ${path}`);
-    rmSync2(path, { force: true });
-  }
-  const server = createServer((socket) => {
-    void serveConnection(socket, handlers);
-  });
-  server.unref();
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(path, () => {
-      server.removeListener("error", reject);
-      resolve();
-    });
-  });
-  if (process.platform !== "win32") {
-    try {
-      chmodSync2(path, 384);
-    } catch (err) {
-      await new Promise((resolve) => server.close(() => resolve()));
-      try {
-        rmSync2(path, { force: true });
-      } catch {
-      }
-      throw err;
-    }
-  }
-  server.on("error", () => {
-  });
-  return {
-    path,
-    close: () => new Promise((resolve) => {
-      server.close(() => {
-        if (process.platform !== "win32") rmSync2(path, { force: true });
-        resolve();
-      });
-    })
-  };
-}
-async function serveConnection(socket, handlers) {
-  socket.on("error", () => socket.destroy());
-  const line = await readLine(socket, CONTROL_TIMEOUT_MS * 5);
-  if (line === null) {
-    socket.destroy();
-    return;
-  }
-  let req;
-  try {
-    req = JSON.parse(line);
-  } catch {
-    reply(socket, { error: "malformed request" });
-    return;
-  }
-  try {
-    if (req.cmd === "status") {
-      reply(socket, handlers.status());
-      return;
-    }
-    if (req.cmd === "detect") {
-      const result = { detection: await handlers.detect() };
-      reply(socket, result);
-      return;
-    }
-    if (req.cmd === "allow") {
-      const result = { detection: await handlers.allow(req.runtime) };
-      reply(socket, result);
-      return;
-    }
-    if (req.cmd === "update") {
-      reply(socket, await handlers.update(req.auto));
-      return;
-    }
-    if (req.cmd === "stop") {
-      reply(socket, { ok: true });
-      setTimeout(() => handlers.stop(), 50).unref?.();
-      return;
-    }
-    reply(socket, { error: `unknown command "${String(req.cmd)}"` });
-  } catch (err) {
-    reply(socket, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-function reply(socket, body) {
-  try {
-    socket.end(`${JSON.stringify(body)}
-`);
-  } catch {
-    socket.destroy();
-  }
-}
-async function controlRequest(path, req, timeoutMs = CONTROL_TIMEOUT_MS) {
-  const socket = connect(path);
-  try {
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new ControlTimeout()), timeoutMs);
-      timer.unref?.();
-      socket.once("connect", () => {
-        clearTimeout(timer);
-        resolve();
-      });
-      socket.once("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-    });
-    socket.write(`${JSON.stringify(req)}
-`);
-    const line = await readLine(socket, timeoutMs);
-    if (line === null) throw new ControlTimeout();
-    return JSON.parse(line);
-  } finally {
-    socket.destroy();
-  }
-}
-var ControlTimeout = class extends Error {
-  constructor() {
-    super("the companion did not answer its control socket in time");
-    this.name = "ControlTimeout";
-  }
-};
-function isNotListening(err) {
-  const code = err?.code;
-  return code === "ENOENT" || code === "ECONNREFUSED";
-}
-function readLine(socket, timeoutMs) {
-  return new Promise((resolve) => {
-    let buf = "";
-    let settled = false;
-    const done = (v) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      socket.removeListener("data", onData);
-      resolve(v);
-    };
-    const timer = setTimeout(() => done(null), timeoutMs);
-    timer.unref?.();
-    const onData = (chunk) => {
-      buf += chunk.toString("utf8");
-      const nl = buf.indexOf("\n");
-      if (nl >= 0) done(buf.slice(0, nl));
-      else if (buf.length > 1e6) done(null);
-    };
-    socket.on("data", onData);
-    socket.once("close", () => done(null));
-    socket.once("error", () => done(null));
-  });
-}
-async function ping(path) {
-  try {
-    await controlRequest(path, { cmd: "status" });
-    return true;
-  } catch (err) {
-    return !isNotListening(err);
-  }
-}
-
-// src/bundled-binaries.ts
-import { realpathSync as realpathSync3, statSync as statSync2 } from "fs";
-import { createRequire } from "module";
-import { dirname as dirname6, join as join9 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-function nodeResolveSelf(specifier) {
-  const here = fileURLToPath4(import.meta.url);
-  if (typeof import.meta.resolve === "function") {
-    try {
-      return fileURLToPath4(import.meta.resolve(specifier));
-    } catch {
-    }
-  }
-  try {
-    return createRequire(here).resolve(specifier);
-  } catch {
-  }
-  return walkNodeModules(specifier, here);
-}
-function walkNodeModules(pkg2, fromPath) {
-  let dir2 = dirname6(fromPath);
-  for (; ; ) {
-    const manifest = join9(dir2, "node_modules", pkg2, "package.json");
-    if (nodeIsFile(manifest)) {
-      try {
-        return realpathSync3(manifest);
-      } catch {
-        return manifest;
-      }
-    }
-    const parent = dirname6(dir2);
-    if (parent === dir2) return null;
-    dir2 = parent;
-  }
-}
-function nodeResolve(specifier, fromPath) {
-  try {
-    return createRequire(fromPath).resolve(specifier);
-  } catch {
-    return null;
+}
+function nodeResolve(specifier, fromPath) {
+  try {
+    return createRequire(fromPath).resolve(specifier);
+  } catch {
+    return null;
   }
 }
 function nodeIsFile(path) {
@@ -1351,7 +897,7 @@ function resolveClaude(env) {
     const manifest = env.resolve(`${pkg2}/package.json`, sdkEntry);
     if (!manifest) continue;
     sawPackage ??= pkg2;
-    const exe = join9(dirname6(manifest), env.platform === "win32" ? "claude.exe" : "claude");
+    const exe = join7(dirname5(manifest), env.platform === "win32" ? "claude.exe" : "claude");
     if (env.isFile(exe)) {
       return { ...base, packageName: pkg2, status: "present", path: exe };
     }
@@ -1402,13 +948,13 @@ function resolveCodex(env) {
   if (!cliManifest) return { ...base, status: "platform_package_missing", path: null };
   const platformManifest = env.resolve(`${pkg2}/package.json`, cliManifest);
   if (!platformManifest) return { ...base, status: "platform_package_missing", path: null };
-  const packageRoot = join9(dirname6(platformManifest), "vendor", triple);
+  const packageRoot = join7(dirname5(platformManifest), "vendor", triple);
   const exeName = env.platform === "win32" ? "codex.exe" : "codex";
-  const current = join9(packageRoot, "bin", exeName);
-  if (env.isFile(current) && env.isFile(join9(packageRoot, "codex-package.json"))) {
+  const current = join7(packageRoot, "bin", exeName);
+  if (env.isFile(current) && env.isFile(join7(packageRoot, "codex-package.json"))) {
     return { ...base, status: "present", path: current };
   }
-  const legacy = join9(packageRoot, "codex", exeName);
+  const legacy = join7(packageRoot, "codex", exeName);
   if (env.isFile(legacy)) return { ...base, status: "present", path: legacy };
   return { ...base, status: "executable_missing", path: null };
 }
@@ -1473,18 +1019,18 @@ function warnAboutHarnessReadiness(cfg, deps = {}) {
 
 // src/runtime-file.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync5,
   readFileSync as readFileSync3,
   rmSync as rmSync3,
   writeFileSync as writeFileSync2,
   mkdirSync as mkdirSync4,
-  openSync as openSync3,
-  closeSync as closeSync2
+  openSync as openSync2,
+  closeSync
 } from "fs";
-import { join as join10 } from "path";
+import { join as join8 } from "path";
 var PROBE_TIMEOUT_MS = 1e3;
 function runtimePath() {
-  return join10(cabaneDir(), "runtime.json");
+  return join8(cabaneDir(), "runtime.json");
 }
 function serialize(state) {
   return JSON.stringify(state, null, 2) + "\n";
@@ -1500,24 +1046,24 @@ function acquireRuntimeState(state) {
   mkdirSync4(cabaneDir(), { recursive: true });
   let fd;
   try {
-    fd = openSync3(runtimePath(), "wx");
+    fd = openSync2(runtimePath(), "wx");
   } catch {
     return { acquired: false, existing: readLiveRuntimeState() };
   }
   try {
     writeFileSync2(fd, serialize(state), "utf8");
   } finally {
-    closeSync2(fd);
+    closeSync(fd);
   }
   return { acquired: true };
 }
 function clearRuntimeState() {
   const path = runtimePath();
-  if (existsSync6(path)) rmSync3(path, { force: true });
+  if (existsSync5(path)) rmSync3(path, { force: true });
 }
 function clearRuntimeStateIfOurs(instanceId) {
   const path = runtimePath();
-  if (!existsSync6(path)) return;
+  if (!existsSync5(path)) return;
   try {
     const parsed = JSON.parse(readFileSync3(path, "utf8"));
     if (parsed.instanceId && parsed.instanceId !== instanceId) return;
@@ -1529,7 +1075,7 @@ function readLiveRuntimeState({
   sweep = true
 } = {}) {
   const path = runtimePath();
-  if (!existsSync6(path)) return null;
+  if (!existsSync5(path)) return null;
   let parsed;
   try {
     parsed = JSON.parse(readFileSync3(path, "utf8"));
@@ -1543,23 +1089,257 @@ function readLiveRuntimeState({
     if (sweep) clearRuntimeState();
     return null;
   }
-  return parsed;
-}
-async function verifyRuntime(state, requestImpl = controlRequest) {
-  if (!state.instanceId || !state.socket) return "unknown";
-  let body;
-  try {
-    body = await requestImpl(
-      state.socket,
-      { cmd: "status" },
-      PROBE_TIMEOUT_MS
-    );
-  } catch (err) {
-    return isNotListening(err) ? "stale" : "unknown";
+  return parsed;
+}
+async function verifyRuntime(state, requestImpl = controlRequest) {
+  if (!state.instanceId || !state.socket) return "unknown";
+  let body;
+  try {
+    body = await requestImpl(
+      state.socket,
+      { cmd: "status" },
+      PROBE_TIMEOUT_MS
+    );
+  } catch (err) {
+    return isNotListening(err) ? "stale" : "unknown";
+  }
+  if (typeof body?.instance_id !== "string") return "unknown";
+  return body.instance_id === state.instanceId ? "ours" : "stale";
+}
+
+// src/state.ts
+import { EventEmitter } from "events";
+function dispatchToWire(r) {
+  return {
+    id: r.id,
+    timestamp: r.timestamp,
+    workspace_slug: r.workspaceSlug,
+    ...r.agentUsername ? { agent_username: r.agentUsername } : {},
+    message: r.message,
+    status: r.status,
+    ...r.durationMs !== void 0 ? { duration_ms: r.durationMs } : {},
+    ...r.error ? { error: r.error } : {},
+    ...r.reply ? { reply: r.reply } : {}
+  };
+}
+var MAX_DISPATCHES = 50;
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+var CompanionStateHub = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.emitter.setMaxListeners(0);
+  }
+  opts;
+  emitter = new EventEmitter();
+  workspaces = /* @__PURE__ */ new Map();
+  dispatches = [];
+  dashboardUrl = null;
+  deviceId = null;
+  deviceLabel = null;
+  deviceError = null;
+  // The latest harness snapshot the supervisor probed, or null before the
+  // first probe (see CompanionStatusJson.harnesses).
+  harnesses = null;
+  // ---- subscription (SSE) ----
+  on(listener) {
+    this.emitter.on("event", listener);
+    return () => this.emitter.off("event", listener);
+  }
+  emit(type, data) {
+    this.emitter.emit("event", { type, data });
+  }
+  // ---- device ----
+  setDevice(info) {
+    if (info.deviceId !== void 0) this.deviceId = info.deviceId;
+    if (info.deviceLabel !== void 0) this.deviceLabel = info.deviceLabel;
+    this.emitStatus();
+  }
+  setDeviceError(message) {
+    if (this.deviceError === message) return;
+    this.deviceError = message;
+    this.emitStatus();
+  }
+  clearDeviceError() {
+    if (this.deviceError === null) return;
+    this.deviceError = null;
+    this.emitStatus();
+  }
+  // ---- harnesses ----
+  // Replace the harness snapshot and push a status change (so the SSE feed flips
+  // the Companion's Harnesses surface live). The supervisor calls this on each
+  // heartbeat-cadence probe and on an on-demand recheck.
+  setHarnesses(harnesses) {
+    this.harnesses = harnesses;
+    this.emitStatus();
+  }
+  // ---- workspace lifecycle ----
+  registerWorkspace(ws) {
+    const existing = this.workspaces.get(ws.workspaceId);
+    if (existing) {
+      existing.slug = ws.slug;
+      existing.name = ws.name;
+      return;
+    }
+    this.workspaces.set(ws.workspaceId, {
+      workspaceId: ws.workspaceId,
+      slug: ws.slug,
+      name: ws.name,
+      connected: false,
+      authFailed: false,
+      lastEventAt: null,
+      dispatchCountToday: 0,
+      countDate: today(),
+      agents: /* @__PURE__ */ new Map()
+    });
+    this.emitStatus();
+  }
+  removeWorkspace(workspaceId) {
+    const ws = this.workspaces.get(workspaceId);
+    if (!ws) return;
+    this.workspaces.delete(workspaceId);
+    this.emit("workspace:disconnected", { slug: ws.slug });
+    this.emitStatus();
+  }
+  setConnected(workspaceId, connected) {
+    const ws = this.workspaces.get(workspaceId);
+    if (!ws || ws.connected === connected) return;
+    ws.connected = connected;
+    if (connected) ws.authFailed = false;
+    this.emitStatus();
+  }
+  setAuthFailed(workspaceId) {
+    const ws = this.workspaces.get(workspaceId);
+    if (!ws) return;
+    if (ws.authFailed && !ws.connected) return;
+    ws.authFailed = true;
+    ws.connected = false;
+    this.emitStatus();
+  }
+  recordEvent(workspaceId) {
+    const ws = this.workspaces.get(workspaceId);
+    if (!ws) return;
+    ws.lastEventAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  // ---- agents ----
+  // Upsert one assigned agent's observable state (called on each reconcile).
+  setAgent(workspaceId, agent) {
+    const ws = this.workspaces.get(workspaceId);
+    if (!ws) return;
+    ws.agents.set(agent.agentId, agent);
+    this.emitStatus();
+  }
+  removeAgent(workspaceId, agentId) {
+    const ws = this.workspaces.get(workspaceId);
+    if (!ws) return;
+    if (ws.agents.delete(agentId)) this.emitStatus();
+  }
+  // ---- dispatch feed ----
+  // A DispatchObserver bound to one (workspace, agent), handed to that agent's
+  // Dispatcher by the supervisor.
+  observerFor(workspaceId, agentId, slug) {
+    const username = () => this.workspaces.get(workspaceId)?.agents.get(agentId)?.username ?? "";
+    return {
+      onStart: (info) => this.dispatchStarted(workspaceId, slug, username(), info),
+      onEnd: (info) => this.dispatchEnded(slug, username(), info)
+    };
+  }
+  bumpCount(workspaceId) {
+    const ws = this.workspaces.get(workspaceId);
+    if (!ws) return;
+    const day = today();
+    if (ws.countDate !== day) {
+      ws.countDate = day;
+      ws.dispatchCountToday = 0;
+    }
+    ws.dispatchCountToday += 1;
+  }
+  dispatchStarted(workspaceId, slug, agentUsername, info) {
+    this.bumpCount(workspaceId);
+    const record = {
+      id: info.id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      workspaceSlug: slug,
+      ...agentUsername ? { agentUsername } : {},
+      message: info.message,
+      status: "running"
+    };
+    this.upsertDispatch(record);
+    this.emit("dispatch:started", dispatchToWire(record));
+    this.emitStatus();
+  }
+  dispatchEnded(slug, agentUsername, info) {
+    const existing = this.dispatches.find((d) => d.id === info.id);
+    const record = {
+      id: info.id,
+      timestamp: existing?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      workspaceSlug: existing?.workspaceSlug ?? slug,
+      ...existing?.agentUsername ?? agentUsername ? { agentUsername: existing?.agentUsername ?? agentUsername } : {},
+      message: existing?.message ?? "",
+      status: info.ok ? "replied" : "error",
+      durationMs: info.durationMs,
+      ...info.reason ? { error: info.reason } : {},
+      ...info.reply ? { reply: info.reply } : {}
+    };
+    this.upsertDispatch(record);
+    this.emit(info.ok ? "dispatch:completed" : "dispatch:error", dispatchToWire(record));
+  }
+  upsertDispatch(record) {
+    const idx = this.dispatches.findIndex((d) => d.id === record.id);
+    if (idx >= 0) {
+      this.dispatches[idx] = record;
+      return;
+    }
+    this.dispatches.unshift(record);
+    if (this.dispatches.length > MAX_DISPATCHES) this.dispatches.length = MAX_DISPATCHES;
+  }
+  // ---- snapshots for the HTTP routes ----
+  setDashboardUrl(url) {
+    this.dashboardUrl = url;
+  }
+  recentDispatches(limit = 20) {
+    return this.dispatches.slice(0, Math.max(0, limit));
+  }
+  statusJson() {
+    const list = [...this.workspaces.values()].sort((a, b) => a.name.localeCompare(b.name));
+    const lastOverall = list.reduce((acc, ws) => {
+      if (!ws.lastEventAt) return acc;
+      if (!acc || ws.lastEventAt > acc) return ws.lastEventAt;
+      return acc;
+    }, null);
+    return {
+      cabane_url: this.opts.baseUrl,
+      device_id: this.deviceId,
+      device_label: this.deviceLabel,
+      device_error: this.deviceError,
+      connected: list.some((ws) => ws.connected),
+      workspaces: list.map((ws) => ({
+        slug: ws.slug,
+        name: ws.name,
+        last_event_at: ws.lastEventAt,
+        dispatch_count_today: ws.dispatchCountToday,
+        connected: ws.connected,
+        auth_failed: ws.authFailed,
+        agents: [...ws.agents.values()].sort((a, b) => a.username.localeCompare(b.username)).map((a) => ({
+          agent_id: a.agentId,
+          username: a.username,
+          display_name: a.displayName,
+          has_credential: a.hasCredential,
+          missing_secrets: a.missingSecrets
+        }))
+      })),
+      last_event_at_overall: lastOverall,
+      dashboard_url: this.dashboardUrl,
+      companion_version: this.opts.companionVersion,
+      instance_id: this.opts.instanceId ?? null,
+      harnesses: this.harnesses
+    };
+  }
+  emitStatus() {
+    this.emit("status:changed", this.statusJson());
   }
-  if (typeof body?.instance_id !== "string") return "unknown";
-  return body.instance_id === state.instanceId ? "ours" : "stale";
-}
+};
 
 // src/heartbeat-status.ts
 import { z as z3 } from "zod";
@@ -2516,27 +2296,27 @@ function requestSignal(signal, timeoutMs = 5e3) {
 // src/credentials.ts
 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 join11 } from "path";
+import { join as join9 } from "path";
 import { z as z5 } from "zod";
 var credentialMapSchema = z5.record(z5.string(), z5.string());
 function credentialsDir() {
-  return join11(cabaneDir(), "credentials");
+  return join9(cabaneDir(), "credentials");
 }
 function legacyPath() {
-  return join11(cabaneDir(), "credentials.json");
+  return join9(cabaneDir(), "credentials.json");
 }
 function devicePath(deviceId) {
-  return join11(credentialsDir(), `${deviceId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+  return join9(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");
@@ -2601,18 +2381,18 @@ function pruneCredentials(deviceId, keepAgentIds) {
 }
 
 // src/dispatch-dedupe.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync4, existsSync as existsSync8 } from "fs";
-import { join as join12 } from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync4, existsSync as existsSync7 } from "fs";
+import { join as join10 } from "path";
 var MAX_IDS = 256;
 function dir(log) {
-  return join12(cabaneDir(), log);
+  return join10(cabaneDir(), log);
 }
 function pathFor(log, workspaceId) {
-  return join12(dir(log), encodeURIComponent(workspaceId));
+  return join10(dir(log), encodeURIComponent(workspaceId));
 }
 function readIds(log, workspaceId) {
   const path = pathFor(log, 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 {
@@ -2645,15 +2425,15 @@ function markCompleted(workspaceId, eventId) {
 }
 var MAX_RESUME_ATTEMPTS = 3;
 function resumeDir() {
-  return join12(cabaneDir(), "resume-attempts");
+  return join10(cabaneDir(), "resume-attempts");
 }
 function resumePathFor(workspaceId) {
-  return join12(resumeDir(), encodeURIComponent(workspaceId));
+  return join10(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();
@@ -2684,16 +2464,16 @@ function bumpResumeAttempt(workspaceId, eventId) {
   return next;
 }
 function turnDir() {
-  return join12(cabaneDir(), "turns");
+  return join10(cabaneDir(), "turns");
 }
 function turnPathFor(workspaceId) {
-  return join12(turnDir(), encodeURIComponent(workspaceId));
+  return join10(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();
@@ -2875,7 +2655,7 @@ var turnOutcomes = ["success", "failure", "cancelled", "skipped"];
 var turnSessionModes = ["fresh", "resumed", "degraded"];
 var turnRuntimeResultKinds = ["success", "error", "no_terminal"];
 var 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",
@@ -3016,15 +2796,6 @@ function standingSegments(req) {
   return req.standing ?? { core: req.systemPrompt, conversation: "" };
 }
 
-// packages/agent-runtime/src/conformance.ts
-import { z as z9 } from "zod";
-var 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 };
@@ -3292,7 +3063,7 @@ function envResolvedFrom(server, secretEnv) {
 }
 
 // packages/agent-runtime/src/claude-code/policy.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var SUBAGENT_TOOLS = ["Task", "Agent"];
 var UNSUPPORTED_TOOLS = ["AskUserQuestion"];
 var STRANDING_TOOLS = [
@@ -3319,18 +3090,18 @@ function withThinkingSummaries(thinking) {
   if (thinking.type === "disabled") return thinking;
   return { display: "summarized", ...thinking };
 }
-var claudeCodeDialectSchema = z10.object({
-  thinking: z10.discriminatedUnion("type", [
-    z10.object({
-      type: z10.literal("adaptive"),
-      display: z10.enum(["summarized", "omitted"]).optional()
+var 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();
 function readThinking(runtimeOptions) {
@@ -3393,7 +3164,7 @@ async function preToolUseHook(input) {
     hookSpecificOutput: {
       hookEventName: "PreToolUse",
       permissionDecision: "allow",
-      permissionDecisionReason: "headless never-prompt (CT680)",
+      permissionDecisionReason: "headless never-prompt",
       updatedInput: toolInput
     }
   };
@@ -3918,7 +3689,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",
@@ -3947,7 +3718,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 }
         );
       }
@@ -3979,538 +3750,6 @@ function createClaudeCodeAdapter(deps = {}) {
 }
 var claudeCodeAdapter = createClaudeCodeAdapter();
 
-// packages/agent-runtime/src/claude-code/conformance.ts
-var ABORT_SENTINEL = { __abortHere: true };
-var CWD = "/env/here";
-var HEALTHY_MCP_INVENTORY = {
-  initReceived: true,
-  servers: [{ name: "cabane", status: "connected" }],
-  toolCount: 1
-};
-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 init = (sessionId, model) => ({
-  type: "system",
-  subtype: "init",
-  session_id: sessionId,
-  mcp_servers: HEALTHY_MCP_INVENTORY.servers,
-  tools: ["mcp__cabane__query"],
-  ...model ? { model } : {}
-});
-var assistantText = (text) => ({
-  type: "assistant",
-  message: { content: [{ type: "text", text }] }
-});
-var assistantTextTool = (text, tool2) => ({
-  type: "assistant",
-  message: {
-    content: [
-      { type: "text", text },
-      { type: "tool_use", id: tool2.id, name: tool2.name, input: tool2.input }
-    ]
-  }
-});
-var toolResult = (id, content, isError = false) => ({
-  type: "user",
-  message: { content: [{ type: "tool_result", tool_use_id: id, is_error: isError, content }] }
-});
-var resultSuccess = (sessionId) => ({
-  type: "result",
-  subtype: "success",
-  session_id: sessionId
-});
-var resultSuccessFull = (sessionId, extra) => ({
-  ...resultSuccess(sessionId),
-  ...extra
-});
-var resultError = (subtype) => ({
-  type: "result",
-  subtype,
-  session_id: "s"
-});
-var resultErrorFull = (subtype, extra = {}) => ({
-  type: "result",
-  subtype,
-  session_id: "s",
-  ...extra
-});
-var rateLimitEvent = (status, resetsAt, rateLimitType) => ({
-  type: "rate_limit_event",
-  rate_limit_info: {
-    status,
-    ...resetsAt !== void 0 ? { resetsAt } : {},
-    ...rateLimitType !== void 0 ? { rateLimitType } : {}
-  },
-  session_id: "s"
-});
-var authStatus = (error) => ({
-  type: "auth_status",
-  isAuthenticating: false,
-  output: [],
-  error,
-  session_id: "s"
-});
-var sessionEvent = (sdkSessionId, cwd = CWD, degraded = false) => ({
-  type: "session",
-  state: encodeSession({ sdkSessionId, cwd }),
-  ...degraded ? { degraded: true } : {}
-});
-var 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 }
-    ]
-  }
-];
-var 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/opencode/addendum.ts
 var OPENCODE_ADDENDUM = [
   "Every tool here goes by its plain name: the workspace tools are `query`, `mutate` and",
@@ -4752,7 +3991,7 @@ function sealHeld(held, terminal) {
 }
 
 // packages/agent-runtime/src/opencode/policy.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 var OPENCODE_SCHEDULING_TOOLS = [];
 var OPENCODE_UI_PROMPT_TOOLS = ["question"];
 function opencodeTools() {
@@ -4761,8 +4000,8 @@ function opencodeTools() {
     tools[name] = false;
   return tools;
 }
-var opencodeDialectSchema = z11.object({
-  agent: z11.string().min(1).optional()
+var opencodeDialectSchema = z10.object({
+  agent: z10.string().min(1).optional()
 }).loose();
 function readOpencodeDialect(runtimeOptions) {
   const parsed = opencodeDialectSchema.safeParse(runtimeOptions?.["opencode"] ?? {});
@@ -5146,516 +4385,40 @@ 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 }
         );
-      }
-      let degraded = "fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session";
-      if ("fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session" && hooks?.fresh) {
-        const recomposed = await hooks.fresh(decision.reason);
-        if (signal.aborted) return;
-        if (recomposed) {
-          req = { ...req, ...recomposed, session: null };
-          degraded = false;
-        }
-      }
-      const spec = buildRunSpec(req, resume);
-      const result = await transport.run(spec, signal);
-      if (signal.aborted) return;
-      if (result.created || result.sessionId !== resume) {
-        yield {
-          type: "session",
-          state: encodeSession2({ sessionId: result.sessionId, directory: result.directory }),
-          ...degraded ? { degraded: true } : {}
-        };
-      }
-      yield* decodeOpencodeStream(result.events, {
-        signal,
-        sessionId: result.sessionId,
-        // The keys the turn's servers were installed under: what the decoder
-        // splits a raw `<server>_<tool>` id on.
-        mcpServers: Object.keys(spec.mcp)
-      });
-    }
-  };
-}
-var opencodeAdapter = createOpencodeAdapter();
-
-// packages/agent-runtime/src/opencode/conformance.ts
-var ABORT_SENTINEL2 = { __abortHere: true };
-var NEW_SESSION_ID = "sess_new";
-var BOUNDED_NOTICE = "You've hit your usage limit \xB7 ".padEnd(200, "x");
-var DIR = "/env/here";
-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 textPart = (id, text) => ({
-  type: "message.part.updated",
-  properties: { part: { type: "text", id, text } }
-});
-var reasoningPart = (id, text) => ({
-  type: "message.part.updated",
-  properties: { part: { type: "reasoning", id, text } }
-});
-var toolPart = (id, tool2, state, callID) => ({
-  type: "message.part.updated",
-  properties: { part: { type: "tool", id, tool: tool2, state, ...callID ? { callID } : {} } }
-});
-var messageUpdated = (role, id) => ({
-  type: "message.updated",
-  properties: { info: { role, id } }
-});
-var echoedUserPart = (partId, messageID, text) => ({
-  type: "message.part.updated",
-  properties: { part: { type: "text", id: partId, messageID, text } }
-});
-var idle = () => ({ type: "session.idle", properties: {} });
-var errored = (message) => ({
-  type: "session.error",
-  properties: { error: { message } }
-});
-var sessionEvent2 = (sessionId, directory = DIR, degraded = false) => ({
-  type: "session",
-  state: encodeSession2({ sessionId, directory }),
-  ...degraded ? { degraded: true } : {}
-});
-var 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 }
-    ]
-  }
-];
+      }
+      let degraded = "fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session";
+      if ("fresh" in decision && decision.reason !== void 0 && decision.reason !== "no_session" && hooks?.fresh) {
+        const recomposed = await hooks.fresh(decision.reason);
+        if (signal.aborted) return;
+        if (recomposed) {
+          req = { ...req, ...recomposed, session: null };
+          degraded = false;
+        }
+      }
+      const spec = buildRunSpec(req, resume);
+      const result = await transport.run(spec, signal);
+      if (signal.aborted) return;
+      if (result.created || result.sessionId !== resume) {
+        yield {
+          type: "session",
+          state: encodeSession2({ sessionId: result.sessionId, directory: result.directory }),
+          ...degraded ? { degraded: true } : {}
+        };
+      }
+      yield* decodeOpencodeStream(result.events, {
+        signal,
+        sessionId: result.sessionId,
+        // The keys the turn's servers were installed under: what the decoder
+        // splits a raw `<server>_<tool>` id on.
+        mcpServers: Object.keys(spec.mcp)
+      });
+    }
+  };
+}
+var opencodeAdapter = createOpencodeAdapter();
 
 // packages/agent-runtime/src/codex/addendum.ts
 var CODEX_ADDENDUM = [
@@ -6068,13 +4831,13 @@ function sealHeld2(held, terminal) {
 }
 
 // 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";
 }
 var CODEX_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
-var codexDialectSchema = z12.object({
-  modelReasoningEffort: z12.enum(CODEX_REASONING_EFFORTS).optional()
+var codexDialectSchema = z11.object({
+  modelReasoningEffort: z11.enum(CODEX_REASONING_EFFORTS).optional()
 }).loose();
 function readCodexDialect(runtimeOptions) {
   const parsed = codexDialectSchema.safeParse(runtimeOptions?.["codex"] ?? {});
@@ -6377,7 +5140,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 }
         );
       }
@@ -6422,7 +5185,7 @@ 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 {
@@ -6431,7 +5194,7 @@ function createCodexAdapter(deps = {}) {
             } catch (err) {
               if (!signal.aborted) {
                 deps.onWarn?.(
-                  "codex adapter: preparing the images failed \u2014 the turn runs without them (CT1757)",
+                  "codex adapter: preparing the images failed \u2014 the turn runs without them",
                   { err: err instanceof Error ? err.message : String(err) }
                 );
               }
@@ -6507,7 +5270,7 @@ function createCodexAdapter(deps = {}) {
           try {
             await images.cleanup();
           } catch (err) {
-            deps.onWarn?.("codex adapter: image cleanup failed (CT1757)", {
+            deps.onWarn?.("codex adapter: image cleanup failed", {
               err: err instanceof Error ? err.message : String(err)
             });
           }
@@ -6518,993 +5281,6 @@ function createCodexAdapter(deps = {}) {
 }
 var codexAdapter = createCodexAdapter();
 
-// packages/agent-runtime/src/codex/conformance.ts
-var ABORT_SENTINEL3 = { __abortHere: true };
-var NEW_THREAD_ID = "th_new";
-var BOUNDED_NOTICE2 = "You've hit your usage limit \xB7 ".padEnd(200, "x");
-var DIR2 = "/env/here";
-var PROMPT = "system";
-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 threadStarted = (threadId) => ({
-  type: "thread.started",
-  thread_id: threadId
-});
-var agentMessage = (id, text) => ({
-  type: "item.completed",
-  item: { id, type: "agent_message", text }
-});
-var reasoning = (id, text) => ({
-  type: "item.completed",
-  item: { id, type: "reasoning", text }
-});
-var toolFrame = (evType, item) => ({ type: evType, item });
-var turnCompleted = (usage) => ({
-  type: "turn.completed",
-  ...usage ? { usage } : {}
-});
-var turnFailed = (message) => ({
-  type: "turn.failed",
-  error: { message }
-});
-var fatalError = (message) => ({ type: "error", message });
-var errorItem = (id, message) => ({
-  type: "item.completed",
-  item: { id, type: "error", message }
-});
-var OP_SUCCESS = { ok: true, result: { source: "native" } };
-var OP_FAILURE = {
-  ok: false,
-  error: {
-    kind: "output_too_large",
-    code: "output_too_large",
-    message: "files.read returned more than the result ceiling"
-  }
-};
-var startedSession = (threadId, cwd = DIR2, degraded = false) => ({
-  type: "session",
-  state: encodeSession3({ threadId, cwd, promptFingerprint: null, usageBaseline: null }),
-  ...degraded ? { degraded: true } : {}
-});
-var closingSession = (threadId, usageBaseline = null) => ({
-  type: "session",
-  state: encodeSession3({
-    threadId,
-    cwd: DIR2,
-    promptFingerprint: fingerprintPrompt(PROMPT),
-    usageBaseline,
-    compactions: 0
-  })
-});
-var 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" } }
-      }
-    }),
-    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" }
-      }
-    ]
-  },
-  {
-    // 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 }
-    ]
-  }
-];
-
 // packages/agent-runtime/src/claude-code/sdk.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 
@@ -7644,47 +5420,47 @@ function classifyStopError(message) {
 }
 
 // src/runner/protocol.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 
 // src/run-config.ts
-import { z as z13 } from "zod";
-var 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(),
+import { z as z12 } from "zod";
+var 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()
 });
-var mcpHttpServerSchema = z13.object({
-  type: z13.literal("http"),
-  url: z13.string().url(),
-  headers: z13.record(z13.string(), z13.string()).optional(),
+var 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()
 });
-var mcpSseServerSchema = z13.object({
-  type: z13.literal("sse"),
-  url: z13.string().url(),
-  headers: z13.record(z13.string(), z13.string()).optional(),
+var 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()
 });
-var mcpServerDefSchema = z13.union([mcpHttpServerSchema, mcpSseServerSchema, mcpStdioServerSchema]);
-var 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") })
+var mcpServerDefSchema = z12.union([mcpHttpServerSchema, mcpSseServerSchema, mcpStdioServerSchema]);
+var 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") })
 ]);
-var effortSchema = z13.enum(["low", "medium", "high", "xhigh", "max"]);
-var runConfigSchema = z13.object({
-  mcpServers: z13.record(z13.string(), mcpServerDefSchema).optional(),
-  model: z13.string().min(1).optional(),
+var effortSchema = z12.enum(["low", "medium", "high", "xhigh", "max"]);
+var runConfigSchema = z12.object({
+  mcpServers: z12.record(z12.string(), mcpServerDefSchema).optional(),
+  model: z12.string().min(1).optional(),
   thinking: thinkingConfigSchema.optional(),
   effort: effortSchema.optional()
 });
@@ -7712,61 +5488,61 @@ var RUNNER_ENV = {
   // Everything else the turn is constructed from, as JSON: see `RunnerSpec`.
   spec: "CABANE_RUNNER_SPEC"
 };
-var runtimeHealthSchema = z14.object({
-  quotaState: z14.enum(["ok", "limited", "auth_expired", "unknown"]),
-  limitedUntil: z14.string().nullable(),
-  lastError: z14.string().nullable()
+var runtimeHealthSchema = z13.object({
+  quotaState: z13.enum(["ok", "limited", "auth_expired", "unknown"]),
+  limitedUntil: z13.string().nullable(),
+  lastError: z13.string().nullable()
 });
-var runnerSpecSchema = z14.object({
-  deviceId: z14.string().optional(),
+var 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()
 });
-var 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()
+var 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()
 });
-var 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()
+var 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()
 });
 function runnerEnv(input) {
   return {
@@ -7801,6 +5577,30 @@ function decodeRunnerEvent(line) {
   return value;
 }
 
+// src/credential-broker/client-config.ts
+import { parse, stringify } from "smol-toml";
+var BROKERED_CREDENTIAL_NAMES = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CODE_OAUTH_REFRESH_TOKEN",
+  "CLAUDE_CODE_SESSION_ACCESS_TOKEN",
+  "CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR",
+  "CLAUDE_CODE_HOST_CREDS_FILE",
+  "CODEX_API_KEY",
+  "OPENAI_API_KEY",
+  "OPENAI_ACCESS_TOKEN",
+  "GH_TOKEN",
+  "GITHUB_TOKEN",
+  "GH_ENTERPRISE_TOKEN",
+  "GITHUB_ENTERPRISE_TOKEN"
+]);
+function withoutBrokeredCredentials(values) {
+  return Object.fromEntries(
+    Object.entries(values).filter(([name]) => !BROKERED_CREDENTIAL_NAMES.has(name))
+  );
+}
+
 // src/runner/launch.ts
 function gzipBodiesSignal() {
   let on = false;
@@ -8064,12 +5864,22 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   }
   try {
     const wrapped = launch.wrapped === true;
-    const env = runnerExecEnv(launch.env ?? process.env, wrapped);
-    const grants = minted.deviceGrants.length > 0 ? launch.grants?.(minted.deviceGrants) ?? {} : {};
+    if (launch.brokeredCredentials && !wrapped)
+      throw new Error("credential broker requires a wrapped runner");
+    const inherited = runnerExecEnv(launch.env ?? process.env, wrapped);
+    const env = launch.brokeredCredentials ? withoutBrokeredCredentials(inherited) : inherited;
+    const directGrants = minted.deviceGrants.length > 0 ? launch.grants?.(minted.deviceGrants) ?? {} : {};
+    const grants = launch.brokeredCredentials ? Object.fromEntries(
+      Object.entries(directGrants).map(([key, values]) => [
+        key,
+        withoutBrokeredCredentials(values)
+      ])
+    ) : directGrants;
+    const secrets = wrapped ? launch.secrets?.() ?? {} : void 0;
     const input = {
       baseUrl: opts.baseUrl,
       credential: minted.credential,
-      ...wrapped ? { secrets: launch.secrets?.() ?? {} } : {},
+      ...secrets ? { secrets: launch.brokeredCredentials ? withoutBrokeredCredentials(secrets) : secrets } : {},
       ...Object.keys(grants).length > 0 ? { grants } : {},
       dispatch: payload,
       turnId,
@@ -8236,12 +6046,12 @@ import { randomUUID as randomUUID2 } from "crypto";
 
 // 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";
 
 // src/grants.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join13 } from "path";
-import { z as z15 } from "zod";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { join as join11 } from "path";
+import { z as z14 } from "zod";
 var VARIABLE_NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
 function allowedGrantVariable(name) {
   return name.length <= 100 && VARIABLE_NAME_RE.test(name) && !name.startsWith("CABANE_");
@@ -8250,9 +6060,9 @@ function environmentSafe(value) {
   return !value.includes("\0");
 }
 function grantsPath() {
-  return join13(cabaneDir(), "grants.json");
+  return join11(cabaneDir(), "grants.json");
 }
-var grantsFileSchema = z15.record(z15.string(), z15.record(z15.string(), z15.string()));
+var grantsFileSchema = z14.record(z14.string(), z14.record(z14.string(), z14.string()));
 function readGrants(keys, report) {
   if (keys.length === 0) return {};
   const file = loadGrantsFile(report);
@@ -8270,7 +6080,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");
@@ -8299,11 +6109,11 @@ function loadGrantsFile(report) {
 
 // src/work-dir.ts
 import { statSync as statSync3 } from "fs";
-import { join as join14 } from "path";
+import { join as join12 } from "path";
 
 // src/turn-control-tools.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 var COMPANION_LOCAL_MCP_SERVER = TURN_CONTROL_MCP_SERVER;
 var COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
 var ASK_TOOL = "ask";
@@ -8316,39 +6126,39 @@ var CANCEL_WAKE_TOOL = "cancel_wake";
 var CANCEL_WAKE_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${CANCEL_WAKE_TOOL}`;
 
 // src/codex-config.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join15 } from "path";
-import { parse } from "smol-toml";
+import { join as join13 } from "path";
+import { parse as parse2 } from "smol-toml";
 
 // src/codex-images.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join16 } from "path";
+import { join as join14 } from "path";
 
 // src/codex-compactions.ts
 import { createReadStream } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { join as join17 } from "path";
+import { join as join15 } from "path";
 import { createInterface as createInterface2 } from "readline";
 
 // src/prepared.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "fs";
-import { join as join18 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync9 } from "fs";
+import { join as join16 } from "path";
 
 // src/secrets.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { join as join19 } from "path";
-import { z as z17 } from "zod";
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { join as join17 } from "path";
+import { z as z16 } from "zod";
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function secretsPath() {
-  return join19(cabaneDir(), "secrets.json");
+  return join17(cabaneDir(), "secrets.json");
 }
-var secretStoreSchema = z17.record(z17.string(), z17.string());
+var secretStoreSchema = z16.record(z16.string(), z16.string());
 function loadSecretValues() {
   const path = secretsPath();
-  if (!existsSync11(path)) return {};
+  if (!existsSync10(path)) return {};
   let raw;
   try {
     raw = readFileSync9(path, "utf8");
@@ -8533,9 +6343,9 @@ function runBounded(path, args, env) {
 
 // src/transcript-writer.ts
 import { appendFileSync, chmodSync as chmodSync4, copyFileSync, mkdirSync as mkdirSync8, readdirSync, rmSync as rmSync6 } from "fs";
-import { basename as basename3, dirname as dirname7, join as join20 } from "path";
+import { basename as basename3, dirname as dirname6, join as join18 } from "path";
 function transcriptsDir() {
-  return join20(cabaneDir(), "transcripts");
+  return join18(cabaneDir(), "transcripts");
 }
 
 // src/turn-execution.ts
@@ -8645,7 +6455,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;
@@ -8660,7 +6470,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 {
@@ -8897,7 +6707,7 @@ function checkReason(check) {
 
 // src/harness-copy.ts
 import { homedir as homedir8 } from "os";
-import { join as join21, win32 } from "path";
+import { join as join19, win32 } from "path";
 var HARNESS_LABELS = {
   "claude-code": "Claude Code",
   codex: "Codex",
@@ -8911,7 +6721,7 @@ function failureText(runtime, reason) {
     case "spawn":
       return `Couldn't check whether ${label} is signed in: Cabane's bundled ${label} wouldn't start. Repair it with  ${repairSteps()}  and try again.${spaced(repairCost())}`;
     case "config":
-      return `Couldn't check whether ${label} is signed in: its configuration file didn't load${runtime === "codex" ? ` (${tildePath(join21(homedir8(), ".codex", "config.toml"))})` : ""}. Fix it, then try again.`;
+      return `Couldn't check whether ${label} is signed in: its configuration file didn't load${runtime === "codex" ? ` (${tildePath(join19(homedir8(), ".codex", "config.toml"))})` : ""}. Fix it, then try again.`;
     case "unreadable":
       return `Couldn't check whether ${label} is signed in: it answered in a way Cabane couldn't read. Try again, and if it keeps happening, update Cabane.`;
   }
@@ -8962,12 +6772,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");
@@ -9168,7 +6978,7 @@ var DispatchClaims = class {
 
 // src/outbox.ts
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync2,
   readFileSync as readFileSync11,
@@ -9176,7 +6986,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 = 2e3;
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var Outbox = class {
@@ -9189,10 +6999,10 @@ var Outbox = class {
   // 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
@@ -9224,7 +7034,7 @@ var Outbox = class {
   // wedging the drain.
   list() {
     const dir2 = this.dir();
-    if (!existsSync14(dir2)) return [];
+    if (!existsSync13(dir2)) return [];
     let names;
     try {
       names = readdirSync2(dir2);
@@ -9234,7 +7044,7 @@ var Outbox = class {
     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") {
@@ -9270,7 +7080,7 @@ var Outbox = class {
   // 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;
@@ -9290,7 +7100,7 @@ var Outbox = class {
   }
   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 {
@@ -9457,8 +7267,8 @@ var SseSubscriber = class {
 
 // src/updater.ts
 import { spawn as spawn5 } 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 {
@@ -9470,7 +7280,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) {
@@ -9493,7 +7303,7 @@ function rolledBackState(state, pending, reason, now) {
 
 // src/install-layout.ts
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync14,
   lstatSync,
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync13,
@@ -9503,26 +7313,26 @@ 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 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;
@@ -9531,14 +7341,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 {
@@ -9550,11 +7360,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;
@@ -9573,31 +7383,31 @@ function compareVersions(a, b) {
 
 // src/update-state.ts
 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 {
@@ -9608,7 +7418,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 });
@@ -9642,14 +7452,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);
@@ -9686,17 +7496,17 @@ var runProcess = (command, args, opts = {}) => new Promise((resolve) => {
 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,
@@ -9713,7 +7523,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
     }
   );
@@ -9725,7 +7535,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 });
@@ -9737,7 +7547,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" }
   });
@@ -9745,7 +7555,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 = {};
@@ -10761,6 +8571,7 @@ var CompanionSupervisor = class {
         ),
         ...this.config.runner?.command ? {
           wrapped: true,
+          brokeredCredentials: this.config.runner.brokeredCredentials,
           secrets: () => loadSecretValuesTolerant(
             (m) => this.log.warn({ err: m }, "Could not read the secrets file for a wrapped turn.")
           )
@@ -11517,10 +9328,10 @@ function handleUncaught(log, err, origin) {
 }
 
 // src/crash-marker.ts
-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(rec) {
   try {
@@ -11532,7 +9343,7 @@ function recordCrash(rec) {
 function clearCrash() {
   try {
     const path = crashMarkerPath();
-    if (existsSync17(path)) rmSync11(path, { force: true });
+    if (existsSync16(path)) rmSync11(path, { force: true });
   } catch {
   }
 }
@@ -11540,7 +9351,7 @@ function clearCrash() {
 // src/stray-companion.ts
 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) {
@@ -11557,7 +9368,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$/, "");
@@ -11629,7 +9440,7 @@ function strayCompanionLines(strays, retry) {
 // src/runtime.ts
 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" }
@@ -11724,11 +9535,12 @@ async function createCompanionRuntime(opts = {}) {
       update: (auto) => active2.update(auto),
       stop: () => void stop().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);
@@ -11788,7 +9600,10 @@ async function createCompanionRuntime(opts = {}) {
   };
 }
 export {
+  ApiError,
+  CompanionError,
   createCompanionRuntime,
+  dispatchToWire,
   embeddedRunner,
   strayCompanionLines
 };