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

package/dist/index.js

@@ -33262,10 +33262,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      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);
+      const commit = readInjected(true ? "200c050e12084938c52f329a7531fd59a7cf5064" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "200c050e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.28-rc.13" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-26T08:48:28.825Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -83336,18 +83336,20 @@ ${body}
       // 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;
-      // KIMI-MESH-COMPLETION-EMIT (axis 1): the native-source transcript progress
-      // fingerprint (record count + source mtime) observed the LAST time the stall
-      // watchdog checked a native-source provider (transcriptAuthority=provider — e.g.
-      // kimi wire.jsonl). A pure-PTY native-source worker running a long, screen-quiet
-      // tool (no viewport bytes for minutes) looks stalled by the lastOutputAt clock
-      // even though its transcript file is still growing. Before firing the stall, we
-      // compare the current transcript fingerprint against this snapshot; if the
-      // transcript advanced, the "stall" is a false positive of PTY-render stasis, so
-      // we re-arm the anchor instead of paging the coordinator (whose no_progress
-      // handling can lead to the worker being stopped mid-work → completion never
-      // emitted). null = not yet sampled for this session/anchor.
-      meshStallNativeTranscriptSample = null;
+      // KIMI-MESH-COMPLETION-EMIT (axis 1) — TX-FSM Stage 1: whether the stall
+      // watchdog has consumed a usable native-transcript SIGNAL SNAPSHOT for the
+      // current stall episode. A pure-PTY native-source worker running a long,
+      // screen-quiet tool (no viewport bytes for minutes) looks stalled by the
+      // lastOutputAt clock even though its transcript file is still growing.
+      // Before firing the stall, the watchdog consults the shared
+      // TranscriptSignalSource's in_turn_progress signal; if the transcript is
+      // advancing, the "stall" is a false positive of PTY-render stasis, so we
+      // re-arm the anchor instead of paging the coordinator (whose no_progress
+      // handling can lead to the worker being stopped mid-work → completion
+      // never emitted). The FIRST usable sample of an episode still re-arms
+      // unconditionally (no episode-scoped baseline exists yet to prove stasis
+      // against) — the historical `!prev → advanced` semantics, preserved.
+      meshStallTranscriptSignalSampled = false;
       // 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
@@ -84145,10 +84147,17 @@ ${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. */
+      /** TX-FSM: lazily-created transcript signal normalizer. Fed ONLY by
+       *  transcript reads this instance already performs — it adds zero I/O.
+       *  Stage 0: its output was a pure shadow observation for the FSM driver.
+       *  Stage 1: the instance's own stall/growth-hold judgments consume the
+       *  normalized snapshot too (single source of truth). */
       transcriptSignalSource = null;
+      /** TX-FSM Stage 1: the latest snapshot the source produced (set inside
+       *  publishTranscriptSignalObservation). Consumed the same tick by the
+       *  stall-path / growth-hold judgments via probeNativeTranscriptSignals —
+       *  never treated as fresh across ticks. */
+      lastTranscriptSignalSnapshot = null;
       /**
        * The final assistant summary of the last completed turn, cached at
        * completion-emit time. For a native-source provider (antigravity) whose
@@ -84326,19 +84335,21 @@ ${body}
         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.
+       * TX-FSM: normalize the transcript read that JUST happened into a
+       * SignalSnapshot. Stage 0 injected it into the FSM driver as a pure
+       * shadow observation (daemon → SpecCliAdapter → FsmDriver); Stage 1
+       * additionally caches it (lastTranscriptSignalSnapshot) so the instance's
+       * OWN stall/growth-hold judgments consume the SAME normalized snapshot
+       * instead of re-running private transcript scans. 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 source update runs regardless of the adapter hook so a
+       * non-spec provider still produces the instance-side snapshot (the FSM
+       * injection is simply skipped there). Fail-open end to end — 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({
@@ -84348,7 +84359,8 @@ ${body}
               profile: resolveTranscriptAuthorityProfile(this.provider),
               turnStartedAt: () => {
                 const t = this.adapter?.currentTurnStartedAt;
-                return typeof t === "number" && Number.isFinite(t) ? t : void 0;
+                if (typeof t === "number" && Number.isFinite(t)) return t;
+                return this.meshTaskInjectedAt > 0 ? this.meshTaskInjectedAt : void 0;
               },
               // Reuse the exact completion machinery (I1) for the
               // final_assistant_present signal rather than duplicating
@@ -84360,7 +84372,11 @@ ${body}
           const snapshot = this.transcriptSignalSource.update(
             { messages, probe: this.lastExternalCompletionProbe, error: error48 }
           );
-          adapter.setSignalObservation(snapshot);
+          this.lastTranscriptSignalSnapshot = snapshot;
+          const adapter = this.adapter;
+          if (typeof adapter?.setSignalObservation === "function") {
+            adapter.setSignalObservation(snapshot);
+          }
         } catch {
         }
       }
@@ -84853,17 +84869,17 @@ ${body}
         const threshold = turnActive ? _CliProviderInstance.MESH_WORKER_STALL_TURN_THRESHOLD_MS : _CliProviderInstance.MESH_WORKER_STALL_IDLE_THRESHOLD_MS;
         const stalledMs = now - this.meshStallAnchorAt;
         if (stalledMs < threshold) return;
-        const nativeSample = this.sampleNativeTranscriptProgress();
-        if (nativeSample) {
-          const prev = this.meshStallNativeTranscriptSample;
-          const advanced = !prev || nativeSample.msgCount > prev.msgCount || nativeSample.sourceMtimeMs > prev.sourceMtimeMs;
-          this.meshStallNativeTranscriptSample = nativeSample;
-          if (advanced) {
+        const transcriptSignals = this.probeNativeTranscriptSignals();
+        if (transcriptSignals?.snapshot?.available === true) {
+          const firstSampleThisEpisode = !this.meshStallTranscriptSignalSampled;
+          this.meshStallTranscriptSignalSampled = true;
+          const signalDetail = transcriptSignals.snapshot.detail;
+          if (firstSampleThisEpisode || transcriptSignals.snapshot.signals.in_turn_progress === true) {
             if (this.isMeshWorkerSession()) {
               traceMeshEventDrop(
                 "mesh_worker_stall_transcript_advancing",
                 this.meshTraceCtx("monitor:no_progress"),
-                `msgCount=${nativeSample.msgCount} sourceMtime=${nativeSample.sourceMtimeMs} (PTY quiet ${Math.round(stalledMs / 1e3)}s but transcript advancing)`
+                `msgCount=${signalDetail.msgCount} sourceMtime=${signalDetail.sourceMtimeMs} (PTY quiet ${Math.round(stalledMs / 1e3)}s but transcript advancing)`
               );
             }
             this.meshStallAnchorAt = now;
@@ -84871,7 +84887,7 @@ ${body}
             return;
           }
         }
-        if (this.tryReconcileTranscriptCompletionForStall(observedStatus)) {
+        if (this.tryReconcileTranscriptCompletionForStall(observedStatus, transcriptSignals)) {
           this.meshStallEmittedForAnchor = true;
           return;
         }
@@ -84911,38 +84927,45 @@ ${body}
         this.meshStallEmittedForAnchor = false;
         this.meshStallTurnActiveLast = void 0;
         this.meshStallLastFiredAt = -1;
-        this.meshStallNativeTranscriptSample = null;
+        this.meshStallTranscriptSignalSampled = false;
       }
+      /** The result of one native-transcript signal probe: the normalized
+       *  snapshot the shared TranscriptSignalSource produced from the read, and
+       *  the very messages it was normalized from (so a judgment site can pull
+       *  a payload — e.g. the final summary — from the SAME read with zero
+       *  added I/O). */
       /**
-       * KIMI-MESH-COMPLETION-EMIT (axis 1). For a native-source provider
-       * (transcriptAuthority=provider — its authoritative history is an on-disk
-       * transcript file, e.g. kimi's wire.jsonl), sample the transcript's current
-       * progress fingerprint (record count + source-file mtime) WITHOUT parsing the
-       * PTY. Used by the stall watchdog to distinguish "PTY render is quiet but the
-       * worker is still doing long tool work (transcript growing)" from a genuine
-       * wedge. Returns null for a pure-PTY provider (no native source) or when the
-       * source cannot be resolved this tick — the caller then falls back to the
-       * unchanged lastOutputAt-only judgment.
+       * TX-FSM Stage 1 — the single native-transcript signal probe (replaces
+       * the Stage-0 sampleNativeTranscriptProgress fingerprint sampler). For a
+       * native-source provider (its authoritative history is an on-disk
+       * transcript file, e.g. kimi's wire.jsonl), perform the read this
+       * judgment point already owns — SAME cadence as before, one
+       * readExternalCompletionMessages() per call, never more — and return the
+       * NORMALIZED SignalSnapshot the shared TranscriptSignalSource produced
+       * from it (publishTranscriptSignalObservation runs inside the read), plus
+       * the messages that read returned. Judgment sites (the stall watchdog's
+       * transcript-advancing axis, the completion growth-hold, the stall-path
+       * completion rescue) consume the snapshot's SIGNALS instead of running
+       * their own fingerprint/freshness/final-assistant scans — one source of
+       * truth for "what does the transcript say right now".
        *
-       * Generalized on the provider's native-source flag, NOT a hardcoded provider
-       * type, so every current and future pure-PTY long-tool native-source provider
-       * benefits. Cheap enough for the stall path: it runs only at the stall threshold
-       * (≥180s of PTY stasis), never on the routine 5s tick.
+       * Class gating goes through resolveTranscriptAuthorityProfile ONLY.
+       * Returns null for a non-native-source class (nothing to signal from) and
+       * a null snapshot when the read threw — callers keep their fail-open
+       * fallbacks ("couldn't tell" never blocks an idle verdict and never
+       * fabricates a completion). Cheap enough for the stall path: it runs
+       * only at the stall threshold (≥180s of PTY stasis) or during an armed
+       * completion-debounce retry, never on the routine 5s tick.
        */
-      sampleNativeTranscriptProgress() {
-        if (!isNativeSourceCanonicalHistory(this.provider?.nativeHistory)) return null;
+      probeNativeTranscriptSignals() {
+        if (resolveTranscriptAuthorityProfile(this.provider).class !== "native-source") return null;
         let messages = null;
         try {
           messages = this.readExternalCompletionMessages();
         } catch {
-          return null;
+          return { snapshot: null, messages: null };
         }
-        const probe = this.lastExternalCompletionProbe;
-        if (!probe) return null;
-        return {
-          msgCount: typeof probe.msgCount === "number" ? probe.msgCount : Array.isArray(messages) ? messages.length : 0,
-          sourceMtimeMs: typeof probe.sourceMtimeMs === "number" ? probe.sourceMtimeMs : 0
-        };
+        return { snapshot: this.lastTranscriptSignalSnapshot, messages };
       }
       /**
        * KIMI-MESH-COMPLETION-EMIT (axis 2). Last-chance completion emit for a mesh
@@ -85031,8 +85054,22 @@ ${body}
        * false for a daemon-owned provider and for a genuinely mid-turn / wedged
        * worker with no in-turn final assistant, so a real stall still fires
        * unchanged. Evidence bar is identical to flushMeshCompletionBeforeCleanup.
+       *
+       * TX-FSM Stage 1 (FIX 3 probe delegation): for a native-source class the
+       * completion VERDICT is the shared TranscriptSignalSource's
+       * final_assistant_present signal, normalized from the ONE transcript read
+       * the stall watchdog already performed this tick (passed in as
+       * `transcriptSignals`) — not a second private read + scan. The emit
+       * payload (finalSummary) is extracted from the SAME messages the signal
+       * was normalized from, with the SAME turn boundary the legacy path used,
+       * so the extraction re-proves the turn scope the signal checked. Fail-open
+       * both ways: no usable snapshot (read failed / unresolved / a pure-PTY
+       * class, which has no native signal by construction) → the legacy
+       * class-appropriate evidence path (completionFinalSummary), unchanged; and
+       * a present-but-unextractable signal yields false rather than a
+       * payload-less emit.
        */
-      tryReconcileTranscriptCompletionForStall(observedStatus) {
+      tryReconcileTranscriptCompletionForStall(observedStatus, transcriptSignals) {
         const profile = resolveTranscriptAuthorityProfile(this.provider);
         if (profile.class === "daemon-owned") return false;
         if (observedStatus !== "idle") return false;
@@ -85050,10 +85087,19 @@ ${body}
           parsedMessages = void 0;
         }
         let finalSummary;
-        try {
-          finalSummary = this.completionFinalSummary(parsedMessages, turnStartedAt);
-        } catch {
-          finalSummary = void 0;
+        const signalSnapshot = transcriptSignals?.snapshot;
+        if (profile.class === "native-source" && signalSnapshot?.available === true) {
+          if (signalSnapshot.signals.final_assistant_present !== true) return false;
+          finalSummary = extractFinalSummaryFromMessagesAfter(
+            Array.isArray(transcriptSignals?.messages) ? transcriptSignals.messages : [],
+            turnStartedAt
+          ) || void 0;
+        } else {
+          try {
+            finalSummary = this.completionFinalSummary(parsedMessages, turnStartedAt);
+          } catch {
+            finalSummary = void 0;
+          }
         }
         if (!finalSummary) return false;
         const diagnosticSource = profile.class === "pure-pty" ? "stall_pure_pty_transcript_completion" : "stall_native_source_transcript_completion";
@@ -85320,24 +85366,25 @@ ${body}
           const isTranscriptEvidenceGate = block2.allowTimeout === true;
           LOG2.debug("CLI", `[${this.type}] finalization block: reason=${blockReason} terminal=${block2.terminal} allowTimeout=${isTranscriptEvidenceGate} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
           if (blockReason === "missing_final_assistant" && block2.noExternalTranscriptSource === true) {
-            let nativeSample = null;
+            let growthSnapshot = null;
             try {
-              nativeSample = this.sampleNativeTranscriptProgress();
+              growthSnapshot = this.probeNativeTranscriptSignals()?.snapshot ?? null;
             } catch {
-              nativeSample = null;
+              growthSnapshot = null;
             }
-            const sourceMtimeMs = nativeSample?.sourceMtimeMs ?? 0;
-            if (nativeSample && sourceMtimeMs > 0 && Date.now() - sourceMtimeMs < MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS) {
+            if (growthSnapshot?.available === true && growthSnapshot.signals.transcript_growing === true) {
+              const growthDetail = growthSnapshot.detail;
+              const mtimeAgeMs = growthDetail.ageMs ?? 0;
               if (pending.loggedBlockReason !== "native_transcript_advancing") {
-                LOG2.info("CLI", `[${this.type}] holding pending completed (native_transcript_advancing: msgCount=${nativeSample.msgCount} mtimeAge=${Date.now() - sourceMtimeMs}ms < ${MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS}ms) \u2014 transcript still growing, screen-idle verdict not trusted`);
+                LOG2.info("CLI", `[${this.type}] holding pending completed (native_transcript_advancing: msgCount=${growthDetail.msgCount} mtimeAge=${mtimeAgeMs}ms < ${MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS}ms) \u2014 transcript still growing, screen-idle verdict not trusted`);
                 if (this.isMeshWorkerSession()) {
-                  traceMeshEventDrop("completion_gate_hold", this.meshTraceCtx(), `native_transcript_advancing msgCount=${nativeSample.msgCount} mtimeAge=${Date.now() - sourceMtimeMs}ms`);
+                  traceMeshEventDrop("completion_gate_hold", this.meshTraceCtx(), `native_transcript_advancing msgCount=${growthDetail.msgCount} mtimeAge=${mtimeAgeMs}ms`);
                 }
                 if (this.completionTraceOn()) this.recordCompletionGateTrace("hold", {
                   blockReason: "native_transcript_advancing",
                   latestVisibleStatus,
-                  msgCount: nativeSample.msgCount,
-                  sourceMtimeAgeMs: Date.now() - sourceMtimeMs,
+                  msgCount: growthDetail.msgCount,
+                  sourceMtimeAgeMs: mtimeAgeMs,
                   growthQuietMs: MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS,
                   waitedMs
                 });