@cabane/companion 0.6.35 → 0.6.37

package/dist/cli.js

@@ -806,8 +806,12 @@ async function warnAboutHarnessReadiness(cfg, deps = {}) {
     ...claudeInstalled ? ["Claude Code"] : [],
     ...codexInstalled ? ["Codex"] : []
   ];
+  const connectCommands = [
+    ...claudeInstalled ? ["`cabane-companion connect claude-code`"] : [],
+    ...codexInstalled ? ["`cabane-companion connect codex`"] : []
+  ];
   warn(
-    "No harness is connected on this device yet, so no agent turn can run here. " + (installed.length > 0 ? `We found ${installed.join(" and ")} on this machine \u2014 connect ${installed.length > 1 ? "one" : "it"} in the Companion dashboard (or in cabane, Settings \u2192 Devices) and turns start routing here.` : "Install a harness and sign in \u2014 Claude Code (`npm i -g @anthropic-ai/claude-code`), the Codex CLI (`codex login`), or `opencode serve` \u2014 then connect it in the Companion dashboard.")
+    "No harness is connected on this device yet, so no agent turn can run here. " + (installed.length > 0 ? `We found ${installed.join(" and ")} on this machine \u2014 connect ${installed.length > 1 ? "one with " : "it with "}${connectCommands.join(" or ")} and turns start routing here.` : "Install a harness and sign in \u2014 Claude Code (`npm i -g @anthropic-ai/claude-code`), the Codex CLI (`codex login`), or `opencode serve` \u2014 then connect it with `cabane-companion connect <harness>` (pass `--url <url>` for opencode).")
   );
 }
 
@@ -1663,30 +1667,10 @@ async function pair(opts = {}) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync12 } from "fs";
-
-// src/service/index.ts
-import { dirname as dirname5 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
 
-// src/service/host.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync4, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir3 } from "os";
-
-// src/cli-entry.ts
-import { existsSync as existsSync5 } from "fs";
-import { fileURLToPath } from "url";
-var RELATIVE_CANDIDATES = ["./cli.js", "../dist/cli.js", "../cli.js"];
-function companionCliEntry(deps = {}) {
-  const exists = deps.exists ?? existsSync5;
-  const candidates = deps.candidates ?? RELATIVE_CANDIDATES.map((rel) => fileURLToPath(new URL(rel, import.meta.url)));
-  for (const candidate of candidates) {
-    if (exists(candidate)) return candidate;
-  }
-  const argv1 = "argv1" in deps ? deps.argv1 : process.argv[1];
-  if (argv1 && exists(argv1)) return argv1;
-  return candidates[0] ?? "";
-}
+// src/commands/start.ts
+import { hostname as hostname2 } from "os";
 
 // src/logger.ts
 import { createWriteStream, mkdirSync as mkdirSync5 } from "fs";
@@ -1752,455 +1736,19 @@ function getLogger() {
   return cached;
 }
 
-// src/service/host.ts
-var RUN_TIMEOUT_MS = 1e4;
-function defaultServiceHost() {
-  if (process.env.VITEST) {
-    throw new Error(
-      "defaultServiceHost() was reached during a test run \u2014 it shells out to the real service manager. Inject a fake host (apps/companion/test/service-host-fake.ts) instead."
-    );
-  }
-  return {
-    platform: process.platform,
-    env: process.env,
-    home: homedir3(),
-    uid: process.getuid?.() ?? 0,
-    execPath: process.execPath,
-    cliPath: companionCliEntry(),
-    logPath: companionLogPath(),
-    fs: {
-      read: (path) => {
-        try {
-          return readFileSync4(path, "utf8");
-        } catch {
-          return null;
-        }
-      },
-      write: (path, contents) => writeFileSync4(path, contents, "utf8"),
-      remove: (path) => rmSync5(path, { force: true }),
-      exists: (path) => existsSync6(path),
-      mkdirp: (dir2) => {
-        mkdirSync6(dir2, { recursive: true });
-      }
-    },
-    run: (cmd, args) => {
-      const res = spawnSync(cmd, args, { encoding: "utf8", timeout: RUN_TIMEOUT_MS });
-      return {
-        ok: res.status === 0,
-        stdout: res.stdout ?? "",
-        stderr: res.stderr ?? (res.error ? res.error.message : "")
-      };
-    }
-  };
-}
-
-// src/service/launchd.ts
-import { join as join6 } from "path";
-var LAUNCHD_LABEL = "ai.cabane.companion";
-function launchAgentPath(home) {
-  return join6(home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-}
-function renderPlist(input) {
-  const args = input.programArguments.map((a) => `    <string>${xml(a)}</string>`).join("\n");
-  const env = Object.entries(input.environment).map(([k, v]) => `    <key>${xml(k)}</key>
-    <string>${xml(v)}</string>`).join("\n");
-  return [
-    '<?xml version="1.0" encoding="UTF-8"?>',
-    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
-    '<plist version="1.0">',
-    "<dict>",
-    "  <key>Label</key>",
-    `  <string>${LAUNCHD_LABEL}</string>`,
-    "  <key>ProgramArguments</key>",
-    "  <array>",
-    args,
-    "  </array>",
-    "  <key>RunAtLoad</key>",
-    "  <true/>",
-    "  <key>KeepAlive</key>",
-    "  <dict>",
-    "    <key>SuccessfulExit</key>",
-    "    <false/>",
-    "  </dict>",
-    "  <key>EnvironmentVariables</key>",
-    "  <dict>",
-    env,
-    "  </dict>",
-    "  <key>StandardOutPath</key>",
-    `  <string>${xml(input.logPath)}</string>`,
-    "  <key>StandardErrorPath</key>",
-    `  <string>${xml(input.logPath)}</string>`,
-    "</dict>",
-    "</plist>",
-    ""
-  ].join("\n");
-}
-function domain(host) {
-  return `gui/${host.uid}`;
-}
-function target(host) {
-  return `${domain(host)}/${LAUNCHD_LABEL}`;
-}
-function launchdStart(host, plistPath) {
-  host.run("launchctl", ["bootout", target(host)]);
-  const res = host.run("launchctl", ["bootstrap", domain(host), plistPath]);
-  return res.ok ? { ok: true } : { ok: false, detail: firstLine(res.stderr || res.stdout) };
-}
-function launchdStop(host) {
-  const res = host.run("launchctl", ["bootout", target(host)]);
-  if (res.ok || notLoaded(res.stderr + res.stdout)) return { ok: true };
-  return { ok: false, detail: firstLine(res.stderr || res.stdout) };
-}
-function launchdProbe(host) {
-  const res = host.run("launchctl", ["print", target(host)]);
-  if (res.ok) {
-    const state = /state\s*=\s*(\w+)/.exec(res.stdout)?.[1];
-    return { ownership: "held", running: state ? state === "running" : "unknown" };
-  }
-  return notLoaded(res.stderr + res.stdout) ? { ownership: "clear", running: false } : { ownership: "unknown", running: "unknown" };
-}
-function launchdRemove(host, plistPath) {
-  const stopped = launchdStop(host);
-  if (!stopped.ok) return stopped;
-  host.fs.remove(plistPath);
-  return { ok: true };
-}
-var NOT_LOADED = new RegExp(
-  `no such process|(could not find|not find service)[^\\n]*${LAUNCHD_LABEL.replace(
-    /[.*+?^${}()|[\]\\]/g,
-    "\\$&"
-  )}`,
-  "i"
-);
-function notLoaded(output) {
-  return NOT_LOADED.test(output);
-}
-function firstLine(s) {
-  return s.trim().split("\n")[0] ?? "";
-}
-function xml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-
-// src/service/systemd.ts
-import { dirname as dirname4, join as join7 } from "path";
-var SYSTEMD_UNIT = "cabane-companion.service";
-function systemdUnitPath(host) {
-  const configHome = host.env.XDG_CONFIG_HOME?.trim() ? host.env.XDG_CONFIG_HOME.trim() : join7(host.home, ".config");
-  return join7(configHome, "systemd", "user", SYSTEMD_UNIT);
-}
-function renderUnit(input) {
-  const [exec, ...rest] = input.programArguments;
-  const execStart = [quote(exec ?? ""), ...rest.map(quote)].join(" ");
-  const env = Object.entries(input.environment).map(([k, v]) => `Environment=${k}=${v}`);
-  return [
-    "[Unit]",
-    "Description=Cabane Companion \u2014 keeps this device answering while you are logged in",
-    "After=network-online.target",
-    "Wants=network-online.target",
-    "",
-    "[Service]",
-    "Type=simple",
-    ...env,
-    `ExecStart=${execStart}`,
-    "Restart=on-failure",
-    "RestartSec=5",
-    "",
-    "[Install]",
-    "WantedBy=default.target"
-  ].join("\n") + "\n";
-}
-function systemdReload(host) {
-  host.run("systemctl", ["--user", "daemon-reload"]);
-}
-function systemdStart(host) {
-  systemdReload(host);
-  const enabled = host.run("systemctl", ["--user", "enable", SYSTEMD_UNIT]);
-  if (!enabled.ok) return { ok: false, detail: firstLine2(enabled.stderr || enabled.stdout) };
-  const started = host.run("systemctl", ["--user", "restart", SYSTEMD_UNIT]);
-  if (!started.ok) return { ok: false, detail: firstLine2(started.stderr || started.stdout) };
-  return { ok: true };
-}
-function systemdStop(host) {
-  const res = host.run("systemctl", ["--user", "stop", SYSTEMD_UNIT]);
-  if (res.ok || notLoaded2(res.stderr + res.stdout)) return { ok: true };
-  return { ok: false, detail: firstLine2(res.stderr || res.stdout) };
-}
-function systemdProbe(host) {
-  const state = host.run("systemctl", ["--user", "is-active", SYSTEMD_UNIT]).stdout.trim();
-  if (state === "active") return { ownership: "held", running: true };
-  if (state === "activating" || state === "reloading" || state === "deactivating") {
-    return { ownership: "held", running: "transitional" };
-  }
-  if (state === "inactive" || state === "failed") return { ownership: "clear", running: false };
-  return { ownership: "unknown", running: "unknown" };
-}
-function systemdWantsLinkPath(host) {
-  return join7(dirname4(systemdUnitPath(host)), "default.target.wants", SYSTEMD_UNIT);
-}
-function systemdInstalled(host) {
-  return host.fs.exists(systemdUnitPath(host)) || host.fs.exists(systemdWantsLinkPath(host));
-}
-function systemdRemove(host, unitPath) {
-  const stopped = host.run("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT]);
-  if (!(stopped.ok || notLoaded2(stopped.stderr + stopped.stdout))) {
-    return { ok: false, detail: firstLine2(stopped.stderr || stopped.stdout) };
-  }
-  host.fs.remove(unitPath);
-  const link = systemdWantsLinkPath(host);
-  if (host.fs.exists(link)) host.fs.remove(link);
-  systemdReload(host);
-  return { ok: true };
-}
-var NOT_LOADED2 = new RegExp(
-  `unit (file )?${SYSTEMD_UNIT.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} (not loaded|does not exist|not found|could not be found)`,
-  "i"
-);
-function notLoaded2(output) {
-  return NOT_LOADED2.test(output);
-}
-function readLinger(host) {
-  const res = host.run("loginctl", ["show-user", String(host.uid), "-p", "Linger"]);
-  if (!res.ok) return "unknown";
-  const match = /Linger=(\w+)/.exec(res.stdout);
-  if (!match) return "unknown";
-  return match[1] === "yes" ? "yes" : "no";
-}
-function tryEnableLinger(host) {
-  host.run("loginctl", ["enable-linger", String(host.uid)]);
-  return readLinger(host);
-}
-function isRemoteSession(env) {
-  return Boolean(env.SSH_CONNECTION || env.SSH_TTY || env.SSH_CLIENT);
-}
-function quote(value) {
-  return `"${value.replace(/(["\\])/g, "\\$1")}"`;
-}
-function firstLine2(s) {
-  return s.trim().split("\n")[0] ?? "";
-}
-
-// src/service/index.ts
-function detectServiceManager(host = defaultServiceHost()) {
-  if (host.platform === "darwin") return "launchd";
-  if (host.platform !== "linux") return "none";
-  return host.run("systemctl", ["--user", "show-environment"]).ok ? "systemd-user" : "none";
-}
-function programArguments(host, _opts) {
-  return [host.execPath, host.cliPath, "start", "--foreground"];
-}
-function environment(host) {
-  return {
-    // PATH CAPTURE. launchd's default PATH is `/usr/bin:/bin:/usr/sbin:/sbin`
-    // and a systemd user manager's is barely better — neither has `claude`,
-    // `codex` or `opencode` on it. A companion that runs but can't find its
-    // harness is worse than one that isn't running, because the device reads
-    // Online. So we bake in the PATH of the shell that ran `start`, and because
-    // it's part of the rendered content, a PATH that later drifts re-renders on
-    // the next `start` like any other change.
-    PATH: host.env.PATH ?? "",
-    CABANE_COMPANION_DAEMON: "1"
-  };
-}
-function unitPathFor(host, manager) {
-  if (manager === "launchd") return launchAgentPath(host.home);
-  if (manager === "systemd-user") return systemdUnitPath(host);
-  return null;
-}
-function renderFor(host, manager, opts) {
-  const input = { programArguments: programArguments(host, opts), environment: environment(host) };
-  return manager === "launchd" ? renderPlist({ ...input, logPath: host.logPath }) : renderUnit(input);
-}
-function installService(opts = {}, host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  if (manager === "none") return { installed: false, reason: "unsupported" };
-  const path = unitPathFor(host, manager);
-  if (!path) return { installed: false, reason: "unsupported" };
-  const desired = renderFor(host, manager, opts);
-  const existing = host.fs.read(path);
-  const hadUnit = existing !== null;
-  const changed = existing !== desired;
-  if (changed) {
-    host.fs.mkdirp(dirname5(path));
-    host.fs.write(path, desired);
-  }
-  if (manager === "systemd-user") {
-    const linger = ensureLinger(host);
-    if (linger !== "yes" && isRemoteSession(host.env)) {
-      systemdRemove(host, path);
-      return failedInstall(
-        host,
-        manager,
-        "linger-unavailable",
-        "a systemd --user service would stop when this SSH session ends (lingering is off and could not be enabled)"
-      );
-    }
-  }
-  const started = manager === "launchd" ? launchdStart(host, path) : systemdStart(host);
-  if (!started.ok) {
-    if (!hadUnit) removeService(host, manager, path);
-    return failedInstall(host, manager, "command-failed", started.detail);
-  }
-  return { installed: true, manager, changed };
-}
-function failedInstall(host, manager, reason, detail) {
-  return {
-    installed: false,
-    reason,
-    ...detail ? { detail } : {},
-    ...managerOwnership(host, manager) === "clear" ? {} : { leftBehind: manager }
-  };
-}
-function managerProbe(host, manager) {
-  if (manager === "launchd") return launchdProbe(host);
-  if (manager === "systemd-user") return systemdProbe(host);
-  return { ownership: "clear", running: false };
-}
-function managerOwnership(host, manager) {
-  return managerProbe(host, manager).ownership;
-}
-function refreshInstalledService(opts = {}, host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  const path = unitPathFor(host, manager);
-  if (!path || !host.fs.exists(path)) return false;
-  const desired = renderFor(host, manager, opts);
-  if (host.fs.read(path) === desired) return false;
-  host.fs.write(path, desired);
-  if (manager === "systemd-user") systemdReload(host);
-  return true;
-}
-function stopService(host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  const path = unitPathFor(host, manager);
-  if (manager === "none" || !path || !managerHasClaim(host, manager, path)) {
-    return { handled: false, ok: true };
-  }
-  const res = manager === "launchd" ? launchdStop(host) : systemdStop(host);
-  return {
-    handled: true,
-    ok: res.ok,
-    manager,
-    ...res.detail ? { detail: res.detail } : {}
-  };
-}
-function disableService(host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  const path = unitPathFor(host, manager);
-  if (manager === "none" || !path) return { handled: false, ok: true };
-  if (!managerHasClaim(host, manager, path)) return { handled: false, ok: true, manager };
-  const res = removeService(host, manager, path);
-  return { handled: true, ok: res.ok, manager, ...res.detail ? { detail: res.detail } : {} };
-}
-function managerHasClaim(host, manager, path) {
-  if (manager === "none") return false;
-  if (host.fs.exists(path)) return true;
-  if (manager === "systemd-user" && systemdInstalled(host)) return true;
-  return managerOwnership(host, manager) !== "clear";
-}
-function removeService(host, manager, path) {
-  return manager === "launchd" ? launchdRemove(host, path) : systemdRemove(host, path);
-}
-function serviceStatus(host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  const path = unitPathFor(host, manager);
-  const probe = managerProbe(host, manager);
-  const installed = manager === "none" || !path ? false : host.fs.exists(path) || probe.ownership === "held" || manager === "systemd-user" && systemdInstalled(host);
-  const running = manager === "none" ? false : probe.running;
-  return {
-    manager,
-    unitPath: path,
-    installed,
-    running,
-    linger: manager === "systemd-user" ? readLinger(host) : null,
-    remoteSession: isRemoteSession(host.env)
-  };
-}
-function ensureLinger(host) {
-  const current = readLinger(host);
-  if (current === "yes") return current;
-  return tryEnableLinger(host);
-}
-
-// src/commands/service.ts
-function serviceStatusCommand(deps = {}) {
-  const status2 = (deps.status ?? serviceStatus)();
-  if (status2.manager === "none") {
-    process.stdout.write(
-      "service:  not supported on this machine yet \u2014 `cabane-companion start` runs the companion detached instead (it stops at the next reboot).\n"
-    );
-    return;
-  }
-  process.stdout.write(`manager:   ${status2.manager}
-`);
-  process.stdout.write(
-    `unit:      ${status2.unitPath}${status2.installed ? "" : " (not written)"}
-`
-  );
-  process.stdout.write(`installed: ${status2.installed ? "yes" : "no"}
-`);
-  process.stdout.write(`running:   ${runningLine(status2.running)}
-`);
-  if (status2.manager === "systemd-user") {
-    process.stdout.write(`linger:    ${status2.linger}${lingerNote(status2)}
-`);
-  }
-  if (status2.installed) {
-    process.stdout.write("disable:   cabane-companion service disable\n");
-  } else {
-    process.stdout.write("install:   cabane-companion start (installs it for you)\n");
-  }
-}
-function serviceDisableCommand(deps = {}) {
-  const disable = deps.disable ?? disableService;
-  const res = disable();
-  if (!res.handled) {
-    process.stdout.write("service:  nothing installed (nothing to remove).\n");
-    return;
-  }
-  if (!res.ok) {
-    process.stdout.write(
-      `service:  nothing was removed \u2014 ${res.detail ?? "the service manager reported an error"}.
-The unit is still installed and may still be running; \`cabane-companion service status\` shows where it stands.
-`
-    );
-    process.exitCode = 1;
-    return;
-  }
-  process.stdout.write(
-    "service:  stopped and removed. The companion no longer starts at login; `cabane-companion start` sets it up again.\n"
-  );
-}
-function runningLine(running) {
-  if (running === "transitional") {
-    return "starting or stopping \u2014 the manager reported a state in transition; ask again in a moment";
-  }
-  if (running === "unknown") return "unknown \u2014 the service manager didn't answer";
-  return running ? "yes" : "no";
-}
-function lingerNote(status2) {
-  if (status2.linger === "yes") return " (survives logout)";
-  if (status2.remoteSession) {
-    return " \u2014 without lingering a --user service stops when this SSH session ends";
-  }
-  return " \u2014 the service runs while you are logged in";
-}
-
-// src/commands/start.ts
-import { hostname as hostname2 } from "os";
-
 // src/runtime.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/dashboard/server.ts
-import { dirname as dirname6, join as join9 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname4, join as join7 } from "path";
+import { fileURLToPath } from "url";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 
 // src/dashboard/routes.ts
-import { openSync as openSync2, readSync, closeSync as closeSync2, fstatSync, existsSync as existsSync7 } from "fs";
+import { openSync as openSync2, readSync, closeSync as closeSync2, fstatSync, existsSync as existsSync5 } from "fs";
 import { readFile } from "fs/promises";
-import { extname, join as join8, normalize } from "path";
+import { extname, join as join6, normalize } from "path";
 import { streamSSE } from "hono/streaming";
 
 // src/state.ts
@@ -2449,14 +1997,14 @@ var CONTENT_TYPES = {
 function registerRoutes(app, deps) {
   const { supervisor, hub, staticDir } = deps;
   app.get("/", async (c) => {
-    const html = await readFile(join8(staticDir, "index.html"), "utf8");
+    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 safe3 = normalize(file).replace(/^(\.\.[/\\])+/, "");
-    const full = join8(staticDir, safe3);
-    if (!full.startsWith(staticDir) || !existsSync7(full)) return c.notFound();
+    const full = join6(staticDir, safe3);
+    if (!full.startsWith(staticDir) || !existsSync5(full)) return c.notFound();
     const body = await readFile(full);
     const type = CONTENT_TYPES[extname(full).toLowerCase()] ?? "application/octet-stream";
     c.header("content-type", type);
@@ -2583,7 +2131,7 @@ function clampLimit(raw, fallback, max = 200) {
   return Math.min(Math.floor(n), max);
 }
 function tailFile(path, lines) {
-  if (!existsSync7(path)) return [];
+  if (!existsSync5(path)) return [];
   const MAX_BYTES = 256 * 1024;
   let fd;
   try {
@@ -2672,7 +2220,7 @@ function isAddrInUse(err) {
   return Boolean(err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE");
 }
 function resolveStaticDir() {
-  return join9(dirname6(fileURLToPath2(import.meta.url)), "static");
+  return join7(dirname4(fileURLToPath(import.meta.url)), "static");
 }
 
 // src/api.ts
@@ -3148,21 +2696,21 @@ function errorMessage2(status2, body) {
 }
 
 // src/cursor.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync8 } from "fs";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "fs";
+import { join as join8 } from "path";
 function pathFor(workspaceId) {
-  return join10(cabaneDir(), "cursors", encodeURIComponent(workspaceId));
+  return join8(cabaneDir(), "cursors", encodeURIComponent(workspaceId));
 }
 function readCursor(workspaceId) {
   const path = pathFor(workspaceId);
-  if (!existsSync8(path)) return null;
-  const raw = readFileSync5(path, "utf8").trim();
+  if (!existsSync6(path)) return null;
+  const raw = readFileSync4(path, "utf8").trim();
   return raw.length > 0 ? raw : null;
 }
 function writeCursor(workspaceId, eventId) {
   const path = pathFor(workspaceId);
-  mkdirSync7(join10(cabaneDir(), "cursors"), { recursive: true });
-  writeFileSync5(path, eventId + "\n", "utf8");
+  mkdirSync6(join8(cabaneDir(), "cursors"), { recursive: true });
+  writeFileSync4(path, eventId + "\n", "utf8");
 }
 
 // src/cursor-tracker.ts
@@ -3205,20 +2753,20 @@ var CursorTracker = class {
 };
 
 // src/dispatch-dedupe.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync9 } from "fs";
-import { join as join11 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
+import { join as join9 } from "path";
 var MAX_IDS = 256;
 function dir(log) {
-  return join11(cabaneDir(), log);
+  return join9(cabaneDir(), log);
 }
 function pathFor2(log, workspaceId) {
-  return join11(dir(log), encodeURIComponent(workspaceId));
+  return join9(dir(log), encodeURIComponent(workspaceId));
 }
 function readIds(log, workspaceId) {
   const path = pathFor2(log, workspaceId);
-  if (!existsSync9(path)) return [];
+  if (!existsSync7(path)) return [];
   try {
-    return readFileSync6(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+    return readFileSync5(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
   } catch {
     return [];
   }
@@ -3231,8 +2779,8 @@ function mark(log, workspaceId, eventId) {
   if (ids.includes(eventId)) return;
   ids.push(eventId);
   const trimmed = ids.length > MAX_IDS ? ids.slice(-MAX_IDS) : ids;
-  mkdirSync8(dir(log), { recursive: true });
-  writeFileSync6(pathFor2(log, workspaceId), trimmed.join("\n") + "\n", "utf8");
+  mkdirSync7(dir(log), { recursive: true });
+  writeFileSync5(pathFor2(log, workspaceId), trimmed.join("\n") + "\n", "utf8");
 }
 function hasDispatched(workspaceId, eventId) {
   return has("dispatched", workspaceId, eventId);
@@ -3248,17 +2796,17 @@ function markCompleted(workspaceId, eventId) {
 }
 var MAX_RESUME_ATTEMPTS = 3;
 function resumeDir() {
-  return join11(cabaneDir(), "resume-attempts");
+  return join9(cabaneDir(), "resume-attempts");
 }
 function resumePathFor(workspaceId) {
-  return join11(resumeDir(), encodeURIComponent(workspaceId));
+  return join9(resumeDir(), encodeURIComponent(workspaceId));
 }
 function readResumeCounts(workspaceId) {
   const out = /* @__PURE__ */ new Map();
   const path = resumePathFor(workspaceId);
-  if (!existsSync9(path)) return out;
+  if (!existsSync7(path)) return out;
   try {
-    for (const line of readFileSync6(path, "utf8").split("\n")) {
+    for (const line of readFileSync5(path, "utf8").split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
       const tab = trimmed.lastIndexOf("	");
@@ -3278,8 +2826,8 @@ function bumpResumeAttempt(workspaceId, eventId) {
   counts.set(eventId, next);
   const entries = [...counts.entries()];
   const trimmed = entries.length > MAX_IDS ? entries.slice(-MAX_IDS) : entries;
-  mkdirSync8(resumeDir(), { recursive: true });
-  writeFileSync6(
+  mkdirSync7(resumeDir(), { recursive: true });
+  writeFileSync5(
     resumePathFor(workspaceId),
     trimmed.map(([id, c]) => `${id}	${c}`).join("\n") + "\n",
     "utf8"
@@ -3451,13 +2999,55 @@ var turnEventSchema = z5.discriminatedUnion("type", [
   })
 ]);
 
-// packages/agent-runtime/src/failure.ts
+// packages/agent-runtime/src/turn-diagnostics.ts
 import { z as z6 } from "zod";
-var turnFailureSchema = z6.discriminatedUnion("kind", [
+var turnResultReasonSchema = z6.discriminatedUnion("kind", [
   z6.object({ kind: z6.literal("usage_capped"), resetsAt: z6.string().optional() }),
   z6.object({ kind: z6.literal("rate_limited") }),
   z6.object({ kind: z6.literal("server_error") }),
-  z6.object({ kind: z6.literal("auth_expired") })
+  z6.object({ kind: z6.literal("auth_expired") }),
+  z6.object({ kind: z6.literal("no_result") }),
+  z6.object({ kind: z6.literal("empty_result") }),
+  z6.object({ kind: z6.literal("empty_result_unverified") }),
+  z6.object({ kind: z6.literal("timeout_idle") }),
+  z6.object({ kind: z6.literal("timeout_total") }),
+  z6.object({ kind: z6.literal("cancelled") }),
+  z6.object({ kind: z6.literal("skipped") }),
+  z6.object({ kind: z6.literal("runtime_error") })
+]);
+var turnOutcomes = ["success", "failure", "cancelled", "skipped"];
+var turnSessionModes = ["fresh", "resumed", "degraded"];
+var turnRuntimeResultKinds = ["success", "error", "no_terminal"];
+var turnFinalSources = [
+  "runtime_text",
+  "progress_promotion",
+  "host_fallback",
+  "marker",
+  "none"
+];
+var turnDiagnosticsSchema = z6.object({
+  outcome: z6.enum(turnOutcomes),
+  resultReason: turnResultReasonSchema.nullable(),
+  sessionMode: z6.enum(turnSessionModes),
+  sessionFingerprint: z6.string().regex(/^[a-f0-9]{16}$/).nullable(),
+  eventCounts: z6.object({
+    session: z6.number().int().nonnegative(),
+    text: z6.number().int().nonnegative(),
+    thinking: z6.number().int().nonnegative(),
+    tool: z6.number().int().nonnegative(),
+    result: z6.number().int().nonnegative()
+  }),
+  runtimeResultKind: z6.enum(turnRuntimeResultKinds).nullable(),
+  finalSource: z6.enum(turnFinalSources)
+});
+
+// packages/agent-runtime/src/failure.ts
+import { z as z7 } from "zod";
+var turnFailureSchema = z7.discriminatedUnion("kind", [
+  z7.object({ kind: z7.literal("usage_capped"), resetsAt: z7.string().optional() }),
+  z7.object({ kind: z7.literal("rate_limited") }),
+  z7.object({ kind: z7.literal("server_error") }),
+  z7.object({ kind: z7.literal("auth_expired") })
 ]);
 var USAGE_CAPPED = "usage_capped";
 var RATE_LIMITED = "rate_limited";
@@ -3562,64 +3152,89 @@ var NEGATED_CAP = /not (your|a) usage limit/g;
 var RATE_PATTERNS = [/rate[_ ]?limit/, /\b429\b/, /too many requests/];
 var BARE_LIMIT = /\blimit (reached|exceeded)\b/;
 
+// packages/agent-runtime/src/turn-diagnostics-normalize.ts
+function normalizeTurnResultReason(reason) {
+  const classified = decodeFailureReason(reason);
+  if (classified) return classified;
+  switch (reason) {
+    case "no_result":
+    case "no_terminal":
+      return { kind: "no_result" };
+    case "empty_result":
+      return { kind: "empty_result" };
+    case "empty_result_unverified":
+      return { kind: "empty_result_unverified" };
+    case "timeout_idle":
+      return { kind: "timeout_idle" };
+    case "timeout_total":
+      return { kind: "timeout_total" };
+    case "cancelled":
+      return { kind: "cancelled" };
+    case "skipped":
+      return { kind: "skipped" };
+    default:
+      return { kind: "runtime_error" };
+  }
+}
+
 // packages/agent-runtime/src/turn-request.ts
-import { z as z7 } from "zod";
-var contentBlockSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("text"), text: z7.string() }),
-  z7.object({
-    type: z7.literal("image"),
-    source: z7.object({ type: z7.literal("url"), url: z7.string() })
+import { z as z8 } from "zod";
+var contentBlockSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("text"), text: z8.string() }),
+  z8.object({
+    type: z8.literal("image"),
+    source: z8.object({ type: z8.literal("url"), url: z8.string() })
   }),
-  z7.object({
-    type: z7.literal("document"),
-    source: z7.object({ type: z7.literal("url"), url: z7.string() })
+  z8.object({
+    type: z8.literal("document"),
+    source: z8.object({ type: z8.literal("url"), url: z8.string() })
   })
 ]);
-var effortLevelSchema = z7.enum(["low", "medium", "high", "xhigh", "max"]);
-var resolvedRunConfigSchema = z7.object({
-  model: z7.string().nullable(),
+var effortLevelSchema = z8.enum(["low", "medium", "high", "xhigh", "max"]);
+var resolvedRunConfigSchema = z8.object({
+  model: z8.string().nullable(),
   effort: effortLevelSchema.optional(),
-  runtimeOptions: z7.record(z7.string(), z7.unknown()).optional()
+  runtimeOptions: z8.record(z8.string(), z8.unknown()).optional()
 });
-var resolvedMcpServerSchema = z7.union([
-  z7.object({
-    type: z7.literal("stdio").optional(),
-    command: z7.string(),
-    args: z7.array(z7.string()).optional(),
-    env: z7.record(z7.string(), z7.string()).optional()
+var resolvedMcpServerSchema = z8.union([
+  z8.object({
+    type: z8.literal("stdio").optional(),
+    command: z8.string(),
+    args: z8.array(z8.string()).optional(),
+    env: z8.record(z8.string(), z8.string()).optional()
   }),
-  z7.object({
-    type: z7.literal("http"),
-    url: z7.string(),
-    headers: z7.record(z7.string(), z7.string()).optional()
+  z8.object({
+    type: z8.literal("http"),
+    url: z8.string(),
+    headers: z8.record(z8.string(), z8.string()).optional()
   }),
-  z7.object({
-    type: z7.literal("sse"),
-    url: z7.string(),
-    headers: z7.record(z7.string(), z7.string()).optional()
+  z8.object({
+    type: z8.literal("sse"),
+    url: z8.string(),
+    headers: z8.record(z8.string(), z8.string()).optional()
   })
 ]);
-var resolvedMcpServersSchema = z7.record(z7.string(), resolvedMcpServerSchema);
-var hostInjectedServersSchema = z7.record(z7.string(), z7.unknown());
-var turnRequestSchema = z7.object({
+var resolvedMcpServersSchema = z8.record(z8.string(), resolvedMcpServerSchema);
+var hostInjectedServersSchema = z8.record(z8.string(), z8.unknown());
+var turnRequestSchema = z8.object({
   // Server-composed system prompt (core + capability prose + adapter addendum +
   // charter). One string to the adapter.
-  systemPrompt: z7.string(),
+  systemPrompt: z8.string(),
   // Server-composed per-turn user text (anchor reminder + the triggering message).
-  prompt: z7.string(),
+  prompt: z8.string(),
   // The multi-block user-message body (text + vision).
-  content: z7.array(contentBlockSchema),
+  content: z8.array(contentBlockSchema),
   // Portable-or-dialect run-config (above).
   config: resolvedRunConfigSchema,
   // Abstract capability grants; the adapter maps them to tool names.
   policy: hostPolicySchema,
   // Prior opaque session state, or null for a fresh session.
-  session: z7.string().nullable(),
+  session: z8.string().nullable(),
   // The cabane control-plane coordinates for this turn's MCP + post-back.
-  cabane: z7.object({
-    mcpUrl: z7.string(),
-    bearer: z7.string(),
-    activeConversationId: z7.string(),
+  cabane: z8.object({
+    mcpUrl: z8.string(),
+    bearer: z8.string(),
+    activeConversationId: z8.string(),
     // CT714: the scoped TURN-CONTROL MCP endpoint (`/api/turn-control`). The
     // EXTERNAL adapters (Codex / opencode) mount it by URL under the key
     // `cabane_companion` — using the same `bearer` (the turn token) and the same
@@ -3629,7 +3244,7 @@ var turnRequestSchema = z7.object({
     // claude-code ignores it (it mounts the in-process instance instead), and
     // every existing `cabane`-block fixture keeps parsing unchanged; the
     // companion always populates it (`build-options.ts`).
-    turnControlUrl: z7.string().optional(),
+    turnControlUrl: z8.string().optional(),
     // CT598: the workspace this turn runs in. The claude-code/opencode/codex
     // adapters never need it (they reach Cabane through the `cabane` MCP server,
     // which takes `workspaceId` as a per-tool arg the model supplies); the
@@ -3639,39 +3254,39 @@ var turnRequestSchema = z7.object({
     // adapters' conformance fixtures, tests) keeps parsing unchanged — the companion
     // always populates it (`build-options.ts`), and the native adapter fails the
     // turn loudly when it is somehow absent rather than guessing.
-    workspaceId: z7.string().optional(),
+    workspaceId: z8.string().optional(),
     // CT752: the server-resolved workspace surface this credential exposes.
     // Readiness uses this explicit fact to require `sdk` for code mode and the
     // granular floor for classic mode; inventory contents alone cannot infer it
     // because `sdk` is intentionally also available on the classic surface.
-    workspaceToolSurface: z7.enum(["code", "classic"]).optional()
+    workspaceToolSurface: z8.enum(["code", "classic"]).optional()
   }),
   // Machine-local resolution (host-filled): the checkout cwd, extra env from a
   // prepare hook, and the resolved user MCP servers.
-  local: z7.object({
-    cwd: z7.string().optional(),
-    env: z7.record(z7.string(), z7.string()).optional(),
+  local: z8.object({
+    cwd: z8.string().optional(),
+    env: z8.record(z8.string(), z8.string()).optional(),
     mcpServers: resolvedMcpServersSchema.optional(),
     // CT289: machine-local claude-code adapter knobs the operator sets on a
     // companion they run themselves — the auto-memory escape hatch. `autoMemory:
     // true` opts back into Claude Code's auto-memory (governed by the operator's
     // own `.claude/settings.json`); absent/false leaves the adapter's force-off
     // default in place (see `buildClaudeCodeOptions`).
-    claudeCode: z7.object({ autoMemory: z7.boolean().optional() }).optional()
+    claudeCode: z8.object({ autoMemory: z8.boolean().optional() }).optional()
   }),
   // Host-owned injected servers (host-filled) — e.g. the summon server.
-  extra: z7.object({
+  extra: z8.object({
     mcpServers: hostInjectedServersSchema
   })
 });
 
 // packages/agent-runtime/src/conformance.ts
-import { z as z8 } from "zod";
-var conformanceFixtureSchema = z8.object({
-  name: z8.string(),
+import { z as z9 } from "zod";
+var conformanceFixtureSchema = z9.object({
+  name: z9.string(),
   request: turnRequestSchema,
-  nativeStream: z8.array(z8.unknown()),
-  expected: z8.array(turnEventSchema)
+  nativeStream: z9.array(z9.unknown()),
+  expected: z9.array(turnEventSchema)
 });
 
 // packages/agent-runtime/src/transcript.ts
@@ -3891,6 +3506,7 @@ var TurnPump = class {
         if (evt.final) {
           this.emittedFinal = true;
           this.finalReplyBody = body;
+          this.emittedFinalSource = "runtime_text";
         } else {
           this.lastProgressBody = body;
         }
@@ -3929,6 +3545,7 @@ var TurnPump = class {
   lastProgressBody = null;
   // The turn's final reply text, captured for the dashboard feed / logging.
   finalReplyBody = null;
+  emittedFinalSource = "none";
   // CT11: each tool's persisted seq so the `done`/`error` frame republishes the
   // same seq the `start` row got (the host's upsert keeps the original seq).
   toolSeqByUseId = /* @__PURE__ */ new Map();
@@ -3951,6 +3568,7 @@ var TurnPump = class {
       await this.opts.commit.commitMessage({ body, kind: "final", seq });
       this.emittedFinal = true;
       this.finalReplyBody = body;
+      this.emittedFinalSource = this.lastProgressBody ? "progress_promotion" : "host_fallback";
     } catch (err) {
       this.opts.onError?.(err, "empty-final");
     }
@@ -3965,6 +3583,9 @@ var TurnPump = class {
   get replyBody() {
     return this.finalReplyBody;
   }
+  get finalSource() {
+    return this.emittedFinalSource;
+  }
 };
 
 // packages/agent-runtime/src/claude-code/index.ts
@@ -3986,7 +3607,7 @@ var CLAUDE_CODE_ADDENDUM = [
 ].join(" ");
 
 // packages/agent-runtime/src/claude-code/policy.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var HOST_FS_TOOLS = [
   // shell + local filesystem
   "Bash",
@@ -4036,18 +3657,18 @@ function withThinkingSummaries(thinking) {
   if (thinking.type === "disabled") return thinking;
   return { display: "summarized", ...thinking };
 }
-var claudeCodeDialectSchema = z9.object({
-  thinking: z9.discriminatedUnion("type", [
-    z9.object({
-      type: z9.literal("adaptive"),
-      display: z9.enum(["summarized", "omitted"]).optional()
+var claudeCodeDialectSchema = z10.object({
+  thinking: z10.discriminatedUnion("type", [
+    z10.object({
+      type: z10.literal("adaptive"),
+      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("enabled"),
+      budgetTokens: z10.number().int().positive().optional(),
+      display: z10.enum(["summarized", "omitted"]).optional()
     }),
-    z9.object({ type: z9.literal("disabled") })
+    z10.object({ type: z10.literal("disabled") })
   ]).optional()
 }).loose();
 function readThinking(runtimeOptions) {
@@ -4989,7 +4610,7 @@ function sealHeld(held, terminal) {
 }
 
 // packages/agent-runtime/src/opencode/policy.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var OPENCODE_HOST_TOOLS = [
   "bash",
   "edit",
@@ -5016,8 +4637,8 @@ function opencodeToolPolicy(policy) {
   deny(OPENCODE_UI_PROMPT_TOOLS);
   return { tools, allowAllHostTools: policy.hostFs };
 }
-var opencodeDialectSchema = z10.object({
-  agent: z10.string().min(1).optional()
+var opencodeDialectSchema = z11.object({
+  agent: z11.string().min(1).optional()
 }).loose();
 function readOpencodeDialect(runtimeOptions) {
   const parsed = opencodeDialectSchema.safeParse(runtimeOptions?.["opencode"] ?? {});
@@ -6027,7 +5648,7 @@ function sealHeld2(held, terminal) {
 }
 
 // packages/agent-runtime/src/codex/policy.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function codexToolPolicy(policy) {
   return policy.hostFs ? {
     sandboxMode: "danger-full-access",
@@ -6046,8 +5667,8 @@ function codexToolPolicy(policy) {
   };
 }
 var CODEX_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
-var codexDialectSchema = z11.object({
-  modelReasoningEffort: z11.enum(CODEX_REASONING_EFFORTS).optional()
+var codexDialectSchema = z12.object({
+  modelReasoningEffort: z12.enum(CODEX_REASONING_EFFORTS).optional()
 }).loose();
 function readCodexDialect(runtimeOptions) {
   const parsed = codexDialectSchema.safeParse(runtimeOptions?.["codex"] ?? {});
@@ -6976,12 +6597,12 @@ var ConnectorHealthStore = class {
 };
 
 // src/dispatcher.ts
-import { randomUUID } from "crypto";
-import { appendFileSync as appendFileSync2, existsSync as existsSync12, mkdirSync as mkdirSync11, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join16 } from "path";
+import { createHash as createHash2, randomUUID } from "crypto";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync10, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join14 } from "path";
 
 // src/summon.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
 var SUMMON_AGENT_TOOL = "summon_agent";
 var SUMMON_AGENT_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SUMMON_AGENT_TOOL}`;
@@ -7029,7 +6650,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
         SUMMON_AGENT_TOOL,
         "Summon another agent into THIS conversation \u2014 dispatch a peer to reply here on your turn. Use it to hand part of the work to a teammate, or pull in an expert, without leaving the conversation. Pass the peer's `agentId` \u2014 every agent's handle and id is on the roster in your turn context. The peer is dispatched on your turn's final reply, so write the context/ask into that reply first \u2014 it receives your message + this conversation to work from. Writing `@handle` in your prose does NOT summon anyone (agent prose never dispatches); this tool is the only in-thread lever. Single target \u2014 the last call wins. Summoning yourself is a no-op. Reach for it when the human wants the peer's answer right HERE, in front of them \u2014 the reply lands in this thread, so there's no return to wire (a return is for work YOU consume, never a courtesy notification). A handoff to a DIFFERENT conversation is `cabane.conversations.create` / `cabane.conversations.post` with their `dispatch` field instead.",
         {
-          agentId: z12.string().uuid().describe(
+          agentId: z13.string().uuid().describe(
             "The peer agent to summon \u2014 a workspace agent id, from your turn context's roster."
           )
         },
@@ -7046,7 +6667,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           SKIP_TURN_TOOL,
           `End your current turn WITHOUT posting a reply. Call this when you've been dispatched but the message genuinely doesn't need a response from you \u2014 a thanks/aside, a question already answered, chatter outside your lane, or a pile-on where someone else has it. Your turn ends silently: no message bubble is posted. The \`reason\` is a short free-text note for telemetry (e.g. "already answered by cabane", "thanks, nothing to add"). Prefer this over posting a low-value "ok!"/"got it" reply. Don't also write a reply when you skip \u2014 skipping IS the whole turn.`,
           {
-            reason: z12.string().min(1).max(500).describe("Short reason you are declining \u2014 used for telemetry/debugging.")
+            reason: z13.string().min(1).max(500).describe("Short reason you are declining \u2014 used for telemetry/debugging.")
           },
           async (args) => {
             skipState.skipped = true;
@@ -7063,23 +6684,23 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           ASK_TOOL,
           "Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact). Pass `targetUserId` (a workspace member's user id \u2014 every person's id is on the roster in your turn context). Two forms: a SINGLE question \u2014 a `headline` (the actual question as one clear, capitalized sentence ending in `?`, \"Do we go to prod?\") plus a short `question` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once, a `questions` array of 1\u20135 items, each `{ headline, body?, options? }`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence `headline`, a short `body` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 `options` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label or a whole sentence. Provide EITHER `question` (single) or `questions` (array), never both. The ask is a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use summon/dispatch instead.",
           {
-            targetUserId: z12.string().uuid().describe(
+            targetUserId: z13.string().uuid().describe(
               "The workspace member (human) to ask \u2014 a user id, from your turn context's roster."
             ),
-            question: z12.string().min(1).max(400).optional().describe(
+            question: z13.string().min(1).max(400).optional().describe(
               "SINGLE-question form: a short body \u2014 one or two sentences of framing the headline can't hold. NOT a report (capped, inline markdown only). Provide EITHER this or `questions`, not both. Put the crisp one-sentence question in `headline`."
             ),
-            headline: z12.string().min(1).max(120).optional().describe(
+            headline: z13.string().min(1).max(120).optional().describe(
               'SINGLE-question form: the question itself as ONE clear, capitalized sentence ending in `?` ("Do we go to prod?"). What the human reads first in the inbox and the chip \u2014 one scannable question, no elaboration (that goes in `question`). Strongly encouraged.'
             ),
-            options: z12.array(z12.string().min(1).max(200)).min(2).max(4).optional().describe("SINGLE-question form: optional 2\u20134 suggested one-click answers."),
-            questions: z12.array(
-              z12.object({
-                headline: z12.string().min(1).max(120).describe(
+            options: z13.array(z13.string().min(1).max(200)).min(2).max(4).optional().describe("SINGLE-question form: optional 2\u20134 suggested one-click answers."),
+            questions: z13.array(
+              z13.object({
+                headline: z13.string().min(1).max(120).describe(
                   'The one-sentence question ("Do we go to prod?") \u2014 required for each item.'
                 ),
-                body: z12.string().min(1).max(400).optional().describe("Optional short framing beneath the headline. NOT a report."),
-                options: z12.array(z12.string().min(1).max(200)).min(2).max(4).optional().describe("Optional 2\u20134 one-click answers for this question.")
+                body: z13.string().min(1).max(400).optional().describe("Optional short framing beneath the headline. NOT a report."),
+                options: z13.array(z13.string().min(1).max(200)).min(2).max(4).optional().describe("Optional 2\u20134 one-click answers for this question.")
               })
             ).min(1).max(5).optional().describe(
               "MULTI-question form: 1\u20135 questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or `question`/`headline`/`options`, not both."
@@ -7136,13 +6757,13 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           SUB_AGENT_TOOL,
           "Spawn a sub-agent \u2014 hand a piece of work to a private worker with a fresh context window, whose result comes back to you automatically. Modeled on the Task tool, with ONE deliberate difference: it does NOT return the result inline. A callee's turn can run for minutes and no turn may hold an unbounded wait, so the shape is spawn-now, results-on-wake \u2014 this returns immediately with the child's `conversationId`, and the outcome lands LATER as a message in THIS conversation; you're woken once every sub-agent you have out in this conversation has returned. So DON'T wait for it: after spawning, finish whatever else this turn can do and end your turn (never poll the child with reads in a loop \u2014 the wake is automatic). Parallel fan-out = call this N times in one turn (they run concurrently; ONE wake when all are in); series = one call per turn. `prompt` is the child's opening instruction \u2014 make it self-contained (the sub-agent starts fresh, with only this prompt + the thread it lands in). `agentId` (optional) dispatches a PEER instead of yourself \u2014 same mechanics, a different mind (use for capability/context you lack); default (self) is the pure sub-worker with a clean context window. `title` (optional) names the child thread (results link it, so a legible title helps). A single sub-agent has no wall-clock advantage (you idle either way) \u2014 it pays when the callee has capability/context you lack, or to isolate a big read from your own session; the real win is fan-out. Don't spawn one for a lookup you can do in-turn with your own tools. The result returns to YOU to act on \u2014 reach for it when you're the consumer of the output, not as a way to notify a human: if a person just wants to read the result, dispatch a plain (no-return) conversation and link it instead of spawning a sub-agent.",
           {
-            prompt: z12.string().min(1).max(65536).describe(
+            prompt: z13.string().min(1).max(65536).describe(
               "The sub-agent's opening instruction \u2014 self-contained (it starts with a fresh context window; only this prompt + the thread it lands in)."
             ),
-            agentId: z12.string().uuid().optional().describe(
+            agentId: z13.string().uuid().optional().describe(
               "Optional peer to run the sub-agent as (a workspace agent id, from your turn context's roster); omit to spawn yourself with a fresh context window."
             ),
-            title: z12.string().max(200).optional().describe("Optional title for the child thread (result chips link it).")
+            title: z13.string().max(200).optional().describe("Optional title for the child thread (result chips link it).")
           },
           async (args) => {
             const result = await subAgentCreate(args);
@@ -7172,13 +6793,13 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           WAKE_ME_TOOL,
           "Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, with a note you write to yourself. Use it for \"wait until X\": when the thing you need hasn't happened yet (a PR isn't merged, a human hasn't answered), arm a wake, end your turn, and you're woken later to CHECK \u2014 read the workspace, and either act or re-arm. Ground the delay before you arm it. Almost every wake is short \u2014 seconds to a couple of hours \u2014 waiting on a condition you can name: a session limit resetting, a PR merging. Reach past a few hours only when (a) a human asked for that timing, or (b) the wait is pinned to a real external event you can name \u2014 a report that only runs Mondays, a known reset time. A speculative far-future check-in you invented yourself is the one thing not to arm: if no one asked and you can't name both what clears the wait and why it takes that long, don't arm it \u2014 finish now, or raise an `ask`. Pass EXACTLY ONE of `afterSeconds` (a relative delay \u2014 `300` for five minutes) or `at` (an absolute ISO-8601 timestamp WITH a zone, e.g. `2026-07-16T09:00:00-07:00` \u2014 YOU compute it from a phrase like \"tomorrow morning\"; the system never parses natural-language time). `note` is a message to your future self \u2014 it becomes the body of the wake message that re-dispatches you, so write the condition to re-check (\"check whether CT441 merged yet\"). The wake is armed when your turn SETTLES, not now, so the delay counts from the turn ending; one wake per turn (last call wins). This is the sanctioned way to schedule your own continuation \u2014 the ONLY one; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days; widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026) rather than hammering; after many consecutive re-arms with no other activity you'll be steered to raise an `ask` to the human instead. If a wake can't be armed you're re-dispatched with a note explaining why \u2014 never a silent drop.",
           {
-            afterSeconds: z12.number().int().positive().optional().describe(
+            afterSeconds: z13.number().int().positive().optional().describe(
               "Relative delay in seconds from when this turn ends (e.g. 300 = five minutes). Provide EITHER this or `at`, not both. Floor 60s, horizon 14 days \u2014 enforced server-side."
             ),
-            at: z12.string().datetime({ offset: true }).optional().describe(
+            at: z13.string().datetime({ offset: true }).optional().describe(
               "Absolute ISO-8601 timestamp WITH a zone (`Z` or `\xB1HH:MM`), e.g. `2026-07-16T09:00:00-07:00`. YOU compute it from a natural-language phrase using the current datetime in your turn context. Provide EITHER this or `afterSeconds`, not both."
             ),
-            note: z12.string().min(1).max(2e3).describe(
+            note: z13.string().min(1).max(2e3).describe(
               'A note to your future self \u2014 becomes the body of the wake message that re-dispatches you. Write the condition to re-check ("check whether the PR merged").'
             )
           },
@@ -7311,11 +6932,11 @@ function trimSlash2(s) {
 // src/codex-instructions.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join12 } from "path";
+import { join as join10 } from "path";
 var PREFIX = "cabane-codex-instructions-";
 async function writeCodexInstructionsFile(contents) {
-  const dir2 = await mkdtemp(join12(tmpdir(), PREFIX));
-  const path = join12(dir2, "instructions.md");
+  const dir2 = await mkdtemp(join10(tmpdir(), PREFIX));
+  const path = join10(dir2, "instructions.md");
   await writeFile(path, contents, { encoding: "utf8", mode: 384 });
   return {
     path,
@@ -7326,22 +6947,22 @@ async function writeCodexInstructionsFile(contents) {
 }
 
 // src/prepared.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync7, existsSync as existsSync10 } from "fs";
-import { join as join13 } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, rmSync as rmSync5, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
+import { join as join11 } from "path";
 function dirFor(workspaceId) {
-  return join13(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
+  return join11(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
 }
 function conversationDir(workspaceId, conversationId) {
-  return join13(dirFor(workspaceId), encodeURIComponent(conversationId));
+  return join11(dirFor(workspaceId), encodeURIComponent(conversationId));
 }
 function pathFor3(workspaceId, conversationId, agentId) {
-  return join13(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
+  return join11(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
 }
 function readPrepared(workspaceId, conversationId, agentId) {
   const path = pathFor3(workspaceId, conversationId, agentId);
-  if (!existsSync10(path)) return null;
+  if (!existsSync8(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync7(path, "utf8"));
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
     if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
       return {
         cwd: parsed.cwd,
@@ -7354,32 +6975,32 @@ function readPrepared(workspaceId, conversationId, agentId) {
   }
 }
 function writePrepared(workspaceId, conversationId, agentId, result) {
-  mkdirSync9(conversationDir(workspaceId, conversationId), { recursive: true });
-  writeFileSync7(
+  mkdirSync8(conversationDir(workspaceId, conversationId), { recursive: true });
+  writeFileSync6(
     pathFor3(workspaceId, conversationId, agentId),
     JSON.stringify(result) + "\n",
     "utf8"
   );
 }
 function clearPrepared(workspaceId, conversationId, agentId) {
-  rmSync6(pathFor3(workspaceId, conversationId, agentId), { force: true });
+  rmSync5(pathFor3(workspaceId, conversationId, agentId), { force: true });
 }
 
 // src/secrets.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
-import { join as join14 } from "path";
-import { z as z13 } from "zod";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join12 } from "path";
+import { z as z14 } from "zod";
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function secretsPath() {
-  return join14(cabaneDir(), "secrets.json");
+  return join12(cabaneDir(), "secrets.json");
 }
-var secretStoreSchema = z13.record(z13.string(), z13.string());
+var secretStoreSchema = z14.record(z14.string(), z14.string());
 function loadSecretStore() {
   const path = secretsPath();
-  if (!existsSync11(path)) return makeStore({});
+  if (!existsSync9(path)) return makeStore({});
   let raw;
   try {
-    raw = readFileSync8(path, "utf8");
+    raw = readFileSync7(path, "utf8");
   } catch (err) {
     throw new ConfigError(
       `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -7457,21 +7078,22 @@ function resolveMcpSecrets(mcpServers, store) {
 }
 
 // src/transcript-writer.ts
-import { appendFileSync, chmodSync as chmodSync3, mkdirSync as mkdirSync10, readdirSync, rmSync as rmSync7 } from "fs";
-import { join as join15 } from "path";
+import { appendFileSync, chmodSync as chmodSync3, copyFileSync, mkdirSync as mkdirSync9, readdirSync, rmSync as rmSync6 } from "fs";
+import { basename, dirname as dirname5, join as join13 } from "path";
 function transcriptsDir() {
-  return join15(cabaneDir(), "transcripts");
+  return join13(cabaneDir(), "transcripts");
 }
 var RETAIN = 200;
+var ANOMALY_RETAIN = 50;
 var TranscriptWriter = class {
   path;
   broken = false;
   onWarn;
   constructor(dir2, meta, onWarn) {
     this.onWarn = onWarn;
-    this.path = join15(dir2, fileName(meta));
+    this.path = join13(dir2, fileName(meta));
     try {
-      mkdirSync10(dir2, { recursive: true });
+      mkdirSync9(dir2, { recursive: true });
       try {
         chmodSync3(dir2, 448);
       } catch {
@@ -7490,6 +7112,25 @@ var TranscriptWriter = class {
   close(outcome) {
     this.line({ type: "_outcome", ...outcome });
   }
+  // CT1145: keep an independent copy of an empty successful envelope after the
+  // footer has landed. The ordinary 200-file FIFO keeps rotating as before;
+  // this bucket retains the newest 50 anomalies regardless of ordinary traffic.
+  // Best-effort like every other transcript operation: observability can never
+  // fail the turn.
+  preserveAnomaly() {
+    if (this.broken) return;
+    try {
+      const dir2 = join13(dirname5(this.path), "anomalies");
+      mkdirSync9(dir2, { recursive: true, mode: 448 });
+      chmodSync3(dir2, 448);
+      const target = join13(dir2, basename(this.path));
+      copyFileSync(this.path, target);
+      chmodSync3(target, 384);
+      pruneOld(dir2, ANOMALY_RETAIN);
+    } catch (err) {
+      this.fail(err);
+    }
+  }
   line(obj) {
     if (this.broken) return;
     try {
@@ -7528,7 +7169,7 @@ function pruneOld(dir2, retain) {
   const drop = files.sort().slice(0, files.length - retain);
   for (const f of drop) {
     try {
-      rmSync7(join15(dir2, f), { force: true });
+      rmSync6(join13(dir2, f), { force: true });
     } catch {
     }
   }
@@ -7647,13 +7288,16 @@ var TurnCommitter = class {
   get replyBody() {
     return this.pump.replyBody;
   }
+  get finalSource() {
+    return this.pump.finalSource;
+  }
   // CT183: resolve the in-thread summon into the `dispatch` field for a `final`
   // commit. A self-target is stripped here (mirror of the in-app self-strip); the
   // server strips it again and resolves / ignores an unknown id.
   summonField() {
-    const target2 = this.deps.summonState.agentId;
-    if (!target2 || target2 === this.deps.agentId) return {};
-    return { dispatch: target2 };
+    const target = this.deps.summonState.agentId;
+    if (!target || target === this.deps.agentId) return {};
+    return { dispatch: target };
   }
   // CT326: resolve the per-turn ask into the `ask` field for a `final` commit.
   // The server validates the target (must be a workspace member/owner) and
@@ -7874,7 +7518,7 @@ var DEFAULT_AGENT_IDLE_TIMEOUT_MS = 10 * 6e4;
 var DEFAULT_AGENT_TOTAL_TIMEOUT_MS = 6 * 60 * 6e4;
 function checkoutState(cwd) {
   if (!cwd) return { ok: false, reason: "no working directory was resolved for this turn" };
-  if (!existsSync12(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
+  if (!existsSync10(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
   let entries;
   try {
     entries = readdirSync2(cwd);
@@ -7884,15 +7528,15 @@ function checkoutState(cwd) {
   if (entries.length === 0) {
     return { ok: false, reason: `${cwd} is empty \u2014 a recreated shell, not a prepared directory` };
   }
-  const gitPath = join16(cwd, ".git");
-  if (!existsSync12(gitPath)) return { ok: true, reason: "usable" };
+  const gitPath = join14(cwd, ".git");
+  if (!existsSync10(gitPath)) return { ok: true, reason: "usable" };
   let stat;
   try {
     stat = statSync(gitPath);
   } catch (error) {
     return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
   }
-  if (stat.isDirectory() && !existsSync12(join16(gitPath, "HEAD")))
+  if (stat.isDirectory() && !existsSync10(join14(gitPath, "HEAD")))
     return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
   return { ok: true, reason: "usable" };
 }
@@ -8083,7 +7727,7 @@ var Dispatcher = class {
     let seqCounter = 0;
     const nextSeq = () => ++seqCounter;
     let effectiveCwd = localCwd ?? cabaneCwd;
-    if (effectiveCwd && !existsSync12(effectiveCwd)) {
+    if (effectiveCwd && !existsSync10(effectiveCwd)) {
       turnLog.warn(
         { cwd: effectiveCwd },
         "dispatcher: configured working directory does not exist on this device \u2014 falling back to the process cwd"
@@ -8347,11 +7991,11 @@ ${reason}`,
     const totalTimeoutMs = this.opts.totalTimeoutMs ?? DEFAULT_AGENT_TOTAL_TIMEOUT_MS;
     const closeTurnReceipt = (ok, reason) => {
       if (!turnReceiptPath) return;
-      const target2 = turnReceiptPath;
+      const target = turnReceiptPath;
       turnReceiptPath = null;
       try {
         appendFileSync2(
-          target2,
+          target,
           `${JSON.stringify({
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             event: "settled",
@@ -8391,7 +8035,7 @@ ${reason}`,
         }
         return this.concludeBeforeRun(payload, turnLog, startedAt, reason);
       }
-      const receiptPath = join16(effectiveCwd, ".git", "cabane", "readiness.jsonl");
+      const receiptPath = join14(effectiveCwd, ".git", "cabane", "readiness.jsonl");
       const receiptLine = (fields) => `${JSON.stringify({
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         taskId: hookEnv.CABANE_TASK_ID,
@@ -8415,7 +8059,7 @@ ${reason}`,
       })}
 `;
       try {
-        mkdirSync11(join16(effectiveCwd, ".git", "cabane"), { recursive: true });
+        mkdirSync10(join14(effectiveCwd, ".git", "cabane"), { recursive: true });
         appendFileSync2(
           receiptPath,
           // `starting` is the honest classification before the proof has run. The
@@ -8510,6 +8154,16 @@ ${reason}`,
     let turnUsage;
     let turnResolvedModel;
     let turnResolvedConfig;
+    const eventCounts = {
+      session: 0,
+      text: 0,
+      thinking: 0,
+      tool: 0,
+      result: 0
+    };
+    let runtimeResultKind = null;
+    let latestSessionState = request.session;
+    let settledDiagnostics = null;
     const committer = new TurnCommitter({
       api: this.opts.api,
       workspaceId,
@@ -8605,6 +8259,7 @@ ${reason}`,
     try {
       for await (const event of adapter.runTurn(request, abortController.signal)) {
         transcript2?.write(event);
+        eventCounts[event.type] += 1;
         armIdle();
         if (abortController.signal.aborted) {
           turnLog.info("dispatcher: aborted mid-turn");
@@ -8613,6 +8268,7 @@ ${reason}`,
           break;
         }
         if (event.type === "session") {
+          latestSessionState = event.state;
           if (event.degraded) sessionDegraded = true;
           if (!sessionWritten) {
             sessionWritten = true;
@@ -8651,6 +8307,7 @@ ${reason}`,
           turnUsage = event.usage;
           turnResolvedModel = event.resolvedModel;
           turnResolvedConfig = event.resolvedConfig;
+          runtimeResultKind = event.ok ? "success" : event.reason === "no_terminal" ? "no_terminal" : "error";
         } else if (event.type === "text" && skipState.skipped) {
         } else {
           if (event.type === "text" && event.terminal) {
@@ -8773,6 +8430,34 @@ ${reason}`,
         body.sessionWriteRejected = true;
         this.sessionWriteNotified.add(key);
       }
+      const outcome = skipState.skipped ? "skipped" : userCancelled ? "cancelled" : okResult ? "success" : "failure";
+      const noContentEvents = eventCounts.text === 0 && eventCounts.thinking === 0 && eventCounts.tool === 0;
+      const emptySuccessfulEnvelope = outcome === "success" && eventCounts.result > 0 && noContentEvents;
+      const diagnosticReason = outcome === "skipped" ? { kind: "skipped" } : outcome === "cancelled" ? { kind: "cancelled" } : emptySuccessfulEnvelope ? turnUsage?.inputTokens === 0 && turnUsage.outputTokens === 0 ? { kind: "empty_result" } : { kind: "empty_result_unverified" } : outcome === "failure" ? normalizeTurnResultReason(resultReason) : null;
+      settledDiagnostics = {
+        outcome,
+        resultReason: diagnosticReason,
+        sessionMode: sessionDegraded ? "degraded" : request.session ? "resumed" : "fresh",
+        sessionFingerprint: fingerprintSessionState(latestSessionState),
+        eventCounts,
+        runtimeResultKind,
+        finalSource: outcome === "skipped" || outcome === "cancelled" ? "marker" : committer.finalSource
+      };
+      body.diagnostics = settledDiagnostics;
+      if (diagnosticReason && !["usage_capped", "rate_limited", "auth_expired", "cancelled", "skipped"].includes(
+        diagnosticReason.kind
+      )) {
+        turnLog.warn(
+          {
+            turnId,
+            conversationId: payload.conversationId,
+            agentId: payload.agentId,
+            runtime: turnRuntime,
+            diagnostics: settledDiagnostics
+          },
+          "dispatcher: anomalous turn settled"
+        );
+      }
       this.opts.connectorHealth?.recordSettle(turnRuntime, {
         ok: okResult,
         errorReason: body.errorReason ?? null
@@ -8805,6 +8490,9 @@ ${reason}`,
       if (!okResult && resultReason !== "cancelled") {
         turnLog.info(`turn failed \u2014 full transcript: ${transcript2.path}`);
       }
+      if (settledDiagnostics?.resultReason?.kind === "empty_result" || settledDiagnostics?.resultReason?.kind === "empty_result_unverified") {
+        transcript2.preserveAnomaly();
+      }
     }
     if (okResult) {
       turnLog.debug({ durationMs }, "dispatcher: turn end (ok)");
@@ -8842,6 +8530,17 @@ ${reason}`,
     return true;
   }
 };
+function fingerprintSessionState(state) {
+  if (!state) return null;
+  let opaqueId = state;
+  try {
+    const parsed = JSON.parse(state);
+    const candidate = parsed.sdkSessionId ?? parsed.threadId ?? parsed.sessionId;
+    if (typeof candidate === "string" && candidate.length > 0) opaqueId = candidate;
+  } catch {
+  }
+  return createHash2("sha256").update(opaqueId).digest("hex").slice(0, 16);
+}
 
 // src/opencode-models.ts
 var OPENCODE_RUNTIME = "opencode";
@@ -8886,15 +8585,15 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
 
 // src/outbox.ts
 import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync11,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync8,
   renameSync as renameSync3,
-  rmSync as rmSync8,
-  writeFileSync as writeFileSync8
+  rmSync as rmSync7,
+  writeFileSync as writeFileSync7
 } from "fs";
-import { join as join17 } from "path";
+import { join as join15 } from "path";
 var MAX_ENTRIES = 2e3;
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var Outbox = class {
@@ -8907,25 +8606,25 @@ var Outbox = class {
   // Resolved lazily (per call, like cursor.ts) so tests that swap HOME between
   // cases route writes at the right tmpdir.
   dir() {
-    return join17(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
+    return join15(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
   }
   fileFor(turnId, seq) {
-    return join17(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+    return join15(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
   // per-workspace bounds.
   persist(entry) {
     const dir2 = this.dir();
-    mkdirSync12(dir2, { recursive: true });
-    const target2 = this.fileFor(entry.turnId, entry.seq);
-    const tmp = `${target2}.${process.pid}.tmp`;
+    mkdirSync11(dir2, { recursive: true });
+    const target = this.fileFor(entry.turnId, entry.seq);
+    const tmp = `${target}.${process.pid}.tmp`;
     try {
-      writeFileSync8(tmp, JSON.stringify(entry) + "\n", "utf8");
-      renameSync3(tmp, target2);
+      writeFileSync7(tmp, JSON.stringify(entry) + "\n", "utf8");
+      renameSync3(tmp, target);
     } catch (err) {
       try {
-        rmSync8(tmp, { force: true });
+        rmSync7(tmp, { force: true });
       } catch {
       }
       this.log?.warn(
@@ -8942,7 +8641,7 @@ var Outbox = class {
   // wedging the drain.
   list() {
     const dir2 = this.dir();
-    if (!existsSync13(dir2)) return [];
+    if (!existsSync11(dir2)) return [];
     let names;
     try {
       names = readdirSync3(dir2);
@@ -8952,9 +8651,9 @@ var Outbox = class {
     const entries = [];
     for (const name of names) {
       if (!name.endsWith(".json")) continue;
-      const full = join17(dir2, name);
+      const full = join15(dir2, name);
       try {
-        const parsed = JSON.parse(readFileSync9(full, "utf8"));
+        const parsed = JSON.parse(readFileSync8(full, "utf8"));
         if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
           entries.push(parsed);
         } else {
@@ -8972,13 +8671,13 @@ var Outbox = class {
   // Remove a delivered (or terminally-discarded) entry. No-op if already gone.
   remove(turnId, seq) {
     try {
-      rmSync8(this.fileFor(turnId, seq), { force: true });
+      rmSync7(this.fileFor(turnId, seq), { force: true });
     } catch {
     }
   }
   size() {
     const dir2 = this.dir();
-    if (!existsSync13(dir2)) return 0;
+    if (!existsSync11(dir2)) return 0;
     try {
       return readdirSync3(dir2).filter((n) => n.endsWith(".json")).length;
     } catch {
@@ -8991,7 +8690,7 @@ var Outbox = class {
       "companion outbox: dropping unreadable entry"
     );
     try {
-      rmSync8(full, { force: true });
+      rmSync7(full, { force: true });
     } catch {
     }
   }
@@ -9026,43 +8725,43 @@ var Outbox = class {
 };
 
 // src/run-config.ts
-import { z as z14 } from "zod";
-var mcpStdioServerSchema = z14.object({
-  type: z14.literal("stdio").optional(),
-  command: z14.string().min(1),
-  args: z14.array(z14.string()).optional(),
-  env: z14.record(z14.string(), z14.string()).optional()
+import { z as z15 } from "zod";
+var mcpStdioServerSchema = z15.object({
+  type: z15.literal("stdio").optional(),
+  command: z15.string().min(1),
+  args: z15.array(z15.string()).optional(),
+  env: z15.record(z15.string(), z15.string()).optional()
 });
-var mcpHttpServerSchema = z14.object({
-  type: z14.literal("http"),
-  url: z14.string().url(),
-  headers: z14.record(z14.string(), z14.string()).optional()
+var mcpHttpServerSchema = z15.object({
+  type: z15.literal("http"),
+  url: z15.string().url(),
+  headers: z15.record(z15.string(), z15.string()).optional()
 });
-var mcpSseServerSchema = z14.object({
-  type: z14.literal("sse"),
-  url: z14.string().url(),
-  headers: z14.record(z14.string(), z14.string()).optional()
+var mcpSseServerSchema = z15.object({
+  type: z15.literal("sse"),
+  url: z15.string().url(),
+  headers: z15.record(z15.string(), z15.string()).optional()
 });
-var mcpServerDefSchema = z14.union([
+var mcpServerDefSchema = z15.union([
   mcpHttpServerSchema,
   mcpSseServerSchema,
   mcpStdioServerSchema
 ]);
-var thinkingConfigSchema = z14.discriminatedUnion("type", [
-  z14.object({ type: z14.literal("adaptive") }),
-  z14.object({ type: z14.literal("enabled"), budgetTokens: z14.number().int().positive().optional() }),
-  z14.object({ type: z14.literal("disabled") })
+var thinkingConfigSchema = z15.discriminatedUnion("type", [
+  z15.object({ type: z15.literal("adaptive") }),
+  z15.object({ type: z15.literal("enabled"), budgetTokens: z15.number().int().positive().optional() }),
+  z15.object({ type: z15.literal("disabled") })
 ]);
-var effortSchema = z14.enum(["low", "medium", "high", "xhigh", "max"]);
-var runConfigSchema = z14.object({
+var effortSchema = z15.enum(["low", "medium", "high", "xhigh", "max"]);
+var runConfigSchema = z15.object({
   // CT788: the host-access binary replaced the `assistant`/`coding`/`custom` mode
   // trio + its custom tool lists — `true` grants the host filesystem/shell, absent
   // is the locked surface. Kept in lockstep with `@cabane/shared`'s
   // `agentRunConfigSchema` (independent zod, forward-compatible: unknown keys are
   // stripped, so an older companion riding a newer server never rejects the config).
-  hostAccess: z14.boolean().optional(),
-  mcpServers: z14.record(z14.string(), mcpServerDefSchema).optional(),
-  model: z14.string().min(1).optional(),
+  hostAccess: z15.boolean().optional(),
+  mcpServers: z15.record(z15.string(), mcpServerDefSchema).optional(),
+  model: z15.string().min(1).optional(),
   thinking: thinkingConfigSchema.optional(),
   effort: effortSchema.optional()
 });
@@ -10153,22 +9852,22 @@ function handleUncaught(log, err, origin) {
 }
 
 // src/crash-marker.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync13, readFileSync as readFileSync10, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync12, readFileSync as readFileSync9, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
+import { join as join16 } from "path";
 function crashMarkerPath() {
-  return join18(cabaneDir(), "last-error.json");
+  return join16(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
-    mkdirSync13(cabaneDir(), { recursive: true });
-    writeFileSync9(crashMarkerPath(), JSON.stringify(rec2, null, 2) + "\n");
+    mkdirSync12(cabaneDir(), { recursive: true });
+    writeFileSync8(crashMarkerPath(), JSON.stringify(rec2, null, 2) + "\n");
   } catch {
   }
 }
 function clearCrash() {
   try {
     const path = crashMarkerPath();
-    if (existsSync14(path)) rmSync9(path, { force: true });
+    if (existsSync12(path)) rmSync8(path, { force: true });
   } catch {
   }
 }
@@ -10320,7 +10019,24 @@ async function closeSurfaces(control, dashboard) {
 
 // src/commands/daemon.ts
 import { spawn as spawn5 } from "child_process";
-import { closeSync as closeSync3, mkdirSync as mkdirSync14, openSync as openSync3 } from "fs";
+import { closeSync as closeSync3, mkdirSync as mkdirSync13, openSync as openSync3 } from "fs";
+
+// src/cli-entry.ts
+import { existsSync as existsSync13 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var RELATIVE_CANDIDATES = ["./cli.js", "../dist/cli.js", "../cli.js"];
+function companionCliEntry(deps = {}) {
+  const exists = deps.exists ?? existsSync13;
+  const candidates = deps.candidates ?? RELATIVE_CANDIDATES.map((rel) => fileURLToPath2(new URL(rel, import.meta.url)));
+  for (const candidate of candidates) {
+    if (exists(candidate)) return candidate;
+  }
+  const argv1 = "argv1" in deps ? deps.argv1 : process.argv[1];
+  if (argv1 && exists(argv1)) return argv1;
+  return candidates[0] ?? "";
+}
+
+// src/commands/daemon.ts
 var STARTUP_TIMEOUT_MS = 8e3;
 var POLL_INTERVAL_MS = 150;
 async function startDaemon(opts = {}, deps = {}) {
@@ -10330,11 +10046,6 @@ async function startDaemon(opts = {}, deps = {}) {
   const spawnDetached = deps.spawnDetached ?? defaultSpawnDetached;
   const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = deps.now ?? (() => Date.now());
-  const install = deps.installService ?? ((o) => installService(o));
-  const refresh = deps.refreshService ?? ((o) => refreshInstalledService(o));
-  const disable = deps.disableService ?? (() => disableService());
-  const isTty = deps.isTty ?? (() => Boolean(process.stdin.isTTY));
-  const serviceOpts = {};
   const quiet = opts.report === "failures";
   const { cfg, claudeOnPath: claudeOnPath2 } = await requireStartConfig({
     // Unset → `requireStartConfig`'s own `requireConfig`, the real one.
@@ -10362,22 +10073,16 @@ async function startDaemon(opts = {}, deps = {}) {
   const existing = readState();
   if (existing) {
     if (await verify(existing) !== "stale") {
-      const rerendered = isTty() ? refresh(serviceOpts) : false;
       process.stdout.write(
         `Cabane Companion is already running (pid ${existing.pid}).
 Stop it first with \`cabane-companion stop\` if you want to relaunch.
 Connect a harness to the running companion: cabane-companion connect claude-code
-` + (rerendered ? "Autostart: the login service was updated for this install \u2014 it takes effect at the next login, or now with `cabane-companion stop` then `start`.\n" : "")
+`
       );
-      return {
-        started: false,
-        service: { installed: false, reason: "unsupported" },
-        state: existing
-      };
+      return { started: false, state: existing };
     }
     clearRuntimeState();
   }
-  let service2 = isTty() ? install(serviceOpts) : { installed: false, reason: "unsupported" };
   const args = ["start", "--foreground"];
   const launchDetached = () => {
     const spawned = spawnDetached(args);
@@ -10394,29 +10099,8 @@ Connect a harness to the running companion: cabane-companion connect claude-code
     }
     return ready(seen) ? seen : null;
   };
-  if (!service2.installed && service2.leftBehind) {
-    refuseDouble(service2.leftBehind, service2.detail);
-    process.exitCode = 1;
-    return { started: false, service: service2, state: null };
-  }
-  let child = service2.installed ? null : launchDetached();
-  let state = await waitForReady();
-  if (!state && service2.installed) {
-    process.stdout.write(
-      `${service2.manager} started the companion but it didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s \u2014 removing the login service.
-`
-    );
-    const removed = disable();
-    if (!removed.handled || !removed.ok) {
-      refuseDouble(service2.manager, removed.detail);
-      process.exitCode = 1;
-      return { started: false, service: service2, state: null };
-    }
-    process.stdout.write("Launching it directly instead.\n");
-    service2 = { installed: false, reason: "command-failed", detail: "the service never came up" };
-    child = launchDetached();
-    state = await waitForReady();
-  }
+  const child = launchDetached();
+  const state = await waitForReady();
   if (!state) {
     process.stdout.write(
       `Cabane Companion was launched (pid ${child?.pid ?? "?"}) but didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.
@@ -10424,9 +10108,9 @@ Check ${companionLogPath()} for errors, or run \`cabane-companion status\`.
 `
     );
     process.exitCode = 1;
-    return { started: false, service: service2, state: null };
+    return { started: false, state: null };
   }
-  if (quiet) return { started: true, service: service2, state };
+  if (quiet) return { started: true, state };
   process.stdout.write(
     `Cabane Companion started in the background (pid ${state.pid}).
 Logs:    ${companionLogPath()}
@@ -10434,27 +10118,11 @@ Status:  cabane-companion status
 Stop:    cabane-companion stop
 `
   );
-  if (service2.installed) {
-    process.stdout.write(`Autostart: enabled (${service2.manager}) \u2014 it starts again at login.
-`);
-  } else if (service2.reason !== "unsupported") {
-    process.stdout.write(
-      `Autostart: not enabled \u2014 ${service2.detail ?? "the service manager refused the install"}. Running detached instead; it won't come back after a reboot.
-`
-    );
-  }
-  return { started: true, service: service2, state };
-}
-function refuseDouble(manager, detail) {
-  process.stdout.write(
-    `${manager} still has the login service${detail ? ` (${detail})` : ""} \u2014 not launching a second companion beside a service that may still own one.
-Check \`cabane-companion service status\`, then \`cabane-companion service disable\`, and run \`cabane-companion start --daemon\` again.
-`
-  );
+  return { started: true, state };
 }
 function defaultSpawnDetached(args) {
   const cliPath = companionCliEntry();
-  mkdirSync14(cabaneDir(), { recursive: true });
+  mkdirSync13(cabaneDir(), { recursive: true });
   const logFd = openSync3(companionLogPath(), "a");
   try {
     return spawn5(process.execPath, [cliPath, ...args], {
@@ -10675,11 +10343,7 @@ async function handOffToBackground(runtime, ctx) {
     return;
   }
   if (ctx.spaceAbove) blank();
-  write(
-    INDENT + tick(
-      outcome.service.installed ? "Cabane companion is running in the background, and will start again when you log in." : "Cabane companion is running in the background."
-    )
-  );
+  write(INDENT + tick("Cabane companion is running in the background."));
   write(`    Stop:  cabane-companion stop        Logs:  ${tildePath(companionLogPath())}`);
   if (ctx.justPaired) {
     blank();
@@ -10743,8 +10407,7 @@ companion: deploy drain requested (${graceMs}ms grace)\u2026
 
 // src/commands/status.ts
 import { readdirSync as readdirSync4 } from "fs";
-async function status(deps = {}) {
-  const readService = deps.service ?? serviceStatus;
+async function status() {
   const cfg = loadConfig();
   if (!cfg || !cfg.deviceToken) {
     process.stdout.write(
@@ -10780,13 +10443,6 @@ async function status(deps = {}) {
       "companion:       not running \u2014 `cabane-companion start` (backgrounds itself; `--foreground` stays attached)\n"
     );
   }
-  const svc = readService();
-  if (svc.installed) {
-    process.stdout.write(
-      `autostart:    ${svc.manager} \u2014 starts at login` + (svc.manager === "systemd-user" && svc.linger !== "yes" ? ", while you are logged in" : "") + ` (details: cabane-companion service status)
-`
-    );
-  }
   process.stdout.write(
     "agents:       pulled from cabane at runtime \u2014 see this device in Cabane for its assigned agents, their run state, and any missing-secret warnings.\n"
   );
@@ -10833,34 +10489,12 @@ function formatUptime(startedAt) {
 // src/commands/stop.ts
 var TERM_GRACE_MS = 6e3;
 var POLL_INTERVAL_MS2 = 150;
-var SERVICE_STOP_GRACE_MS = 3e3;
 async function stop(deps = {}) {
   const readState = deps.readState ?? readLiveRuntimeState;
   const verify = deps.verify ?? ((s) => verifyRuntime(s));
   const kill = deps.kill ?? ((pid2, signal) => process.kill(pid2, signal));
   const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = deps.now ?? (() => Date.now());
-  const stopSvc = deps.stopService ?? (() => stopService());
-  const svc = stopSvc();
-  if (svc.handled) {
-    if (!svc.ok) {
-      process.stdout.write(
-        `companion: ${svc.manager} wouldn't stop the service${svc.detail ? ` (${svc.detail})` : ""}.
-The service manager owns this process \u2014 stopping it directly would just be restarted.
-Check \`cabane-companion service status\`, or remove it with \`cabane-companion service disable\`.
-`
-      );
-      process.exitCode = 1;
-      return;
-    }
-    const deadline2 = now() + SERVICE_STOP_GRACE_MS;
-    while (readState() && now() < deadline2) await sleep4(POLL_INTERVAL_MS2);
-    if (!readState()) {
-      process.stdout.write(`companion: stopped (${svc.manager} service stopped).
-`);
-      return;
-    }
-  }
   const state = readState();
   if (!state) {
     process.stdout.write("companion: not running (nothing to stop).\n");
@@ -10910,8 +10544,8 @@ function isAlive(kill, pid) {
 }
 
 // src/commands/transcript.ts
-import { existsSync as existsSync15, readFileSync as readFileSync11, readdirSync as readdirSync5 } from "fs";
-import { isAbsolute, join as join19 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync10, readdirSync as readdirSync5 } from "fs";
+import { isAbsolute, join as join17 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -10928,7 +10562,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join19(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join17(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -11011,7 +10645,7 @@ function isComplete(content) {
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync11(join19(dir2, f), "utf8"),
+    read: (f) => readFileSync10(join17(dir2, f), "utf8"),
     write: (s) => process.stdout.write(s),
     // CSI: cursor up `n` lines, then erase from cursor to end of screen.
     clearLines: (n) => process.stdout.write(`\x1B[${n}A\x1B[0J`),
@@ -11051,7 +10685,7 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join19(dir2, f));
+    const { meta, outcome } = peek(join17(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
     const ws = str2(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
@@ -11072,7 +10706,7 @@ function peek(path) {
   let meta;
   let outcome;
   try {
-    for (const line of readFileSync11(path, "utf8").split("\n")) {
+    for (const line of readFileSync10(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       const o = safeParse(line);
       const t = str2(rec(o)?.type);
@@ -11083,29 +10717,29 @@ function peek(path) {
   }
   return { meta, outcome };
 }
-function resolveTarget(dir2, target2) {
-  if (isAbsolute(target2) || target2.includes("/")) {
-    if (existsSync15(target2)) return target2;
-    throw new CompanionError(`no transcript at ${target2}.`);
+function resolveTarget(dir2, target) {
+  if (isAbsolute(target) || target.includes("/")) {
+    if (existsSync14(target)) return target;
+    throw new CompanionError(`no transcript at ${target}.`);
   }
-  const exact = join19(dir2, target2);
-  if (existsSync15(exact)) return exact;
-  const matches = listFiles(dir2).filter((f) => f.includes(target2));
-  if (matches.length === 1) return join19(dir2, matches[0]);
+  const exact = join17(dir2, target);
+  if (existsSync14(exact)) return exact;
+  const matches = listFiles(dir2).filter((f) => f.includes(target));
+  if (matches.length === 1) return join17(dir2, matches[0]);
   if (matches.length === 0) {
     throw new CompanionError(
-      `no transcript matching "${target2}" in ${dir2}. Run \`cabane-companion transcript\` to list them.`
+      `no transcript matching "${target}" in ${dir2}. Run \`cabane-companion transcript\` to list them.`
     );
   }
   throw new CompanionError(
-    `"${target2}" matches ${matches.length} transcripts \u2014 be more specific:
+    `"${target}" matches ${matches.length} transcripts \u2014 be more specific:
 ` + matches.slice(0, 10).map((m) => `  ${m}`).join("\n")
   );
 }
 function renderFile(path) {
   let content;
   try {
-    content = readFileSync11(path, "utf8");
+    content = readFileSync10(path, "utf8");
   } catch (err) {
     throw new CompanionError(
       `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -11242,11 +10876,11 @@ program.command("pair").description(
   });
 });
 program.command("write-paired-config", { hidden: true }).description("persist an already-completed device enrollment payload from stdin.").action(() => {
-  writeCompletedPairing(readFileSync12(0, "utf8"));
+  writeCompletedPairing(readFileSync11(0, "utf8"));
 });
 program.command("start").description(
   "pair this device if needed, connect a coding agent on it, and run in the background."
-).option("--foreground", "run attached in this terminal (never installs the login service)").option("--daemon", "run in the background (the default; kept for compatibility)").option("--server <url>", "the cabane instance to pair with, if this device isn\u2019t paired yet").addOption(new Option("--open").hideHelp()).addOption(new Option("--no-open").hideHelp()).addOption(new Option("--port <port>").hideHelp()).action(async (opts) => {
+).option("--foreground", "run attached in this terminal (for terminals and supervisors)").option("--daemon", "run in the background (the default; kept for compatibility)").option("--server <url>", "the cabane instance to pair with, if this device isn\u2019t paired yet").addOption(new Option("--open").hideHelp()).addOption(new Option("--no-open").hideHelp()).addOption(new Option("--port <port>").hideHelp()).action(async (opts) => {
   await start({
     ...opts.foreground ? { foreground: true } : {},
     ...opts.server !== void 0 ? { server: opts.server } : {}
@@ -11261,13 +10895,6 @@ program.command("stop").description("stop a running companion (SIGTERM, then for
 program.command("status").description("print the companion's local state (pairing, secrets, log path).").action(async () => {
   await status();
 });
-var service = program.command("service").description("inspect or remove the login service that starts the companion when you log in.");
-service.command("status").description("print the service manager, whether the unit is installed and running.").action(() => {
-  serviceStatusCommand();
-});
-service.command("disable").description("stop the companion and remove the login service, leaving the machine clean.").action(() => {
-  serviceDisableCommand();
-});
 program.command("transcript").description("show the full agent transcript for a recent dispatch (the agent's whole turn).").argument("[file]", "a transcript filename or substring; omit to list recent transcripts").option("--last", "render the most recent transcript").option("-f, --follow", "watch for new turns and live-render them as they land (Ctrl-C to stop)").action(async (file, opts) => {
   await transcript({
     ...file !== void 0 ? { target: file } : {},