@cabane/companion 0.6.158 → 0.6.160

package/dist/cli.js

@@ -9,166 +9,11 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/bundled-binaries.ts
-import { realpathSync, statSync } from "fs";
-import { createRequire } from "module";
+// src/install-kind.ts
+import { realpathSync } from "fs";
 import { homedir } from "os";
 import { dirname, join, sep } from "path";
 import { fileURLToPath } from "url";
-function nodeResolveSelf(specifier) {
-  const here = fileURLToPath(import.meta.url);
-  if (typeof import.meta.resolve === "function") {
-    try {
-      return fileURLToPath(import.meta.resolve(specifier));
-    } catch {
-    }
-  }
-  try {
-    return createRequire(here).resolve(specifier);
-  } catch {
-  }
-  return walkNodeModules(specifier, here);
-}
-function walkNodeModules(pkg2, fromPath) {
-  let dir2 = dirname(fromPath);
-  for (; ; ) {
-    const manifest = join(dir2, "node_modules", pkg2, "package.json");
-    if (nodeIsFile(manifest)) {
-      try {
-        return realpathSync(manifest);
-      } catch {
-        return manifest;
-      }
-    }
-    const parent = dirname(dir2);
-    if (parent === dir2) return null;
-    dir2 = parent;
-  }
-}
-function nodeResolve(specifier, fromPath) {
-  try {
-    return createRequire(fromPath).resolve(specifier);
-  } catch {
-    return null;
-  }
-}
-function nodeIsFile(path) {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
-}
-function detectPreferMusl(platform = process.platform) {
-  if (platform !== "linux") return false;
-  const report = typeof process.report?.getReport === "function" ? process.report.getReport() : null;
-  const header = report?.header;
-  return report != null && header?.glibcVersionRuntime === void 0;
-}
-function defaultResolveEnv() {
-  return {
-    platform: process.platform,
-    arch: process.arch,
-    preferMusl: detectPreferMusl(),
-    // Both resolutions start from this module, which tsup bundles into
-    // `dist/cli.js` and `dist/postinstall.js` — both at the package's `dist/`
-    // root — so one environment serves the runtime checks and the install
-    // verifier alike.
-    resolveSelf: nodeResolveSelf,
-    resolve: nodeResolve,
-    isFile: nodeIsFile
-  };
-}
-function claudePlatformPackages(platform, arch, preferMusl) {
-  if (platform === "android") return [`${CLAUDE_SDK}-linux-${arch}-android`];
-  if (platform === "linux") {
-    return preferMusl ? [`${CLAUDE_SDK}-linux-${arch}-musl`, `${CLAUDE_SDK}-linux-${arch}`] : [`${CLAUDE_SDK}-linux-${arch}`, `${CLAUDE_SDK}-linux-${arch}-musl`];
-  }
-  return [`${CLAUDE_SDK}-${platform}-${arch}`];
-}
-function resolveClaude(env) {
-  const candidates = claudePlatformPackages(env.platform, env.arch, env.preferMusl);
-  const base = {
-    runtime: "claude-code",
-    packageName: candidates[0] ?? null,
-    platform: env.platform,
-    arch: env.arch
-  };
-  const sdkEntry = env.resolveSelf(CLAUDE_SDK);
-  if (!sdkEntry) return { ...base, status: "platform_package_missing", path: null };
-  let sawPackage = null;
-  for (const pkg2 of candidates) {
-    const manifest = env.resolve(`${pkg2}/package.json`, sdkEntry);
-    if (!manifest) continue;
-    sawPackage ??= pkg2;
-    const exe = join(dirname(manifest), env.platform === "win32" ? "claude.exe" : "claude");
-    if (env.isFile(exe)) {
-      return { ...base, packageName: pkg2, status: "present", path: exe };
-    }
-  }
-  return sawPackage ? { ...base, packageName: sawPackage, status: "executable_missing", path: null } : { ...base, status: "platform_package_missing", path: null };
-}
-function codexTargetTriple(platform, arch) {
-  if (platform === "linux" || platform === "android") {
-    if (arch === "x64") return "x86_64-unknown-linux-musl";
-    if (arch === "arm64") return "aarch64-unknown-linux-musl";
-    return null;
-  }
-  if (platform === "darwin") {
-    if (arch === "x64") return "x86_64-apple-darwin";
-    if (arch === "arm64") return "aarch64-apple-darwin";
-    return null;
-  }
-  if (platform === "win32") {
-    if (arch === "x64") return "x86_64-pc-windows-msvc";
-    if (arch === "arm64") return "aarch64-pc-windows-msvc";
-    return null;
-  }
-  return null;
-}
-function resolveCodex(env) {
-  const triple = codexTargetTriple(env.platform, env.arch);
-  const pkg2 = triple ? CODEX_PACKAGE_BY_TRIPLE[triple] : void 0;
-  const base = {
-    runtime: "codex",
-    packageName: pkg2 ?? null,
-    platform: env.platform,
-    arch: env.arch
-  };
-  if (!triple || !pkg2) return { ...base, status: "platform_package_missing", path: null };
-  const sdkEntry = env.resolveSelf(CODEX_SDK);
-  if (!sdkEntry) return { ...base, status: "platform_package_missing", path: null };
-  const cliManifest = env.resolve(`${CODEX_CLI}/package.json`, sdkEntry);
-  if (!cliManifest) return { ...base, status: "platform_package_missing", path: null };
-  const platformManifest = env.resolve(`${pkg2}/package.json`, cliManifest);
-  if (!platformManifest) return { ...base, status: "platform_package_missing", path: null };
-  const packageRoot = join(dirname(platformManifest), "vendor", triple);
-  const exeName = env.platform === "win32" ? "codex.exe" : "codex";
-  const current = join(packageRoot, "bin", exeName);
-  if (env.isFile(current) && env.isFile(join(packageRoot, "codex-package.json"))) {
-    return { ...base, status: "present", path: current };
-  }
-  const legacy = join(packageRoot, "codex", exeName);
-  if (env.isFile(legacy)) return { ...base, status: "present", path: legacy };
-  return { ...base, status: "executable_missing", path: null };
-}
-function resolveBundledBinary(runtime, env = defaultResolveEnv()) {
-  try {
-    return runtime === "codex" ? resolveCodex(env) : resolveClaude(env);
-  } catch {
-    return {
-      runtime,
-      status: "platform_package_missing",
-      path: null,
-      packageName: null,
-      platform: env.platform,
-      arch: env.arch
-    };
-  }
-}
-function missingNoun(status2) {
-  return status2 === "executable_missing" ? "executable" : "platform package";
-}
 function companionInstall(execPath = process.execPath, home = homedir()) {
   const real = (path) => {
     try {
@@ -180,47 +25,21 @@ function companionInstall(execPath = process.execPath, home = homedir()) {
   const scriptNode = join(real(home), ".cabane", "node") + sep;
   return real(execPath).startsWith(scriptNode) ? "script" : "npm";
 }
-function repairCommands(install = companionInstall()) {
-  return install === "script" ? [INSTALL_SCRIPT_COMMAND] : ["npm i -g @cabane/companion --include=optional"];
-}
-function repairAction(install = companionInstall()) {
-  return `Reinstall with \`${repairCommands(install)[0]}\`.`;
-}
-function startupWarning(r) {
-  const label = HARNESS_LABEL[r.runtime];
-  return `${label} is ${HARNESS_INTENT_WORD[r.runtime]}, but its installation is incomplete (${missingNoun(r.status)} is missing). It cannot run turns until repaired. ${repairAction()} Then restart the companion.`;
-}
-function harnessIssueNote(runtime, status2, install = companionInstall()) {
-  const intent = HARNESS_INTENT_WORD[runtime];
-  const capitalized = `${intent[0].toUpperCase()}${intent.slice(1)}`;
-  return `${capitalized}, but @cabane/companion's bundled ${HARNESS_LABEL[runtime]} ${missingNoun(status2)} is missing. ${repairAction(install)} Then restart the companion.`;
+function repairRoute(packageRoot = ownRoot(), install = companionInstall()) {
+  let root = packageRoot;
+  try {
+    root = realpathSync(packageRoot);
+  } catch {
+  }
+  return root.includes(`${sep}.cabane${sep}versions${sep}`) ? "managed" : install;
 }
-function turnIncompleteCopy(runtime) {
-  return `**This device's ${HARNESS_LABEL[runtime]} runtime is incomplete.** ${repairAction()} Restart it, then try again.`;
+function ownRoot() {
+  return dirname(dirname(fileURLToPath(import.meta.url)));
 }
-var CLAUDE_SDK, CODEX_SDK, CODEX_CLI, CODEX_PACKAGE_BY_TRIPLE, HARNESS_LABEL, HARNESS_INTENT_WORD, INSTALL_SCRIPT_COMMAND;
-var init_bundled_binaries = __esm({
-  "src/bundled-binaries.ts"() {
+var INSTALL_SCRIPT_COMMAND;
+var init_install_kind = __esm({
+  "src/install-kind.ts"() {
     "use strict";
-    CLAUDE_SDK = "@anthropic-ai/claude-agent-sdk";
-    CODEX_SDK = "@openai/codex-sdk";
-    CODEX_CLI = "@openai/codex";
-    CODEX_PACKAGE_BY_TRIPLE = {
-      "x86_64-unknown-linux-musl": `${CODEX_CLI}-linux-x64`,
-      "aarch64-unknown-linux-musl": `${CODEX_CLI}-linux-arm64`,
-      "x86_64-apple-darwin": `${CODEX_CLI}-darwin-x64`,
-      "aarch64-apple-darwin": `${CODEX_CLI}-darwin-arm64`,
-      "x86_64-pc-windows-msvc": `${CODEX_CLI}-win32-x64`,
-      "aarch64-pc-windows-msvc": `${CODEX_CLI}-win32-arm64`
-    };
-    HARNESS_LABEL = {
-      "claude-code": "Claude Code",
-      codex: "Codex"
-    };
-    HARNESS_INTENT_WORD = {
-      "claude-code": "connected",
-      codex: "enabled"
-    };
     INSTALL_SCRIPT_COMMAND = "curl -fsSL https://cabane.ai/install.sh | bash";
   }
 });
@@ -358,16 +177,37 @@ var init_term = __esm({
 // src/cabane-command.ts
 import { accessSync, constants, realpathSync as realpathSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { delimiter, join as join2, sep as sep2 } from "path";
+import { basename, delimiter, dirname as dirname2, join as join2, sep as sep2 } from "path";
+function invokedCommand(argv1) {
+  if (!argv1 || argv1.includes(VERSIONS_SEGMENT)) return null;
+  const name = basename(argv1);
+  if (name === "cabane" || name === "cabane-companion") return join2(dirname2(argv1), "cabane");
+  return npmBinFor(argv1);
+}
+function rememberInvokedCommand(env = process.env, argv1 = process.argv[1]) {
+  if (env[INVOKED_COMMAND_ENV]) return;
+  const invoked = invokedCommand(argv1);
+  if (invoked) env[INVOKED_COMMAND_ENV] = invoked;
+}
 function installedCommandPath(deps = {}) {
   const install = deps.install ?? companionInstall();
   const home = deps.home ?? homedir3();
   if (install === "script") return join2(home, ".cabane", "bin", "cabane");
   const entry = deps.cliEntry ?? companionCliEntry();
+  const own = npmBinFor(entry);
+  if (own) return own;
+  if (!entry.includes(VERSIONS_SEGMENT)) return null;
+  const isExecutable = deps.isExecutable ?? executable;
+  const invoked = "invoked" in deps ? deps.invoked : process.env[INVOKED_COMMAND_ENV];
+  if (invoked && isExecutable(invoked)) return invoked;
+  const besideNode = join2(dirname2(dirname2(deps.execPath ?? process.execPath)), "bin", "cabane");
+  return isExecutable(besideNode) ? besideNode : null;
+}
+function npmBinFor(path) {
   const marker = `${sep2}lib${sep2}node_modules${sep2}@cabane${sep2}companion${sep2}`;
-  const at = entry.indexOf(marker);
+  const at = path.indexOf(marker);
   if (at < 0) return null;
-  return join2(entry.slice(0, at), "bin", "cabane");
+  return join2(path.slice(0, at), "bin", "cabane");
 }
 function cabaneCommand(deps = {}) {
   const own = installedCommandPath(deps);
@@ -383,6 +223,9 @@ function cabaneCommand(deps = {}) {
 function cabane(rest, deps) {
   return `${cabaneCommand(deps)} ${rest}`;
 }
+function mayNeedUpdate(deps) {
+  return `This companion may need an update: run ${cabane("update", deps)}`;
+}
 function firstOnPath(name, path, isExecutable = executable) {
   for (const dir2 of (path ?? "").split(delimiter)) {
     if (!dir2) continue;
@@ -406,12 +249,15 @@ function safeRealpath(path) {
     return null;
   }
 }
+var INVOKED_COMMAND_ENV, VERSIONS_SEGMENT;
 var init_cabane_command = __esm({
   "src/cabane-command.ts"() {
     "use strict";
-    init_bundled_binaries();
+    init_install_kind();
     init_cli_entry();
     init_term();
+    INVOKED_COMMAND_ENV = "CABANE_INVOKED_COMMAND";
+    VERSIONS_SEGMENT = `${sep2}.cabane${sep2}versions${sep2}`;
   }
 });
 
@@ -641,7 +487,7 @@ import {
   existsSync as existsSync2
 } from "fs";
 import { homedir as homedir4, userInfo } from "os";
-import { dirname as dirname2, join as join3 } from "path";
+import { dirname as dirname3, join as join3 } from "path";
 import { z as z2 } from "zod";
 function realAccountHome() {
   if (realHomeCache === void 0) {
@@ -835,7 +681,7 @@ function loadConfigTolerant() {
 }
 function saveConfig(cfg) {
   const path = configPath();
-  mkdirSync(dirname2(path), { recursive: true });
+  mkdirSync(dirname3(path), { recursive: true });
   try {
     chmodSync(cabaneDir(), 448);
   } catch {
@@ -1032,6 +878,226 @@ var init_config = __esm({
   }
 });
 
+// src/bundled-binaries.ts
+import { realpathSync as realpathSync3, statSync } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname4, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function nodeResolveSelf(specifier) {
+  const here = fileURLToPath3(import.meta.url);
+  if (typeof import.meta.resolve === "function") {
+    try {
+      return fileURLToPath3(import.meta.resolve(specifier));
+    } catch {
+    }
+  }
+  try {
+    return createRequire(here).resolve(specifier);
+  } catch {
+  }
+  return walkNodeModules(specifier, here);
+}
+function walkNodeModules(pkg2, fromPath) {
+  let dir2 = dirname4(fromPath);
+  for (; ; ) {
+    const manifest = join4(dir2, "node_modules", pkg2, "package.json");
+    if (nodeIsFile(manifest)) {
+      try {
+        return realpathSync3(manifest);
+      } catch {
+        return manifest;
+      }
+    }
+    const parent = dirname4(dir2);
+    if (parent === dir2) return null;
+    dir2 = parent;
+  }
+}
+function nodeResolve(specifier, fromPath) {
+  try {
+    return createRequire(fromPath).resolve(specifier);
+  } catch {
+    return null;
+  }
+}
+function nodeIsFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function detectPreferMusl(platform = process.platform) {
+  if (platform !== "linux") return false;
+  const report = typeof process.report?.getReport === "function" ? process.report.getReport() : null;
+  const header = report?.header;
+  return report != null && header?.glibcVersionRuntime === void 0;
+}
+function defaultResolveEnv() {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    preferMusl: detectPreferMusl(),
+    // Both resolutions start from this module, which tsup bundles into
+    // `dist/cli.js` and `dist/postinstall.js` — both at the package's `dist/`
+    // root — so one environment serves the runtime checks and the install
+    // verifier alike.
+    resolveSelf: nodeResolveSelf,
+    resolve: nodeResolve,
+    isFile: nodeIsFile
+  };
+}
+function claudePlatformPackages(platform, arch, preferMusl) {
+  if (platform === "android") return [`${CLAUDE_SDK}-linux-${arch}-android`];
+  if (platform === "linux") {
+    return preferMusl ? [`${CLAUDE_SDK}-linux-${arch}-musl`, `${CLAUDE_SDK}-linux-${arch}`] : [`${CLAUDE_SDK}-linux-${arch}`, `${CLAUDE_SDK}-linux-${arch}-musl`];
+  }
+  return [`${CLAUDE_SDK}-${platform}-${arch}`];
+}
+function resolveClaude(env) {
+  const candidates = claudePlatformPackages(env.platform, env.arch, env.preferMusl);
+  const base = {
+    runtime: "claude-code",
+    packageName: candidates[0] ?? null,
+    platform: env.platform,
+    arch: env.arch
+  };
+  const sdkEntry = env.resolveSelf(CLAUDE_SDK);
+  if (!sdkEntry) return { ...base, status: "platform_package_missing", path: null };
+  let sawPackage = null;
+  for (const pkg2 of candidates) {
+    const manifest = env.resolve(`${pkg2}/package.json`, sdkEntry);
+    if (!manifest) continue;
+    sawPackage ??= pkg2;
+    const exe = join4(dirname4(manifest), env.platform === "win32" ? "claude.exe" : "claude");
+    if (env.isFile(exe)) {
+      return { ...base, packageName: pkg2, status: "present", path: exe };
+    }
+  }
+  return sawPackage ? { ...base, packageName: sawPackage, status: "executable_missing", path: null } : { ...base, status: "platform_package_missing", path: null };
+}
+function codexTargetTriple(platform, arch) {
+  if (platform === "linux" || platform === "android") {
+    if (arch === "x64") return "x86_64-unknown-linux-musl";
+    if (arch === "arm64") return "aarch64-unknown-linux-musl";
+    return null;
+  }
+  if (platform === "darwin") {
+    if (arch === "x64") return "x86_64-apple-darwin";
+    if (arch === "arm64") return "aarch64-apple-darwin";
+    return null;
+  }
+  if (platform === "win32") {
+    if (arch === "x64") return "x86_64-pc-windows-msvc";
+    if (arch === "arm64") return "aarch64-pc-windows-msvc";
+    return null;
+  }
+  return null;
+}
+function codexPlatformPackage(platform, arch) {
+  const triple = codexTargetTriple(platform, arch);
+  return triple ? CODEX_PACKAGE_BY_TRIPLE[triple] ?? null : null;
+}
+function resolveCodex(env) {
+  const triple = codexTargetTriple(env.platform, env.arch);
+  const pkg2 = triple ? CODEX_PACKAGE_BY_TRIPLE[triple] : void 0;
+  const base = {
+    runtime: "codex",
+    packageName: pkg2 ?? null,
+    platform: env.platform,
+    arch: env.arch
+  };
+  if (!triple || !pkg2) return { ...base, status: "platform_package_missing", path: null };
+  const sdkEntry = env.resolveSelf(CODEX_SDK);
+  if (!sdkEntry) return { ...base, status: "platform_package_missing", path: null };
+  const cliManifest = env.resolve(`${CODEX_CLI}/package.json`, sdkEntry);
+  if (!cliManifest) return { ...base, status: "platform_package_missing", path: null };
+  const platformManifest = env.resolve(`${pkg2}/package.json`, cliManifest);
+  if (!platformManifest) return { ...base, status: "platform_package_missing", path: null };
+  const packageRoot = join4(dirname4(platformManifest), "vendor", triple);
+  const exeName = env.platform === "win32" ? "codex.exe" : "codex";
+  const current = join4(packageRoot, "bin", exeName);
+  if (env.isFile(current) && env.isFile(join4(packageRoot, "codex-package.json"))) {
+    return { ...base, status: "present", path: current };
+  }
+  const legacy = join4(packageRoot, "codex", exeName);
+  if (env.isFile(legacy)) return { ...base, status: "present", path: legacy };
+  return { ...base, status: "executable_missing", path: null };
+}
+function resolveBundledBinary(runtime, env = defaultResolveEnv()) {
+  try {
+    return runtime === "codex" ? resolveCodex(env) : resolveClaude(env);
+  } catch {
+    return {
+      runtime,
+      status: "platform_package_missing",
+      path: null,
+      packageName: null,
+      platform: env.platform,
+      arch: env.arch
+    };
+  }
+}
+function missingNoun(status2) {
+  return status2 === "executable_missing" ? "executable" : "platform package";
+}
+function repairCommands(route = repairRoute(), spell = cabane) {
+  if (route === "managed") return [spell("stop"), spell("update")];
+  if (route === "script") return [spell("stop"), INSTALL_SCRIPT_COMMAND];
+  return ["npm i -g @cabane/companion --include=optional"];
+}
+function repairAction(route = repairRoute(), spell = cabane) {
+  const [first, ...rest] = repairCommands(route, spell);
+  if (rest.length === 0) return `Reinstall with \`${first}\`.`;
+  return `Run \`${first}\`, then \`${rest.join("`, then `")}\`. ${STOP_WARNING}`;
+}
+function repairSteps(route = repairRoute()) {
+  return repairCommands(route).join(", then ");
+}
+function repairCost(route = repairRoute()) {
+  return repairCommands(route).length > 1 ? STOP_WARNING : "";
+}
+function startupWarning(r) {
+  const label = HARNESS_LABEL[r.runtime];
+  return `${label} is ${HARNESS_INTENT_WORD[r.runtime]}, but its installation is incomplete (${missingNoun(r.status)} is missing). It cannot run turns until repaired. ${repairAction()} Then restart the companion.`;
+}
+function harnessIssueNote(runtime, status2, route = repairRoute(), spell = cabane) {
+  const intent = HARNESS_INTENT_WORD[runtime];
+  const capitalized = `${intent[0].toUpperCase()}${intent.slice(1)}`;
+  return `${capitalized}, but @cabane/companion's bundled ${HARNESS_LABEL[runtime]} ${missingNoun(status2)} is missing. ${repairAction(route, spell)} Then restart the companion.`;
+}
+function turnIncompleteCopy(runtime) {
+  return `**This device's ${HARNESS_LABEL[runtime]} runtime is incomplete.** ${repairAction()} Restart it, then try again.`;
+}
+var CLAUDE_SDK, CODEX_SDK, CODEX_CLI, CODEX_PACKAGE_BY_TRIPLE, HARNESS_LABEL, HARNESS_INTENT_WORD, STOP_WARNING;
+var init_bundled_binaries = __esm({
+  "src/bundled-binaries.ts"() {
+    "use strict";
+    init_cabane_command();
+    init_install_kind();
+    CLAUDE_SDK = "@anthropic-ai/claude-agent-sdk";
+    CODEX_SDK = "@openai/codex-sdk";
+    CODEX_CLI = "@openai/codex";
+    CODEX_PACKAGE_BY_TRIPLE = {
+      "x86_64-unknown-linux-musl": `${CODEX_CLI}-linux-x64`,
+      "aarch64-unknown-linux-musl": `${CODEX_CLI}-linux-arm64`,
+      "x86_64-apple-darwin": `${CODEX_CLI}-darwin-x64`,
+      "aarch64-apple-darwin": `${CODEX_CLI}-darwin-arm64`,
+      "x86_64-pc-windows-msvc": `${CODEX_CLI}-win32-x64`,
+      "aarch64-pc-windows-msvc": `${CODEX_CLI}-win32-arm64`
+    };
+    HARNESS_LABEL = {
+      "claude-code": "Claude Code",
+      codex: "Codex"
+    };
+    HARNESS_INTENT_WORD = {
+      "claude-code": "connected",
+      codex: "enabled"
+    };
+    STOP_WARNING = "Stopping ends any turn in progress.";
+  }
+});
+
 // packages/agent-runtime/src/failure.ts
 import { z as z4 } from "zod";
 function encodeFailureReason(failure) {
@@ -1302,6 +1368,7 @@ var init_api = __esm({
   "src/api.ts"() {
     "use strict";
     init_api_error_shape();
+    init_cabane_command();
     init_errors();
     DEVICE_HEADER = "x-cabane-device";
     RETRY_BACKOFF_MS = [250, 750];
@@ -1436,7 +1503,7 @@ var init_api = __esm({
                 }
                 this.opts.log?.warn(
                   { kind: entry.kind, turnId: entry.turnId, seq: entry.seq, ...apiErrorLogFields(err) },
-                  "Cabane rejected a saved update; it could not be delivered. This companion may need an update: npm i -g @cabane/companion@latest"
+                  `Cabane rejected a saved update; it could not be delivered. ${mayNeedUpdate()}`
                 );
                 outbox.remove(entry.turnId, entry.seq);
                 progressed = true;
@@ -7503,10 +7570,10 @@ var init_turn_containment = __esm({
 
 // src/secrets.ts
 import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { z as z14 } from "zod";
 function secretsPath() {
-  return join12(cabaneDir(), "secrets.json");
+  return join13(cabaneDir(), "secrets.json");
 }
 function loadSecretStore() {
   const path = secretsPath();
@@ -8556,10 +8623,10 @@ var init_build_options = __esm({
 // src/codex-instructions.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function writeCodexInstructionsFile(contents) {
-  const dir2 = await mkdtemp(join13(tmpdir(), PREFIX));
-  const path = join13(dir2, "instructions.md");
+  const dir2 = await mkdtemp(join14(tmpdir(), PREFIX));
+  const path = join14(dir2, "instructions.md");
   await writeFile(path, contents, { encoding: "utf8", mode: 384 });
   return {
     path,
@@ -8579,13 +8646,13 @@ var init_codex_instructions = __esm({
 // src/codex-images.ts
 import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function createCodexImagePreparer(opts) {
   const doFetch = opts.fetch ?? fetch;
   const timeoutMs = opts.timeoutMs ?? FETCH_TIMEOUT_MS;
   return async (urls, signal) => {
     signal.throwIfAborted();
-    const dir2 = await mkdtemp2(join14(tmpdir2(), `cabane-codex-images-${opts.turnId}-`));
+    const dir2 = await mkdtemp2(join15(tmpdir2(), `cabane-codex-images-${opts.turnId}-`));
     const cleanup = async () => {
       try {
         await rm2(dir2, { recursive: true, force: true });
@@ -8606,7 +8673,7 @@ function createCodexImagePreparer(opts) {
         const ext = EXTENSIONS[type];
         if (!ext) throw new Error(`not a vision image type: ${type || "none"}`);
         const bytes = new Uint8Array(await res.arrayBuffer());
-        const path = join14(dir2, `image-${index + 1}.${ext}`);
+        const path = join15(dir2, `image-${index + 1}.${ext}`);
         await writeFile2(path, bytes, { mode: 384 });
         return path;
       } catch (err) {
@@ -8752,15 +8819,15 @@ var init_prepare_failure = __esm({
 
 // src/prepared.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync7, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync9 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function dirFor(workspaceId) {
-  return join15(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
+  return join16(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
 }
 function conversationDir(workspaceId, conversationId) {
-  return join15(dirFor(workspaceId), encodeURIComponent(conversationId));
+  return join16(dirFor(workspaceId), encodeURIComponent(conversationId));
 }
 function pathFor2(workspaceId, conversationId, agentId) {
-  return join15(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
+  return join16(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
 }
 function readPrepared(workspaceId, conversationId, agentId) {
   const path = pathFor2(workspaceId, conversationId, agentId);
@@ -8798,9 +8865,9 @@ var init_prepared = __esm({
 
 // src/transcript-writer.ts
 import { appendFileSync, chmodSync as chmodSync4, copyFileSync, mkdirSync as mkdirSync8, readdirSync, rmSync as rmSync6 } from "fs";
-import { basename, dirname as dirname6, join as join16 } from "path";
+import { basename as basename2, dirname as dirname8, join as join17 } from "path";
 function transcriptsDir() {
-  return join16(runnerStateDir(), "transcripts");
+  return join17(runnerStateDir(), "transcripts");
 }
 function fileName(meta) {
   const d = new Date(meta.ts);
@@ -8826,7 +8893,7 @@ function pruneOld(dir2, retain) {
   const drop = files.sort().slice(0, files.length - retain);
   for (const f of drop) {
     try {
-      rmSync6(join16(dir2, f), { force: true });
+      rmSync6(join17(dir2, f), { force: true });
     } catch {
     }
   }
@@ -8844,7 +8911,7 @@ var init_transcript_writer = __esm({
       onWarn;
       constructor(dir2, meta, onWarn) {
         this.onWarn = onWarn;
-        this.path = join16(dir2, fileName(meta));
+        this.path = join17(dir2, fileName(meta));
         try {
           mkdirSync8(dir2, { recursive: true });
           try {
@@ -8873,10 +8940,10 @@ var init_transcript_writer = __esm({
       preserveAnomaly() {
         if (this.broken) return;
         try {
-          const dir2 = join16(dirname6(this.path), "anomalies");
+          const dir2 = join17(dirname8(this.path), "anomalies");
           mkdirSync8(dir2, { recursive: true, mode: 448 });
           chmodSync4(dir2, 448);
-          const target = join16(dir2, basename(this.path));
+          const target = join17(dir2, basename2(this.path));
           copyFileSync(this.path, target);
           chmodSync4(target, 384);
           pruneOld(dir2, ANOMALY_RETAIN);
@@ -8906,6 +8973,7 @@ var TurnCommitter;
 var init_turn_committer = __esm({
   "src/turn-committer.ts"() {
     "use strict";
+    init_cabane_command();
     init_src();
     init_api_error_shape();
     TurnCommitter = class {
@@ -8915,7 +8983,7 @@ var init_turn_committer = __esm({
         this.onError = (err, hook) => {
           deps.log.warn(
             { ...apiErrorLogFields(err), hook },
-            `Couldn't save ${String(deps.log.bindings().agentName ?? "the agent")}'s ${hook === "text" ? "reply" : "reply or activity"} to Cabane. This companion may need an update: npm i -g @cabane/companion@latest`
+            `Couldn't save ${String(deps.log.bindings().agentName ?? "the agent")}'s ${hook === "text" ? "reply" : "reply or activity"} to Cabane. ${mayNeedUpdate()}`
           );
           deps.onCommitFailed?.(err);
         };
@@ -9057,7 +9125,7 @@ async function postIncompleteNotice(ctx2, harness, resolution) {
   } catch (err) {
     ctx2.log.warn(
       { ...apiErrorLogFields(err) },
-      "Couldn't save the explanation to Cabane. This companion may need an update: npm i -g @cabane/companion@latest"
+      `Couldn't save the explanation to Cabane. ${mayNeedUpdate()}`
     );
     return false;
   }
@@ -9119,6 +9187,7 @@ var init_turn_runtime_integrity = __esm({
   "src/turn-runtime-integrity.ts"() {
     "use strict";
     init_api_error_shape();
+    init_cabane_command();
     init_bundled_binaries();
   }
 });
@@ -9167,6 +9236,7 @@ var init_turn_execution = __esm({
   "src/turn-execution.ts"() {
     "use strict";
     init_term();
+    init_cabane_command();
     init_boot_id();
     init_src();
     init_build_options();
@@ -9405,7 +9475,7 @@ var init_turn_execution = __esm({
           } else {
             turnLog.warn(
               { ...apiErrorLogFields(err), turnId },
-              "Couldn't save the turn's result to Cabane. This companion may need an update: npm i -g @cabane/companion@latest"
+              `Couldn't save the turn's result to Cabane. ${mayNeedUpdate()}`
             );
           }
         }
@@ -9883,7 +9953,7 @@ var init_turn_execution = __esm({
           } catch (postErr) {
             turnLog.warn(
               { ...apiErrorLogFields(postErr) },
-              "Couldn't save the explanation to Cabane. This companion may need an update: npm i -g @cabane/companion@latest"
+              `Couldn't save the explanation to Cabane. ${mayNeedUpdate()}`
             );
             const reason = `runtime_unavailable:${err.runtime}`;
             throw this.concluded(reason, reason);
@@ -10092,7 +10162,7 @@ var init_turn_execution = __esm({
                         stateLength: event.state.length,
                         runtime: turnRuntime
                       },
-                      "Couldn't save the agent's memory in Cabane. The next turn will start a new session. This companion may need an update: npm i -g @cabane/companion@latest"
+                      `Couldn't save the agent's memory in Cabane. The next turn will start a new session. ${mayNeedUpdate()}`
                     );
                   } else {
                     turnLog.warn(
@@ -10256,7 +10326,7 @@ var init_turn_execution = __esm({
             } else {
               turnLog.warn(
                 { ...apiErrorLogFields(err) },
-                "Couldn't save the turn's result to Cabane. This companion may need an update: npm i -g @cabane/companion@latest"
+                `Couldn't save the turn's result to Cabane. ${mayNeedUpdate()}`
               );
             }
           }
@@ -10310,7 +10380,7 @@ var init_turn_execution = __esm({
 // src/dispatcher.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { existsSync as existsSync11, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 function checkoutState(cwd) {
   if (!cwd) return { ok: false, reason: "no working directory was resolved for this turn" };
   if (!existsSync11(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
@@ -10323,7 +10393,7 @@ function checkoutState(cwd) {
   if (entries.length === 0) {
     return { ok: false, reason: `${cwd} is empty \u2014 a recreated shell, not a prepared directory` };
   }
-  const gitPath = join17(cwd, ".git");
+  const gitPath = join18(cwd, ".git");
   if (!existsSync11(gitPath)) return { ok: true, reason: "usable" };
   let stat;
   try {
@@ -10331,7 +10401,7 @@ function checkoutState(cwd) {
   } catch (error) {
     return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
   }
-  if (stat.isDirectory() && !existsSync11(join17(gitPath, "HEAD")))
+  if (stat.isDirectory() && !existsSync11(join18(gitPath, "HEAD")))
     return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
   return { ok: true, reason: "usable" };
 }
@@ -10703,15 +10773,15 @@ import {
   mkdirSync as mkdirSync11,
   mkdtempSync,
   readFileSync as readFileSync10,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   rmSync as rmSync10,
   writeFileSync as writeFileSync7
 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { isIP } from "net";
 import { homedir as homedir6, networkInterfaces, tmpdir as tmpdir4, userInfo as userInfo2 } from "os";
-import { dirname as dirname8, join as join21, sep as sep4 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { dirname as dirname10, join as join22, sep as sep4 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
 import { SandboxManager } from "@anthropic-ai/sandbox-runtime";
 function accountHome() {
   try {
@@ -10742,23 +10812,23 @@ async function resolvedAddresses(baseUrl) {
   }
 }
 function companionPackageRoot(modulePath) {
-  for (let dir2 = dirname8(modulePath); ; dir2 = dirname8(dir2)) {
+  for (let dir2 = dirname10(modulePath); ; dir2 = dirname10(dir2)) {
     try {
-      const manifest = JSON.parse(readFileSync10(join21(dir2, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync10(join22(dir2, "package.json"), "utf8"));
       if (manifest.name === "@cabane/companion") return dir2;
     } catch {
     }
-    if (dirname8(dir2) === dir2) return null;
+    if (dirname10(dir2) === dir2) return null;
   }
 }
 function harnessRuntimePaths() {
-  const paths = [dirname8(dirname8(process.execPath))];
-  const root = companionPackageRoot(fileURLToPath5(import.meta.url));
+  const paths = [dirname10(dirname10(process.execPath))];
+  const root = companionPackageRoot(fileURLToPath6(import.meta.url));
   if (root) paths.push(root);
   try {
     const require2 = createRequire2(import.meta.url);
     paths.push(
-      dirname8(realpathSync4(require2.resolve("@anthropic-ai/sandbox-runtime/package.json")))
+      dirname10(realpathSync5(require2.resolve("@anthropic-ai/sandbox-runtime/package.json")))
     );
   } catch {
   }
@@ -10766,7 +10836,7 @@ function harnessRuntimePaths() {
     const bundled = resolveBundledBinary(runtime).path;
     if (bundled) {
       try {
-        paths.push(dirname8(realpathSync4(bundled)));
+        paths.push(dirname10(realpathSync5(bundled)));
       } catch {
       }
     }
@@ -10777,9 +10847,9 @@ function ownAddresses() {
   return Object.values(networkInterfaces()).flat().flatMap((i) => i ? [i.address] : []);
 }
 function storeWalkRoots(homes, cabaneDir2) {
-  const companionHome = dirname8(cabaneDir2);
-  const parent = dirname8(companionHome);
-  const beside = homes.includes(companionHome) || dirname8(parent) === parent ? [] : [parent];
+  const companionHome = dirname10(cabaneDir2);
+  const parent = dirname10(companionHome);
+  const beside = homes.includes(companionHome) || dirname10(parent) === parent ? [] : [parent];
   const candidates = [.../* @__PURE__ */ new Set([...homes, ...beside])];
   return candidates.filter(
     (root) => !candidates.some((other) => other !== root && isAtOrUnder(root, other))
@@ -10817,19 +10887,19 @@ async function walkCompanionStores(roots, opts = {}) {
 }
 function companionStoreDenies(input) {
   const { homes, cabaneDir: cabaneDir2, foundStores } = input;
-  const parent = dirname8(dirname8(cabaneDir2));
+  const parent = dirname10(dirname10(cabaneDir2));
   const always = [
     cabaneDir2,
     ...homes.flatMap((home) => [
-      join21(home, ".cabane"),
-      join21(home, "*", ".cabane"),
-      join21(home, "*", "*", ".cabane")
+      join22(home, ".cabane"),
+      join22(home, "*", ".cabane"),
+      join22(home, "*", "*", ".cabane")
     ]),
     // A glob anchored at the root has no directory to start from.
-    ...dirname8(parent) === parent ? [] : [join21(parent, "*", ".cabane")]
+    ...dirname10(parent) === parent ? [] : [join22(parent, "*", ".cabane")]
   ];
-  const companionHome = dirname8(cabaneDir2);
-  const otherLogins = foundStores.map((store) => dirname8(store)).filter((home) => home !== companionHome).flatMap((home) => [join21(home, ".claude"), join21(home, ".codex")]).filter((path) => !input.ownState.some((own) => isAtOrUnder(own, path)));
+  const companionHome = dirname10(cabaneDir2);
+  const otherLogins = foundStores.map((store) => dirname10(store)).filter((home) => home !== companionHome).flatMap((home) => [join22(home, ".claude"), join22(home, ".codex")]).filter((path) => !input.ownState.some((own) => isAtOrUnder(own, path)));
   return [.../* @__PURE__ */ new Set([...always, ...foundStores, ...otherLogins])];
 }
 function companionStoreWatch(log) {
@@ -10846,7 +10916,7 @@ function isAtOrUnder(path, dir2) {
 }
 function expandHome(path, home) {
   if (path === "~") return home;
-  return path.startsWith("~/") ? join21(home, path.slice(2)) : path;
+  return path.startsWith("~/") ? join22(home, path.slice(2)) : path;
 }
 function stripPort(pattern) {
   return pattern.startsWith("[") ? pattern.replace(/^\[([^\]]+)\](:\d+)?$/, "$1") : pattern.replace(/:\d+$/, "");
@@ -10864,8 +10934,8 @@ function patternsOverlap(a, b) {
 }
 function harnessSandboxConfig(input) {
   const { policy } = input;
-  const claudeDir = input.claudeConfigDir ?? join21(input.home, ".claude");
-  const codexDir = input.codexHome ?? join21(input.home, ".codex");
+  const claudeDir = input.claudeConfigDir ?? join22(input.home, ".claude");
+  const codexDir = input.codexHome ?? join22(input.home, ".codex");
   const homes = [.../* @__PURE__ */ new Set([input.home, input.accountHome ?? input.home])];
   const expand = (paths) => (paths ?? []).map((p) => expandHome(p, input.home));
   const cabane2 = cabaneHostEntries(input.baseUrl, input.resolved, input.ownAddresses);
@@ -10882,7 +10952,7 @@ function harnessSandboxConfig(input) {
       foundStores: input.foundStores,
       ownState: [claudeDir, codexDir]
     }),
-    ...homes.flatMap((home) => SECRET_PATHS_UNDER_HOME.map((p) => join21(home, p))),
+    ...homes.flatMap((home) => SECRET_PATHS_UNDER_HOME.map((p) => join22(home, p))),
     ...expand(policy.filesystem?.denyRead)
   ];
   const strict = policy.filesystem?.mode === "strict";
@@ -10890,7 +10960,7 @@ function harnessSandboxConfig(input) {
   const allowRead = strict ? [
     ...input.cwd ? [input.cwd] : [],
     claudeDir,
-    join21(input.home, ".claude.json"),
+    join22(input.home, ".claude.json"),
     codexDir,
     ...input.runtimePaths ?? [],
     ...expand(policy.filesystem?.allowRead)
@@ -10930,7 +11000,7 @@ function harnessSandboxConfig(input) {
         ...input.cwd ? [input.cwd] : [],
         input.tmp,
         claudeDir,
-        join21(input.home, ".claude.json"),
+        join22(input.home, ".claude.json"),
         codexDir,
         ...expand(policy.filesystem?.allowWrite)
       ],
@@ -11032,9 +11102,9 @@ async function prepareHarnessSandbox(input) {
   } finally {
     for (const name of held) delete process.env[name];
   }
-  mkdirSync11(join21(cabaneDir(), "sandbox"), { recursive: true });
-  const dir2 = mkdtempSync(join21(cabaneDir(), "sandbox", "turn-"));
-  const script = join21(dir2, "exec-sandboxed");
+  mkdirSync11(join22(cabaneDir(), "sandbox"), { recursive: true });
+  const dir2 = mkdtempSync(join22(cabaneDir(), "sandbox", "turn-"));
+  const script = join22(dir2, "exec-sandboxed");
   writeFileSync7(
     script,
     [
@@ -11050,7 +11120,7 @@ async function prepareHarnessSandbox(input) {
   return {
     wrap: (command, args) => ({ command: script, args: [command, ...args] }),
     executableFor: (real) => {
-      const shim = join21(dir2, `exec-${++shims}`);
+      const shim = join22(dir2, `exec-${++shims}`);
       writeFileSync7(shim, `#!/bin/bash
 exec ${shellQuote(script)} ${shellQuote(real)} "$@"
 `);
@@ -11143,7 +11213,7 @@ import {
   rmSync as rmSync11,
   writeFileSync as writeFileSync8
 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var MAX_ENTRIES, MAX_AGE_MS, Outbox;
 var init_outbox = __esm({
   "src/outbox.ts"() {
@@ -11161,10 +11231,10 @@ var init_outbox = __esm({
       // Resolved lazily (per call) so tests that swap HOME between
       // cases route writes at the right tmpdir.
       dir() {
-        return join22(runnerStateDir(), "outbox", encodeURIComponent(this.workspaceId));
+        return join23(runnerStateDir(), "outbox", encodeURIComponent(this.workspaceId));
       }
       fileFor(turnId, seq) {
-        return join22(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+        return join23(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
@@ -11206,7 +11276,7 @@ var init_outbox = __esm({
         const entries = [];
         for (const name of names) {
           if (!name.endsWith(".json")) continue;
-          const full = join22(dir2, name);
+          const full = join23(dir2, name);
           try {
             const parsed = JSON.parse(readFileSync11(full, "utf8"));
             if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
@@ -11346,7 +11416,7 @@ var init_image_manifest = __esm({
 
 // src/runner/exec-shim.ts
 import { chmodSync as chmodSync8, mkdirSync as mkdirSync20, mkdtempSync as mkdtempSync2, rmSync as rmSync17, writeFileSync as writeFileSync13 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 function shellQuote2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -11356,10 +11426,10 @@ function createShimDir() {
   return {
     write(argv) {
       if (!dir2) {
-        mkdirSync20(join31(cabaneDir(), "runner"), { recursive: true });
-        dir2 = mkdtempSync2(join31(cabaneDir(), "runner", "turn-"));
+        mkdirSync20(join32(cabaneDir(), "runner"), { recursive: true });
+        dir2 = mkdtempSync2(join32(cabaneDir(), "runner", "turn-"));
       }
-      const path = join31(dir2, `exec-${++count}`);
+      const path = join32(dir2, `exec-${++count}`);
       writeFileSync13(path, `#!/bin/sh
 exec ${argv.map(shellQuote2).join(" ")} "$@"
 `);
@@ -11716,13 +11786,13 @@ init_config();
 import { createHash } from "crypto";
 import { chmodSync as chmodSync2, existsSync as existsSync3, rmSync as rmSync2, mkdirSync as mkdirSync2 } from "fs";
 import { createServer, connect } from "net";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/harness-copy.ts
 init_bundled_binaries();
 init_cabane_command();
 import { homedir as homedir5 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/harness-status.ts
 init_bundled_binaries();
@@ -11883,7 +11953,12 @@ function runtimeIssuesFor(gates) {
   for (const name of ["claude-code", "codex"]) {
     const gate = name === "codex" ? gates.codex : gates.claudeCode;
     if (!gate.intended || gate.bundled === "present") continue;
-    issues.push({ name, reason: gate.bundled, install: gates.install });
+    issues.push({
+      name,
+      reason: gate.bundled,
+      install: gates.install,
+      ...gates.managed ? { managed: true } : {}
+    });
   }
   return issues;
 }
@@ -12152,16 +12227,16 @@ function failureText(runtime, reason) {
     case "timeout":
       return `Couldn't check whether ${label} is signed in: the check didn't answer in time. Try again.`;
     case "spawn":
-      return `Couldn't check whether ${label} is signed in: Cabane's bundled ${label} wouldn't start. Repair it with  ${repairCommands()[0]}  , then try again.`;
+      return `Couldn't check whether ${label} is signed in: Cabane's bundled ${label} wouldn't start. Repair it with  ${repairSteps()}  and try again.${spaced(repairCost())}`;
     case "config":
-      return `Couldn't check whether ${label} is signed in: its configuration file didn't load${runtime === "codex" ? ` (${join4(homedir5(), ".codex", "config.toml").replace(homedir5(), "~")})` : ""}. Fix it, then try again.`;
+      return `Couldn't check whether ${label} is signed in: its configuration file didn't load${runtime === "codex" ? ` (${join5(homedir5(), ".codex", "config.toml").replace(homedir5(), "~")})` : ""}. Fix it, then try again.`;
     case "unreadable":
       return `Couldn't check whether ${label} is signed in: it answered in a way Cabane couldn't read. Try again, and if it keeps happening, update Cabane.`;
   }
 }
 function bundleMissingText(runtime) {
   const label = HARNESS_LABELS[runtime];
-  return `This Cabane install is missing its bundled ${label}. Repair it with  ${repairCommands()[0]}  , then try again.`;
+  return `This Cabane install is missing its bundled ${label}. Repair it with  ${repairSteps()}  and try again.${spaced(repairCost())}`;
 }
 function unusableReason(runtime, check) {
   if (check.status === "bundle_missing") return bundleMissingText(runtime);
@@ -12235,6 +12310,9 @@ function connectLines(outcome, opts = {}) {
     ]
   };
 }
+function spaced(sentence) {
+  return sentence ? ` ${sentence}` : "";
+}
 
 // src/control-socket.ts
 var CONTROL_TIMEOUT_MS = 1e3;
@@ -12245,11 +12323,11 @@ function controlSocketPath() {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\cabane-companion-${key}`;
   }
-  const besideRuntime = join5(dir2, "companion.sock");
+  const besideRuntime = join6(dir2, "companion.sock");
   if (Buffer.byteLength(besideRuntime) <= MAX_UNIX_SOCKET_PATH_BYTES) return besideRuntime;
   const filename = `cabane-companion-${key}.sock`;
-  const xdgPath = process.env.XDG_RUNTIME_DIR && existsSync3(process.env.XDG_RUNTIME_DIR) ? join5(process.env.XDG_RUNTIME_DIR, filename) : null;
-  return xdgPath && Buffer.byteLength(xdgPath) <= MAX_UNIX_SOCKET_PATH_BYTES ? xdgPath : join5("/tmp", filename);
+  const xdgPath = process.env.XDG_RUNTIME_DIR && existsSync3(process.env.XDG_RUNTIME_DIR) ? join6(process.env.XDG_RUNTIME_DIR, filename) : null;
+  return xdgPath && Buffer.byteLength(xdgPath) <= MAX_UNIX_SOCKET_PATH_BYTES ? xdgPath : join6("/tmp", filename);
 }
 async function startControlServer(handlers) {
   const path = controlSocketPath();
@@ -12424,10 +12502,10 @@ import {
   openSync,
   closeSync
 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var PROBE_TIMEOUT_MS2 = 1e3;
 function runtimePath() {
-  return join6(cabaneDir(), "runtime.json");
+  return join7(cabaneDir(), "runtime.json");
 }
 function serialize(state) {
   return JSON.stringify(state, null, 2) + "\n";
@@ -12642,10 +12720,10 @@ import {
   rmSync as rmSync4,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname5, join as join8 } from "path";
 import { z as z3 } from "zod";
 function credentialsPath() {
-  return join7(cabaneDir(), "credentials.json");
+  return join8(cabaneDir(), "credentials.json");
 }
 var credentialStoreSchema = z3.record(z3.string(), z3.string());
 function load() {
@@ -12667,7 +12745,7 @@ function load() {
 }
 function save(map) {
   const path = credentialsPath();
-  mkdirSync4(dirname3(path), { recursive: true });
+  mkdirSync4(dirname5(path), { recursive: true });
   try {
     chmodSync3(cabaneDir(), 448);
   } catch {
@@ -12962,11 +13040,11 @@ import {
   renameSync as renameSync3,
   statSync as statSync2
 } from "fs";
-import { dirname as dirname4, join as join8 } from "path";
+import { dirname as dirname6, join as join9 } from "path";
 import { stripVTControlCharacters } from "util";
 import pino from "pino";
 function companionLogPath() {
-  return join8(cabaneDir(), "companion.log");
+  return join9(cabaneDir(), "companion.log");
 }
 function humanText(value) {
   return stripVTControlCharacters(String(value ?? "")).replace(
@@ -13080,7 +13158,7 @@ function configureLogger(log, config) {
 }
 function createLogger(destinations = {}, options = {}) {
   const path = companionLogPath();
-  if (!destinations.file) mkdirSync5(dirname4(path), { recursive: true });
+  if (!destinations.file) mkdirSync5(dirname6(path), { recursive: true });
   const file = destinations.file ?? new RotatingLog(path);
   const state = { format: options.logFormat ?? "human" };
   const streams = [];
@@ -13133,15 +13211,15 @@ import { randomUUID as randomUUID7 } from "crypto";
 
 // src/dashboard/server.ts
 init_errors();
-import { dirname as dirname5, join as join10 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname7, join as join11 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 
 // src/dashboard/routes.ts
 import { openSync as openSync3, readSync, closeSync as closeSync2, fstatSync, existsSync as existsSync6 } from "fs";
 import { readFile } from "fs/promises";
-import { extname, join as join9, normalize } from "path";
+import { extname, join as join10, normalize } from "path";
 import { streamSSE } from "hono/streaming";
 
 // src/state.ts
@@ -13390,13 +13468,13 @@ var CONTENT_TYPES = {
 function registerRoutes(app, deps) {
   const { supervisor, hub, staticDir } = deps;
   app.get("/", async (c) => {
-    const html = await readFile(join9(staticDir, "index.html"), "utf8");
+    const html = await readFile(join10(staticDir, "index.html"), "utf8");
     return c.html(html);
   });
   app.get("/static/:file", async (c) => {
     const file = c.req.param("file");
     const safe2 = normalize(file).replace(/^(\.\.[/\\])+/, "");
-    const full = join9(staticDir, safe2);
+    const full = join10(staticDir, safe2);
     if (!full.startsWith(staticDir) || !existsSync6(full)) return c.notFound();
     const body = await readFile(full);
     const type = CONTENT_TYPES[extname(full).toLowerCase()] ?? "application/octet-stream";
@@ -13608,7 +13686,7 @@ function isAddrInUse(err) {
   return Boolean(err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE");
 }
 function resolveStaticDir() {
-  return join10(dirname5(fileURLToPath3(import.meta.url)), "static");
+  return join11(dirname7(fileURLToPath4(import.meta.url)), "static");
 }
 
 // src/supervisor.ts
@@ -13617,6 +13695,7 @@ import { hostname as hostname2 } from "os";
 
 // src/log-copy.ts
 init_failure();
+init_bundled_binaries();
 function turnFailureCopy(reason, runtime) {
   const failure = decodeFailureReason(reason);
   if (failure?.kind === "auth_expired") {
@@ -13635,7 +13714,7 @@ function turnFailureCopy(reason, runtime) {
   if (reason?.startsWith("missing_secret:"))
     return `A required secret is missing: ${humanText(reason.slice(15))}. Add it to ~/.cabane/secrets.json, then reply in Cabane to try again.`;
   if (reason?.startsWith("runtime_incomplete:"))
-    return "The agent installation is incomplete. Reinstall with npm i -g @cabane/companion@latest, then restart the companion.";
+    return `The agent installation is incomplete. ${repairAction()} Then restart the companion.`;
   if (/^(runtime|codex|opencode)_unavailable:/.test(reason ?? ""))
     return "The agent is unavailable on this machine. Enable it here or choose another connector in Cabane.";
   if (reason?.startsWith("model_unavailable:"))
@@ -13775,13 +13854,13 @@ init_config();
 // src/dispatch-dedupe.ts
 init_config();
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4, renameSync as renameSync4, existsSync as existsSync7 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 var MAX_IDS = 256;
 function dir(log) {
-  return join11(cabaneDir(), log);
+  return join12(cabaneDir(), log);
 }
 function pathFor(log, workspaceId) {
-  return join11(dir(log), encodeURIComponent(workspaceId));
+  return join12(dir(log), encodeURIComponent(workspaceId));
 }
 function readIds(log, workspaceId) {
   const path = pathFor(log, workspaceId);
@@ -13818,10 +13897,10 @@ function markCompleted(workspaceId, eventId) {
 }
 var MAX_RESUME_ATTEMPTS = 3;
 function resumeDir() {
-  return join11(cabaneDir(), "resume-attempts");
+  return join12(cabaneDir(), "resume-attempts");
 }
 function resumePathFor(workspaceId) {
-  return join11(resumeDir(), encodeURIComponent(workspaceId));
+  return join12(resumeDir(), encodeURIComponent(workspaceId));
 }
 function readResumeCounts(workspaceId) {
   const out = /* @__PURE__ */ new Map();
@@ -13857,10 +13936,10 @@ function bumpResumeAttempt(workspaceId, eventId) {
   return next;
 }
 function turnDir() {
-  return join11(cabaneDir(), "turns");
+  return join12(cabaneDir(), "turns");
 }
 function turnPathFor(workspaceId) {
-  return join11(turnDir(), encodeURIComponent(workspaceId));
+  return join12(turnDir(), encodeURIComponent(workspaceId));
 }
 var TURN_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function readTurnIds(workspaceId) {
@@ -13912,6 +13991,7 @@ function noResume() {
 
 // src/supervisor.ts
 init_bundled_binaries();
+init_install_kind();
 
 // src/connector-health.ts
 init_src();
@@ -14093,7 +14173,7 @@ import {
   statSync as statSync4,
   writeFileSync as writeFileSync6
 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { Writable } from "stream";
 
 // src/providers/docker-cli.ts
@@ -14166,7 +14246,7 @@ import {
   renameSync as renameSync5,
   rmSync as rmSync8
 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function routes(t) {
   const conv = `/api/workspaces/${t.workspaceId}/conversations/${t.conversationId}`;
   const agent = `${conv}/participants/agents/${t.agentId}`;
@@ -14212,7 +14292,7 @@ function publishStaged(from, to, move = atomicMove) {
   const staged = readdirSync3(from).filter((n) => n.endsWith(".json")).map((name) => {
     let entry = {};
     try {
-      entry = JSON.parse(readFileSync8(join18(from, name), "utf8"));
+      entry = JSON.parse(readFileSync8(join19(from, name), "utf8"));
     } catch {
     }
     return { name, entry };
@@ -14225,7 +14305,7 @@ function publishStaged(from, to, move = atomicMove) {
   let published = 0;
   for (const { name } of staged) {
     try {
-      move(join18(from, name), join18(to, name));
+      move(join19(from, name), join19(to, name));
     } catch {
       return { published, complete: false };
     }
@@ -14237,9 +14317,9 @@ function publishStaged(from, to, move = atomicMove) {
 
 // src/providers/runner-base.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync13, realpathSync as realpathSync3 } from "fs";
-import { dirname as dirname7, join as join19, sep as sep3 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { existsSync as existsSync13, realpathSync as realpathSync4 } from "fs";
+import { dirname as dirname9, join as join20, sep as sep3 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 var COMPANION_MOUNT = "/opt/cabane/companion";
 var BASE_DOCKERFILE = `FROM node:22-slim
 RUN apt-get update \\
@@ -14283,17 +14363,17 @@ async function ensureBaseImage(docker, image, log) {
   }
   return true;
 }
-function ownInstall(moduleFile = fileURLToPath4(import.meta.url)) {
-  let dir2 = dirname7(moduleFile);
+function ownInstall(moduleFile = fileURLToPath5(import.meta.url)) {
+  let dir2 = dirname9(moduleFile);
   for (let i = 0; i < 4; i++) {
-    if (existsSync13(join19(dir2, "dist", "cli.js")) && existsSync13(join19(dir2, "package.json"))) break;
-    dir2 = dirname7(dir2);
+    if (existsSync13(join20(dir2, "dist", "cli.js")) && existsSync13(join20(dir2, "package.json"))) break;
+    dir2 = dirname9(dir2);
   }
-  if (!existsSync13(join19(dir2, "dist", "cli.js"))) return null;
-  const sdk = join19(dir2, "node_modules", "@anthropic-ai", "claude-agent-sdk");
+  if (!existsSync13(join20(dir2, "dist", "cli.js"))) return null;
+  const sdk = join20(dir2, "node_modules", "@anthropic-ai", "claude-agent-sdk");
   if (!existsSync13(sdk)) return null;
-  const root = realpathSync3(dir2);
-  return realpathSync3(sdk).startsWith(root + sep3) ? root : null;
+  const root = realpathSync4(dir2);
+  return realpathSync4(sdk).startsWith(root + sep3) ? root : null;
 }
 function companionSource(input) {
   if (input.configured) {
@@ -14429,39 +14509,39 @@ function networkCreateError(stderr) {
 }
 function sessionArchivePath(deviceDir, attemptId) {
   if (!UUID_RE.test(attemptId)) throw new Error(`docker: not an attempt id: ${attemptId}`);
-  return join20(deviceDir, "attempts", attemptId, "session.tar");
+  return join21(deviceDir, "attempts", attemptId, "session.tar");
 }
 function pruneOtherAttempts(deviceDir, pair2, keep) {
-  const root = join20(deviceDir, "attempts");
+  const root = join21(deviceDir, "attempts");
   if (!existsSync14(root)) return;
   for (const id of readdirSync4(root)) {
     if (id === keep || !UUID_RE.test(id)) continue;
     let pairOf = "";
     try {
-      pairOf = readFileSync9(join20(root, id, "pair"), "utf8");
+      pairOf = readFileSync9(join21(root, id, "pair"), "utf8");
     } catch {
       continue;
     }
     if (pairOf === `${pair2.conversationId}/${pair2.agentId}`) {
-      rmSync9(join20(root, id), { recursive: true, force: true });
+      rmSync9(join21(root, id), { recursive: true, force: true });
     }
   }
 }
 var IDLE_SESSION_ARCHIVE_MS = 30 * 24 * 60 * 6e4;
 function pruneIdleSessionArchives(deviceDir, now = Date.now(), maxAgeMs = IDLE_SESSION_ARCHIVE_MS) {
-  const root = join20(deviceDir, "attempts");
+  const root = join21(deviceDir, "attempts");
   if (!existsSync14(root)) return [];
   const removed = [];
   for (const id of readdirSync4(root)) {
     if (!UUID_RE.test(id)) continue;
     let kept;
     try {
-      kept = statSync4(join20(root, id)).mtimeMs;
+      kept = statSync4(join21(root, id)).mtimeMs;
     } catch {
       continue;
     }
     if (now - kept < maxAgeMs) continue;
-    rmSync9(join20(root, id), { recursive: true, force: true });
+    rmSync9(join21(root, id), { recursive: true, force: true });
     removed.push(id);
   }
   return removed;
@@ -14662,11 +14742,11 @@ function createDockerProvider(opts) {
       await must(["network", "disconnect", "-f", other, name], "moving the container");
     if (others.includes(sharedNetwork)) await retireSharedNetwork();
   };
-  const socketRoot = opts.socketRoot ?? join20(
+  const socketRoot = opts.socketRoot ?? join21(
     process.env.XDG_RUNTIME_DIR && existsSync14(process.env.XDG_RUNTIME_DIR) ? process.env.XDG_RUNTIME_DIR : tmpdir3(),
     `cabane-runners-${opts.deviceKey}`
   );
-  const socketDir = (name) => join20(socketRoot, createHash4("sha256").update(name).digest("hex").slice(0, 12));
+  const socketDir = (name) => join21(socketRoot, createHash4("sha256").update(name).digest("hex").slice(0, 12));
   const create = async (name, attempt) => {
     mkdirSync10(socketRoot, { recursive: true, mode: 448 });
     mkdirSync10(socketDir(name), { recursive: true, mode: 457 });
@@ -14808,7 +14888,7 @@ function createDockerProvider(opts) {
     }
   };
   const removeIn = (name, from, names) => names.length ? execIn(name, ["sh", "-c", 'cd "$1" && shift && rm -f -- "$@"', "sh", from, ...names]) : Promise.resolve(null);
-  const pendingPath = (name) => join20(opts.deviceDir, "runners-pending", `${name}.json`);
+  const pendingPath = (name) => join21(opts.deviceDir, "runners-pending", `${name}.json`);
   const readPending = (name) => {
     try {
       const ids = JSON.parse(readFileSync9(pendingPath(name), "utf8"));
@@ -14822,12 +14902,12 @@ function createDockerProvider(opts) {
       rmSync9(pendingPath(name), { force: true });
       return;
     }
-    mkdirSync10(join20(opts.deviceDir, "runners-pending"), { recursive: true });
+    mkdirSync10(join21(opts.deviceDir, "runners-pending"), { recursive: true });
     writeFileSync6(pendingPath(name), JSON.stringify([...new Set(ids)]));
   };
   const keepSession = async (name, attempt, attemptId) => {
     const archive = sessionArchivePath(opts.deviceDir, attemptId);
-    mkdirSync10(join20(archive, ".."), { recursive: true });
+    mkdirSync10(join21(archive, ".."), { recursive: true });
     const partial = `${archive}.${process.pid}.partial`;
     const file = new CappedFile(partial, sessionCap);
     const r = await execIn(
@@ -14844,7 +14924,7 @@ function createDockerProvider(opts) {
     );
     if (r.code === 0 && !file.over) {
       renameSync6(partial, archive);
-      writeFileSync6(join20(archive, "..", "pair"), `${attempt.conversationId}/${attempt.agentId}`);
+      writeFileSync6(join21(archive, "..", "pair"), `${attempt.conversationId}/${attempt.agentId}`);
       pruneOtherAttempts(opts.deviceDir, attempt, attemptId);
       await writeMarker(name, attemptId);
       log.debug({ container: name, attemptId, bytes: file.bytes }, "runners: session files kept");
@@ -14858,7 +14938,7 @@ function createDockerProvider(opts) {
       file.over ? "runners: the session files are over the size cap and weren't kept; the next new container starts the session over" : "runners: couldn't keep the session files; the next new container starts the session over"
     );
   };
-  const stagingDir = (name) => join20(opts.deviceDir, "runners-pending", `${name}.outbox`);
+  const stagingDir = (name) => join21(opts.deviceDir, "runners-pending", `${name}.outbox`);
   const ensureRunning = async (name) => {
     const seen = await docker.run(["inspect", "-f", "{{.State.Running}}", name]);
     if (seen.code !== 0) return false;
@@ -14866,7 +14946,7 @@ function createDockerProvider(opts) {
     return (await docker.run(["start", name])).code === 0;
   };
   const dropArchive = (attemptId) => {
-    rmSync9(join20(sessionArchivePath(opts.deviceDir, attemptId), ".."), {
+    rmSync9(join21(sessionArchivePath(opts.deviceDir, attemptId), ".."), {
       recursive: true,
       force: true
     });
@@ -14935,7 +15015,7 @@ function createDockerProvider(opts) {
         if (seen.stdout.trim().split(" ")[0] !== "true")
           await must(["start", name], "starting the container");
         const git = await serveGitCredentials({
-          socketPath: join20(socketDir(name), "git.sock"),
+          socketPath: join21(socketDir(name), "git.sock"),
           hosts: opts.gitHosts,
           fill: opts.gitFill,
           log
@@ -15084,15 +15164,15 @@ function createDockerProvider(opts) {
       const transcripts = await readDir(name, `${CONTAINER_STATE}/transcripts`);
       if (transcripts) {
         const kept = transcripts.files.filter((f) => SAFE_NAME_RE.test(f.name));
-        if (kept.length) mkdirSync10(join20(opts.hostStateDir, "transcripts"), { recursive: true });
-        for (const f of kept) writeFileSync6(join20(opts.hostStateDir, "transcripts", f.name), f.data);
+        if (kept.length) mkdirSync10(join21(opts.hostStateDir, "transcripts"), { recursive: true });
+        for (const f of kept) writeFileSync6(join21(opts.hostStateDir, "transcripts", f.name), f.data);
         await removeIn(
           name,
           `${CONTAINER_STATE}/transcripts`,
           kept.map((f) => f.name)
         );
       }
-      const outboxRel = join20("outbox", encodeURIComponent(attempt.agentId));
+      const outboxRel = join21("outbox", encodeURIComponent(attempt.agentId));
       const outbox = await readDir(name, `${CONTAINER_STATE}/${outboxRel}`);
       let unpublished = false;
       if (outbox) {
@@ -15118,7 +15198,7 @@ function createDockerProvider(opts) {
           const staged = stagingDir(name);
           mkdirSync10(staged, { recursive: true });
           writeFileSync6(
-            join20(staged, `${encodeURIComponent(entry.turnId)}__${entry.seq}.json`),
+            join21(staged, `${encodeURIComponent(entry.turnId)}__${entry.seq}.json`),
             `${JSON.stringify(entry)}
 `
           );
@@ -15131,7 +15211,7 @@ function createDockerProvider(opts) {
         if (outbox.complete) {
           const published = publishStaged(
             stagingDir(name),
-            join20(opts.hostStateDir, outboxRel),
+            join21(opts.hostStateDir, outboxRel),
             opts.moveFile
           );
           queued = published.published;
@@ -15433,6 +15513,8 @@ var SseSubscriber = class {
   opts;
   aborted = false;
   controller = null;
+  // Ends the reconnect backoff early, so a stop never waits out a sleep of up to 30 s.
+  wake = null;
   lastEventId;
   // Set after `start()`; resolved when the subscriber loop exits (either
   // because `stop()` was called or because an auth failure tore it down).
@@ -15443,12 +15525,7 @@ var SseSubscriber = class {
   stop() {
     this.aborted = true;
     this.controller?.abort();
-  }
-  // Connect again after a `stop()`, once its loop has exited.
-  async resume() {
-    await this.finished;
-    this.aborted = false;
-    this.start();
+    this.wake?.();
   }
   setCursor(eventId) {
     this.lastEventId = eventId;
@@ -15461,7 +15538,7 @@ var SseSubscriber = class {
         backoff = 500;
         if (!this.aborted) {
           this.opts.log.warn("Lost the connection to Cabane; reconnecting");
-          await sleep4(backoff);
+          await this.backoff(backoff);
         }
       } catch (err) {
         if (this.aborted) return;
@@ -15481,11 +15558,21 @@ var SseSubscriber = class {
           },
           "Lost the connection to Cabane; reconnecting"
         );
-        await sleep4(backoff);
+        await this.backoff(backoff);
         backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
       }
     }
   }
+  backoff(ms) {
+    return new Promise((resolve2) => {
+      const timer = setTimeout(done, ms);
+      this.wake = done;
+      function done() {
+        clearTimeout(timer);
+        resolve2();
+      }
+    });
+  }
   async connect() {
     const base = this.opts.baseUrl.endsWith("/") ? this.opts.baseUrl.slice(0, -1) : this.opts.baseUrl;
     const url = `${base}${this.opts.path}`;
@@ -15532,9 +15619,6 @@ var SseSubscriber = class {
     }
   }
 };
-function sleep4(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
 
 // src/supervisor.ts
 init_transcript_writer();
@@ -15542,19 +15626,19 @@ init_transcript_writer();
 // src/updater.ts
 import { spawn as spawn8 } from "child_process";
 import { copyFileSync as copyFileSync3, existsSync as existsSync17, mkdirSync as mkdirSync16, renameSync as renameSync11, rmSync as rmSync14 } from "fs";
-import { dirname as dirname12, join as join26 } from "path";
+import { dirname as dirname14, join as join27 } from "path";
 
 // src/boot-rule.ts
 import {
   mkdirSync as mkdirSync13,
   readFileSync as readFileSync12,
-  realpathSync as realpathSync5,
+  realpathSync as realpathSync6,
   renameSync as renameSync8,
   rmSync as rmSync12,
   symlinkSync,
   writeFileSync as writeFileSync9
 } from "fs";
-import { dirname as dirname9, join as join23 } from "path";
+import { dirname as dirname11, join as join24 } from "path";
 var UNCONFIRMED_WINDOW_MS = 10 * 6e4;
 var MAX_STAGE_ATTEMPTS = 3;
 function superseded(pending, ...running) {
@@ -15583,37 +15667,37 @@ import {
   mkdirSync as mkdirSync14,
   readFileSync as readFileSync13,
   readdirSync as readdirSync6,
-  realpathSync as realpathSync6,
+  realpathSync as realpathSync7,
   renameSync as renameSync9,
   rmSync as rmSync13,
   symlinkSync as symlinkSync2
 } from "fs";
-import { dirname as dirname10, join as join24 } from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import { dirname as dirname12, join as join25 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
 function versionsDir() {
-  return join24(cabaneDir(), "versions");
+  return join25(cabaneDir(), "versions");
 }
 function currentLink() {
-  return join24(cabaneDir(), "current");
+  return join25(cabaneDir(), "current");
 }
 function bootGuardPath() {
-  return join24(cabaneDir(), "boot-guard.mjs");
+  return join25(cabaneDir(), "boot-guard.mjs");
 }
 function pinnedNodeDir() {
-  return join24(cabaneDir(), "node");
+  return join25(cabaneDir(), "node");
 }
 function pinnedNodePath() {
-  return join24(pinnedNodeDir(), "bin", "node");
+  return join25(pinnedNodeDir(), "bin", "node");
 }
 function versionPackageRoot(version) {
-  return join24(versionsDir(), version, "node_modules", "@cabane", "companion");
+  return join25(versionsDir(), version, "node_modules", "@cabane", "companion");
 }
 function ownPackageRoot(moduleUrl = import.meta.url) {
-  return dirname10(dirname10(fileURLToPath6(moduleUrl)));
+  return dirname12(dirname12(fileURLToPath7(moduleUrl)));
 }
 function packageVersion(root) {
   try {
-    const pkg2 = JSON.parse(readFileSync13(join24(root, "package.json"), "utf8"));
+    const pkg2 = JSON.parse(readFileSync13(join25(root, "package.json"), "utf8"));
     return typeof pkg2.version === "string" ? pkg2.version : null;
   } catch {
     return null;
@@ -15621,15 +15705,15 @@ function packageVersion(root) {
 }
 function currentRoot() {
   try {
-    const root = realpathSync6(currentLink());
-    return existsSync16(join24(root, "dist", "cli.js")) ? root : null;
+    const root = realpathSync7(currentLink());
+    return existsSync16(join25(root, "dist", "cli.js")) ? root : null;
   } catch {
     return null;
   }
 }
 function pointCurrentAt(root) {
   const link = currentLink();
-  mkdirSync14(dirname10(link), { recursive: true });
+  mkdirSync14(dirname12(link), { recursive: true });
   const fresh = `${link}.${process.pid}.${Date.now()}`;
   symlinkSync2(root, fresh);
   try {
@@ -15645,7 +15729,7 @@ function pruneVersions(keep) {
   const removed = [];
   for (const name of readdirSync6(dir2)) {
     if (keep.includes(name)) continue;
-    rmSync13(join24(dir2, name), { recursive: true, force: true });
+    rmSync13(join25(dir2, name), { recursive: true, force: true });
     removed.push(name);
   }
   return removed;
@@ -15665,7 +15749,7 @@ function compareVersions(a, b) {
 // src/update-state.ts
 init_config();
 import { mkdirSync as mkdirSync15, readFileSync as readFileSync14, renameSync as renameSync10, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname11, join as join25 } from "path";
+import { dirname as dirname13, join as join26 } from "path";
 import { z as z18 } from "zod";
 var resultSchema = z18.object({
   kind: z18.enum(["updated", "rolled_back", "failed"]),
@@ -15689,7 +15773,7 @@ var stateSchema = z18.object({
   failed: z18.object({ version: z18.string(), attempts: z18.number().int(), at: z18.string() }).optional()
 });
 function updateStatePath(dir2 = cabaneDir()) {
-  return join25(dir2, "update.json");
+  return join26(dir2, "update.json");
 }
 function readUpdateState(path = updateStatePath()) {
   try {
@@ -15700,7 +15784,7 @@ function readUpdateState(path = updateStatePath()) {
   }
 }
 function writeUpdateState(state, path = updateStatePath()) {
-  mkdirSync15(dirname11(path), { recursive: true });
+  mkdirSync15(dirname13(path), { recursive: true });
   const tmp = `${path}.${process.pid}.tmp`;
   writeFileSync10(tmp, `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
@@ -15717,7 +15801,7 @@ function updateMode(env = process.env) {
   return env.CABANE_COMPANION_SUPERVISED === "1" ? "supervised" : "attached";
 }
 var STAGE_RETRY_MS = 60 * 6e4;
-var SWAP_DRAIN_MS = 1e4;
+var SWAP_WAIT_MS = 10 * 6e4;
 var SOURCE_BUILD_VERSION = "0.0.0";
 function versionToStage(input) {
   const { own, state, now, force } = input;
@@ -15738,10 +15822,10 @@ function rollBack(pending, reason, now = /* @__PURE__ */ new Date()) {
   return updateUpdateState((state) => rolledBackState(state, pending, reason, now));
 }
 function writeBootGuard(root = ownPackageRoot()) {
-  const built = join26(root, "dist", "boot-guard.js");
+  const built = join27(root, "dist", "boot-guard.js");
   if (!existsSync17(built)) return false;
   const target = bootGuardPath();
-  mkdirSync16(dirname12(target), { recursive: true });
+  mkdirSync16(dirname14(target), { recursive: true });
   const tmp = `${target}.${process.pid}.tmp`;
   copyFileSync3(built, tmp);
   renameSync11(tmp, target);
@@ -15778,17 +15862,17 @@ var runProcess = (command, args, opts = {}) => new Promise((resolve2) => {
 async function stageVersion(version, harnesses, deps = {}) {
   const run = deps.run ?? runProcess;
   const node = deps.execPath ?? process.execPath;
-  const target = join26(versionsDir(), version);
+  const target = join27(versionsDir(), version);
   const placed = versionPackageRoot(version);
   if (existsSync17(placed)) {
     if (!await verifyInstall(placed, version, harnesses, { run, execPath: node }))
       return { ok: true, root: placed };
   }
-  const npm = join26(dirname12(node), "npm");
+  const npm = join27(dirname14(node), "npm");
   if (!existsSync17(npm))
-    return { ok: false, reason: `there is no npm beside Node at ${dirname12(node)}` };
+    return { ok: false, reason: `there is no npm beside Node at ${dirname14(node)}` };
   mkdirSync16(versionsDir(), { recursive: true });
-  const staging = join26(versionsDir(), `.${version}.staging-${process.pid}`);
+  const staging = join27(versionsDir(), `.${version}.staging-${process.pid}`);
   rmSync14(staging, { recursive: true, force: true });
   const installed = await run(
     npm,
@@ -15805,7 +15889,7 @@ async function stageVersion(version, harnesses, deps = {}) {
     ],
     {
       // npm's install scripts run on this Node, not whichever `node` is first on PATH.
-      env: { ...process.env, PATH: `${dirname12(node)}:${process.env.PATH ?? ""}` },
+      env: { ...process.env, PATH: `${dirname14(node)}:${process.env.PATH ?? ""}` },
       timeoutMs: 15 * 6e4
     }
   );
@@ -15817,7 +15901,7 @@ async function stageVersion(version, harnesses, deps = {}) {
       return { ok: false, reason: `version ${version} isn't published yet`, unpublished: true };
     return { ok: false, reason: `npm couldn't install it: ${lastLine(installed.stderr)}` };
   }
-  const root = join26(staging, "node_modules", "@cabane", "companion");
+  const root = join27(staging, "node_modules", "@cabane", "companion");
   const verdict = await verifyInstall(root, version, harnesses, { run, execPath: node });
   if (verdict) {
     rmSync14(staging, { recursive: true, force: true });
@@ -15829,7 +15913,7 @@ async function stageVersion(version, harnesses, deps = {}) {
 }
 async function verifyInstall(root, version, harnesses, deps) {
   if (packageVersion(root) !== version) return `the installed package isn't version ${version}`;
-  const answered = await deps.run(deps.execPath, [join26(root, "dist", "bin.js"), "--version"], {
+  const answered = await deps.run(deps.execPath, [join27(root, "dist", "bin.js"), "--version"], {
     timeoutMs: 6e4,
     env: { ...process.env, CABANE_LAUNCH_SELF: "1" }
   });
@@ -15837,7 +15921,7 @@ async function verifyInstall(root, version, harnesses, deps) {
     return `it doesn't start: ${lastLine(answered.stderr) || "no version printed"}`;
   }
   if (harnesses.length === 0) return null;
-  const probed = await deps.run(deps.execPath, [join26(root, "dist", "postinstall.js"), "--json"], {
+  const probed = await deps.run(deps.execPath, [join27(root, "dist", "postinstall.js"), "--json"], {
     timeoutMs: 6e4
   });
   let resolutions = {};
@@ -15867,6 +15951,8 @@ var CompanionUpdater = class {
   deps;
   staging = null;
   ready = null;
+  // When `ready` verified; `SWAP_WAIT_MS` counts from here.
+  readyAt = 0;
   swapping = false;
   watchdog = null;
   now;
@@ -15965,7 +16051,7 @@ var CompanionUpdater = class {
       return { ok: true, message: `Cabane ${this.deps.own} is up to date.` };
     if (state.pending?.to === latest) return { ok: true, message: this.waitingMessage(latest) };
     if (this.ready === latest) {
-      void this.trySwap();
+      void this.trySwap(true);
       return { ok: true, message: this.waitingMessage(latest) };
     }
     this.maybeStage(true);
@@ -15981,13 +16067,14 @@ var CompanionUpdater = class {
         message: failed?.kind === "failed" && failed.to === latest ? `Couldn't update to ${latest}: ${failed.reason ?? "see cabane logs"}.` : `Couldn't update to ${latest}. cabane logs says why.`
       };
     }
-    void this.trySwap();
+    void this.trySwap(true);
     return { ok: true, message: this.waitingMessage(latest) };
   }
+  // Only the person's `cabane update` asks, and that swaps at once.
   waitingMessage(version) {
     if (this.deps.mode === "attached")
       return `Cabane ${version} is installed. It runs from the next  cabane start.`;
-    return this.deps.isIdle() ? `Updating to ${version} now.` : `Updating to ${version} once the turns running now finish.`;
+    return this.deps.isIdle() ? `Updating to ${version} now.` : `Updating to ${version} now. The turns running now carry on after the restart.`;
   }
   maybeStage(force) {
     if (this.staging) return;
@@ -16005,6 +16092,7 @@ var CompanionUpdater = class {
       const outcome = await stage(version, this.deps.harnesses());
       if (outcome.ok) {
         this.ready = version;
+        this.readyAt = this.now();
         updateUpdateState((s) => {
           const { failed: _failed, ...rest } = s;
           return rest;
@@ -16043,8 +16131,10 @@ var CompanionUpdater = class {
     });
     void this.staging.then(() => this.trySwap());
   }
-  // Swap into the ready version once nothing is running. Called on each heartbeat until it can.
-  async trySwap() {
+  // Swap into the ready version: when nothing is running, when it has waited `SWAP_WAIT_MS` for
+  // that, when this version is below the server's minimum, or `now` (the person asked). Called on
+  // each heartbeat until it does.
+  async trySwap(now = false) {
     const to = this.ready;
     if (!to || this.swapping) return;
     if (readUpdateState().pending) return;
@@ -16053,18 +16143,9 @@ var CompanionUpdater = class {
       this.deps.log.info({ version: to }, `Cabane ${to} is installed; it runs from the next start`);
       return;
     }
-    if (!this.deps.isIdle()) return;
+    if (!now && !this.deps.isIdle() && !this.waitedLongEnough() && !this.belowMinimum()) return;
     this.swapping = true;
     try {
-      await this.deps.pauseStream();
-      const sleep5 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-      const deadline = this.now() + SWAP_DRAIN_MS;
-      await sleep5(250);
-      while (!this.deps.isIdle() && this.now() < deadline) await sleep5(250);
-      if (!this.deps.isIdle()) {
-        this.deps.resumeStream();
-        return;
-      }
       this.select(to);
       this.deps.log.info({ from: this.deps.own, to }, `Restarting into Cabane ${to}`);
       await this.deps.restart();
@@ -16072,6 +16153,14 @@ var CompanionUpdater = class {
       this.swapping = false;
     }
   }
+  waitedLongEnough() {
+    return this.now() - this.readyAt >= SWAP_WAIT_MS;
+  }
+  // Cabane refuses this version's turns: waiting would only turn them away.
+  belowMinimum() {
+    const minimum = readUpdateState().server?.minimum;
+    return !!minimum && compareVersions(this.deps.own, minimum) < 0;
+  }
   // Record the swap and point `current` at `to`, leaving the guard that counts its starts.
   select(to) {
     const fromRoot = currentRoot() ?? ownPackageRoot();
@@ -16096,6 +16185,7 @@ init_version2();
 init_src();
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var ARCHIVE_PRUNE_MS = 24 * 60 * 6e4;
+var FORCE_EXIT_MS = 4e3;
 var SHUTDOWN_HEARTBEAT_WAIT_MS = 1e3;
 function positiveIntEnv(name) {
   const raw = process.env[name];
@@ -16316,14 +16406,7 @@ var CompanionSupervisor = class {
       autoUpdate: () => this.config.update?.auto === true,
       harnesses: () => this.connectedBundledHarnesses(),
       isIdle: () => this.idle(),
-      pauseStream: async () => {
-        const sub = this.deviceSub;
-        if (!sub) return;
-        sub.stop();
-        await sub.finished;
-      },
-      resumeStream: () => void this.deviceSub?.resume(),
-      restart: () => this.restartForUpdate(),
+      restart: () => this.restartBounded(),
       log: this.log
     });
     this.updater.start();
@@ -16416,7 +16499,7 @@ var CompanionSupervisor = class {
     this.versionSkewWarned = true;
     this.log.warn(
       { companionVersion: COMPANION_VERSION, serverVersion },
-      "This companion and Cabane are on different versions. If turns fail, update with npm i -g @cabane/companion@latest"
+      `This companion and Cabane are on different versions. If turns fail, update with ${cabane("update")}`
     );
   }
   // Pull assignments and reconcile the live runner set against them. Re-entrancy
@@ -16645,7 +16728,8 @@ var CompanionSupervisor = class {
         bundled: this.bundledStatus("claude-code")
       },
       codex: { intended: isCodexEnabled(this.config), bundled: this.bundledStatus("codex") },
-      install: companionInstall()
+      install: companionInstall(),
+      managed: repairRoute() === "managed"
     });
   }
   // A missing binary is reported ONCE, and again only when the answer CHANGES,
@@ -17445,8 +17529,22 @@ var CompanionSupervisor = class {
       );
     }
   }
+  // The update's restart, held to the same `FORCE_EXIT_MS` a signal's stop gets. Exit 0: the
+  // swap is recorded and `current` names the new version, so the service starts it either way.
+  async restartBounded() {
+    const force = setTimeout(() => {
+      this.log.warn({ ms: FORCE_EXIT_MS }, "Restarting for the update: shutdown took too long");
+      this.exitFn(0);
+    }, FORCE_EXIT_MS);
+    force.unref?.();
+    try {
+      await this.restartForUpdate();
+    } finally {
+      clearTimeout(force);
+    }
+  }
   // Nothing running and nothing about to: no dispatch claimed, no turn chained, no recovery
-  // in progress. What a self-update swap waits for.
+  // in progress. What a self-update swap waits for, up to `SWAP_WAIT_MS`.
   idle() {
     if (this.claims.size > 0 || this.recovering) return false;
     for (const wr of this.workspaces.values()) if (wr.chains.size > 0) return false;
@@ -17468,7 +17566,7 @@ var CompanionSupervisor = class {
       if (auto) this.kickHeartbeat();
       return {
         ok: true,
-        message: auto ? "Cabane will keep itself up to date. Updates install between turns and roll back if they fail." : "Cabane won't update itself. Run  cabane update  to update."
+        message: auto ? "Cabane will keep itself up to date. Updates install between turns when they can, and roll back if they fail." : "Cabane won't update itself. Run  cabane update  to update."
       };
     }
     if (!this.updater) return { ok: false, message: "This computer isn't paired yet." };
@@ -17590,9 +17688,9 @@ function handleUncaught(log, err, origin) {
 // src/crash-marker.ts
 init_config();
 import { existsSync as existsSync18, mkdirSync as mkdirSync17, readFileSync as readFileSync15, rmSync as rmSync15, writeFileSync as writeFileSync11 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function crashMarkerPath() {
-  return join27(cabaneDir(), "last-error.json");
+  return join28(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
@@ -17783,7 +17881,7 @@ import {
   writeFileSync as writeFileSync12
 } from "fs";
 import { homedir as homedir7, userInfo as userInfo3 } from "os";
-import { dirname as dirname13, join as join28, sep as sep5 } from "path";
+import { dirname as dirname15, join as join29, sep as sep5 } from "path";
 function servicePlatform(platform = process.platform) {
   if (platform === "linux") return "systemd";
   if (platform === "darwin") return "launchd";
@@ -17801,15 +17899,15 @@ function serviceNode(execPath = process.execPath) {
   return existsSync19(pinnedNodePath()) ? pinnedNodePath() : execPath;
 }
 function servicePaths(platform, env = process.env, home = homedir7(), node = serviceNode()) {
-  const unitFile = platform === "systemd" ? join28(
-    env.XDG_CONFIG_HOME || join28(home, ".config"),
+  const unitFile = platform === "systemd" ? join29(
+    env.XDG_CONFIG_HOME || join29(home, ".config"),
     "systemd",
     "user",
     `${serviceName(env)}.service`
-  ) : join28(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
+  ) : join29(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
   return {
     unitFile,
-    envFile: join28(cabaneDir(), "service.env"),
+    envFile: join29(cabaneDir(), "service.env"),
     node,
     entry: bootGuardPath()
   };
@@ -17876,7 +17974,7 @@ function renderLaunchdPlist(paths, env = process.env, servicePath) {
     "  <key>ThrottleInterval</key><integer>5</integer>",
     // The companion writes its own log; the console copy would only grow a second one.
     "  <key>StandardOutPath</key><string>/dev/null</string>",
-    `  <key>StandardErrorPath</key><string>${xml(join28(cabaneDir(), "service-error.log"))}</string>`,
+    `  <key>StandardErrorPath</key><string>${xml(join29(cabaneDir(), "service-error.log"))}</string>`,
     "</dict>",
     "</plist>",
     ""
@@ -17931,11 +18029,11 @@ async function installService(deps = {}) {
   rewriteScriptWrappers();
   const paths = servicePaths(platform, env, deps.home, node);
   const servicePath = await loginShellPath(run, env);
-  mkdirSync18(dirname13(paths.envFile), { recursive: true });
+  mkdirSync18(dirname15(paths.envFile), { recursive: true });
   const existing = existsSync19(paths.envFile) ? readFileSync16(paths.envFile, "utf8") : "";
   writeFileSync12(paths.envFile, withServicePath(existing, servicePath), { mode: 384 });
   chmodSync7(paths.envFile, 384);
-  mkdirSync18(dirname13(paths.unitFile), { recursive: true });
+  mkdirSync18(dirname15(paths.unitFile), { recursive: true });
   const outcome = await writeAndStartUnit(platform, paths, env, servicePath, run);
   if (!outcome.ok) await removeUnit(platform, paths, env, run);
   return outcome;
@@ -18016,15 +18114,15 @@ async function seedManagedInstall(deps) {
   }
   const target = versionPackageRoot(version);
   if (!existsSync19(target)) {
-    const staging = join28(versionsDir(), `.${version}.seed-${process.pid}`);
+    const staging = join29(versionsDir(), `.${version}.seed-${process.pid}`);
     rmSync16(staging, { recursive: true, force: true });
     try {
-      cpSync(own, join28(staging, "node_modules", "@cabane", "companion"), {
+      cpSync(own, join29(staging, "node_modules", "@cabane", "companion"), {
         recursive: true,
         verbatimSymlinks: true
       });
-      rmSync16(join28(versionsDir(), version), { recursive: true, force: true });
-      renameSync12(staging, join28(versionsDir(), version));
+      rmSync16(join29(versionsDir(), version), { recursive: true, force: true });
+      renameSync12(staging, join29(versionsDir(), version));
     } catch (err) {
       rmSync16(staging, { recursive: true, force: true });
       return {
@@ -18035,7 +18133,7 @@ async function seedManagedInstall(deps) {
   }
   const unrunnable = await verifyInstall(target, version, [], deps);
   if (unrunnable) {
-    rmSync16(join28(versionsDir(), version), { recursive: true, force: true });
+    rmSync16(join29(versionsDir(), version), { recursive: true, force: true });
     return { ok: false, reason: `The copy of Cabane for the service can't run: ${unrunnable}.` };
   }
   pointCurrentAt(target);
@@ -18117,9 +18215,9 @@ function userName() {
     return process.env.USER ?? "";
   }
 }
-function rewriteScriptWrappers(dir2 = join28(cabaneDir(), "bin")) {
+function rewriteScriptWrappers(dir2 = join29(cabaneDir(), "bin")) {
   for (const name of ["cabane", "cabane-companion"]) {
-    const path = join28(dir2, name);
+    const path = join29(dir2, name);
     let text;
     try {
       text = readFileSync16(path, "utf8");
@@ -18178,7 +18276,7 @@ async function startDaemon(opts = {}, deps = {}) {
   const readState = deps.readState ?? readLiveRuntimeState;
   const verify = deps.verify ?? ((s) => verifyRuntime(s));
   const spawnDetached = deps.spawnDetached ?? defaultSpawnDetached;
-  const sleep5 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = deps.now ?? (() => Date.now());
   const quiet = opts.report === "failures";
   const cfg = requireStartConfig({
@@ -18226,7 +18324,7 @@ async function startDaemon(opts = {}, deps = {}) {
     const deadline = now() + STARTUP_TIMEOUT_MS;
     let seen = readState();
     while (!ready(seen) && now() < deadline) {
-      await sleep5(POLL_INTERVAL_MS);
+      await sleep4(POLL_INTERVAL_MS);
       seen = readState();
     }
     return ready(seen) ? seen : null;
@@ -18299,7 +18397,7 @@ 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 sleep5 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = deps.now ?? (() => Date.now());
   const state = readState();
   if (!state) {
@@ -18327,7 +18425,7 @@ async function stop(deps = {}) {
       process.stdout.write("companion: stopped.\n");
       return;
     }
-    await sleep5(POLL_INTERVAL_MS2);
+    await sleep4(POLL_INTERVAL_MS2);
   }
   process.stdout.write(
     `companion: didn't exit within ${TERM_GRACE_MS / 1e3}s, sending SIGKILL.
@@ -18353,7 +18451,7 @@ function isAlive(kill, pid) {
 var STARTUP_WAIT_MS = 2e4;
 async function installAndStartService(deps = {}) {
   const readState = deps.readState ?? readLiveRuntimeState;
-  const sleep5 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = deps.now ?? Date.now;
   const before = await serviceState(deps);
   const running = readState();
@@ -18369,7 +18467,7 @@ async function installAndStartService(deps = {}) {
   while (now() < deadline) {
     const state = readState();
     if (state?.socket) return true;
-    await sleep5(250);
+    await sleep4(250);
   }
   write(
     `${INDENT}The service is installed but Cabane hasn't come up yet. ${cabane("service status")} and ${cabane("logs")} say why.`
@@ -18383,7 +18481,7 @@ async function serviceInstall(deps = {}) {
   }
   write(
     INDENT + tick(
-      "Cabane runs as a service. It starts at boot, restarts if it stops, and updates itself between turns."
+      "Cabane runs as a service. It starts at boot, restarts if it stops, and updates itself, usually between turns."
     )
   );
   write(`${INDENT}  Status:  ${cabane("service status")}        Logs:  ${cabane("logs")}`);
@@ -18446,7 +18544,7 @@ function updateRows(state, auto, opts = {}) {
   rows.push(
     row(
       "Auto-update",
-      !opts.service ? `off \u2014 runs with the service: ${cabane("service install")}` : auto === true ? "on \u2014 updates install between turns and roll back if they fail" : `off \u2014 ${cabane("update --auto on")} turns it on`
+      !opts.service ? `off \u2014 runs with the service: ${cabane("service install")}` : auto === true ? "on \u2014 updates install between turns when they can, and roll back if they fail" : `off \u2014 ${cabane("update --auto on")} turns it on`
     )
   );
   const last = state.lastResult;
@@ -18477,7 +18575,6 @@ function setRunsAsService(on) {
 }
 
 // src/commands/start.ts
-var FORCE_EXIT_MS = 4e3;
 var MAX_CODES = 3;
 async function start(opts = {}) {
   setLogOverrides(opts);
@@ -18943,7 +19040,7 @@ async function askHowToRun(deps = {}) {
     return { asService: false };
   blank();
   const asService = await ask(
-    "Keep Cabane running and up to date on this computer? It starts at boot, restarts if it stops, and updates itself between turns."
+    "Keep Cabane running and up to date on this computer? It starts at boot, restarts if it stops, and updates itself, usually between turns."
   );
   if (!asService) saveConfig({ ...cfg, serviceDeclined: true });
   blank();
@@ -19113,10 +19210,11 @@ async function logs(opts = {}) {
 
 // src/commands/status.ts
 init_bundled_binaries();
+init_install_kind();
 init_cabane_command();
-import { readdirSync as readdirSync7, realpathSync as realpathSync7, existsSync as existsSync20 } from "fs";
+import { readdirSync as readdirSync7, realpathSync as realpathSync8, existsSync as existsSync20 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname14, join as join29 } from "path";
+import { dirname as dirname16, join as join30 } from "path";
 init_config();
 init_sandbox_policy();
 init_secrets();
@@ -19182,10 +19280,10 @@ function versionLine() {
   const install = companionInstall();
   const own = installedCommandPath({ install });
   if (install === "script") {
-    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join29(homedir8(), ".cabane"))})`;
+    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join30(homedir8(), ".cabane"))})`;
   }
   if (own)
-    return `Cabane ${COMPANION_VERSION} \xB7 installed with npm (${tildePath(dirname14(dirname14(own)))})`;
+    return `Cabane ${COMPANION_VERSION} \xB7 installed with npm (${tildePath(dirname16(dirname16(own)))})`;
   return `Cabane ${COMPANION_VERSION}`;
 }
 function otherInstallLines(running) {
@@ -19202,13 +19300,13 @@ function otherInstallLines(running) {
 function otherInstall(install, own) {
   const real = (p) => {
     try {
-      return realpathSync7(p);
+      return realpathSync8(p);
     } catch {
       return null;
     }
   };
   if (install === "npm") {
-    const script = join29(
+    const script = join30(
       homedir8(),
       ".cabane",
       "node",
@@ -19217,12 +19315,12 @@ function otherInstall(install, own) {
       "@cabane",
       "companion"
     );
-    return existsSync20(script) ? join29(homedir8(), ".cabane") : null;
+    return existsSync20(script) ? join30(homedir8(), ".cabane") : null;
   }
   const found = firstOnPath("cabane-companion", process.env.PATH);
   if (!found) return null;
-  const ownAlias = own ? real(join29(dirname14(own), "cabane-companion")) : null;
-  return real(found) === ownAlias ? null : dirname14(found);
+  const ownAlias = own ? real(join30(dirname16(own), "cabane-companion")) : null;
+  return real(found) === ownAlias ? null : dirname16(found);
 }
 async function liveState() {
   const running = readLiveRuntimeState();
@@ -19282,7 +19380,7 @@ function signInText(runtime, status2, version) {
     case "signed_out":
       return `signed out \u2014 run  ${loginCommand(runtime)}`;
     case "bundle_missing":
-      return `this install is missing it \u2014 repair with  ${repairCommands()[0]}`;
+      return `this install is missing it \u2014 repair with  ${repairSteps()}${repairCost() ? `. ${repairCost()}` : ""}`;
     case "check_failed":
       return "connected, but its sign-in couldn't be checked";
     default:
@@ -19341,6 +19439,8 @@ init_config();
 init_term();
 init_version2();
 init_cabane_command();
+init_bundled_binaries();
+init_install_kind();
 var UPDATE_TIMEOUT_MS = 20 * 6e4;
 async function update(opts = {}) {
   const running = readLiveRuntimeState();
@@ -19358,20 +19458,43 @@ async function update(opts = {}) {
       write(`${INDENT}${r.ok ? tick(r.message) : r.message}`);
       return;
     }
-    const cfg2 = loadConfig();
-    if (!cfg2) {
+    const cfg = loadConfig();
+    if (!cfg) {
       write(`${INDENT}This computer isn't set up yet. Run  ${cabane("start")}  first.`);
       process.exitCode = 1;
       return;
     }
-    saveConfig({ ...cfg2, update: { auto } });
+    saveConfig({ ...cfg, update: { auto } });
     write(
       INDENT + tick(
-        auto ? "Cabane will keep itself up to date. Updates install between turns and roll back if they fail." : "Cabane won't update itself."
+        auto ? "Cabane will keep itself up to date. Updates install between turns when they can, and roll back if they fail." : "Cabane won't update itself."
       )
     );
     return;
   }
+  const harnesses = connectedHarnesses();
+  const latest = readUpdateState().server?.latest;
+  if (!latest || compareVersions(latest, COMPANION_VERSION) <= 0) {
+    const repair = await repairOwnCopy({ running: Boolean(running) });
+    if (repair.kind === "running") {
+      write(
+        `${INDENT}This copy of Cabane ${COMPANION_VERSION} is incomplete: ${repair.reason}. Run  ${cabane("stop")}, then  ${cabane("update")}  again to repair it. Stopping ends any turn in progress.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (repair.kind === "failed") {
+      write(`${INDENT}Couldn't repair Cabane ${COMPANION_VERSION}: ${repair.reason}.`);
+      process.exitCode = 1;
+      return;
+    }
+    if (repair.kind === "repaired") {
+      write(
+        INDENT + tick(`Repaired Cabane ${COMPANION_VERSION}. Start it with  ${cabane("start")}`)
+      );
+      return;
+    }
+  }
   if (running?.socket) {
     const r = await controlRequest(
       running.socket,
@@ -19382,7 +19505,6 @@ async function update(opts = {}) {
     if (!r.ok) process.exitCode = 1;
     return;
   }
-  const latest = readUpdateState().server?.latest;
   if (!latest) {
     write(
       `${INDENT}Cabane hasn't said which version is latest yet. Run  ${cabane("start")}, and it updates from there.`
@@ -19394,11 +19516,6 @@ async function update(opts = {}) {
     write(INDENT + tick(`Cabane ${COMPANION_VERSION} is up to date.`));
     return;
   }
-  const cfg = loadConfig();
-  const harnesses = cfg ? [
-    ...isClaudeCodeConnected(cfg) ? ["claude-code"] : [],
-    ...isCodexEnabled(cfg) ? ["codex"] : []
-  ] : [];
   write(
     `${INDENT}Installing Cabane ${latest}. It brings its own copies of the agents, so this can take a few minutes.`
   );
@@ -19438,6 +19555,31 @@ async function update(opts = {}) {
   pointCurrentAt(outcome.root);
   write(INDENT + tick(`Updated to ${latest}. Start it with  ${cabane("start")}`));
 }
+function bundledHere(platform, arch) {
+  return ["claude-code", ...codexPlatformPackage(platform, arch) ? ["codex"] : []];
+}
+function connectedHarnesses() {
+  const cfg = loadConfig();
+  if (!cfg) return [];
+  return [
+    ...isClaudeCodeConnected(cfg) ? ["claude-code"] : [],
+    ...isCodexEnabled(cfg) ? ["codex"] : []
+  ];
+}
+async function repairOwnCopy(deps) {
+  if ((deps.route ?? repairRoute()) !== "managed") return { kind: "healthy" };
+  const harnesses = deps.harnesses ?? bundledHere(deps.platform ?? process.platform, deps.arch ?? process.arch);
+  const root = deps.root ?? ownPackageRoot();
+  const version = deps.version ?? COMPANION_VERSION;
+  const verify = deps.verify ?? ((r, v, h) => verifyInstall(r, v, h, { run: runProcess, execPath: process.execPath }));
+  const broken = await verify(root, version, harnesses);
+  if (!broken) return { kind: "healthy" };
+  if (deps.running) return { kind: "running", reason: broken };
+  const outcome = await (deps.stage ?? stageVersion)(version, harnesses);
+  if (!outcome.ok) return { kind: "failed", reason: outcome.reason };
+  (deps.point ?? pointCurrentAt)(outcome.root);
+  return { kind: "repaired" };
+}
 
 // src/commands/transcript.ts
 init_cabane_command();
@@ -19445,7 +19587,7 @@ init_errors();
 init_src();
 init_transcript_writer();
 import { existsSync as existsSync21, readFileSync as readFileSync17, readdirSync as readdirSync8 } from "fs";
-import { isAbsolute, join as join30 } from "path";
+import { isAbsolute, join as join31 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -19462,7 +19604,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join30(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join31(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -19545,7 +19687,7 @@ function isComplete(content) {
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync17(join30(dir2, f), "utf8"),
+    read: (f) => readFileSync17(join31(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`),
@@ -19585,7 +19727,7 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join30(dir2, f));
+    const { meta, outcome } = peek(join31(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
     const ws = str2(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
@@ -19623,10 +19765,10 @@ function resolveTarget(dir2, target) {
     if (existsSync21(target)) return target;
     throw new CompanionError(`no transcript at ${target}.`);
   }
-  const exact = join30(dir2, target);
+  const exact = join31(dir2, target);
   if (existsSync21(exact)) return exact;
   const matches = listFiles(dir2).filter((f) => f.includes(target));
-  if (matches.length === 1) return join30(dir2, matches[0]);
+  if (matches.length === 1) return join31(dir2, matches[0]);
   if (matches.length === 0) {
     throw new CompanionError(
       `no transcript matching "${target}" in ${dir2}. Run \`${cabane("transcript")}\` to list them.`
@@ -19790,6 +19932,8 @@ They are written per dispatch while \`${cabane("start")}\` is running.
 // src/cli.ts
 init_errors();
 init_version2();
+init_cabane_command();
+rememberInvokedCommand();
 var program = new Command();
 program.name("cabane").description("Run your Cabane agents on this computer, with Claude Code, Codex or OpenCode.").version(COMPANION_VERSION);
 program.command("pair").description(