switchroom 0.19.17 → 0.19.18

package/dist/host-control/main.js

@@ -7598,8 +7598,8 @@ var require_base = __commonJS((exports) => {
   var _logger = require_logger();
   var _logger2 = _interopRequireDefault(_logger);
   var _internalProtoAccess = require_proto_access();
-  var VERSION = "4.7.9";
-  exports.VERSION = VERSION;
+  var VERSION2 = "4.7.9";
+  exports.VERSION = VERSION2;
   var COMPILER_REVISION = 8;
   exports.COMPILER_REVISION = COMPILER_REVISION;
   var LAST_COMPATIBLE_COMPILER_REVISION = 7;
@@ -18744,7 +18744,7 @@ var AgentMemorySchema = exports_external.object({
   recall: exports_external.object({
     max_memories: exports_external.number().int().min(0).optional().describe("Cap on the number of memories injected into the prompt by " + "auto-recall, regardless of token budget. Plugin default is 12. " + "0 disables the cap (all memories Hindsight returns are injected)."),
     cache_ttl_secs: exports_external.number().int().min(0).optional().describe("Per-session recall cache TTL in seconds. When > 0, identical " + "(prompt, bank) within the same session reuse the cached recall " + "result instead of round-tripping to Hindsight. 0 disables. " + "Default is 600 (10 min) for switchroom-managed agents."),
-    min_overlap: exports_external.number().min(0).max(1).optional().describe("Minimum Jaccard token overlap [0.0–1.0] between the user " + "prompt and a memory's text for the memory to be injected. " + "Drops low-relevance matches before the count cap so weak hits " + "don't fill the slot on real queries. 0.0 disables (default — " + "current behaviour). Try 0.10–0.20 to start; observe the " + "`overlap_dropped` field via `switchroom memory recall-log`."),
+    min_overlap: exports_external.number().min(0).max(1).optional().describe("Minimum containment token overlap [0.0–1.0] between the user " + "prompt and a memory's text for the memory to be injected. " + "A cheap FLOOR that removes candidates with (near-)zero lexical " + "relationship to the prompt — NOT a precision control: at the " + "recommended 0.10 the gate is near-passthrough, and the " + "effective precision control is the engine rerank plus the " + "max_memories head-slice. 0.0 disables (default — current " + "behaviour). Use 0.10; values at or above 0.20 measurably " + "starve recall — on production replay 0.20 leaves ~41.9% of " + "turns with NO memories at all, re-creating the bug #3541 " + "fixed. Observe the `overlap_dropped` field via " + "`switchroom memory recall-log`."),
     types: exports_external.array(exports_external.string()).optional().describe("Hindsight fact types to recall. Switchroom default is " + '["world", "experience", "observation"] — the synthesized ' + "`observation` tier is on by default. Set to " + '["world", "experience"] to opt out of observation-backed ' + "recall for this agent (or fleet-wide under defaults)."),
     additional_banks: exports_external.array(exports_external.string()).optional().describe("Extra Hindsight banks to recall from on every turn, merged into " + "the agent's own bank results — e.g. a shared operator/household " + "profile bank authored via `switchroom memory profile`. Each is " + "recalled with an 8s timeout and is non-fatal on failure. Stays " + "within the single tenant: all banks are the operator's data, in " + "the operator's Hindsight instance (see the `single-tenant` " + "invariant). Defaults to [] (no extra banks)."),
     sender_banks: exports_external.record(exports_external.string(), exports_external.string()).optional().describe("Per-speaker recall routing: a map of Telegram sender → extra " + "recall bank. When a message arrives, the agent also recalls the " + "speaker's bank (matched by Telegram username — a leading @ is " + "optional — or numeric user_id), merged " + "into its own results — so each trusted user gets their own " + "profile context. Additive recall scoping within the single " + "tenant: never an access boundary (who may drive an agent stays " + "the per-agent user assignment in `access.allowFrom`). Author the " + "banks via `switchroom memory profile`."),
@@ -19056,9 +19056,16 @@ var ReactionDispatchSchema = exports_external.object({
   enabled: exports_external.boolean().optional().describe("Master switch for the reaction-dispatch path. Default false — " + "with no reaction_dispatch block, reactions are persisted (and may " + "feed the `reactions` feedback path) but are NEVER dispatched as " + "event-driven inbound turns."),
   emojis: exports_external.array(exports_external.string()).optional().describe('Emoji allowlist that triggers a `<channel event="reaction">` ' + "inbound turn when reacted to any message. Default [] (nothing " + "fires). Cascade mode: REPLACE (not union) — a layer's list " + "replaces lower layers entirely so an operator can narrow per-agent.")
 }).optional();
-var ReleaseBlock = exports_external.object({
+var releaseBlockFields = {
   channel: exports_external.enum(["dev", "rc", "latest"]).optional(),
   pin: exports_external.string().regex(/^(sha-[0-9a-f]{7,40}|v\d+\.\d+\.\d+)$/).optional()
+};
+var ReleaseBlock = exports_external.object(releaseBlockFields).strict().refine((r) => !(r.channel && r.pin), {
+  message: "release.channel and release.pin are mutually exclusive"
+});
+var RootReleaseBlock = exports_external.object({
+  ...releaseBlockFields,
+  auto_update: exports_external.boolean().optional().describe("Opt-in unattended fleet auto-update (KEN-131). When true, hostd's " + "release watcher polls the published release version and, on a new " + "release, drives the EXISTING staggered canary rollout " + "(`switchroom rollout --pin vX.Y.Z`) unattended: canary-first, " + "per-agent version assert, durable pin persisted only after the " + "canary is green, abort + operator alert card on canary failure, " + "and compose rollback on a failed apply. Default false — with it " + "unset/false, behaviour is unchanged.")
 }).strict().refine((r) => !(r.channel && r.pin), {
   message: "release.channel and release.pin are mutually exclusive"
 });
@@ -19302,6 +19309,7 @@ var AutoReleaseCheckSchema = exports_external.object({
   enabled: exports_external.boolean().default(false).describe("When true, hostd polls the remote release tag every " + "`interval_minutes` and applies + restarts the fleet when a new " + "release is detected. Default false — opt-in."),
   interval_minutes: exports_external.number().int().min(5).max(1440).default(5).describe("Poll interval in minutes. Floor of 5m matches the agent-config " + "cron rate limit; ceiling of 1440m (24h) is a sanity cap."),
   apply_on_detect: exports_external.boolean().default(true).describe("When false, hostd logs `release_detected` but does NOT call " + "update_apply / restart all. Useful for dogfooding the detector " + "without rolling the fleet."),
+  notify_on_detect: exports_external.boolean().default(false).describe("KEN-129 — operator-in-the-loop update prompt. Only consulted " + "when apply_on_detect is false (auto-apply supersedes notify): " + "a newly detected release posts ONE operator approval card " + "('fleet is behind — tap to apply') via an admin agent's " + "gateway; Approve runs hostd's update_apply path (fleet-" + "mutation-locked, durable status rows, get_status-pollable). " + "Dedup on release id: the last-notified id persists in " + "~/.switchroom/release-notify-state.json, so a card that " + "reached the operator is never re-posted for the same release."),
   image_ref: exports_external.string().default("ghcr.io/switchroom/switchroom-agent:latest").describe("Image reference whose remote digest is compared to the local " + "image digest. Defaults to the agent image's :latest tag, which " + "is the canonical signal that a release has been promoted.")
 });
 var HostControlConfigSchema = exports_external.object({
@@ -19344,7 +19352,7 @@ var SwitchroomConfigSchema = exports_external.object({
     timezone: exports_external.string().regex(TIMEZONE_REGEX, "timezone must be an IANA zone name like 'Australia/Melbourne' or 'UTC'").optional().describe("Global default IANA timezone applied to every agent unless the " + "agent (or its profile) declares its own. See the per-agent " + "timezone field for the full cascade and auto-detection fallback.")
   }),
   telegram: TelegramConfigSchema,
-  release: ReleaseBlock.optional().describe("Fleet-wide default release-channel pin / pointer for the update " + "flow. Either `channel` (dev|rc|latest) or `pin` (sha-<hex>|v<semver>) " + "— mutually exclusive. Per-agent `release` REPLACES this entirely."),
+  release: RootReleaseBlock.optional().describe("Fleet-wide default release-channel pin / pointer for the update " + "flow. Either `channel` (dev|rc|latest) or `pin` (sha-<hex>|v<semver>) " + "— mutually exclusive. Per-agent `release` REPLACES this entirely " + "(except `auto_update`, which is root-only — a fleet property read by " + "hostd's release watcher, never per-agent)."),
   memory: MemoryBackendConfigSchema.optional(),
   hindsight: HindsightConfigSchema.optional().describe("Fleet-singleton Hindsight (memory backend) configuration. Currently " + "just the LLM knob (provider + model) used for retain/reflect/" + "consolidation. Both fields optional; when unset the container falls " + "back to provider=claude-code + the hard-coded HINDSIGHT_DEFAULT_MODEL " + "so nothing changes for operators who don't set it. Read at container " + "launch by startHindsight() (src/setup/hindsight.ts) — takes effect on " + "the next `switchroom apply` / `memory setup --recreate`."),
   vault: VaultConfigSchema.optional(),
@@ -20669,6 +20677,9 @@ function allocateAgentUid(name) {
   return AGENT_UID_MIN + u32 % range;
 }
 
+// src/build-info.ts
+var VERSION = "0.19.18";
+
 // src/cli/agent-config.ts
 import { join as join2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
@@ -20732,7 +20743,23 @@ var HINDSIGHT_HEALTHCHECK_PY = 'import urllib.request,sys; sys.exit(0 if urllib.
 var HINDSIGHT_HEALTHCHECK_CMD = `python3 -c '${HINDSIGHT_HEALTHCHECK_PY}'`;
 
 // src/memory/hindsight.ts
-var DEFAULT_RETAIN_MISSION = "Extract user preferences, ongoing projects, recurring commitments, " + "important context, and durable facts that should help across future " + "conversations. Skip one-off chatter and temporary task noise, " + "including in-flight workflow/process narration (a sub-task started, " + "paused, or is still running) — only retain the outcome once a task " + "actually completes or a decision is made.";
+var DEFAULT_RETAIN_MISSION = "Extract durable facts that will still be true and useful weeks from now: " + "user preferences and standing rules, ongoing projects and recurring " + "commitments, technical and architectural decisions with their rationale, " + "and people/tool relationships. A preference revealed by a request is " + "durable — record the preference (what the user likes, wants, or always " + `does), not the request itself.
+
+` + `NEVER extract:
+` + "- Agent tool-use traces or narration of what the assistant did (e.g. " + `"the assistant used X to query Y", "ran a search", "sent the message").
+` + "- In-flight workflow/process narration (a sub-task started, paused, or is " + "still running) — retain the outcome only once the task completes or a " + `decision is made.
+` + `- Operation, request, batch or session IDs, UUIDs, hashes, or error codes.
+` + "- Hindsight's own errors, retries, backlogs, or internal state — the " + `memory system's self-reports are not memories.
+` + `- Restatements of the user's current request or the task in progress.
+` + "- Transient state (unread counts, build status, what is running right now) " + "unless the fact is explicitly dated, in which case record it as a dated " + `observation.
+` + `- Greetings, acknowledgements, and routine operational chatter.
+
+` + "If a candidate fact matches an exclusion, drop it rather than rewording " + "it. If nothing durable remains, return an empty facts list.";
+var SUPERSEDED_RETAIN_MISSIONS = [
+  "Extract technical decisions, architectural choices, user preferences, project context, and people/tool relationships. Ignore routine greetings and transient operational details.",
+  "Extract user preferences, ongoing projects, recurring commitments, " + "important context, and durable facts that should help across future " + "conversations. Skip one-off chatter and temporary task noise.",
+  "Extract user preferences, ongoing projects, recurring commitments, " + "important context, and durable facts that should help across future " + "conversations. Skip one-off chatter and temporary task noise, " + "including in-flight workflow/process narration (a sub-task started, " + "paused, or is still running) — only retain the outcome once a task " + "actually completes or a decision is made."
+];
 var PROFILE_MEMORY_DEFAULTS = {
   "health-coach": {
     disposition: { skepticism: 2, literalism: 2, empathy: 5 },
@@ -21202,6 +21229,7 @@ var materializedDirs = new Set;
 // src/agents/scaffold.ts
 var REPO_ROOT = resolve5(import.meta.dirname, "../..");
 var CLAUDE_MD_YOURS_PLACEHOLDER = "This space is yours. Add per-agent rules, exceptions, or context the " + "Switchroom template doesn't capture. Everything above the marker line is " + "regenerated on every apply; this section is preserved.";
+var pendingBankOps = new Set;
 var SWITCHROOM_OWNED_SETTINGS_KEYS = new Set([
   "permissions",
   "mcpServers",
@@ -26662,11 +26690,6 @@ init_atomic();
 // src/cli/resolve-version.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
 import { dirname as dirname5, join as join7 } from "node:path";
-
-// src/build-info.ts
-var VERSION = "0.19.17";
-
-// src/cli/resolve-version.ts
 function readPackageVersion() {
   let dir = import.meta.dirname;
   for (let i = 0;i < 12 && dir && dir !== "/"; i++) {
@@ -27934,6 +27957,11 @@ var STATUS_RETENTION_MS = 10 * 60 * 1000;
 var STATUS_MAX_ENTRIES = 256;
 var TAIL_BYTES = 4096;
 var ORPHAN_RECONCILE_AGE_MS = 15 * 60 * 1000;
+var AUTO_ROLLOUT_REQUEST_PREFIX = "auto-rollout-";
+function isAutoRolloutRequestId(requestId) {
+  return requestId.startsWith(AUTO_ROLLOUT_REQUEST_PREFIX);
+}
+var AUTO_ROLLOUT_LATCH_FILENAME = "auto-rollout-latch.json";
 
 class HostdServer {
   opts;
@@ -27943,6 +27971,41 @@ class HostdServer {
   auditChainState;
   idempotencyKeys = new Map;
   fleetMutationInFlight = null;
+  lastAutoRolloutFailedPin = null;
+  autoRolloutLatchPath() {
+    return join10(this.hostdDirPath(), AUTO_ROLLOUT_LATCH_FILENAME);
+  }
+  readAutoRolloutLatch() {
+    try {
+      const raw = readFileSync9(this.autoRolloutLatchPath(), "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && parsed.v === 1 && typeof parsed.pin === "string" && parsed.pin.length > 0 && (parsed.outcome === "attempting" || parsed.outcome === "failed")) {
+        return parsed;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  autoRolloutLatchedPin() {
+    return this.readAutoRolloutLatch()?.pin ?? this.lastAutoRolloutFailedPin;
+  }
+  writeAutoRolloutLatch(latch) {
+    try {
+      mkdirSync4(this.hostdDirPath(), { recursive: true });
+      writeFileSync5(this.autoRolloutLatchPath(), JSON.stringify(latch, null, 2), {
+        mode: 384
+      });
+    } catch (e) {
+      process.stderr.write(`hostd: auto-rollout latch write failed (falling back to in-memory ` + `latch for this process lifetime): ${e.message}
+`);
+    }
+  }
+  clearAutoRolloutLatch() {
+    try {
+      unlinkSync2(this.autoRolloutLatchPath());
+    } catch {}
+  }
   get rolloutNarrator() {
     return this.opts.rolloutNarrator;
   }
@@ -28459,6 +28522,23 @@ class HostdServer {
       return null;
     return deniedResponse(request_id, `refused: this switchroom-hostd image is missing apply-time ` + `assets [${missing.join(", ")}]. hostd's in-container ` + `\`switchroom apply\` cannot scaffold agents without them and ` + `would pull images then strand the fleet on the old image ` + `(the klanker incident). Nothing was pulled or changed. Fix: ` + `rebuild/refresh the hostd image — \`switchroom update\` ` + `(refreshes hostd) or \`switchroom hostd install\` on the ` + `host; meanwhile run \`switchroom update\` host-side.`, Date.now() - started);
   }
+  isFleetMutationLocked() {
+    return this.fleetMutationInFlight !== null;
+  }
+  startOperatorApprovedUpdateApply(requestId) {
+    const req = {
+      v: 1,
+      request_id: requestId,
+      op: "update_apply"
+    };
+    const caller = { kind: "operator" };
+    const resp = this.handleUpdateApply(req, caller, Date.now());
+    this.writeAudit({ caller, req, resp }).catch((err2) => {
+      process.stderr.write(`hostd: audit write failed for operator-approved update_apply ` + `(request_id=${requestId}): ${err2.message}
+`);
+    });
+    return resp;
+  }
   handleUpdateApply(req, caller, started) {
     const denied = this.checkFleetMutationLock(req.op, req.request_id, started);
     if (denied)
@@ -28590,6 +28670,68 @@ class HostdServer {
       duration_ms: Date.now() - started
     };
   }
+  async startAutoRollout(pin) {
+    const started = Date.now();
+    const request_id = `${AUTO_ROLLOUT_REQUEST_PREFIX}${started}`;
+    const diskLatch = this.readAutoRolloutLatch();
+    if (this.lastAutoRolloutFailedPin === pin || diskLatch?.pin === pin) {
+      const why = diskLatch?.pin === pin && diskLatch.outcome === "attempting" ? `a previous unattended roll to ${pin} did not complete (hostd ` + `restarted or crashed mid-roll — the fleet state is unverified)` : `a previous unattended roll to ${pin} FAILED`;
+      return {
+        started: false,
+        reason: `${why} — refusing to retry unattended (the latch is durable ` + `across hostd restarts; fix the cause, then roll manually via ` + `\`switchroom rollout --pin ${pin}\`; a newer release supersedes ` + `the latch)`
+      };
+    }
+    const inFlight = this.fleetMutationInFlight;
+    if (inFlight) {
+      return {
+        started: false,
+        reason: `fleet-mutation lock held by ${inFlight.op} (request_id ` + `"${inFlight.request_id}") — will re-check next tick`
+      };
+    }
+    if (diskLatch && diskLatch.pin !== pin)
+      this.clearAutoRolloutLatch();
+    const caller = { kind: "operator" };
+    if (needsSelfBump(this.opts.selfVersion ?? SWITCHROOM_VERSION, pin)) {
+      const req = {
+        v: 1,
+        request_id,
+        op: "rollout",
+        args: { pin }
+      };
+      this.writeAutoRolloutLatch({
+        v: 1,
+        pin,
+        request_id,
+        outcome: "attempting",
+        at: new Date().toISOString()
+      });
+      const resp = await this.beginSelfBump(req, caller, started);
+      if (resp.result !== "started") {
+        this.clearAutoRolloutLatch();
+        return {
+          started: false,
+          reason: resp.error ?? `self-bump refused (result=${resp.result})`
+        };
+      }
+      return { started: true, request_id };
+    }
+    const assetDenied = this.applyAssetPreflight(request_id, started);
+    if (assetDenied) {
+      return {
+        started: false,
+        reason: assetDenied.error ?? "apply-asset preflight refused"
+      };
+    }
+    this.writeAutoRolloutLatch({
+      v: 1,
+      pin,
+      request_id,
+      outcome: "attempting",
+      at: new Date().toISOString()
+    });
+    this.launchRollout({ pin }, request_id, caller, started);
+    return { started: true, request_id };
+  }
   launchRollout(args, request_id, caller, started) {
     const argv = ["rollout", "--pin", args.pin];
     if (args.agents && args.agents.length > 0) {
@@ -28813,6 +28955,17 @@ class HostdServer {
       this.recordStatus(entry2);
       process.stderr.write(`hostd: self-bump resume failed: ${why}
 `);
+      if (isAutoRolloutRequestId(marker.request_id)) {
+        this.lastAutoRolloutFailedPin = marker.pin;
+        this.writeAutoRolloutLatch({
+          v: 1,
+          pin: marker.pin,
+          request_id: marker.request_id,
+          outcome: "failed",
+          at: new Date().toISOString(),
+          reason: "self-bump"
+        });
+      }
       await this.writeTerminalAudit(entry2);
       this.pushRolloutTerminal(entry2);
     };
@@ -29395,6 +29548,7 @@ ${output.recovery.stderr}` : "";
     });
   }
   spawnRollout(args, entry) {
+    const priorPinAtStart = entry.prior_pin;
     const onLine = (line) => {
       const phase = parseRolloutPhaseLine(line);
       if (phase)
@@ -29429,6 +29583,24 @@ ${output.recovery.stderr}` : "";
       delete entry.prior_pin;
     }).finally(() => {
       this.writeTerminalAudit(entry);
+      if (isAutoRolloutRequestId(entry.request_id) && entry.result !== "completed") {
+        this.lastAutoRolloutFailedPin = entry.pin ?? null;
+        if (entry.pin) {
+          this.writeAutoRolloutLatch({
+            v: 1,
+            pin: entry.pin,
+            request_id: entry.request_id,
+            outcome: "failed",
+            at: new Date().toISOString(),
+            ...entry.failed_step ? { reason: entry.failed_step } : {}
+          });
+        }
+        this.finishFailedAutoRollout(entry, priorPinAtStart);
+        return;
+      }
+      if (isAutoRolloutRequestId(entry.request_id)) {
+        this.clearAutoRolloutLatch();
+      }
       this.pushRolloutTerminal(entry);
       try {
         this.rolloutNarrator?.onTerminal(entry);
@@ -29441,10 +29613,60 @@ ${output.recovery.stderr}` : "";
       }
     });
   }
-  pushRolloutTerminal(entry) {
+  async finishFailedAutoRollout(entry, priorPin) {
+    const notes = [
+      `Unattended auto-update roll to ${entry.pin ?? "?"} FAILED at ` + `${entry.failed_step ?? "unknown step"}` + `${entry.failed_agent ? ` (agent ${entry.failed_agent})` : ""}. ` + `Unattended retries of this version are disabled; fix the cause, ` + `then roll manually (\`switchroom rollout --pin ${entry.pin ?? "vX.Y.Z"}\`).`
+    ];
+    try {
+      notes.push(...await this.recoverFailedAutoRollout(entry, priorPin));
+    } catch (e) {
+      notes.push(`Automatic rollback THREW: ${e.message} — verify compose/` + `canary state host-side.`);
+    } finally {
+      this.pushRolloutTerminal(entry, notes);
+      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;
+      }
+    }
+  }
+  async recoverFailedAutoRollout(entry, priorPin) {
+    const notes = [];
+    const rolledCount = (entry.rolled ?? []).length;
+    const beforeAnyAgent = entry.failed_step === "apply" || entry.failed_step === "restart-agent" && rolledCount === 0;
+    if (!beforeAnyAgent) {
+      notes.push(rolledCount > 0 ? `No automatic rollback: ${rolledCount} agent(s) already confirmed on ` + `${entry.pin ?? "the target"} past a green canary ` + `(${(entry.rolled ?? []).join(", ")}). The fleet is mixed — ` + `finish the roll or roll back manually.` : `No automatic rollback: the roll stopped at ` + `${entry.failed_step ?? "an unknown step"} before any change ` + `landed — nothing to revert. Verify host-side if unsure.`);
+      return notes;
+    }
+    if (!priorPin) {
+      notes.push(`No automatic rollback: no prior version-assertable release.pin was ` + `recorded before this roll. Verify compose host-side ` + `(\`switchroom apply\`).`);
+      return notes;
+    }
+    const applyRes = await this.runSwitchroom(["apply", "--pin", priorPin, "--compose-only", "--non-interactive"], { SWITCHROOM_HOSTD_CONTEXT: "1" });
+    notes.push(applyRes.exit_code === 0 ? `Rollback: compose restored to ${priorPin}.` : `Rollback FAILED: compose restore to ${priorPin} exited ` + `${applyRes.exit_code} — run \`switchroom apply\` host-side ` + `(${tail(applyRes.stderr).trim().slice(-300) || "no stderr"}).`);
+    if (entry.failed_step === "restart-agent" && entry.failed_agent) {
+      const restartRes = await this.runSwitchroom([
+        "agent",
+        "restart",
+        entry.failed_agent,
+        "--wait",
+        "--force",
+        "--pin",
+        priorPin
+      ], { SWITCHROOM_HOSTD_CONTEXT: "1" });
+      notes.push(restartRes.exit_code === 0 ? `Rollback: canary ${entry.failed_agent} restarted back on ${priorPin}.` : `Rollback FAILED: canary ${entry.failed_agent} did not restart ` + `cleanly on ${priorPin} (exit ${restartRes.exit_code}) — restart ` + `it manually.`);
+    }
+    return notes;
+  }
+  pushRolloutTerminal(entry, extraNotes) {
     if (!this.opts.rolloutRelay)
       return;
-    if (entry.caller.kind !== "agent")
+    const relayAgent = entry.caller.kind === "agent" ? entry.caller.name : isAutoRolloutRequestId(entry.request_id) ? this.firstAdminAgentName() : null;
+    if (relayAgent === null)
       return;
     try {
       const text = renderRolloutStatus({
@@ -29460,14 +29682,26 @@ ${output.recovery.stderr}` : "";
       });
       this.opts.rolloutRelay.postTerminal({
         requestId: entry.request_id,
-        agentName: entry.caller.name,
-        text
+        agentName: relayAgent,
+        text: extraNotes && extraNotes.length > 0 ? text + `
+
+` + extraNotes.map((n) => `- ${n}`).join(`
+`) : text
       });
     } catch (e) {
       process.stderr.write(`hostd: rollout terminal push failed (non-fatal): ${e.message}
 `);
     }
   }
+  firstAdminAgentName() {
+    const agents = this.opts.config.agents ?? {};
+    for (const name of Object.keys(agents).sort()) {
+      const a = agents[name];
+      if (a?.admin === true || a?.root === true)
+        return name;
+    }
+    return null;
+  }
   handleGetStatus(req, _caller, started) {
     const entry = this.statusByRequestId.get(req.args.target_request_id);
     if (!entry) {
@@ -29949,7 +30183,8 @@ class SocketApprovalGateway {
             agentName: req.agentName,
             reason: req.reason,
             unifiedDiff: req.unifiedDiff,
-            timeoutMs: req.timeoutMs
+            timeoutMs: req.timeoutMs,
+            ...req.title ? { title: req.title } : {}
           }) + `
 `);
         } catch (err2) {
@@ -30537,8 +30772,16 @@ class ReleaseWatcher {
         ...check.version ? { version: check.version } : {}
       });
       this.log(`release detected${check.version ? `: ${check.version}` : ""}` + (this.opts.applyOnDetect ? ", auto-applying" : " (apply_on_detect=false; not rolling)"));
-      if (!this.opts.applyOnDetect)
+      if (!this.opts.applyOnDetect) {
+        if (this.opts.notifyFn) {
+          try {
+            await this.opts.notifyFn(check.version ?? "");
+          } catch (err2) {
+            this.log(`notify_failed: ${errMsg(err2)}`);
+          }
+        }
         return;
+      }
       const applyStarted = this.now();
       this.emit({
         at: applyStarted,
@@ -30546,7 +30789,7 @@ class ReleaseWatcher {
         ...check.version ? { version: check.version } : {}
       });
       try {
-        await this.opts.applyFn();
+        await this.opts.applyFn(check.version);
       } catch (err2) {
         this.emit({
           at: this.now(),
@@ -30718,6 +30961,13 @@ function makeApply(switchroomBin) {
     }
   };
 }
+function makeUpdatePlan(switchroomBin) {
+  return async () => {
+    const r = await run(switchroomBin, ["update", "--check"], 2 * 60000);
+    const out = r.stdout.trim();
+    return out.length > 4000 ? out.slice(-4000) : out;
+  };
+}
 function makeRestart(switchroomBin) {
   return async () => {
     const r = await run(switchroomBin, ["restart", "all"], 5 * 60000);
@@ -30727,6 +30977,248 @@ function makeRestart(switchroomBin) {
   };
 }
 
+// src/host-control/update-notifier.ts
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync10, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { dirname as dirname8 } from "node:path";
+var FINALIZE_DETAIL_MAX = 450;
+var DEFAULT_REPOST_SUPPRESS_MS = 60 * 60000;
+
+class UpdateNotifier {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async notifyIfNew(version2) {
+    try {
+      return await this.run(version2);
+    } catch (err2) {
+      this.log(`notify failed: ${errMsg2(err2)}`);
+      return "dispatch_failed";
+    }
+  }
+  async run(version2) {
+    if (version2 === "") {
+      this.log("release detected but no release id was provided — skipping card");
+      return "skipped_no_version";
+    }
+    const state = this.readState();
+    if (state?.last_notified_version === version2) {
+      return "deduped";
+    }
+    const suppressMs = this.opts.repostSuppressMs ?? DEFAULT_REPOST_SUPPRESS_MS;
+    if (state?.pending_version === version2 && typeof state.pending_posted_at === "number" && this.now() - state.pending_posted_at < suppressMs) {
+      this.log(`release ${short(version2)} has a possibly-live card from before a restart — suppressing re-post`);
+      return "pending_recent";
+    }
+    if (this.opts.isFleetMutationInFlight()) {
+      this.log(`release ${short(version2)} detected but a fleet mutation is in flight — not posting a card this tick`);
+      return "locked";
+    }
+    let plan = "";
+    if (this.opts.planFn) {
+      try {
+        plan = await this.opts.planFn();
+      } catch (err2) {
+        this.log(`update --check plan probe failed: ${errMsg2(err2)}`);
+      }
+    }
+    if (this.opts.isFleetMutationInFlight()) {
+      this.log(`fleet mutation started during the plan probe for ${short(version2)} — not posting a card this tick`);
+      return "locked";
+    }
+    const requestId = this.opts.mintRequestId ? this.opts.mintRequestId() : `relnotify-${randomBytes3(4).toString("hex")}`;
+    this.log(`posting update approval card for release ${short(version2)} (requestId=${requestId})`);
+    this.writeState({
+      ...this.carryNotified(state),
+      pending_version: version2,
+      pending_posted_at: this.now()
+    });
+    let res;
+    try {
+      res = await this.opts.requestApproval({ requestId, version: version2, plan });
+    } catch (err2) {
+      res = {
+        verdict: "deny",
+        reason: `requestApproval threw: ${errMsg2(err2)}`,
+        denySource: "dispatch_failure",
+        finalize: async () => {}
+      };
+    }
+    if (res.verdict === "deny" && res.denySource === "dispatch_failure") {
+      this.log(`update approval card dispatch failed (${res.reason ?? "unknown"}) — will retry next tick`);
+      this.writeState(this.carryNotified(state));
+      return "dispatch_failed";
+    }
+    this.writeState({
+      last_notified_version: version2,
+      notified_at: this.now()
+    });
+    if (res.verdict === "deny") {
+      this.log(`operator denied update for release ${short(version2)}`);
+      return "denied";
+    }
+    if (res.verdict === "timeout") {
+      this.log(`update approval card expired for release ${short(version2)}`);
+      return "timed_out";
+    }
+    let start;
+    try {
+      start = this.opts.startApply(requestId);
+    } catch (err2) {
+      start = { result: "error", error: errMsg2(err2) };
+    }
+    if (start.result === "started") {
+      this.log(`update_apply started (requestId=${requestId})`);
+      await res.finalize({
+        outcome: "applied",
+        detail: clipDetail(`switchroom update started (request_id ${requestId}) — track progress via get_status / the rollout narration message.`)
+      });
+      return "apply_started";
+    }
+    const why = start.error ?? `unexpected result "${start.result}"`;
+    this.log(`update_apply refused after approval: ${why}`);
+    await res.finalize({
+      outcome: "reconcile_failed_rolled_back",
+      detail: clipDetail(`update did not start: ${why}`)
+    });
+    return "apply_refused";
+  }
+  carryNotified(state) {
+    return state?.last_notified_version !== undefined ? {
+      last_notified_version: state.last_notified_version,
+      notified_at: state.notified_at ?? 0
+    } : {};
+  }
+  now() {
+    return this.opts.now ? this.opts.now() : Date.now();
+  }
+  readState() {
+    try {
+      const raw = readFileSync10(this.opts.statePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed === null || typeof parsed !== "object")
+        return null;
+      const out = {};
+      if (typeof parsed.last_notified_version === "string") {
+        out.last_notified_version = parsed.last_notified_version;
+        out.notified_at = typeof parsed.notified_at === "number" ? parsed.notified_at : 0;
+      }
+      if (typeof parsed.pending_version === "string") {
+        out.pending_version = parsed.pending_version;
+        out.pending_posted_at = typeof parsed.pending_posted_at === "number" ? parsed.pending_posted_at : 0;
+      }
+      return Object.keys(out).length > 0 ? out : null;
+    } catch {
+      return null;
+    }
+  }
+  writeState(state) {
+    try {
+      mkdirSync5(dirname8(this.opts.statePath), { recursive: true });
+      const tmp = `${this.opts.statePath}.tmp`;
+      writeFileSync6(tmp, JSON.stringify(state) + `
+`, "utf8");
+      renameSync4(tmp, this.opts.statePath);
+    } catch (err2) {
+      this.log(`failed to persist notify state: ${errMsg2(err2)}`);
+    }
+  }
+  log(m) {
+    if (this.opts.log)
+      this.opts.log(`update-notifier: ${m}`);
+  }
+}
+function clipDetail(detail) {
+  return detail.length > FINALIZE_DETAIL_MAX ? detail.slice(0, FINALIZE_DETAIL_MAX - 1) + "…" : detail;
+}
+function short(version2) {
+  const hex = version2.startsWith("sha256:") ? version2.slice(7) : version2;
+  return hex.length > 12 ? hex.slice(0, 12) : hex;
+}
+function errMsg2(err2) {
+  return err2 instanceof Error ? err2.message : String(err2);
+}
+
+// src/host-control/auto-update-check.ts
+var NPM_LATEST_URL = "https://registry.npmjs.org/switchroom/latest";
+var FETCH_TIMEOUT_MS = 15000;
+function versionedImageRef(imageRef, version2) {
+  const lastSlash = imageRef.lastIndexOf("/");
+  const colon = imageRef.indexOf(":", lastSlash + 1);
+  const repo = colon === -1 ? imageRef : imageRef.slice(0, colon);
+  return `${repo}:${version2}`;
+}
+async function fetchNpmLatestVersion(url = NPM_LATEST_URL) {
+  const res = await fetch(url, {
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    headers: { accept: "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`npm registry responded ${res.status} for ${url}`);
+  }
+  const body = await res.json();
+  if (typeof body.version !== "string" || !/^\d+\.\d+\.\d+$/.test(body.version)) {
+    throw new Error(`npm registry document at ${url} has no clean semver version field`);
+  }
+  return body.version;
+}
+function makeAutoUpdateCheck(opts) {
+  const log = opts.log ?? (() => {});
+  const fetchLatest = opts.fetchLatestVersion ?? fetchNpmLatestVersion;
+  const imageExists = opts.imageExists ?? (async (ref) => {
+    const probe = await probeRemoteDigest(ref);
+    if (probe.digest === null && probe.error) {
+      log(`auto-update: manifest probe for ${ref} returned no digest ` + `(missing image OR registry error — deferring either way): ` + probe.error);
+    }
+    return probe.digest !== null;
+  });
+  let lastSuppressed = "";
+  const logOnce = (key, m) => {
+    if (lastSuppressed === key)
+      return;
+    lastSuppressed = key;
+    log(m);
+  };
+  return async () => {
+    const latest = `v${(await fetchLatest()).trim().replace(/^v/, "")}`;
+    const channel = opts.getCurrentChannel?.();
+    if (channel !== undefined && channel !== "latest") {
+      logOnce(`channel:${channel}`, `auto-update: release.channel is "${channel}" (not "latest") — the ` + `auto-update path tracks the npm latest dist-tag and persisting a ` + `pin would delete your channel, so no unattended roll will happen. ` + `Remove release.channel (or set it to "latest") to enable it. ` + `Latest published: ${latest}`);
+      return { available: false, version: latest };
+    }
+    const latched = opts.getLatchedPin?.() ?? null;
+    if (latched !== null && latched === latest) {
+      logOnce(`latch:${latched}`, `auto-update: ${latest} is latched from a previous unattended roll ` + `that failed or died mid-flight — not re-reporting it as available. ` + `Fix the cause and roll manually (\`switchroom rollout --pin ` + `${latest}\`), or wait for a newer release.`);
+      return { available: false, version: latest };
+    }
+    const pin = opts.getCurrentPin();
+    if (pin !== undefined) {
+      const cmp = compareReleaseTags(latest, pin);
+      if (cmp === null) {
+        log(`auto-update: current release.pin "${pin}" is not a vX.Y.Z tag — ` + `skipping unattended roll (latest published: ${latest})`);
+        return { available: false, version: latest };
+      }
+      if (cmp <= 0)
+        return { available: false, version: latest };
+    }
+    const target = versionedImageRef(opts.imageRef, latest);
+    if (!await imageExists(target)) {
+      log(`auto-update: ${latest} is published but ${target} is not pullable ` + `yet (docker-images workflow may still be building) — deferring`);
+      return { available: false, version: latest };
+    }
+    return { available: true, version: latest };
+  };
+}
+function resolveReleaseWatcherMode(config) {
+  if (config.release?.auto_update === true)
+    return { mode: "auto_update" };
+  if (config.host_control?.auto_release_check?.enabled === true) {
+    return { mode: "legacy" };
+  }
+  return { mode: "off" };
+}
+
 // src/host-control/main.ts
 import { appendFile as appendFile2 } from "node:fs/promises";
 async function loadConfigResilient() {
@@ -30846,28 +31338,126 @@ async function main() {
 `);
   let releaseWatcher = null;
   const autoRel = config.host_control?.auto_release_check;
-  if (autoRel?.enabled === true) {
+  const watcherMode = resolveReleaseWatcherMode(config);
+  if (watcherMode.mode !== "off") {
     const eventsLog = join11(homedir6(), ".switchroom", "release-watcher-events.jsonl");
-    releaseWatcher = new ReleaseWatcher({
-      intervalMs: autoRel.interval_minutes * 60000,
-      checkFn: makeReleaseCheck({
-        imageRef: autoRel.image_ref,
-        log: (m) => process.stderr.write(`hostd: ${m}
-`)
-      }),
-      applyFn: makeApply("switchroom"),
-      restartFn: makeRestart("switchroom"),
-      applyOnDetect: autoRel.apply_on_detect,
-      log: (m) => process.stderr.write(`hostd: ${m}
-`),
-      onEvent: (e) => {
-        appendFile2(eventsLog, JSON.stringify(e) + `
+    const log = (m) => {
+      process.stderr.write(`hostd: ${m}
+`);
+    };
+    const onEvent = (e) => {
+      appendFile2(eventsLog, JSON.stringify(e) + `
 `).catch(() => {});
+    };
+    const intervalMinutes = autoRel?.interval_minutes ?? 5;
+    const imageRef = autoRel?.image_ref ?? "ghcr.io/switchroom/switchroom-agent:latest";
+    if (watcherMode.mode === "auto_update") {
+      if (autoRel?.notify_on_detect === true) {
+        process.stderr.write("hostd: release.auto_update is on, so notify_on_detect is " + "ignored — new releases roll unattended via the canary path and " + "only FAILURES post an operator alert. Turn off " + `release.auto_update if you want the tap-to-apply card instead.
+`);
       }
-    });
-    releaseWatcher.start();
-    process.stderr.write(`hostd: release-watcher started — polling ${autoRel.image_ref} ` + `every ${autoRel.interval_minutes}m ` + `(apply_on_detect=${autoRel.apply_on_detect})
+      const liveRelease = () => loadConfig().release ?? {};
+      releaseWatcher = new ReleaseWatcher({
+        intervalMs: intervalMinutes * 60000,
+        checkFn: makeAutoUpdateCheck({
+          imageRef,
+          getCurrentPin: () => liveRelease().pin,
+          getCurrentChannel: () => liveRelease().channel,
+          getLatchedPin: () => server.autoRolloutLatchedPin(),
+          log
+        }),
+        applyFn: async (version2) => {
+          if (!version2) {
+            throw new Error("auto-update check reported no target version");
+          }
+          const r = await server.startAutoRollout(version2);
+          if (!r.started) {
+            throw new Error(`auto rollout not started: ${r.reason}`);
+          }
+          log(`auto-update: unattended rollout to ${version2} started ` + `(request_id ${r.request_id})`);
+        },
+        restartFn: async () => {},
+        applyOnDetect: true,
+        log,
+        onEvent
+      });
+      releaseWatcher.start();
+      process.stderr.write(`hostd: auto-update watcher started (release.auto_update) — ` + `checking the published release every ${intervalMinutes}m; new ` + `releases roll via the staggered canary rollout
+`);
+    } else {
+      const applyOnDetect = autoRel?.apply_on_detect ?? true;
+      const notifyOnDetect = autoRel?.notify_on_detect ?? false;
+      let notifier = null;
+      if (!applyOnDetect && notifyOnDetect) {
+        const adminAgents = Object.keys(config.agents).filter((n) => {
+          const a = config.agents[n];
+          return a.admin === true || a.root === true;
+        }).sort();
+        const cardTimeoutMs = 60 * 60000;
+        if (adminAgents.length === 0) {
+          process.stderr.write("hostd: notify_on_detect is enabled but no agent has " + "admin/root — update approval cards have nowhere to go; " + `notifier disabled
+`);
+        } else
+          notifier = new UpdateNotifier({
+            statePath: join11(homedir6(), ".switchroom", "release-notify-state.json"),
+            repostSuppressMs: cardTimeoutMs,
+            isFleetMutationInFlight: () => server.isFleetMutationLocked(),
+            startApply: (requestId) => {
+              const res = server.startOperatorApprovedUpdateApply(requestId);
+              return { result: res.result, ...res.error ? { error: res.error } : {} };
+            },
+            planFn: makeUpdatePlan("switchroom"),
+            requestApproval: async ({ requestId, version: version2, plan }) => {
+              let last = {
+                verdict: "deny",
+                reason: "no admin agent with a reachable gateway socket",
+                denySource: "dispatch_failure",
+                finalize: async () => {}
+              };
+              for (const agent of adminAgents) {
+                const res = await approvalGateway.requestApproval({
+                  requestId,
+                  agentName: agent,
+                  title: "⬆️ **Switchroom update available — fleet is behind**",
+                  reason: `New release detected for ${imageRef} ` + `(digest ${short(version2)}). Approve to run ` + `switchroom update (the hostd update_apply path).`,
+                  unifiedDiff: plan.length > 0 ? plan : `switchroom update --check produced no plan output;
+` + `remote digest: ${version2}`,
+                  timeoutMs: cardTimeoutMs
+                });
+                if (res.verdict === "deny" && res.denySource === "dispatch_failure") {
+                  last = res;
+                  continue;
+                }
+                return res;
+              }
+              return last;
+            },
+            log: (m) => process.stderr.write(`hostd: ${m}
+`)
+          });
+      }
+      const notifierRef = notifier;
+      releaseWatcher = new ReleaseWatcher({
+        intervalMs: intervalMinutes * 60000,
+        checkFn: makeReleaseCheck({
+          imageRef,
+          log
+        }),
+        applyFn: makeApply("switchroom"),
+        restartFn: makeRestart("switchroom"),
+        applyOnDetect,
+        ...notifierRef ? {
+          notifyFn: async (version2) => {
+            await notifierRef.notifyIfNew(version2);
+          }
+        } : {},
+        log,
+        onEvent
+      });
+      releaseWatcher.start();
+      process.stderr.write(`hostd: release-watcher started — polling ${imageRef} ` + `every ${intervalMinutes}m ` + `(apply_on_detect=${applyOnDetect}, ` + `notify_on_detect=${notifyOnDetect})
 `);
+    }
   }
   let stopping = false;
   async function shutdown(reason) {