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

package/dist/index.mjs

@@ -786,10 +786,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "5cd04eec1e043188c3ef97821372ad5ff615cd04" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "5cd04eec" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:19.328Z" : 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 version = 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:47:54.956Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -50437,18 +50437,20 @@ var CliProviderInstance = class _CliProviderInstance {
   // 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
@@ -51246,10 +51248,17 @@ var CliProviderInstance = class _CliProviderInstance {
   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
@@ -51427,19 +51436,21 @@ var CliProviderInstance = class _CliProviderInstance {
     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, error = false) {
-    const adapter = this.adapter;
-    if (typeof adapter?.setSignalObservation !== "function") return;
     try {
       if (!this.transcriptSignalSource) {
         this.transcriptSignalSource = new TranscriptSignalSource({
@@ -51449,7 +51460,8 @@ var CliProviderInstance = class _CliProviderInstance {
           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
@@ -51461,7 +51473,11 @@ var CliProviderInstance = class _CliProviderInstance {
       const snapshot = this.transcriptSignalSource.update(
         { messages, probe: this.lastExternalCompletionProbe, error }
       );
-      adapter.setSignalObservation(snapshot);
+      this.lastTranscriptSignalSnapshot = snapshot;
+      const adapter = this.adapter;
+      if (typeof adapter?.setSignalObservation === "function") {
+        adapter.setSignalObservation(snapshot);
+      }
     } catch {
     }
   }
@@ -51954,17 +51970,17 @@ var CliProviderInstance = class _CliProviderInstance {
     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;
@@ -51972,7 +51988,7 @@ var CliProviderInstance = class _CliProviderInstance {
         return;
       }
     }
-    if (this.tryReconcileTranscriptCompletionForStall(observedStatus)) {
+    if (this.tryReconcileTranscriptCompletionForStall(observedStatus, transcriptSignals)) {
       this.meshStallEmittedForAnchor = true;
       return;
     }
@@ -52012,38 +52028,45 @@ var CliProviderInstance = class _CliProviderInstance {
     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
@@ -52132,8 +52155,22 @@ var CliProviderInstance = class _CliProviderInstance {
    * 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;
@@ -52151,10 +52188,19 @@ var CliProviderInstance = class _CliProviderInstance {
       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";
@@ -52421,24 +52467,25 @@ var CliProviderInstance = class _CliProviderInstance {
       const isTranscriptEvidenceGate = block2.allowTimeout === true;
       LOG.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") {
-            LOG.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`);
+            LOG.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
             });