@cabane/companion 0.6.34 → 0.6.36

package/dist/cli.js

@@ -806,8 +806,12 @@ async function warnAboutHarnessReadiness(cfg, deps = {}) {
     ...claudeInstalled ? ["Claude Code"] : [],
     ...codexInstalled ? ["Codex"] : []
   ];
+  const connectCommands = [
+    ...claudeInstalled ? ["`cabane-companion connect claude-code`"] : [],
+    ...codexInstalled ? ["`cabane-companion connect codex`"] : []
+  ];
   warn(
-    "No harness is connected on this device yet, so no agent turn can run here. " + (installed.length > 0 ? `We found ${installed.join(" and ")} on this machine \u2014 connect ${installed.length > 1 ? "one" : "it"} in the Companion dashboard (or in cabane, Settings \u2192 Devices) and turns start routing here.` : "Install a harness and sign in \u2014 Claude Code (`npm i -g @anthropic-ai/claude-code`), the Codex CLI (`codex login`), or `opencode serve` \u2014 then connect it in the Companion dashboard.")
+    "No harness is connected on this device yet, so no agent turn can run here. " + (installed.length > 0 ? `We found ${installed.join(" and ")} on this machine \u2014 connect ${installed.length > 1 ? "one with " : "it with "}${connectCommands.join(" or ")} and turns start routing here.` : "Install a harness and sign in \u2014 Claude Code (`npm i -g @anthropic-ai/claude-code`), the Codex CLI (`codex login`), or `opencode serve` \u2014 then connect it with `cabane-companion connect <harness>` (pass `--url <url>` for opencode).")
   );
 }
 
@@ -1010,7 +1014,7 @@ async function shakeOutHarness(runtime, cfg, deps = {}) {
   try {
     if (runtime === "opencode") {
       const url = cfg.opencode?.serverUrl;
-      if (!url) return "failed";
+      if (!url) return "absent";
       return await probeOpencode(url) !== null ? "ok" : "failed";
     }
     const { auth, presence } = runtime === "codex" ? {
@@ -1020,11 +1024,13 @@ async function shakeOutHarness(runtime, cfg, deps = {}) {
       auth: ["claude", ["auth", "status"]],
       presence: ["claude", ["--version"]]
     };
+    const presenceRun = await run(presence[0], [...presence[1]]);
+    if (presenceRun.error === "spawn") return "absent";
+    if (presenceRun.code !== 0) return "unverified";
     const authRun = await run(auth[0], [...auth[1]]);
     if (authRun.code === 0) return "ok";
     if (looksUnsupported(authRun.output)) {
-      const presenceRun = await run(presence[0], [...presence[1]]);
-      return presenceRun.code === 0 ? "unverified" : "failed";
+      return "unverified";
     }
     return "failed";
   } catch {
@@ -1032,6 +1038,7 @@ async function shakeOutHarness(runtime, cfg, deps = {}) {
   }
 }
 function connectedLine(runtime, verdict) {
+  if (verdict === "absent") throw new Error("an absent harness cannot be connected");
   const label = HARNESS_LABELS[runtime];
   if (verdict !== "failed") return `${label} connected.`;
   return `${label} connected \u2014 ${FAILED_SUFFIX[runtime]}`;
@@ -1041,6 +1048,14 @@ var FAILED_SUFFIX = {
   codex: "it doesn\u2019t look signed in yet. Run `codex login` once, then it\u2019s ready.",
   opencode: "its server isn\u2019t answering. Start `opencode serve`, then it\u2019s ready."
 };
+function absentLine(runtime) {
+  if (runtime === "opencode") {
+    return "No opencode server is configured \u2014 run `opencode serve` and connect with `--url`.";
+  }
+  const label = HARNESS_LABELS[runtime];
+  const login = runtime === "codex" ? "`codex login`" : "`claude`";
+  return `${label} isn\u2019t installed on this machine \u2014 install it and sign in (${login}), then run this again.`;
+}
 function looksUnsupported(output) {
   return /unrecognized|unknown (sub)?command|unexpected argument|invalid (sub)?command|no such (sub)?command|usage:|did you mean/i.test(
     output
@@ -1049,17 +1064,17 @@ function looksUnsupported(output) {
 function runBounded(command, args) {
   return new Promise((resolve) => {
     let settled = false;
-    const done = (code, output) => {
+    const done = (result) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve({ code, output });
+      resolve(result);
     };
     let child;
     try {
       child = spawn4(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     } catch {
-      resolve({ code: null, output: "" });
+      resolve({ code: null, output: "", error: "spawn" });
       return;
     }
     let out = "";
@@ -1070,11 +1085,11 @@ function runBounded(command, args) {
     child.stderr?.on("data", capture);
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      done(null, out);
+      done({ code: null, output: out, error: "timeout" });
     }, CHECK_TIMEOUT_MS);
     timer.unref?.();
-    child.once("error", () => done(null, out));
-    child.once("exit", (code) => done(code, out));
+    child.once("error", () => done({ code: null, output: out, error: "spawn" }));
+    child.once("exit", (code) => done({ code, output: out }));
   });
 }
 
@@ -1271,11 +1286,23 @@ async function connect2(raw, opts = {}) {
   }
   const live = await liveSocket();
   if (live) {
-    const result = await controlRequest(live, {
-      cmd: "connect",
-      runtime,
-      ...opts.serverUrl ? { serverUrl: opts.serverUrl } : {}
-    });
+    let result;
+    try {
+      result = await controlRequest(
+        live,
+        {
+          cmd: "connect",
+          runtime,
+          ...opts.serverUrl ? { serverUrl: opts.serverUrl } : {}
+        },
+        1e4
+      );
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new CompanionError(
+        `Couldn\u2019t reach the running companion \u2014 ${detail}; try again, or \`cabane-companion stop\` and \`start\`.`
+      );
+    }
     if (!result.ok) throw new CompanionError(result.message);
     write(INDENT + tick(result.message));
     return;
@@ -1307,8 +1334,9 @@ async function connect2(raw, opts = {}) {
     }
     next = { ...cfg, opencode: { serverUrl } };
   }
-  saveConfig(next);
   const verdict = await shakeOutHarness(runtime, next);
+  if (verdict === "absent") throw new CompanionError(absentLine(runtime));
+  saveConfig(next);
   write(INDENT + tick(connectedLine(runtime, verdict)));
   write(`${INDENT}Not running yet \u2014 start it with: cabane-companion start`);
 }
@@ -1639,30 +1667,10 @@ async function pair(opts = {}) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 
-// src/service/index.ts
-import { dirname as dirname5 } from "path";
-
-// src/service/host.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync4, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir3 } from "os";
-
-// src/cli-entry.ts
-import { existsSync as existsSync5 } from "fs";
-import { fileURLToPath } from "url";
-var RELATIVE_CANDIDATES = ["./cli.js", "../dist/cli.js", "../cli.js"];
-function companionCliEntry(deps = {}) {
-  const exists = deps.exists ?? existsSync5;
-  const candidates = deps.candidates ?? RELATIVE_CANDIDATES.map((rel) => fileURLToPath(new URL(rel, import.meta.url)));
-  for (const candidate of candidates) {
-    if (exists(candidate)) return candidate;
-  }
-  const argv1 = "argv1" in deps ? deps.argv1 : process.argv[1];
-  if (argv1 && exists(argv1)) return argv1;
-  return candidates[0] ?? "";
-}
+// src/commands/start.ts
+import { hostname as hostname2 } from "os";
 
 // src/logger.ts
 import { createWriteStream, mkdirSync as mkdirSync5 } from "fs";
@@ -1692,473 +1700,55 @@ function consoleMessageFormat(log, messageKey) {
   return short ? `${short} ${msg}` : msg;
 }
 var cached = null;
-function getLogger() {
-  if (cached) return cached;
+var consoleLogging = true;
+function setConsoleLogging(enabled) {
+  consoleLogging = enabled;
+}
+function createLogger(destinations = {}) {
   const path = companionLogPath();
-  mkdirSync5(dirname3(path), { recursive: true });
+  if (!destinations.file) mkdirSync5(dirname3(path), { recursive: true });
   const streams = [];
   if (process.env.CABANE_COMPANION_DAEMON !== "1") {
     const consoleStream = pretty({
       colorize: true,
       ignore: CONSOLE_IGNORE,
-      messageFormat: (log, messageKey) => consoleMessageFormat(log, messageKey)
+      messageFormat: (log, messageKey) => consoleMessageFormat(log, messageKey),
+      ...destinations.console ? { destination: destinations.console } : {}
     });
-    streams.push({ level: "info", stream: consoleStream });
-  }
-  streams.push({ level: "debug", stream: createWriteStream(path, { flags: "a" }) });
-  cached = pino({ level: "debug" }, pino.multistream(streams));
-  return cached;
-}
-
-// src/service/host.ts
-var RUN_TIMEOUT_MS = 1e4;
-function defaultServiceHost() {
-  if (process.env.VITEST) {
-    throw new Error(
-      "defaultServiceHost() was reached during a test run \u2014 it shells out to the real service manager. Inject a fake host (apps/companion/test/service-host-fake.ts) instead."
-    );
-  }
-  return {
-    platform: process.platform,
-    env: process.env,
-    home: homedir3(),
-    uid: process.getuid?.() ?? 0,
-    execPath: process.execPath,
-    cliPath: companionCliEntry(),
-    logPath: companionLogPath(),
-    fs: {
-      read: (path) => {
-        try {
-          return readFileSync4(path, "utf8");
-        } catch {
-          return null;
+    streams.push({
+      level: "info",
+      stream: {
+        write(chunk) {
+          if (consoleLogging) consoleStream.write(chunk);
         }
-      },
-      write: (path, contents) => writeFileSync4(path, contents, "utf8"),
-      remove: (path) => rmSync5(path, { force: true }),
-      exists: (path) => existsSync6(path),
-      mkdirp: (dir2) => {
-        mkdirSync6(dir2, { recursive: true });
       }
-    },
-    run: (cmd, args) => {
-      const res = spawnSync(cmd, args, { encoding: "utf8", timeout: RUN_TIMEOUT_MS });
-      return {
-        ok: res.status === 0,
-        stdout: res.stdout ?? "",
-        stderr: res.stderr ?? (res.error ? res.error.message : "")
-      };
-    }
-  };
-}
-
-// src/service/launchd.ts
-import { join as join6 } from "path";
-var LAUNCHD_LABEL = "ai.cabane.companion";
-function launchAgentPath(home) {
-  return join6(home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-}
-function renderPlist(input) {
-  const args = input.programArguments.map((a) => `    <string>${xml(a)}</string>`).join("\n");
-  const env = Object.entries(input.environment).map(([k, v]) => `    <key>${xml(k)}</key>
-    <string>${xml(v)}</string>`).join("\n");
-  return [
-    '<?xml version="1.0" encoding="UTF-8"?>',
-    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
-    '<plist version="1.0">',
-    "<dict>",
-    "  <key>Label</key>",
-    `  <string>${LAUNCHD_LABEL}</string>`,
-    "  <key>ProgramArguments</key>",
-    "  <array>",
-    args,
-    "  </array>",
-    "  <key>RunAtLoad</key>",
-    "  <true/>",
-    "  <key>KeepAlive</key>",
-    "  <dict>",
-    "    <key>SuccessfulExit</key>",
-    "    <false/>",
-    "  </dict>",
-    "  <key>EnvironmentVariables</key>",
-    "  <dict>",
-    env,
-    "  </dict>",
-    "  <key>StandardOutPath</key>",
-    `  <string>${xml(input.logPath)}</string>`,
-    "  <key>StandardErrorPath</key>",
-    `  <string>${xml(input.logPath)}</string>`,
-    "</dict>",
-    "</plist>",
-    ""
-  ].join("\n");
-}
-function domain(host) {
-  return `gui/${host.uid}`;
-}
-function target(host) {
-  return `${domain(host)}/${LAUNCHD_LABEL}`;
-}
-function launchdStart(host, plistPath) {
-  host.run("launchctl", ["bootout", target(host)]);
-  const res = host.run("launchctl", ["bootstrap", domain(host), plistPath]);
-  return res.ok ? { ok: true } : { ok: false, detail: firstLine(res.stderr || res.stdout) };
-}
-function launchdStop(host) {
-  const res = host.run("launchctl", ["bootout", target(host)]);
-  if (res.ok || notLoaded(res.stderr + res.stdout)) return { ok: true };
-  return { ok: false, detail: firstLine(res.stderr || res.stdout) };
-}
-function launchdProbe(host) {
-  const res = host.run("launchctl", ["print", target(host)]);
-  if (res.ok) {
-    const state = /state\s*=\s*(\w+)/.exec(res.stdout)?.[1];
-    return { ownership: "held", running: state ? state === "running" : "unknown" };
-  }
-  return notLoaded(res.stderr + res.stdout) ? { ownership: "clear", running: false } : { ownership: "unknown", running: "unknown" };
-}
-function launchdRemove(host, plistPath) {
-  const stopped = launchdStop(host);
-  if (!stopped.ok) return stopped;
-  host.fs.remove(plistPath);
-  return { ok: true };
-}
-var NOT_LOADED = new RegExp(
-  `no such process|(could not find|not find service)[^\\n]*${LAUNCHD_LABEL.replace(
-    /[.*+?^${}()|[\]\\]/g,
-    "\\$&"
-  )}`,
-  "i"
-);
-function notLoaded(output) {
-  return NOT_LOADED.test(output);
-}
-function firstLine(s) {
-  return s.trim().split("\n")[0] ?? "";
-}
-function xml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-
-// src/service/systemd.ts
-import { dirname as dirname4, join as join7 } from "path";
-var SYSTEMD_UNIT = "cabane-companion.service";
-function systemdUnitPath(host) {
-  const configHome = host.env.XDG_CONFIG_HOME?.trim() ? host.env.XDG_CONFIG_HOME.trim() : join7(host.home, ".config");
-  return join7(configHome, "systemd", "user", SYSTEMD_UNIT);
-}
-function renderUnit(input) {
-  const [exec, ...rest] = input.programArguments;
-  const execStart = [quote(exec ?? ""), ...rest.map(quote)].join(" ");
-  const env = Object.entries(input.environment).map(([k, v]) => `Environment=${k}=${v}`);
-  return [
-    "[Unit]",
-    "Description=Cabane Companion \u2014 keeps this device answering while you are logged in",
-    "After=network-online.target",
-    "Wants=network-online.target",
-    "",
-    "[Service]",
-    "Type=simple",
-    ...env,
-    `ExecStart=${execStart}`,
-    "Restart=on-failure",
-    "RestartSec=5",
-    "",
-    "[Install]",
-    "WantedBy=default.target"
-  ].join("\n") + "\n";
-}
-function systemdReload(host) {
-  host.run("systemctl", ["--user", "daemon-reload"]);
-}
-function systemdStart(host) {
-  systemdReload(host);
-  const enabled = host.run("systemctl", ["--user", "enable", SYSTEMD_UNIT]);
-  if (!enabled.ok) return { ok: false, detail: firstLine2(enabled.stderr || enabled.stdout) };
-  const started = host.run("systemctl", ["--user", "restart", SYSTEMD_UNIT]);
-  if (!started.ok) return { ok: false, detail: firstLine2(started.stderr || started.stdout) };
-  return { ok: true };
-}
-function systemdStop(host) {
-  const res = host.run("systemctl", ["--user", "stop", SYSTEMD_UNIT]);
-  if (res.ok || notLoaded2(res.stderr + res.stdout)) return { ok: true };
-  return { ok: false, detail: firstLine2(res.stderr || res.stdout) };
-}
-function systemdProbe(host) {
-  const state = host.run("systemctl", ["--user", "is-active", SYSTEMD_UNIT]).stdout.trim();
-  if (state === "active") return { ownership: "held", running: true };
-  if (state === "activating" || state === "reloading" || state === "deactivating") {
-    return { ownership: "held", running: "transitional" };
-  }
-  if (state === "inactive" || state === "failed") return { ownership: "clear", running: false };
-  return { ownership: "unknown", running: "unknown" };
-}
-function systemdWantsLinkPath(host) {
-  return join7(dirname4(systemdUnitPath(host)), "default.target.wants", SYSTEMD_UNIT);
-}
-function systemdInstalled(host) {
-  return host.fs.exists(systemdUnitPath(host)) || host.fs.exists(systemdWantsLinkPath(host));
-}
-function systemdRemove(host, unitPath) {
-  const stopped = host.run("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT]);
-  if (!(stopped.ok || notLoaded2(stopped.stderr + stopped.stdout))) {
-    return { ok: false, detail: firstLine2(stopped.stderr || stopped.stdout) };
-  }
-  host.fs.remove(unitPath);
-  const link = systemdWantsLinkPath(host);
-  if (host.fs.exists(link)) host.fs.remove(link);
-  systemdReload(host);
-  return { ok: true };
-}
-var NOT_LOADED2 = new RegExp(
-  `unit (file )?${SYSTEMD_UNIT.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} (not loaded|does not exist|not found|could not be found)`,
-  "i"
-);
-function notLoaded2(output) {
-  return NOT_LOADED2.test(output);
-}
-function readLinger(host) {
-  const res = host.run("loginctl", ["show-user", String(host.uid), "-p", "Linger"]);
-  if (!res.ok) return "unknown";
-  const match = /Linger=(\w+)/.exec(res.stdout);
-  if (!match) return "unknown";
-  return match[1] === "yes" ? "yes" : "no";
-}
-function tryEnableLinger(host) {
-  host.run("loginctl", ["enable-linger", String(host.uid)]);
-  return readLinger(host);
-}
-function isRemoteSession(env) {
-  return Boolean(env.SSH_CONNECTION || env.SSH_TTY || env.SSH_CLIENT);
-}
-function quote(value) {
-  return `"${value.replace(/(["\\])/g, "\\$1")}"`;
-}
-function firstLine2(s) {
-  return s.trim().split("\n")[0] ?? "";
-}
-
-// src/service/index.ts
-function detectServiceManager(host = defaultServiceHost()) {
-  if (host.platform === "darwin") return "launchd";
-  if (host.platform !== "linux") return "none";
-  return host.run("systemctl", ["--user", "show-environment"]).ok ? "systemd-user" : "none";
-}
-function programArguments(host, _opts) {
-  return [host.execPath, host.cliPath, "start", "--foreground"];
-}
-function environment(host) {
-  return {
-    // PATH CAPTURE. launchd's default PATH is `/usr/bin:/bin:/usr/sbin:/sbin`
-    // and a systemd user manager's is barely better — neither has `claude`,
-    // `codex` or `opencode` on it. A companion that runs but can't find its
-    // harness is worse than one that isn't running, because the device reads
-    // Online. So we bake in the PATH of the shell that ran `start`, and because
-    // it's part of the rendered content, a PATH that later drifts re-renders on
-    // the next `start` like any other change.
-    PATH: host.env.PATH ?? "",
-    CABANE_COMPANION_DAEMON: "1"
-  };
-}
-function unitPathFor(host, manager) {
-  if (manager === "launchd") return launchAgentPath(host.home);
-  if (manager === "systemd-user") return systemdUnitPath(host);
-  return null;
-}
-function renderFor(host, manager, opts) {
-  const input = { programArguments: programArguments(host, opts), environment: environment(host) };
-  return manager === "launchd" ? renderPlist({ ...input, logPath: host.logPath }) : renderUnit(input);
-}
-function installService(opts = {}, host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  if (manager === "none") return { installed: false, reason: "unsupported" };
-  const path = unitPathFor(host, manager);
-  if (!path) return { installed: false, reason: "unsupported" };
-  const desired = renderFor(host, manager, opts);
-  const existing = host.fs.read(path);
-  const hadUnit = existing !== null;
-  const changed = existing !== desired;
-  if (changed) {
-    host.fs.mkdirp(dirname5(path));
-    host.fs.write(path, desired);
-  }
-  if (manager === "systemd-user") {
-    const linger = ensureLinger(host);
-    if (linger !== "yes" && isRemoteSession(host.env)) {
-      systemdRemove(host, path);
-      return failedInstall(
-        host,
-        manager,
-        "linger-unavailable",
-        "a systemd --user service would stop when this SSH session ends (lingering is off and could not be enabled)"
-      );
-    }
-  }
-  const started = manager === "launchd" ? launchdStart(host, path) : systemdStart(host);
-  if (!started.ok) {
-    if (!hadUnit) removeService(host, manager, path);
-    return failedInstall(host, manager, "command-failed", started.detail);
-  }
-  return { installed: true, manager, changed };
-}
-function failedInstall(host, manager, reason, detail) {
-  return {
-    installed: false,
-    reason,
-    ...detail ? { detail } : {},
-    ...managerOwnership(host, manager) === "clear" ? {} : { leftBehind: manager }
-  };
-}
-function managerProbe(host, manager) {
-  if (manager === "launchd") return launchdProbe(host);
-  if (manager === "systemd-user") return systemdProbe(host);
-  return { ownership: "clear", running: false };
-}
-function managerOwnership(host, manager) {
-  return managerProbe(host, manager).ownership;
-}
-function refreshInstalledService(opts = {}, host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  const path = unitPathFor(host, manager);
-  if (!path || !host.fs.exists(path)) return false;
-  const desired = renderFor(host, manager, opts);
-  if (host.fs.read(path) === desired) return false;
-  host.fs.write(path, desired);
-  if (manager === "systemd-user") systemdReload(host);
-  return true;
-}
-function stopService(host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  const path = unitPathFor(host, manager);
-  if (manager === "none" || !path || !managerHasClaim(host, manager, path)) {
-    return { handled: false, ok: true };
-  }
-  const res = manager === "launchd" ? launchdStop(host) : systemdStop(host);
-  return {
-    handled: true,
-    ok: res.ok,
-    manager,
-    ...res.detail ? { detail: res.detail } : {}
-  };
-}
-function disableService(host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  const path = unitPathFor(host, manager);
-  if (manager === "none" || !path) return { handled: false, ok: true };
-  if (!managerHasClaim(host, manager, path)) return { handled: false, ok: true, manager };
-  const res = removeService(host, manager, path);
-  return { handled: true, ok: res.ok, manager, ...res.detail ? { detail: res.detail } : {} };
-}
-function managerHasClaim(host, manager, path) {
-  if (manager === "none") return false;
-  if (host.fs.exists(path)) return true;
-  if (manager === "systemd-user" && systemdInstalled(host)) return true;
-  return managerOwnership(host, manager) !== "clear";
-}
-function removeService(host, manager, path) {
-  return manager === "launchd" ? launchdRemove(host, path) : systemdRemove(host, path);
-}
-function serviceStatus(host = defaultServiceHost()) {
-  const manager = detectServiceManager(host);
-  const path = unitPathFor(host, manager);
-  const probe = managerProbe(host, manager);
-  const installed = manager === "none" || !path ? false : host.fs.exists(path) || probe.ownership === "held" || manager === "systemd-user" && systemdInstalled(host);
-  const running = manager === "none" ? false : probe.running;
-  return {
-    manager,
-    unitPath: path,
-    installed,
-    running,
-    linger: manager === "systemd-user" ? readLinger(host) : null,
-    remoteSession: isRemoteSession(host.env)
-  };
-}
-function ensureLinger(host) {
-  const current = readLinger(host);
-  if (current === "yes") return current;
-  return tryEnableLinger(host);
-}
-
-// src/commands/service.ts
-function serviceStatusCommand(deps = {}) {
-  const status2 = (deps.status ?? serviceStatus)();
-  if (status2.manager === "none") {
-    process.stdout.write(
-      "service:  not supported on this machine yet \u2014 `cabane-companion start` runs the companion detached instead (it stops at the next reboot).\n"
-    );
-    return;
-  }
-  process.stdout.write(`manager:   ${status2.manager}
-`);
-  process.stdout.write(
-    `unit:      ${status2.unitPath}${status2.installed ? "" : " (not written)"}
-`
-  );
-  process.stdout.write(`installed: ${status2.installed ? "yes" : "no"}
-`);
-  process.stdout.write(`running:   ${runningLine(status2.running)}
-`);
-  if (status2.manager === "systemd-user") {
-    process.stdout.write(`linger:    ${status2.linger}${lingerNote(status2)}
-`);
-  }
-  if (status2.installed) {
-    process.stdout.write("disable:   cabane-companion service disable\n");
-  } else {
-    process.stdout.write("install:   cabane-companion start (installs it for you)\n");
-  }
-}
-function serviceDisableCommand(deps = {}) {
-  const disable = deps.disable ?? disableService;
-  const res = disable();
-  if (!res.handled) {
-    process.stdout.write("service:  nothing installed (nothing to remove).\n");
-    return;
-  }
-  if (!res.ok) {
-    process.stdout.write(
-      `service:  nothing was removed \u2014 ${res.detail ?? "the service manager reported an error"}.
-The unit is still installed and may still be running; \`cabane-companion service status\` shows where it stands.
-`
-    );
-    process.exitCode = 1;
-    return;
-  }
-  process.stdout.write(
-    "service:  stopped and removed. The companion no longer starts at login; `cabane-companion start` sets it up again.\n"
-  );
-}
-function runningLine(running) {
-  if (running === "transitional") {
-    return "starting or stopping \u2014 the manager reported a state in transition; ask again in a moment";
+    });
   }
-  if (running === "unknown") return "unknown \u2014 the service manager didn't answer";
-  return running ? "yes" : "no";
+  streams.push({
+    level: "debug",
+    stream: destinations.file ?? createWriteStream(path, { flags: "a" })
+  });
+  return pino({ level: "debug" }, pino.multistream(streams));
 }
-function lingerNote(status2) {
-  if (status2.linger === "yes") return " (survives logout)";
-  if (status2.remoteSession) {
-    return " \u2014 without lingering a --user service stops when this SSH session ends";
-  }
-  return " \u2014 the service runs while you are logged in";
+function getLogger() {
+  if (cached) return cached;
+  cached = createLogger();
+  return cached;
 }
 
-// src/commands/start.ts
-import { hostname as hostname2 } from "os";
-
 // src/runtime.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/dashboard/server.ts
-import { dirname as dirname6, join as join9 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname4, join as join7 } from "path";
+import { fileURLToPath } from "url";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 
 // src/dashboard/routes.ts
-import { openSync as openSync2, readSync, closeSync as closeSync2, fstatSync, existsSync as existsSync7 } from "fs";
+import { openSync as openSync2, readSync, closeSync as closeSync2, fstatSync, existsSync as existsSync5 } from "fs";
 import { readFile } from "fs/promises";
-import { extname, join as join8, normalize } from "path";
+import { extname, join as join6, normalize } from "path";
 import { streamSSE } from "hono/streaming";
 
 // src/state.ts
@@ -2407,14 +1997,14 @@ var CONTENT_TYPES = {
 function registerRoutes(app, deps) {
   const { supervisor, hub, staticDir } = deps;
   app.get("/", async (c) => {
-    const html = await readFile(join8(staticDir, "index.html"), "utf8");
+    const html = await readFile(join6(staticDir, "index.html"), "utf8");
     return c.html(html);
   });
   app.get("/static/:file", async (c) => {
     const file = c.req.param("file");
     const safe3 = normalize(file).replace(/^(\.\.[/\\])+/, "");
-    const full = join8(staticDir, safe3);
-    if (!full.startsWith(staticDir) || !existsSync7(full)) return c.notFound();
+    const full = join6(staticDir, safe3);
+    if (!full.startsWith(staticDir) || !existsSync5(full)) return c.notFound();
     const body = await readFile(full);
     const type = CONTENT_TYPES[extname(full).toLowerCase()] ?? "application/octet-stream";
     c.header("content-type", type);
@@ -2541,7 +2131,7 @@ function clampLimit(raw, fallback, max = 200) {
   return Math.min(Math.floor(n), max);
 }
 function tailFile(path, lines) {
-  if (!existsSync7(path)) return [];
+  if (!existsSync5(path)) return [];
   const MAX_BYTES = 256 * 1024;
   let fd;
   try {
@@ -2630,7 +2220,7 @@ function isAddrInUse(err) {
   return Boolean(err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE");
 }
 function resolveStaticDir() {
-  return join9(dirname6(fileURLToPath2(import.meta.url)), "static");
+  return join7(dirname4(fileURLToPath(import.meta.url)), "static");
 }
 
 // src/api.ts
@@ -3106,21 +2696,21 @@ function errorMessage2(status2, body) {
 }
 
 // src/cursor.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync8 } from "fs";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "fs";
+import { join as join8 } from "path";
 function pathFor(workspaceId) {
-  return join10(cabaneDir(), "cursors", encodeURIComponent(workspaceId));
+  return join8(cabaneDir(), "cursors", encodeURIComponent(workspaceId));
 }
 function readCursor(workspaceId) {
   const path = pathFor(workspaceId);
-  if (!existsSync8(path)) return null;
-  const raw = readFileSync5(path, "utf8").trim();
+  if (!existsSync6(path)) return null;
+  const raw = readFileSync4(path, "utf8").trim();
   return raw.length > 0 ? raw : null;
 }
 function writeCursor(workspaceId, eventId) {
   const path = pathFor(workspaceId);
-  mkdirSync7(join10(cabaneDir(), "cursors"), { recursive: true });
-  writeFileSync5(path, eventId + "\n", "utf8");
+  mkdirSync6(join8(cabaneDir(), "cursors"), { recursive: true });
+  writeFileSync4(path, eventId + "\n", "utf8");
 }
 
 // src/cursor-tracker.ts
@@ -3163,20 +2753,20 @@ var CursorTracker = class {
 };
 
 // src/dispatch-dedupe.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync9 } from "fs";
-import { join as join11 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
+import { join as join9 } from "path";
 var MAX_IDS = 256;
 function dir(log) {
-  return join11(cabaneDir(), log);
+  return join9(cabaneDir(), log);
 }
 function pathFor2(log, workspaceId) {
-  return join11(dir(log), encodeURIComponent(workspaceId));
+  return join9(dir(log), encodeURIComponent(workspaceId));
 }
 function readIds(log, workspaceId) {
   const path = pathFor2(log, workspaceId);
-  if (!existsSync9(path)) return [];
+  if (!existsSync7(path)) return [];
   try {
-    return readFileSync6(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+    return readFileSync5(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
   } catch {
     return [];
   }
@@ -3189,8 +2779,8 @@ function mark(log, workspaceId, eventId) {
   if (ids.includes(eventId)) return;
   ids.push(eventId);
   const trimmed = ids.length > MAX_IDS ? ids.slice(-MAX_IDS) : ids;
-  mkdirSync8(dir(log), { recursive: true });
-  writeFileSync6(pathFor2(log, workspaceId), trimmed.join("\n") + "\n", "utf8");
+  mkdirSync7(dir(log), { recursive: true });
+  writeFileSync5(pathFor2(log, workspaceId), trimmed.join("\n") + "\n", "utf8");
 }
 function hasDispatched(workspaceId, eventId) {
   return has("dispatched", workspaceId, eventId);
@@ -3206,17 +2796,17 @@ function markCompleted(workspaceId, eventId) {
 }
 var MAX_RESUME_ATTEMPTS = 3;
 function resumeDir() {
-  return join11(cabaneDir(), "resume-attempts");
+  return join9(cabaneDir(), "resume-attempts");
 }
 function resumePathFor(workspaceId) {
-  return join11(resumeDir(), encodeURIComponent(workspaceId));
+  return join9(resumeDir(), encodeURIComponent(workspaceId));
 }
 function readResumeCounts(workspaceId) {
   const out = /* @__PURE__ */ new Map();
   const path = resumePathFor(workspaceId);
-  if (!existsSync9(path)) return out;
+  if (!existsSync7(path)) return out;
   try {
-    for (const line of readFileSync6(path, "utf8").split("\n")) {
+    for (const line of readFileSync5(path, "utf8").split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
       const tab = trimmed.lastIndexOf("	");
@@ -3236,8 +2826,8 @@ function bumpResumeAttempt(workspaceId, eventId) {
   counts.set(eventId, next);
   const entries = [...counts.entries()];
   const trimmed = entries.length > MAX_IDS ? entries.slice(-MAX_IDS) : entries;
-  mkdirSync8(resumeDir(), { recursive: true });
-  writeFileSync6(
+  mkdirSync7(resumeDir(), { recursive: true });
+  writeFileSync5(
     resumePathFor(workspaceId),
     trimmed.map(([id, c]) => `${id}	${c}`).join("\n") + "\n",
     "utf8"
@@ -6935,8 +6525,8 @@ var ConnectorHealthStore = class {
 
 // src/dispatcher.ts
 import { randomUUID } from "crypto";
-import { appendFileSync as appendFileSync2, existsSync as existsSync12, mkdirSync as mkdirSync11, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join16 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync10, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join14 } from "path";
 
 // src/summon.ts
 import { z as z12 } from "zod";
@@ -7269,11 +6859,11 @@ function trimSlash2(s) {
 // src/codex-instructions.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join12 } from "path";
+import { join as join10 } from "path";
 var PREFIX = "cabane-codex-instructions-";
 async function writeCodexInstructionsFile(contents) {
-  const dir2 = await mkdtemp(join12(tmpdir(), PREFIX));
-  const path = join12(dir2, "instructions.md");
+  const dir2 = await mkdtemp(join10(tmpdir(), PREFIX));
+  const path = join10(dir2, "instructions.md");
   await writeFile(path, contents, { encoding: "utf8", mode: 384 });
   return {
     path,
@@ -7284,22 +6874,22 @@ async function writeCodexInstructionsFile(contents) {
 }
 
 // src/prepared.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync7, existsSync as existsSync10 } from "fs";
-import { join as join13 } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, rmSync as rmSync5, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
+import { join as join11 } from "path";
 function dirFor(workspaceId) {
-  return join13(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
+  return join11(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
 }
 function conversationDir(workspaceId, conversationId) {
-  return join13(dirFor(workspaceId), encodeURIComponent(conversationId));
+  return join11(dirFor(workspaceId), encodeURIComponent(conversationId));
 }
 function pathFor3(workspaceId, conversationId, agentId) {
-  return join13(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
+  return join11(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
 }
 function readPrepared(workspaceId, conversationId, agentId) {
   const path = pathFor3(workspaceId, conversationId, agentId);
-  if (!existsSync10(path)) return null;
+  if (!existsSync8(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync7(path, "utf8"));
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
     if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
       return {
         cwd: parsed.cwd,
@@ -7312,32 +6902,32 @@ function readPrepared(workspaceId, conversationId, agentId) {
   }
 }
 function writePrepared(workspaceId, conversationId, agentId, result) {
-  mkdirSync9(conversationDir(workspaceId, conversationId), { recursive: true });
-  writeFileSync7(
+  mkdirSync8(conversationDir(workspaceId, conversationId), { recursive: true });
+  writeFileSync6(
     pathFor3(workspaceId, conversationId, agentId),
     JSON.stringify(result) + "\n",
     "utf8"
   );
 }
 function clearPrepared(workspaceId, conversationId, agentId) {
-  rmSync6(pathFor3(workspaceId, conversationId, agentId), { force: true });
+  rmSync5(pathFor3(workspaceId, conversationId, agentId), { force: true });
 }
 
 // src/secrets.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join12 } from "path";
 import { z as z13 } from "zod";
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function secretsPath() {
-  return join14(cabaneDir(), "secrets.json");
+  return join12(cabaneDir(), "secrets.json");
 }
 var secretStoreSchema = z13.record(z13.string(), z13.string());
 function loadSecretStore() {
   const path = secretsPath();
-  if (!existsSync11(path)) return makeStore({});
+  if (!existsSync9(path)) return makeStore({});
   let raw;
   try {
-    raw = readFileSync8(path, "utf8");
+    raw = readFileSync7(path, "utf8");
   } catch (err) {
     throw new ConfigError(
       `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -7415,10 +7005,10 @@ function resolveMcpSecrets(mcpServers, store) {
 }
 
 // src/transcript-writer.ts
-import { appendFileSync, chmodSync as chmodSync3, mkdirSync as mkdirSync10, readdirSync, rmSync as rmSync7 } from "fs";
-import { join as join15 } from "path";
+import { appendFileSync, chmodSync as chmodSync3, mkdirSync as mkdirSync9, readdirSync, rmSync as rmSync6 } from "fs";
+import { join as join13 } from "path";
 function transcriptsDir() {
-  return join15(cabaneDir(), "transcripts");
+  return join13(cabaneDir(), "transcripts");
 }
 var RETAIN = 200;
 var TranscriptWriter = class {
@@ -7427,9 +7017,9 @@ var TranscriptWriter = class {
   onWarn;
   constructor(dir2, meta, onWarn) {
     this.onWarn = onWarn;
-    this.path = join15(dir2, fileName(meta));
+    this.path = join13(dir2, fileName(meta));
     try {
-      mkdirSync10(dir2, { recursive: true });
+      mkdirSync9(dir2, { recursive: true });
       try {
         chmodSync3(dir2, 448);
       } catch {
@@ -7486,7 +7076,7 @@ function pruneOld(dir2, retain) {
   const drop = files.sort().slice(0, files.length - retain);
   for (const f of drop) {
     try {
-      rmSync7(join15(dir2, f), { force: true });
+      rmSync6(join13(dir2, f), { force: true });
     } catch {
     }
   }
@@ -7609,9 +7199,9 @@ var TurnCommitter = class {
   // commit. A self-target is stripped here (mirror of the in-app self-strip); the
   // server strips it again and resolves / ignores an unknown id.
   summonField() {
-    const target2 = this.deps.summonState.agentId;
-    if (!target2 || target2 === this.deps.agentId) return {};
-    return { dispatch: target2 };
+    const target = this.deps.summonState.agentId;
+    if (!target || target === this.deps.agentId) return {};
+    return { dispatch: target };
   }
   // CT326: resolve the per-turn ask into the `ask` field for a `final` commit.
   // The server validates the target (must be a workspace member/owner) and
@@ -7832,7 +7422,7 @@ var DEFAULT_AGENT_IDLE_TIMEOUT_MS = 10 * 6e4;
 var DEFAULT_AGENT_TOTAL_TIMEOUT_MS = 6 * 60 * 6e4;
 function checkoutState(cwd) {
   if (!cwd) return { ok: false, reason: "no working directory was resolved for this turn" };
-  if (!existsSync12(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
+  if (!existsSync10(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
   let entries;
   try {
     entries = readdirSync2(cwd);
@@ -7842,15 +7432,15 @@ function checkoutState(cwd) {
   if (entries.length === 0) {
     return { ok: false, reason: `${cwd} is empty \u2014 a recreated shell, not a prepared directory` };
   }
-  const gitPath = join16(cwd, ".git");
-  if (!existsSync12(gitPath)) return { ok: true, reason: "usable" };
+  const gitPath = join14(cwd, ".git");
+  if (!existsSync10(gitPath)) return { ok: true, reason: "usable" };
   let stat;
   try {
     stat = statSync(gitPath);
   } catch (error) {
     return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
   }
-  if (stat.isDirectory() && !existsSync12(join16(gitPath, "HEAD")))
+  if (stat.isDirectory() && !existsSync10(join14(gitPath, "HEAD")))
     return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
   return { ok: true, reason: "usable" };
 }
@@ -8041,7 +7631,7 @@ var Dispatcher = class {
     let seqCounter = 0;
     const nextSeq = () => ++seqCounter;
     let effectiveCwd = localCwd ?? cabaneCwd;
-    if (effectiveCwd && !existsSync12(effectiveCwd)) {
+    if (effectiveCwd && !existsSync10(effectiveCwd)) {
       turnLog.warn(
         { cwd: effectiveCwd },
         "dispatcher: configured working directory does not exist on this device \u2014 falling back to the process cwd"
@@ -8305,11 +7895,11 @@ ${reason}`,
     const totalTimeoutMs = this.opts.totalTimeoutMs ?? DEFAULT_AGENT_TOTAL_TIMEOUT_MS;
     const closeTurnReceipt = (ok, reason) => {
       if (!turnReceiptPath) return;
-      const target2 = turnReceiptPath;
+      const target = turnReceiptPath;
       turnReceiptPath = null;
       try {
         appendFileSync2(
-          target2,
+          target,
           `${JSON.stringify({
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             event: "settled",
@@ -8349,7 +7939,7 @@ ${reason}`,
         }
         return this.concludeBeforeRun(payload, turnLog, startedAt, reason);
       }
-      const receiptPath = join16(effectiveCwd, ".git", "cabane", "readiness.jsonl");
+      const receiptPath = join14(effectiveCwd, ".git", "cabane", "readiness.jsonl");
       const receiptLine = (fields) => `${JSON.stringify({
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         taskId: hookEnv.CABANE_TASK_ID,
@@ -8373,7 +7963,7 @@ ${reason}`,
       })}
 `;
       try {
-        mkdirSync11(join16(effectiveCwd, ".git", "cabane"), { recursive: true });
+        mkdirSync10(join14(effectiveCwd, ".git", "cabane"), { recursive: true });
         appendFileSync2(
           receiptPath,
           // `starting` is the honest classification before the proof has run. The
@@ -8844,15 +8434,15 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
 
 // src/outbox.ts
 import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync11,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync8,
   renameSync as renameSync3,
-  rmSync as rmSync8,
-  writeFileSync as writeFileSync8
+  rmSync as rmSync7,
+  writeFileSync as writeFileSync7
 } from "fs";
-import { join as join17 } from "path";
+import { join as join15 } from "path";
 var MAX_ENTRIES = 2e3;
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var Outbox = class {
@@ -8865,25 +8455,25 @@ var Outbox = class {
   // Resolved lazily (per call, like cursor.ts) so tests that swap HOME between
   // cases route writes at the right tmpdir.
   dir() {
-    return join17(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
+    return join15(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
   }
   fileFor(turnId, seq) {
-    return join17(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+    return join15(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
   }
   // Persist a commit for later draining. Atomic (temp file + rename) so a
   // concurrent `list()` never reads a half-written entry, then enforces the
   // per-workspace bounds.
   persist(entry) {
     const dir2 = this.dir();
-    mkdirSync12(dir2, { recursive: true });
-    const target2 = this.fileFor(entry.turnId, entry.seq);
-    const tmp = `${target2}.${process.pid}.tmp`;
+    mkdirSync11(dir2, { recursive: true });
+    const target = this.fileFor(entry.turnId, entry.seq);
+    const tmp = `${target}.${process.pid}.tmp`;
     try {
-      writeFileSync8(tmp, JSON.stringify(entry) + "\n", "utf8");
-      renameSync3(tmp, target2);
+      writeFileSync7(tmp, JSON.stringify(entry) + "\n", "utf8");
+      renameSync3(tmp, target);
     } catch (err) {
       try {
-        rmSync8(tmp, { force: true });
+        rmSync7(tmp, { force: true });
       } catch {
       }
       this.log?.warn(
@@ -8900,7 +8490,7 @@ var Outbox = class {
   // wedging the drain.
   list() {
     const dir2 = this.dir();
-    if (!existsSync13(dir2)) return [];
+    if (!existsSync11(dir2)) return [];
     let names;
     try {
       names = readdirSync3(dir2);
@@ -8910,9 +8500,9 @@ var Outbox = class {
     const entries = [];
     for (const name of names) {
       if (!name.endsWith(".json")) continue;
-      const full = join17(dir2, name);
+      const full = join15(dir2, name);
       try {
-        const parsed = JSON.parse(readFileSync9(full, "utf8"));
+        const parsed = JSON.parse(readFileSync8(full, "utf8"));
         if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
           entries.push(parsed);
         } else {
@@ -8930,13 +8520,13 @@ var Outbox = class {
   // Remove a delivered (or terminally-discarded) entry. No-op if already gone.
   remove(turnId, seq) {
     try {
-      rmSync8(this.fileFor(turnId, seq), { force: true });
+      rmSync7(this.fileFor(turnId, seq), { force: true });
     } catch {
     }
   }
   size() {
     const dir2 = this.dir();
-    if (!existsSync13(dir2)) return 0;
+    if (!existsSync11(dir2)) return 0;
     try {
       return readdirSync3(dir2).filter((n) => n.endsWith(".json")).length;
     } catch {
@@ -8949,7 +8539,7 @@ var Outbox = class {
       "companion outbox: dropping unreadable entry"
     );
     try {
-      rmSync8(full, { force: true });
+      rmSync7(full, { force: true });
     } catch {
     }
   }
@@ -10111,22 +9701,22 @@ function handleUncaught(log, err, origin) {
 }
 
 // src/crash-marker.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync13, readFileSync as readFileSync10, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync12, readFileSync as readFileSync9, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
+import { join as join16 } from "path";
 function crashMarkerPath() {
-  return join18(cabaneDir(), "last-error.json");
+  return join16(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
-    mkdirSync13(cabaneDir(), { recursive: true });
-    writeFileSync9(crashMarkerPath(), JSON.stringify(rec2, null, 2) + "\n");
+    mkdirSync12(cabaneDir(), { recursive: true });
+    writeFileSync8(crashMarkerPath(), JSON.stringify(rec2, null, 2) + "\n");
   } catch {
   }
 }
 function clearCrash() {
   try {
     const path = crashMarkerPath();
-    if (existsSync14(path)) rmSync9(path, { force: true });
+    if (existsSync12(path)) rmSync8(path, { force: true });
   } catch {
   }
 }
@@ -10201,11 +9791,13 @@ async function createCompanionRuntime(opts = {}) {
   });
   await supervisor.start();
   const connectHarness = async (runtime, serverUrl) => {
+    const candidate = runtime === "opencode" ? { ...supervisor.currentConfig(), opencode: { serverUrl: serverUrl ?? "" } } : supervisor.currentConfig();
+    const verdict = await shakeOutHarness(runtime, candidate);
+    if (verdict === "absent") return { ok: false, error: absentLine(runtime) };
     const result = await supervisor.enableHarness(
       runtime === "opencode" ? { runtime: "opencode", serverUrl: serverUrl ?? "" } : { runtime }
     );
     if (!result.ok) return { ok: false, error: result.error };
-    const verdict = await shakeOutHarness(runtime, supervisor.currentConfig());
     return { ok: true, message: connectedLine(runtime, verdict) };
   };
   const control = await startControlServer({
@@ -10276,7 +9868,24 @@ async function closeSurfaces(control, dashboard) {
 
 // src/commands/daemon.ts
 import { spawn as spawn5 } from "child_process";
-import { closeSync as closeSync3, mkdirSync as mkdirSync14, openSync as openSync3 } from "fs";
+import { closeSync as closeSync3, mkdirSync as mkdirSync13, openSync as openSync3 } from "fs";
+
+// src/cli-entry.ts
+import { existsSync as existsSync13 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var RELATIVE_CANDIDATES = ["./cli.js", "../dist/cli.js", "../cli.js"];
+function companionCliEntry(deps = {}) {
+  const exists = deps.exists ?? existsSync13;
+  const candidates = deps.candidates ?? RELATIVE_CANDIDATES.map((rel) => fileURLToPath2(new URL(rel, import.meta.url)));
+  for (const candidate of candidates) {
+    if (exists(candidate)) return candidate;
+  }
+  const argv1 = "argv1" in deps ? deps.argv1 : process.argv[1];
+  if (argv1 && exists(argv1)) return argv1;
+  return candidates[0] ?? "";
+}
+
+// src/commands/daemon.ts
 var STARTUP_TIMEOUT_MS = 8e3;
 var POLL_INTERVAL_MS = 150;
 async function startDaemon(opts = {}, deps = {}) {
@@ -10286,11 +9895,6 @@ async function startDaemon(opts = {}, deps = {}) {
   const spawnDetached = deps.spawnDetached ?? defaultSpawnDetached;
   const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = deps.now ?? (() => Date.now());
-  const install = deps.installService ?? ((o) => installService(o));
-  const refresh = deps.refreshService ?? ((o) => refreshInstalledService(o));
-  const disable = deps.disableService ?? (() => disableService());
-  const isTty = deps.isTty ?? (() => Boolean(process.stdin.isTTY));
-  const serviceOpts = {};
   const quiet = opts.report === "failures";
   const { cfg, claudeOnPath: claudeOnPath2 } = await requireStartConfig({
     // Unset → `requireStartConfig`'s own `requireConfig`, the real one.
@@ -10318,22 +9922,16 @@ async function startDaemon(opts = {}, deps = {}) {
   const existing = readState();
   if (existing) {
     if (await verify(existing) !== "stale") {
-      const rerendered = isTty() ? refresh(serviceOpts) : false;
       process.stdout.write(
         `Cabane Companion is already running (pid ${existing.pid}).
 Stop it first with \`cabane-companion stop\` if you want to relaunch.
 Connect a harness to the running companion: cabane-companion connect claude-code
-` + (rerendered ? "Autostart: the login service was updated for this install \u2014 it takes effect at the next login, or now with `cabane-companion stop` then `start`.\n" : "")
+`
       );
-      return {
-        started: false,
-        service: { installed: false, reason: "unsupported" },
-        state: existing
-      };
+      return { started: false, state: existing };
     }
     clearRuntimeState();
   }
-  let service2 = isTty() ? install(serviceOpts) : { installed: false, reason: "unsupported" };
   const args = ["start", "--foreground"];
   const launchDetached = () => {
     const spawned = spawnDetached(args);
@@ -10350,29 +9948,8 @@ Connect a harness to the running companion: cabane-companion connect claude-code
     }
     return ready(seen) ? seen : null;
   };
-  if (!service2.installed && service2.leftBehind) {
-    refuseDouble(service2.leftBehind, service2.detail);
-    process.exitCode = 1;
-    return { started: false, service: service2, state: null };
-  }
-  let child = service2.installed ? null : launchDetached();
-  let state = await waitForReady();
-  if (!state && service2.installed) {
-    process.stdout.write(
-      `${service2.manager} started the companion but it didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s \u2014 removing the login service.
-`
-    );
-    const removed = disable();
-    if (!removed.handled || !removed.ok) {
-      refuseDouble(service2.manager, removed.detail);
-      process.exitCode = 1;
-      return { started: false, service: service2, state: null };
-    }
-    process.stdout.write("Launching it directly instead.\n");
-    service2 = { installed: false, reason: "command-failed", detail: "the service never came up" };
-    child = launchDetached();
-    state = await waitForReady();
-  }
+  const child = launchDetached();
+  const state = await waitForReady();
   if (!state) {
     process.stdout.write(
       `Cabane Companion was launched (pid ${child?.pid ?? "?"}) but didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.
@@ -10380,9 +9957,9 @@ Check ${companionLogPath()} for errors, or run \`cabane-companion status\`.
 `
     );
     process.exitCode = 1;
-    return { started: false, service: service2, state: null };
+    return { started: false, state: null };
   }
-  if (quiet) return { started: true, service: service2, state };
+  if (quiet) return { started: true, state };
   process.stdout.write(
     `Cabane Companion started in the background (pid ${state.pid}).
 Logs:    ${companionLogPath()}
@@ -10390,27 +9967,11 @@ Status:  cabane-companion status
 Stop:    cabane-companion stop
 `
   );
-  if (service2.installed) {
-    process.stdout.write(`Autostart: enabled (${service2.manager}) \u2014 it starts again at login.
-`);
-  } else if (service2.reason !== "unsupported") {
-    process.stdout.write(
-      `Autostart: not enabled \u2014 ${service2.detail ?? "the service manager refused the install"}. Running detached instead; it won't come back after a reboot.
-`
-    );
-  }
-  return { started: true, service: service2, state };
-}
-function refuseDouble(manager, detail) {
-  process.stdout.write(
-    `${manager} still has the login service${detail ? ` (${detail})` : ""} \u2014 not launching a second companion beside a service that may still own one.
-Check \`cabane-companion service status\`, then \`cabane-companion service disable\`, and run \`cabane-companion start --daemon\` again.
-`
-  );
+  return { started: true, state };
 }
 function defaultSpawnDetached(args) {
   const cliPath = companionCliEntry();
-  mkdirSync14(cabaneDir(), { recursive: true });
+  mkdirSync13(cabaneDir(), { recursive: true });
   const logFd = openSync3(companionLogPath(), "a");
   try {
     return spawn5(process.execPath, [cliPath, ...args], {
@@ -10430,6 +9991,15 @@ var DEPLOY_GRACE_MS = 6.5 * 60 * 60 * 1e3;
 var MAX_CODES = 3;
 async function start(opts = {}) {
   const interactive = isInteractive();
+  if (!interactive) return startScript(opts, false);
+  setConsoleLogging(false);
+  try {
+    await startScript(opts, true);
+  } finally {
+    setConsoleLogging(true);
+  }
+}
+async function startScript(opts, interactive) {
   const running = await liveCompanion();
   if (running) {
     reportAlreadyRunning(running.pid);
@@ -10439,7 +10009,9 @@ async function start(opts = {}) {
   let paired = null;
   if (!isDevicePaired()) {
     paired = await pairHere(opts, interactive);
-    if (!paired) return;
+    if (!paired) {
+      return;
+    }
     const { note } = writePairedConfig(paired);
     if (note) getLogger().warn({ note }, "companion: salvaged an older config on pairing");
   }
@@ -10470,6 +10042,7 @@ async function start(opts = {}) {
     write(`    Stop:  Ctrl-C                       Logs:  ${tildePath(companionLogPath())}`);
     blank();
     write(`${INDENT}Listening for messages\u2026`);
+    setConsoleLogging(true);
   } else {
     if (!offered.printedSomething) blank();
     write(
@@ -10619,11 +10192,7 @@ async function handOffToBackground(runtime, ctx) {
     return;
   }
   if (ctx.spaceAbove) blank();
-  write(
-    INDENT + tick(
-      outcome.service.installed ? "Cabane companion is running in the background, and will start again when you log in." : "Cabane companion is running in the background."
-    )
-  );
+  write(INDENT + tick("Cabane companion is running in the background."));
   write(`    Stop:  cabane-companion stop        Logs:  ${tildePath(companionLogPath())}`);
   if (ctx.justPaired) {
     blank();
@@ -10687,8 +10256,7 @@ companion: deploy drain requested (${graceMs}ms grace)\u2026
 
 // src/commands/status.ts
 import { readdirSync as readdirSync4 } from "fs";
-async function status(deps = {}) {
-  const readService = deps.service ?? serviceStatus;
+async function status() {
   const cfg = loadConfig();
   if (!cfg || !cfg.deviceToken) {
     process.stdout.write(
@@ -10724,13 +10292,6 @@ async function status(deps = {}) {
       "companion:       not running \u2014 `cabane-companion start` (backgrounds itself; `--foreground` stays attached)\n"
     );
   }
-  const svc = readService();
-  if (svc.installed) {
-    process.stdout.write(
-      `autostart:    ${svc.manager} \u2014 starts at login` + (svc.manager === "systemd-user" && svc.linger !== "yes" ? ", while you are logged in" : "") + ` (details: cabane-companion service status)
-`
-    );
-  }
   process.stdout.write(
     "agents:       pulled from cabane at runtime \u2014 see this device in Cabane for its assigned agents, their run state, and any missing-secret warnings.\n"
   );
@@ -10777,34 +10338,12 @@ function formatUptime(startedAt) {
 // src/commands/stop.ts
 var TERM_GRACE_MS = 6e3;
 var POLL_INTERVAL_MS2 = 150;
-var SERVICE_STOP_GRACE_MS = 3e3;
 async function stop(deps = {}) {
   const readState = deps.readState ?? readLiveRuntimeState;
   const verify = deps.verify ?? ((s) => verifyRuntime(s));
   const kill = deps.kill ?? ((pid2, signal) => process.kill(pid2, signal));
   const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = deps.now ?? (() => Date.now());
-  const stopSvc = deps.stopService ?? (() => stopService());
-  const svc = stopSvc();
-  if (svc.handled) {
-    if (!svc.ok) {
-      process.stdout.write(
-        `companion: ${svc.manager} wouldn't stop the service${svc.detail ? ` (${svc.detail})` : ""}.
-The service manager owns this process \u2014 stopping it directly would just be restarted.
-Check \`cabane-companion service status\`, or remove it with \`cabane-companion service disable\`.
-`
-      );
-      process.exitCode = 1;
-      return;
-    }
-    const deadline2 = now() + SERVICE_STOP_GRACE_MS;
-    while (readState() && now() < deadline2) await sleep4(POLL_INTERVAL_MS2);
-    if (!readState()) {
-      process.stdout.write(`companion: stopped (${svc.manager} service stopped).
-`);
-      return;
-    }
-  }
   const state = readState();
   if (!state) {
     process.stdout.write("companion: not running (nothing to stop).\n");
@@ -10854,8 +10393,8 @@ function isAlive(kill, pid) {
 }
 
 // src/commands/transcript.ts
-import { existsSync as existsSync15, readFileSync as readFileSync11, readdirSync as readdirSync5 } from "fs";
-import { isAbsolute, join as join19 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync10, readdirSync as readdirSync5 } from "fs";
+import { isAbsolute, join as join17 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -10872,7 +10411,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join19(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join17(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -10955,7 +10494,7 @@ function isComplete(content) {
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync11(join19(dir2, f), "utf8"),
+    read: (f) => readFileSync10(join17(dir2, f), "utf8"),
     write: (s) => process.stdout.write(s),
     // CSI: cursor up `n` lines, then erase from cursor to end of screen.
     clearLines: (n) => process.stdout.write(`\x1B[${n}A\x1B[0J`),
@@ -10995,7 +10534,7 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join19(dir2, f));
+    const { meta, outcome } = peek(join17(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
     const ws = str2(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
@@ -11016,7 +10555,7 @@ function peek(path) {
   let meta;
   let outcome;
   try {
-    for (const line of readFileSync11(path, "utf8").split("\n")) {
+    for (const line of readFileSync10(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       const o = safeParse(line);
       const t = str2(rec(o)?.type);
@@ -11027,29 +10566,29 @@ function peek(path) {
   }
   return { meta, outcome };
 }
-function resolveTarget(dir2, target2) {
-  if (isAbsolute(target2) || target2.includes("/")) {
-    if (existsSync15(target2)) return target2;
-    throw new CompanionError(`no transcript at ${target2}.`);
+function resolveTarget(dir2, target) {
+  if (isAbsolute(target) || target.includes("/")) {
+    if (existsSync14(target)) return target;
+    throw new CompanionError(`no transcript at ${target}.`);
   }
-  const exact = join19(dir2, target2);
-  if (existsSync15(exact)) return exact;
-  const matches = listFiles(dir2).filter((f) => f.includes(target2));
-  if (matches.length === 1) return join19(dir2, matches[0]);
+  const exact = join17(dir2, target);
+  if (existsSync14(exact)) return exact;
+  const matches = listFiles(dir2).filter((f) => f.includes(target));
+  if (matches.length === 1) return join17(dir2, matches[0]);
   if (matches.length === 0) {
     throw new CompanionError(
-      `no transcript matching "${target2}" in ${dir2}. Run \`cabane-companion transcript\` to list them.`
+      `no transcript matching "${target}" in ${dir2}. Run \`cabane-companion transcript\` to list them.`
     );
   }
   throw new CompanionError(
-    `"${target2}" matches ${matches.length} transcripts \u2014 be more specific:
+    `"${target}" matches ${matches.length} transcripts \u2014 be more specific:
 ` + matches.slice(0, 10).map((m) => `  ${m}`).join("\n")
   );
 }
 function renderFile(path) {
   let content;
   try {
-    content = readFileSync11(path, "utf8");
+    content = readFileSync10(path, "utf8");
   } catch (err) {
     throw new CompanionError(
       `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -11186,11 +10725,11 @@ program.command("pair").description(
   });
 });
 program.command("write-paired-config", { hidden: true }).description("persist an already-completed device enrollment payload from stdin.").action(() => {
-  writeCompletedPairing(readFileSync12(0, "utf8"));
+  writeCompletedPairing(readFileSync11(0, "utf8"));
 });
 program.command("start").description(
   "pair this device if needed, connect a coding agent on it, and run in the background."
-).option("--foreground", "run attached in this terminal (never installs the login service)").option("--daemon", "run in the background (the default; kept for compatibility)").option("--server <url>", "the cabane instance to pair with, if this device isn\u2019t paired yet").addOption(new Option("--open").hideHelp()).addOption(new Option("--no-open").hideHelp()).addOption(new Option("--port <port>").hideHelp()).action(async (opts) => {
+).option("--foreground", "run attached in this terminal (for terminals and supervisors)").option("--daemon", "run in the background (the default; kept for compatibility)").option("--server <url>", "the cabane instance to pair with, if this device isn\u2019t paired yet").addOption(new Option("--open").hideHelp()).addOption(new Option("--no-open").hideHelp()).addOption(new Option("--port <port>").hideHelp()).action(async (opts) => {
   await start({
     ...opts.foreground ? { foreground: true } : {},
     ...opts.server !== void 0 ? { server: opts.server } : {}
@@ -11205,13 +10744,6 @@ program.command("stop").description("stop a running companion (SIGTERM, then for
 program.command("status").description("print the companion's local state (pairing, secrets, log path).").action(async () => {
   await status();
 });
-var service = program.command("service").description("inspect or remove the login service that starts the companion when you log in.");
-service.command("status").description("print the service manager, whether the unit is installed and running.").action(() => {
-  serviceStatusCommand();
-});
-service.command("disable").description("stop the companion and remove the login service, leaving the machine clean.").action(() => {
-  serviceDisableCommand();
-});
 program.command("transcript").description("show the full agent transcript for a recent dispatch (the agent's whole turn).").argument("[file]", "a transcript filename or substring; omit to list recent transcripts").option("--last", "render the most recent transcript").option("-f, --follow", "watch for new turns and live-render them as they land (Ctrl-C to stop)").action(async (file, opts) => {
   await transcript({
     ...file !== void 0 ? { target: file } : {},
@@ -11242,7 +10774,12 @@ program.parseAsync(process.argv).catch((err) => {
     process.exitCode = 130;
     return;
   }
-  process.stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}
+  setConsoleLogging(false);
+  try {
+    getLogger().error({ err }, "companion: command failed");
+  } catch {
+  }
+  process.stderr.write(`${err instanceof Error ? err.message : String(err)}
 `);
   process.exitCode = 1;
 });