@cabane/companion 0.6.32 → 0.6.35

package/dist/cli.js

@@ -1,26 +1,13 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command } from "commander";
+import { Command, Option } from "commander";
 
-// src/commands/daemon.ts
-import { spawn as spawn4 } from "child_process";
-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/control-socket.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, rmSync as rmSync2, mkdirSync as mkdirSync2 } from "fs";
+import { createServer, connect } from "net";
+import { join as join2 } from "path";
 
 // src/config.ts
 import {
@@ -30,7 +17,7 @@ import {
   renameSync,
   rmSync,
   writeFileSync,
-  existsSync as existsSync2
+  existsSync
 } from "fs";
 import { homedir, userInfo } from "os";
 import { dirname, join } from "path";
@@ -308,10 +295,11 @@ var companionConfigSchema = z2.object({
   // device with no device-level entry behaves exactly as it did before. A hook
   // that fails still fails the dispatch loudly, as now.
   prepareHook: prepareHookSchema.optional(),
-  // Dashboard settings (all optional). dashboardPort: preferred bind port (next
-  // free one if taken); autoOpen: whether `start` opens the browser (the
-  // `--no-open` flag / `COMPANION_NO_OPEN=1` override per-run); logLevel: pino
-  // level, live-editable from the dashboard settings panel.
+  // CT1085 §9: `dashboardPort` and `autoOpen` are READ AND IGNORED by the CLI —
+  // it binds no port and opens no browser. They stay in the schema (rather than
+  // becoming a strict-mode parse error on an existing config file) and still mean
+  // what they say to the Electron shell, the one front-end that renders a
+  // dashboard. `logLevel` is unaffected: pino level, live-editable.
   dashboardPort: z2.number().int().min(1).max(65535).optional(),
   autoOpen: z2.boolean().optional(),
   logLevel: z2.enum(["warn", "info", "debug"]).optional(),
@@ -376,7 +364,7 @@ function localAgentConfig(cfg, agent) {
 }
 function loadConfig() {
   const path = configPath();
-  if (!existsSync2(path)) return null;
+  if (!existsSync(path)) return null;
   let raw;
   try {
     raw = readFileSync(path, "utf8");
@@ -412,7 +400,7 @@ function loadConfigTolerant() {
   const path = configPath();
   const empty = {};
   const fresh = { local: empty, note: null, hadPriorConfig: false };
-  if (!existsSync2(path)) return fresh;
+  if (!existsSync(path)) return fresh;
   let raw;
   try {
     raw = readFileSync(path, "utf8");
@@ -499,59 +487,163 @@ function requireConfig() {
 }
 function deleteConfig() {
   const path = configPath();
-  if (existsSync2(path)) {
+  if (existsSync(path)) {
     writeFileSync(path, "", { mode: 384 });
   }
 }
 
-// src/logger.ts
-import { createWriteStream, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import pino from "pino";
-import pretty from "pino-pretty";
-function companionLogPath() {
-  return join2(cabaneDir(), "companion.log");
+// src/control-socket.ts
+var CONTROL_TIMEOUT_MS = 1e3;
+function controlSocketPath() {
+  const dir2 = cabaneDir();
+  if (process.platform === "win32") {
+    const key = createHash("sha256").update(dir2).digest("hex").slice(0, 16);
+    return `\\\\.\\pipe\\cabane-companion-${key}`;
+  }
+  return join2(dir2, "companion.sock");
+}
+async function startControlServer(handlers) {
+  const path = controlSocketPath();
+  mkdirSync2(cabaneDir(), { recursive: true });
+  if (process.platform !== "win32" && existsSync2(path)) {
+    const alive = await ping(path);
+    if (alive) throw new Error(`another companion is already listening on ${path}`);
+    rmSync2(path, { force: true });
+  }
+  const server = createServer((socket) => {
+    void serveConnection(socket, handlers);
+  });
+  server.unref();
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(path, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  server.on("error", () => {
+  });
+  return {
+    path,
+    close: () => new Promise((resolve) => {
+      server.close(() => {
+        if (process.platform !== "win32") rmSync2(path, { force: true });
+        resolve();
+      });
+    })
+  };
 }
-var CONSOLE_IGNORE = [
-  "pid",
-  "hostname",
-  "workspaceId",
-  "conversationId",
-  "agentId",
-  "messageId",
-  "sessionId",
-  "companionId"
-].join(",");
-function consoleShortId(log) {
-  const id = log.conversationId ?? log.workspaceId;
-  return typeof id === "string" && id.length > 0 ? id.slice(0, 8) : null;
+async function serveConnection(socket, handlers) {
+  socket.on("error", () => socket.destroy());
+  const line = await readLine(socket, CONTROL_TIMEOUT_MS * 5);
+  if (line === null) {
+    socket.destroy();
+    return;
+  }
+  let req;
+  try {
+    req = JSON.parse(line);
+  } catch {
+    reply(socket, { error: "malformed request" });
+    return;
+  }
+  try {
+    if (req.cmd === "status") {
+      reply(socket, handlers.status());
+      return;
+    }
+    if (req.cmd === "connect") {
+      const result = await handlers.connect(req.runtime, req.serverUrl);
+      reply(socket, result);
+      return;
+    }
+    if (req.cmd === "stop") {
+      reply(socket, { ok: true });
+      setTimeout(() => handlers.stop(), 50).unref?.();
+      return;
+    }
+    reply(socket, { error: `unknown command "${String(req.cmd)}"` });
+  } catch (err) {
+    reply(socket, { error: err instanceof Error ? err.message : String(err) });
+  }
 }
-function consoleMessageFormat(log, messageKey) {
-  const short = consoleShortId(log);
-  const msg = String(log[messageKey] ?? "");
-  return short ? `${short} ${msg}` : msg;
+function reply(socket, body) {
+  try {
+    socket.end(`${JSON.stringify(body)}
+`);
+  } catch {
+    socket.destroy();
+  }
 }
-var cached = null;
-function getLogger() {
-  if (cached) return cached;
-  const path = companionLogPath();
-  mkdirSync2(dirname2(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)
+async function controlRequest(path, req, timeoutMs = CONTROL_TIMEOUT_MS) {
+  const socket = connect(path);
+  try {
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new ControlTimeout()), timeoutMs);
+      timer.unref?.();
+      socket.once("connect", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      socket.once("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
     });
-    streams.push({ level: "info", stream: consoleStream });
+    socket.write(`${JSON.stringify(req)}
+`);
+    const line = await readLine(socket, timeoutMs);
+    if (line === null) throw new ControlTimeout();
+    return JSON.parse(line);
+  } finally {
+    socket.destroy();
+  }
+}
+var ControlTimeout = class extends Error {
+  constructor() {
+    super("the companion did not answer its control socket in time");
+    this.name = "ControlTimeout";
+  }
+};
+function isNotListening(err) {
+  const code = err?.code;
+  return code === "ENOENT" || code === "ECONNREFUSED";
+}
+function readLine(socket, timeoutMs) {
+  return new Promise((resolve) => {
+    let buf = "";
+    let settled = false;
+    const done = (v) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.removeListener("data", onData);
+      resolve(v);
+    };
+    const timer = setTimeout(() => done(null), timeoutMs);
+    timer.unref?.();
+    const onData = (chunk) => {
+      buf += chunk.toString("utf8");
+      const nl = buf.indexOf("\n");
+      if (nl >= 0) done(buf.slice(0, nl));
+      else if (buf.length > 1e6) done(null);
+    };
+    socket.on("data", onData);
+    socket.once("close", () => done(null));
+    socket.once("error", () => done(null));
+  });
+}
+async function ping(path) {
+  try {
+    await controlRequest(path, { cmd: "status" });
+    return true;
+  } catch (err) {
+    return !isNotListening(err);
   }
-  streams.push({ level: "debug", stream: createWriteStream(path, { flags: "a" }) });
-  cached = pino({ level: "debug" }, pino.multistream(streams));
-  return cached;
 }
 
-// src/prereqs.ts
-import { spawn as spawn3 } from "child_process";
+// src/harness-check.ts
+import { spawn as spawn4 } from "child_process";
 
 // src/harness-versions.ts
 import { spawn as spawn2 } from "child_process";
@@ -634,7 +726,22 @@ async function safe(fn) {
   }
 }
 
+// src/manifest.ts
+var DEVICE_MANIFEST = {
+  runtimes: [{ name: "claude-code", version: null }],
+  capabilities: { hostFs: true, browser: true, userMcp: true }
+};
+function buildCompanionManifest(opts) {
+  const v = opts.versions ?? {};
+  const runtimes = [];
+  if (opts.claudeCode) runtimes.push({ name: "claude-code", version: v.claudeCode ?? null });
+  if (opts.opencode) runtimes.push({ name: "opencode", version: v.opencode ?? null });
+  if (opts.codex) runtimes.push({ name: "codex", version: v.codex ?? null });
+  return { runtimes, capabilities: { ...DEVICE_MANIFEST.capabilities } };
+}
+
 // src/prereqs.ts
+import { spawn as spawn3 } from "child_process";
 async function claudeOnPath() {
   return new Promise((resolve) => {
     let settled = false;
@@ -704,633 +811,581 @@ async function warnAboutHarnessReadiness(cfg, deps = {}) {
   );
 }
 
-// src/runtime-file.ts
-import {
-  existsSync as existsSync3,
-  readFileSync as readFileSync2,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync2,
-  mkdirSync as mkdirSync3,
-  openSync,
-  closeSync
-} from "fs";
-import { join as join3 } from "path";
-var PROBE_TIMEOUT_MS = 1e3;
-function runtimePath() {
-  return join3(cabaneDir(), "runtime.json");
-}
-function serialize(state) {
-  return JSON.stringify(state, null, 2) + "\n";
+// src/harness-status.ts
+var HARNESS_LABELS = {
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  opencode: "opencode"
+};
+var LABELS = HARNESS_LABELS;
+var OFFER_ORDER = ["claude-code", "codex", "opencode"];
+function parseHarnessRuntime(raw) {
+  const key = raw.trim().toLowerCase().replace(/[\s_]+/g, "-");
+  if (key === "claude-code" || key === "claudecode" || key === "claude") return "claude-code";
+  if (key === "codex") return "codex";
+  if (key === "opencode") return "opencode";
+  return null;
 }
-function writeRuntimeState(state) {
-  const path = runtimePath();
-  mkdirSync3(cabaneDir(), { recursive: true });
-  writeFileSync2(path, serialize(state), "utf8");
+function deriveHarnessSnapshot(signals) {
+  const advertised = new Set(
+    buildCompanionManifest({
+      // CT1082: connected AND installed — the manifest's own rule, restated here
+      // through the same function rather than re-decided.
+      claudeCode: signals.claudeCodeConnected && signals.claudeOnPath,
+      opencode: signals.opencodeConfigured,
+      codex: signals.codexEnabled
+    }).runtimes.map((r) => r.name)
+  );
+  const harnesses = [
+    deriveClaudeCode(signals, advertised.has("claude-code")),
+    deriveCodex(signals, advertised.has("codex")),
+    deriveOpencode(signals, advertised.has("opencode"))
+  ];
+  return { harnesses, anyExposed: harnesses.some((h) => h.state === "exposed") };
 }
-function acquireRuntimeState(state) {
-  const live = readLiveRuntimeState();
-  if (live) return { acquired: false, existing: live };
-  mkdirSync3(cabaneDir(), { recursive: true });
-  let fd;
-  try {
-    fd = openSync(runtimePath(), "wx");
-  } catch {
-    return { acquired: false, existing: readLiveRuntimeState() };
-  }
-  try {
-    writeFileSync2(fd, serialize(state), "utf8");
-  } finally {
-    closeSync(fd);
+function deriveClaudeCode(signals, manifestHas) {
+  const base = { runtime: "claude-code", label: LABELS["claude-code"] };
+  if (manifestHas) {
+    return {
+      ...base,
+      state: "exposed",
+      version: signals.claudeVersion,
+      detail: "Claude Code is connected and exposed to Cabane.",
+      enable: null
+    };
   }
-  return { acquired: true };
-}
-function clearRuntimeState() {
-  const path = runtimePath();
-  if (existsSync3(path)) rmSync2(path, { force: true });
-}
-function readLiveRuntimeState() {
-  const path = runtimePath();
-  if (!existsSync3(path)) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync2(path, "utf8"));
-  } catch {
-    return null;
+  if (signals.claudeCodeConnected) {
+    return {
+      ...base,
+      state: "needs_attention",
+      version: null,
+      detail: "Connected, but the `claude` CLI isn\u2019t on your PATH. Install it (`npm i -g @anthropic-ai/claude-code`) and sign in, or disconnect it.",
+      enable: null
+    };
   }
-  if (typeof parsed.pid !== "number") return null;
-  try {
-    process.kill(parsed.pid, 0);
-  } catch {
-    clearRuntimeState();
-    return null;
+  if (signals.claudeOnPath) {
+    return {
+      ...base,
+      state: "detected_not_exposed",
+      version: signals.claudeVersion,
+      detail: "Claude Code is installed here but not connected yet. Connect it to let Cabane run Claude Code on this device.",
+      enable: "claude-code"
+    };
   }
-  return parsed;
+  return {
+    ...base,
+    state: "not_detected",
+    version: null,
+    detail: "Not detected. Install Claude Code (`npm i -g @anthropic-ai/claude-code`) and sign in with `claude`, then connect it here.",
+    enable: null
+  };
 }
-async function verifyRuntime(state, fetchImpl = fetch) {
-  if (!state.instanceId) return "unknown";
-  const url = `${trimSlash(state.url)}/api/status`;
-  let res;
-  try {
-    res = await fetchImpl(url, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) });
-  } catch (err) {
-    return isConnRefused(err) ? "stale" : "unknown";
+function deriveCodex(signals, manifestHas) {
+  const base = { runtime: "codex", label: LABELS.codex };
+  if (manifestHas) {
+    if (signals.codexOnPath) {
+      return {
+        ...base,
+        state: "exposed",
+        version: signals.codexVersion,
+        detail: "Codex is enabled and exposed to Cabane.",
+        enable: null
+      };
+    }
+    return {
+      ...base,
+      state: "needs_attention",
+      version: null,
+      detail: "Enabled, but the `codex` CLI isn\u2019t on your PATH. Install it and sign in (`codex login`), or turn Codex off.",
+      enable: null
+    };
   }
-  if (!res.ok) return "unknown";
-  let body;
-  try {
-    body = await res.json();
-  } catch {
-    return "unknown";
-  }
-  if (typeof body.instance_id !== "string") return "unknown";
-  return body.instance_id === state.instanceId ? "ours" : "stale";
-}
-function isConnRefused(err) {
-  if (!err || typeof err !== "object") return false;
-  const cause = err.cause;
-  return !!cause && typeof cause === "object" && cause.code === "ECONNREFUSED";
-}
-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."
-    );
+  if (signals.codexOnPath) {
+    return {
+      ...base,
+      state: "detected_not_exposed",
+      version: signals.codexVersion,
+      detail: "Codex is installed but not exposed yet. Turn it on to let Cabane run Codex here.",
+      enable: "codex"
+    };
   }
   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 });
+    ...base,
+    state: "not_detected",
+    version: null,
+    detail: "Not detected. Install the Codex CLI and sign in (`codex login`), then enable it here.",
+    enable: null
+  };
+}
+function deriveOpencode(signals, manifestHas) {
+  const base = { runtime: "opencode", label: LABELS.opencode };
+  if (manifestHas) {
+    if (signals.opencodeReachable) {
       return {
-        ok: res.status === 0,
-        stdout: res.stdout ?? "",
-        stderr: res.stderr ?? (res.error ? res.error.message : "")
+        ...base,
+        state: "exposed",
+        version: signals.opencodeVersion,
+        detail: "An opencode server is reachable and exposed to Cabane.",
+        enable: null
       };
     }
+    return {
+      ...base,
+      state: "needs_attention",
+      version: null,
+      detail: "Configured, but the opencode server isn\u2019t answering. Start `opencode serve` and check the URL.",
+      enable: null
+    };
+  }
+  return {
+    ...base,
+    state: "not_detected",
+    version: null,
+    detail: "Not detected. Run `opencode serve` and add its URL here to expose opencode.",
+    enable: "opencode"
   };
 }
-
-// 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 detectedRuntimesFor(snapshot) {
+  return snapshot.harnesses.filter((h) => h.state === "detected_not_exposed").map((h) => ({ runtime: h.runtime, version: h.version }));
 }
-function domain(host) {
-  return `gui/${host.uid}`;
+var PROBE_TIMEOUT_MS = 4e3;
+async function probeHarnessSignals(cfg, deps = {}) {
+  const probeClaudePresence = deps.probeClaudePresence ?? claudeOnPath;
+  const probeClaudeVersion = deps.probeClaudeVersion ?? (() => probeCliVersion("claude"));
+  const probeCodexVersion = deps.probeCodexVersion ?? (() => probeCliVersion("codex"));
+  const probeOpencode = deps.probeOpencode ?? ((url) => probeOpencodeVersion(url));
+  const serverUrl = cfg.opencode?.serverUrl;
+  const [claudeOnPathResult, claudeVersion, codexVersion, opencodeVersion] = await Promise.all([
+    withTimeout(probeClaudePresence(), false),
+    withTimeout(probeClaudeVersion(), null),
+    withTimeout(probeCodexVersion(), null),
+    serverUrl ? withTimeout(probeOpencode(serverUrl), null) : Promise.resolve(null)
+  ]);
+  return {
+    claudeOnPath: claudeOnPathResult,
+    claudeVersion,
+    // CT1082: the user's opt-in. Presence alone exposes nothing now, so this is
+    // the manifest gate and the probe above is only a suggestion.
+    claudeCodeConnected: isClaudeCodeConnected(cfg),
+    // A parseable `codex --version` is our presence signal (presence alone never
+    // exposes codex; its config flag is the manifest gate either way).
+    codexOnPath: codexVersion !== null,
+    codexVersion,
+    codexEnabled: isCodexEnabled(cfg),
+    opencodeConfigured: !!serverUrl,
+    // A version came back ⟺ the serve answered its health endpoint (CT584).
+    opencodeReachable: opencodeVersion !== null,
+    opencodeVersion
+  };
 }
-function target(host) {
-  return `${domain(host)}/${LAUNCHD_LABEL}`;
+function withTimeout(promise, fallback) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (v) => {
+      if (!settled) {
+        settled = true;
+        resolve(v);
+      }
+    };
+    const timer = setTimeout(() => done(fallback), PROBE_TIMEOUT_MS);
+    timer.unref?.();
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        done(v);
+      },
+      () => {
+        clearTimeout(timer);
+        done(fallback);
+      }
+    );
+  });
 }
-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) };
+
+// src/harness-check.ts
+var CHECK_TIMEOUT_MS = 4e3;
+async function shakeOutHarness(runtime, cfg, deps = {}) {
+  const run = deps.run ?? runBounded;
+  const probeOpencode = deps.probeOpencode ?? ((url) => probeOpencodeVersion(url));
+  try {
+    if (runtime === "opencode") {
+      const url = cfg.opencode?.serverUrl;
+      if (!url) return "absent";
+      return await probeOpencode(url) !== null ? "ok" : "failed";
+    }
+    const { auth, presence } = runtime === "codex" ? {
+      auth: ["codex", ["login", "status"]],
+      presence: ["codex", ["--version"]]
+    } : {
+      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)) {
+      return "unverified";
+    }
+    return "failed";
+  } catch {
+    return "unverified";
+  }
 }
-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 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]}`;
 }
-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" };
+var FAILED_SUFFIX = {
+  "claude-code": "it doesn\u2019t look signed in yet. Run `claude` once and sign in, then it\u2019s ready.",
+  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`.";
   }
-  return notLoaded(res.stderr + res.stdout) ? { ownership: "clear", running: false } : { ownership: "unknown", running: "unknown" };
+  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 launchdRemove(host, plistPath) {
-  const stopped = launchdStop(host);
-  if (!stopped.ok) return stopped;
-  host.fs.remove(plistPath);
-  return { ok: true };
+function looksUnsupported(output) {
+  return /unrecognized|unknown (sub)?command|unexpected argument|invalid (sub)?command|no such (sub)?command|usage:|did you mean/i.test(
+    output
+  );
 }
-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 runBounded(command, args) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    let child;
+    try {
+      child = spawn4(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    } catch {
+      resolve({ code: null, output: "", error: "spawn" });
+      return;
+    }
+    let out = "";
+    const capture = (chunk) => {
+      if (out.length < 4096) out += chunk.toString();
+    };
+    child.stdout?.on("data", capture);
+    child.stderr?.on("data", capture);
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      done({ code: null, output: out, error: "timeout" });
+    }, CHECK_TIMEOUT_MS);
+    timer.unref?.();
+    child.once("error", () => done({ code: null, output: out, error: "spawn" }));
+    child.once("exit", (code) => done({ code, output: out }));
+  });
 }
-function firstLine(s) {
-  return s.trim().split("\n")[0] ?? "";
+
+// src/runtime-file.ts
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync2,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync3,
+  openSync,
+  closeSync
+} from "fs";
+import { join as join3 } from "path";
+var PROBE_TIMEOUT_MS2 = 1e3;
+function runtimePath() {
+  return join3(cabaneDir(), "runtime.json");
 }
-function xml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function serialize(state) {
+  return JSON.stringify(state, null, 2) + "\n";
 }
-
-// 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 writeRuntimeState(state) {
+  const path = runtimePath();
+  mkdirSync3(cabaneDir(), { recursive: true });
+  writeFileSync2(path, serialize(state), "utf8");
 }
-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" };
+function acquireRuntimeState(state) {
+  const live = readLiveRuntimeState();
+  if (live) return { acquired: false, existing: live };
+  mkdirSync3(cabaneDir(), { recursive: true });
+  let fd;
+  try {
+    fd = openSync(runtimePath(), "wx");
+  } catch {
+    return { acquired: false, existing: readLiveRuntimeState() };
   }
-  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) };
+  try {
+    writeFileSync2(fd, serialize(state), "utf8");
+  } finally {
+    closeSync(fd);
   }
-  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";
+  return { acquired: true };
 }
-function tryEnableLinger(host) {
-  host.run("loginctl", ["enable-linger", String(host.uid)]);
-  return readLinger(host);
+function clearRuntimeState() {
+  const path = runtimePath();
+  if (existsSync3(path)) rmSync3(path, { force: true });
 }
-function isRemoteSession(env) {
-  return Boolean(env.SSH_CONNECTION || env.SSH_TTY || env.SSH_CLIENT);
+function clearRuntimeStateIfOurs(instanceId) {
+  const path = runtimePath();
+  if (!existsSync3(path)) return;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (parsed.instanceId && parsed.instanceId !== instanceId) return;
+  } catch {
+  }
+  rmSync3(path, { force: true });
 }
-function quote(value) {
-  return `"${value.replace(/(["\\])/g, "\\$1")}"`;
+function readLiveRuntimeState() {
+  const path = runtimePath();
+  if (!existsSync3(path)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed.pid !== "number") return null;
+  try {
+    process.kill(parsed.pid, 0);
+  } catch {
+    clearRuntimeState();
+    return null;
+  }
+  return parsed;
 }
-function firstLine2(s) {
-  return s.trim().split("\n")[0] ?? "";
+async function verifyRuntime(state, requestImpl = controlRequest) {
+  if (!state.instanceId || !state.socket) return "unknown";
+  let body;
+  try {
+    body = await requestImpl(
+      state.socket,
+      { cmd: "status" },
+      PROBE_TIMEOUT_MS2
+    );
+  } catch (err) {
+    return isNotListening(err) ? "stale" : "unknown";
+  }
+  if (typeof body?.instance_id !== "string") return "unknown";
+  return body.instance_id === state.instanceId ? "ours" : "stale";
 }
 
-// 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;
+// src/term.ts
+import { createInterface } from "readline";
+import { homedir as homedir2 } from "os";
+import pc from "picocolors";
+var INDENT = "  ";
+var DATA_INDENT = "      ";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function write(line) {
+  process.stdout.write(`${line}
+`);
 }
-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 blank() {
+  process.stdout.write("\n");
+}
+var tick = (rest) => `${pc.green("\u2713")} ${rest}`;
+var arrow = (rest) => `${pc.yellow("\u2192")} ${rest}`;
+var bang = (rest) => `${pc.yellow("!")} ${rest}`;
+function tildePath(path) {
+  const home = homedir2();
+  if (home && path.startsWith(home + "/")) return `~${path.slice(home.length)}`;
+  return path;
+}
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var FRAME_MS = 80;
+var Spinner = class {
+  timer = null;
+  frame = 0;
+  text = "";
+  animate;
+  constructor(opts = {}) {
+    this.animate = opts.animate ?? isInteractive();
+  }
+  start(text) {
+    this.text = text;
+    if (!this.animate) {
+      write(`${INDENT}${text}`);
+      return;
+    }
+    this.render();
+    this.timer = setInterval(() => {
+      this.frame = (this.frame + 1) % FRAMES.length;
+      this.render();
+    }, FRAME_MS);
+    this.timer.unref?.();
+  }
+  // Stop, erase the spinner line, and write `line` in its place.
+  replaceWith(line) {
+    this.halt();
+    if (this.animate) this.eraseLine();
+    write(line);
+  }
+  // Stop, leaving the line as it last rendered — for an outcome that reads as
+  // "this is where we gave up waiting" rather than as a resolution. Without a
+  // TTY the line was already terminated when it printed, so there is nothing to
+  // close.
+  freeze() {
+    this.halt();
+    if (this.animate) process.stdout.write("\n");
+  }
+  // Stop and erase, writing nothing — the Ctrl-C path, where the shell's own
+  // `^C` echo is the last thing on the line.
+  clear() {
+    this.halt();
+    if (this.animate) this.eraseLine();
+  }
+  halt() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  render() {
+    this.eraseLine();
+    process.stdout.write(`${INDENT}${pc.dim(FRAMES[this.frame] ?? FRAMES[0])} ${this.text}`);
+  }
+  // Carriage return + "erase the whole line", so a replacement starts clean
+  // however wide the spinner text was.
+  eraseLine() {
+    process.stdout.write("\r\x1B[2K");
+  }
+};
+async function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question(`${INDENT}${question} [Y/n] `, resolve);
+    });
+    return !/^n(o)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
 }
-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);
+
+// src/commands/connect.ts
+async function connect2(raw, opts = {}) {
+  const runtime = parseHarnessRuntime(raw);
+  if (!runtime) {
+    throw new CompanionError(
+      `unknown harness "${raw}". Connectable harnesses are: claude-code, codex, opencode.`
+    );
   }
-  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 live = await liveSocket();
+  if (live) {
+    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;
   }
-  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);
+  const cfg = requireConfig();
+  if (alreadyConnected(runtime, cfg)) {
+    write(`${INDENT}${HARNESS_LABELS[runtime]} is already connected on this device.`);
+    return;
   }
-  return { installed: true, manager, changed };
-}
-function failedInstall(host, manager, reason, detail) {
-  return {
-    installed: false,
-    reason,
-    ...detail ? { detail } : {},
-    ...managerOwnership(host, manager) === "clear" ? {} : { leftBehind: manager }
-  };
+  if (runtime === "claude-code" && !await claudeOnPath()) {
+    throw new CompanionError(
+      "Couldn\u2019t find `claude` on this machine\u2019s PATH. Install Claude Code (`npm i -g @anthropic-ai/claude-code`) and sign in, then connect it."
+    );
+  }
+  let next = cfg;
+  if (runtime === "claude-code") next = { ...cfg, claudeCode: { enabled: true } };
+  else if (runtime === "codex") next = { ...cfg, codex: { enabled: true } };
+  else {
+    const serverUrl = opts.serverUrl?.trim();
+    if (!serverUrl) {
+      throw new CompanionError(
+        "opencode is addressed by URL \u2014 pass it: `cabane-companion connect opencode --url http://127.0.0.1:4096`."
+      );
+    }
+    if (await probeOpencodeVersion(serverUrl) === null) {
+      throw new CompanionError(
+        `Couldn\u2019t reach an opencode server at ${serverUrl}. Start \`opencode serve\` and check the URL.`
+      );
+    }
+    next = { ...cfg, opencode: { serverUrl } };
+  }
+  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`);
 }
-function managerProbe(host, manager) {
-  if (manager === "launchd") return launchdProbe(host);
-  if (manager === "systemd-user") return systemdProbe(host);
-  return { ownership: "clear", running: false };
+async function liveSocket() {
+  const state = readLiveRuntimeState();
+  if (!state) return null;
+  const verdict = await verifyRuntime(state);
+  if (verdict === "stale") {
+    clearRuntimeState();
+    return null;
+  }
+  if (!state.socket) return null;
+  try {
+    await controlRequest(state.socket, { cmd: "status" });
+    return state.socket;
+  } catch (err) {
+    if (isNotListening(err)) return null;
+    throw new CompanionError(
+      "a companion is running but isn\u2019t answering its control socket. Try `cabane-companion stop`, then `cabane-companion start`."
+    );
+  }
 }
-function managerOwnership(host, manager) {
-  return managerProbe(host, manager).ownership;
+function alreadyConnected(runtime, cfg) {
+  if (runtime === "claude-code") return isClaudeCodeConnected(cfg);
+  if (runtime === "codex") return isCodexEnabled(cfg);
+  return !!cfg.opencode?.serverUrl;
 }
-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;
-async function startDaemon(opts = {}, deps = {}) {
-  const ensureRuntime = deps.ensureRuntime ?? warnAboutHarnessReadiness;
-  const readState = deps.readState ?? readLiveRuntimeState;
-  const verify = deps.verify ?? ((s) => verifyRuntime(s));
-  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 } : {},
-    ...deps.probeClaude ? { probeClaude: deps.probeClaude } : {},
-    ...deps.save ? { save: deps.save } : {},
-    // The child won't log it (the block is written by then), and this process owns
-    // the user's terminal — so the one-time record is one line, here.
-    onMigrated: (_migrated, onPath) => {
-      if (onPath) {
-        process.stdout.write(
-          "Carried Claude Code over as a connected harness on this device \u2014 connectors are chosen now, not detected.\n"
-        );
-      }
-    }
-  });
-  await ensureRuntime(cfg, { probeClaude: async () => claudeOnPath2 });
-  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 launchDetached = () => {
-    const spawned = spawnDetached(args);
-    spawned.unref();
-    return spawned;
-  };
-  const ready = (s) => !!s && !!s.url;
-  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;
-  }
-  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;
-    }
-    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\`.
-`
-    );
-    process.exitCode = 1;
-    return;
-  }
-  process.stdout.write(
-    `Cabane Companion started in the background (pid ${state.pid}).
-\u2192 Dashboard: ${state.url}
-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 = companionCliEntry();
-  mkdirSync5(cabaneDir(), { recursive: true });
-  const logFd = openSync2(companionLogPath(), "a");
-  try {
-    return spawn4(process.execPath, [cliPath, ...args], {
-      detached: true,
-      stdio: ["ignore", logFd, logFd],
-      env: { ...process.env, CABANE_COMPANION_DAEMON: "1" }
-    });
-  } finally {
-    closeSync2(logFd);
-  }
-}
-
-// src/commands/logout.ts
-import { confirm } from "@inquirer/prompts";
-
-// src/credentials.ts
-import {
-  chmodSync as chmodSync2,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync4,
-  renameSync as renameSync2,
-  rmSync as rmSync4,
-  writeFileSync as writeFileSync4
-} from "fs";
-import { dirname as dirname5, join as join6 } from "path";
-import { z as z3 } from "zod";
-function credentialsPath() {
-  return join6(cabaneDir(), "credentials.json");
+
+// src/commands/logout.ts
+import { confirm as confirm2 } from "@inquirer/prompts";
+
+// src/credentials.ts
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync3,
+  renameSync as renameSync2,
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { z as z3 } from "zod";
+function credentialsPath() {
+  return join4(cabaneDir(), "credentials.json");
 }
 var credentialStoreSchema = z3.record(z3.string(), z3.string());
 function load() {
   const path = credentialsPath();
-  if (!existsSync5(path)) return {};
+  if (!existsSync4(path)) return {};
   let raw;
   try {
-    raw = readFileSync4(path, "utf8");
+    raw = readFileSync3(path, "utf8");
   } catch {
     return {};
   }
@@ -1344,14 +1399,14 @@ function load() {
 }
 function save(map) {
   const path = credentialsPath();
-  mkdirSync6(dirname5(path), { recursive: true });
+  mkdirSync4(dirname2(path), { recursive: true });
   try {
     chmodSync2(cabaneDir(), 448);
   } catch {
   }
   const tmp = `${path}.${process.pid}.tmp`;
   try {
-    writeFileSync4(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
+    writeFileSync3(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
     try {
       chmodSync2(tmp, 384);
     } catch {
@@ -1389,7 +1444,7 @@ function pruneCredentials(keepAgentIds) {
 }
 function clearCredentials() {
   const path = credentialsPath();
-  if (existsSync5(path)) writeFileSync4(path, "", { mode: 384 });
+  if (existsSync4(path)) writeFileSync3(path, "", { mode: 384 });
 }
 
 // src/commands/logout.ts
@@ -1401,7 +1456,7 @@ async function logout(opts = {}) {
   }
   if (!opts.yes) {
     const message = opts.purge ? "Purge the entire local companion config (device + agent overrides + settings)?" : "Log out this device (removes the device token + cached agent credentials; keeps your config)?";
-    const ok = await confirm({ message, default: false });
+    const ok = await confirm2({ message, default: false });
     if (!ok) {
       process.stdout.write("cancelled\n");
       return;
@@ -1424,7 +1479,22 @@ async function logout(opts = {}) {
   );
 }
 
+// src/commands/pair.ts
+import { hostname } from "os";
+
 // src/enrollment.ts
+var EnrollmentExpiredError = class extends CompanionError {
+  constructor() {
+    super("this pairing code expired before it was confirmed.");
+    this.name = "EnrollmentExpiredError";
+  }
+};
+var EnrollmentCancelledError = class extends CompanionError {
+  constructor() {
+    super("pairing was cancelled.");
+    this.name = "EnrollmentCancelledError";
+  }
+};
 function trimBase(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
 }
@@ -1461,18 +1531,25 @@ async function postJson(baseUrl, path, body) {
   }
   return parsed;
 }
-function requestEnrollmentCode(baseUrl) {
-  return postJson(baseUrl, "/api/device-enrollment/code", {});
+function requestEnrollmentCode(baseUrl, opts = {}) {
+  return postJson(baseUrl, "/api/device-enrollment/code", {
+    ...opts.label ? { label: opts.label } : {}
+  });
+}
+function deviceLabelFromHostname(hostname3) {
+  const trimmed = hostname3.trim().replace(/\.local$/i, "");
+  if (trimmed.length === 0) return void 0;
+  return trimmed.slice(0, 120);
 }
 function pollOnce(baseUrl, deviceCode) {
   return postJson(baseUrl, "/api/device-enrollment/poll", { deviceCode });
 }
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function runDeviceFlow(baseUrl, print, opts = {}) {
-  const now = opts.now ?? (() => Date.now());
-  const wait = opts.sleepMs ?? sleep;
-  if (opts.signal?.aborted) throw new CompanionError("pairing was cancelled.");
-  const code = await requestEnrollmentCode(baseUrl);
+  if (opts.signal?.aborted) throw new EnrollmentCancelledError();
+  const code = await requestEnrollmentCode(baseUrl, {
+    ...opts.label ? { label: opts.label } : {}
+  });
   if (opts.onCode) await opts.onCode(code);
   print("");
   print(`  Enter this code at ${code.verificationUri}`);
@@ -1481,12 +1558,17 @@ async function runDeviceFlow(baseUrl, print, opts = {}) {
   print("");
   print(`  or open: ${code.verificationUriComplete}`);
   print("");
-  print("Waiting for you to confirm it in cabane\u2026");
+  print("Waiting for you to confirm it in Cabane\u2026");
+  return awaitEnrollment(baseUrl, code, opts);
+}
+async function awaitEnrollment(baseUrl, code, opts = {}) {
+  const now = opts.now ?? (() => Date.now());
+  const wait = opts.sleepMs ?? sleep;
   const deadline = now() + code.expiresIn * 1e3;
   let intervalMs = Math.max(1, code.interval) * 1e3;
   while (now() < deadline) {
     await wait(intervalMs);
-    if (opts.signal?.aborted) throw new CompanionError("pairing was cancelled.");
+    if (opts.signal?.aborted) throw new EnrollmentCancelledError();
     const res = await pollOnce(baseUrl, code.deviceCode);
     if (res.status === "complete") {
       if (!res.deviceToken || !res.baseUrl) {
@@ -1496,19 +1578,14 @@ async function runDeviceFlow(baseUrl, print, opts = {}) {
         baseUrl: res.baseUrl,
         deviceToken: res.deviceToken,
         ...res.deviceId ? { deviceId: res.deviceId } : {},
-        ...res.deviceLabel ? { deviceLabel: res.deviceLabel } : {}
+        ...res.deviceLabel ? { deviceLabel: res.deviceLabel } : {},
+        ...res.ownerName ? { ownerName: res.ownerName } : {}
       };
     }
-    if (res.status === "expired") {
-      throw new CompanionError(
-        "this pairing code expired before it was confirmed. Run `cabane-companion pair` again for a fresh one."
-      );
-    }
+    if (res.status === "expired") throw new EnrollmentExpiredError();
     if (res.status === "slow_down") intervalMs += 1e3;
   }
-  throw new CompanionError(
-    "this pairing code expired before it was confirmed. Run `cabane-companion pair` again for a fresh one."
-  );
+  throw new EnrollmentExpiredError();
 }
 
 // src/pairing-config.ts
@@ -1542,16 +1619,23 @@ function writePairedConfig(paired) {
   saveConfig(config);
   return { config, note };
 }
+function isDevicePaired() {
+  try {
+    return !!loadConfig()?.deviceToken;
+  } catch {
+    return false;
+  }
+}
 
 // src/commands/pair.ts
 function writePairedConfigCli(paired) {
   const { note } = writePairedConfig(paired);
   if (note) process.stderr.write(`note: ${note}
 `);
-  const labelSuffix = paired.deviceLabel ? ` as "${paired.deviceLabel}"` : "";
+  const owner = paired.ownerName ? `${paired.ownerName}'s` : "your Cabane";
   process.stdout.write(
-    `\u2713 Paired this device${labelSuffix} with ${paired.baseUrl}.
-Run \`cabane-companion start\` \u2014 it will pull the agents assigned to this device and run them.
+    `  \u2713 Paired to ${owner} account.
+  Run \`cabane-companion start\` \u2014 it connects a harness, runs in the background, and pulls this device's agents.
 `
   );
 }
@@ -1567,16 +1651,476 @@ function writeCompletedPairing(raw) {
   }
   writePairedConfigCli(paired);
 }
-async function pair(opts = {}) {
-  const baseUrl = resolvePairBaseUrl(opts.server);
-  const paired = await runDeviceFlow(baseUrl, (line) => process.stdout.write(`${line}
-`));
-  writePairedConfigCli(paired);
+async function pair(opts = {}) {
+  const baseUrl = resolvePairBaseUrl(opts.server);
+  const paired = await runDeviceFlow(baseUrl, (line) => process.stdout.write(`${line}
+`), {
+    // The hostname rides the mint here too, so a `pair`-then-`start` device is
+    // named exactly as a one-command one is.
+    ...deviceLabelFromHostname(hostname()) ? { label: deviceLabelFromHostname(hostname()) } : {}
+  });
+  writePairedConfigCli(paired);
+}
+
+// src/cli.ts
+import { readFileSync as readFileSync12 } 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/logger.ts
+import { createWriteStream, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+import pino from "pino";
+import pretty from "pino-pretty";
+function companionLogPath() {
+  return join5(cabaneDir(), "companion.log");
+}
+var CONSOLE_IGNORE = [
+  "pid",
+  "hostname",
+  "workspaceId",
+  "conversationId",
+  "agentId",
+  "messageId",
+  "sessionId",
+  "companionId"
+].join(",");
+function consoleShortId(log) {
+  const id = log.conversationId ?? log.workspaceId;
+  return typeof id === "string" && id.length > 0 ? id.slice(0, 8) : null;
+}
+function consoleMessageFormat(log, messageKey) {
+  const short = consoleShortId(log);
+  const msg = String(log[messageKey] ?? "");
+  return short ? `${short} ${msg}` : msg;
+}
+var cached = null;
+var consoleLogging = true;
+function setConsoleLogging(enabled) {
+  consoleLogging = enabled;
+}
+function createLogger(destinations = {}) {
+  const path = companionLogPath();
+  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),
+      ...destinations.console ? { destination: destinations.console } : {}
+    });
+    streams.push({
+      level: "info",
+      stream: {
+        write(chunk) {
+          if (consoleLogging) consoleStream.write(chunk);
+        }
+      }
+    });
+  }
+  streams.push({
+    level: "debug",
+    stream: destinations.file ?? createWriteStream(path, { flags: "a" })
+  });
+  return pino({ level: "debug" }, pino.multistream(streams));
+}
+function getLogger() {
+  if (cached) return cached;
+  cached = createLogger();
+  return cached;
+}
+
+// src/service/host.ts
+var RUN_TIMEOUT_MS = 1e4;
+function defaultServiceHost() {
+  if (process.env.VITEST) {
+    throw new Error(
+      "defaultServiceHost() was reached during a test run \u2014 it shells out to the real service manager. Inject a fake host (apps/companion/test/service-host-fake.ts) instead."
+    );
+  }
+  return {
+    platform: process.platform,
+    env: process.env,
+    home: homedir3(),
+    uid: process.getuid?.() ?? 0,
+    execPath: process.execPath,
+    cliPath: companionCliEntry(),
+    logPath: companionLogPath(),
+    fs: {
+      read: (path) => {
+        try {
+          return readFileSync4(path, "utf8");
+        } catch {
+          return null;
+        }
+      },
+      write: (path, contents) => writeFileSync4(path, contents, "utf8"),
+      remove: (path) => rmSync5(path, { force: true }),
+      exists: (path) => existsSync6(path),
+      mkdirp: (dir2) => {
+        mkdirSync6(dir2, { recursive: true });
+      }
+    },
+    run: (cmd, args) => {
+      const res = spawnSync(cmd, args, { encoding: "utf8", timeout: RUN_TIMEOUT_MS });
+      return {
+        ok: res.status === 0,
+        stdout: res.stdout ?? "",
+        stderr: res.stderr ?? (res.error ? res.error.message : "")
+      };
+    }
+  };
+}
+
+// src/service/launchd.ts
+import { join as join6 } from "path";
+var LAUNCHD_LABEL = "ai.cabane.companion";
+function launchAgentPath(home) {
+  return join6(home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function renderPlist(input) {
+  const args = input.programArguments.map((a) => `    <string>${xml(a)}</string>`).join("\n");
+  const env = Object.entries(input.environment).map(([k, v]) => `    <key>${xml(k)}</key>
+    <string>${xml(v)}</string>`).join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    "  <key>Label</key>",
+    `  <string>${LAUNCHD_LABEL}</string>`,
+    "  <key>ProgramArguments</key>",
+    "  <array>",
+    args,
+    "  </array>",
+    "  <key>RunAtLoad</key>",
+    "  <true/>",
+    "  <key>KeepAlive</key>",
+    "  <dict>",
+    "    <key>SuccessfulExit</key>",
+    "    <false/>",
+    "  </dict>",
+    "  <key>EnvironmentVariables</key>",
+    "  <dict>",
+    env,
+    "  </dict>",
+    "  <key>StandardOutPath</key>",
+    `  <string>${xml(input.logPath)}</string>`,
+    "  <key>StandardErrorPath</key>",
+    `  <string>${xml(input.logPath)}</string>`,
+    "</dict>",
+    "</plist>",
+    ""
+  ].join("\n");
+}
+function domain(host) {
+  return `gui/${host.uid}`;
+}
+function target(host) {
+  return `${domain(host)}/${LAUNCHD_LABEL}`;
+}
+function launchdStart(host, plistPath) {
+  host.run("launchctl", ["bootout", target(host)]);
+  const res = host.run("launchctl", ["bootstrap", domain(host), plistPath]);
+  return res.ok ? { ok: true } : { ok: false, detail: firstLine(res.stderr || res.stdout) };
+}
+function launchdStop(host) {
+  const res = host.run("launchctl", ["bootout", target(host)]);
+  if (res.ok || notLoaded(res.stderr + res.stdout)) return { ok: true };
+  return { ok: false, detail: firstLine(res.stderr || res.stdout) };
+}
+function launchdProbe(host) {
+  const res = host.run("launchctl", ["print", target(host)]);
+  if (res.ok) {
+    const state = /state\s*=\s*(\w+)/.exec(res.stdout)?.[1];
+    return { ownership: "held", running: state ? state === "running" : "unknown" };
+  }
+  return notLoaded(res.stderr + res.stdout) ? { ownership: "clear", running: false } : { ownership: "unknown", running: "unknown" };
+}
+function launchdRemove(host, plistPath) {
+  const stopped = launchdStop(host);
+  if (!stopped.ok) return stopped;
+  host.fs.remove(plistPath);
+  return { ok: true };
+}
+var NOT_LOADED = new RegExp(
+  `no such process|(could not find|not find service)[^\\n]*${LAUNCHD_LABEL.replace(
+    /[.*+?^${}()|[\]\\]/g,
+    "\\$&"
+  )}`,
+  "i"
+);
+function notLoaded(output) {
+  return NOT_LOADED.test(output);
+}
+function firstLine(s) {
+  return s.trim().split("\n")[0] ?? "";
+}
+function xml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/service/systemd.ts
+import { dirname as dirname4, join as join7 } from "path";
+var SYSTEMD_UNIT = "cabane-companion.service";
+function systemdUnitPath(host) {
+  const configHome = host.env.XDG_CONFIG_HOME?.trim() ? host.env.XDG_CONFIG_HOME.trim() : join7(host.home, ".config");
+  return join7(configHome, "systemd", "user", SYSTEMD_UNIT);
+}
+function renderUnit(input) {
+  const [exec, ...rest] = input.programArguments;
+  const execStart = [quote(exec ?? ""), ...rest.map(quote)].join(" ");
+  const env = Object.entries(input.environment).map(([k, v]) => `Environment=${k}=${v}`);
+  return [
+    "[Unit]",
+    "Description=Cabane Companion \u2014 keeps this device answering while you are logged in",
+    "After=network-online.target",
+    "Wants=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    ...env,
+    `ExecStart=${execStart}`,
+    "Restart=on-failure",
+    "RestartSec=5",
+    "",
+    "[Install]",
+    "WantedBy=default.target"
+  ].join("\n") + "\n";
+}
+function systemdReload(host) {
+  host.run("systemctl", ["--user", "daemon-reload"]);
+}
+function systemdStart(host) {
+  systemdReload(host);
+  const enabled = host.run("systemctl", ["--user", "enable", SYSTEMD_UNIT]);
+  if (!enabled.ok) return { ok: false, detail: firstLine2(enabled.stderr || enabled.stdout) };
+  const started = host.run("systemctl", ["--user", "restart", SYSTEMD_UNIT]);
+  if (!started.ok) return { ok: false, detail: firstLine2(started.stderr || started.stdout) };
+  return { ok: true };
+}
+function systemdStop(host) {
+  const res = host.run("systemctl", ["--user", "stop", SYSTEMD_UNIT]);
+  if (res.ok || notLoaded2(res.stderr + res.stdout)) return { ok: true };
+  return { ok: false, detail: firstLine2(res.stderr || res.stdout) };
+}
+function systemdProbe(host) {
+  const state = host.run("systemctl", ["--user", "is-active", SYSTEMD_UNIT]).stdout.trim();
+  if (state === "active") return { ownership: "held", running: true };
+  if (state === "activating" || state === "reloading" || state === "deactivating") {
+    return { ownership: "held", running: "transitional" };
+  }
+  if (state === "inactive" || state === "failed") return { ownership: "clear", running: false };
+  return { ownership: "unknown", running: "unknown" };
+}
+function systemdWantsLinkPath(host) {
+  return join7(dirname4(systemdUnitPath(host)), "default.target.wants", SYSTEMD_UNIT);
+}
+function systemdInstalled(host) {
+  return host.fs.exists(systemdUnitPath(host)) || host.fs.exists(systemdWantsLinkPath(host));
+}
+function systemdRemove(host, unitPath) {
+  const stopped = host.run("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT]);
+  if (!(stopped.ok || notLoaded2(stopped.stderr + stopped.stdout))) {
+    return { ok: false, detail: firstLine2(stopped.stderr || stopped.stdout) };
+  }
+  host.fs.remove(unitPath);
+  const link = systemdWantsLinkPath(host);
+  if (host.fs.exists(link)) host.fs.remove(link);
+  systemdReload(host);
+  return { ok: true };
+}
+var NOT_LOADED2 = new RegExp(
+  `unit (file )?${SYSTEMD_UNIT.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} (not loaded|does not exist|not found|could not be found)`,
+  "i"
+);
+function notLoaded2(output) {
+  return NOT_LOADED2.test(output);
+}
+function readLinger(host) {
+  const res = host.run("loginctl", ["show-user", String(host.uid), "-p", "Linger"]);
+  if (!res.ok) return "unknown";
+  const match = /Linger=(\w+)/.exec(res.stdout);
+  if (!match) return "unknown";
+  return match[1] === "yes" ? "yes" : "no";
+}
+function tryEnableLinger(host) {
+  host.run("loginctl", ["enable-linger", String(host.uid)]);
+  return readLinger(host);
+}
+function isRemoteSession(env) {
+  return Boolean(env.SSH_CONNECTION || env.SSH_TTY || env.SSH_CLIENT);
+}
+function quote(value) {
+  return `"${value.replace(/(["\\])/g, "\\$1")}"`;
+}
+function firstLine2(s) {
+  return s.trim().split("\n")[0] ?? "";
+}
+
+// src/service/index.ts
+function detectServiceManager(host = defaultServiceHost()) {
+  if (host.platform === "darwin") return "launchd";
+  if (host.platform !== "linux") return "none";
+  return host.run("systemctl", ["--user", "show-environment"]).ok ? "systemd-user" : "none";
+}
+function programArguments(host, _opts) {
+  return [host.execPath, host.cliPath, "start", "--foreground"];
+}
+function environment(host) {
+  return {
+    // PATH CAPTURE. launchd's default PATH is `/usr/bin:/bin:/usr/sbin:/sbin`
+    // and a systemd user manager's is barely better — neither has `claude`,
+    // `codex` or `opencode` on it. A companion that runs but can't find its
+    // harness is worse than one that isn't running, because the device reads
+    // Online. So we bake in the PATH of the shell that ran `start`, and because
+    // it's part of the rendered content, a PATH that later drifts re-renders on
+    // the next `start` like any other change.
+    PATH: host.env.PATH ?? "",
+    CABANE_COMPANION_DAEMON: "1"
+  };
+}
+function unitPathFor(host, manager) {
+  if (manager === "launchd") return launchAgentPath(host.home);
+  if (manager === "systemd-user") return systemdUnitPath(host);
+  return null;
+}
+function renderFor(host, manager, opts) {
+  const input = { programArguments: programArguments(host, opts), environment: environment(host) };
+  return manager === "launchd" ? renderPlist({ ...input, logPath: host.logPath }) : renderUnit(input);
+}
+function installService(opts = {}, host = defaultServiceHost()) {
+  const manager = detectServiceManager(host);
+  if (manager === "none") return { installed: false, reason: "unsupported" };
+  const path = unitPathFor(host, manager);
+  if (!path) return { installed: false, reason: "unsupported" };
+  const desired = renderFor(host, manager, opts);
+  const existing = host.fs.read(path);
+  const hadUnit = existing !== null;
+  const changed = existing !== desired;
+  if (changed) {
+    host.fs.mkdirp(dirname5(path));
+    host.fs.write(path, desired);
+  }
+  if (manager === "systemd-user") {
+    const linger = ensureLinger(host);
+    if (linger !== "yes" && isRemoteSession(host.env)) {
+      systemdRemove(host, path);
+      return failedInstall(
+        host,
+        manager,
+        "linger-unavailable",
+        "a systemd --user service would stop when this SSH session ends (lingering is off and could not be enabled)"
+      );
+    }
+  }
+  const started = manager === "launchd" ? launchdStart(host, path) : systemdStart(host);
+  if (!started.ok) {
+    if (!hadUnit) removeService(host, manager, path);
+    return failedInstall(host, manager, "command-failed", started.detail);
+  }
+  return { installed: true, manager, changed };
+}
+function failedInstall(host, manager, reason, detail) {
+  return {
+    installed: false,
+    reason,
+    ...detail ? { detail } : {},
+    ...managerOwnership(host, manager) === "clear" ? {} : { leftBehind: manager }
+  };
+}
+function managerProbe(host, manager) {
+  if (manager === "launchd") return launchdProbe(host);
+  if (manager === "systemd-user") return systemdProbe(host);
+  return { ownership: "clear", running: false };
+}
+function managerOwnership(host, manager) {
+  return managerProbe(host, manager).ownership;
+}
+function refreshInstalledService(opts = {}, host = defaultServiceHost()) {
+  const manager = detectServiceManager(host);
+  const path = unitPathFor(host, manager);
+  if (!path || !host.fs.exists(path)) return false;
+  const desired = renderFor(host, manager, opts);
+  if (host.fs.read(path) === desired) return false;
+  host.fs.write(path, desired);
+  if (manager === "systemd-user") systemdReload(host);
+  return true;
+}
+function stopService(host = defaultServiceHost()) {
+  const manager = detectServiceManager(host);
+  const path = unitPathFor(host, manager);
+  if (manager === "none" || !path || !managerHasClaim(host, manager, path)) {
+    return { handled: false, ok: true };
+  }
+  const res = manager === "launchd" ? launchdStop(host) : systemdStop(host);
+  return {
+    handled: true,
+    ok: res.ok,
+    manager,
+    ...res.detail ? { detail: res.detail } : {}
+  };
+}
+function disableService(host = defaultServiceHost()) {
+  const manager = detectServiceManager(host);
+  const path = unitPathFor(host, manager);
+  if (manager === "none" || !path) return { handled: false, ok: true };
+  if (!managerHasClaim(host, manager, path)) return { handled: false, ok: true, manager };
+  const res = removeService(host, manager, path);
+  return { handled: true, ok: res.ok, manager, ...res.detail ? { detail: res.detail } : {} };
+}
+function managerHasClaim(host, manager, path) {
+  if (manager === "none") return false;
+  if (host.fs.exists(path)) return true;
+  if (manager === "systemd-user" && systemdInstalled(host)) return true;
+  return managerOwnership(host, manager) !== "clear";
+}
+function removeService(host, manager, path) {
+  return manager === "launchd" ? launchdRemove(host, path) : systemdRemove(host, path);
+}
+function serviceStatus(host = defaultServiceHost()) {
+  const manager = detectServiceManager(host);
+  const path = unitPathFor(host, manager);
+  const probe = managerProbe(host, manager);
+  const installed = manager === "none" || !path ? false : host.fs.exists(path) || probe.ownership === "held" || manager === "systemd-user" && systemdInstalled(host);
+  const running = manager === "none" ? false : probe.running;
+  return {
+    manager,
+    unitPath: path,
+    installed,
+    running,
+    linger: manager === "systemd-user" ? readLinger(host) : null,
+    remoteSession: isRemoteSession(host.env)
+  };
+}
+function ensureLinger(host) {
+  const current = readLinger(host);
+  if (current === "yes") return current;
+  return tryEnableLinger(host);
 }
 
-// src/cli.ts
-import { readFileSync as readFileSync12 } from "fs";
-
 // src/commands/service.ts
 function serviceStatusCommand(deps = {}) {
   const status2 = (deps.status ?? serviceStatus)();
@@ -1641,50 +2185,22 @@ function lingerNote(status2) {
   return " \u2014 the service runs while you are logged in";
 }
 
-// src/browser.ts
-import { spawn as spawn5 } from "child_process";
-import { platform } from "process";
-function openBrowser(url) {
-  try {
-    const { command, args } = openerFor(url);
-    const child = spawn5(command, args, { stdio: "ignore", detached: true });
-    child.on("error", () => {
-    });
-    child.unref();
-  } catch {
-  }
-}
-function openerFor(url) {
-  switch (platform) {
-    case "darwin":
-      return { command: "open", args: [url] };
-    case "win32":
-      return { command: "cmd", args: ["/c", "start", "", url] };
-    default:
-      return { command: "xdg-open", args: [url] };
-  }
-}
-function shouldAutoOpen(opts) {
-  if (opts.flagOpen === true) return true;
-  if (opts.flagOpen === false) return false;
-  if (process.env.COMPANION_NO_OPEN === "1") return false;
-  if (opts.configAutoOpen === true) return true;
-  return false;
-}
+// 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 join8 } from "path";
+import { dirname as dirname6, join as join9 } 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 existsSync6 } from "fs";
+import { openSync as openSync2, readSync, closeSync as closeSync2, fstatSync, existsSync as existsSync7 } from "fs";
 import { readFile } from "fs/promises";
-import { extname, join as join7, normalize } from "path";
+import { extname, join as join8, normalize } from "path";
 import { streamSSE } from "hono/streaming";
 
 // src/state.ts
@@ -1933,14 +2449,14 @@ var CONTENT_TYPES = {
 function registerRoutes(app, deps) {
   const { supervisor, hub, staticDir } = deps;
   app.get("/", async (c) => {
-    const html = await readFile(join7(staticDir, "index.html"), "utf8");
+    const html = await readFile(join8(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 = join7(staticDir, safe3);
-    if (!full.startsWith(staticDir) || !existsSync6(full)) return c.notFound();
+    const full = join8(staticDir, safe3);
+    if (!full.startsWith(staticDir) || !existsSync7(full)) return c.notFound();
     const body = await readFile(full);
     const type = CONTENT_TYPES[extname(full).toLowerCase()] ?? "application/octet-stream";
     c.header("content-type", type);
@@ -2067,11 +2583,11 @@ function clampLimit(raw, fallback, max = 200) {
   return Math.min(Math.floor(n), max);
 }
 function tailFile(path, lines) {
-  if (!existsSync6(path)) return [];
+  if (!existsSync7(path)) return [];
   const MAX_BYTES = 256 * 1024;
   let fd;
   try {
-    fd = openSync3(path, "r");
+    fd = openSync2(path, "r");
     const size = fstatSync(fd).size;
     const start2 = Math.max(0, size - MAX_BYTES);
     const len = size - start2;
@@ -2085,7 +2601,7 @@ function tailFile(path, lines) {
   } catch {
     return [];
   } finally {
-    if (fd !== void 0) closeSync3(fd);
+    if (fd !== void 0) closeSync2(fd);
   }
 }
 
@@ -2156,7 +2672,7 @@ function isAddrInUse(err) {
   return Boolean(err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE");
 }
 function resolveStaticDir() {
-  return join8(dirname6(fileURLToPath2(import.meta.url)), "static");
+  return join9(dirname6(fileURLToPath2(import.meta.url)), "static");
 }
 
 // src/api.ts
@@ -2632,20 +3148,20 @@ function errorMessage2(status2, body) {
 }
 
 // src/cursor.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
-import { join as join9 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync8 } from "fs";
+import { join as join10 } from "path";
 function pathFor(workspaceId) {
-  return join9(cabaneDir(), "cursors", encodeURIComponent(workspaceId));
+  return join10(cabaneDir(), "cursors", encodeURIComponent(workspaceId));
 }
 function readCursor(workspaceId) {
   const path = pathFor(workspaceId);
-  if (!existsSync7(path)) return null;
+  if (!existsSync8(path)) return null;
   const raw = readFileSync5(path, "utf8").trim();
   return raw.length > 0 ? raw : null;
 }
 function writeCursor(workspaceId, eventId) {
   const path = pathFor(workspaceId);
-  mkdirSync7(join9(cabaneDir(), "cursors"), { recursive: true });
+  mkdirSync7(join10(cabaneDir(), "cursors"), { recursive: true });
   writeFileSync5(path, eventId + "\n", "utf8");
 }
 
@@ -2689,18 +3205,18 @@ var CursorTracker = class {
 };
 
 // src/dispatch-dedupe.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync9 } from "fs";
+import { join as join11 } from "path";
 var MAX_IDS = 256;
 function dir(log) {
-  return join10(cabaneDir(), log);
+  return join11(cabaneDir(), log);
 }
 function pathFor2(log, workspaceId) {
-  return join10(dir(log), encodeURIComponent(workspaceId));
+  return join11(dir(log), encodeURIComponent(workspaceId));
 }
 function readIds(log, workspaceId) {
   const path = pathFor2(log, workspaceId);
-  if (!existsSync8(path)) return [];
+  if (!existsSync9(path)) return [];
   try {
     return readFileSync6(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
   } catch {
@@ -2732,15 +3248,15 @@ function markCompleted(workspaceId, eventId) {
 }
 var MAX_RESUME_ATTEMPTS = 3;
 function resumeDir() {
-  return join10(cabaneDir(), "resume-attempts");
+  return join11(cabaneDir(), "resume-attempts");
 }
 function resumePathFor(workspaceId) {
-  return join10(resumeDir(), encodeURIComponent(workspaceId));
+  return join11(resumeDir(), encodeURIComponent(workspaceId));
 }
 function readResumeCounts(workspaceId) {
   const out = /* @__PURE__ */ new Map();
   const path = resumePathFor(workspaceId);
-  if (!existsSync8(path)) return out;
+  if (!existsSync9(path)) return out;
   try {
     for (const line of readFileSync6(path, "utf8").split("\n")) {
       const trimmed = line.trim();
@@ -4654,7 +5170,7 @@ async function acquireServerTurnLock(url) {
   };
 }
 function createHttpOpencodeTransport(opts) {
-  const base = trimSlash2(opts.baseUrl);
+  const base = trimSlash(opts.baseUrl);
   const doFetch = opts.fetchImpl ?? fetch;
   return {
     async run(spec, signal) {
@@ -4800,7 +5316,7 @@ function belongsToSession(ev, sessionId) {
 function newOpencodeMessageId() {
   return `msg_${crypto.randomUUID().replace(/-/g, "")}`;
 }
-function trimSlash2(s) {
+function trimSlash(s) {
   return s.endsWith("/") ? s.slice(0, -1) : s;
 }
 
@@ -5550,7 +6066,13 @@ function parseCodexModel(model) {
 var CABANE_MCP_SERVER3 = "cabane";
 var TURN_CONTROL_MCP_SERVER2 = "cabane_companion";
 var ACTIVE_CONVERSATION_HEADER4 = "x-cabane-active-conversation";
-var ENV_ENVELOPE_KEYS = ["CABANE_ENV_TIER", "CABANE_ENV_KEY", "CABANE_ENV_BINDING"];
+var ENV_ENVELOPE_KEYS = [
+  "CABANE_PLAYGROUND",
+  "CABANE_PLAYGROUND_BIN",
+  "CABANE_CONVERSATION_ID",
+  "CABANE_AGENT_ID",
+  "CABANE_CONVERSATION_TITLE"
+];
 function buildRunSpec2(req, resumeThreadId, instructionsFile = null, threadPromptFingerprint = null) {
   const { policy, config } = req;
   const directory = req.local.cwd ?? "";
@@ -6455,8 +6977,8 @@ var ConnectorHealthStore = class {
 
 // src/dispatcher.ts
 import { randomUUID } from "crypto";
-import { appendFileSync as appendFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync11, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join15 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync12, mkdirSync as mkdirSync11, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join16 } from "path";
 
 // src/summon.ts
 import { z as z12 } from "zod";
@@ -6730,10 +7252,10 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
 
 // src/build-options.ts
 function cabaneMcpUrl(baseUrl) {
-  return `${trimSlash3(baseUrl)}/api/mcp`;
+  return `${trimSlash2(baseUrl)}/api/mcp`;
 }
 function turnControlMcpUrl(baseUrl) {
-  return `${trimSlash3(baseUrl)}/api/turn-control`;
+  return `${trimSlash2(baseUrl)}/api/turn-control`;
 }
 function buildCompanionTurnRequest(params) {
   const { turnContext: t } = params;
@@ -6782,18 +7304,18 @@ function buildCompanionTurnRequest(params) {
     }
   };
 }
-function trimSlash3(s) {
+function trimSlash2(s) {
   return s.endsWith("/") ? s.slice(0, -1) : s;
 }
 
 // src/codex-instructions.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 var PREFIX = "cabane-codex-instructions-";
 async function writeCodexInstructionsFile(contents) {
-  const dir2 = await mkdtemp(join11(tmpdir(), PREFIX));
-  const path = join11(dir2, "instructions.md");
+  const dir2 = await mkdtemp(join12(tmpdir(), PREFIX));
+  const path = join12(dir2, "instructions.md");
   await writeFile(path, contents, { encoding: "utf8", mode: 384 });
   return {
     path,
@@ -6804,20 +7326,20 @@ async function writeCodexInstructionsFile(contents) {
 }
 
 // src/prepared.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync7, rmSync as rmSync5, writeFileSync as writeFileSync7, existsSync as existsSync9 } from "fs";
-import { join as join12 } from "path";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync7, existsSync as existsSync10 } from "fs";
+import { join as join13 } from "path";
 function dirFor(workspaceId) {
-  return join12(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
+  return join13(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
 }
 function conversationDir(workspaceId, conversationId) {
-  return join12(dirFor(workspaceId), encodeURIComponent(conversationId));
+  return join13(dirFor(workspaceId), encodeURIComponent(conversationId));
 }
 function pathFor3(workspaceId, conversationId, agentId) {
-  return join12(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
+  return join13(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
 }
 function readPrepared(workspaceId, conversationId, agentId) {
   const path = pathFor3(workspaceId, conversationId, agentId);
-  if (!existsSync9(path)) return null;
+  if (!existsSync10(path)) return null;
   try {
     const parsed = JSON.parse(readFileSync7(path, "utf8"));
     if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
@@ -6840,21 +7362,21 @@ function writePrepared(workspaceId, conversationId, agentId, result) {
   );
 }
 function clearPrepared(workspaceId, conversationId, agentId) {
-  rmSync5(pathFor3(workspaceId, conversationId, agentId), { force: true });
+  rmSync6(pathFor3(workspaceId, conversationId, agentId), { force: true });
 }
 
 // src/secrets.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { join as join14 } from "path";
 import { z as z13 } from "zod";
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function secretsPath() {
-  return join13(cabaneDir(), "secrets.json");
+  return join14(cabaneDir(), "secrets.json");
 }
 var secretStoreSchema = z13.record(z13.string(), z13.string());
 function loadSecretStore() {
   const path = secretsPath();
-  if (!existsSync10(path)) return makeStore({});
+  if (!existsSync11(path)) return makeStore({});
   let raw;
   try {
     raw = readFileSync8(path, "utf8");
@@ -6935,10 +7457,10 @@ function resolveMcpSecrets(mcpServers, store) {
 }
 
 // src/transcript-writer.ts
-import { appendFileSync, chmodSync as chmodSync3, mkdirSync as mkdirSync10, readdirSync, rmSync as rmSync6 } from "fs";
-import { join as join14 } from "path";
+import { appendFileSync, chmodSync as chmodSync3, mkdirSync as mkdirSync10, readdirSync, rmSync as rmSync7 } from "fs";
+import { join as join15 } from "path";
 function transcriptsDir() {
-  return join14(cabaneDir(), "transcripts");
+  return join15(cabaneDir(), "transcripts");
 }
 var RETAIN = 200;
 var TranscriptWriter = class {
@@ -6947,7 +7469,7 @@ var TranscriptWriter = class {
   onWarn;
   constructor(dir2, meta, onWarn) {
     this.onWarn = onWarn;
-    this.path = join14(dir2, fileName(meta));
+    this.path = join15(dir2, fileName(meta));
     try {
       mkdirSync10(dir2, { recursive: true });
       try {
@@ -7006,7 +7528,7 @@ function pruneOld(dir2, retain) {
   const drop = files.sort().slice(0, files.length - retain);
   for (const f of drop) {
     try {
-      rmSync6(join14(dir2, f), { force: true });
+      rmSync7(join15(dir2, f), { force: true });
     } catch {
     }
   }
@@ -7352,7 +7874,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 (!existsSync11(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
+  if (!existsSync12(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
   let entries;
   try {
     entries = readdirSync2(cwd);
@@ -7362,15 +7884,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 = join15(cwd, ".git");
-  if (!existsSync11(gitPath)) return { ok: true, reason: "usable" };
+  const gitPath = join16(cwd, ".git");
+  if (!existsSync12(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() && !existsSync11(join15(gitPath, "HEAD")))
+  if (stat.isDirectory() && !existsSync12(join16(gitPath, "HEAD")))
     return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
   return { ok: true, reason: "usable" };
 }
@@ -7561,7 +8083,7 @@ var Dispatcher = class {
     let seqCounter = 0;
     const nextSeq = () => ++seqCounter;
     let effectiveCwd = localCwd ?? cabaneCwd;
-    if (effectiveCwd && !existsSync11(effectiveCwd)) {
+    if (effectiveCwd && !existsSync12(effectiveCwd)) {
       turnLog.warn(
         { cwd: effectiveCwd },
         "dispatcher: configured working directory does not exist on this device \u2014 falling back to the process cwd"
@@ -7869,7 +8391,7 @@ ${reason}`,
         }
         return this.concludeBeforeRun(payload, turnLog, startedAt, reason);
       }
-      const receiptPath = join15(effectiveCwd, ".git", "cabane", "readiness.jsonl");
+      const receiptPath = join16(effectiveCwd, ".git", "cabane", "readiness.jsonl");
       const receiptLine = (fields) => `${JSON.stringify({
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         taskId: hookEnv.CABANE_TASK_ID,
@@ -7893,7 +8415,7 @@ ${reason}`,
       })}
 `;
       try {
-        mkdirSync11(join15(effectiveCwd, ".git", "cabane"), { recursive: true });
+        mkdirSync11(join16(effectiveCwd, ".git", "cabane"), { recursive: true });
         appendFileSync2(
           receiptPath,
           // `starting` is the honest classification before the proof has run. The
@@ -8298,224 +8820,28 @@ ${reason}`,
     this.notifyEnd({
       id: dispatchId,
       ok: false,
-      durationMs,
-      ...resultReason ? { reason: resultReason } : {}
-    });
-    return {
-      ok: false,
-      durationMs,
-      ...resultReason ? { reason: resultReason } : {}
-    };
-  }
-  // SJ383: cancel a specific (conversation, agent) run if one is in flight in
-  // THIS companion process. Returns true if an in-flight run was aborted.
-  cancel(conversationId, agentId) {
-    const key = runKey(conversationId, agentId);
-    const ac = this.aborts.get(key);
-    if (!ac) return false;
-    try {
-      ac.abort();
-    } catch {
-    }
-    return true;
-  }
-};
-
-// src/manifest.ts
-var DEVICE_MANIFEST = {
-  runtimes: [{ name: "claude-code", version: null }],
-  capabilities: { hostFs: true, browser: true, userMcp: true }
-};
-function buildCompanionManifest(opts) {
-  const v = opts.versions ?? {};
-  const runtimes = [];
-  if (opts.claudeCode) runtimes.push({ name: "claude-code", version: v.claudeCode ?? null });
-  if (opts.opencode) runtimes.push({ name: "opencode", version: v.opencode ?? null });
-  if (opts.codex) runtimes.push({ name: "codex", version: v.codex ?? null });
-  return { runtimes, capabilities: { ...DEVICE_MANIFEST.capabilities } };
-}
-
-// src/harness-status.ts
-var LABELS = {
-  "claude-code": "Claude Code",
-  codex: "Codex",
-  opencode: "opencode"
-};
-function deriveHarnessSnapshot(signals) {
-  const advertised = new Set(
-    buildCompanionManifest({
-      // CT1082: connected AND installed — the manifest's own rule, restated here
-      // through the same function rather than re-decided.
-      claudeCode: signals.claudeCodeConnected && signals.claudeOnPath,
-      opencode: signals.opencodeConfigured,
-      codex: signals.codexEnabled
-    }).runtimes.map((r) => r.name)
-  );
-  const harnesses = [
-    deriveClaudeCode(signals, advertised.has("claude-code")),
-    deriveCodex(signals, advertised.has("codex")),
-    deriveOpencode(signals, advertised.has("opencode"))
-  ];
-  return { harnesses, anyExposed: harnesses.some((h) => h.state === "exposed") };
-}
-function deriveClaudeCode(signals, manifestHas) {
-  const base = { runtime: "claude-code", label: LABELS["claude-code"] };
-  if (manifestHas) {
-    return {
-      ...base,
-      state: "exposed",
-      version: signals.claudeVersion,
-      detail: "Claude Code is connected and exposed to Cabane.",
-      enable: null
-    };
-  }
-  if (signals.claudeCodeConnected) {
-    return {
-      ...base,
-      state: "needs_attention",
-      version: null,
-      detail: "Connected, but the `claude` CLI isn\u2019t on your PATH. Install it (`npm i -g @anthropic-ai/claude-code`) and sign in, or disconnect it.",
-      enable: null
-    };
-  }
-  if (signals.claudeOnPath) {
-    return {
-      ...base,
-      state: "detected_not_exposed",
-      version: signals.claudeVersion,
-      detail: "Claude Code is installed here but not connected yet. Connect it to let Cabane run Claude Code on this device.",
-      enable: "claude-code"
-    };
-  }
-  return {
-    ...base,
-    state: "not_detected",
-    version: null,
-    detail: "Not detected. Install Claude Code (`npm i -g @anthropic-ai/claude-code`) and sign in with `claude`, then connect it here.",
-    enable: null
-  };
-}
-function deriveCodex(signals, manifestHas) {
-  const base = { runtime: "codex", label: LABELS.codex };
-  if (manifestHas) {
-    if (signals.codexOnPath) {
-      return {
-        ...base,
-        state: "exposed",
-        version: signals.codexVersion,
-        detail: "Codex is enabled and exposed to Cabane.",
-        enable: null
-      };
-    }
-    return {
-      ...base,
-      state: "needs_attention",
-      version: null,
-      detail: "Enabled, but the `codex` CLI isn\u2019t on your PATH. Install it and sign in (`codex login`), or turn Codex off.",
-      enable: null
-    };
-  }
-  if (signals.codexOnPath) {
-    return {
-      ...base,
-      state: "detected_not_exposed",
-      version: signals.codexVersion,
-      detail: "Codex is installed but not exposed yet. Turn it on to let Cabane run Codex here.",
-      enable: "codex"
-    };
-  }
-  return {
-    ...base,
-    state: "not_detected",
-    version: null,
-    detail: "Not detected. Install the Codex CLI and sign in (`codex login`), then enable it here.",
-    enable: null
-  };
-}
-function deriveOpencode(signals, manifestHas) {
-  const base = { runtime: "opencode", label: LABELS.opencode };
-  if (manifestHas) {
-    if (signals.opencodeReachable) {
-      return {
-        ...base,
-        state: "exposed",
-        version: signals.opencodeVersion,
-        detail: "An opencode server is reachable and exposed to Cabane.",
-        enable: null
-      };
-    }
-    return {
-      ...base,
-      state: "needs_attention",
-      version: null,
-      detail: "Configured, but the opencode server isn\u2019t answering. Start `opencode serve` and check the URL.",
-      enable: null
-    };
-  }
-  return {
-    ...base,
-    state: "not_detected",
-    version: null,
-    detail: "Not detected. Run `opencode serve` and add its URL here to expose opencode.",
-    enable: "opencode"
-  };
-}
-function detectedRuntimesFor(snapshot) {
-  return snapshot.harnesses.filter((h) => h.state === "detected_not_exposed").map((h) => ({ runtime: h.runtime, version: h.version }));
-}
-var PROBE_TIMEOUT_MS2 = 4e3;
-async function probeHarnessSignals(cfg, deps = {}) {
-  const probeClaudePresence = deps.probeClaudePresence ?? claudeOnPath;
-  const probeClaudeVersion = deps.probeClaudeVersion ?? (() => probeCliVersion("claude"));
-  const probeCodexVersion = deps.probeCodexVersion ?? (() => probeCliVersion("codex"));
-  const probeOpencode = deps.probeOpencode ?? ((url) => probeOpencodeVersion(url));
-  const serverUrl = cfg.opencode?.serverUrl;
-  const [claudeOnPathResult, claudeVersion, codexVersion, opencodeVersion] = await Promise.all([
-    withTimeout(probeClaudePresence(), false),
-    withTimeout(probeClaudeVersion(), null),
-    withTimeout(probeCodexVersion(), null),
-    serverUrl ? withTimeout(probeOpencode(serverUrl), null) : Promise.resolve(null)
-  ]);
-  return {
-    claudeOnPath: claudeOnPathResult,
-    claudeVersion,
-    // CT1082: the user's opt-in. Presence alone exposes nothing now, so this is
-    // the manifest gate and the probe above is only a suggestion.
-    claudeCodeConnected: isClaudeCodeConnected(cfg),
-    // A parseable `codex --version` is our presence signal (presence alone never
-    // exposes codex; its config flag is the manifest gate either way).
-    codexOnPath: codexVersion !== null,
-    codexVersion,
-    codexEnabled: isCodexEnabled(cfg),
-    opencodeConfigured: !!serverUrl,
-    // A version came back ⟺ the serve answered its health endpoint (CT584).
-    opencodeReachable: opencodeVersion !== null,
-    opencodeVersion
-  };
-}
-function withTimeout(promise, fallback) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const done = (v) => {
-      if (!settled) {
-        settled = true;
-        resolve(v);
-      }
+      durationMs,
+      ...resultReason ? { reason: resultReason } : {}
+    });
+    return {
+      ok: false,
+      durationMs,
+      ...resultReason ? { reason: resultReason } : {}
     };
-    const timer = setTimeout(() => done(fallback), PROBE_TIMEOUT_MS2);
-    timer.unref?.();
-    promise.then(
-      (v) => {
-        clearTimeout(timer);
-        done(v);
-      },
-      () => {
-        clearTimeout(timer);
-        done(fallback);
-      }
-    );
-  });
-}
+  }
+  // SJ383: cancel a specific (conversation, agent) run if one is in flight in
+  // THIS companion process. Returns true if an in-flight run was aborted.
+  cancel(conversationId, agentId) {
+    const key = runKey(conversationId, agentId);
+    const ac = this.aborts.get(key);
+    if (!ac) return false;
+    try {
+      ac.abort();
+    } catch {
+    }
+    return true;
+  }
+};
 
 // src/opencode-models.ts
 var OPENCODE_RUNTIME = "opencode";
@@ -8560,15 +8886,15 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
 
 // src/outbox.ts
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync12,
   readdirSync as readdirSync3,
   readFileSync as readFileSync9,
   renameSync as renameSync3,
-  rmSync as rmSync7,
+  rmSync as rmSync8,
   writeFileSync as writeFileSync8
 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 var MAX_ENTRIES = 2e3;
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var Outbox = class {
@@ -8581,10 +8907,10 @@ 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 join16(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
+    return join17(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
   }
   fileFor(turnId, seq) {
-    return join16(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+    return join17(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
@@ -8599,7 +8925,7 @@ var Outbox = class {
       renameSync3(tmp, target2);
     } catch (err) {
       try {
-        rmSync7(tmp, { force: true });
+        rmSync8(tmp, { force: true });
       } catch {
       }
       this.log?.warn(
@@ -8616,7 +8942,7 @@ var Outbox = class {
   // wedging the drain.
   list() {
     const dir2 = this.dir();
-    if (!existsSync12(dir2)) return [];
+    if (!existsSync13(dir2)) return [];
     let names;
     try {
       names = readdirSync3(dir2);
@@ -8626,7 +8952,7 @@ var Outbox = class {
     const entries = [];
     for (const name of names) {
       if (!name.endsWith(".json")) continue;
-      const full = join16(dir2, name);
+      const full = join17(dir2, name);
       try {
         const parsed = JSON.parse(readFileSync9(full, "utf8"));
         if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
@@ -8646,13 +8972,13 @@ var Outbox = class {
   // Remove a delivered (or terminally-discarded) entry. No-op if already gone.
   remove(turnId, seq) {
     try {
-      rmSync7(this.fileFor(turnId, seq), { force: true });
+      rmSync8(this.fileFor(turnId, seq), { force: true });
     } catch {
     }
   }
   size() {
     const dir2 = this.dir();
-    if (!existsSync12(dir2)) return 0;
+    if (!existsSync13(dir2)) return 0;
     try {
       return readdirSync3(dir2).filter((n) => n.endsWith(".json")).length;
     } catch {
@@ -8665,7 +8991,7 @@ var Outbox = class {
       "companion outbox: dropping unreadable entry"
     );
     try {
-      rmSync7(full, { force: true });
+      rmSync8(full, { force: true });
     } catch {
     }
   }
@@ -9594,6 +9920,26 @@ var CompanionSupervisor = class {
   async recheckHarnesses() {
     await this.refreshHarnessStatuses();
   }
+  // CT1085 §1 step 3: beat NOW and wait for it to land. `start` calls this
+  // between bringing the runtime up and asking the person anything, so the
+  // browser's connect step is already showing what this machine has ("your
+  // terminal is asking") rather than sitting blank while the terminal blocks on
+  // an answer. Coalesces with an in-flight beat rather than stacking a second.
+  async heartbeatNow() {
+    if (this.inFlightHeartbeat) {
+      await this.inFlightHeartbeat;
+      return;
+    }
+    this.kickHeartbeat();
+    if (this.inFlightHeartbeat) await this.inFlightHeartbeat;
+  }
+  // CT1085: the config as it stands right now — after any `enableHarness` write.
+  // The control socket's connect handler needs it to run the shake-out check
+  // against the URL/flag that was just persisted, not the one this process booted
+  // with.
+  currentConfig() {
+    return this.config;
+  }
   // Friendly enable for the config-driven harnesses — flip the flag the app owns in
   // `~/.cabane/config.json`, no hand-edited JSON. This is enable/expose ONLY: it
   // never installs a binary and never drives a login (BYO — Decided).
@@ -9807,10 +10153,10 @@ function handleUncaught(log, err, origin) {
 }
 
 // src/crash-marker.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync13, readFileSync as readFileSync10, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync13, readFileSync as readFileSync10, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "fs";
+import { join as join18 } from "path";
 function crashMarkerPath() {
-  return join17(cabaneDir(), "last-error.json");
+  return join18(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
@@ -9822,7 +10168,7 @@ function recordCrash(rec2) {
 function clearCrash() {
   try {
     const path = crashMarkerPath();
-    if (existsSync13(path)) rmSync8(path, { force: true });
+    if (existsSync14(path)) rmSync9(path, { force: true });
   } catch {
   }
 }
@@ -9841,7 +10187,13 @@ async function createCompanionRuntime(opts = {}) {
         onPath ? "companion: carried Claude Code over as a connected harness on this device (connectors are now chosen, not detected)" : "companion: no Claude Code on PATH, so this device starts with it disconnected (connectors are now chosen, not detected)"
       )
     }));
-    await warnAboutHarnessReadiness(cfg, { probeClaude: async () => claudeCode });
+    await warnAboutHarnessReadiness(cfg, {
+      probeClaude: async () => claudeCode,
+      // CT1085: the CLI's onboarding script owns the terminal and says this in
+      // its own words (the `!` block, or the per-harness offer), so it hands us a
+      // sink that logs instead. Every other caller keeps the stderr line.
+      ...opts.onReadinessWarning ? { warn: opts.onReadinessWarning } : {}
+    });
   } catch (err) {
     recordCrash({
       reason: err instanceof Error ? err.message : String(err),
@@ -9865,8 +10217,6 @@ async function createCompanionRuntime(opts = {}) {
   if (pre && await verifyRuntime(pre) === "stale") clearRuntimeState();
   const claim = acquireRuntimeState({
     pid: process.pid,
-    url: "",
-    port: 0,
     startedAt,
     daemon: process.env.CABANE_COMPANION_DAEMON === "1",
     instanceId
@@ -9874,7 +10224,7 @@ async function createCompanionRuntime(opts = {}) {
   if (!claim.acquired) {
     return { ok: false, reason: "already-running", existing: claim.existing ?? null };
   }
-  process.on("exit", () => clearRuntimeState());
+  process.on("exit", () => clearRuntimeStateIfOurs(instanceId));
   const hub = new CompanionStateHub({
     // CT29: one device, one base URL — the cabane instance this device is paired
     // with. The dashboard's connection line shows it.
@@ -9892,17 +10242,38 @@ async function createCompanionRuntime(opts = {}) {
     harnessVersions
   });
   await supervisor.start();
-  const preferredPort = opts.port ?? cfg.dashboardPort;
-  const dashboard = await startDashboard({
-    supervisor,
-    hub,
-    ...preferredPort !== void 0 ? { port: preferredPort } : {}
+  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 };
+    return { ok: true, message: connectedLine(runtime, verdict) };
+  };
+  const control = await startControlServer({
+    status: () => hub.statusJson(),
+    connect: async (runtime, serverUrl) => {
+      const result = await connectHarness(runtime, serverUrl);
+      return result.ok ? { ok: true, message: result.message } : { ok: false, message: result.error };
+    },
+    stop: () => void supervisor.requestStop()
   });
-  hub.setDashboardUrl(dashboard.url);
+  let dashboard = null;
+  if (opts.dashboard) {
+    const preferredPort = opts.port ?? cfg.dashboardPort;
+    dashboard = await startDashboard({
+      supervisor,
+      hub,
+      ...preferredPort !== void 0 ? { port: preferredPort } : {}
+    });
+    hub.setDashboardUrl(dashboard.url);
+  }
   writeRuntimeState({
     pid: process.pid,
-    url: dashboard.url,
-    port: dashboard.port,
+    socket: control.path,
+    ...dashboard ? { url: dashboard.url, port: dashboard.port } : {},
     startedAt,
     // SJ495: the daemon launcher sets this env on the detached child, so the
     // marker records whether this companion is backgrounded (foreground start
@@ -9915,68 +10286,407 @@ async function createCompanionRuntime(opts = {}) {
   const stop2 = async () => {
     if (stopped) return;
     stopped = true;
-    clearRuntimeState();
+    clearRuntimeStateIfOurs(instanceId);
     try {
       await supervisor.shutdown();
-      await dashboard.close();
+      await closeSurfaces(control, dashboard);
     } catch {
     }
   };
   return {
     ok: true,
     runtime: {
-      url: dashboard.url,
-      port: dashboard.port,
+      ...dashboard ? { url: dashboard.url, port: dashboard.port } : {},
+      socketPath: control.path,
       config: cfg,
       stop: stop2,
+      heartbeatNow: () => supervisor.heartbeatNow(),
+      harnesses: () => hub.statusJson().harnesses ?? [],
+      connectHarness,
       drainForRestart: async (graceMs) => {
-        clearRuntimeState();
+        clearRuntimeStateIfOurs(instanceId);
         const result = await supervisor.drainForRestart(graceMs);
-        await dashboard.close();
+        await closeSurfaces(control, dashboard);
         stopped = true;
         return result;
       }
     }
   };
 }
+async function closeSurfaces(control, dashboard) {
+  await control.close();
+  if (dashboard) await dashboard.close();
+}
+
+// src/commands/daemon.ts
+import { spawn as spawn5 } from "child_process";
+import { closeSync as closeSync3, mkdirSync as mkdirSync14, openSync as openSync3 } from "fs";
+var STARTUP_TIMEOUT_MS = 8e3;
+var POLL_INTERVAL_MS = 150;
+async function startDaemon(opts = {}, deps = {}) {
+  const ensureRuntime = deps.ensureRuntime ?? warnAboutHarnessReadiness;
+  const readState = deps.readState ?? readLiveRuntimeState;
+  const verify = deps.verify ?? ((s) => verifyRuntime(s));
+  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.
+    ...deps.requireCfg ? { requireCfg: deps.requireCfg } : {},
+    ...deps.probeClaude ? { probeClaude: deps.probeClaude } : {},
+    ...deps.save ? { save: deps.save } : {},
+    // The child won't log it (the block is written by then), and this process owns
+    // the user's terminal — so the one-time record is one line, here.
+    onMigrated: (_migrated, onPath) => {
+      if (onPath && !quiet) {
+        process.stdout.write(
+          "Carried Claude Code over as a connected harness on this device \u2014 connectors are chosen now, not detected.\n"
+        );
+      }
+    }
+  });
+  await ensureRuntime(cfg, {
+    probeClaude: async () => claudeOnPath2,
+    // CT1085: the onboarding script already said what's connectable, in its own
+    // words. Saying it again here, on stderr, in the middle of the closing block
+    // would be the same news twice.
+    ...quiet ? { warn: () => {
+    } } : {}
+  });
+  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
+      };
+    }
+    clearRuntimeState();
+  }
+  let service2 = isTty() ? install(serviceOpts) : { installed: false, reason: "unsupported" };
+  const args = ["start", "--foreground"];
+  const launchDetached = () => {
+    const spawned = spawnDetached(args);
+    spawned.unref();
+    return spawned;
+  };
+  const ready = (s) => !!s && !!s.socket;
+  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 { 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();
+  }
+  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\`.
+`
+    );
+    process.exitCode = 1;
+    return { started: false, service: service2, state: null };
+  }
+  if (quiet) return { started: true, service: service2, state };
+  process.stdout.write(
+    `Cabane Companion started in the background (pid ${state.pid}).
+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.
+`
+    );
+  }
+  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.
+`
+  );
+}
+function defaultSpawnDetached(args) {
+  const cliPath = companionCliEntry();
+  mkdirSync14(cabaneDir(), { recursive: true });
+  const logFd = openSync3(companionLogPath(), "a");
+  try {
+    return spawn5(process.execPath, [cliPath, ...args], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: { ...process.env, CABANE_COMPANION_DAEMON: "1" }
+    });
+  } finally {
+    closeSync3(logFd);
+  }
+}
 
 // src/commands/start.ts
 var FORCE_EXIT_MS = 4e3;
 var DEPLOY_REEXEC_EXIT = 75;
 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);
+    return;
+  }
+  blank();
+  let paired = null;
+  if (!isDevicePaired()) {
+    paired = await pairHere(opts, interactive);
+    if (!paired) {
+      return;
+    }
+    const { note } = writePairedConfig(paired);
+    if (note) getLogger().warn({ note }, "companion: salvaged an older config on pairing");
+  }
+  const justPaired = paired !== null;
+  const log = getLogger();
   const result = await createCompanionRuntime({
-    ...opts.port !== void 0 ? { port: opts.port } : {}
+    // The script says what's connectable in its own words below; a stderr warning
+    // in the middle of it would be the same news, worse.
+    onReadinessWarning: (message) => log.info({ msg: message }, "companion: harness readiness")
   });
   if (!result.ok) {
-    const existing = result.existing;
-    process.stdout.write(
-      `Cabane Companion is already running (pid ${existing?.pid ?? "?"}).
-` + (existing?.url ? `\u2192 Dashboard: ${existing.url}
-` : "") + `Stop it first with \`cabane-companion stop\` if you want to relaunch.
-`
-    );
+    reportAlreadyRunning(result.existing?.pid);
     return;
   }
   const runtime = result.runtime;
-  process.stdout.write(`
-Cabane Companion is running.
-`);
-  process.stdout.write(`\u2192 Dashboard: ${runtime.url}
-
-`);
-  if (!runtime.config.deviceToken) {
-    process.stdout.write(
-      `This device isn't paired yet \u2014 run \`cabane-companion pair\`, then confirm the short code in Settings \u2192 Connectors.
-
-`
+  await runtime.heartbeatNow();
+  const offered = await runConnectorOffer(runtime, { interactive, justPaired });
+  if (interactive && !opts.foreground) {
+    await handOffToBackground(runtime, {
+      justPaired,
+      spaceAbove: justPaired || offered.printedSomething
+    });
+    return;
+  }
+  if (interactive) {
+    blank();
+    write(INDENT + tick("Cabane companion is running in this terminal."));
+    write(`    Stop:  Ctrl-C                       Logs:  ${tildePath(companionLogPath())}`);
+    blank();
+    write(`${INDENT}Listening for messages\u2026`);
+    setConsoleLogging(true);
+  } else {
+    if (!offered.printedSomething) blank();
+    write(
+      `${INDENT}Cabane companion is running. No terminal attached, so it stays in the foreground.`
     );
+    write(`${INDENT}Listening for messages\u2026`);
   }
-  process.stdout.write(`Listening for messages\u2026
-`);
-  if (shouldAutoOpen({ flagOpen: opts.open, configAutoOpen: runtime.config.autoOpen })) {
-    openBrowser(runtime.url);
+  await runAttached(runtime);
+}
+async function liveCompanion() {
+  const state = readLiveRuntimeState();
+  if (!state) return null;
+  if (await verifyRuntime(state) === "stale") {
+    clearRuntimeState();
+    return null;
+  }
+  return state;
+}
+function reportAlreadyRunning(pid) {
+  write(`Cabane Companion is already running (pid ${pid ?? "?"}).`);
+  write("Stop it first with `cabane-companion stop` if you want to relaunch.");
+  write("Connect a harness to the running companion: cabane-companion connect claude-code");
+}
+async function pairHere(opts, interactive) {
+  const baseUrl = resolvePairBaseUrl(opts.server);
+  const label = deviceLabelFromHostname(hostname2());
+  write(`${INDENT}Not paired yet.`);
+  blank();
+  const aborter = new AbortController();
+  const onSigint = () => aborter.abort();
+  process.on("SIGINT", onSigint);
+  const spinner = new Spinner({ animate: interactive });
+  let minutesWaited = 0;
+  try {
+    for (let attempt = 1; attempt <= MAX_CODES; attempt += 1) {
+      const code = await requestEnrollmentCode(baseUrl, { ...label ? { label } : {} });
+      const minutes = Math.max(1, Math.round(code.expiresIn / 60));
+      if (attempt === 1) printFirstCode(code);
+      else printFreshCode(code);
+      spinner.start(
+        `Waiting for you to confirm it in Cabane\u2026 (the code is good for ${minutes} minutes)`
+      );
+      try {
+        const device = await awaitEnrollment(baseUrl, code, { signal: aborter.signal });
+        spinner.replaceWith(INDENT + tick(`Paired to ${possessive(device.ownerName)} account.`));
+        return device;
+      } catch (err) {
+        if (err instanceof EnrollmentCancelledError) {
+          spinner.clear();
+          blank();
+          write(`${INDENT}Pairing cancelled. Run \`cabane-companion start\` when you're ready.`);
+          return null;
+        }
+        if (!(err instanceof EnrollmentExpiredError)) throw err;
+        minutesWaited += minutes;
+        if (attempt < MAX_CODES) {
+          spinner.replaceWith(`${INDENT}That code expired \u2014 here's a fresh one:`);
+          continue;
+        }
+        spinner.freeze();
+        blank();
+        write(`${INDENT}Still not confirmed after ${minutesWaited} minutes \u2014 stopping here.`);
+        write(`${INDENT}Run \`cabane-companion start\` again when you're ready.`);
+        return null;
+      }
+    }
+    return null;
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+}
+function printFirstCode(code) {
+  write(`${INDENT}Enter this code in Cabane:`);
+  blank();
+  write(`${DATA_INDENT}${code.userCode}`);
+  blank();
+  write(`${INDENT}or open this link:`);
+  blank();
+  write(`${DATA_INDENT}${code.verificationUriComplete}`);
+  blank();
+}
+function printFreshCode(code) {
+  blank();
+  write(`${DATA_INDENT}${code.userCode}`);
+  blank();
+  write(`${DATA_INDENT}${code.verificationUriComplete}`);
+  blank();
+}
+function possessive(ownerName) {
+  return ownerName ? `${ownerName}'s` : "your Cabane";
+}
+async function runConnectorOffer(runtime, ctx) {
+  const snapshot = runtime.harnesses();
+  const detected = OFFER_ORDER.map((r) => snapshot.find((h) => h.runtime === r)).filter(
+    (h) => !!h && h.state === "detected_not_exposed"
+  );
+  if (detected.length === 0) {
+    if (!ctx.justPaired) return { printedSomething: false };
+    blank();
+    write(
+      INDENT + bang(
+        "No coding agent found on this machine yet \u2014 install Claude Code, Codex or opencode and sign in,"
+      )
+    );
+    write(`${INDENT}  then: cabane-companion connect claude-code   (or codex, or opencode)`);
+    return { printedSomething: true };
+  }
+  blank();
+  if (!ctx.interactive) {
+    for (const h of detected) {
+      write(
+        `${INDENT}${foundPhrase(h, runtime.config)} but it isn't connected. Connect it: ${connectCommand(h.runtime)}`
+      );
+    }
+    return { printedSomething: true };
   }
+  for (const h of detected) {
+    const yes = await confirm(`${foundPhrase(h, runtime.config)}. Connect it to Cabane?`);
+    if (!yes) {
+      write(`${INDENT}Skipped. Connect it later with: ${connectCommand(h.runtime)}`);
+      continue;
+    }
+    const outcome = await runtime.connectHarness(h.runtime);
+    if (!outcome.ok) {
+      write(`${INDENT}${outcome.error}`);
+      continue;
+    }
+    write(INDENT + tick(outcome.message));
+  }
+  return { printedSomething: true };
+}
+function foundPhrase(h, cfg) {
+  const label = HARNESS_LABELS[h.runtime];
+  if (h.runtime === "opencode") {
+    const url = cfg.opencode?.serverUrl;
+    return url ? `We found ${label} at ${url}` : `We found ${label} on this machine`;
+  }
+  return h.version ? `We found ${label} on this machine (${h.version})` : `We found ${label} on this machine`;
+}
+function connectCommand(runtime) {
+  return `cabane-companion connect ${runtime}`;
+}
+async function handOffToBackground(runtime, ctx) {
+  await runtime.stop();
+  const outcome = await startDaemon({ report: "failures" });
+  if (!outcome.started) {
+    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(`    Stop:  cabane-companion stop        Logs:  ${tildePath(companionLogPath())}`);
+  if (ctx.justPaired) {
+    blank();
+    write(INDENT + arrow("Head back to Cabane to finish up."));
+  }
+}
+async function runAttached(runtime) {
   await new Promise((resolve) => {
     let shuttingDown = false;
     const shutdown = async (signal) => {
@@ -10038,7 +10748,7 @@ async function status(deps = {}) {
   const cfg = loadConfig();
   if (!cfg || !cfg.deviceToken) {
     process.stdout.write(
-      "companion: not paired. Run `cabane-companion pair`, then confirm the short code in Settings \u2192 Connectors.\n"
+      "companion: not paired. Run `cabane-companion start` \u2014 it prints a short code you confirm in Cabane, then keeps running.\n"
     );
     process.exitCode = 1;
     return;
@@ -10063,14 +10773,11 @@ async function status(deps = {}) {
       `companion:       running in ${mode} (pid ${running.pid}${uptime ? `, up ${uptime}` : ""})
 `
     );
-    process.stdout.write(`dashboard:    ${running.url}  (assigned agents + run state live here)
-`);
     process.stdout.write(`stop with:    cabane-companion stop
 `);
   } else {
     process.stdout.write(
-      `companion:       not running \u2014 \`cabane-companion start\` (foreground) or \`cabane-companion start --daemon\` (background)
-`
+      "companion:       not running \u2014 `cabane-companion start` (backgrounds itself; `--foreground` stays attached)\n"
     );
   }
   const svc = readService();
@@ -10081,7 +10788,7 @@ async function status(deps = {}) {
     );
   }
   process.stdout.write(
-    "agents:       pulled from cabane at runtime \u2014 open the dashboard while running to see assigned agents, their run state, and any missing-secret warnings.\n"
+    "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"
   );
   const names = loadSecretStoreTolerant().names();
   process.stdout.write(
@@ -10203,8 +10910,8 @@ function isAlive(kill, pid) {
 }
 
 // src/commands/transcript.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11, readdirSync as readdirSync5 } from "fs";
-import { isAbsolute, join as join18 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync11, readdirSync as readdirSync5 } from "fs";
+import { isAbsolute, join as join19 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -10221,7 +10928,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join18(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join19(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -10304,7 +11011,7 @@ function isComplete(content) {
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync11(join18(dir2, f), "utf8"),
+    read: (f) => readFileSync11(join19(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`),
@@ -10344,7 +11051,7 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join18(dir2, f));
+    const { meta, outcome } = peek(join19(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
     const ws = str2(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
@@ -10378,13 +11085,13 @@ function peek(path) {
 }
 function resolveTarget(dir2, target2) {
   if (isAbsolute(target2) || target2.includes("/")) {
-    if (existsSync14(target2)) return target2;
+    if (existsSync15(target2)) return target2;
     throw new CompanionError(`no transcript at ${target2}.`);
   }
-  const exact = join18(dir2, target2);
-  if (existsSync14(exact)) return exact;
+  const exact = join19(dir2, target2);
+  if (existsSync15(exact)) return exact;
   const matches = listFiles(dir2).filter((f) => f.includes(target2));
-  if (matches.length === 1) return join18(dir2, matches[0]);
+  if (matches.length === 1) return join19(dir2, matches[0]);
   if (matches.length === 0) {
     throw new CompanionError(
       `no transcript matching "${target2}" in ${dir2}. Run \`cabane-companion transcript\` to list them.`
@@ -10528,7 +11235,7 @@ program.name("cabane-companion").description(
   "Connect a coding agent on your machine to your Cabane workspace as a responder \u2014 reply to Cabane messages while staying a full local AI client (Claude Code or OpenCode)."
 ).version(COMPANION_VERSION);
 program.command("pair").description(
-  "pair this device with cabane \u2014 shows a short code you confirm in Settings \u2192 Devices."
+  "pair this device with cabane \u2014 shows a short code you confirm in Cabane. `start` does this for you."
 ).allowExcessArguments(false).option("--server <url>", "the cabane instance to pair with (default https://app.cabane.ai)").action(async (opts) => {
   await pair({
     ...opts.server !== void 0 ? { server: opts.server } : {}
@@ -10537,22 +11244,17 @@ 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"));
 });
-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 } : {}
-    });
-  }
-);
+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) => {
+  await start({
+    ...opts.foreground ? { foreground: true } : {},
+    ...opts.server !== void 0 ? { server: opts.server } : {}
+  });
+});
+program.command("connect").description("connect a coding agent on this machine to Cabane (claude-code, codex, opencode).").argument("<harness>", "claude-code, codex, or opencode").option("--url <url>", "the `opencode serve` URL (opencode only)").action(async (harness, opts) => {
+  await connect2(harness, { ...opts.url !== void 0 ? { serverUrl: opts.url } : {} });
+});
 program.command("stop").description("stop a running companion (SIGTERM, then force-kill after a timeout).").action(async () => {
   await stop();
 });
@@ -10584,13 +11286,6 @@ program.command("logout").description(
     ...opts.purge ? { purge: true } : {}
   });
 });
-function parsePort(raw) {
-  const n = Number(raw);
-  if (!Number.isInteger(n) || n < 1 || n > 65535) {
-    throw new CompanionError(`invalid --port "${raw}": expected an integer between 1 and 65535.`);
-  }
-  return n;
-}
 program.parseAsync(process.argv).catch((err) => {
   if (err instanceof CompanionError) {
     process.stderr.write(`error: ${err.message}
@@ -10603,7 +11298,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;
 });