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

package/dist/index.js

@@ -30217,10 +30217,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "be22dd93c4d346e18a1c16b2d451c0b3d085e5e3" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "be22dd93" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:59.099Z" : 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 version2 = 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:23:47.341Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -77451,9 +77451,30 @@ ${body}
       // 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 = [];
@@ -77477,6 +77498,18 @@ ${body}
       // -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
@@ -78728,43 +78761,62 @@ ${body}
        * 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;
@@ -78776,15 +78828,14 @@ ${body}
           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");
         }
@@ -78804,6 +78855,19 @@ ${body}
           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