@adhdev/daemon-standalone 1.0.28-rc.10 → 1.0.28-rc.11

package/dist/index.js

@@ -33262,10 +33262,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "e4b8cfd97ab9fbe458b61198b091a9051da87a6e" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "e4b8cfd9" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28-rc.10" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-26T03:08:59.459Z" : void 0);
+      const commit = readInjected(true ? "5cd04eec1e043188c3ef97821372ad5ff615cd04" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "5cd04eec" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.28-rc.11" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-26T07:08:53.585Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -59929,6 +59929,11 @@ ${cleanBody}`;
         return errs;
       }
       if ("cursor_above" in w && "changed" in w) return errs;
+      if ("signal" in w) {
+        if (typeof w.signal !== "string" || !w.signal.trim()) errs.push(`${path46}.signal must be a non-empty string`);
+        if (w.equals !== void 0 && typeof w.equals !== "boolean") errs.push(`${path46}.equals must be a boolean`);
+        return errs;
+      }
       if ("elapsed_ms" in w) {
         if (typeof w.elapsed_ms !== "number") errs.push(`${path46}.elapsed_ms must be a number`);
         return errs;
@@ -60242,6 +60247,49 @@ ${cleanBody}`;
         "use strict";
       }
     });
+    function unavailableSignalSnapshot(now, reason, profile) {
+      return {
+        kind: SIGNAL_SNAPSHOT_KIND,
+        sampledAt: now,
+        available: false,
+        unavailableReason: reason,
+        ...profile ? { profile } : {},
+        signals: { final_assistant_present: null, in_turn_progress: null, transcript_growing: null },
+        detail: { msgCount: 0, sourceMtimeMs: 0, ageMs: null }
+      };
+    }
+    function evaluateSignalLeaf(cond, snapshot) {
+      const expected = cond.equals ?? true;
+      if (!snapshot || !snapshot.available) {
+        const why = !snapshot ? "no snapshot" : `unavailable(${snapshot.unavailableReason ?? "unknown"})`;
+        return {
+          value: null,
+          shadowResult: null,
+          detail: `signal ${cond.signal} ${why} \u2192 fail-open`
+        };
+      }
+      const raw = Object.prototype.hasOwnProperty.call(snapshot.signals, cond.signal) ? snapshot.signals[cond.signal] : null;
+      if (raw === null || raw === void 0) {
+        return {
+          value: null,
+          shadowResult: null,
+          detail: `signal ${cond.signal} unknown \u2192 fail-open`
+        };
+      }
+      const shadowResult = raw === expected;
+      return {
+        value: raw,
+        shadowResult,
+        detail: `signal ${cond.signal}=${raw} expected=${expected} \u2192 ${shadowResult}`
+      };
+    }
+    var SIGNAL_SNAPSHOT_KIND;
+    var init_signal_envelope = __esm2({
+      "src/providers/spec/signal-envelope.ts"() {
+        "use strict";
+        SIGNAL_SNAPSHOT_KIND = "adhdev:fsm/signal-snapshot@0";
+      }
+    });
     var fsm_evaluator_exports = {};
     __export2(fsm_evaluator_exports, {
       evaluateConditionPreview: () => evaluateConditionPreview,
@@ -60274,24 +60322,74 @@ ${cleanBody}`;
     function isNot(c) {
       return "not" in c;
     }
-    function evalCond(cond, sections, fullScreen, cursor, prevLines, clock, legacyTrace, stateId) {
+    function isSignal(c) {
+      return "signal" in c;
+    }
+    function containsSignal(c) {
+      if (isSignal(c)) return true;
+      if (isAll(c)) return c.all.some(containsSignal);
+      if (isAny(c)) return c.any.some(containsSignal);
+      if (isNot(c)) return containsSignal(c.not);
+      return false;
+    }
+    function foldShadow(cond) {
+      if (cond.kind === "signal") {
+        const s2 = cond.signal;
+        if (s2 && s2.shadowResult !== null && s2.shadowResult !== void 0) {
+          return { value: s2.shadowResult, unknown: false };
+        }
+        return { value: true, unknown: true };
+      }
+      if (cond.kind === "not" && cond.children?.length) {
+        const c = foldShadow(cond.children[0]);
+        return { value: !c.value, unknown: c.unknown };
+      }
+      if (cond.kind === "all" && cond.children) {
+        const kids = cond.children.map(foldShadow);
+        if (kids.some((k) => !k.unknown && !k.value)) return { value: false, unknown: false };
+        if (kids.some((k) => k.unknown)) return { value: true, unknown: true };
+        return { value: true, unknown: false };
+      }
+      if (cond.kind === "any" && cond.children) {
+        const kids = cond.children.map(foldShadow);
+        if (kids.some((k) => !k.unknown && k.value)) return { value: true, unknown: false };
+        if (kids.some((k) => k.unknown)) return { value: false, unknown: true };
+        return { value: false, unknown: false };
+      }
+      return { value: cond.result, unknown: false };
+    }
+    function evalCond(cond, sections, fullScreen, cursor, prevLines, clock, legacyTrace, stateId, signalSnapshot) {
       if (isAll(cond)) {
-        const children = cond.all.map((c) => evalCond(c, sections, fullScreen, cursor, prevLines, clock, legacyTrace, stateId));
+        const children = cond.all.map((c) => evalCond(c, sections, fullScreen, cursor, prevLines, clock, legacyTrace, stateId, signalSnapshot));
         const result = children.every((c) => c.result);
         const remainingMs = result ? 0 : Math.max(0, ...children.filter((c) => !c.result).map((c) => c.remainingMs ?? 0));
         return { kind: "all", result, detail: `all(${children.length})`, remainingMs, children };
       }
       if (isAny(cond)) {
-        const children = cond.any.map((c) => evalCond(c, sections, fullScreen, cursor, prevLines, clock, legacyTrace, stateId));
+        const children = cond.any.map((c) => evalCond(c, sections, fullScreen, cursor, prevLines, clock, legacyTrace, stateId, signalSnapshot));
         const result = children.some((c) => c.result);
         const pending = children.filter((c) => !c.result).map((c) => c.remainingMs ?? Infinity);
         const remainingMs = result ? 0 : pending.length ? Math.min(...pending) : 0;
         return { kind: "any", result, detail: `any(${children.length})`, remainingMs: Number.isFinite(remainingMs) ? remainingMs : 0, children };
       }
       if (isNot(cond)) {
-        const child = evalCond(cond.not, sections, fullScreen, cursor, prevLines, clock, legacyTrace, stateId);
+        const child = evalCond(cond.not, sections, fullScreen, cursor, prevLines, clock, legacyTrace, stateId, signalSnapshot);
         return { kind: "not", result: !child.result, detail: `not`, remainingMs: 0, children: [child] };
       }
+      if (isSignal(cond)) {
+        const leaf = evaluateSignalLeaf(cond, signalSnapshot);
+        return {
+          kind: "signal",
+          result: true,
+          detail: `${leaf.detail} (stage0 shadow \u2014 pass-through)`,
+          signal: {
+            name: cond.signal,
+            available: !!signalSnapshot?.available,
+            value: leaf.value,
+            shadowResult: leaf.shadowResult
+          }
+        };
+      }
       if (isElapsed(cond)) {
         const age = clock.now - clock.stateEnteredAt;
         const result = age >= cond.elapsed_ms;
@@ -60330,7 +60428,7 @@ ${cleanBody}`;
       const from = Array.isArray(t.from) ? t.from.join("|") : t.from;
       return t.label ?? `${from}\u2192${t.to}`;
     }
-    function evaluateFsm(spec, currentStateId, screenText, cursor, prevLines, clock) {
+    function evaluateFsm(spec, currentStateId, screenText, cursor, prevLines, clock, signalSnapshot) {
       const legacyTrace = [];
       const lines = screenText.split("\n").map((l) => l.endsWith("\r") ? l.slice(0, -1) : l);
       const cleanScreen = lines.join("\n");
@@ -60346,7 +60444,7 @@ ${cleanBody}`;
         let cond;
         let condResult = true;
         if (t.when) {
-          cond = evalCond(t.when, sections, cleanScreen, cursor, prevLines, clock, legacyTrace, `${currentStateId}\u2192${t.to}`);
+          cond = evalCond(t.when, sections, cleanScreen, cursor, prevLines, clock, legacyTrace, `${currentStateId}\u2192${t.to}`, signalSnapshot);
           condResult = cond.result;
         }
         const fires = holdSatisfied && condResult;
@@ -60361,6 +60459,14 @@ ${cleanBody}`;
           fires,
           priority: t.priority ?? 0
         };
+        if (t.when && containsSignal(t.when) && cond) {
+          const folded = foldShadow(cond);
+          te.shadow = {
+            condResult: folded.value,
+            fires: holdSatisfied && folded.value,
+            unknown: folded.unknown
+          };
+        }
         transitions.push(te);
         if (fires && !fired) fired = te;
       }
@@ -60383,6 +60489,7 @@ ${cleanBody}`;
         "use strict";
         init_evaluator();
         init_fsm_types();
+        init_signal_envelope();
         WHOLE_SCREEN = -1;
       }
     });
@@ -78044,12 +78151,21 @@ ${body}
         appendUpgradeLog(`Waiting for parent pid ${payload.parentPid} to exit`);
         await waitForPidExit(payload.parentPid, 15e3);
       }
-      if (process.platform === "win32") {
+      if (process.platform === "win32" || payload.killSessionHost === true) {
         await stopSessionHostProcesses(sessionHostAppName);
       } else {
         appendUpgradeLog("POSIX \u2014 session-host left running (survives upgrade; sessions rebind on next boot)");
       }
       removeDaemonPidFile();
+      if (payload.skipInstall) {
+        appendUpgradeLog("Restart-only mode \u2014 package install skipped, re-spawning daemon");
+        spawnDetachedDaemonRestart(restartArgv, payload.cwd);
+        try {
+          fs15.unlinkSync(getUpgradeFailureNoticePath());
+        } catch {
+        }
+        return;
+      }
       const instanceDir = resolveInstanceDir();
       const windowsInstallerLayout = resolveWindowsInstallerLayout({
         homeDir: os14.homedir(),
@@ -78168,6 +78284,13 @@ ${body}
         cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
         appendUpgradeLog("Post-install staging cleanup complete");
       }
+      spawnDetachedDaemonRestart(restartArgv, payload.cwd);
+      try {
+        fs15.unlinkSync(getUpgradeFailureNoticePath());
+      } catch {
+      }
+    }
+    function spawnDetachedDaemonRestart(restartArgv, cwd) {
       if (restartArgv.length > 0) {
         const env2 = { ...process.env };
         delete env2[UPGRADE_HELPER_ENV];
@@ -78176,17 +78299,13 @@ ${body}
           detached: true,
           stdio: "ignore",
           windowsHide: true,
-          cwd: payload.cwd || process.cwd(),
+          cwd: cwd || process.cwd(),
           env: env2
         });
         child.unref();
       } else {
         appendUpgradeLog("No restart argv provided; upgrade completed without restart");
       }
-      try {
-        fs15.unlinkSync(getUpgradeFailureNoticePath());
-      } catch {
-      }
     }
     async function maybeRunDaemonUpgradeHelperFromEnv2() {
       const raw = process.env[UPGRADE_HELPER_ENV];
@@ -78277,6 +78396,41 @@ ${body}
           return { success: false, error: e.message };
         }
       },
+      // Restart-only path (mesh restart_daemon_node mode="restart"): re-spawn the
+      // daemon WITHOUT the npm reinstall daemon_upgrade performs. Used to reset
+      // daemon state (memory leaks, zombie sessions, wedged internals) when the
+      // version is already correct — downtime drops to the detached re-spawn.
+      // killSessionHost is an explicit opt-in hard refresh (see upgrade-helper).
+      daemon_restart: async (ctx, args) => {
+        LOG2.info("Restart", "Restart-only requested (no package reinstall)");
+        try {
+          const isStandalone = ctx.deps.packageName === "@adhdev/daemon-standalone" || process.argv[1]?.includes("daemon-standalone");
+          const pkgName = isStandalone ? "@adhdev/daemon-standalone" : "adhdev";
+          const killSessionHost = args?.killSessionHost === true;
+          if (killSessionHost) {
+            LOG2.warn("Restart", "killSessionHost requested \u2014 session-host will be stopped and ALL hosted sessions destroyed");
+          }
+          spawnDetachedDaemonUpgradeHelper({
+            packageName: pkgName,
+            targetVersion: "",
+            parentPid: process.pid,
+            restartArgv: process.argv.slice(1),
+            cwd: process.cwd(),
+            sessionHostAppName: process.env.ADHDEV_SESSION_HOST_NAME || "adhdev",
+            skipInstall: true,
+            killSessionHost
+          });
+          LOG2.info("Restart", "Scheduled detached restart-only helper");
+          setTimeout(() => {
+            LOG2.info("Restart", "Exiting daemon so detached helper can re-spawn it...");
+            process.exit(0);
+          }, 3e3);
+          return { success: true, restarted: true, restarting: true, mode: "restart", killSessionHost };
+        } catch (e) {
+          LOG2.error("Restart", `Failed: ${e.message}`);
+          return { success: false, error: e.message };
+        }
+      },
       set_machine_nickname: async (_ctx, args) => {
         const nickname = args?.nickname;
         updateConfig({ machineNickname: nickname || null });
@@ -78754,6 +78908,91 @@ ${body}
     init_provider_input_support();
     init_hash();
     init_transcript_evidence();
+    init_logger();
+    init_signal_envelope();
+    var TranscriptSignalSource = class {
+      constructor(opts) {
+        this.opts = opts;
+      }
+      /** msgCount seen at the previous update — drives in_turn_progress. */
+      prevMsgCount = -1;
+      /** Fingerprint of the last LOGGED snapshot, so the shadow log fires on
+       *  change only (a quiet session must not spam one line per read). */
+      lastLoggedFingerprint = "";
+      /**
+       * Normalize one daemon read into a SignalSnapshot and emit the Stage-0
+       * shadow log when the observation changed. Pure w.r.t. the outside world:
+       * the only side effect is the (change-gated) log line. Returns the
+       * snapshot the caller should inject into the FSM driver.
+       */
+      update(sample, now = Date.now()) {
+        const snapshot = this.buildSnapshot(sample, now);
+        this.logOnChange(snapshot);
+        return snapshot;
+      }
+      /** Pure normalization — separated from update() so tests can assert the
+       *  envelope without touching the log path. */
+      buildSnapshot(sample, now) {
+        const profileRef = { class: this.opts.profile.class, timing: this.opts.profile.timing };
+        if (this.opts.profile.class !== "native-source") {
+          return unavailableSignalSnapshot(now, "no_native_source", profileRef);
+        }
+        if (sample.error) {
+          return unavailableSignalSnapshot(now, "error", profileRef);
+        }
+        const probe = sample.probe;
+        if (!probe || !Array.isArray(sample.messages)) {
+          return unavailableSignalSnapshot(now, "unresolved", profileRef);
+        }
+        const msgCount = typeof probe.msgCount === "number" && Number.isFinite(probe.msgCount) ? probe.msgCount : sample.messages.length;
+        const sourceMtimeMs = typeof probe.sourceMtimeMs === "number" && Number.isFinite(probe.sourceMtimeMs) ? probe.sourceMtimeMs : 0;
+        const ageMs = sourceMtimeMs > 0 ? Math.max(0, now - sourceMtimeMs) : null;
+        let turnStartedAt;
+        try {
+          turnStartedAt = this.opts.turnStartedAt?.();
+        } catch {
+          turnStartedAt = void 0;
+        }
+        let finalAssistant = null;
+        try {
+          finalAssistant = this.opts.finalAssistantPresent(sample.messages, turnStartedAt);
+        } catch {
+          finalAssistant = null;
+        }
+        const countAdvanced = this.prevMsgCount >= 0 && msgCount > this.prevMsgCount;
+        const fresh = ageMs !== null && ageMs < this.opts.growthQuietMs;
+        const inTurnProgress = countAdvanced || fresh;
+        const transcriptGrowing = ageMs === null ? null : fresh;
+        this.prevMsgCount = msgCount;
+        return {
+          kind: SIGNAL_SNAPSHOT_KIND,
+          sampledAt: now,
+          available: true,
+          profile: profileRef,
+          signals: {
+            final_assistant_present: finalAssistant,
+            in_turn_progress: inTurnProgress,
+            transcript_growing: transcriptGrowing
+          },
+          detail: { msgCount, sourceMtimeMs, ageMs }
+        };
+      }
+      /** Stage-0 shadow log: emit one line when the normalized observation
+       *  CHANGES. This log is the Stage 1-3 judgment input ("which signals were
+       *  actually observable, and when"), so it carries the full signal set —
+       *  but only on change, so a steady-state session stays quiet. */
+      logOnChange(snapshot) {
+        const s2 = snapshot.signals;
+        const fingerprint = snapshot.available ? `1|fa=${s2.final_assistant_present}|tp=${s2.in_turn_progress}|tg=${s2.transcript_growing}|n=${snapshot.detail.msgCount}` : `0|${snapshot.unavailableReason ?? "unknown"}`;
+        if (fingerprint === this.lastLoggedFingerprint) return;
+        this.lastLoggedFingerprint = fingerprint;
+        const age = snapshot.detail.ageMs === null ? "n/a" : `${snapshot.detail.ageMs}ms`;
+        LOG2.info(
+          "TranscriptSignalSource",
+          `[${this.opts.label}] [shadow] signals available=${snapshot.available}` + (snapshot.available ? ` final_assistant_present=${s2.final_assistant_present} in_turn_progress=${s2.in_turn_progress} transcript_growing=${s2.transcript_growing} msgCount=${snapshot.detail.msgCount} age=${age}` : ` reason=${snapshot.unavailableReason ?? "unknown"}`)
+        );
+      }
+    };
     var fs222 = __toESM2(require("fs"));
     var path26 = __toESM2(require("path"));
     init_provider_cli_adapter();
@@ -79107,6 +79346,15 @@ ${body}
        *  transition — the rich pre-transition table that lastFsmEval only keeps
        *  for the single most recent evaluation. Separate from stateHistory. */
       fsmSnapshotHistory = [];
+      /** TX-FSM Stage 0 (shadow): the latest daemon-injected signal observation.
+       *  Read by evalFsmNow for the shadow verdict of `signal` conditions ONLY —
+       *  the Stage-0 pass-through in the evaluator means it can never alter
+       *  which transition fires. */
+      signalObservation = null;
+      /** Per-transition last-logged shadow divergence (`${from}→${to}` → whether
+       *  the shadow verdict currently disagrees with the real one), so the
+       *  shadow log emits on FLIP only, not every frame. */
+      shadowDivergenceLast = /* @__PURE__ */ new Map();
       subscribe(listener) {
         this.listeners.add(listener);
         return () => {
@@ -79179,6 +79427,16 @@ ${body}
       updateMeta(meta3, replace = false) {
         this.adapter.updateMeta(meta3, replace);
       }
+      /**
+       * TX-FSM Stage 0 (shadow): receive the daemon-normalized signal
+       * observation. The driver stores it verbatim — it does NOT poll, parse,
+       * or read anything itself (generic-PTY-engine boundary). The observation
+       * only feeds the shadow verdict of `signal` conditions; the evaluator's
+       * Stage-0 pass-through guarantees it cannot change a transition.
+       */
+      setSignalObservation(snapshot) {
+        this.signalObservation = snapshot ?? null;
+      }
       snapshot() {
         return this.adapter.snapshot();
       }
@@ -79369,7 +79627,35 @@ ${body}
       }
       evalFsmNow(screen, cursor, now) {
         const prev = this.prevScreenLines.length > 0 ? this.prevScreenLines : void 0;
-        return evaluateFsm(this.spec, this.currentStateId, screen, cursor, prev, this.buildClock(now));
+        return evaluateFsm(this.spec, this.currentStateId, screen, cursor, prev, this.buildClock(now), this.signalObservation);
+      }
+      /**
+       * TX-FSM Stage 0 (shadow): compare each signal-guarded transition's
+       * counterfactual verdict against the real (PTY-only) one and log on FLIP.
+       * This is the "만약 적용했다면" half of the shadow log — the Stage 1-3
+       * evidence for whether signal gating would have changed any verdict, and
+       * in which direction. Read-only: runs after the evaluation is complete
+       * and never feeds back into it.
+       */
+      logShadowDivergence(ev) {
+        for (const t of ev.transitions) {
+          if (!t.shadow) continue;
+          const key2 = `${this.currentStateId}\u2192${t.to}`;
+          const diverges = t.shadow.fires !== t.fires;
+          if ((this.shadowDivergenceLast.get(key2) ?? false) === diverges) continue;
+          this.shadowDivergenceLast.set(key2, diverges);
+          if (diverges) {
+            LOG2.info(
+              "FsmDriver",
+              `[${this.specTag()}] [shadow] ${key2} (${t.label}): real fires=${t.fires} but signal-gated verdict would be fires=${t.shadow.fires} (shadowCond=${t.shadow.condResult}${t.shadow.unknown ? ", signal unknown/fail-open" : ""})`
+            );
+          } else {
+            LOG2.info(
+              "FsmDriver",
+              `[${this.specTag()}] [shadow] ${key2} (${t.label}): shadow verdict realigned with real fires=${t.fires}`
+            );
+          }
+        }
       }
       reevaluate(forceEmit = false) {
         const now = Date.now();
@@ -79380,6 +79666,7 @@ ${body}
         const ev = this.evalFsmNow(screen, cursor, now);
         this.lastFsmEval = ev;
         this.prevScreenLines = currentLines;
+        this.logShadowDivergence(ev);
         if (ev.fired) {
           this.commitTransition(ev.fired, now, ev);
           this.emitStateChanged(forceEmit);
@@ -82016,6 +82303,18 @@ ${body}
       }
       refreshProviderDefinition() {
       }
+      /**
+       * TX-FSM Stage 0 (shadow): forward the daemon's normalized signal
+       * observation into the FSM driver. Observation-only — failures here must
+       * never break the adapter, and the driver treats the envelope as a pure
+       * injected value (no reads cross the engine boundary).
+       */
+      setSignalObservation(snapshot) {
+        try {
+          this.driver.setSignalObservation?.(snapshot);
+        } catch {
+        }
+      }
       handleEvent(ev) {
         this.lastEvent = ev;
         switch (ev.kind) {
@@ -83846,6 +84145,10 @@ ${body}
       completedDebounceTimer = null;
       completedDebouncePending = null;
       lastExternalCompletionProbe = null;
+      /** TX-FSM Stage 0 (shadow): lazily-created transcript signal normalizer.
+       *  Fed ONLY by transcript reads this instance already performs — it adds
+       *  zero I/O and its output never feeds back into any verdict. */
+      transcriptSignalSource = null;
       /**
        * The final assistant summary of the last completed turn, cached at
        * completion-emit time. For a native-source provider (antigravity) whose
@@ -84011,6 +84314,7 @@ ${body}
         });
         if (restoredHistory.source !== "provider-native") {
           this.lastExternalCompletionProbe = null;
+          this.publishTranscriptSignalObservation(null);
           return null;
         }
         this.lastExternalCompletionProbe = buildExternalTranscriptProbe(
@@ -84018,8 +84322,48 @@ ${body}
           restoredHistory.sourcePath,
           restoredHistory.sourceMtimeMs
         );
+        this.publishTranscriptSignalObservation(restoredHistory.messages);
         return restoredHistory.messages;
       }
+      /**
+       * TX-FSM Stage 0 (shadow): normalize the transcript read that JUST
+       * happened into a SignalSnapshot and inject it into the FSM driver as a
+       * pure observation (daemon → SpecCliAdapter → FsmDriver). Fed ONLY by
+       * reads this method's caller already performs — it adds zero I/O, so the
+       * getState() zero-native-read invariant and the stall-path read cadence
+       * are untouched. The snapshot is shadow data: nothing on this path feeds
+       * back into completion/stall/redrive verdicts. Fail-open end to end — a
+       * missing adapter hook (non-spec providers), an unresolved transcript, or
+       * any throw degrades to "no observation", never to a wedge.
+       */
+      publishTranscriptSignalObservation(messages, error48 = false) {
+        const adapter = this.adapter;
+        if (typeof adapter?.setSignalObservation !== "function") return;
+        try {
+          if (!this.transcriptSignalSource) {
+            this.transcriptSignalSource = new TranscriptSignalSource({
+              label: this.type,
+              // Choke point: class/timing come from the P0 profile
+              // resolver, never from raw predicates or provider names.
+              profile: resolveTranscriptAuthorityProfile(this.provider),
+              turnStartedAt: () => {
+                const t = this.adapter?.currentTurnStartedAt;
+                return typeof t === "number" && Number.isFinite(t) ? t : void 0;
+              },
+              // Reuse the exact completion machinery (I1) for the
+              // final_assistant_present signal rather than duplicating
+              // the message scan.
+              finalAssistantPresent: (msgs, ts2) => this.completionHasFinalAssistantMessage(msgs, ts2),
+              growthQuietMs: MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS
+            });
+          }
+          const snapshot = this.transcriptSignalSource.update(
+            { messages, probe: this.lastExternalCompletionProbe, error: error48 }
+          );
+          adapter.setSignalObservation(snapshot);
+        } catch {
+        }
+      }
       /**
        * The content of the LAST visible assistant bubble in a message list, or ''
        * when the tail is not an assistant reply. Skips trailing system/tool/activity
@@ -95437,17 +95781,134 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     };
     init_dist();
+    init_logger();
     var RESTART_BLOCKING_STATES = /* @__PURE__ */ new Set(["generating", "waiting_approval", "starting"]);
-    function hasBlockingSessions(ctx) {
+    var DEFERRED_RESTART_DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
+    var DEFERRED_RESTART_MAX_TIMEOUT_MS = 6 * 60 * 60 * 1e3;
+    var DEFERRED_RESTART_POLL_MS = 1e4;
+    function collectBlockingSessions(ctx, meshId) {
+      const blocking = [];
       const states = ctx.deps.instanceManager.collectAllStates();
+      const consider = (state) => {
+        const status = String(state?.status || "");
+        if (!RESTART_BLOCKING_STATES.has(status)) return;
+        blocking.push({
+          instanceId: typeof state?.instanceId === "string" ? state.instanceId : null,
+          status,
+          // The coordinator marker is stamped by mesh_coordinator_launch and
+          // re-stamped on restore (cli-manager.restoreHostedSessions). Ad-hoc
+          // coordinator sessions have no marker and are NOT waived by selfOnly.
+          selfCoordinator: !!meshId && state?.settings?.meshCoordinatorFor === meshId
+        });
+      };
       for (const state of states) {
-        if (RESTART_BLOCKING_STATES.has(String(state.status || ""))) return true;
+        consider(state);
         const childStates = "extensions" in state && Array.isArray(state.extensions) ? state.extensions : [];
-        for (const child of childStates) {
-          if (RESTART_BLOCKING_STATES.has(String(child?.status || ""))) return true;
-        }
+        for (const child of childStates) consider(child);
+      }
+      return blocking;
+    }
+    var pendingDeferredRestart = null;
+    function deferredRestartInfo() {
+      if (!pendingDeferredRestart) return null;
+      return {
+        meshId: pendingDeferredRestart.meshId,
+        nodeId: pendingDeferredRestart.nodeId,
+        mode: pendingDeferredRestart.mode,
+        killSessionHost: pendingDeferredRestart.killSessionHost,
+        scheduledAt: new Date(pendingDeferredRestart.scheduledAt).toISOString(),
+        expiresAt: new Date(pendingDeferredRestart.expiresAt).toISOString(),
+        runCondition: "executes automatically once no session is generating / waiting_approval / starting"
+      };
+    }
+    function clearPendingDeferredRestart() {
+      if (pendingDeferredRestart) clearInterval(pendingDeferredRestart.timer);
+      pendingDeferredRestart = null;
+    }
+    function normalizeRestartMode(value) {
+      return value === "restart" ? "restart" : "upgrade";
+    }
+    function restartWarnings(args) {
+      const warnings = [];
+      if (args.forced) {
+        warnings.push("forced restart over active sessions \u2014 in-flight turns were interrupted and the in-memory pendingOutboundQueue is permanently lost (no persistence/restore path).");
+      }
+      if (args.killSessionHost) {
+        warnings.push("killSessionHost: the session-host process was stopped \u2014 ALL hosted CLI sessions on this machine are destroyed (hard refresh).");
+      }
+      if (process.platform === "win32") {
+        warnings.push("Windows: the daemon restart/upgrade path stops the session-host regardless of options \u2014 all hosted sessions terminate.");
+      } else {
+        warnings.push("POSIX: hosted PTY sessions survive a plain daemon restart and rebind on next boot (unless killSessionHost was set).");
+      }
+      return warnings;
+    }
+    async function executeRestart(ctx, args, opts) {
+      const mode = normalizeRestartMode(args?.mode);
+      const killSessionHost = args?.killSessionHost === true;
+      const result = mode === "restart" ? await daemonLifecycleHandlers.daemon_restart({ deps: ctx.deps }, { killSessionHost }) : await daemonLifecycleHandlers.daemon_upgrade({ deps: ctx.deps }, args);
+      const restarting = result?.restarting === true;
+      return {
+        ...result,
+        mode,
+        restarted: restarting,
+        ...restarting ? {
+          warnings: restartWarnings({ killSessionHost, forced: opts.forced }),
+          // MCP IPC has no automatic reconnect/retry — tell the caller when to
+          // talk to this daemon again.
+          clientHint: "daemon restarting \u2014 retry your next call in ~10s"
+        } : {}
+      };
+    }
+    function scheduleDeferredRestart(ctx, args, meshId, nodeId) {
+      clearPendingDeferredRestart();
+      const requestedTimeout = typeof args?.timeoutMs === "number" && Number.isFinite(args.timeoutMs) ? args.timeoutMs : DEFERRED_RESTART_DEFAULT_TIMEOUT_MS;
+      const timeoutMs = Math.min(Math.max(requestedTimeout, DEFERRED_RESTART_POLL_MS), DEFERRED_RESTART_MAX_TIMEOUT_MS);
+      const record2 = {
+        meshId,
+        nodeId,
+        mode: normalizeRestartMode(args?.mode),
+        killSessionHost: args?.killSessionHost === true,
+        scheduledAt: Date.now(),
+        expiresAt: Date.now() + timeoutMs,
+        timer: setInterval(() => {
+          void deferredRestartTick(ctx);
+        }, DEFERRED_RESTART_POLL_MS)
+      };
+      record2.timer.unref?.();
+      pendingDeferredRestart = record2;
+      LOG2.info("MeshRestart", `Deferred restart scheduled for node ${nodeId} (mode=${record2.mode}, expires in ${Math.round(timeoutMs / 6e4)}min)`);
+      return {
+        success: true,
+        restarted: false,
+        scheduled: true,
+        code: "restart_scheduled_when_idle",
+        reason: "Restart scheduled \u2014 it will execute automatically as soon as no session on this daemon is generating / waiting_approval / starting. Running at an idle point also avoids pendingOutboundQueue loss, making this the safest restart path.",
+        deferredRestart: deferredRestartInfo()
+      };
+    }
+    async function deferredRestartTick(ctx) {
+      const record2 = pendingDeferredRestart;
+      if (!record2) return;
+      if (Date.now() >= record2.expiresAt) {
+        LOG2.warn("MeshRestart", `Deferred restart for node ${record2.nodeId} expired without reaching an idle point; dropping the schedule`);
+        clearPendingDeferredRestart();
+        return;
+      }
+      const blocking = collectBlockingSessions(ctx, record2.meshId);
+      if (blocking.length > 0) return;
+      LOG2.info("MeshRestart", `Deferred restart for node ${record2.nodeId} executing \u2014 daemon is idle`);
+      clearPendingDeferredRestart();
+      try {
+        await executeRestart(ctx, {
+          meshId: record2.meshId,
+          nodeId: record2.nodeId,
+          mode: record2.mode,
+          killSessionHost: record2.killSessionHost
+        }, { forced: false });
+      } catch (e) {
+        LOG2.error("MeshRestart", `Deferred restart execution failed: ${e?.message || String(e)}`);
       }
-      return false;
     }
     var meshRestartHandlers = {
       restart_daemon_node: async (ctx, args) => {
@@ -95468,16 +95929,43 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           });
           return forwarded ?? { success: false, error: "no response from remote node" };
         }
-        if (hasBlockingSessions(ctx)) {
+        if (args?.cancelWhenIdle === true) {
+          const had = pendingDeferredRestart !== null;
+          clearPendingDeferredRestart();
+          return { success: true, restarted: false, cancelled: had, deferredRestart: null };
+        }
+        if (args?.whenIdleStatus === true) {
+          return { success: true, restarted: false, deferredRestart: deferredRestartInfo() };
+        }
+        const blocking = collectBlockingSessions(ctx, meshId);
+        if (blocking.length > 0) {
+          if (args?.force === true) {
+            LOG2.warn("MeshRestart", `force restart over ${blocking.length} blocking session(s): ${blocking.map((b) => `${b.instanceId || "?"}(${b.status})`).join(", ")} \u2014 pendingOutboundQueue will be lost`);
+            return executeRestart(ctx, args, { forced: true });
+          }
+          const foreignBlocking = blocking.filter((b) => !b.selfCoordinator);
+          if (args?.selfOnly === true && foreignBlocking.length === 0) {
+            LOG2.info("MeshRestart", `selfOnly restart: waiving ${blocking.length} self-coordinator session(s) for mesh ${meshId}`);
+            return executeRestart(ctx, args, { forced: false });
+          }
+          if (args?.whenIdle === true) {
+            return scheduleDeferredRestart(ctx, args, meshId, nodeId);
+          }
           return {
             success: false,
             restarted: false,
             code: "blocking_sessions",
-            reason: "Daemon has an active session (generating / waiting_approval / starting); restart refused to avoid interrupting in-flight work. Retry when the node is idle."
+            reason: "Daemon has an active session (generating / waiting_approval / starting); restart refused to avoid interrupting in-flight work. Retry when the node is idle.",
+            blockingSessions: blocking,
+            options: {
+              selfOnly: "waive only this mesh's own coordinator session (settings.meshCoordinatorFor === meshId)",
+              force: "bypass the idle-gate entirely \u2014 kills in-flight turns and loses the unpersisted pendingOutboundQueue",
+              whenIdle: "schedule the restart to run automatically once the daemon goes idle (safest)"
+            },
+            deferredRestart: deferredRestartInfo()
           };
         }
-        const result = await daemonLifecycleHandlers.daemon_upgrade({ deps: ctx.deps }, args);
-        return { ...result, restarted: result?.restarting === true };
+        return executeRestart(ctx, args, { forced: false });
       }
     };
     var medFamilyRegistry = new Map(