@adhdev/daemon-core 0.9.82-rc.556 → 0.9.82-rc.558

package/dist/index.js

@@ -428,10 +428,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "be22dd93c4d346e18a1c16b2d451c0b3d085e5e3" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "be22dd93" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.556" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-17T09:34:20.876Z" : void 0);
+  const commit = readInjected(true ? "97717181f86a63a5331c149f92111ee72088620c" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "97717181" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.558" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-17T12:19:20.741Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -47704,9 +47704,30 @@ var CliProviderInstance = class _CliProviderInstance {
   // event. Unlike the StatusMonitor no-progress watchdog (which only runs while a
   // turn is generating), this observes pure screen stasis regardless of the
   // reported status — a worker parked idle, wedged mid-turn, or spawned with no
-  // output at all. 180s matches DEFAULT_MONITOR_CONFIG.noProgressThresholdSec so
-  // the two watchdogs agree on the same "long interval" bound.
-  static MESH_WORKER_STALL_THRESHOLD_MS = 18e4;
+  // output at all.
+  //
+  // FALSE-STALL-WATCHDOG-OVERFIRE (fix C): the threshold is now turn-scoped. When
+  // an explicit turn is in flight (hasAdapterPendingResponse() — the adapter's
+  // currentTurnScope / isWaitingForResponse / isProcessing / partial buffer), a
+  // long silent thinking gap (claude-cli opus/high can go minutes between visible
+  // tokens) is normal, so the bar is raised to MESH_WORKER_STALL_TURN_THRESHOLD_MS.
+  // Outside a turn (idle) the tighter MESH_WORKER_STALL_IDLE_THRESHOLD_MS applies.
+  // This is a THRESHOLD RAISE, not a suppression: a genuine mid-turn wedge still
+  // fires (late, at the turn bound) rather than being hidden behind a sticky
+  // generating status. 180s matches DEFAULT_MONITOR_CONFIG.noProgressThresholdSec
+  // so the idle bound agrees with the StatusMonitor watchdog's "long interval".
+  static MESH_WORKER_STALL_IDLE_THRESHOLD_MS = 18e4;
+  static MESH_WORKER_STALL_TURN_THRESHOLD_MS = 36e4;
+  // FALSE-STALL-WATCHDOG-OVERFIRE (fix E): minimum spacing between two stall
+  // notifications for the SAME session, even across anchor re-arms. The
+  // per-anchor meshStallEmittedForAnchor guard already stops a single continuous
+  // stall from re-firing; this cooldown additionally throttles the churn where a
+  // worker dribbles one byte every few minutes (each re-arming the anchor and then
+  // re-crossing the bar), which would otherwise page the coordinator repeatedly.
+  // The stall is still fired for observability — just not more than once per
+  // window per session. Set larger than the stall thresholds so consecutive
+  // re-armed stalls a few minutes apart collapse into a single notification.
+  static MESH_WORKER_STALL_REFIRE_COOLDOWN_MS = 6e5;
   adapter;
   context = null;
   events = [];
@@ -47730,6 +47751,18 @@ var CliProviderInstance = class _CliProviderInstance {
   // -1 = not yet initialised for this session.
   meshStallAnchorAt = -1;
   meshStallEmittedForAnchor = false;
+  // FALSE-STALL-WATCHDOG-OVERFIRE (fix B): the turn-active state observed on the
+  // PREVIOUS stall tick. When a turn ends (active → inactive: the completion/idle
+  // transition), the anchor is force re-armed to `now` so the completed→idle valley
+  // does not fire against the pre-completion output clock. The turn-end edge is the
+  // signal; updateStatus's own idle transition does not touch the stall anchor, so
+  // this watchdog-local edge detector owns the re-arm. undefined = no prior tick.
+  meshStallTurnActiveLast = void 0;
+  // FALSE-STALL-WATCHDOG-OVERFIRE (fix E): wall-clock of the most recent stall
+  // emission for this session, or -1 if none. Enforces
+  // MESH_WORKER_STALL_REFIRE_COOLDOWN_MS between successive emissions across
+  // anchor re-arms (the per-anchor guard only covers a single continuous stall).
+  meshStallLastFiredAt = -1;
   // FALSE-IDLE continuity epoch: monotonically bumped on EVERY entry into a busy
   // phase (→generating or →waiting_approval). The completedDebouncePending snapshots
   // this value at arm time (busyEpochAtArm); the flush guard requires it UNCHANGED
@@ -48981,43 +49014,62 @@ var CliProviderInstance = class _CliProviderInstance {
    * ProviderInstanceManager's existing 5s onTick loop (NO new timer) — see
    * ProviderInstanceManager.startTicking. Reuses the adapter's raw-PTY-output
    * clock (lastOutputAt, bumped on every output chunk) as the sole signal: if a
-   * live worker's screen has been byte-for-byte unchanged for
-   * MESH_WORKER_STALL_THRESHOLD_MS (180s), fire ONE informational
-   * monitor:no_progress event down the existing task_stalled ledger +
-   * pendingCoordinatorEvent path.
+   * live worker's screen has been byte-for-byte unchanged past the turn-scoped
+   * threshold (below), fire ONE informational monitor:no_progress event down the
+   * existing task_stalled ledger + pendingCoordinatorEvent path.
    *
-   * Deliberately status-agnostic: it does NOT read getStatus()'s reported status
-   * (which would couple it to the generating-only StatusMonitor and the
-   * idle-timeout FSM). A normally-idle worker CAN trip this after 3 quiet
-   * minutes; that is accepted and surfaced as an informational stall (NOT a
-   * failure/auto-restart) so the coordinator judges. getStatus/getState are NOT
-   * called here, so status heartbeats never move the stall anchor.
+   * The reported status is read for TWO bounded purposes only — it does NOT
+   * suppress the fire (sticky-status blindness would hide a real wedge):
+   *   • Fix B (anchor re-arm on turn end): the FSM's completion/idle transition
+   *     never touches the stall anchor, so a completed worker that goes idle would
+   *     otherwise keep counting from its LAST pre-completion output and false-fire
+   *     in the quiet valley right after finishing. We detect the turn-active edge
+   *     (hasAdapterPendingResponse()) and, on active → inactive, re-arm the anchor
+   *     to `now` so the post-completion idle valley starts a fresh clock.
+   *   • Fix C (turn-scoped threshold): while a turn is genuinely in flight the bar
+   *     is raised (MESH_WORKER_STALL_TURN_THRESHOLD_MS) to absorb long normal
+   *     thinking gaps; outside a turn the tighter idle bound applies. This is a
+   *     RAISE, not a skip — a real mid-turn wedge still fires late at the turn bound.
    *
    * Anchoring: the episode arms against the current lastOutputAt; a worker that
    * has emitted nothing yet (lastOutputAt === 0) anchors on this.startedAt (spawn
    * time) so a silent spawn is still caught. Any new output re-arms the anchor
    * and clears the emitted flag, so one continuous stall emits at most once and a
-   * later stall re-arms cleanly.
+   * later stall re-arms cleanly. Fix E adds a per-session refire cooldown so a
+   * dribble of one-byte-per-few-minutes output cannot page the coordinator on
+   * every re-arm.
    */
   checkMeshWorkerStall(now = Date.now()) {
     if (!this.isMeshWorkerSession()) {
-      this.meshStallAnchorAt = -1;
-      this.meshStallEmittedForAnchor = false;
+      this.resetMeshStallEpisode();
       return;
     }
     if (typeof this.adapter.isAlive === "function" && !this.adapter.isAlive()) {
-      this.meshStallAnchorAt = -1;
-      this.meshStallEmittedForAnchor = false;
+      this.resetMeshStallEpisode();
       return;
     }
     let lastOutputAt;
+    let observedStatus = "unknown";
     try {
       const status = this.adapter.getStatus({ allowParse: false });
       lastOutputAt = typeof status?.lastOutputAt === "number" && Number.isFinite(status.lastOutputAt) ? status.lastOutputAt : 0;
+      if (typeof status?.status === "string" && status.status) observedStatus = status.status;
     } catch {
       return;
     }
+    let turnActive = false;
+    try {
+      turnActive = this.hasAdapterPendingResponse();
+    } catch {
+    }
+    const turnEnded = this.meshStallTurnActiveLast === true && !turnActive;
+    this.meshStallTurnActiveLast = turnActive;
     const anchor = lastOutputAt > 0 ? lastOutputAt : this.startedAt;
+    if (turnEnded && this.meshStallAnchorAt !== -1) {
+      this.meshStallAnchorAt = Math.max(anchor, now);
+      this.meshStallEmittedForAnchor = false;
+      return;
+    }
     if (this.meshStallAnchorAt === -1) {
       this.meshStallAnchorAt = anchor;
       this.meshStallEmittedForAnchor = false;
@@ -49029,15 +49081,14 @@ var CliProviderInstance = class _CliProviderInstance {
       return;
     }
     if (this.meshStallEmittedForAnchor) return;
+    const threshold = turnActive ? _CliProviderInstance.MESH_WORKER_STALL_TURN_THRESHOLD_MS : _CliProviderInstance.MESH_WORKER_STALL_IDLE_THRESHOLD_MS;
     const stalledMs = now - this.meshStallAnchorAt;
-    if (stalledMs < _CliProviderInstance.MESH_WORKER_STALL_THRESHOLD_MS) return;
+    if (stalledMs < threshold) return;
     this.meshStallEmittedForAnchor = true;
-    let observedStatus = "unknown";
-    try {
-      const s2 = this.adapter.getStatus({ allowParse: false })?.status;
-      if (typeof s2 === "string" && s2) observedStatus = s2;
-    } catch {
+    if (this.meshStallLastFiredAt >= 0 && now - this.meshStallLastFiredAt < _CliProviderInstance.MESH_WORKER_STALL_REFIRE_COOLDOWN_MS) {
+      return;
     }
+    this.meshStallLastFiredAt = now;
     if (this.isMeshWorkerSession()) {
       traceMeshEventStage("fired", this.meshTraceCtx("monitor:no_progress"), "mesh_worker_stall_watchdog");
     }
@@ -49057,6 +49108,19 @@ var CliProviderInstance = class _CliProviderInstance {
       taskId: this.completingTurnTaskId()
     });
   }
+  /**
+   * FALSE-STALL-WATCHDOG-OVERFIRE: drop the entire stall episode for this session.
+   * Called when the session is no longer a mesh worker or the PTY is dead — the
+   * next live tick re-arms a fresh episode. Clears the fix-B turn-edge state and
+   * the fix-E refire cooldown alongside the base anchor so a re-armed session
+   * starts with a clean slate (a restart is not throttled by a prior stall).
+   */
+  resetMeshStallEpisode() {
+    this.meshStallAnchorAt = -1;
+    this.meshStallEmittedForAnchor = false;
+    this.meshStallTurnActiveLast = void 0;
+    this.meshStallLastFiredAt = -1;
+  }
   /**
    * AUTOAPPROVE-FLAP-RECUR (Fix A+B): how long a busy blip / modal scroll-out may
    * persist before the in-progress settle gate is torn down. For a delegated