@cabane/companion 0.6.25 → 0.6.27

package/dist/cli.js

@@ -5,8 +5,22 @@ import { Command } from "commander";
 
 // src/commands/daemon.ts
 import { spawn as spawn4 } from "child_process";
-import { closeSync as closeSync2, mkdirSync as mkdirSync4, openSync as openSync2 } from "fs";
+import { closeSync as closeSync2, mkdirSync as mkdirSync5, openSync as openSync2 } from "fs";
+
+// src/cli-entry.ts
+import { existsSync } from "fs";
 import { fileURLToPath } from "url";
+var RELATIVE_CANDIDATES = ["./cli.js", "../dist/cli.js", "../cli.js"];
+function companionCliEntry(deps = {}) {
+  const exists = deps.exists ?? existsSync;
+  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/config.ts
 import {
@@ -16,7 +30,7 @@ import {
   renameSync,
   rmSync,
   writeFileSync,
-  existsSync
+  existsSync as existsSync2
 } from "fs";
 import { homedir, userInfo } from "os";
 import { dirname, join } from "path";
@@ -362,7 +376,7 @@ function localAgentConfig(cfg, agent) {
 }
 function loadConfig() {
   const path = configPath();
-  if (!existsSync(path)) return null;
+  if (!existsSync2(path)) return null;
   let raw;
   try {
     raw = readFileSync(path, "utf8");
@@ -398,7 +412,7 @@ function loadConfigTolerant() {
   const path = configPath();
   const empty = {};
   const fresh = { local: empty, note: null, hadPriorConfig: false };
-  if (!existsSync(path)) return fresh;
+  if (!existsSync2(path)) return fresh;
   let raw;
   try {
     raw = readFileSync(path, "utf8");
@@ -485,7 +499,7 @@ function requireConfig() {
 }
 function deleteConfig() {
   const path = configPath();
-  if (existsSync(path)) {
+  if (existsSync2(path)) {
     writeFileSync(path, "", { mode: 384 });
   }
 }
@@ -692,7 +706,7 @@ async function warnAboutHarnessReadiness(cfg, deps = {}) {
 
 // src/runtime-file.ts
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   readFileSync as readFileSync2,
   rmSync as rmSync2,
   writeFileSync as writeFileSync2,
@@ -732,11 +746,11 @@ function acquireRuntimeState(state) {
 }
 function clearRuntimeState() {
   const path = runtimePath();
-  if (existsSync2(path)) rmSync2(path, { force: true });
+  if (existsSync3(path)) rmSync2(path, { force: true });
 }
 function readLiveRuntimeState() {
   const path = runtimePath();
-  if (!existsSync2(path)) return null;
+  if (!existsSync3(path)) return null;
   let parsed;
   try {
     parsed = JSON.parse(readFileSync2(path, "utf8"));
@@ -780,6 +794,383 @@ function trimSlash(s) {
   return s.endsWith("/") ? s.slice(0, -1) : s;
 }
 
+// src/service/index.ts
+import { dirname as dirname4 } from "path";
+
+// src/service/host.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+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: homedir2(),
+    uid: process.getuid?.() ?? 0,
+    execPath: process.execPath,
+    cliPath: companionCliEntry(),
+    logPath: companionLogPath(),
+    fs: {
+      read: (path) => {
+        try {
+          return readFileSync3(path, "utf8");
+        } catch {
+          return null;
+        }
+      },
+      write: (path, contents) => writeFileSync3(path, contents, "utf8"),
+      remove: (path) => rmSync3(path, { force: true }),
+      exists: (path) => existsSync4(path),
+      mkdirp: (dir2) => {
+        mkdirSync4(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 join4 } from "path";
+var LAUNCHD_LABEL = "ai.cabane.companion";
+function launchAgentPath(home) {
+  return join4(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 dirname3, join as join5 } 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() : join5(host.home, ".config");
+  return join5(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 join5(dirname3(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) {
+  const args = [host.execPath, host.cliPath, "start", "--foreground", "--no-open"];
+  if (opts.port !== void 0) args.push("--port", String(opts.port));
+  return args;
+}
+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(dirname4(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/daemon.ts
 var STARTUP_TIMEOUT_MS = 8e3;
 var POLL_INTERVAL_MS = 150;
@@ -790,6 +1181,11 @@ 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 = opts.port !== void 0 ? { port: opts.port } : {};
   const { cfg, claudeOnPath: claudeOnPath2 } = await requireStartConfig({
     // Unset → `requireStartConfig`'s own `requireConfig`, the real one.
     ...deps.requireCfg ? { requireCfg: deps.requireCfg } : {},
@@ -809,30 +1205,61 @@ 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}).
 \u2192 Dashboard: ${existing.url}
 Stop it first with \`cabane-companion stop\` if you want to relaunch.
-`
+` + (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;
     }
     clearRuntimeState();
   }
+  let service2 = isTty() ? install(serviceOpts) : { installed: false, reason: "unsupported" };
   const args = ["start", "--no-open"];
   if (opts.port !== void 0) args.push("--port", String(opts.port));
-  const child = spawnDetached(args);
-  child.unref();
+  const launchDetached = () => {
+    const spawned = spawnDetached(args);
+    spawned.unref();
+    return spawned;
+  };
   const ready = (s) => !!s && !!s.url;
-  const deadline = now() + STARTUP_TIMEOUT_MS;
-  let state = readState();
-  while (!ready(state) && now() < deadline) {
-    await sleep4(POLL_INTERVAL_MS);
-    state = readState();
+  const waitForReady = async () => {
+    const deadline = now() + STARTUP_TIMEOUT_MS;
+    let seen = readState();
+    while (!ready(seen) && now() < deadline) {
+      await sleep4(POLL_INTERVAL_MS);
+      seen = readState();
+    }
+    return ready(seen) ? seen : null;
+  };
+  if (!service2.installed && service2.leftBehind) {
+    refuseDouble(service2.leftBehind, service2.detail);
+    process.exitCode = 1;
+    return;
   }
-  if (!ready(state)) {
+  let child = service2.installed ? null : launchDetached();
+  let state = await waitForReady();
+  if (!state && service2.installed) {
     process.stdout.write(
-      `Cabane Companion was launched (pid ${child.pid ?? "?"}) but didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.
+      `${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;
+    }
+    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();
+  }
+  if (!state) {
+    process.stdout.write(
+      `Cabane Companion was launched (pid ${child?.pid ?? "?"}) but didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.
 Check ${companionLogPath()} for errors, or run \`cabane-companion status\`.
 `
     );
@@ -845,12 +1272,28 @@ Check ${companionLogPath()} for errors, or run \`cabane-companion status\`.
 Logs:    ${companionLogPath()}
 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.
+`
+    );
+  }
+}
+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.
 `
   );
 }
 function defaultSpawnDetached(args) {
-  const cliPath = fileURLToPath(new URL("../cli.js", import.meta.url));
-  mkdirSync4(cabaneDir(), { recursive: true });
+  const cliPath = companionCliEntry();
+  mkdirSync5(cabaneDir(), { recursive: true });
   const logFd = openSync2(companionLogPath(), "a");
   try {
     return spawn4(process.execPath, [cliPath, ...args], {
@@ -869,25 +1312,25 @@ import { confirm } from "@inquirer/prompts";
 // src/credentials.ts
 import {
   chmodSync as chmodSync2,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync3,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync4,
   renameSync as renameSync2,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync3
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname5, join as join6 } from "path";
 import { z as z3 } from "zod";
 function credentialsPath() {
-  return join4(cabaneDir(), "credentials.json");
+  return join6(cabaneDir(), "credentials.json");
 }
 var credentialStoreSchema = z3.record(z3.string(), z3.string());
 function load() {
   const path = credentialsPath();
-  if (!existsSync3(path)) return {};
+  if (!existsSync5(path)) return {};
   let raw;
   try {
-    raw = readFileSync3(path, "utf8");
+    raw = readFileSync4(path, "utf8");
   } catch {
     return {};
   }
@@ -901,14 +1344,14 @@ function load() {
 }
 function save(map) {
   const path = credentialsPath();
-  mkdirSync5(dirname3(path), { recursive: true });
+  mkdirSync6(dirname5(path), { recursive: true });
   try {
     chmodSync2(cabaneDir(), 448);
   } catch {
   }
   const tmp = `${path}.${process.pid}.tmp`;
   try {
-    writeFileSync3(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
+    writeFileSync4(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
     try {
       chmodSync2(tmp, 384);
     } catch {
@@ -916,7 +1359,7 @@ function save(map) {
     renameSync2(tmp, path);
   } catch (err) {
     try {
-      rmSync3(tmp, { force: true });
+      rmSync4(tmp, { force: true });
     } catch {
     }
     throw err;
@@ -946,7 +1389,7 @@ function pruneCredentials(keepAgentIds) {
 }
 function clearCredentials() {
   const path = credentialsPath();
-  if (existsSync3(path)) writeFileSync3(path, "", { mode: 384 });
+  if (existsSync5(path)) writeFileSync4(path, "", { mode: 384 });
 }
 
 // src/commands/logout.ts
@@ -1132,7 +1575,71 @@ async function pair(opts = {}) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
+
+// src/commands/service.ts
+function serviceStatusCommand(deps = {}) {
+  const status2 = (deps.status ?? serviceStatus)();
+  if (status2.manager === "none") {
+    process.stdout.write(
+      "service:  not supported on this machine yet \u2014 `cabane-companion start` runs the companion detached instead (it stops at the next reboot).\n"
+    );
+    return;
+  }
+  process.stdout.write(`manager:   ${status2.manager}
+`);
+  process.stdout.write(
+    `unit:      ${status2.unitPath}${status2.installed ? "" : " (not written)"}
+`
+  );
+  process.stdout.write(`installed: ${status2.installed ? "yes" : "no"}
+`);
+  process.stdout.write(`running:   ${runningLine(status2.running)}
+`);
+  if (status2.manager === "systemd-user") {
+    process.stdout.write(`linger:    ${status2.linger}${lingerNote(status2)}
+`);
+  }
+  if (status2.installed) {
+    process.stdout.write("disable:   cabane-companion service disable\n");
+  } else {
+    process.stdout.write("install:   cabane-companion start (installs it for you)\n");
+  }
+}
+function serviceDisableCommand(deps = {}) {
+  const disable = deps.disable ?? disableService;
+  const res = disable();
+  if (!res.handled) {
+    process.stdout.write("service:  nothing installed (nothing to remove).\n");
+    return;
+  }
+  if (!res.ok) {
+    process.stdout.write(
+      `service:  nothing was removed \u2014 ${res.detail ?? "the service manager reported an error"}.
+The unit is still installed and may still be running; \`cabane-companion service status\` shows where it stands.
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(
+    "service:  stopped and removed. The companion no longer starts at login; `cabane-companion start` sets it up again.\n"
+  );
+}
+function runningLine(running) {
+  if (running === "transitional") {
+    return "starting or stopping \u2014 the manager reported a state in transition; ask again in a moment";
+  }
+  if (running === "unknown") return "unknown \u2014 the service manager didn't answer";
+  return running ? "yes" : "no";
+}
+function lingerNote(status2) {
+  if (status2.linger === "yes") return " (survives logout)";
+  if (status2.remoteSession) {
+    return " \u2014 without lingering a --user service stops when this SSH session ends";
+  }
+  return " \u2014 the service runs while you are logged in";
+}
 
 // src/browser.ts
 import { spawn as spawn5 } from "child_process";
@@ -1169,15 +1676,15 @@ function shouldAutoOpen(opts) {
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/dashboard/server.ts
-import { dirname as dirname4, join as join6 } from "path";
+import { dirname as dirname6, join as join8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 
 // src/dashboard/routes.ts
-import { openSync as openSync3, readSync, closeSync as closeSync3, fstatSync, existsSync as existsSync4 } from "fs";
+import { openSync as openSync3, readSync, closeSync as closeSync3, fstatSync, existsSync as existsSync6 } from "fs";
 import { readFile } from "fs/promises";
-import { extname, join as join5, normalize } from "path";
+import { extname, join as join7, normalize } from "path";
 import { streamSSE } from "hono/streaming";
 
 // src/state.ts
@@ -1426,14 +1933,14 @@ var CONTENT_TYPES = {
 function registerRoutes(app, deps) {
   const { supervisor, hub, staticDir } = deps;
   app.get("/", async (c) => {
-    const html = await readFile(join5(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 safe3 = normalize(file).replace(/^(\.\.[/\\])+/, "");
-    const full = join5(staticDir, safe3);
-    if (!full.startsWith(staticDir) || !existsSync4(full)) return c.notFound();
+    const full = join7(staticDir, safe3);
+    if (!full.startsWith(staticDir) || !existsSync6(full)) return c.notFound();
     const body = await readFile(full);
     const type = CONTENT_TYPES[extname(full).toLowerCase()] ?? "application/octet-stream";
     c.header("content-type", type);
@@ -1560,7 +2067,7 @@ function clampLimit(raw, fallback, max = 200) {
   return Math.min(Math.floor(n), max);
 }
 function tailFile(path, lines) {
-  if (!existsSync4(path)) return [];
+  if (!existsSync6(path)) return [];
   const MAX_BYTES = 256 * 1024;
   let fd;
   try {
@@ -1649,7 +2156,7 @@ function isAddrInUse(err) {
   return Boolean(err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE");
 }
 function resolveStaticDir() {
-  return join6(dirname4(fileURLToPath2(import.meta.url)), "static");
+  return join8(dirname6(fileURLToPath2(import.meta.url)), "static");
 }
 
 // src/api.ts
@@ -2125,21 +2632,21 @@ function errorMessage2(status2, body) {
 }
 
 // src/cursor.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync5 } from "fs";
-import { join as join7 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
+import { join as join9 } from "path";
 function pathFor(workspaceId) {
-  return join7(cabaneDir(), "cursors", encodeURIComponent(workspaceId));
+  return join9(cabaneDir(), "cursors", encodeURIComponent(workspaceId));
 }
 function readCursor(workspaceId) {
   const path = pathFor(workspaceId);
-  if (!existsSync5(path)) return null;
-  const raw = readFileSync4(path, "utf8").trim();
+  if (!existsSync7(path)) return null;
+  const raw = readFileSync5(path, "utf8").trim();
   return raw.length > 0 ? raw : null;
 }
 function writeCursor(workspaceId, eventId) {
   const path = pathFor(workspaceId);
-  mkdirSync6(join7(cabaneDir(), "cursors"), { recursive: true });
-  writeFileSync4(path, eventId + "\n", "utf8");
+  mkdirSync7(join9(cabaneDir(), "cursors"), { recursive: true });
+  writeFileSync5(path, eventId + "\n", "utf8");
 }
 
 // src/cursor-tracker.ts
@@ -2182,20 +2689,20 @@ var CursorTracker = class {
 };
 
 // src/dispatch-dedupe.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync6 } from "fs";
-import { join as join8 } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
+import { join as join10 } from "path";
 var MAX_IDS = 256;
 function dir(log) {
-  return join8(cabaneDir(), log);
+  return join10(cabaneDir(), log);
 }
 function pathFor2(log, workspaceId) {
-  return join8(dir(log), encodeURIComponent(workspaceId));
+  return join10(dir(log), encodeURIComponent(workspaceId));
 }
 function readIds(log, workspaceId) {
   const path = pathFor2(log, workspaceId);
-  if (!existsSync6(path)) return [];
+  if (!existsSync8(path)) return [];
   try {
-    return readFileSync5(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+    return readFileSync6(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
   } catch {
     return [];
   }
@@ -2208,8 +2715,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;
-  mkdirSync7(dir(log), { recursive: true });
-  writeFileSync5(pathFor2(log, workspaceId), trimmed.join("\n") + "\n", "utf8");
+  mkdirSync8(dir(log), { recursive: true });
+  writeFileSync6(pathFor2(log, workspaceId), trimmed.join("\n") + "\n", "utf8");
 }
 function hasDispatched(workspaceId, eventId) {
   return has("dispatched", workspaceId, eventId);
@@ -2225,17 +2732,17 @@ function markCompleted(workspaceId, eventId) {
 }
 var MAX_RESUME_ATTEMPTS = 3;
 function resumeDir() {
-  return join8(cabaneDir(), "resume-attempts");
+  return join10(cabaneDir(), "resume-attempts");
 }
 function resumePathFor(workspaceId) {
-  return join8(resumeDir(), encodeURIComponent(workspaceId));
+  return join10(resumeDir(), encodeURIComponent(workspaceId));
 }
 function readResumeCounts(workspaceId) {
   const out = /* @__PURE__ */ new Map();
   const path = resumePathFor(workspaceId);
-  if (!existsSync6(path)) return out;
+  if (!existsSync8(path)) return out;
   try {
-    for (const line of readFileSync5(path, "utf8").split("\n")) {
+    for (const line of readFileSync6(path, "utf8").split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
       const tab = trimmed.lastIndexOf("	");
@@ -2255,8 +2762,8 @@ function bumpResumeAttempt(workspaceId, eventId) {
   counts.set(eventId, next);
   const entries = [...counts.entries()];
   const trimmed = entries.length > MAX_IDS ? entries.slice(-MAX_IDS) : entries;
-  mkdirSync7(resumeDir(), { recursive: true });
-  writeFileSync5(
+  mkdirSync8(resumeDir(), { recursive: true });
+  writeFileSync6(
     resumePathFor(workspaceId),
     trimmed.map(([id, c]) => `${id}	${c}`).join("\n") + "\n",
     "utf8"
@@ -5968,8 +6475,8 @@ var ConnectorHealthStore = class {
 
 // src/dispatcher.ts
 import { randomUUID } from "crypto";
-import { appendFileSync as appendFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync10, statSync } from "fs";
-import { join as join13 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync11, statSync } from "fs";
+import { join as join15 } from "path";
 
 // src/summon.ts
 import { z as z12 } from "zod";
@@ -6302,11 +6809,11 @@ function trimSlash3(s) {
 // src/codex-instructions.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 var PREFIX = "cabane-codex-instructions-";
 async function writeCodexInstructionsFile(contents) {
-  const dir2 = await mkdtemp(join9(tmpdir(), PREFIX));
-  const path = join9(dir2, "instructions.md");
+  const dir2 = await mkdtemp(join11(tmpdir(), PREFIX));
+  const path = join11(dir2, "instructions.md");
   await writeFile(path, contents, { encoding: "utf8", mode: 384 });
   return {
     path,
@@ -6317,22 +6824,22 @@ async function writeCodexInstructionsFile(contents) {
 }
 
 // src/prepared.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, rmSync as rmSync4, writeFileSync as writeFileSync6, existsSync as existsSync7 } from "fs";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync7, rmSync as rmSync5, writeFileSync as writeFileSync7, existsSync as existsSync9 } from "fs";
+import { join as join12 } from "path";
 function dirFor(workspaceId) {
-  return join10(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
+  return join12(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
 }
 function conversationDir(workspaceId, conversationId) {
-  return join10(dirFor(workspaceId), encodeURIComponent(conversationId));
+  return join12(dirFor(workspaceId), encodeURIComponent(conversationId));
 }
 function pathFor3(workspaceId, conversationId, agentId) {
-  return join10(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
+  return join12(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
 }
 function readPrepared(workspaceId, conversationId, agentId) {
   const path = pathFor3(workspaceId, conversationId, agentId);
-  if (!existsSync7(path)) return null;
+  if (!existsSync9(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path, "utf8"));
     if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
       return {
         cwd: parsed.cwd,
@@ -6345,32 +6852,32 @@ function readPrepared(workspaceId, conversationId, agentId) {
   }
 }
 function writePrepared(workspaceId, conversationId, agentId, result) {
-  mkdirSync8(conversationDir(workspaceId, conversationId), { recursive: true });
-  writeFileSync6(
+  mkdirSync9(conversationDir(workspaceId, conversationId), { recursive: true });
+  writeFileSync7(
     pathFor3(workspaceId, conversationId, agentId),
     JSON.stringify(result) + "\n",
     "utf8"
   );
 }
 function clearPrepared(workspaceId, conversationId, agentId) {
-  rmSync4(pathFor3(workspaceId, conversationId, agentId), { force: true });
+  rmSync5(pathFor3(workspaceId, conversationId, agentId), { force: true });
 }
 
 // src/secrets.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join13 } from "path";
 import { z as z13 } from "zod";
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function secretsPath() {
-  return join11(cabaneDir(), "secrets.json");
+  return join13(cabaneDir(), "secrets.json");
 }
 var secretStoreSchema = z13.record(z13.string(), z13.string());
 function loadSecretStore() {
   const path = secretsPath();
-  if (!existsSync8(path)) return makeStore({});
+  if (!existsSync10(path)) return makeStore({});
   let raw;
   try {
-    raw = readFileSync7(path, "utf8");
+    raw = readFileSync8(path, "utf8");
   } catch (err) {
     throw new ConfigError(
       `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -6448,10 +6955,10 @@ function resolveMcpSecrets(mcpServers, store) {
 }
 
 // src/transcript-writer.ts
-import { appendFileSync, chmodSync as chmodSync3, mkdirSync as mkdirSync9, readdirSync, rmSync as rmSync5 } from "fs";
-import { join as join12 } from "path";
+import { appendFileSync, chmodSync as chmodSync3, mkdirSync as mkdirSync10, readdirSync, rmSync as rmSync6 } from "fs";
+import { join as join14 } from "path";
 function transcriptsDir() {
-  return join12(cabaneDir(), "transcripts");
+  return join14(cabaneDir(), "transcripts");
 }
 var RETAIN = 200;
 var TranscriptWriter = class {
@@ -6460,9 +6967,9 @@ var TranscriptWriter = class {
   onWarn;
   constructor(dir2, meta, onWarn) {
     this.onWarn = onWarn;
-    this.path = join12(dir2, fileName(meta));
+    this.path = join14(dir2, fileName(meta));
     try {
-      mkdirSync9(dir2, { recursive: true });
+      mkdirSync10(dir2, { recursive: true });
       try {
         chmodSync3(dir2, 448);
       } catch {
@@ -6519,7 +7026,7 @@ function pruneOld(dir2, retain) {
   const drop = files.sort().slice(0, files.length - retain);
   for (const f of drop) {
     try {
-      rmSync5(join12(dir2, f), { force: true });
+      rmSync6(join14(dir2, f), { force: true });
     } catch {
     }
   }
@@ -6642,9 +7149,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 target = this.deps.summonState.agentId;
-    if (!target || target === this.deps.agentId) return {};
-    return { dispatch: target };
+    const target2 = this.deps.summonState.agentId;
+    if (!target2 || target2 === this.deps.agentId) return {};
+    return { dispatch: target2 };
   }
   // 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
@@ -6819,16 +7326,16 @@ 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 checkout was resolved for this turn" };
-  if (!existsSync9(cwd)) return { ok: false, reason: `the checkout directory is gone (${cwd})` };
-  const gitPath = join13(cwd, ".git");
-  if (!existsSync9(gitPath)) return { ok: false, reason: `${cwd} holds no git metadata` };
+  if (!existsSync11(cwd)) return { ok: false, reason: `the checkout directory is gone (${cwd})` };
+  const gitPath = join15(cwd, ".git");
+  if (!existsSync11(gitPath)) return { ok: false, reason: `${cwd} holds no git metadata` };
   let stat;
   try {
     stat = statSync(gitPath);
   } catch (error) {
     return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
   }
-  if (stat.isDirectory() && !existsSync9(join13(gitPath, "HEAD")))
+  if (stat.isDirectory() && !existsSync11(join15(gitPath, "HEAD")))
     return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
   return { ok: true, reason: "usable" };
 }
@@ -7019,7 +7526,7 @@ var Dispatcher = class {
     let seqCounter = 0;
     const nextSeq = () => ++seqCounter;
     let effectiveCwd = localCwd ?? cabaneCwd;
-    if (effectiveCwd && !existsSync9(effectiveCwd)) {
+    if (effectiveCwd && !existsSync11(effectiveCwd)) {
       turnLog.warn(
         { cwd: effectiveCwd },
         "dispatcher: configured working directory does not exist on this device \u2014 falling back to the process cwd"
@@ -7157,9 +7664,9 @@ ${reason}`,
     }
     let turnEnv = hookEnv;
     if (effectiveCwd && turnContext.runtime === "codex") {
-      const tmpDir = join13(effectiveCwd, "node_modules", ".cache", "cabane-tmp", turnId);
+      const tmpDir = join15(effectiveCwd, "node_modules", ".cache", "cabane-tmp", turnId);
       try {
-        mkdirSync10(tmpDir, { recursive: true });
+        mkdirSync11(tmpDir, { recursive: true });
         turnEnv = { ...hookEnv, TMPDIR: tmpDir };
       } catch (err) {
         turnLog.warn(
@@ -7298,11 +7805,11 @@ ${reason}`,
     const totalTimeoutMs = this.opts.totalTimeoutMs ?? DEFAULT_AGENT_TOTAL_TIMEOUT_MS;
     const closeTurnReceipt = (ok, reason) => {
       if (!turnReceiptPath) return;
-      const target = turnReceiptPath;
+      const target2 = turnReceiptPath;
       turnReceiptPath = null;
       try {
         appendFileSync2(
-          target,
+          target2,
           `${JSON.stringify({
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             event: "settled",
@@ -7342,7 +7849,7 @@ ${reason}`,
         }
         return this.concludeBeforeRun(payload, turnLog, startedAt, reason);
       }
-      const receiptPath = join13(effectiveCwd, ".git", "cabane", "readiness.jsonl");
+      const receiptPath = join15(effectiveCwd, ".git", "cabane", "readiness.jsonl");
       const receiptLine = (fields) => `${JSON.stringify({
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         taskId: hookEnv.CABANE_TASK_ID,
@@ -7366,7 +7873,7 @@ ${reason}`,
       })}
 `;
       try {
-        mkdirSync10(join13(effectiveCwd, ".git", "cabane"), { recursive: true });
+        mkdirSync11(join15(effectiveCwd, ".git", "cabane"), { recursive: true });
         appendFileSync2(
           receiptPath,
           // `starting` is the honest classification before the proof has run. The
@@ -8032,15 +8539,15 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
 
 // src/outbox.ts
 import {
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync11,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync12,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   renameSync as renameSync3,
-  rmSync as rmSync6,
-  writeFileSync as writeFileSync7
+  rmSync as rmSync7,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 var MAX_ENTRIES = 2e3;
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var Outbox = class {
@@ -8053,25 +8560,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 join14(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
+    return join16(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
   }
   fileFor(turnId, seq) {
-    return join14(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+    return join16(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();
-    mkdirSync11(dir2, { recursive: true });
-    const target = this.fileFor(entry.turnId, entry.seq);
-    const tmp = `${target}.${process.pid}.tmp`;
+    mkdirSync12(dir2, { recursive: true });
+    const target2 = this.fileFor(entry.turnId, entry.seq);
+    const tmp = `${target2}.${process.pid}.tmp`;
     try {
-      writeFileSync7(tmp, JSON.stringify(entry) + "\n", "utf8");
-      renameSync3(tmp, target);
+      writeFileSync8(tmp, JSON.stringify(entry) + "\n", "utf8");
+      renameSync3(tmp, target2);
     } catch (err) {
       try {
-        rmSync6(tmp, { force: true });
+        rmSync7(tmp, { force: true });
       } catch {
       }
       this.log?.warn(
@@ -8088,7 +8595,7 @@ var Outbox = class {
   // wedging the drain.
   list() {
     const dir2 = this.dir();
-    if (!existsSync10(dir2)) return [];
+    if (!existsSync12(dir2)) return [];
     let names;
     try {
       names = readdirSync2(dir2);
@@ -8098,9 +8605,9 @@ var Outbox = class {
     const entries = [];
     for (const name of names) {
       if (!name.endsWith(".json")) continue;
-      const full = join14(dir2, name);
+      const full = join16(dir2, name);
       try {
-        const parsed = JSON.parse(readFileSync8(full, "utf8"));
+        const parsed = JSON.parse(readFileSync9(full, "utf8"));
         if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
           entries.push(parsed);
         } else {
@@ -8118,13 +8625,13 @@ var Outbox = class {
   // Remove a delivered (or terminally-discarded) entry. No-op if already gone.
   remove(turnId, seq) {
     try {
-      rmSync6(this.fileFor(turnId, seq), { force: true });
+      rmSync7(this.fileFor(turnId, seq), { force: true });
     } catch {
     }
   }
   size() {
     const dir2 = this.dir();
-    if (!existsSync10(dir2)) return 0;
+    if (!existsSync12(dir2)) return 0;
     try {
       return readdirSync2(dir2).filter((n) => n.endsWith(".json")).length;
     } catch {
@@ -8137,7 +8644,7 @@ var Outbox = class {
       "companion outbox: dropping unreadable entry"
     );
     try {
-      rmSync6(full, { force: true });
+      rmSync7(full, { force: true });
     } catch {
     }
   }
@@ -8377,6 +8884,7 @@ var CompanionSupervisor = class {
   refreshing = false;
   stopped = false;
   draining = false;
+  restartPending = false;
   // CT484: latch so the companion/server version-skew warning is logged once, not
   // on every 30s heartbeat.
   versionSkewWarned = false;
@@ -8487,7 +8995,8 @@ var CompanionSupervisor = class {
         // actually landed (`harnessSignals` non-null) — an absent field means "we
         // didn't look this beat" and leaves the server's stored suggestion alone,
         // the same fail-soft contract `models` keeps.
-        ...this.harnessSignals ? { detectedRuntimes: detectedRuntimesFor(deriveHarnessSnapshot(this.harnessSignals)) } : {}
+        ...this.harnessSignals ? { detectedRuntimes: detectedRuntimesFor(deriveHarnessSnapshot(this.harnessSignals)) } : {},
+        ...this.restartPending ? { restarting: true } : {}
       });
       this.hub.setDevice({ deviceId: res.deviceId });
       this.deviceId = res.deviceId;
@@ -9125,32 +9634,41 @@ var CompanionSupervisor = class {
     );
   }
   async drainForRestart(graceMs) {
-    this.draining = true;
-    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
-    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.restartPending = true;
     if (this.inFlightHeartbeat) await this.inFlightHeartbeat;
     if (!this.deviceApi) throw new Error("cannot establish deploy drain before pairing");
-    await this.deviceApi.beginDrain();
-    for (const wr of this.workspaces.values()) wr.sub?.stop();
-    const turns = [...this.workspaces.values()].flatMap((wr) => [...wr.chains.values()]);
+    await this.sendHeartbeat();
+    const drainStartedAt = Date.now();
+    const deadline = Date.now() + Math.max(0, graceMs);
     let timedOut = false;
-    if (turns.length > 0) {
+    while (true) {
+      const turns = [...this.workspaces.values()].flatMap((wr) => [...wr.chains.values()]);
+      if (turns.length === 0) break;
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        timedOut = true;
+        break;
+      }
       let timer;
       await Promise.race([
         Promise.allSettled(turns),
         new Promise((resolve) => {
-          timer = setTimeout(
-            () => {
-              timedOut = true;
-              resolve();
-            },
-            Math.max(0, graceMs)
-          );
+          timer = setTimeout(resolve, remainingMs);
           timer.unref?.();
         })
       ]);
       if (timer) clearTimeout(timer);
     }
+    this.log.info(
+      { waitedMs: Date.now() - drainStartedAt, timedOut },
+      timedOut ? "companion: deploy drain grace elapsed; fencing admission for restart" : "companion: deploy drain reached a quiet point; fencing admission for restart"
+    );
+    this.draining = true;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    if (this.inFlightHeartbeat) await this.inFlightHeartbeat;
+    await this.deviceApi.beginDrain();
+    for (const wr of this.workspaces.values()) wr.sub?.stop();
     await Promise.allSettled(
       [...this.workspaces.values()].flatMap(
         (wr) => [...wr.agents.values()].map((agent) => agent.api.drainOutbox())
@@ -9241,22 +9759,22 @@ function handleUncaught(log, err, origin) {
 }
 
 // src/crash-marker.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync12, readFileSync as readFileSync9, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync13, readFileSync as readFileSync10, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
+import { join as join17 } from "path";
 function crashMarkerPath() {
-  return join15(cabaneDir(), "last-error.json");
+  return join17(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
-    mkdirSync12(cabaneDir(), { recursive: true });
-    writeFileSync8(crashMarkerPath(), JSON.stringify(rec2, null, 2) + "\n");
+    mkdirSync13(cabaneDir(), { recursive: true });
+    writeFileSync9(crashMarkerPath(), JSON.stringify(rec2, null, 2) + "\n");
   } catch {
   }
 }
 function clearCrash() {
   try {
     const path = crashMarkerPath();
-    if (existsSync11(path)) rmSync7(path, { force: true });
+    if (existsSync13(path)) rmSync8(path, { force: true });
   } catch {
   }
 }
@@ -9467,7 +9985,8 @@ companion: deploy drain requested (${graceMs}ms grace)\u2026
 
 // src/commands/status.ts
 import { readdirSync as readdirSync3 } from "fs";
-async function status() {
+async function status(deps = {}) {
+  const readService = deps.service ?? serviceStatus;
   const cfg = loadConfig();
   if (!cfg || !cfg.deviceToken) {
     process.stdout.write(
@@ -9503,6 +10022,13 @@ async function status() {
   } else {
     process.stdout.write(
       `companion:       not running \u2014 \`cabane-companion start\` (foreground) or \`cabane-companion start --daemon\` (background)
+`
+    );
+  }
+  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)
 `
     );
   }
@@ -9552,12 +10078,34 @@ 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");
@@ -9607,8 +10155,8 @@ function isAlive(kill, pid) {
 }
 
 // src/commands/transcript.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10, readdirSync as readdirSync4 } from "fs";
-import { isAbsolute, join as join16 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync11, readdirSync as readdirSync4 } from "fs";
+import { isAbsolute, join as join18 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -9625,7 +10173,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join16(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join18(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -9708,7 +10256,7 @@ function isComplete(content) {
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync10(join16(dir2, f), "utf8"),
+    read: (f) => readFileSync11(join18(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`),
@@ -9748,7 +10296,7 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join16(dir2, f));
+    const { meta, outcome } = peek(join18(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
     const ws = str2(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
@@ -9769,7 +10317,7 @@ function peek(path) {
   let meta;
   let outcome;
   try {
-    for (const line of readFileSync10(path, "utf8").split("\n")) {
+    for (const line of readFileSync11(path, "utf8").split("\n")) {
       if (!line.trim()) continue;
       const o = safeParse(line);
       const t = str2(rec(o)?.type);
@@ -9780,29 +10328,29 @@ function peek(path) {
   }
   return { meta, outcome };
 }
-function resolveTarget(dir2, target) {
-  if (isAbsolute(target) || target.includes("/")) {
-    if (existsSync12(target)) return target;
-    throw new CompanionError(`no transcript at ${target}.`);
+function resolveTarget(dir2, target2) {
+  if (isAbsolute(target2) || target2.includes("/")) {
+    if (existsSync14(target2)) return target2;
+    throw new CompanionError(`no transcript at ${target2}.`);
   }
-  const exact = join16(dir2, target);
-  if (existsSync12(exact)) return exact;
-  const matches = listFiles(dir2).filter((f) => f.includes(target));
-  if (matches.length === 1) return join16(dir2, matches[0]);
+  const exact = join18(dir2, target2);
+  if (existsSync14(exact)) return exact;
+  const matches = listFiles(dir2).filter((f) => f.includes(target2));
+  if (matches.length === 1) return join18(dir2, matches[0]);
   if (matches.length === 0) {
     throw new CompanionError(
-      `no transcript matching "${target}" in ${dir2}. Run \`cabane-companion transcript\` to list them.`
+      `no transcript matching "${target2}" in ${dir2}. Run \`cabane-companion transcript\` to list them.`
     );
   }
   throw new CompanionError(
-    `"${target}" matches ${matches.length} transcripts \u2014 be more specific:
+    `"${target2}" matches ${matches.length} transcripts \u2014 be more specific:
 ` + matches.slice(0, 10).map((m) => `  ${m}`).join("\n")
   );
 }
 function renderFile(path) {
   let content;
   try {
-    content = readFileSync10(path, "utf8");
+    content = readFileSync11(path, "utf8");
   } catch (err) {
     throw new CompanionError(
       `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -9939,28 +10487,37 @@ program.command("pair").description(
   });
 });
 program.command("write-paired-config", { hidden: true }).description("persist an already-completed device enrollment payload from stdin.").action(() => {
-  writeCompletedPairing(readFileSync11(0, "utf8"));
+  writeCompletedPairing(readFileSync12(0, "utf8"));
 });
-program.command("start").description("pull this device\u2019s assigned agents from cabane and run them.").option("--open", "open the dashboard in a browser on startup (default: off)").option("--no-open", "don't auto-open the dashboard (overrides config.autoOpen)").option("--daemon", "run detached in the background (terminal returns; replies keep landing)").option("--port <port>", "dashboard port (default 7474; falls through if taken)", parsePort).action(async (opts) => {
-  if (opts.daemon) {
-    await startDaemon({
+program.command("start").description("pull this device\u2019s assigned agents from cabane and run them.").option("--open", "open the dashboard in a browser on startup (default: off)").option("--no-open", "don't auto-open the dashboard (overrides config.autoOpen)").option("--daemon", "run detached in the background (terminal returns; replies keep landing)").option("--foreground", "run attached in this terminal (never installs the login service)").option("--port <port>", "dashboard port (default 7474; falls through if taken)", parsePort).action(
+  async (opts) => {
+    if (opts.daemon && !opts.foreground) {
+      await startDaemon({
+        ...opts.port !== void 0 ? { port: opts.port } : {}
+      });
+      return;
+    }
+    await start({
+      // commander sets `open` to true for `--open`, false for `--no-open`, and
+      // leaves it undefined when neither is passed (respect config + env).
+      ...opts.open !== void 0 ? { open: opts.open } : {},
       ...opts.port !== void 0 ? { port: opts.port } : {}
     });
-    return;
   }
-  await start({
-    // commander sets `open` to true for `--open`, false for `--no-open`, and
-    // leaves it undefined when neither is passed (respect config + env).
-    ...opts.open !== void 0 ? { open: opts.open } : {},
-    ...opts.port !== void 0 ? { port: opts.port } : {}
-  });
-});
+);
 program.command("stop").description("stop a running companion (SIGTERM, then force-kill after a timeout).").action(async () => {
   await stop();
 });
 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 } : {},