@cabane/companion 0.6.178 → 0.6.179

package/dist/runtime.js

@@ -1714,16 +1714,49 @@ async function verifyRuntime(state, requestImpl = controlRequest) {
   return body.instance_id === state.instanceId ? "ours" : "stale";
 }
 
+// src/heartbeat-status.ts
+import { z as z3 } from "zod";
+
+// src/device-state.ts
+var DEVICE_STATES = ["waiting", "online", "offline", "deactivated"];
+var HARNESS_STATES = [
+  "checking",
+  "connected",
+  "needs_sign_in",
+  "limited",
+  "problem",
+  "off",
+  "gone"
+];
+var DEVICE_HEALTH_STATES = ["checking", "ready", "degraded"];
+
+// src/heartbeat-status.ts
+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
 import { hostname as hostname2 } from "os";
 
 // packages/agent-runtime/src/failure.ts
-import { z as z3 } from "zod";
-var 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") })
+import { z as z4 } from "zod";
+var 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") })
 ]);
 var USAGE_CAPPED = "usage_capped";
 var RATE_LIMITED = "rate_limited";
@@ -2552,8 +2585,8 @@ import {
   writeFileSync as writeFileSync3
 } from "fs";
 import { join as join11 } 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 join11(cabaneDir(), "credentials");
 }
@@ -2769,34 +2802,34 @@ function noResume() {
 var TURN_PROTOCOL_VERSION = 1;
 
 // packages/agent-runtime/src/host-policy.ts
-import { z as z5 } from "zod";
-var hostPolicySchema = z5.object({
+import { z as z6 } from "zod";
+var 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";
-var turnEventSchema = z6.discriminatedUnion("type", [
+import { z as z7 } from "zod";
+var 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.
@@ -2808,21 +2841,21 @@ var turnEventSchema = z6.discriminatedUnion("type", [
   // 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`.
@@ -2831,15 +2864,15 @@ var turnEventSchema = z6.discriminatedUnion("type", [
   // 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`.
@@ -2860,70 +2893,70 @@ var turnEventSchema = z6.discriminatedUnion("type", [
   // 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()
   })
 ]);
 
 // packages/agent-runtime/src/turn-diagnostics.ts
-import { z as z7 } from "zod";
-var 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") })
+import { z as z8 } from "zod";
+var 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") })
 ]);
 var turnOutcomes = ["success", "failure", "cancelled", "skipped"];
 var turnSessionModes = ["fresh", "resumed", "degraded"];
@@ -2935,25 +2968,25 @@ var turnFinalSources = [
   "marker",
   "none"
 ];
-var turnDiagnosticsSchema = z7.object({
-  outcome: z7.enum(turnOutcomes),
+var 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()
 });
 
@@ -3014,100 +3047,100 @@ function classifyEmptyResult(input) {
 }
 
 // packages/agent-runtime/src/turn-request.ts
-import { z as z8 } from "zod";
-var 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() })
+import { z as z9 } from "zod";
+var 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() })
   })
 ]);
-var effortLevelSchema = z8.enum(["low", "medium", "high", "xhigh", "max"]);
-var resolvedRunConfigSchema = z8.object({
-  model: z8.string().nullable(),
+var effortLevelSchema = z9.enum(["low", "medium", "high", "xhigh", "max"]);
+var 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()
 });
-var 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()
+var 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()
   })
 ]);
-var resolvedMcpServersSchema = z8.record(z8.string(), resolvedMcpServerSchema);
-var hostInjectedServersSchema = z8.record(z8.string(), z8.unknown());
-var turnRequestSchema = z8.object({
+var resolvedMcpServersSchema = z9.record(z9.string(), resolvedMcpServerSchema);
+var hostInjectedServersSchema = z9.record(z9.string(), z9.unknown());
+var 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
   })
 });
@@ -3123,12 +3156,12 @@ function standingSegments(req) {
 }
 
 // packages/agent-runtime/src/conformance.ts
-import { z as z9 } from "zod";
-var conformanceFixtureSchema = z9.object({
-  name: z9.string(),
+import { z as z10 } from "zod";
+var 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)
 });
 
 // packages/agent-runtime/src/transcript.ts
@@ -3583,7 +3616,7 @@ function envResolvedFrom(server, secretEnv) {
 }
 
 // packages/agent-runtime/src/claude-code/policy.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var HOST_FS_TOOLS = [
   // shell + local filesystem
   "Bash",
@@ -3633,18 +3666,18 @@ function withThinkingSummaries(thinking) {
   if (thinking.type === "disabled") return thinking;
   return { display: "summarized", ...thinking };
 }
-var claudeCodeDialectSchema = z10.object({
-  thinking: z10.discriminatedUnion("type", [
-    z10.object({
-      type: z10.literal("adaptive"),
-      display: z10.enum(["summarized", "omitted"]).optional()
+var 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();
 function readThinking(runtimeOptions) {
@@ -5113,7 +5146,7 @@ function sealHeld(held, terminal) {
 }
 
 // packages/agent-runtime/src/opencode/policy.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var OPENCODE_HOST_TOOLS = [
   "bash",
   "edit",
@@ -5140,8 +5173,8 @@ function opencodeToolPolicy(policy) {
   deny(OPENCODE_UI_PROMPT_TOOLS);
   return { tools, allowAllHostTools: policy.hostFs };
 }
-var opencodeDialectSchema = z11.object({
-  agent: z11.string().min(1).optional()
+var opencodeDialectSchema = z12.object({
+  agent: z12.string().min(1).optional()
 }).loose();
 function readOpencodeDialect(runtimeOptions) {
   const parsed = opencodeDialectSchema.safeParse(runtimeOptions?.["opencode"] ?? {});
@@ -6355,7 +6388,7 @@ function sealHeld2(held, terminal) {
 }
 
 // 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",
@@ -6374,8 +6407,8 @@ function codexToolPolicy(policy) {
   };
 }
 var CODEX_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
-var codexDialectSchema = z12.object({
-  modelReasoningEffort: z12.enum(CODEX_REASONING_EFFORTS).optional()
+var codexDialectSchema = z13.object({
+  modelReasoningEffort: z13.enum(CODEX_REASONING_EFFORTS).optional()
 }).loose();
 function readCodexDialect(runtimeOptions) {
   const parsed = codexDialectSchema.safeParse(runtimeOptions?.["codex"] ?? {});
@@ -7817,30 +7850,30 @@ import { createInterface } from "readline";
 // 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";
-var hostPattern = z13.string().min(1);
-var secretRef = z13.string().regex(/^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/, "must be a ${NAME} reference into secrets.json");
-var envCredentialSchema = z13.object({ secret: secretRef, hosts: z13.array(hostPattern).min(1) }).strict();
-var 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(),
+import { z as z14 } from "zod";
+var hostPattern = z14.string().min(1);
+var secretRef = z14.string().regex(/^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/, "must be a ${NAME} reference into secrets.json");
+var envCredentialSchema = z14.object({ secret: secretRef, hosts: z14.array(hostPattern).min(1) }).strict();
+var 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();
-var sandboxPolicySchema = z13.object({
-  hosts: z13.object({
-    allow: z13.array(hostPattern).optional(),
-    deny: z13.array(hostPattern).optional(),
-    defaults: z13.boolean().optional()
+var 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();
 function parseSandboxPolicy(raw) {
@@ -8269,12 +8302,12 @@ function createTurnContainment(turnId, deps = {}) {
 // src/secrets.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 import { join as join13 } from "path";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function secretsPath() {
   return join13(cabaneDir(), "secrets.json");
 }
-var secretStoreSchema = z14.record(z14.string(), z14.string());
+var secretStoreSchema = z15.record(z15.string(), z15.string());
 function loadSecretStore() {
   const path = secretsPath();
   if (!existsSync9(path)) return makeStore({});
@@ -8391,52 +8424,52 @@ function missingSecretReason(missing) {
 }
 
 // src/runner/protocol.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/run-config.ts
-import { z as z15 } from "zod";
-var 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(),
+import { z as z16 } from "zod";
+var 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()
 });
-var mcpHttpServerSchema = z15.object({
-  type: z15.literal("http"),
-  url: z15.string().url(),
-  headers: z15.record(z15.string(), z15.string()).optional(),
+var 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()
 });
-var mcpSseServerSchema = z15.object({
-  type: z15.literal("sse"),
-  url: z15.string().url(),
-  headers: z15.record(z15.string(), z15.string()).optional(),
+var 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()
 });
-var mcpServerDefSchema = z15.union([mcpHttpServerSchema, mcpSseServerSchema, mcpStdioServerSchema]);
-var 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") })
+var mcpServerDefSchema = z16.union([mcpHttpServerSchema, mcpSseServerSchema, mcpStdioServerSchema]);
+var 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") })
 ]);
-var effortSchema = z15.enum(["low", "medium", "high", "xhigh", "max"]);
-var runConfigSchema = z15.object({
+var effortSchema = z16.enum(["low", "medium", "high", "xhigh", "max"]);
+var 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()
 });
@@ -8464,76 +8497,76 @@ var RUNNER_ENV = {
   // Everything else the turn is constructed from, as JSON: see `RunnerSpec`.
   spec: "CABANE_RUNNER_SPEC"
 };
-var runtimeHealthSchema = z16.object({
-  quotaState: z16.enum(["ok", "limited", "auth_expired", "unknown"]),
-  limitedUntil: z16.string().nullable(),
-  lastError: z16.string().nullable()
+var runtimeHealthSchema = z17.object({
+  quotaState: z17.enum(["ok", "limited", "auth_expired", "unknown"]),
+  limitedUntil: z17.string().nullable(),
+  lastError: z17.string().nullable()
 });
-var runnerSpecSchema = z16.object({
-  deviceId: z16.string().optional(),
+var 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()
 });
-var 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()
+var 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()
 });
-var 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()
+var 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()
 });
@@ -9002,7 +9035,7 @@ import { existsSync as existsSync11 } from "fs";
 
 // src/turn-control-tools.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
 var COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
 var SKIP_TURN_TOOL = "skip_turn";
@@ -9065,7 +9098,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;
@@ -9081,22 +9114,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) => {
@@ -9137,9 +9170,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;
@@ -9173,8 +9206,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",
@@ -12848,7 +12881,7 @@ function unusableReason(runtime, check) {
   if (check.status === "check_failed") return failureText(runtime, check.reason);
   return null;
 }
-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 spaced(sentence) {
   return sentence ? ` ${sentence}` : "";
 }
@@ -13572,27 +13605,27 @@ function compareVersions(a, b) {
 // src/update-state.ts
 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");
@@ -14080,6 +14113,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
@@ -14199,19 +14239,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",
@@ -14257,11 +14304,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);
@@ -14282,15 +14324,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,
@@ -14299,31 +14342,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(
@@ -14332,9 +14383,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."
       );
     }
   }
@@ -15421,7 +15473,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();
@@ -15699,7 +15752,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),