@cabane/companion 0.6.177 → 0.6.179

package/dist/cli.js

@@ -110,9 +110,6 @@ function write(line) {
   process.stdout.write(`${line}
 `);
 }
-function blank() {
-  process.stdout.write("\n");
-}
 function tildePath(path, home = homedir3()) {
   if (home && path.startsWith(home + "/")) return `~${path.slice(home.length)}`;
   return path;
@@ -1046,7 +1043,7 @@ var init_bundled_binaries = __esm({
 });
 
 // packages/agent-runtime/src/failure.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function encodeFailureReason(failure) {
   switch (failure.kind) {
     case "auth_expired":
@@ -1135,11 +1132,11 @@ var turnFailureSchema, USAGE_CAPPED, RATE_LIMITED, SERVER_ERROR, AUTH_EXPIRED, A
 var init_failure = __esm({
   "packages/agent-runtime/src/failure.ts"() {
     "use strict";
-    turnFailureSchema = z3.discriminatedUnion("kind", [
-      z3.object({ kind: z3.literal("usage_capped"), resetsAt: z3.string().optional() }),
-      z3.object({ kind: z3.literal("rate_limited") }),
-      z3.object({ kind: z3.literal("server_error") }),
-      z3.object({ kind: z3.literal("auth_expired") })
+    turnFailureSchema = z4.discriminatedUnion("kind", [
+      z4.object({ kind: z4.literal("usage_capped"), resetsAt: z4.string().optional() }),
+      z4.object({ kind: z4.literal("rate_limited") }),
+      z4.object({ kind: z4.literal("server_error") }),
+      z4.object({ kind: z4.literal("auth_expired") })
     ]);
     USAGE_CAPPED = "usage_capped";
     RATE_LIMITED = "rate_limited";
@@ -1752,44 +1749,44 @@ var init_version = __esm({
 });
 
 // packages/agent-runtime/src/host-policy.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var hostPolicySchema;
 var init_host_policy = __esm({
   "packages/agent-runtime/src/host-policy.ts"() {
     "use strict";
-    hostPolicySchema = z5.object({
+    hostPolicySchema = z6.object({
       // Host filesystem and shell: `Bash`/`Read`/`Write`/`Edit`/`Glob`/`Grep`, the notebook pair,
       // git-worktree tools and `REPL`. Off on the locked assistant surface; on in the coding posture.
-      hostFs: z5.boolean(),
+      hostFs: z6.boolean(),
       // Public web (`WebSearch` / `WebFetch`). Not host reach; a grant like the rest.
-      web: z5.boolean(),
+      web: z6.boolean(),
       // Browser automation (the Playwright MCP surface). Varies by host.
-      browser: z5.boolean(),
+      browser: z6.boolean(),
       // User-configured MCP servers permitted.
-      userMcp: z5.boolean(),
+      userMcp: z6.boolean(),
       // Subagent dispatch (`Task` / `Agent`) — a grant: `false` on the locked surface, `true` in the
       // coding posture, where the coding allow-hook reaches sub-agent tool calls. A subagent completes
       // within the turn, so it's not an invariant like `scheduling`.
-      subagents: z5.boolean(),
+      subagents: z6.boolean(),
       // ── Hard platform invariants — always denied, never granted ────────────────
       // Deferred re-invocation / scheduling (`ScheduleWakeup`, the `Cron*` / `Task*` families,
       // `Monitor`, `Workflow`, …). A turn is one query that resolves on `result`; a scheduled callback
       // fires after the reply window has closed and strands the agent.
-      scheduling: z5.literal("never"),
+      scheduling: z6.literal("never"),
       // Human-facing UI prompts (`AskUserQuestion`). Nothing in a Cabane conversation can answer a
       // structured prompt, so the call hangs the turn. The agent asks in its reply instead.
-      uiPrompts: z5.literal("never")
+      uiPrompts: z6.literal("never")
     });
   }
 });
 
 // packages/agent-runtime/src/turn-event.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var turnEventSchema;
 var init_turn_event = __esm({
   "packages/agent-runtime/src/turn-event.ts"() {
     "use strict";
-    turnEventSchema = z6.discriminatedUnion("type", [
+    turnEventSchema = z7.discriminatedUnion("type", [
       // The runtime's opaque session state, emitted when the adapter learns it (e.g. the SDK
       // `system/init` frame). The platform stores `state` verbatim per (conversation, agent) and
       // hands it back next turn; only the adapter knows what it means.
@@ -1801,21 +1798,21 @@ var init_turn_event = __esm({
       // server rewinds the mark, so the next turn rebuilds a full catch-up (this turn is unavoidably
       // lossy — the degrade is known only after the manifest was committed). A plain boolean; the
       // runtime-specific reason stays in the adapter's `onWarn` log. Optional.
-      z6.object({
-        type: z6.literal("session"),
-        state: z6.string(),
-        degraded: z6.boolean().optional()
+      z7.object({
+        type: z7.literal("session"),
+        state: z7.string(),
+        degraded: z7.boolean().optional()
       }),
       // One readable thinking summary. Transient — surfaced live, never persisted as content.
-      z6.object({ type: z6.literal("thinking"), text: z6.string() }),
+      z7.object({ type: z7.literal("thinking"), text: z7.string() }),
       // Assistant text. `terminal: false` is interim narration (commits as `progress`);
       // `terminal: true` is the turn's closing reply (commits as `final`).
-      z6.object({ type: z6.literal("text"), body: z6.string(), terminal: z6.boolean() }),
+      z7.object({ type: z7.literal("text"), body: z7.string(), terminal: z7.boolean() }),
       // Runtime/provider-authored prose about the turn — a failure's explanation, or a line the
       // harness wrote on a turn it recovered. Not the agent's words: the pump persists it as
       // `runtime_notice`, drawn in the SystemNote voice. Adapters emit it only from positive runtime
       // evidence; the web never classifies English strings.
-      z6.object({ type: z6.literal("runtime_notice"), body: z6.string() }),
+      z7.object({ type: z7.literal("runtime_notice"), body: z7.string() }),
       // A tool-activity transition. `name` is prefix-stripped (`cabane_read`, not
       // `mcp__cabane__cabane_read`); `summary` is the short card label; `phase` pairs `start` with a
       // later `done`/`error` on the same `id`.
@@ -1824,15 +1821,15 @@ var init_turn_event = __esm({
       // log are a consumer concern (docs/turn-protocol.md). `mcpServer` is the MCP server the call
       // came from (`cabane`, `playwright`, …), derived before `name` dropped the prefix; null for a
       // host tool. Optional, read as null when absent.
-      z6.object({
-        type: z6.literal("tool"),
-        id: z6.string(),
-        name: z6.string(),
-        phase: z6.enum(["start", "done", "error"]),
-        summary: z6.string(),
-        input: z6.unknown().optional(),
-        result: z6.unknown().optional(),
-        mcpServer: z6.string().nullable().optional()
+      z7.object({
+        type: z7.literal("tool"),
+        id: z7.string(),
+        name: z7.string(),
+        phase: z7.enum(["start", "done", "error"]),
+        summary: z7.string(),
+        input: z7.unknown().optional(),
+        result: z7.unknown().optional(),
+        mcpServer: z7.string().nullable().optional()
       }),
       // The turn's terminal outcome. `ok:false` carries a machine reason (`no_session`, an error
       // code), surfaced by the host's clear-PATCH as `errorReason`.
@@ -1853,48 +1850,48 @@ var init_turn_event = __esm({
       // started with); `resolvedConfig` the knobs the harness reported (`{ reasoningEffort }` for
       // codex). Known only after the run streams, so they ride this event home and the host relays
       // them on settle. A cancel has no result event at all.
-      z6.object({
-        type: z6.literal("result"),
-        ok: z6.boolean(),
-        reason: z6.string().optional(),
-        usage: z6.object({
-          inputTokens: z6.number(),
-          outputTokens: z6.number(),
-          cacheReadTokens: z6.number().optional(),
-          cacheCreationTokens: z6.number().optional(),
-          contextTokens: z6.number().optional(),
-          contextWindow: z6.number().optional(),
+      z7.object({
+        type: z7.literal("result"),
+        ok: z7.boolean(),
+        reason: z7.string().optional(),
+        usage: z7.object({
+          inputTokens: z7.number(),
+          outputTokens: z7.number(),
+          cacheReadTokens: z7.number().optional(),
+          cacheCreationTokens: z7.number().optional(),
+          contextTokens: z7.number().optional(),
+          contextWindow: z7.number().optional(),
           // The rest of the harness's context reading, when it gave one: where it will compact, its
           // `/context` breakdown, and every compaction it reported. Claude Code only.
-          contextCompactAt: z6.number().optional(),
-          contextCategories: z6.array(
-            z6.object({
-              name: z6.string(),
-              tokens: z6.number(),
-              kind: z6.enum(["used", "free", "buffer", "deferred"])
+          contextCompactAt: z7.number().optional(),
+          contextCategories: z7.array(
+            z7.object({
+              name: z7.string(),
+              tokens: z7.number(),
+              kind: z7.enum(["used", "free", "buffer", "deferred"])
             })
           ).optional(),
-          contextCompactions: z6.array(
-            z6.object({
-              trigger: z6.enum(["manual", "auto"]),
-              preTokens: z6.number(),
-              postTokens: z6.number().optional()
+          contextCompactions: z7.array(
+            z7.object({
+              trigger: z7.enum(["manual", "auto"]),
+              preTokens: z7.number(),
+              postTokens: z7.number().optional()
             })
           ).optional()
         }).optional(),
-        resolvedModel: z6.string().optional(),
-        resolvedConfig: z6.object({
-          effort: z6.string().optional(),
-          thinking: z6.string().optional(),
-          reasoningEffort: z6.string().optional()
+        resolvedModel: z7.string().optional(),
+        resolvedConfig: z7.object({
+          effort: z7.string().optional(),
+          thinking: z7.string().optional(),
+          reasoningEffort: z7.string().optional()
         }).optional(),
         // The harness-reported MCP inventory from this turn's init frame. Diagnostic only: names,
         // statuses and a count — never server definitions, credentials or session ids.
         // `initReceived:false` tells a missing init frame from a real empty inventory.
-        mcpInventory: z6.object({
-          initReceived: z6.boolean(),
-          servers: z6.array(z6.object({ name: z6.string(), status: z6.string() })),
-          toolCount: z6.number().int().nonnegative()
+        mcpInventory: z7.object({
+          initReceived: z7.boolean(),
+          servers: z7.array(z7.object({ name: z7.string(), status: z7.string() })),
+          toolCount: z7.number().int().nonnegative()
         }).optional()
       })
     ]);
@@ -1902,27 +1899,27 @@ var init_turn_event = __esm({
 });
 
 // packages/agent-runtime/src/turn-diagnostics.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var turnResultReasonSchema, turnOutcomes, turnSessionModes, turnRuntimeResultKinds, turnFinalSources, turnDiagnosticsSchema;
 var init_turn_diagnostics = __esm({
   "packages/agent-runtime/src/turn-diagnostics.ts"() {
     "use strict";
-    turnResultReasonSchema = z7.discriminatedUnion("kind", [
-      z7.object({ kind: z7.literal("usage_capped"), resetsAt: z7.string().optional() }),
-      z7.object({ kind: z7.literal("rate_limited") }),
-      z7.object({ kind: z7.literal("server_error") }),
-      z7.object({ kind: z7.literal("auth_expired") }),
-      z7.object({ kind: z7.literal("no_result") }),
-      z7.object({ kind: z7.literal("empty_result") }),
-      z7.object({ kind: z7.literal("empty_result_unverified") }),
-      z7.object({ kind: z7.literal("timeout_idle") }),
-      z7.object({ kind: z7.literal("timeout_total") }),
-      z7.object({ kind: z7.literal("cancelled") }),
-      z7.object({ kind: z7.literal("lease_lost") }),
-      z7.object({ kind: z7.literal("skipped") }),
-      z7.object({ kind: z7.literal("session_start_failed") }),
-      z7.object({ kind: z7.literal("workspace_tools_missing") }),
-      z7.object({ kind: z7.literal("runtime_error") })
+    turnResultReasonSchema = z8.discriminatedUnion("kind", [
+      z8.object({ kind: z8.literal("usage_capped"), resetsAt: z8.string().optional() }),
+      z8.object({ kind: z8.literal("rate_limited") }),
+      z8.object({ kind: z8.literal("server_error") }),
+      z8.object({ kind: z8.literal("auth_expired") }),
+      z8.object({ kind: z8.literal("no_result") }),
+      z8.object({ kind: z8.literal("empty_result") }),
+      z8.object({ kind: z8.literal("empty_result_unverified") }),
+      z8.object({ kind: z8.literal("timeout_idle") }),
+      z8.object({ kind: z8.literal("timeout_total") }),
+      z8.object({ kind: z8.literal("cancelled") }),
+      z8.object({ kind: z8.literal("lease_lost") }),
+      z8.object({ kind: z8.literal("skipped") }),
+      z8.object({ kind: z8.literal("session_start_failed") }),
+      z8.object({ kind: z8.literal("workspace_tools_missing") }),
+      z8.object({ kind: z8.literal("runtime_error") })
     ]);
     turnOutcomes = ["success", "failure", "cancelled", "skipped"];
     turnSessionModes = ["fresh", "resumed", "degraded"];
@@ -1934,25 +1931,25 @@ var init_turn_diagnostics = __esm({
       "marker",
       "none"
     ];
-    turnDiagnosticsSchema = z7.object({
-      outcome: z7.enum(turnOutcomes),
+    turnDiagnosticsSchema = z8.object({
+      outcome: z8.enum(turnOutcomes),
       resultReason: turnResultReasonSchema.nullable(),
-      sessionMode: z7.enum(turnSessionModes),
-      sessionFingerprint: z7.string().regex(/^[a-f0-9]{16}$/).nullable(),
-      eventCounts: z7.object({
-        session: z7.number().int().nonnegative(),
-        text: z7.number().int().nonnegative(),
-        runtime_notice: z7.number().int().nonnegative(),
-        thinking: z7.number().int().nonnegative(),
-        tool: z7.number().int().nonnegative(),
-        result: z7.number().int().nonnegative()
+      sessionMode: z8.enum(turnSessionModes),
+      sessionFingerprint: z8.string().regex(/^[a-f0-9]{16}$/).nullable(),
+      eventCounts: z8.object({
+        session: z8.number().int().nonnegative(),
+        text: z8.number().int().nonnegative(),
+        runtime_notice: z8.number().int().nonnegative(),
+        thinking: z8.number().int().nonnegative(),
+        tool: z8.number().int().nonnegative(),
+        result: z8.number().int().nonnegative()
       }),
-      runtimeResultKind: z7.enum(turnRuntimeResultKinds).nullable(),
-      finalSource: z7.enum(turnFinalSources),
-      mcpInventory: z7.object({
-        initReceived: z7.boolean(),
-        servers: z7.array(z7.object({ name: z7.string(), status: z7.string() })),
-        toolCount: z7.number().int().nonnegative()
+      runtimeResultKind: z8.enum(turnRuntimeResultKinds).nullable(),
+      finalSource: z8.enum(turnFinalSources),
+      mcpInventory: z8.object({
+        initReceived: z8.boolean(),
+        servers: z8.array(z8.object({ name: z8.string(), status: z8.string() })),
+        toolCount: z8.number().int().nonnegative()
       }).optional()
     });
   }
@@ -2026,105 +2023,105 @@ var init_empty_result = __esm({
 });
 
 // packages/agent-runtime/src/turn-request.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var contentBlockSchema, effortLevelSchema, resolvedRunConfigSchema, resolvedMcpServerSchema, resolvedMcpServersSchema, hostInjectedServersSchema, turnRequestSchema;
 var init_turn_request = __esm({
   "packages/agent-runtime/src/turn-request.ts"() {
     "use strict";
     init_host_policy();
-    contentBlockSchema = z8.discriminatedUnion("type", [
-      z8.object({ type: z8.literal("text"), text: z8.string() }),
-      z8.object({
-        type: z8.literal("image"),
-        source: z8.object({ type: z8.literal("url"), url: z8.string() })
+    contentBlockSchema = z9.discriminatedUnion("type", [
+      z9.object({ type: z9.literal("text"), text: z9.string() }),
+      z9.object({
+        type: z9.literal("image"),
+        source: z9.object({ type: z9.literal("url"), url: z9.string() })
       }),
-      z8.object({
-        type: z8.literal("document"),
-        source: z8.object({ type: z8.literal("url"), url: z8.string() })
+      z9.object({
+        type: z9.literal("document"),
+        source: z9.object({ type: z9.literal("url"), url: z9.string() })
       })
     ]);
-    effortLevelSchema = z8.enum(["low", "medium", "high", "xhigh", "max"]);
-    resolvedRunConfigSchema = z8.object({
-      model: z8.string().nullable(),
+    effortLevelSchema = z9.enum(["low", "medium", "high", "xhigh", "max"]);
+    resolvedRunConfigSchema = z9.object({
+      model: z9.string().nullable(),
       effort: effortLevelSchema.optional(),
-      runtimeOptions: z8.record(z8.string(), z8.unknown()).optional()
+      runtimeOptions: z9.record(z9.string(), z9.unknown()).optional()
     });
-    resolvedMcpServerSchema = z8.union([
-      z8.object({
-        type: z8.literal("stdio").optional(),
-        command: z8.string(),
-        args: z8.array(z8.string()).optional(),
-        env: z8.record(z8.string(), z8.string()).optional(),
-        envFromEnv: z8.record(z8.string(), z8.string()).optional()
+    resolvedMcpServerSchema = z9.union([
+      z9.object({
+        type: z9.literal("stdio").optional(),
+        command: z9.string(),
+        args: z9.array(z9.string()).optional(),
+        env: z9.record(z9.string(), z9.string()).optional(),
+        envFromEnv: z9.record(z9.string(), z9.string()).optional()
       }),
-      z8.object({
-        type: z8.literal("http"),
-        url: z8.string(),
-        headers: z8.record(z8.string(), z8.string()).optional(),
-        headersFromEnv: z8.record(z8.string(), z8.string()).optional()
+      z9.object({
+        type: z9.literal("http"),
+        url: z9.string(),
+        headers: z9.record(z9.string(), z9.string()).optional(),
+        headersFromEnv: z9.record(z9.string(), z9.string()).optional()
       }),
-      z8.object({
-        type: z8.literal("sse"),
-        url: z8.string(),
-        headers: z8.record(z8.string(), z8.string()).optional(),
-        headersFromEnv: z8.record(z8.string(), z8.string()).optional()
+      z9.object({
+        type: z9.literal("sse"),
+        url: z9.string(),
+        headers: z9.record(z9.string(), z9.string()).optional(),
+        headersFromEnv: z9.record(z9.string(), z9.string()).optional()
       })
     ]);
-    resolvedMcpServersSchema = z8.record(z8.string(), resolvedMcpServerSchema);
-    hostInjectedServersSchema = z8.record(z8.string(), z8.unknown());
-    turnRequestSchema = z8.object({
+    resolvedMcpServersSchema = z9.record(z9.string(), resolvedMcpServerSchema);
+    hostInjectedServersSchema = z9.record(z9.string(), z9.unknown());
+    turnRequestSchema = z9.object({
       // Server-composed standing instructions: the core segment (body, tool naming, identity, agent
       // charter) and, after it, the conversation segment (workspace and room charters, skill indexes,
       // roster). One string to the adapter, current as of this dispatch.
-      systemPrompt: z8.string(),
+      systemPrompt: z9.string(),
       // The same text as its two ordered segments, so an adapter that writes standing text into the
       // conversation (Codex's input preamble) can tell which half changed. `systemPrompt` is
       // `joinStanding(standing)`. Optional: absent from an API older than the split, where
       // `systemPrompt` is the core alone and the conversation material rides `prompt`.
-      standing: z8.object({ core: z8.string(), conversation: z8.string() }).optional(),
+      standing: z9.object({ core: z9.string(), conversation: z9.string() }).optional(),
       // Server-composed per-turn user text (anchor reminder + the triggering message).
-      prompt: z8.string(),
+      prompt: z9.string(),
       // The multi-block user-message body (text + vision).
-      content: z8.array(contentBlockSchema),
+      content: z9.array(contentBlockSchema),
       // Portable-or-dialect run-config (above).
       config: resolvedRunConfigSchema,
       // Abstract capability grants; the adapter maps them to tool names.
       policy: hostPolicySchema,
       // Prior opaque session state, or null for a fresh session.
-      session: z8.string().nullable(),
+      session: z9.string().nullable(),
       // The cabane control-plane coordinates for this turn's MCP + post-back.
-      cabane: z8.object({
-        mcpUrl: z8.string(),
-        bearer: z8.string(),
-        activeConversationId: z8.string(),
+      cabane: z9.object({
+        mcpUrl: z9.string(),
+        bearer: z9.string(),
+        activeConversationId: z9.string(),
         // Scoped turn-control MCP URL. Codex and opencode mount it as `cabane_companion` with the bearer
         // and active-conversation header, for ask, withdraw_ask, wake_me, cancel_wake and skip_turn.
         // Claude Code mounts the companion's in-process instance instead. Optional; the companion
         // populates it.
-        turnControlUrl: z8.string().optional(),
+        turnControlUrl: z9.string().optional(),
         // Workspace coordinate retained for envelope compatibility. Current
         // adapters use MCP, whose workspace operations take workspaceId explicitly.
         // The companion supplies this field; it is not required by those adapters.
-        workspaceId: z8.string().optional()
+        workspaceId: z9.string().optional()
       }),
       // Machine-local resolution (host-filled): the checkout cwd, extra env from a
       // prepare hook, and the resolved user MCP servers.
-      local: z8.object({
-        cwd: z8.string().optional(),
-        env: z8.record(z8.string(), z8.string()).optional(),
+      local: z9.object({
+        cwd: z9.string().optional(),
+        env: z9.record(z9.string(), z9.string()).optional(),
         mcpServers: resolvedMcpServersSchema.optional(),
         // The values `headersFromEnv` names, per turn (`CABANE_MCP_<n>` → complete header value). The
         // adapter merges them into the harness process's environment and nowhere else; the host never
         // merges them into its own. Absent when no server references one.
-        secretEnv: z8.record(z8.string(), z8.string()).optional(),
+        secretEnv: z9.record(z9.string(), z9.string()).optional(),
         // Machine-local claude-code knobs for an operator running their own companion — the auto-memory
         // escape hatch. `autoMemory: true` opts back into Claude Code's auto-memory (governed by the
         // operator's `.claude/settings.json`); absent/false keeps the adapter's force-off default
         // (`buildClaudeCodeOptions`).
-        claudeCode: z8.object({ autoMemory: z8.boolean().optional() }).optional()
+        claudeCode: z9.object({ autoMemory: z9.boolean().optional() }).optional()
       }),
       // Host-owned injected servers (host-filled).
-      extra: z8.object({
+      extra: z9.object({
         mcpServers: hostInjectedServersSchema
       })
     });
@@ -2148,18 +2145,18 @@ var init_standing = __esm({
 });
 
 // packages/agent-runtime/src/conformance.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var conformanceFixtureSchema;
 var init_conformance = __esm({
   "packages/agent-runtime/src/conformance.ts"() {
     "use strict";
     init_turn_event();
     init_turn_request();
-    conformanceFixtureSchema = z9.object({
-      name: z9.string(),
+    conformanceFixtureSchema = z10.object({
+      name: z10.string(),
       request: turnRequestSchema,
-      nativeStream: z9.array(z9.unknown()),
-      expected: z9.array(turnEventSchema)
+      nativeStream: z10.array(z10.unknown()),
+      expected: z10.array(turnEventSchema)
     });
   }
 });
@@ -2656,7 +2653,7 @@ var init_mcp_secret_env = __esm({
 });
 
 // packages/agent-runtime/src/claude-code/policy.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function disallowedToolsFor(policy) {
   const tools = [...UNSUPPORTED_TOOLS, ...STRANDING_TOOLS];
   if (!policy.subagents) tools.unshift(...SUBAGENT_TOOLS);
@@ -2716,18 +2713,18 @@ var init_policy = __esm({
       "Workflow"
     ];
     DEFAULT_WEB_TOOLS = ["WebSearch", "WebFetch"];
-    claudeCodeDialectSchema = z10.object({
-      thinking: z10.discriminatedUnion("type", [
-        z10.object({
-          type: z10.literal("adaptive"),
-          display: z10.enum(["summarized", "omitted"]).optional()
+    claudeCodeDialectSchema = z11.object({
+      thinking: z11.discriminatedUnion("type", [
+        z11.object({
+          type: z11.literal("adaptive"),
+          display: z11.enum(["summarized", "omitted"]).optional()
         }),
-        z10.object({
-          type: z10.literal("enabled"),
-          budgetTokens: z10.number().int().positive().optional(),
-          display: z10.enum(["summarized", "omitted"]).optional()
+        z11.object({
+          type: z11.literal("enabled"),
+          budgetTokens: z11.number().int().positive().optional(),
+          display: z11.enum(["summarized", "omitted"]).optional()
         }),
-        z10.object({ type: z10.literal("disabled") })
+        z11.object({ type: z11.literal("disabled") })
       ]).optional()
     }).loose();
   }
@@ -4297,7 +4294,7 @@ var init_loop2 = __esm({
 });
 
 // packages/agent-runtime/src/opencode/policy.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function opencodeToolPolicy(policy) {
   const tools = {};
   const deny = (names) => {
@@ -4332,8 +4329,8 @@ var init_policy2 = __esm({
     OPENCODE_SUBAGENT_TOOLS = ["task"];
     OPENCODE_SCHEDULING_TOOLS = [];
     OPENCODE_UI_PROMPT_TOOLS = ["question"];
-    opencodeDialectSchema = z11.object({
-      agent: z11.string().min(1).optional()
+    opencodeDialectSchema = z12.object({
+      agent: z12.string().min(1).optional()
     }).loose();
   }
 });
@@ -5624,7 +5621,7 @@ var init_loop3 = __esm({
 });
 
 // packages/agent-runtime/src/codex/policy.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function codexToolPolicy(policy) {
   return policy.hostFs ? {
     sandboxMode: "danger-full-access",
@@ -5651,8 +5648,8 @@ var init_policy3 = __esm({
   "packages/agent-runtime/src/codex/policy.ts"() {
     "use strict";
     CODEX_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
-    codexDialectSchema = z12.object({
-      modelReasoningEffort: z12.enum(CODEX_REASONING_EFFORTS).optional()
+    codexDialectSchema = z13.object({
+      modelReasoningEffort: z13.enum(CODEX_REASONING_EFFORTS).optional()
     }).loose();
   }
 });
@@ -7123,7 +7120,7 @@ var init_src = __esm({
 // src/runner/sandbox-policy.ts
 import { NetworkConfigSchema } from "@anthropic-ai/sandbox-runtime";
 import { globToRegex } from "@anthropic-ai/sandbox-runtime/dist/sandbox/sandbox-utils.js";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function parseSandboxPolicy(raw) {
   if (raw === void 0) return { ok: true, policy: {} };
   const result = sandboxPolicySchema.safeParse(raw);
@@ -7243,29 +7240,29 @@ var hostPattern, secretRef, envCredentialSchema, gitCredentialSchema, sandboxPol
 var init_sandbox_policy = __esm({
   "src/runner/sandbox-policy.ts"() {
     "use strict";
-    hostPattern = z13.string().min(1);
-    secretRef = z13.string().regex(/^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/, "must be a ${NAME} reference into secrets.json");
-    envCredentialSchema = z13.object({ secret: secretRef, hosts: z13.array(hostPattern).min(1) }).strict();
-    gitCredentialSchema = z13.object({
-      host: z13.string().regex(/^[A-Za-z0-9.-]+(:\d+)?$/, "must be a host name, like github.com"),
-      username: z13.string().min(1).optional(),
+    hostPattern = z14.string().min(1);
+    secretRef = z14.string().regex(/^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/, "must be a ${NAME} reference into secrets.json");
+    envCredentialSchema = z14.object({ secret: secretRef, hosts: z14.array(hostPattern).min(1) }).strict();
+    gitCredentialSchema = z14.object({
+      host: z14.string().regex(/^[A-Za-z0-9.-]+(:\d+)?$/, "must be a host name, like github.com"),
+      username: z14.string().min(1).optional(),
       secret: secretRef
     }).strict();
-    sandboxPolicySchema = z13.object({
-      hosts: z13.object({
-        allow: z13.array(hostPattern).optional(),
-        deny: z13.array(hostPattern).optional(),
-        defaults: z13.boolean().optional()
+    sandboxPolicySchema = z14.object({
+      hosts: z14.object({
+        allow: z14.array(hostPattern).optional(),
+        deny: z14.array(hostPattern).optional(),
+        defaults: z14.boolean().optional()
       }).strict().optional(),
-      filesystem: z13.object({
-        mode: z13.enum(["blocklist", "strict"]).optional(),
-        denyRead: z13.array(z13.string().min(1)).optional(),
-        allowRead: z13.array(z13.string().min(1)).optional(),
-        allowWrite: z13.array(z13.string().min(1)).optional()
+      filesystem: z14.object({
+        mode: z14.enum(["blocklist", "strict"]).optional(),
+        denyRead: z14.array(z14.string().min(1)).optional(),
+        allowRead: z14.array(z14.string().min(1)).optional(),
+        allowWrite: z14.array(z14.string().min(1)).optional()
       }).strict().optional(),
-      credentials: z13.object({
-        env: z13.record(z13.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), envCredentialSchema).optional(),
-        git: z13.array(gitCredentialSchema).optional()
+      credentials: z14.object({
+        env: z14.record(z14.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), envCredentialSchema).optional(),
+        git: z14.array(gitCredentialSchema).optional()
       }).strict().optional()
     }).strict();
     DEFAULT_ALLOWED_HOSTS = [
@@ -7647,7 +7644,7 @@ var init_turn_containment = __esm({
 // src/secrets.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 import { join as join14 } from "path";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function secretsPath() {
   return join14(cabaneDir(), "secrets.json");
 }
@@ -7770,14 +7767,14 @@ var init_secrets = __esm({
     init_config();
     init_errors();
     PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
-    secretStoreSchema = z14.record(z14.string(), z14.string());
+    secretStoreSchema = z15.record(z15.string(), z15.string());
     SECRET_ENV_NAME = /^CABANE_MCP_(\d+)$/;
     ERROR_REASON_MAX = 200;
   }
 });
 
 // src/run-config.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function parseRunConfig(raw, onWarn) {
   const result = runConfigSchema.safeParse(raw ?? {});
   if (result.success) return result.data;
@@ -7790,48 +7787,48 @@ var mcpStdioServerSchema, mcpHttpServerSchema, mcpSseServerSchema, mcpServerDefS
 var init_run_config = __esm({
   "src/run-config.ts"() {
     "use strict";
-    mcpStdioServerSchema = z15.object({
-      type: z15.literal("stdio").optional(),
-      command: z15.string().min(1),
-      args: z15.array(z15.string()).optional(),
-      env: z15.record(z15.string(), z15.string()).optional(),
+    mcpStdioServerSchema = z16.object({
+      type: z16.literal("stdio").optional(),
+      command: z16.string().min(1),
+      args: z16.array(z16.string()).optional(),
+      env: z16.record(z16.string(), z16.string()).optional(),
       // Variable → the name of a `secretEnv` entry holding its value. Set by the server on a
       // room's shared browser, whose connect URL is a credential.
-      envFromEnv: z15.record(z15.string(), z15.string()).optional()
+      envFromEnv: z16.record(z16.string(), z16.string()).optional()
     });
-    mcpHttpServerSchema = z15.object({
-      type: z15.literal("http"),
-      url: z15.string().url(),
-      headers: z15.record(z15.string(), z15.string()).optional(),
+    mcpHttpServerSchema = z16.object({
+      type: z16.literal("http"),
+      url: z16.string().url(),
+      headers: z16.record(z16.string(), z16.string()).optional(),
       // Header → the name of a `secretEnv` entry holding its value. Set by
       // the server on a room connection's entry, and by `resolveMcpSecrets` on a
       // header whose `${VAR}` it resolved.
-      headersFromEnv: z15.record(z15.string(), z15.string()).optional()
+      headersFromEnv: z16.record(z16.string(), z16.string()).optional()
     });
-    mcpSseServerSchema = z15.object({
-      type: z15.literal("sse"),
-      url: z15.string().url(),
-      headers: z15.record(z15.string(), z15.string()).optional(),
+    mcpSseServerSchema = z16.object({
+      type: z16.literal("sse"),
+      url: z16.string().url(),
+      headers: z16.record(z16.string(), z16.string()).optional(),
       // Header → the name of a `secretEnv` entry holding its value. Set by
       // the server on a room connection's entry, and by `resolveMcpSecrets` on a
       // header whose `${VAR}` it resolved.
-      headersFromEnv: z15.record(z15.string(), z15.string()).optional()
+      headersFromEnv: z16.record(z16.string(), z16.string()).optional()
     });
-    mcpServerDefSchema = z15.union([mcpHttpServerSchema, mcpSseServerSchema, mcpStdioServerSchema]);
-    thinkingConfigSchema = z15.discriminatedUnion("type", [
-      z15.object({ type: z15.literal("adaptive") }),
-      z15.object({ type: z15.literal("enabled"), budgetTokens: z15.number().int().positive().optional() }),
-      z15.object({ type: z15.literal("disabled") })
+    mcpServerDefSchema = z16.union([mcpHttpServerSchema, mcpSseServerSchema, mcpStdioServerSchema]);
+    thinkingConfigSchema = z16.discriminatedUnion("type", [
+      z16.object({ type: z16.literal("adaptive") }),
+      z16.object({ type: z16.literal("enabled"), budgetTokens: z16.number().int().positive().optional() }),
+      z16.object({ type: z16.literal("disabled") })
     ]);
-    effortSchema = z15.enum(["low", "medium", "high", "xhigh", "max"]);
-    runConfigSchema = z15.object({
+    effortSchema = z16.enum(["low", "medium", "high", "xhigh", "max"]);
+    runConfigSchema = z16.object({
       // `true` grants the host filesystem/shell; absent is the locked surface. Kept
       // in lockstep with `@cabane/shared`'s
       // `agentRunConfigSchema` (independent zod, forward-compatible: unknown keys are
       // stripped, so an older companion riding a newer server never rejects the config).
-      hostAccess: z15.boolean().optional(),
-      mcpServers: z15.record(z15.string(), mcpServerDefSchema).optional(),
-      model: z15.string().min(1).optional(),
+      hostAccess: z16.boolean().optional(),
+      mcpServers: z16.record(z16.string(), mcpServerDefSchema).optional(),
+      model: z16.string().min(1).optional(),
       thinking: thinkingConfigSchema.optional(),
       effort: effortSchema.optional()
     });
@@ -7840,7 +7837,7 @@ var init_run_config = __esm({
 });
 
 // src/runner/protocol.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 function required(env, name) {
   const value = env[name];
   if (!value) throw new Error(`runner: ${name} is not set`);
@@ -7923,76 +7920,76 @@ var init_protocol = __esm({
       // Everything else the turn is constructed from, as JSON: see `RunnerSpec`.
       spec: "CABANE_RUNNER_SPEC"
     };
-    runtimeHealthSchema = z16.object({
-      quotaState: z16.enum(["ok", "limited", "auth_expired", "unknown"]),
-      limitedUntil: z16.string().nullable(),
-      lastError: z16.string().nullable()
+    runtimeHealthSchema = z17.object({
+      quotaState: z17.enum(["ok", "limited", "auth_expired", "unknown"]),
+      limitedUntil: z17.string().nullable(),
+      lastError: z17.string().nullable()
     });
-    runnerSpecSchema = z16.object({
-      deviceId: z16.string().optional(),
+    runnerSpecSchema = z17.object({
+      deviceId: z17.string().optional(),
       // The launcher's boot id: the one its heartbeat carries, so a runner's lease
       // matches the device that holds it.
-      bootId: z16.string(),
-      workspaceId: z16.string(),
-      workspaceSlug: z16.string(),
-      agentId: z16.string(),
-      agentUsername: z16.string(),
-      agentName: z16.string(),
+      bootId: z17.string(),
+      workspaceId: z17.string(),
+      workspaceSlug: z17.string(),
+      agentId: z17.string(),
+      agentUsername: z17.string(),
+      agentName: z17.string(),
       local: localAgentConfigSchema,
       runConfig: runConfigSchema,
-      opencodeServerUrl: z16.string().optional(),
-      claudeCodeAvailable: z16.boolean(),
-      codexAvailable: z16.boolean(),
-      idleTimeoutMs: z16.number().int().positive().optional(),
-      totalTimeoutMs: z16.number().int().positive().optional(),
-      leaseRenewalMs: z16.number().int().positive().optional(),
-      preparingRowDelayMs: z16.number().int().nonnegative().optional(),
+      opencodeServerUrl: z17.string().optional(),
+      claudeCodeAvailable: z17.boolean(),
+      codexAvailable: z17.boolean(),
+      idleTimeoutMs: z17.number().int().positive().optional(),
+      totalTimeoutMs: z17.number().int().positive().optional(),
+      leaseRenewalMs: z17.number().int().positive().optional(),
+      preparingRowDelayMs: z17.number().int().nonnegative().optional(),
       // Whether the turn writes a transcript. The directory is the runner's own
       // (`transcriptsDir()`), so `CABANE_RUNNER_STATE_DIR` moves it with the outbox.
-      transcripts: z16.boolean(),
+      transcripts: z17.boolean(),
       // Whether the harness starts under the OS sandbox. The launcher sends 'os'
       // only when this host can make one.
-      sandbox: z16.enum(["os", "none"]),
+      sandbox: z17.enum(["os", "none"]),
       // The device's sandbox policy, validated by the launcher. Absent
       // when the sandbox is off.
       sandboxPolicy: sandboxPolicySchema.optional(),
       // Every companion store the launcher's latest walk found, denied
       // to the harness. Absent when the sandbox is off.
-      companionStores: z16.array(z16.string()).optional(),
-      logLevel: z16.string(),
+      companionStores: z17.array(z17.string()).optional(),
+      logLevel: z17.string(),
       // The launcher's connector-health observations, by runtime, as of the start.
-      connectorHealth: z16.record(z16.string(), runtimeHealthSchema),
+      connectorHealth: z17.record(z17.string(), runtimeHealthSchema),
       // True when this (conversation, agent) pair was already told its session
       // could not be saved: the notice is once per pair, not once per process.
-      sessionWriteNoticeClaimed: z16.boolean(),
+      sessionWriteNoticeClaimed: z17.boolean(),
       // The runner's identity, minted with its credential. The start
       // PATCH carries it so the lease knows which runner holds the span.
-      runnerId: z16.string(),
+      runnerId: z17.string(),
       // The launcher keeps the runtime's session files beside the attempt
       // and restores them into this runner's home, so the runner names the attempt
       // each context was composed for and waits for the launcher to say it's in
       // place. Absent: nothing to wait for (a runner on the launcher's own disk).
-      attemptState: z16.boolean().optional(),
+      attemptState: z17.boolean().optional(),
       // MCP `${NAME}` secrets come from the launcher, by name, instead of
       // this machine's secrets.json. Absent: the runner reads the device's file.
-      secretsFromLauncher: z16.boolean().optional()
+      secretsFromLauncher: z17.boolean().optional()
     });
-    dispatchSchema = z16.object({
-      type: z16.literal("device:dispatch_requested"),
-      agentId: z16.string(),
-      deviceId: z16.string(),
-      conversationId: z16.string(),
-      messageId: z16.string(),
-      episode: z16.number().int().optional()
+    dispatchSchema = z17.object({
+      type: z17.literal("device:dispatch_requested"),
+      agentId: z17.string(),
+      deviceId: z17.string(),
+      conversationId: z17.string(),
+      messageId: z17.string(),
+      episode: z17.number().int().optional()
     });
-    credentialsSchema = z16.object({
-      credential: z16.string().startsWith("cabrn_"),
-      sandboxCredentials: z16.array(
-        z16.object({
-          name: z16.string(),
-          value: z16.string(),
-          hosts: z16.array(z16.string()),
-          gitHost: z16.string().optional()
+    credentialsSchema = z17.object({
+      credential: z17.string().startsWith("cabrn_"),
+      sandboxCredentials: z17.array(
+        z17.object({
+          name: z17.string(),
+          value: z17.string(),
+          hosts: z17.array(z17.string()),
+          gitHost: z17.string().optional()
         })
       ).optional()
     });
@@ -8443,7 +8440,7 @@ var init_launch = __esm({
 
 // src/turn-control-tools.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 function createSkipState() {
   return { skipped: false, reason: null };
 }
@@ -8494,7 +8491,7 @@ function createTurnControlMcpServer(acts, skipState) {
           SKIP_TURN_TOOL,
           TURN_CONTROL_TOOL_DESCRIPTIONS.skip_turn,
           {
-            reason: z17.string().min(1).max(MAX_SKIP_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.skip_turn.reason)
+            reason: z18.string().min(1).max(MAX_SKIP_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.skip_turn.reason)
           },
           async (args) => {
             skipState.skipped = true;
@@ -8510,22 +8507,22 @@ function createTurnControlMcpServer(acts, skipState) {
         ASK_TOOL,
         TURN_CONTROL_TOOL_DESCRIPTIONS.ask,
         {
-          targetUserId: z17.string().regex(ASK_TARGET_PATTERN, { error: ASK_TARGET_INVALID }).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.targetUserId),
-          question: z17.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.question),
-          headline: z17.string().min(1).max(MAX_ASK_HEADLINE_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.headline),
-          options: z17.array(z17.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.options),
-          questions: z17.array(
-            z17.object({
-              headline: z17.string().min(1).max(MAX_ASK_HEADLINE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.headline"]),
-              body: z17.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.body"]),
-              options: z17.array(
-                z17.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)
+          targetUserId: z18.string().regex(ASK_TARGET_PATTERN, { error: ASK_TARGET_INVALID }).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.targetUserId),
+          question: z18.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.question),
+          headline: z18.string().min(1).max(MAX_ASK_HEADLINE_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.headline),
+          options: z18.array(z18.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.options),
+          questions: z18.array(
+            z18.object({
+              headline: z18.string().min(1).max(MAX_ASK_HEADLINE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.headline"]),
+              body: z18.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.body"]),
+              options: z18.array(
+                z18.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)
               ).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.options"])
             })
           ).min(1).max(MAX_ASK_ITEMS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.questions),
-          replaces: z17.object({
-            askId: z17.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.askId"]),
-            reason: z17.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.reason"])
+          replaces: z18.object({
+            askId: z18.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.askId"]),
+            reason: z18.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.reason"])
           }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.replaces)
         },
         async (args) => {
@@ -8566,9 +8563,9 @@ function createTurnControlMcpServer(acts, skipState) {
         WAKE_ME_TOOL,
         TURN_CONTROL_TOOL_DESCRIPTIONS.wake_me,
         {
-          afterSeconds: z17.number().int().positive().optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.afterSeconds),
-          at: z17.string().datetime({ offset: true }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.at),
-          note: z17.string().min(1).max(MAX_WAKE_NOTE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.note)
+          afterSeconds: z18.number().int().positive().optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.afterSeconds),
+          at: z18.string().datetime({ offset: true }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.at),
+          note: z18.string().min(1).max(MAX_WAKE_NOTE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.note)
         },
         async (args) => {
           const hasAfter = args.afterSeconds !== void 0;
@@ -8602,8 +8599,8 @@ function createTurnControlMcpServer(acts, skipState) {
         WITHDRAW_ASK_TOOL,
         TURN_CONTROL_TOOL_DESCRIPTIONS.withdraw_ask,
         {
-          askId: z17.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.askId),
-          reason: z17.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.reason)
+          askId: z18.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.askId),
+          reason: z18.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.reason)
         },
         async (args) => performAct(acts, {
           kind: "withdraw_ask",
@@ -10699,7 +10696,7 @@ function connectTarget(target) {
 }
 function createEgressProxy(opts) {
   const { allow, log: log2 } = opts;
-  const refuse2 = (host) => `cabane: ${host} is not on this device's egress allow-list (runners.docker.egressAllow)
+  const refuse = (host) => `cabane: ${host} is not on this device's egress allow-list (runners.docker.egressAllow)
 `;
   const server = createServer2((req, res) => {
     req.on("error", () => res.destroy());
@@ -10713,7 +10710,7 @@ function createEgressProxy(opts) {
     }
     if (url.protocol !== "http:" || !egressAllowed(url.hostname, allow, url.port ? Number(url.port) : 80, 80)) {
       log2?.warn({ host: url.hostname }, "egress: refused");
-      res.writeHead(403, { "content-type": "text/plain" }).end(refuse2(url.hostname));
+      res.writeHead(403, { "content-type": "text/plain" }).end(refuse(url.hostname));
       return;
     }
     const upstream = httpRequest(
@@ -10742,7 +10739,7 @@ function createEgressProxy(opts) {
     if (!target || !egressAllowed(target.host, allow, target.port)) {
       const host = target?.host ?? String(req.url);
       log2?.warn({ host }, "egress: refused");
-      const body = refuse2(host);
+      const body = refuse(host);
       socket.end(
         `HTTP/1.1 403 Forbidden\r
 content-type: text/plain\r
@@ -12121,6 +12118,30 @@ import { homedir as homedir6 } from "os";
 import { join as join7 } from "path";
 
 // src/device-state.ts
+var DEVICE_STATES = ["waiting", "online", "offline", "deactivated"];
+var DEFAULT_DEVICE_OFFLINE_THRESHOLD_MS = 9e4;
+var DEFAULT_DEVICE_RECONNECT_GRACE_MS = 9e4;
+var HARNESS_STATES = [
+  "checking",
+  "connected",
+  "needs_sign_in",
+  "limited",
+  "problem",
+  "off",
+  "gone"
+];
+var DEVICE_HEALTH_STATES = ["checking", "ready", "degraded"];
+var DEVICE_STATE_LABEL = {
+  waiting: "Waiting for its first check-in",
+  online: "Online",
+  offline: "Offline",
+  deactivated: "Deactivated"
+};
+var DEVICE_HEALTH_LABEL = {
+  checking: "Checking harnesses\u2026",
+  ready: "Ready",
+  degraded: "Needs attention"
+};
 var HARNESS_STATE_LABEL = {
   checking: "checking",
   connected: "connected",
@@ -12250,7 +12271,7 @@ var AGENT_CHOICES = [
   { value: "opencode", label: "OpenCode" }
 ];
 var CHOOSE_AGENT = "Cabane needs one of them. Which will you set up?";
-var SETUP_AGAIN = `Then run  ${cabane("setup")}  again. It picks up where you left off.`;
+var SETUP_AGAIN = `Then  ${cabane("status")}  shows it signed in; nothing else to run.`;
 function agentNote(runtime, c = {}) {
   const k = ctx(c);
   if (runtime === "claude-code") {
@@ -12312,27 +12333,10 @@ function agentNote(runtime, c = {}) {
       ...here.map(indent),
       indent("opencode serve --port 4096"),
       "",
-      `Then come back here and run  ${cabane("setup")}  again.`
+      `Then  ${cabane("status")}  shows it signed in; nothing else to run.`
     ]
   };
 }
-function nothingUsableLines(detection) {
-  const lines2 = [];
-  for (const runtime of ["claude-code", "codex"]) {
-    const state = detection[runtime];
-    const label = HARNESS_LABELS[runtime];
-    if (state.state === "signed_out") {
-      lines2.push(
-        `${label} isn't signed in on this device. Run  ${loginCommand(runtime)}  to use it.`
-      );
-    } else if (state.state === "problem") {
-      const reason = unusableReason(runtime, state.check);
-      if (reason) lines2.push(reason);
-    }
-  }
-  lines2.push(`Cabane can run while you sign in to a harness.`);
-  return lines2;
-}
 function indent(line) {
   return `  ${line}`;
 }
@@ -12953,6 +12957,8 @@ async function claimSetupCode(baseUrl, input) {
     baseUrl: body.baseUrl,
     deviceToken: token,
     deviceId: body.deviceId,
+    ..."workspace" in body && body.workspace && typeof body.workspace === "object" && "name" in body.workspace && typeof body.workspace.name === "string" && "slug" in body.workspace && typeof body.workspace.slug === "string" ? { workspace: { name: body.workspace.name, slug: body.workspace.slug } } : {},
+    ..."devicesUrl" in body && typeof body.devicesUrl === "string" ? { devicesUrl: body.devicesUrl } : {},
     ..."deviceLabel" in body && typeof body.deviceLabel === "string" ? { deviceLabel: body.deviceLabel } : {}
   };
 }
@@ -12961,9 +12967,6 @@ function deviceLabelFromHostname(hostname4) {
   return trimmed.length ? trimmed.slice(0, 120) : void 0;
 }
 
-// src/commands/setup.ts
-init_errors();
-
 // src/commands/start.ts
 init_cabane_command();
 init_config();
@@ -13482,6 +13485,27 @@ function warnAboutHarnessReadiness(cfg, deps = {}) {
   }
 }
 
+// src/supervisor.ts
+init_errors();
+
+// src/heartbeat-status.ts
+import { z as z3 } from "zod";
+var acknowledgedDeviceSchema = z3.object({
+  state: z3.enum(DEVICE_STATES),
+  health: z3.enum(DEVICE_HEALTH_STATES).nullable(),
+  harnesses: z3.array(z3.object({ runtime: z3.string(), state: z3.enum(HARNESS_STATES) }))
+});
+var heartbeatStatusSchema = z3.object({
+  lastHeartbeatAckAt: z3.string().datetime().nullable().default(null),
+  lastAcknowledgedDevice: acknowledgedDeviceSchema.nullable().default(null),
+  lastHeartbeatRefused: z3.boolean().default(false)
+});
+var emptyHeartbeatStatus = () => ({
+  lastHeartbeatAckAt: null,
+  lastAcknowledgedDevice: null,
+  lastHeartbeatRefused: false
+});
+
 // src/supervisor.ts
 init_cabane_command();
 import { hostname as hostname2 } from "os";
@@ -13662,8 +13686,8 @@ import {
   writeFileSync as writeFileSync3
 } from "fs";
 import { join as join12 } from "path";
-import { z as z4 } from "zod";
-var credentialMapSchema = z4.record(z4.string(), z4.string());
+import { z as z5 } from "zod";
+var credentialMapSchema = z5.record(z5.string(), z5.string());
 function credentialsDir() {
   return join12(cabaneDir(), "credentials");
 }
@@ -15652,27 +15676,27 @@ function compareVersions(a, b) {
 init_config();
 import { mkdirSync as mkdirSync15, readFileSync as readFileSync15, renameSync as renameSync10, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname12, join as join28 } from "path";
-import { z as z18 } from "zod";
-var resultSchema = z18.object({
-  kind: z18.enum(["updated", "rolled_back", "failed"]),
-  from: z18.string(),
-  to: z18.string(),
-  at: z18.string(),
-  reason: z18.string().optional()
+import { z as z19 } from "zod";
+var resultSchema = z19.object({
+  kind: z19.enum(["updated", "rolled_back", "failed"]),
+  from: z19.string(),
+  to: z19.string(),
+  at: z19.string(),
+  reason: z19.string().optional()
 });
-var pendingSchema = z18.object({
-  from: z18.string(),
+var pendingSchema = z19.object({
+  from: z19.string(),
   // The package root `current` pointed at before the swap, so a rollback can point it back.
-  fromRoot: z18.string(),
-  to: z18.string(),
-  at: z18.string(),
-  boots: z18.number().int().nonnegative()
+  fromRoot: z19.string(),
+  to: z19.string(),
+  at: z19.string(),
+  boots: z19.number().int().nonnegative()
 });
-var stateSchema = z18.object({
-  server: z18.object({ latest: z18.string(), minimum: z18.string(), at: z18.string() }).optional(),
+var stateSchema = z19.object({
+  server: z19.object({ latest: z19.string(), minimum: z19.string(), at: z19.string() }).optional(),
   pending: pendingSchema.optional(),
   lastResult: resultSchema.optional(),
-  failed: z18.object({ version: z18.string(), attempts: z18.number().int(), at: z18.string() }).optional()
+  failed: z19.object({ version: z19.string(), attempts: z19.number().int(), at: z19.string() }).optional()
 });
 function updateStatePath(dir2 = cabaneDir()) {
   return join28(dir2, "update.json");
@@ -16157,6 +16181,13 @@ var CompanionSupervisor = class {
   recoveryChecked = false;
   recovering = false;
   heartbeated = false;
+  heartbeatStatus = emptyHeartbeatStatus();
+  currentDetection() {
+    return this.detection;
+  }
+  lastHeartbeat() {
+    return { ...this.heartbeatStatus };
+  }
   recoveryCursor;
   recoveredTurns = /* @__PURE__ */ new Set();
   // Agents assigned here, as `workspaceId|agentId`, whose sign-in to Cabane is missing and
@@ -16276,19 +16307,26 @@ var CompanionSupervisor = class {
       else this.log.error({ posture }, `runners: ${summary}`);
       void this.companionStores().refresh();
     }
-    const startupHarnessRefresh = this.detect().then(() => {
+    if (this.config.deviceToken) {
+      this.deviceApi = new DeviceApi({
+        baseUrl: this.config.baseUrl,
+        deviceToken: this.config.deviceToken
+      });
+      this.trackHeartbeat(this.sendHeartbeat(true));
+    }
+    const firstHeartbeat = this.inFlightHeartbeat;
+    const startupHarnessRefresh = this.detect();
+    void startupHarnessRefresh.then(async () => {
+      await firstHeartbeat;
+      if (this.stopped) return;
+      await this.heartbeatNow();
     });
-    this.trackHeartbeat(startupHarnessRefresh);
     this.detectTimer = setInterval(() => void this.detect(), DETECT_INTERVAL_MS);
     this.detectTimer.unref?.();
-    if (!this.config.deviceToken) {
-      this.log.warn("This device isn't paired. Run cabane start to pair it.");
+    if (!this.deviceApi || !this.config.deviceToken) {
+      this.log.warn("This device isn't paired. Get a setup line from Settings \u2192 Devices.");
       return;
     }
-    this.deviceApi = new DeviceApi({
-      baseUrl: this.config.baseUrl,
-      deviceToken: this.config.deviceToken
-    });
     this.deviceSub = new SseSubscriber({
       baseUrl: this.config.baseUrl,
       workspaceId: "device-control",
@@ -16334,11 +16372,6 @@ var CompanionSupervisor = class {
     this.updater.start();
     await this.refreshAssignments();
     this.deviceSub.start();
-    const firstHeartbeat = startupHarnessRefresh.then(async () => {
-      if (this.stopped) return;
-      await this.sendHeartbeat();
-    });
-    this.trackHeartbeat(firstHeartbeat);
     this.heartbeatTimer = setInterval(() => this.kickHeartbeat(), HEARTBEAT_INTERVAL_MS);
     this.heartbeatTimer.unref?.();
     this.pollTimer = setInterval(() => void this.refreshAssignments(), ASSIGNMENTS_POLL_MS);
@@ -16359,15 +16392,16 @@ var CompanionSupervisor = class {
       if (this.inFlightHeartbeat === pending) this.inFlightHeartbeat = null;
     });
   }
-  async sendHeartbeat() {
+  async sendHeartbeat(first = false) {
     if (!this.deviceApi) return;
     try {
-      if (!this.detection || advertisedRuntimes(this.detection).length === 0) await this.detect();
+      if (!first && this.detection && advertisedRuntimes(this.detection).length === 0)
+        await this.detect();
       const store = loadSecretStoreTolerant(
         (m) => this.log.warn({ err: m }, "Could not read the secrets file. Check ~/.cabane/secrets.json.")
       );
       const connectorReports = this.connectorReports();
-      const opencodeUrl = this.opencodeUrl();
+      const opencodeUrl = first ? null : this.opencodeUrl();
       const opencodeModels = opencodeUrl ? await enumerateOpencodeModels(opencodeUrl) : null;
       const res = await this.deviceApi.heartbeat({
         bootId,
@@ -16376,31 +16410,39 @@ var CompanionSupervisor = class {
         // Each runtime only when this device can actually run it: what the last
         // detection found usable (signed in, or an API key, or a serve
         // answering) — a usable bundled binary is a present one.
-        manifest: buildCompanionManifest({
-          claudeCode: this.offered("claude-code"),
-          opencode: this.offered("opencode"),
-          codex: this.offered("codex"),
-          // WHY an allowed harness is absent above. Diagnostic only, and always
-          // sent, so an empty array clears a previously reported issue.
-          runtimeIssues: this.runtimeIssues(),
-          // Informational only; the server matches on name.
-          versions: this.harnessVersions,
-          // Shown on the device page.
-          ...runnersEnabled(this.config) ? { runner: this.runnerManifest() } : {}
-        }),
+        ...!first && this.detection ? {
+          manifest: buildCompanionManifest({
+            claudeCode: this.offered("claude-code"),
+            opencode: this.offered("opencode"),
+            codex: this.offered("codex"),
+            // WHY an allowed harness is absent above. Diagnostic only, and always
+            // sent, so an empty array clears a previously reported issue.
+            runtimeIssues: this.runtimeIssues(),
+            // Informational only; the server matches on name.
+            versions: this.harnessVersions,
+            // Shown on the device page.
+            ...runnersEnabled(this.config) ? { runner: this.runnerManifest() } : {}
+          })
+        } : {},
         // Omitted until the first observed failure or heal, so the server's
         // status-less manifest synthesis still runs for a fresh companion.
-        ...connectorReports.length > 0 ? { connectors: connectorReports } : {},
+        ...!first && connectorReports.length > 0 ? { connectors: connectorReports } : {},
         // The complete harness inventory in the machine's words, once detection
         // has run; omitted before it, which the server reads as "nothing yet".
-        ...this.detection ? { harnesses: harnessEntriesFromDetection(this.detection) } : {},
+        ...!first && this.detection ? { harnesses: harnessEntriesFromDetection(this.detection) } : {},
         ...opencodeModels !== null ? { models: opencodeModels } : {},
-        ...this.updater ? { update: this.updater.report() } : {}
+        ...!first && this.updater ? { update: this.updater.report() } : {}
       });
       this.hub.setDevice({ deviceId: res.deviceId });
       this.deviceId = res.deviceId;
       this.checkVersionSkew(res.serverVersion);
       this.heartbeated = true;
+      const view = acknowledgedDeviceSchema.safeParse(res.device);
+      this.heartbeatStatus = {
+        lastHeartbeatAckAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastAcknowledgedDevice: view.success ? view.data : null,
+        lastHeartbeatRefused: false
+      };
       void this.recoverRuns();
       void this.updater?.onHeartbeat(res.companion, this.deviceConnected).catch(
         (err) => this.log.warn(
@@ -16409,9 +16451,10 @@ var CompanionSupervisor = class {
         )
       );
     } catch (err) {
+      this.heartbeatStatus.lastHeartbeatRefused = err instanceof ApiError && (err.status === 401 || err.status === 403);
       this.log.warn(
         { ...apiErrorLogFields(err) },
-        "Couldn't check in with Cabane; trying again shortly."
+        "Couldn't check in with the server; trying again shortly."
       );
     }
   }
@@ -17498,7 +17541,8 @@ var CompanionSupervisor = class {
     if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
     if (this.detectTimer) clearInterval(this.detectTimer);
     if (this.pollTimer) clearInterval(this.pollTimer);
-    const heartbeat = this.inFlightHeartbeat;
+    const heartbeat = Promise.all([this.inFlightHeartbeat, this.detecting]).then(() => {
+    });
     this.deviceSub?.stop();
     for (const wr of this.workspaces.values()) {
       for (const a of wr.agents.values()) a.cancelDrain();
@@ -17781,7 +17825,11 @@ async function createCompanionRuntime(opts = {}) {
   let dashboard = null;
   try {
     control = await startControlServer({
-      status: () => hub.statusJson(),
+      status: () => ({
+        ...hub.statusJson(),
+        ...supervisor.lastHeartbeat(),
+        detection: supervisor.currentDetection()
+      }),
       detect: () => supervisor.redetect(),
       allow: (runtime) => supervisor.allowHarness(runtime),
       update: (auto) => supervisor.update(auto),
@@ -18274,7 +18322,7 @@ async function startDaemon(opts = {}, deps = {}) {
   const spawnDetached = deps.spawnDetached ?? defaultSpawnDetached;
   const sleep3 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = deps.now ?? (() => Date.now());
-  const quiet = opts.report === "failures";
+  const quiet = opts.report === "failures" || opts.report === "silent";
   const cfg = (deps.requireCfg ?? requireConfig)();
   ensureRuntime(cfg, {
     // The terminal already said what it found, in its own words. Saying it
@@ -18286,7 +18334,8 @@ async function startDaemon(opts = {}, deps = {}) {
   const existing = readState();
   if (existing) {
     if (await verify(existing) !== "stale") {
-      process.stdout.write(alreadyRunningLines(existing.pid).join("\n") + "\n");
+      if (opts.report !== "silent")
+        process.stdout.write(alreadyRunningLines(existing.pid).join("\n") + "\n");
       return { started: false, state: existing };
     }
     clearRuntimeState();
@@ -18315,13 +18364,15 @@ async function startDaemon(opts = {}, deps = {}) {
   const child = launchDetached();
   const state = await waitForReady();
   if (!state) {
-    process.stdout.write(
-      `Cabane Companion was launched (pid ${child?.pid ?? "?"}) but didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.
+    const error = `The background process (pid ${child?.pid ?? "?"}) did not report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.`;
+    if (opts.report !== "silent")
+      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("status")}\`.
 `
-    );
+      );
     process.exitCode = 1;
-    return { started: false, state: null };
+    return { started: false, state: null, error };
   }
   if (quiet) return { started: true, state };
   process.stdout.write(
@@ -18351,120 +18402,210 @@ function defaultSpawnDetached(args) {
   }
 }
 
+// src/terminal-copy.ts
+init_cabane_command();
+var UNPAIRED = "This device isn't paired yet. Get a setup line from a workspace's Settings \u2192 Devices and paste it here.";
+var lease = DEFAULT_DEVICE_OFFLINE_THRESHOLD_MS + DEFAULT_DEVICE_RECONNECT_GRACE_MS;
+function age(at, now) {
+  const seconds = Math.max(0, Math.floor((now - Date.parse(at)) / 1e3));
+  return seconds < 60 ? `${seconds}s` : seconds < 3600 ? `${Math.floor(seconds / 60)}m` : `${Math.floor(seconds / 3600)}h`;
+}
+function deviceLine(f, now = Date.now()) {
+  if (!f.running) return `not running \u2014 start it with  ${cabane("start")}`;
+  if (f.lastHeartbeatRefused)
+    return `refused by the server \u2014 it may be deactivated; see ${f.devicesUrl}`;
+  if (!f.lastHeartbeatAckAt) return "starting \u2014 hasn't checked in yet";
+  const since = age(f.lastHeartbeatAckAt, now);
+  if (now - Date.parse(f.lastHeartbeatAckAt) > lease)
+    return `can't reach the server \u2014 last checked in ${since} ago`;
+  const view = f.lastAcknowledgedDevice;
+  if (!view) return `checked in ${since} ago`;
+  const word = view.state === "online" && view.health ? view.health === "checking" ? "online, checking harnesses\u2026" : DEVICE_HEALTH_LABEL[view.health] : DEVICE_STATE_LABEL[view.state];
+  return `${word.toLowerCase()} \u2014 checked in ${since} ago`;
+}
+function pairingLine(pair) {
+  return `\u2713 Paired as "${pair.deviceLabel ?? "Computer"}" with ${pair.workspace?.name ?? "the workspace"}.`;
+}
+function pathLines(reload) {
+  return reload ? [`  To use cabane in this window:  ${reload}`, ""] : [];
+}
+function agentLines(detection, opts) {
+  const rows = agentRows(detection, opts);
+  const names = rows.map((row3) => row3.usable ? `\u2713 ${row3.label}` : row3.label);
+  const width = Math.max(...names.map((name) => name.length)) + 3;
+  return rows.map((row3, i) => `${names[i].padEnd(width)}${row3.text}`);
+}
+var modeLines = {
+  background: "Cabane is running in the background",
+  service: "Cabane is running as a service",
+  attached: "Cabane is running in this process",
+  existing: "Cabane was already running"
+};
+function closingBlock(input, now = Date.now()) {
+  const { mode, facts } = input;
+  const device = deviceLine(facts, now);
+  const noAck = !facts.lastHeartbeatAckAt && !facts.lastHeartbeatRefused;
+  const stale = facts.lastHeartbeatAckAt !== null && now - Date.parse(facts.lastHeartbeatAckAt) > lease;
+  const modeLine = modeLines[mode];
+  const sentence = noAck ? `${mode === "background" ? "Cabane started in the background" : modeLine} but hasn't checked in yet.` : `${modeLine}. ${facts.lastHeartbeatRefused || stale ? device[0].toUpperCase() + device.slice(1) : `This device ${device.startsWith("checked in") || device.startsWith("needs attention") ? "" : "is "}${device}`}.`;
+  const lines2 = [`  ${sentence}`, "", ...pathLines(input.reload)];
+  if (noAck || stale || facts.lastHeartbeatRefused) {
+    lines2.push(
+      `  See what it's doing:  ${cabane("status")}${facts.lastHeartbeatRefused ? "" : `     Log:  ${cabane("logs")}`}`
+    );
+  } else {
+    lines2.push("  Harnesses on this device");
+    lines2.push(
+      ...(input.detection ? agentLines(input.detection, { signInHint: true }) : ["Claude Code   checking", "Codex         checking", "OpenCode      checking"]).map((line) => `  ${line}`)
+    );
+    lines2.push(
+      "",
+      `  Status  ${cabane("status")}${mode === "attached" ? "" : `     Stop  ${cabane("stop")}`}     Log  ${cabane("logs")}`
+    );
+    if (!input.service && input.servicePlatform) {
+      lines2.push(
+        `  Start at login and keep Cabane updating itself:  ${cabane("service install")}${input.servicePlatform === "launchd" ? " (macOS will ask you to allow a background item)" : ""}`
+      );
+      lines2.push(
+        `  Updates itself only as a service; to turn that off:  ${cabane("update --auto off")}`
+      );
+    } else if (input.service && input.autoUpdate)
+      lines2.push(`  Updating itself; to turn that off:  ${cabane("update --auto off")}`);
+  }
+  if (input.address) lines2.push("", `  In Cabane: ${input.address}`);
+  if (mode === "attached") lines2.push("", "  Listening for messages\u2026");
+  return lines2;
+}
+function startFailure(message2, reload) {
+  return [
+    ...pathLines(reload),
+    `\u2717 Cabane couldn't start: ${message2}`,
+    "",
+    `  Log:  ${cabane("logs")}     Try again:  ${cabane("start")}`
+  ];
+}
+
+// src/terminal-status.ts
+async function readTerminalStatus(socket, timeoutMs = 1e3) {
+  if (!socket) return emptyHeartbeatStatus();
+  try {
+    const body = await controlRequest(socket, { cmd: "status" }, timeoutMs);
+    const facts = heartbeatStatusSchema.safeParse(body);
+    return facts.success ? { ...facts.data, detection: body.detection } : emptyHeartbeatStatus();
+  } catch {
+    return emptyHeartbeatStatus();
+  }
+}
+async function waitForAcknowledgement(socket) {
+  const deadline = Date.now() + 1e4;
+  let status2 = emptyHeartbeatStatus();
+  while (Date.now() < deadline) {
+    status2 = await readTerminalStatus(socket, Math.min(1e3, deadline - Date.now()));
+    if (status2.lastHeartbeatAckAt || status2.lastHeartbeatRefused) return status2;
+    await new Promise(
+      (resolve2) => setTimeout(resolve2, Math.min(100, Math.max(0, deadline - Date.now())))
+    );
+  }
+  return status2;
+}
+
 // src/commands/start.ts
-async function start(opts = {}) {
+async function start(opts = {}, deps = {}) {
   setLogOverrides(opts);
-  const interactive = isInteractive();
   setConsoleLogging(false);
   try {
-    await startScript(opts, interactive);
+    return await startScript(opts, deps);
+  } catch (err) {
+    for (const line of startFailure(err instanceof Error ? err.message : String(err), reloadLine()))
+      write(line);
+    process.exitCode = 1;
+    return null;
   } finally {
     setConsoleLogging(true);
   }
 }
-async function startScript(opts, interactive) {
-  const running = await liveCompanionState();
-  if (running) {
-    for (const line of alreadyRunningLines(running.pid)) write(`${INDENT}${line}`);
-    return;
-  }
-  const daemon = process.env.CABANE_COMPANION_DAEMON === "1";
-  if (opts.foreground || daemon) {
-    await startSupervised(opts, interactive, daemon);
-    return;
-  }
+async function startScript(opts, deps) {
+  const interactive = deps.interactive ?? isInteractive();
   if (!isDevicePaired()) {
-    refuse([
-      `This device isn't set up yet. Run  ${cabane("setup")}  to sign in to a harness and pair it.`
-    ]);
-    return;
+    for (const line of [...pathLines(reloadLine()), UNPAIRED]) write(line);
+    process.exitCode = 1;
+    return null;
   }
   const cfg = requireConfig();
-  const detection = await detectHarnesses(cfg);
-  if (!anyUsable(detection)) {
-    for (const line of nothingUsableLines(detection)) write(`${INDENT}${line}`);
-  }
-  if (serviceInstalled()) {
-    await startTheService();
-    return;
+  let running = await (deps.live ?? liveCompanionState)();
+  const installed = serviceInstalled();
+  const daemon = process.env.CABANE_COMPANION_DAEMON === "1";
+  let mode = "existing";
+  let runtime = null;
+  if (!running) {
+    write("Starting Cabane\u2026");
+    if (opts.foreground || daemon || !interactive && !installed) {
+      const result = await createCompanionRuntime({
+        onReadinessWarning: (message2) => getLogger().warn(message2)
+      });
+      if (!result.ok) {
+        if (result.reason === "stray-companion")
+          throw new Error(strayCompanionLines(result.strays, cabane("start")).join(" "));
+        running = result.existing;
+        if (!running) throw new Error("Another start owns this device but has not reported ready.");
+      } else {
+        runtime = result.runtime;
+        mode = "attached";
+      }
+    } else if (installed) {
+      const result = await startService();
+      if (!result.ok) throw new Error(result.lines.join(" "));
+      const deadline = Date.now() + 8e3;
+      while (!running?.socket && Date.now() < deadline) {
+        running = await (deps.live ?? liveCompanionState)();
+        if (!running?.socket) await new Promise((resolve2) => setTimeout(resolve2, 150));
+      }
+      if (!running?.socket) throw new Error("The service did not report ready within 8s.");
+      mode = "service";
+    } else {
+      const result = await startDaemon({ ...opts, report: "silent" });
+      if (!result.state)
+        throw new Error(result.error ?? "The background process did not report ready.");
+      running = result.state;
+      mode = result.started ? "background" : "existing";
+    }
   }
-  if (!interactive) {
-    const runtime = await bringUp();
-    if (!runtime) return;
-    blank();
-    write(`${INDENT}Cabane is running. No terminal attached, so it stays in the foreground.`);
-    write(`${INDENT}Listening for messages\u2026`);
+  const socket = runtime?.socketPath ?? running?.socket;
+  let status2 = await (deps.waitAck ?? waitForAcknowledgement)(socket);
+  let detection = status2.detection ?? null;
+  if (!runtime && status2.lastHeartbeatAckAt && !status2.lastHeartbeatRefused) {
+    write("Checking harnesses\u2026");
+    try {
+      detection = socket ? await (deps.detectRunning ?? detectOverSocket)(socket) : await (deps.detect ?? detectHarnesses)(cfg);
+    } catch {
+      detection = await (deps.detect ?? detectHarnesses)(cfg);
+    }
+    const latest = await readTerminalStatus(socket);
+    if (latest.lastHeartbeatAckAt || latest.lastHeartbeatRefused) status2 = latest;
+  }
+  const personalUrl = `${cfg.baseUrl.replace(/\/$/, "")}/settings/devices`;
+  const address = opts.pairing ? opts.pairing.devicesUrl : personalUrl;
+  if (!daemon)
+    for (const line of closingBlock({
+      mode,
+      facts: { ...status2, running: true, devicesUrl: address ?? personalUrl },
+      detection,
+      reload: reloadLine(),
+      service: installed,
+      servicePlatform: servicePlatform(),
+      autoUpdate: cfg.update?.auto !== false,
+      ...address ? { address } : {}
+    }))
+      write(line);
+  if (runtime) {
     setConsoleLogging(true);
     await runAttached(runtime);
-    return;
-  }
-  const { started } = await startDaemon({
-    report: "failures",
-    ...opts.logLevel ? { logLevel: opts.logLevel } : {},
-    ...opts.logFormat ? { logFormat: opts.logFormat } : {}
-  });
-  if (!started) return;
-  write(INDENT + tick("Cabane is running in the background."));
-  write(`    Stop:  ${cabane("stop")}        Logs:  ${cabane("logs")}`);
-}
-function refuse(lines2) {
-  const reload = reloadLine();
-  if (reload) write(`${INDENT}Run  ${reload}  first.`);
-  for (const line of lines2) write(`${INDENT}${line}`);
-  process.exitCode = 1;
-}
-async function startSupervised(opts, interactive, daemon) {
-  if (daemon) write(`Running in the background (pid ${process.pid}). Stop with ${cabane("stop")}.`);
-  else blank();
-  if (!isDevicePaired()) {
-    refuse(["Get a setup line from your workspace's Settings \u2192 Devices, then paste it here."]);
-    return;
-  }
-  const runtime = await bringUp();
-  if (!runtime) return;
-  await runtime.heartbeatNow();
-  if (interactive) {
-    blank();
-    write(INDENT + tick("Cabane is running in this terminal."));
-    write(
-      `    Stop:  Ctrl-C                       Logs:  ${cabane("logs")}   (${tildePath(companionLogPath())})`
-    );
-    blank();
-    write(`${INDENT}Listening for messages\u2026`);
-  } else if (!daemon) {
-    blank();
-    write(`${INDENT}Cabane is running. No terminal attached, so it stays in the foreground.`);
-    write(`${INDENT}Listening for messages\u2026`);
-  }
-  setConsoleLogging(true);
-  await runAttached(runtime);
-}
-async function bringUp() {
-  const log2 = getLogger();
-  const result = await createCompanionRuntime({
-    // The terminal says what it found in its own words; a stderr warning in
-    // the middle of it would be the same news, worse.
-    onReadinessWarning: (message2) => log2.warn(message2)
-  });
-  if (!result.ok && result.reason === "stray-companion") {
-    refuse(strayCompanionLines(result.strays, cabane("start")));
-    return null;
-  }
-  if (!result.ok) {
-    for (const line of alreadyRunningLines(result.existing?.pid)) write(`${INDENT}${line}`);
-    return null;
   }
-  return result.runtime;
+  return detection;
 }
-async function startTheService() {
-  const outcome = await startService();
-  for (const line of outcome.lines) write(`${INDENT}${line}`);
-  if (!outcome.ok) {
-    process.exitCode = 1;
-    return;
-  }
-  write(INDENT + tick("Cabane runs as a service here, and is starting."));
-  write(`    Status:  ${cabane("service status")}        Logs:  ${cabane("logs")}`);
+async function detectOverSocket(socket) {
+  const body = await controlRequest(socket, { cmd: "detect" }, 15e3);
+  return body.detection;
 }
 async function runAttached(runtime) {
   await new Promise((resolve2) => {
@@ -18573,348 +18714,79 @@ function plainUi() {
 
 // src/commands/setup.ts
 init_term();
-
-// src/commands/service.ts
-init_cabane_command();
-init_config();
-init_term();
-init_version2();
-
-// src/commands/stop.ts
-var TERM_GRACE_MS = 6e3;
-var POLL_INTERVAL_MS2 = 150;
-async function stop(deps = {}) {
-  if ((deps.serviceInstalled ?? serviceInstalled)()) {
-    const outcome = await (deps.stopService ?? stopService)();
-    for (const line of outcome.lines) process.stdout.write(`${line}
-`);
-    if (!outcome.ok) {
-      process.exitCode = 1;
-      return;
-    }
-    process.stdout.write(
-      "companion: stopped the service. It starts again at boot, or with `cabane start`.\n"
+async function setup(opts = {}, deps = {}) {
+  setLogOverrides(opts);
+  setConsoleLogging(false);
+  try {
+    await setupScript(opts, deps);
+  } catch (err) {
+    for (const line of pathLines(reloadLine())) write(line);
+    write(err instanceof Error ? err.message : String(err));
+    write(
+      "Check the server connection, then take a fresh setup line from the workspace's Settings \u2192 Devices."
     );
-    return;
-  }
-  const readState = deps.readState ?? readLiveRuntimeState;
-  const verify = deps.verify ?? ((s) => verifyRuntime(s));
-  const kill = deps.kill ?? ((pid2, signal) => process.kill(pid2, signal));
-  const sleep3 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  const now = deps.now ?? (() => Date.now());
-  const state = readState();
-  if (!state) {
-    process.stdout.write("companion: not running (nothing to stop).\n");
-    return;
+    process.exitCode = 1;
+  } finally {
+    setConsoleLogging(true);
   }
-  if (await verify(state) === "stale") {
-    clearRuntimeState();
-    process.stdout.write("companion: not running (stale marker swept).\n");
+}
+async function setupScript(opts, deps) {
+  const interactive = deps.interactive ?? isInteractive();
+  const paired = isDevicePaired();
+  if (!opts.code && !paired) {
+    write(UNPAIRED);
+    process.exitCode = 1;
     return;
   }
-  const { pid } = state;
-  process.stdout.write(`companion: stopping (pid ${pid})\u2026
-`);
-  try {
-    kill(pid, "SIGTERM");
-  } catch {
-    clearRuntimeState();
-    process.stdout.write("companion: already stopped.\n");
+  const ui = deps.ui ?? (interactive ? terminalUi() : plainUi());
+  const running = await (deps.live ?? liveCompanionState)();
+  const cfg = safeLoadConfig();
+  const strays = (deps.strays ?? findStrayCompanions)(running ? [running.pid] : []);
+  if (strays.length) {
+    for (const line of pathLines(reloadLine())) write(line);
+    ui.cancel(strayCompanionLines(strays, cabane("setup")).join("\n"));
+    process.exitCode = 1;
     return;
   }
-  const deadline = now() + TERM_GRACE_MS;
-  while (now() < deadline) {
-    if (!isAlive(kill, pid)) {
-      process.stdout.write("companion: stopped.\n");
+  let device;
+  if (opts.code) {
+    const baseUrl = resolvePairBaseUrl(opts.server ?? cfg?.baseUrl);
+    if (paired && cfg && new URL(cfg.baseUrl).origin !== new URL(baseUrl).origin) {
+      for (const line of pathLines(reloadLine())) write(line);
+      write(
+        "This device is paired to another Cabane server. Log out before setting it up on a different server."
+      );
+      write(`Run  ${cabane("logout")}  before using the new setup line.`);
+      process.exitCode = 1;
       return;
     }
-    await sleep3(POLL_INTERVAL_MS2);
+    device = await (deps.claim ?? claimSetupCode)(baseUrl, {
+      userCode: opts.code,
+      label: deviceLabelFromHostname(hostname3()) ?? "Computer",
+      ...paired && cfg?.deviceToken ? { deviceToken: cfg.deviceToken } : {}
+    });
+    writePairedConfig(device);
+    write(pairingLine(device));
   }
-  process.stdout.write(
-    `companion: didn't exit within ${TERM_GRACE_MS / 1e3}s, sending SIGKILL.
-`
+  const detection = await start(
+    {
+      ...opts,
+      ...device ? { pairing: device } : {},
+      ...!interactive && device ? { foreground: true } : {}
+    },
+    { ...deps, interactive }
   );
-  try {
-    kill(pid, "SIGKILL");
-  } catch {
+  if (interactive && detection && !anyUsable(detection)) {
+    const choice = await ui.select(CHOOSE_AGENT, AGENT_CHOICES);
+    if (choice) {
+      const note2 = agentNote(choice, { reload: null });
+      ui.note(note2.lines, note2.title);
+    }
   }
-  clearRuntimeState();
-  process.stdout.write("companion: force-stopped.\n");
 }
-function isAlive(kill, pid) {
+function safeLoadConfig() {
   try {
-    kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/commands/service.ts
-var STARTUP_WAIT_MS = 2e4;
-async function installAndStartService(deps = {}) {
-  const readState = deps.readState ?? readLiveRuntimeState;
-  const sleep3 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  const now = deps.now ?? Date.now;
-  const before = await serviceState(deps);
-  const running = readState();
-  if (running && running.pid !== before.pid) await (deps.stopRunning ?? (() => stop()))();
-  setRunsAsService(true);
-  const outcome = await installService(deps);
-  for (const line of outcome.lines) write(`${INDENT}${line}`);
-  if (!outcome.ok) {
-    setRunsAsService(false);
-    return false;
-  }
-  const deadline = now() + STARTUP_WAIT_MS;
-  while (now() < deadline) {
-    const state = readState();
-    if (state?.socket) return true;
-    await sleep3(250);
-  }
-  write(
-    `${INDENT}The service is installed but Cabane hasn't come up yet. ${cabane("service status")} and ${cabane("logs")} say why.`
-  );
-  return false;
-}
-async function serviceInstall(deps = {}) {
-  if (!await installAndStartService(deps)) {
-    process.exitCode = 1;
-    return;
-  }
-  write(
-    INDENT + tick(
-      "Cabane runs as a service. It starts at boot, restarts if it stops, and updates itself, usually between turns."
-    )
-  );
-  write(`${INDENT}  Status:  ${cabane("service status")}        Logs:  ${cabane("logs")}`);
-}
-async function serviceUninstall(deps = {}) {
-  const outcome = await uninstallService(deps);
-  for (const line of outcome.lines) write(`${INDENT}${line}`);
-  if (outcome.lines.length > 0) return;
-  setRunsAsService(false);
-  write(
-    INDENT + tick("Removed the service. Cabane won't start at boot, and it isn't running now.")
-  );
-  write(`${INDENT}  Start it again with  ${cabane("start")}`);
-}
-async function serviceStatus(deps = {}) {
-  const state = await serviceState(deps);
-  for (const line of serviceRows(state)) write(line);
-  for (const line of updateRows(readUpdateState(), safeConfig()?.update?.auto, {
-    service: state.installed
-  }))
-    write(line);
-  if (state.installed && state.state !== "running") process.exitCode = 1;
-}
-var LABEL_WIDTH = 13;
-var row = (label, value) => `  ${label.padEnd(LABEL_WIDTH)}${value}`;
-function serviceRows(state) {
-  if (!state.installed) {
-    return [
-      row(
-        "Service",
-        state.platform ? `not installed \u2014 ${cabane("service install")} starts Cabane at boot` : "not available on this system"
-      )
-    ];
-  }
-  const via = state.platform === "systemd" ? "systemd" : "launchd";
-  const rows = [
-    row(
-      "Service",
-      state.state === "running" ? `running (${via}${state.pid ? `, pid ${state.pid}` : ""})` : `installed, not running (${via}: ${state.state})`
-    )
-  ];
-  if (!state.nodeOk) {
-    rows.push(
-      `  ! The service's Node at ${tildePath(state.node ?? "")} is gone. Run  ${cabane("service install")}  again.`
-    );
-  }
-  return rows;
-}
-function updateRows(state, auto, opts = {}) {
-  const rows = [];
-  if (opts.version !== false) rows.push(row("Version", COMPANION_VERSION));
-  if (state.server) {
-    rows.push(
-      row(
-        "Cabane wants",
-        `${state.server.latest} (the latest), ${state.server.minimum} or newer to run turns`
-      )
-    );
-  }
-  rows.push(
-    row(
-      "Auto-update",
-      !opts.service ? `off \u2014 runs with the service: ${cabane("service install")}` : auto === true ? "on \u2014 updates install between turns when they can, and roll back if they fail" : `off \u2014 ${cabane("update --auto on")} turns it on`
-    )
-  );
-  const last = state.lastResult;
-  if (last) {
-    const when = new Date(last.at).toLocaleDateString("en-GB", { day: "numeric", month: "short" });
-    const why = last.reason ? `: ${last.reason}` : "";
-    rows.push(
-      row(
-        "Last update",
-        last.kind === "updated" ? `${last.from} \u2192 ${last.to} on ${when}` : last.kind === "rolled_back" ? `${last.to} rolled back to ${last.from} on ${when}${why}` : `${last.to} failed on ${when}${why}`
-      )
-    );
-  }
-  return rows;
-}
-function safeConfig() {
-  try {
-    return loadConfig();
-  } catch {
-    return null;
-  }
-}
-function setRunsAsService(on) {
-  const cfg = safeConfig();
-  if (!cfg) return;
-  const { serviceDeclined: _declined, ...rest } = cfg;
-  saveConfig({ ...rest, update: { auto: on } });
-}
-
-// src/commands/setup.ts
-var DETECT_TIMEOUT_MS = 15e3;
-async function setup(opts = {}, deps = {}) {
-  setLogOverrides(opts);
-  setConsoleLogging(false);
-  try {
-    await setupScript(opts, deps);
-  } finally {
-    setConsoleLogging(true);
-  }
-}
-async function setupScript(opts, deps) {
-  const interactive = deps.interactive ?? isInteractive();
-  const paired = isDevicePaired();
-  if (!opts.code && !paired) {
-    write("Get a setup line from your workspace's Settings \u2192 Devices, then paste it here.");
-    return;
-  }
-  const ui = deps.ui ?? (interactive ? terminalUi() : plainUi());
-  const running = await (deps.live ?? liveCompanionState)();
-  const cfg = safeLoadConfig();
-  if (opts.code) {
-    const strays2 = (deps.strays ?? findStrayCompanions)(running ? [running.pid] : []);
-    if (strays2.length) {
-      ui.cancel(strayCompanionLines(strays2, cabane("setup")).join("\n"));
-      process.exitCode = 1;
-      return;
-    }
-    const baseUrl = resolvePairBaseUrl(opts.server ?? cfg?.baseUrl);
-    if (paired && cfg && new URL(cfg.baseUrl).origin !== new URL(baseUrl).origin)
-      throw new CompanionError(
-        "This computer is paired to another Cabane server. Log out before setting it up on a different server."
-      );
-    const device = await (deps.claim ?? claimSetupCode)(baseUrl, {
-      userCode: opts.code,
-      label: deviceLabelFromHostname(hostname3()) ?? "Computer",
-      ...paired && cfg?.deviceToken && cfg.baseUrl.replace(/\/$/, "") === baseUrl.replace(/\/$/, "") ? { deviceToken: cfg.deviceToken } : {}
-    });
-    writePairedConfig(device);
-    const detection2 = await detect(safeLoadConfig(), running, deps);
-    if (!running && interactive && !await bringUp2(ui, opts)) return;
-    for (const line of agentLines(detection2, { signInHint: !anyUsable(detection2) })) write(line);
-    write("All set here. Back to the browser.");
-    if (!running && !interactive) await start({ ...opts, foreground: true });
-    return;
-  }
-  const detection = await detect(cfg, running, deps);
-  ui.intro("Cabane setup");
-  const usable = anyUsable(detection);
-  ui.step(["Harnesses on this device", ...agentLines(detection, { signInHint: !usable })]);
-  if (!usable && hasProblem(detection)) {
-    ui.cancel(`Fix the above, then run  ${cabane("setup")}  again.`);
-    process.exitCode = 1;
-    return;
-  }
-  if (!usable) {
-    const choice = await ui.select(CHOOSE_AGENT, AGENT_CHOICES);
-    if (!choice) {
-      ui.cancel(`Run  ${cabane("setup")}  when you're ready.`);
-      process.exitCode = 1;
-      return;
-    }
-    const note2 = agentNote(choice);
-    ui.note(note2.lines, note2.title);
-    ui.outro(["Come back when you're signed in."]);
-    process.exitCode = 1;
-    return;
-  }
-  if (paired && running) {
-    ui.outro(["Nothing left to set up."]);
-    return;
-  }
-  const strays = (deps.strays ?? findStrayCompanions)(running ? [running.pid] : []);
-  if (strays.length > 0) {
-    ui.cancel(strayCompanionLines(strays, cabane("setup")).join("\n"));
-    process.exitCode = 1;
-    return;
-  }
-  if (!await bringUp2(ui, opts)) return;
-  ui.outro(["All set here. Back to the browser."]);
-}
-async function detect(cfg, running, deps) {
-  const local = deps.detect ?? ((c) => detectHarnesses(c));
-  if (!running?.socket) return local(cfg);
-  try {
-    return await (deps.detectRunning ?? detectOverSocket)(running.socket);
-  } catch {
-    return local(cfg);
-  }
-}
-async function detectOverSocket(socket) {
-  const body = await controlRequest(
-    socket,
-    { cmd: "detect" },
-    DETECT_TIMEOUT_MS
-  );
-  if (!body.detection) throw new Error("the running companion sent no detection");
-  return body.detection;
-}
-function hasProblem(detection) {
-  return HARNESS_RUNTIMES.some((runtime) => detection[runtime].state === "problem");
-}
-function agentLines(detection, opts) {
-  const rows = agentRows(detection, opts);
-  const names = rows.map((row3) => row3.usable ? `\u2713 ${row3.label}` : row3.label);
-  const width = Math.max(...names.map((name) => name.length)) + 3;
-  return rows.map((row3, i) => `${names[i].padEnd(width)}${row3.text}`);
-}
-async function bringUp2(ui, opts) {
-  if (serviceInstalled()) {
-    const outcome = await startService();
-    if (!outcome.ok) {
-      ui.cancel(outcome.lines.join(" "));
-      process.exitCode = 1;
-      return null;
-    }
-    return { asService: true, declined: false };
-  }
-  if (servicePlatform()) {
-    const spinner = ui.spinner();
-    spinner.start("Installing the service\u2026");
-    if (await installAndStartService()) {
-      spinner.stop("Service installed.");
-      return { asService: true, declined: false };
-    }
-    spinner.stop("Running it in the background instead.");
-  }
-  const { started } = await startDaemon({
-    report: "failures",
-    ...opts.logLevel ? { logLevel: opts.logLevel } : {},
-    ...opts.logFormat ? { logFormat: opts.logFormat } : {}
-  });
-  if (!started) return null;
-  return { asService: false, declined: false };
-}
-function safeLoadConfig() {
-  try {
-    return loadConfig();
+    return loadConfig();
   } catch {
     return null;
   }
@@ -19086,6 +18958,7 @@ async function logs(opts = {}) {
 }
 
 // src/commands/status.ts
+init_cabane_command();
 init_install_kind();
 init_cabane_command();
 import { readdirSync as readdirSync7, realpathSync as realpathSync8, existsSync as existsSync21 } from "fs";
@@ -19097,6 +18970,211 @@ init_secrets();
 init_term();
 init_transcript_writer();
 init_version2();
+
+// src/commands/service.ts
+init_cabane_command();
+init_config();
+init_term();
+init_version2();
+
+// src/commands/stop.ts
+var TERM_GRACE_MS = 6e3;
+var POLL_INTERVAL_MS2 = 150;
+async function stop(deps = {}) {
+  if ((deps.serviceInstalled ?? serviceInstalled)()) {
+    const outcome = await (deps.stopService ?? stopService)();
+    for (const line of outcome.lines) process.stdout.write(`${line}
+`);
+    if (!outcome.ok) {
+      process.exitCode = 1;
+      return;
+    }
+    process.stdout.write(
+      "companion: stopped the service. It starts again at boot, or with `cabane start`.\n"
+    );
+    return;
+  }
+  const readState = deps.readState ?? readLiveRuntimeState;
+  const verify = deps.verify ?? ((s) => verifyRuntime(s));
+  const kill = deps.kill ?? ((pid2, signal) => process.kill(pid2, signal));
+  const sleep3 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const now = deps.now ?? (() => Date.now());
+  const state = readState();
+  if (!state) {
+    process.stdout.write("companion: not running (nothing to stop).\n");
+    return;
+  }
+  if (await verify(state) === "stale") {
+    clearRuntimeState();
+    process.stdout.write("companion: not running (stale marker swept).\n");
+    return;
+  }
+  const { pid } = state;
+  process.stdout.write(`companion: stopping (pid ${pid})\u2026
+`);
+  try {
+    kill(pid, "SIGTERM");
+  } catch {
+    clearRuntimeState();
+    process.stdout.write("companion: already stopped.\n");
+    return;
+  }
+  const deadline = now() + TERM_GRACE_MS;
+  while (now() < deadline) {
+    if (!isAlive(kill, pid)) {
+      process.stdout.write("companion: stopped.\n");
+      return;
+    }
+    await sleep3(POLL_INTERVAL_MS2);
+  }
+  process.stdout.write(
+    `companion: didn't exit within ${TERM_GRACE_MS / 1e3}s, sending SIGKILL.
+`
+  );
+  try {
+    kill(pid, "SIGKILL");
+  } catch {
+  }
+  clearRuntimeState();
+  process.stdout.write("companion: force-stopped.\n");
+}
+function isAlive(kill, pid) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/service.ts
+var STARTUP_WAIT_MS = 2e4;
+async function installAndStartService(deps = {}) {
+  const readState = deps.readState ?? readLiveRuntimeState;
+  const sleep3 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const now = deps.now ?? Date.now;
+  const before = await serviceState(deps);
+  const running = readState();
+  if (running && running.pid !== before.pid) await (deps.stopRunning ?? (() => stop()))();
+  setRunsAsService(true);
+  const outcome = await installService(deps);
+  for (const line of outcome.lines) write(`${INDENT}${line}`);
+  if (!outcome.ok) {
+    setRunsAsService(false);
+    return false;
+  }
+  const deadline = now() + STARTUP_WAIT_MS;
+  while (now() < deadline) {
+    const state = readState();
+    if (state?.socket) return true;
+    await sleep3(250);
+  }
+  write(
+    `${INDENT}The service is installed but Cabane hasn't come up yet. ${cabane("service status")} and ${cabane("logs")} say why.`
+  );
+  return false;
+}
+async function serviceInstall(deps = {}) {
+  if (!await installAndStartService(deps)) {
+    process.exitCode = 1;
+    return;
+  }
+  write(
+    INDENT + tick(
+      "Cabane runs as a service. It starts at boot, restarts if it stops, and updates itself, usually between turns."
+    )
+  );
+  write(`${INDENT}  Status:  ${cabane("service status")}        Logs:  ${cabane("logs")}`);
+}
+async function serviceUninstall(deps = {}) {
+  const outcome = await uninstallService(deps);
+  for (const line of outcome.lines) write(`${INDENT}${line}`);
+  if (outcome.lines.length > 0) return;
+  setRunsAsService(false);
+  write(
+    INDENT + tick("Removed the service. Cabane won't start at boot, and it isn't running now.")
+  );
+  write(`${INDENT}  Start it again with  ${cabane("start")}`);
+}
+async function serviceStatus(deps = {}) {
+  const state = await serviceState(deps);
+  for (const line of serviceRows(state)) write(line);
+  for (const line of updateRows(readUpdateState(), safeConfig()?.update?.auto, {
+    service: state.installed
+  }))
+    write(line);
+  if (state.installed && state.state !== "running") process.exitCode = 1;
+}
+var LABEL_WIDTH = 13;
+var row = (label, value) => `  ${label.padEnd(LABEL_WIDTH)}${value}`;
+function serviceRows(state) {
+  if (!state.installed) {
+    return [
+      row(
+        "Service",
+        state.platform ? `not installed \u2014 ${cabane("service install")} starts Cabane at boot` : "not available on this system"
+      )
+    ];
+  }
+  const via = state.platform === "systemd" ? "systemd" : "launchd";
+  const rows = [
+    row(
+      "Service",
+      state.state === "running" ? `running (${via}${state.pid ? `, pid ${state.pid}` : ""})` : `installed, not running (${via}: ${state.state})`
+    )
+  ];
+  if (!state.nodeOk) {
+    rows.push(
+      `  ! The service's Node at ${tildePath(state.node ?? "")} is gone. Run  ${cabane("service install")}  again.`
+    );
+  }
+  return rows;
+}
+function updateRows(state, auto, opts = {}) {
+  const rows = [];
+  if (opts.version !== false) rows.push(row("Version", COMPANION_VERSION));
+  if (state.server) {
+    rows.push(
+      row(
+        "Cabane wants",
+        `${state.server.latest} (the latest), ${state.server.minimum} or newer to run turns`
+      )
+    );
+  }
+  rows.push(
+    row(
+      "Auto-update",
+      !opts.service ? `off \u2014 runs with the service: ${cabane("service install")}` : auto === true ? "on \u2014 updates install between turns when they can, and roll back if they fail" : `off \u2014 ${cabane("update --auto on")} turns it on`
+    )
+  );
+  const last = state.lastResult;
+  if (last) {
+    const when = new Date(last.at).toLocaleDateString("en-GB", { day: "numeric", month: "short" });
+    const why = last.reason ? `: ${last.reason}` : "";
+    rows.push(
+      row(
+        "Last update",
+        last.kind === "updated" ? `${last.from} \u2192 ${last.to} on ${when}` : last.kind === "rolled_back" ? `${last.to} rolled back to ${last.from} on ${when}${why}` : `${last.to} failed on ${when}${why}`
+      )
+    );
+  }
+  return rows;
+}
+function safeConfig() {
+  try {
+    return loadConfig();
+  } catch {
+    return null;
+  }
+}
+function setRunsAsService(on) {
+  const cfg = safeConfig();
+  if (!cfg) return;
+  const { serviceDeclined: _declined, ...rest } = cfg;
+  saveConfig({ ...rest, update: { auto: on } });
+}
+
+// src/commands/status.ts
 var LABEL_WIDTH2 = 13;
 function row2(label, value) {
   return `  ${label.padEnd(LABEL_WIDTH2)}${value}`;
@@ -19105,6 +19183,7 @@ async function status(deps = {}) {
   const out = (line) => void process.stdout.write(`${line}
 `);
   const running = await liveState();
+  for (const line of pathLines(reloadLine())) out(line);
   const strays = strayStatusLines(running, deps.strays);
   out(`  ${versionLine()}`);
   for (const line of otherInstallLines(running)) out(line);
@@ -19115,7 +19194,9 @@ async function status(deps = {}) {
     cfg = null;
   }
   if (!cfg || !cfg.deviceToken) {
-    out(`  Not paired yet. Run  ${cabane("setup")}  to set up this device.`);
+    out(
+      "  Not paired yet. Get a setup line from a workspace's Settings \u2192 Devices and paste it here."
+    );
     for (const line of strays) out(line);
     process.exitCode = 1;
     return;
@@ -19130,6 +19211,16 @@ async function status(deps = {}) {
   } else {
     out(row2("Running", `no \u2014 start it with  ${cabane("start")}`));
   }
+  out(
+    row2(
+      "Device",
+      deviceLine({
+        ...await readTerminalStatus(running?.socket),
+        running: !!running,
+        devicesUrl: `${cfg.baseUrl.replace(/\/$/, "")}/settings/devices`
+      })
+    )
+  );
   for (const line of strays) out(line);
   const service2 = await serviceState();
   for (const line of serviceRows(service2)) out(line);