switchroom 0.16.28 → 0.16.38

package/dist/host-control/main.js

@@ -15921,19 +15921,30 @@ var TelegramChannelSchema = exports_external.object({
   stream_mode: exports_external.enum(["pty", "checklist"]).optional().describe("How live progress is streamed to Telegram during a turn. " + "'pty' (default) surfaces text snapshots of Claude Code's TUI — " + "compatible but can flicker as Ink re-renders. 'checklist' drives " + "a structured progress card from session-tail events — stable " + "order, per-tool status emojis, fires only on semantic transitions."),
   stream_throttle_ms: exports_external.number().int().nonnegative().optional().describe("Throttle window in ms between successive in-place stream edits " + "during a turn. Lower = more responsive stream, higher = fewer API " + "calls. Floored at 250 by draft-stream itself. Default 400 ms for DMs " + "and 1000 ms for groups/forums (respects Telegram's ~1 edit/sec/message " + "practical ceiling). Override per-agent if a particular agent needs " + "snappier or quieter streaming."),
   clear_status_on_completion: exports_external.boolean().optional().describe("When true, the live activity/status feed (the in-place 'what it's " + "doing' message — Reading X, Searching the web for Y, …) is DELETED " + "when the turn's final answer lands, so only the reply remains. " + "Default false: the status message is left in the chat as a record " + "(its last step marked done) — no post-then-delete. Per-agent " + "override; cascades defaults → profile → agent (per-key)."),
+  pin_status_while_working: exports_external.boolean().optional().describe("When true (default), the framework SILENTLY pins the already-" + "rendered status message while its work is in-flight and auto-unpins " + "it on completion — the per-turn activity/status message (foreground) " + "and the '\uD83D\uDEE0 Worker' background-worker message. Keeps in-flight work " + "in view when the conversation scrolls past it (fast turns, stacked " + "background workers, long turns). No new surface is rendered; it pins " + "a message the chat already owns. The pin never buzzes the device. " + "The ONE sanctioned pin under chat-is-the-single-source-of-truth. " + "Set false to disable. Per-agent override; cascades defaults → " + "profile → agent (per-key)."),
   hotReloadStable: exports_external.boolean().optional().describe("If true, the stable workspace prefix (AGENTS.md, SOUL.md, USER.md, " + "IDENTITY.md, TOOLS.md) is re-injected on every turn via " + "the UserPromptSubmit hook instead of baked into --append-system-prompt " + "at session start. Lets workspace edits propagate without a restart. " + "Costs ~5-10% per-turn latency/spend since the stable prefix is no " + "longer prompt-cached."),
   inject_on_change: exports_external.boolean().optional().describe("Context-efficiency gate for per-turn hook injection (default true). " + "When true (the default), the turn-pacing directive and dynamic " + "workspace content are only re-emitted when their content changes or " + "the session_id changes — suppressing redundant injection that " + "otherwise triples compaction frequency. Set to false to revert to " + "the legacy always-emit behaviour (every turn injects the full " + "content regardless of whether it changed)."),
   orphan_promotion_ms: exports_external.number().int().nonnegative().optional().describe("How long (ms) a parent turn waits for a sub-agent JSONL watcher " + "to deliver sub_agent_started before the heartbeat promotes the spawn " + "to a synthesised 'running' row. Default 5000. Set to 0 to disable " + "orphan promotion entirely."),
   cold_sub_agent_threshold_ms: exports_external.number().int().nonnegative().optional().describe("JSONL-cold threshold (ms). When a running sub-agent emits no events " + "for this long, the heartbeat synthesises a turn_end for it so the " + "deferred-completion path can proceed. Default 30000. Set to 0 to " + "disable the synthetic close."),
   deferred_completion_timeout_ms: exports_external.number().int().nonnegative().optional().describe("Force-close timeout (ms) for deferred sub-agent completion. After " + "the parent turn_end arrives while sub-agents are still running, the " + "card is force-closed after this many ms even if sub-agents never " + "finish. Watcher-disconnect safety net. Default 180000 (3 min)."),
+  approval_timeout_minutes: exports_external.number().int().nonnegative().optional().describe("Operator approval-card lifetime (minutes) for the tool-use 'Allow " + "once' card and the vault grant decision wait. After this long with " + "no operator tap, the card auto-denies (a TIMEOUT, not a denial — the " + "agent is told not to retry). Default 60. hostd-gated verbs " + "(mcp__hostd__*) keep their own longer window; the hostd " + "config-propose card is not governed by this key."),
   sub_agent_tick_interval_ms: exports_external.number().int().nonnegative().optional().describe("Heartbeat tick interval (ms) for sub-agent rendering. Forces a " + "re-render of the elapsed-time counter while sub-agents are running, " + "even during silent stretches between tool calls. Default 10000 (10 s). " + "Set to 0 to disable the elapsed-ticker path."),
   edit_budget_threshold: exports_external.number().int().nonnegative().optional().describe("Telegram API edit budget per minute before the progress-card driver " + "falls back to a slower coalesce window. When a chat accumulates more " + "than this many card edits in the trailing 60 s, the driver switches " + "to a wider coalesce interval until the rate drops back. Default 18. " + "Increase if your gateway frequently bumps the Telegram edit-rate ceiling " + "with many parallel sub-agents; decrease for a more conservative buffer."),
   stickers: exports_external.record(exports_external.string(), exports_external.string()).optional().describe("Sticker aliases for the `send_sticker` MCP tool (#576). Maps a " + "short alias name (e.g. 'happy', 'thinking') to a Telegram file_id. " + "Operator-curated — capture file_ids from inbound stickers the user " + "sends and add them here. The agent calls send_sticker(chat_id, " + "alias='happy') and the gateway resolves to the file_id at send " + "time. Aliases enable persona-flavored expressiveness without " + "exposing raw file_ids in the agent prompt. Personal-assistant / " + "health-coach personas benefit; coding agents typically don't " + "configure any."),
   voice_in: exports_external.object({
     enabled: exports_external.boolean().optional().describe("Master switch for voice-message transcription."),
     provider: exports_external.enum(["openai"]).optional().describe("Transcription provider. Only 'openai' (Whisper API) supported in the spike (#578); " + "Groq/Deepgram/local-whisper-cli are follow-up choices."),
-    language: exports_external.string().optional().describe("Optional ISO-639-1 language hint (e.g. 'en', 'fr'). Skips Whisper's auto-detection.")
-  }).optional().describe("Inbound voice-message transcription (#578). When enabled, voice/audio " + "messages from allowlisted users are downloaded, transcribed via the " + "configured provider, and surface to the agent as the user's text. " + "API key read from ~/.switchroom/openai-api-key (mode 0600). Off by " + "default — opt-in per agent. Cascades from defaults.channels.telegram.voice_in. " + "(Migrated from per-agent root in #596 — see consistency unification.)"),
+    language: exports_external.string().optional().describe("Optional ISO-639-1 language hint (e.g. 'en', 'fr'). Skips Whisper's auto-detection."),
+    api_key: exports_external.string().optional().describe("Transcription-provider API key, as a `vault:<key>` reference " + "(e.g. 'vault:openai/api-key' — the default if omitted). The " + "gateway resolves it through the vault broker at use-time and " + "never writes the resolved value to disk or the agent prompt. " + "`switchroom enable voice-in` vault-stores the key and writes " + "this reference for you. A literal key is accepted but " + "discouraged — keep secrets in the vault.")
+  }).optional().describe("Inbound voice-message transcription (#578). When enabled, voice/audio " + "messages from allowlisted users are downloaded, transcribed via the " + "configured provider, and surface to the agent as the user's text. " + "The provider API key is a `vault:` reference (`api_key`, default " + "`vault:openai/api-key`) resolved through the vault broker at " + "use-time — opt-in third-party key, honest-exception per the " + "subscription-honest outcome. Off by default — opt-in per agent. " + "Cascades from defaults.channels.telegram.voice_in. " + "(Migrated from per-agent root in #596 — see consistency unification.)"),
+  voice_out: exports_external.object({
+    enabled: exports_external.boolean().optional().describe("Master switch for spoken-reply (TTS) voice notes."),
+    engine: exports_external.enum(["kokoro", "openai"]).default("kokoro").describe("Synthesis engine. 'kokoro' = local voice sidecar (POST /tts, " + "subscription-honest, no third-party key); 'openai' = OpenAI TTS " + "cloud (honest-exception, requires an `api_key` vault ref). " + "'kokoro' is only active when the host voice verdict is local " + "(SWITCHROOM_VOICE_ENGINE === 'local'); otherwise voice-out is a " + "no-op and replies stay text-only."),
+    voice: exports_external.string().optional().describe("Engine-specific voice id (e.g. a Kokoro voice name or an OpenAI " + "voice like 'alloy'). Optional — the sidecar/engine has its own " + "default when omitted."),
+    reply_mode: exports_external.enum(["voice+text", "voice-only", "on-demand"]).default("voice+text").describe("How the spoken reply accompanies the text. 'voice+text' sends " + "both the normal text reply and a voice note; 'voice-only' sends " + "the voice note and suppresses the text body. 'on-demand' sends " + "the text reply with a single '\uD83D\uDD0A Listen' inline button and " + "synthesizes NO audio until the user taps it — zero GPU/sidecar " + "work unless requested, which keeps the voice pipeline " + "subscription-honest and visible (nothing is generated behind the " + "user's back). The Listen button is injected ONLY when the reply " + "carries no agent-authored buttons, to avoid colliding with the " + "single_use keyboard-strip that protects agent buttons from " + "double-fire. In every mode the text reply is ALWAYS still sent " + "when synthesis fails or the reply exceeds max_chars — the user's " + "answer is never dropped silently."),
+    max_chars: exports_external.number().int().positive().optional().describe("Per-voice-note chunk size (chars). Default 600; clamped to the " + "engine's hard cap (1200). A reply LONGER than this is NOT truncated " + "to text — it's split on sentence/paragraph boundaries and spoken " + "across several sequential voice notes, so the full answer is heard " + "even when the user can't read the screen (driving / cycling). Lower " + "it for snappier individual notes; raise it (up to 1200) for fewer, " + "longer notes."),
+    api_key: exports_external.string().optional().describe("OpenAI TTS API key as a `vault:<key>` reference (only used when " + "engine='openai'; default 'vault:openai/api-key'). Resolved through " + "the vault broker at use-time and never written to disk or the agent " + "prompt. Ignored for engine='kokoro' (the sidecar needs no key).")
+  }).optional().describe("Outbound spoken replies via TTS (PR-C2). When enabled, the gateway " + "synthesizes the agent's text reply into an OGG/Opus voice note and " + "sends it alongside (or instead of) the text, per reply_mode. The " + "'kokoro' engine uses the local voice sidecar (POST /tts) and is only " + "active when the host voice verdict is local; the 'openai' engine is " + "an honest-exception cloud path gated on an `api_key` vault ref. Voice " + "is best-effort and fully non-fatal — any TTS error falls back to the " + "text reply. Off by default — opt-in per agent. " + "Cascades from defaults.channels.telegram.voice_out."),
   telegraph: exports_external.object({
     enabled: exports_external.boolean().optional().describe("Master switch for Telegraph Instant View publishing."),
     threshold: exports_external.number().int().positive().optional().describe("Char count above which a reply is published to Telegraph instead of " + "HTML-chunked into multiple Telegram messages. Default 3000 (≈3 chunks)."),
@@ -22593,7 +22604,7 @@ import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:f
 import { dirname as dirname4, join as join2 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.16.28";
+var VERSION = "0.16.38";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {
@@ -22696,15 +22707,77 @@ function parseAuditLine(line) {
     entry.failed_step = o.failed_step;
   if (typeof o.failed_agent === "string")
     entry.failed_agent = o.failed_agent;
+  if (typeof o.agent === "string")
+    entry.agent = o.agent;
+  if (typeof o.n === "number")
+    entry.n = o.n;
+  if (typeof o.m === "number")
+    entry.m = o.m;
   if (typeof o.prior_pin === "string")
     entry.prior_pin = o.prior_pin;
   return entry;
 }
+function latestRolloutRowForRequest(raw, requestId) {
+  const ROLLOUT_OPS = new Set(["rollout", "rollout_orphaned"]);
+  let latest = null;
+  for (const line of raw.split(`
+`)) {
+    const e = parseAuditLine(line);
+    if (e === null)
+      continue;
+    if (e.request_id !== requestId)
+      continue;
+    if (!ROLLOUT_OPS.has(e.op))
+      continue;
+    latest = e;
+  }
+  return latest;
+}
 
 // src/cli/rollout.ts
 function isVersionAssertable(target) {
   return /^v?\d+\.\d+\.\d+$/.test(target.trim());
 }
+var ROLLOUT_PHASE_SENTINEL = "SWITCHROOM_ROLLOUT_PHASE:";
+function parseRolloutPhaseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith(ROLLOUT_PHASE_SENTINEL))
+    return null;
+  let obj;
+  try {
+    obj = JSON.parse(trimmed.slice(ROLLOUT_PHASE_SENTINEL.length));
+  } catch {
+    return null;
+  }
+  if (typeof obj !== "object" || obj === null)
+    return null;
+  const o = obj;
+  const PHASES = new Set([
+    "apply",
+    "canary-start",
+    "canary-pass",
+    "canary-fail",
+    "agent-start",
+    "agent-done",
+    "persist-pin",
+    "hostd-web-deferred"
+  ]);
+  if (typeof o.phase !== "string" || !PHASES.has(o.phase))
+    return null;
+  if (typeof o.target !== "string")
+    return null;
+  const out = {
+    phase: o.phase,
+    target: o.target
+  };
+  if (typeof o.agent === "string")
+    out.agent = o.agent;
+  if (typeof o.n === "number")
+    out.n = o.n;
+  if (typeof o.m === "number")
+    out.m = o.m;
+  return out;
+}
 var ROLLOUT_RESULT_SENTINEL = "SWITCHROOM_ROLLOUT_RESULT:";
 function parseRolloutResultLine(stdout) {
   const lines = stdout.split(`
@@ -22735,6 +22808,18 @@ import { execFileSync, spawn, spawnSync } from "node:child_process";
 // src/agents/tmux.ts
 var MAX_BYTES = 10 * 1024 * 1024;
 
+// src/agents/singleton-reconcile.ts
+var CORE_SINGLETON_SERVICES = [
+  "vault-broker",
+  "approval-kernel",
+  "switchroom-auth-broker"
+];
+var VOICE_SIDECAR_SERVICE = "voice-sidecar";
+var SINGLETON_SERVICES = [
+  ...CORE_SINGLETON_SERVICES,
+  VOICE_SIDECAR_SERVICE
+];
+
 // src/agents/lifecycle.ts
 function containerName(name) {
   return `switchroom-${name}`;
@@ -22855,6 +22940,33 @@ function isTargetPathHeader(headerPath, targetBasename) {
     return false;
   return norm === targetBasename || basename2(norm) === targetBasename;
 }
+function normalizeDiffHeadersToBasename(unifiedDiff, targetBasename) {
+  const rewriteHeaderLine = (line, marker) => {
+    const rest = line.slice(marker.length);
+    const tabIdx = rest.indexOf("\t");
+    const pathPart = (tabIdx === -1 ? rest : rest.slice(0, tabIdx)).trim();
+    const tail = tabIdx === -1 ? "" : rest.slice(tabIdx);
+    if (pathPart === "/dev/null")
+      return line;
+    let prefix = "";
+    let p = pathPart;
+    if (p.startsWith("a/") || p.startsWith("b/")) {
+      prefix = p.slice(0, 2);
+      p = p.slice(2);
+    }
+    const newPath = `${prefix}${targetBasename}`;
+    return `${marker}${newPath}${tail}`;
+  };
+  return unifiedDiff.split(`
+`).map((ln) => {
+    if (ln.startsWith("--- "))
+      return rewriteHeaderLine(ln, "--- ");
+    if (ln.startsWith("+++ "))
+      return rewriteHeaderLine(ln, "+++ ");
+    return ln;
+  }).join(`
+`);
+}
 function validateShape(unifiedDiff, targetPath) {
   const byteLen = Buffer.byteLength(unifiedDiff, "utf8");
   if (byteLen > MAX_PATCH_BYTES) {
@@ -22929,11 +23041,12 @@ function applyPatch(unifiedDiff, configPath, gitBin) {
   const liveContent = readFileSync5(configPath, "utf8");
   const scratchDir = mkdtempSync(join4(tmpdir(), "config-propose-edit-"));
   try {
-    const basename3 = configPath.split("/").pop() ?? "switchroom.yaml";
-    const scratchFile = join4(scratchDir, basename3);
+    const targetBasename = configPath.split("/").pop() ?? "switchroom.yaml";
+    const scratchFile = join4(scratchDir, targetBasename);
     writeFileSync2(scratchFile, liveContent);
+    const normalizedDiff = normalizeDiffHeadersToBasename(unifiedDiff, targetBasename);
     const patchFile = join4(scratchDir, "proposal.patch");
-    writeFileSync2(patchFile, unifiedDiff);
+    writeFileSync2(patchFile, normalizedDiff);
     const bin = gitBin ?? "git";
     const baseArgs = [
       "apply",
@@ -23314,6 +23427,43 @@ function classifyBlastRadius(beforeYaml, afterYaml) {
   };
 }
 
+// src/host-control/render-rollout-status.ts
+function phaseLine(s) {
+  switch (s.phase) {
+    case "apply":
+      return "applying — regenerating compose";
+    case "canary-start":
+      return `canary — restarting ${s.agent ?? "canary agent"}`;
+    case "canary-pass":
+      return `canary passed (${s.agent ?? "canary"}) — rolling the rest`;
+    case "canary-fail":
+      return `canary failed (${s.agent ?? "canary"})`;
+    case "agent-start":
+      return `agent ${s.n ?? "?"}/${s.m ?? "?"} — restarting ${s.agent ?? ""}`.trim();
+    case "agent-done":
+      return `agent ${s.n ?? "?"}/${s.m ?? "?"} — ${s.agent ?? ""} done`.trim();
+    case "persist-pin":
+      return "persisting pin";
+    case "hostd-web-deferred":
+      return "hostd/web refresh deferred (run host-side)";
+    default:
+      return "starting";
+  }
+}
+function renderRolloutStatus(s) {
+  const head = `Rollout → ${s.target}`;
+  const rolledCount = s.rolled?.length ?? 0;
+  if (s.terminal === "completed") {
+    return `✅ ${head} — done. Rolled ${rolledCount} agent(s): ${(s.rolled ?? []).join(", ") || "none"}.`;
+  }
+  if (s.terminal === "error") {
+    const where = s.failedStep ? ` at ${s.failedStep}${s.failedAgent ? ` (${s.failedAgent} → ${s.got ?? "unreachable"})` : ""}` : "";
+    return `❌ ${head} — STOPPED${where}. ` + `Rolled before stop: ${(s.rolled ?? []).join(", ") || "none"}.`;
+  }
+  const progress = rolledCount > 0 ? ` · ${rolledCount} rolled` : "";
+  return `⏳ ${head} — ${phaseLine(s)}${progress}`;
+}
+
 // src/scheduler/dispatch.ts
 import { createHash as createHash4 } from "node:crypto";
 function collectScheduleEntries(config) {
@@ -23424,7 +23574,7 @@ function readCachedInstallType(bindRoot) {
   } catch {}
   return payload;
 }
-var CONFIG_APPROVAL_TIMEOUT_MS = 10 * 60 * 1000;
+var CONFIG_APPROVAL_TIMEOUT_MS = 60 * 60 * 1000;
 function defaultApprovalId() {
   return randomBytes(4).toString("hex");
 }
@@ -23467,6 +23617,9 @@ class HostdServer {
   auditChainState;
   idempotencyKeys = new Map;
   fleetMutationInFlight = null;
+  get rolloutNarrator() {
+    return this.opts.rolloutNarrator;
+  }
   constructor(opts) {
     this.opts = opts;
   }
@@ -23779,6 +23932,9 @@ class HostdServer {
       case "get_status": {
         const entry = this.statusByRequestId.get(req.args.target_request_id);
         if (!entry) {
+          if (callerAdmin && this.rolloutRowExistsInLog(req.args.target_request_id)) {
+            return null;
+          }
           return `get_status: request_id not found or not visible to caller "${caller.name}"`;
         }
         const ownCall = entry.caller.kind === caller.kind && ("name" in entry.caller && "name" in caller ? entry.caller.name === caller.name : true);
@@ -24530,7 +24686,12 @@ class HostdServer {
     });
   }
   spawnRollout(args, entry) {
-    this.runSwitchroom(args, { SWITCHROOM_HOSTD_CONTEXT: "1" }).then((res) => {
+    const onLine = (line) => {
+      const phase = parseRolloutPhaseLine(line);
+      if (phase)
+        this.onRolloutPhase(entry, phase);
+    };
+    this.runSwitchroom(args, { SWITCHROOM_HOSTD_CONTEXT: "1" }, onLine).then((res) => {
       entry.exit_code = res.exit_code;
       entry.finished_at = Date.now();
       entry.stdout_tail = tail(res.stdout);
@@ -24559,27 +24720,111 @@ class HostdServer {
       delete entry.prior_pin;
     }).finally(() => {
       this.writeTerminalAudit(entry);
+      this.pushRolloutTerminal(entry);
+      try {
+        this.rolloutNarrator?.onTerminal(entry);
+      } catch (e) {
+        process.stderr.write(`hostd: rollout narrator onTerminal threw (non-fatal): ${e.message}
+`);
+      }
       if (this.fleetMutationInFlight && this.fleetMutationInFlight.request_id === entry.request_id) {
         this.fleetMutationInFlight = null;
       }
     });
   }
+  pushRolloutTerminal(entry) {
+    if (!this.opts.rolloutRelay)
+      return;
+    if (entry.caller.kind !== "agent")
+      return;
+    try {
+      const text = renderRolloutStatus({
+        target: entry.pin ?? "",
+        rolled: entry.rolled,
+        terminal: entry.result === "completed" ? "completed" : "error",
+        ...entry.failed_step ? { failedStep: entry.failed_step } : {},
+        ...entry.failed_agent ? { failedAgent: entry.failed_agent } : {},
+        ...entry.got !== undefined ? { got: entry.got } : {}
+      });
+      this.opts.rolloutRelay.postTerminal({
+        requestId: entry.request_id,
+        agentName: entry.caller.name,
+        text
+      });
+    } catch (e) {
+      process.stderr.write(`hostd: rollout terminal push failed (non-fatal): ${e.message}
+`);
+    }
+  }
   handleGetStatus(req, _caller, started) {
     const entry = this.statusByRequestId.get(req.args.target_request_id);
     if (!entry) {
+      const fromLog = this.rolloutStatusFromLog(req.request_id, req.args.target_request_id, started);
+      if (fromLog)
+        return fromLog;
       const legacy = `get_status: internal: entry missing despite gate accept`;
       const built = err("E_INTERNAL", "entry missing despite gate accept").op("get_status").build(req.request_id, Date.now() - started);
       return { ...built, error: legacy };
     }
     return this.statusEntryToResponse(req.request_id, entry);
   }
+  rolloutRowExistsInLog(targetRequestId) {
+    const path2 = this.auditLogPath();
+    if (!existsSync8(path2))
+      return false;
+    try {
+      const raw = readFileSync6(path2, "utf-8");
+      return latestRolloutRowForRequest(raw, targetRequestId) !== null;
+    } catch {
+      return false;
+    }
+  }
+  rolloutStatusFromLog(responseRequestId, targetRequestId, started) {
+    const path2 = this.auditLogPath();
+    if (!existsSync8(path2))
+      return null;
+    let raw;
+    try {
+      raw = readFileSync6(path2, "utf-8");
+    } catch {
+      return null;
+    }
+    const row = latestRolloutRowForRequest(raw, targetRequestId);
+    if (!row)
+      return null;
+    const isTerminal = row.phase === "terminal";
+    const payload = JSON.stringify({
+      rolled: row.rolled ?? [],
+      ...row.phase && !isTerminal ? { phase: row.phase } : {},
+      ...row.n !== undefined ? { n: row.n } : {},
+      ...row.m !== undefined ? { m: row.m } : {},
+      ...row.agent ? { agent: row.agent } : {},
+      ...row.failed_step ? { failedStep: row.failed_step } : {},
+      ...row.failed_agent ? { failedAgent: row.failed_agent } : {},
+      ...row.pin ? { pin: row.pin } : {},
+      ...row.prior_pin ? { prior_pin: row.prior_pin } : {}
+    });
+    return {
+      v: 1,
+      request_id: responseRequestId,
+      result: row.result,
+      exit_code: row.exit_code,
+      duration_ms: Date.now() - started,
+      payload
+    };
+  }
   statusEntryToResponse(request_id, entry) {
-    const rolloutPayload = entry.op === "rollout" && (entry.rolled !== undefined || entry.failed_step !== undefined || entry.failed_agent !== undefined) ? JSON.stringify({
+    const rolloutPayload = entry.op === "rollout" && (entry.rolled !== undefined || entry.failed_step !== undefined || entry.failed_agent !== undefined || entry.current_phase !== undefined) ? JSON.stringify({
       rolled: entry.rolled ?? [],
+      ...entry.current_phase ? { phase: entry.current_phase } : {},
+      ...entry.phase_n !== undefined ? { n: entry.phase_n } : {},
+      ...entry.phase_m !== undefined ? { m: entry.phase_m } : {},
+      ...entry.phase_agent ? { agent: entry.phase_agent } : {},
       ...entry.failed_step ? { failedStep: entry.failed_step } : {},
       ...entry.failed_agent ? { failedAgent: entry.failed_agent } : {},
       ...entry.got !== undefined ? { got: entry.got } : {},
-      ...entry.pin ? { pin: entry.pin } : {}
+      ...entry.pin ? { pin: entry.pin } : {},
+      ...entry.prior_pin ? { prior_pin: entry.prior_pin } : {}
     }) : undefined;
     const updatePayload = entry.op === "update_apply" && (entry.deferred !== undefined || entry.channel !== undefined || entry.pin !== undefined) ? {
       ...entry.deferred !== undefined ? { deferred: entry.deferred } : {},
@@ -24681,7 +24926,36 @@ class HostdServer {
       ...entry.prior_pin ? { prior_pin: entry.prior_pin } : {}
     });
   }
-  runSwitchroom(args, extraEnv) {
+  onRolloutPhase(entry, phase) {
+    entry.current_phase = phase.phase;
+    entry.phase_n = phase.n;
+    entry.phase_m = phase.m;
+    entry.phase_agent = phase.agent;
+    this.writePhaseAudit(entry, phase);
+    try {
+      this.rolloutNarrator?.onPhase(entry, phase);
+    } catch (e) {
+      process.stderr.write(`hostd: rollout narrator onPhase threw (non-fatal): ${e.message}
+`);
+    }
+  }
+  async writePhaseAudit(entry, phase) {
+    await this.appendAuditRow({
+      ts: new Date().toISOString(),
+      op: entry.op,
+      phase: phase.phase,
+      caller: entry.caller.kind === "agent" ? { kind: "agent", name: entry.caller.name } : { kind: "operator" },
+      request_id: entry.request_id,
+      result: "started",
+      exit_code: null,
+      duration_ms: Date.now() - entry.started_at,
+      ...entry.pin ? { pin: entry.pin } : {},
+      ...phase.agent !== undefined ? { agent: phase.agent } : {},
+      ...phase.n !== undefined ? { n: phase.n } : {},
+      ...phase.m !== undefined ? { m: phase.m } : {}
+    });
+  }
+  runSwitchroom(args, extraEnv, onStdoutLine) {
     return new Promise((resolve7, reject) => {
       const bin = this.opts.switchroomBin ?? "switchroom";
       const child = spawn2(bin, args, {
@@ -24690,14 +24964,49 @@ class HostdServer {
       });
       let stdout = "";
       let stderr = "";
+      let lineBuf = "";
+      const drainLines = (flush) => {
+        if (!onStdoutLine)
+          return;
+        let nl;
+        while ((nl = lineBuf.indexOf(`
+`)) !== -1) {
+          const line = lineBuf.slice(0, nl);
+          lineBuf = lineBuf.slice(nl + 1);
+          try {
+            onStdoutLine(line);
+          } catch (e) {
+            process.stderr.write(`hostd: rollout stdout-tap threw (non-fatal): ${e.message}
+`);
+          }
+        }
+        if (flush && lineBuf.length > 0) {
+          const line = lineBuf;
+          lineBuf = "";
+          try {
+            onStdoutLine(line);
+          } catch (e) {
+            process.stderr.write(`hostd: rollout stdout-tap threw (non-fatal): ${e.message}
+`);
+          }
+        }
+      };
       child.stdout.on("data", (d) => {
-        stdout += d.toString("utf8");
+        const s = d.toString("utf8");
+        stdout += s;
+        if (onStdoutLine) {
+          lineBuf += s;
+          drainLines(false);
+        }
       });
       child.stderr.on("data", (d) => {
         stderr += d.toString("utf8");
       });
       child.on("error", (err2) => reject(err2));
-      child.on("close", (code) => resolve7({ exit_code: code ?? -1, stdout, stderr }));
+      child.on("close", (code) => {
+        drainLines(true);
+        resolve7({ exit_code: code ?? -1, stdout, stderr });
+      });
     });
   }
 }
@@ -24929,6 +25238,395 @@ class SocketApprovalGateway {
   }
 }
 
+// src/host-control/rollout-relay.ts
+import { connect as connect2 } from "node:net";
+
+class SocketRolloutRelay {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  postTerminal(notice) {
+    const log = this.opts.log ?? (() => {});
+    let sockPath;
+    try {
+      sockPath = this.opts.resolveGatewaySocket(notice.agentName);
+    } catch (e) {
+      log(`resolveGatewaySocket threw for ${notice.agentName}: ${e.message}`);
+      return;
+    }
+    if (sockPath === null) {
+      log(`no reachable gateway socket for ${notice.agentName}; dropping terminal ping`);
+      return;
+    }
+    try {
+      const client2 = connect2({ path: sockPath });
+      client2.setTimeout(5000);
+      const done = () => {
+        try {
+          client2.destroy();
+        } catch {}
+      };
+      client2.on("connect", () => {
+        try {
+          client2.write(JSON.stringify({
+            type: "rollout_status_post",
+            requestId: notice.requestId,
+            agentName: notice.agentName,
+            text: notice.text
+          }) + `
+`);
+          client2.end();
+        } catch (e) {
+          log(`rollout terminal write failed (requestId=${notice.requestId}): ${e.message}`);
+          done();
+        }
+      });
+      client2.on("timeout", () => {
+        log(`rollout terminal connect timed out (requestId=${notice.requestId})`);
+        done();
+      });
+      client2.on("error", (e) => {
+        log(`rollout terminal socket error (requestId=${notice.requestId}): ${e.message}`);
+        done();
+      });
+      client2.on("close", () => {});
+    } catch (e) {
+      log(`rollout terminal connect threw (requestId=${notice.requestId}): ${e.message}`);
+    }
+  }
+}
+
+// src/host-control/rollout-narration-relay.ts
+import { connect as connect3 } from "node:net";
+var DEFAULT_POST_REPLY_TIMEOUT_MS = 5000;
+
+class SocketRolloutNarrationRelay {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  post(args) {
+    const log = this.opts.log ?? (() => {});
+    let sockPath;
+    try {
+      sockPath = this.opts.resolveGatewaySocket(args.agentName);
+    } catch (e) {
+      log(`narration resolveGatewaySocket threw: ${e.message}`);
+      return Promise.resolve(null);
+    }
+    if (sockPath === null) {
+      log(`narration post: no reachable gateway for ${args.agentName}`);
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve7) => {
+      let settled = false;
+      const finish = (v) => {
+        if (settled)
+          return;
+        settled = true;
+        try {
+          client2.destroy();
+        } catch {}
+        resolve7(v);
+      };
+      let client2;
+      try {
+        client2 = connect3({ path: sockPath });
+      } catch (e) {
+        log(`narration post connect threw: ${e.message}`);
+        resolve7(null);
+        return;
+      }
+      client2.setTimeout(this.opts.postReplyTimeoutMs ?? DEFAULT_POST_REPLY_TIMEOUT_MS);
+      let buffer = "";
+      client2.on("connect", () => {
+        try {
+          client2.write(JSON.stringify({
+            type: "rollout_status_post",
+            requestId: args.requestId,
+            agentName: args.agentName,
+            text: args.text
+          }) + `
+`);
+        } catch (e) {
+          log(`narration post write failed: ${e.message}`);
+          finish(null);
+        }
+      });
+      client2.on("data", (chunk2) => {
+        buffer += chunk2.toString("utf8");
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim())
+            continue;
+          let obj;
+          try {
+            obj = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (obj.type === "rollout_status_posted" && obj.requestId === args.requestId) {
+            if (obj.ok === true && typeof obj.messageId === "number") {
+              finish(obj.messageId);
+            } else {
+              log(`narration post rejected by gateway (requestId=${args.requestId}): ${typeof obj.reason === "string" ? obj.reason : "no message_id"}`);
+              finish(null);
+            }
+            return;
+          }
+        }
+      });
+      client2.on("timeout", () => {
+        log(`narration post reply timed out (requestId=${args.requestId})`);
+        finish(null);
+      });
+      client2.on("error", (e) => {
+        log(`narration post socket error (requestId=${args.requestId}): ${e.message}`);
+        finish(null);
+      });
+      client2.on("close", () => finish(null));
+    });
+  }
+  edit(args) {
+    const log = this.opts.log ?? (() => {});
+    let sockPath;
+    try {
+      sockPath = this.opts.resolveGatewaySocket(args.agentName);
+    } catch (e) {
+      log(`narration edit resolveGatewaySocket threw: ${e.message}`);
+      return;
+    }
+    if (sockPath === null)
+      return;
+    try {
+      const client2 = connect3({ path: sockPath });
+      client2.setTimeout(5000);
+      const done = () => {
+        try {
+          client2.destroy();
+        } catch {}
+      };
+      client2.on("connect", () => {
+        try {
+          client2.write(JSON.stringify({
+            type: "rollout_status_edit",
+            requestId: args.requestId,
+            agentName: args.agentName,
+            messageId: args.messageId,
+            text: args.text
+          }) + `
+`);
+          client2.end();
+        } catch (e) {
+          log(`narration edit write failed: ${e.message}`);
+          done();
+        }
+      });
+      client2.on("timeout", done);
+      client2.on("error", (e) => {
+        log(`narration edit socket error: ${e.message}`);
+        done();
+      });
+      client2.on("close", () => {});
+    } catch (e) {
+      log(`narration edit connect threw: ${e.message}`);
+    }
+  }
+}
+
+// src/host-control/rollout-narrator.ts
+var DEFAULT_DEBOUNCE_MS = 1500;
+var MAX_POST_ATTEMPTS = 2;
+
+class LogTailRolloutNarrator {
+  relay;
+  opts;
+  states = new Map;
+  constructor(relay, opts = {}) {
+    this.relay = relay;
+    this.opts = opts;
+  }
+  static seqFor(phase) {
+    switch (phase.phase) {
+      case "apply":
+        return 0;
+      case "canary-start":
+        return 2 * 1 + 0;
+      case "canary-pass":
+      case "canary-fail":
+        return 2 * 1 + 1;
+      case "persist-pin":
+        return 2 * 1 + 1;
+      case "agent-start":
+        return 2 * (phase.n ?? 1) + 0;
+      case "agent-done":
+        return 2 * (phase.n ?? 1) + 1;
+      case "hostd-web-deferred":
+        return Number.MAX_SAFE_INTEGER - 1;
+      default:
+        return 0;
+    }
+  }
+  onPhase(entry, phase) {
+    try {
+      const st = this.ensureState(entry);
+      if (st.frozen)
+        return;
+      const seq = LogTailRolloutNarrator.seqFor(phase);
+      if (seq < st.lastAppliedSeq)
+        return;
+      st.lastAppliedSeq = seq;
+      st.render = {
+        ...st.render,
+        target: phase.target,
+        phase: phase.phase,
+        ...phase.n !== undefined ? { n: phase.n } : {},
+        ...phase.m !== undefined ? { m: phase.m } : {},
+        ...phase.agent !== undefined ? { agent: phase.agent } : {},
+        rolled: entry.rolled
+      };
+      this.scheduleRenderOrPost(entry.request_id);
+    } catch (e) {
+      this.opts.log?.(`onPhase threw (non-fatal): ${e.message}`);
+    }
+  }
+  onTerminal(entry) {
+    try {
+      const st = this.ensureState(entry);
+      st.render = {
+        target: entry.pin ?? st.render.target,
+        rolled: entry.rolled ?? st.render.rolled,
+        terminal: entry.result === "completed" ? "completed" : "error",
+        ...entry.failed_step ? { failedStep: entry.failed_step } : {},
+        ...entry.failed_agent ? { failedAgent: entry.failed_agent } : {},
+        ...entry.got !== undefined ? { got: entry.got } : {}
+      };
+      st.frozen = true;
+      if (st.timer) {
+        clearTimeout(st.timer);
+        st.timer = null;
+      }
+      this.flush(entry.request_id, true);
+      setTimeout(() => this.states.delete(entry.request_id), 1e4).unref?.();
+    } catch (e) {
+      this.opts.log?.(`onTerminal threw (non-fatal): ${e.message}`);
+    }
+  }
+  ensureState(entry) {
+    let st = this.states.get(entry.request_id);
+    if (!st) {
+      const agentName = entry.caller.kind === "agent" ? entry.caller.name : "";
+      st = {
+        agentName,
+        lastAppliedSeq: -1,
+        messageId: null,
+        posting: false,
+        postAttempts: 0,
+        postFailed: false,
+        render: { target: entry.pin ?? "" },
+        frozen: false,
+        timer: null,
+        pendingEditAfterPost: false
+      };
+      this.states.set(entry.request_id, st);
+    }
+    return st;
+  }
+  scheduleRenderOrPost(requestId) {
+    const st = this.states.get(requestId);
+    if (!st)
+      return;
+    if (st.agentName.length === 0)
+      return;
+    if (st.messageId !== null) {
+      this.scheduleDebouncedEdit(requestId);
+      return;
+    }
+    if (st.posting) {
+      st.pendingEditAfterPost = true;
+      return;
+    }
+    if (st.postFailed)
+      return;
+    this.tryPost(requestId, false);
+  }
+  tryPost(requestId, terminal) {
+    const st = this.states.get(requestId);
+    if (!st)
+      return false;
+    if (st.messageId !== null || st.posting)
+      return false;
+    if (st.postAttempts >= MAX_POST_ATTEMPTS)
+      return false;
+    if (st.postFailed && !terminal)
+      return false;
+    st.posting = true;
+    st.postAttempts += 1;
+    const text = renderRolloutStatus(st.render);
+    this.relay.post({ requestId, agentName: st.agentName, text }).then((mid) => {
+      st.posting = false;
+      if (mid === null) {
+        st.postFailed = true;
+        this.opts.log?.(`rollout narration post returned no message_id (requestId=${requestId}); backing off re-posts`);
+        return;
+      }
+      st.messageId = mid;
+      st.postFailed = false;
+      if (st.pendingEditAfterPost) {
+        st.pendingEditAfterPost = false;
+        this.flush(requestId, false);
+      }
+    }).catch((e) => {
+      st.posting = false;
+      st.postFailed = true;
+      this.opts.log?.(`rollout narration post failed (non-fatal): ${e.message}`);
+    });
+    return true;
+  }
+  scheduleDebouncedEdit(requestId) {
+    const st = this.states.get(requestId);
+    if (!st)
+      return;
+    if (st.timer)
+      return;
+    const ms = this.opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    st.timer = setTimeout(() => {
+      st.timer = null;
+      this.flush(requestId, true);
+    }, ms);
+    st.timer.unref?.();
+  }
+  flush(requestId, immediate) {
+    const st = this.states.get(requestId);
+    if (!st)
+      return;
+    if (st.agentName.length === 0)
+      return;
+    if (!immediate) {
+      this.scheduleDebouncedEdit(requestId);
+      return;
+    }
+    if (st.messageId === null) {
+      if (st.posting) {
+        st.pendingEditAfterPost = true;
+        return;
+      }
+      this.tryPost(requestId, true);
+      return;
+    }
+    const text = renderRolloutStatus(st.render);
+    this.relay.edit({
+      requestId,
+      agentName: st.agentName,
+      messageId: st.messageId,
+      text
+    });
+  }
+}
+
 // src/host-control/release-watcher.ts
 class ReleaseWatcher {
   opts;
@@ -25194,14 +25892,26 @@ async function main() {
     process.exit(2);
   }
   const agentsDir = process.env.SWITCHROOM_AGENTS_DIR ?? join6(homedir4(), ".switchroom", "agents");
+  const resolveGatewaySocket = (agentName) => {
+    const sock = resolve7(agentsDir, agentName, "telegram", "gateway.sock");
+    return existsSync9(sock) ? sock : null;
+  };
   const approvalGateway = new SocketApprovalGateway({
-    resolveGatewaySocket: (agentName) => {
-      const sock = resolve7(agentsDir, agentName, "telegram", "gateway.sock");
-      return existsSync9(sock) ? sock : null;
-    },
+    resolveGatewaySocket,
     log: (m) => process.stderr.write(`hostd: approval-gateway — ${m}
 `)
   });
+  const rolloutRelay = new SocketRolloutRelay({
+    resolveGatewaySocket,
+    log: (m) => process.stderr.write(`hostd: rollout-relay — ${m}
+`)
+  });
+  const rolloutNarrator = new LogTailRolloutNarrator(new SocketRolloutNarrationRelay({
+    resolveGatewaySocket,
+    log: (m) => process.stderr.write(`hostd: rollout-narration — ${m}
+`)
+  }), { log: (m) => process.stderr.write(`hostd: rollout-narration — ${m}
+`) });
   const server = new HostdServer({
     homeDir: homedir4(),
     agentUids,
@@ -25216,7 +25926,9 @@ async function main() {
         }
       } : {}
     },
-    approvalGateway
+    approvalGateway,
+    rolloutRelay,
+    rolloutNarrator
   });
   await server.start();
   const paths = server.getBoundPaths();