@cabane/companion 0.6.158 → 0.6.160

package/dist/runtime.js

@@ -4,187 +4,13 @@ import { randomUUID as randomUUID7 } from "crypto";
 // 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";
 
-// 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
-  };
-}
-var CLAUDE_SDK = "@anthropic-ai/claude-agent-sdk";
-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 };
-}
-var CODEX_SDK = "@openai/codex-sdk";
-var CODEX_CLI = "@openai/codex";
-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;
-}
-var 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`
-};
-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
-    };
-  }
-}
-var HARNESS_LABEL = {
-  "claude-code": "Claude Code",
-  codex: "Codex"
-};
-var HARNESS_INTENT_WORD = {
-  "claude-code": "connected",
-  codex: "enabled"
-};
-function missingNoun(status) {
-  return status === "executable_missing" ? "executable" : "platform package";
-}
 var INSTALL_SCRIPT_COMMAND = "curl -fsSL https://cabane.ai/install.sh | bash";
 function companionInstall(execPath = process.execPath, home = homedir()) {
   const real = (path) => {
@@ -197,23 +23,16 @@ 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, status, 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(status)} 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)));
 }
 
 // src/cli-entry.ts
@@ -241,15 +60,27 @@ function tildePath(path, home = homedir2()) {
 }
 
 // src/cabane-command.ts
+var INVOKED_COMMAND_ENV = "CABANE_INVOKED_COMMAND";
+var VERSIONS_SEGMENT = `${sep2}.cabane${sep2}versions${sep2}`;
 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);
@@ -265,6 +96,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;
@@ -300,7 +134,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";
 
 // src/errors.ts
@@ -763,7 +597,7 @@ function loadConfig() {
 }
 function saveConfig(cfg) {
   const path = configPath();
-  mkdirSync(dirname2(path), { recursive: true });
+  mkdirSync(dirname3(path), { recursive: true });
   try {
     chmodSync(cabaneDir(), 448);
   } catch {
@@ -795,20 +629,228 @@ function requireConfig() {
 }
 
 // src/dashboard/server.ts
-import { dirname as dirname4, join as join7 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname6, join as join8 } 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 openSync2, readSync, closeSync, fstatSync, existsSync as existsSync3 } from "fs";
 import { readFile } from "fs/promises";
-import { extname, join as join6, normalize } from "path";
+import { extname, join as join7, normalize } from "path";
 import { streamSSE } from "hono/streaming";
 
 // src/harness-copy.ts
 import { homedir as homedir5 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
+
+// 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
+  };
+}
+var CLAUDE_SDK = "@anthropic-ai/claude-agent-sdk";
+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 };
+}
+var CODEX_SDK = "@openai/codex-sdk";
+var CODEX_CLI = "@openai/codex";
+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;
+}
+var 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`
+};
+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
+    };
+  }
+}
+var HARNESS_LABEL = {
+  "claude-code": "Claude Code",
+  codex: "Codex"
+};
+var HARNESS_INTENT_WORD = {
+  "claude-code": "connected",
+  codex: "enabled"
+};
+function missingNoun(status) {
+  return status === "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}`;
+}
+var STOP_WARNING = "Stopping ends any turn in progress.";
+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, status, 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(status)} 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.`;
+}
 
 // src/harness-usable.ts
 import { spawn as spawn2 } from "child_process";
@@ -964,7 +1006,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;
 }
@@ -1225,16 +1272,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);
@@ -1271,6 +1318,9 @@ function connectLines(outcome, opts = {}) {
     ]
   };
 }
+function spaced(sentence) {
+  return sentence ? ` ${sentence}` : "";
+}
 
 // src/logger.ts
 import {
@@ -1280,11 +1330,11 @@ import {
   renameSync as renameSync2,
   statSync as statSync2
 } from "fs";
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname5, join as join6 } from "path";
 import { stripVTControlCharacters } from "util";
 import pino from "pino";
 function companionLogPath() {
-  return join5(cabaneDir(), "companion.log");
+  return join6(cabaneDir(), "companion.log");
 }
 function humanText(value) {
   return stripVTControlCharacters(String(value ?? "")).replace(
@@ -1392,7 +1442,7 @@ function configureLogger(log, config) {
 }
 function createLogger(destinations = {}, options = {}) {
   const path = companionLogPath();
-  if (!destinations.file) mkdirSync2(dirname3(path), { recursive: true });
+  if (!destinations.file) mkdirSync2(dirname5(path), { recursive: true });
   const file = destinations.file ?? new RotatingLog(path);
   const state = { format: options.logFormat ?? "human" };
   const streams = [];
@@ -1684,13 +1734,13 @@ var CONTENT_TYPES = {
 function registerRoutes(app, deps) {
   const { supervisor, hub, staticDir } = deps;
   app.get("/", async (c) => {
-    const html = await readFile(join6(staticDir, "index.html"), "utf8");
+    const html = await readFile(join7(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 = join6(staticDir, safe2);
+    const full = join7(staticDir, safe2);
     if (!full.startsWith(staticDir) || !existsSync3(full)) return c.notFound();
     const body = await readFile(full);
     const type = CONTENT_TYPES[extname(full).toLowerCase()] ?? "application/octet-stream";
@@ -1902,14 +1952,14 @@ function isAddrInUse(err) {
   return Boolean(err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE");
 }
 function resolveStaticDir() {
-  return join7(dirname4(fileURLToPath3(import.meta.url)), "static");
+  return join8(dirname6(fileURLToPath4(import.meta.url)), "static");
 }
 
 // src/control-socket.ts
 import { createHash } from "crypto";
 import { chmodSync as chmodSync2, existsSync as existsSync4, rmSync as rmSync2, mkdirSync as mkdirSync3 } from "fs";
 import { createServer, connect } from "net";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var CONTROL_TIMEOUT_MS = 1e3;
 var MAX_UNIX_SOCKET_PATH_BYTES = 103;
 function controlSocketPath() {
@@ -1918,11 +1968,11 @@ function controlSocketPath() {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\cabane-companion-${key}`;
   }
-  const besideRuntime = join8(dir2, "companion.sock");
+  const besideRuntime = join9(dir2, "companion.sock");
   if (Buffer.byteLength(besideRuntime) <= MAX_UNIX_SOCKET_PATH_BYTES) return besideRuntime;
   const filename = `cabane-companion-${key}.sock`;
-  const xdgPath = process.env.XDG_RUNTIME_DIR && existsSync4(process.env.XDG_RUNTIME_DIR) ? join8(process.env.XDG_RUNTIME_DIR, filename) : null;
-  return xdgPath && Buffer.byteLength(xdgPath) <= MAX_UNIX_SOCKET_PATH_BYTES ? xdgPath : join8("/tmp", filename);
+  const xdgPath = process.env.XDG_RUNTIME_DIR && existsSync4(process.env.XDG_RUNTIME_DIR) ? join9(process.env.XDG_RUNTIME_DIR, filename) : null;
+  return xdgPath && Buffer.byteLength(xdgPath) <= MAX_UNIX_SOCKET_PATH_BYTES ? xdgPath : join9("/tmp", filename);
 }
 async function startControlServer(handlers) {
   const path = controlSocketPath();
@@ -2122,10 +2172,10 @@ import {
   openSync as openSync3,
   closeSync as closeSync2
 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var PROBE_TIMEOUT_MS2 = 1e3;
 function runtimePath() {
-  return join9(cabaneDir(), "runtime.json");
+  return join10(cabaneDir(), "runtime.json");
 }
 function serialize(state) {
   return JSON.stringify(state, null, 2) + "\n";
@@ -2344,7 +2394,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:"))
@@ -2619,7 +2669,7 @@ var CabaneApi = class {
             }
             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;
@@ -3031,10 +3081,10 @@ import {
   rmSync as rmSync4,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname5, join as join10 } from "path";
+import { dirname as dirname7, join as join11 } from "path";
 import { z as z4 } from "zod";
 function credentialsPath() {
-  return join10(cabaneDir(), "credentials.json");
+  return join11(cabaneDir(), "credentials.json");
 }
 var credentialStoreSchema = z4.record(z4.string(), z4.string());
 function load() {
@@ -3056,7 +3106,7 @@ function load() {
 }
 function save(map) {
   const path = credentialsPath();
-  mkdirSync5(dirname5(path), { recursive: true });
+  mkdirSync5(dirname7(path), { recursive: true });
   try {
     chmodSync3(cabaneDir(), 448);
   } catch {
@@ -3102,13 +3152,13 @@ function pruneCredentials(keepAgentIds) {
 
 // src/dispatch-dedupe.ts
 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);
@@ -3145,10 +3195,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();
@@ -3184,10 +3234,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) {
@@ -8182,7 +8232,7 @@ var ConnectorHealthStore = class {
 // 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";
 
 // src/runner/launch.ts
 import { createInterface as createInterface2 } from "readline";
@@ -8641,11 +8691,11 @@ function createTurnContainment(turnId, deps = {}) {
 
 // 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";
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function secretsPath() {
-  return join12(cabaneDir(), "secrets.json");
+  return join13(cabaneDir(), "secrets.json");
 }
 var secretStoreSchema = z14.record(z14.string(), z14.string());
 function loadSecretStore() {
@@ -9615,11 +9665,11 @@ function trimSlash2(s) {
 // 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";
 var PREFIX = "cabane-codex-instructions-";
 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,
@@ -9632,7 +9682,7 @@ async function writeCodexInstructionsFile(contents) {
 // 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";
 var FETCH_TIMEOUT_MS = 3e4;
 var EXTENSIONS = {
   "image/png": "png",
@@ -9645,7 +9695,7 @@ function createCodexImagePreparer(opts) {
   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 });
@@ -9666,7 +9716,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) {
@@ -9788,15 +9838,15 @@ function reportFailure(config, body) {
 
 // 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);
@@ -9828,9 +9878,9 @@ function clearPrepared(workspaceId, conversationId, agentId) {
 
 // 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");
 }
 var RETAIN = 200;
 var ANOMALY_RETAIN = 50;
@@ -9840,7 +9890,7 @@ var TranscriptWriter = class {
   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 {
@@ -9869,10 +9919,10 @@ var TranscriptWriter = class {
   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);
@@ -9918,7 +9968,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 {
     }
   }
@@ -9932,7 +9982,7 @@ var TurnCommitter = class {
     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);
     };
@@ -10072,7 +10122,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;
   }
@@ -10374,7 +10424,7 @@ var TurnExecution = class {
       } 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()}`
         );
       }
     }
@@ -10852,7 +10902,7 @@ var TurnExecution = class {
       } 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);
@@ -11061,7 +11111,7 @@ var TurnExecution = class {
                     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(
@@ -11225,7 +11275,7 @@ var TurnExecution = class {
         } 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()}`
           );
         }
       }
@@ -11298,7 +11348,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 {
@@ -11306,7 +11356,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" };
 }
@@ -11524,7 +11574,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
@@ -11718,7 +11768,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}`;
@@ -11764,7 +11814,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 };
@@ -11777,7 +11827,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 };
     }
@@ -11789,9 +11839,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 \\
@@ -11835,17 +11885,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) {
@@ -11981,39 +12031,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, pair, 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 === `${pair.conversationId}/${pair.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;
@@ -12214,11 +12264,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 });
@@ -12360,7 +12410,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"));
@@ -12374,12 +12424,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(
@@ -12396,7 +12446,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");
@@ -12410,7 +12460,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;
@@ -12418,7 +12468,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
     });
@@ -12487,7 +12537,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
@@ -12636,15 +12686,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) {
@@ -12670,7 +12720,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)}
 `
           );
@@ -12683,7 +12733,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;
@@ -12892,15 +12942,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 {
@@ -12912,9 +12962,9 @@ function accountHome() {
 var STORE_WALK_TIMEOUT_MS = 6e4;
 var STORE_WALK_MAX_AGE_MS = 5 * 6e4;
 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))
@@ -13109,7 +13159,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 = 2e3;
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var Outbox = class {
@@ -13122,10 +13172,10 @@ var Outbox = class {
   // 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
@@ -13167,7 +13217,7 @@ var Outbox = class {
     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") {
@@ -13281,6 +13331,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).
@@ -13291,12 +13343,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;
@@ -13309,7 +13356,7 @@ var SseSubscriber = class {
         backoff = 500;
         if (!this.aborted) {
           this.opts.log.warn("Lost the connection to Cabane; reconnecting");
-          await sleep3(backoff);
+          await this.backoff(backoff);
         }
       } catch (err) {
         if (this.aborted) return;
@@ -13329,11 +13376,21 @@ var SseSubscriber = class {
           },
           "Lost the connection to Cabane; reconnecting"
         );
-        await sleep3(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}`;
@@ -13380,26 +13437,23 @@ var SseSubscriber = class {
     }
   }
 };
-function sleep3(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
 
 // 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) {
@@ -13427,31 +13481,31 @@ 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 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;
@@ -13459,15 +13513,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 {
@@ -13483,7 +13537,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;
@@ -13502,7 +13556,7 @@ function compareVersions(a, b) {
 
 // src/update-state.ts
 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"]),
@@ -13526,7 +13580,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 {
@@ -13537,7 +13591,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 });
@@ -13554,7 +13608,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;
@@ -13575,10 +13629,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);
@@ -13615,17 +13669,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,
@@ -13642,7 +13696,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
     }
   );
@@ -13654,7 +13708,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 });
@@ -13666,7 +13720,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" }
   });
@@ -13674,7 +13728,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 = {};
@@ -13704,6 +13758,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;
@@ -13802,7 +13858,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);
@@ -13818,13 +13874,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;
@@ -13842,6 +13899,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;
@@ -13880,8 +13938,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;
@@ -13890,18 +13950,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 sleep4 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-      const deadline = this.now() + SWAP_DRAIN_MS;
-      await sleep4(250);
-      while (!this.deps.isIdle() && this.now() < deadline) await sleep4(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();
@@ -13909,6 +13960,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();
@@ -13936,6 +13995,7 @@ var COMPANION_VERSION = pkg.version;
 // src/supervisor.ts
 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];
@@ -14156,14 +14216,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();
@@ -14256,7 +14309,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
@@ -14485,7 +14538,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,
@@ -15285,8 +15339,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;
@@ -15308,7 +15376,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." };
@@ -15426,9 +15494,9 @@ function handleUncaught(log, err, origin) {
 
 // src/crash-marker.ts
 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(rec) {
   try {