@adhdev/daemon-standalone 1.0.28-rc.25 → 1.0.28-rc.26

package/dist/index.js

@@ -33311,10 +33311,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "ebb85401b79dca73fefef3c6d25259dd39a4f894" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "ebb85401" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28-rc.25" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-29T12:45:19.679Z" : void 0);
+      const commit = readInjected(true ? "6eb8c9b32842573a3be53f868c84feb02358ac43" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "6eb8c9b3" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.28-rc.26" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-29T13:55:59.471Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -43586,8 +43586,8 @@ Next step: ${nextStep}`;
             }
             this.maybeCheckpointWal();
           }
-          countTurnOutboxByStatus() {
-            const rows = this.db.prepare("SELECT status, COUNT(*) AS n FROM mesh_turn_outbox GROUP BY status").all();
+          countTurnOutboxByStatus(meshId) {
+            const rows = meshId ? this.db.prepare("SELECT status, COUNT(*) AS n FROM mesh_turn_outbox WHERE mesh_id = ? GROUP BY status").all(meshId) : this.db.prepare("SELECT status, COUNT(*) AS n FROM mesh_turn_outbox GROUP BY status").all();
             const out = {};
             for (const r of rows) out[r.status] = r.n;
             return out;
@@ -57271,6 +57271,126 @@ ${cleanBody}`;
         recentReadDebugSignatureBySession = /* @__PURE__ */ new Map();
       }
     });
+    function readRecord6(value) {
+      return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+    }
+    function readFiniteNumber(value) {
+      return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+    }
+    function identitiesMatch(metadataEvent, evidence, attempt, eventSessionId) {
+      const taskId = readNonEmptyString(metadataEvent.taskId);
+      const attemptId = readNonEmptyString(metadataEvent.attemptId);
+      const evidenceTaskId = readNonEmptyString(evidence.taskId);
+      const evidenceAttemptId = readNonEmptyString(evidence.attemptId);
+      const evidenceSessionId = readNonEmptyString(evidence.sessionId);
+      const eventNonce = readFiniteNumber(metadataEvent.dispatchNonce);
+      const evidenceNonce = readFiniteNumber(evidence.dispatchNonce);
+      if (!taskId || !attemptId || !eventSessionId) return false;
+      if (taskId !== attempt.taskId || attemptId !== attempt.attemptId) return false;
+      if (evidenceTaskId !== taskId || evidenceAttemptId !== attemptId) return false;
+      if (!evidenceSessionId || !sessionIdsEquivalent(evidenceSessionId, eventSessionId)) return false;
+      if (!attempt.sessionId || !sessionIdsEquivalent(attempt.sessionId, eventSessionId)) return false;
+      if (typeof attempt.dispatchNonce !== "number" || eventNonce !== attempt.dispatchNonce || evidenceNonce !== attempt.dispatchNonce) return false;
+      return true;
+    }
+    function evaluateAuthoritativeTranscriptCompletion(args) {
+      const { metadataEvent, eventSessionId, attempt } = args;
+      const nowMs = args.nowMs ?? Date.now();
+      if (!attempt || attempt.terminalOutcome || isTerminalTurnStage(attempt.stage)) {
+        return { authoritative: false, reason: "attempt_missing_or_terminal" };
+      }
+      if (isWeakCompletionEvidence(metadataEvent)) {
+        return { authoritative: false, reason: "weak_evidence" };
+      }
+      const diagnostic = readRecord6(metadataEvent.completionDiagnostic);
+      const evidence = readRecord6(diagnostic?.transcriptEvidence);
+      if (diagnostic?.finalAssistantPresent !== true || diagnostic?.cleanPath !== true || diagnostic?.evidenceWeak !== false || !evidence) {
+        return { authoritative: false, reason: "not_clean_strong_evidence" };
+      }
+      if (evidence.version !== 1 || evidence.kind !== "final_assistant" || evidence.cleanPath !== true || evidence.weak !== false) {
+        return { authoritative: false, reason: "invalid_evidence_contract" };
+      }
+      const authorityClass = readNonEmptyString(evidence.authorityClass);
+      const timing = readNonEmptyString(evidence.timing);
+      if (authorityClass !== "native-source" && authorityClass !== "pure-pty" || timing !== "floor" && timing !== "hold" && timing !== "immediate") {
+        return { authoritative: false, reason: "non_transcript_authority_profile" };
+      }
+      const evidenceSource = readNonEmptyString(diagnostic.finalAssistantEvidenceSource);
+      if (authorityClass === "native-source" && evidenceSource !== "external-native" || authorityClass === "pure-pty" && evidenceSource !== "parsed") {
+        return { authoritative: false, reason: "evidence_source_profile_mismatch" };
+      }
+      const finalSummary = readNonEmptyString(metadataEvent.finalSummary);
+      const finalContentLength = readFiniteNumber(evidence.finalContentLength) ?? 0;
+      if (!finalSummary || finalContentLength <= 0) {
+        return { authoritative: false, reason: "empty_final_content" };
+      }
+      if (!identitiesMatch(metadataEvent, evidence, attempt, eventSessionId)) {
+        return { authoritative: false, reason: "causal_identity_mismatch" };
+      }
+      const observedAt = readFiniteNumber(evidence.observedAt);
+      const eventTimestamp = readFiniteNumber(metadataEvent.timestamp);
+      const turnStartedAt = readFiniteNumber(evidence.turnStartedAt);
+      const acceptedAt = Date.parse(attempt.acceptedAt || attempt.createdAt);
+      if (!observedAt || !eventTimestamp || !turnStartedAt) {
+        return { authoritative: false, reason: "missing_evidence_timestamp" };
+      }
+      if (observedAt < turnStartedAt || eventTimestamp < turnStartedAt) {
+        return { authoritative: false, reason: "pre_turn_evidence" };
+      }
+      if (Number.isFinite(acceptedAt) && (observedAt < acceptedAt - 2e3 || eventTimestamp < acceptedAt - 2e3)) {
+        return { authoritative: false, reason: "pre_dispatch_evidence" };
+      }
+      if (observedAt > nowMs + 2e3 || eventTimestamp > nowMs + 2e3 || nowMs - observedAt > AUTHORITATIVE_COMPLETION_MAX_AGE_MS || nowMs - eventTimestamp > AUTHORITATIVE_COMPLETION_MAX_AGE_MS) {
+        return { authoritative: false, reason: "stale_evidence_timestamp" };
+      }
+      const attemptUpdatedAt = Date.parse(attempt.updatedAt);
+      return {
+        authoritative: true,
+        evidenceObservedAt: observedAt,
+        attemptStage: attempt.stage,
+        attemptUpdatedAt: Number.isFinite(attemptUpdatedAt) ? attemptUpdatedAt : null
+      };
+    }
+    function authoritativeEvidenceOutranksLivePending(authority, live) {
+      if (!authority.authoritative || live.pending !== true) return false;
+      if (live.kind !== "modal" && live.kind !== "adapter") return false;
+      if (live.kind === "modal" && (authority.attemptStage === "waiting_approval" || authority.attemptStage === "waiting_choice") && authority.attemptUpdatedAt !== null && authority.attemptUpdatedAt <= authority.evidenceObservedAt) {
+        return true;
+      }
+      return typeof live.observedAt === "number" && Number.isFinite(live.observedAt) && live.observedAt <= authority.evidenceObservedAt;
+    }
+    function completionEligibleForLiveStateRetry(args) {
+      const { metadataEvent, eventSessionId, attempt } = args;
+      const nowMs = args.nowMs ?? Date.now();
+      if (!evaluateAuthoritativeTranscriptCompletion({
+        metadataEvent,
+        eventSessionId,
+        attempt,
+        nowMs
+      }).authoritative) return false;
+      if (!attempt || attempt.terminalOutcome || isTerminalTurnStage(attempt.stage)) return false;
+      const taskId = readNonEmptyString(metadataEvent.taskId);
+      const attemptId = readNonEmptyString(metadataEvent.attemptId);
+      const nonce = readFiniteNumber(metadataEvent.dispatchNonce);
+      if (!taskId || taskId !== attempt.taskId || attemptId !== attempt.attemptId) return false;
+      if (!attempt.sessionId || !sessionIdsEquivalent(attempt.sessionId, eventSessionId)) return false;
+      if (typeof attempt.dispatchNonce !== "number" || nonce !== attempt.dispatchNonce) return false;
+      const eventTimestamp = readFiniteNumber(metadataEvent.timestamp);
+      const acceptedAt = Date.parse(attempt.acceptedAt || attempt.createdAt);
+      if (!eventTimestamp || eventTimestamp > nowMs + 2e3 || nowMs - eventTimestamp > AUTHORITATIVE_COMPLETION_MAX_AGE_MS) return false;
+      if (Number.isFinite(acceptedAt) && eventTimestamp < acceptedAt - 2e3) return false;
+      return true;
+    }
+    var AUTHORITATIVE_COMPLETION_MAX_AGE_MS;
+    var init_mesh_completion_live_gate = __esm2({
+      "src/mesh/mesh-completion-live-gate.ts"() {
+        "use strict";
+        init_dist();
+        init_mesh_turn_ledger();
+        init_mesh_events_utils();
+        AUTHORITATIVE_COMPLETION_MAX_AGE_MS = 6e4;
+      }
+    });
     function bootstrapQueueTaskCountsAsHandled(task, bootstrapNodeId, nowMs) {
       if (!meshNodeIdMatches({ id: task.targetNodeId }, bootstrapNodeId)) return false;
       if (task.status === "assigned") return true;
@@ -57287,6 +57407,111 @@ ${cleanBody}`;
       const machineId = readNonEmptyString(loadConfig2().machineId);
       return expandDaemonIdForms([statusInstanceId, machineId]);
     }
+    function heldCompletionKey(meshId, taskId, attemptId, sessionId, nonce) {
+      return `${meshId}${taskId}${attemptId}${sessionId}${nonce}`;
+    }
+    function readLivePendingEvidence(instance) {
+      try {
+        if (typeof instance?.getLiveTurnPendingEvidence === "function") {
+          const evidence = instance.getLiveTurnPendingEvidence();
+          if (evidence && typeof evidence === "object") {
+            return {
+              pending: evidence.pending === true,
+              ...evidence.kind === "adapter" || evidence.kind === "modal" || evidence.kind === "transcript_tool" ? { kind: evidence.kind } : {},
+              ...typeof evidence.observedAt === "number" && Number.isFinite(evidence.observedAt) ? { observedAt: evidence.observedAt } : {}
+            };
+          }
+        }
+        if (typeof instance?.hasLiveTurnPendingEvidence === "function") {
+          return { pending: instance.hasLiveTurnPendingEvidence() === true };
+        }
+      } catch {
+      }
+      return { pending: false };
+    }
+    function scheduleHeldLiveStateCompletionDrain() {
+      if (heldLiveStateCompletionTimer || heldLiveStateCompletions.size === 0) return;
+      heldLiveStateCompletionTimer = setTimeout(() => {
+        heldLiveStateCompletionTimer = null;
+        drainHeldLiveStateCompletions();
+      }, MID_TURN_COMPLETION_HOLD_RETRY_MS);
+      heldLiveStateCompletionTimer.unref?.();
+    }
+    function drainHeldLiveStateCompletions(nowMs = Date.now()) {
+      for (const [key2, held] of heldLiveStateCompletions) {
+        if (nowMs < held.nextCheckAt) continue;
+        if (nowMs >= held.expiresAt) {
+          heldLiveStateCompletions.delete(key2);
+          continue;
+        }
+        const attempt = MeshRuntimeStore.getInstance().getCurrentTurnAttempt(held.meshId, held.taskId);
+        const identityStillCurrent = !!attempt && !attempt.terminalOutcome && attempt.attemptId === held.attemptId && sessionIdsEquivalent(attempt.sessionId, held.sessionId) && attempt.dispatchNonce === held.dispatchNonce;
+        if (!identityStillCurrent) {
+          heldLiveStateCompletions.delete(key2);
+          continue;
+        }
+        const liveInstance = held.components.instanceManager?.getInstance?.(held.sessionId);
+        if (!liveInstance) {
+          heldLiveStateCompletions.delete(key2);
+          continue;
+        }
+        const live = readLivePendingEvidence(liveInstance);
+        if (live.pending) {
+          held.nextCheckAt = nowMs + MID_TURN_COMPLETION_HOLD_RETRY_MS;
+          continue;
+        }
+        heldLiveStateCompletions.delete(key2);
+        injectMeshSystemMessage(held.components, {
+          meshId: held.meshId,
+          sourceInstanceId: held.sourceInstanceId,
+          nodeId: held.nodeId,
+          nodeLabel: held.nodeLabel,
+          event: "agent:generating_completed",
+          metadataEvent: {
+            event: "agent:generating_completed",
+            instanceId: held.sessionId,
+            targetSessionId: held.sessionId,
+            taskId: held.taskId,
+            attemptId: held.attemptId,
+            dispatchNonce: held.dispatchNonce,
+            timestamp: held.eventTimestamp,
+            ...held.providerType ? { providerType: held.providerType } : {},
+            completionDiagnostic: {
+              source: "mid_turn_live_state_retry",
+              contentFreeRetry: true
+            }
+          }
+        });
+      }
+      scheduleHeldLiveStateCompletionDrain();
+    }
+    function holdCompletionForLiveStateRetry(components, args, eventSessionId, nowMs) {
+      const taskId = readNonEmptyString(args.metadataEvent.taskId);
+      const attemptId = readNonEmptyString(args.metadataEvent.attemptId);
+      const dispatchNonce = typeof args.metadataEvent.dispatchNonce === "number" ? args.metadataEvent.dispatchNonce : NaN;
+      const eventTimestamp = typeof args.metadataEvent.timestamp === "number" ? args.metadataEvent.timestamp : NaN;
+      if (!taskId || !attemptId || !Number.isFinite(dispatchNonce) || !Number.isFinite(eventTimestamp)) return false;
+      const key2 = heldCompletionKey(args.meshId, taskId, attemptId, eventSessionId, dispatchNonce);
+      if (!heldLiveStateCompletions.has(key2)) {
+        heldLiveStateCompletions.set(key2, {
+          components,
+          meshId: args.meshId,
+          sourceInstanceId: args.sourceInstanceId,
+          nodeId: args.nodeId,
+          nodeLabel: args.nodeLabel,
+          sessionId: eventSessionId,
+          taskId,
+          attemptId,
+          dispatchNonce,
+          providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0,
+          eventTimestamp,
+          expiresAt: nowMs + MID_TURN_COMPLETION_HOLD_TTL_MS,
+          nextCheckAt: nowMs + MID_TURN_COMPLETION_HOLD_RETRY_MS
+        });
+      }
+      scheduleHeldLiveStateCompletionDrain();
+      return true;
+    }
     function getCachedMeshByWorkspace(workspace) {
       const now = Date.now();
       const cached4 = meshByWorkspaceCache.get(workspace);
@@ -57576,19 +57801,38 @@ ${cleanBody}`;
       }
       if (args.event === "agent:generating_completed" && eventSessionId) {
         const liveInstance = components.instanceManager?.getInstance?.(eventSessionId);
-        if (typeof liveInstance?.hasLiveTurnPendingEvidence === "function") {
-          let midTurnPending = false;
-          try {
-            midTurnPending = liveInstance.hasLiveTurnPendingEvidence() === true;
-          } catch {
-          }
-          if (midTurnPending) {
-            LOG2.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): live adapter re-check shows the turn is still pending (mid-tool / streaming / modal) \u2014 treating as a premature/redraw-race emit; the adapter's own finalization retry or the reconcile loop's transcript evidence will surface the real completion`);
-            traceMeshEventDrop("mid_turn_live_state_pending", traceCtx);
-            return {
-              kind: "suppress",
-              result: { success: true, forwarded: 0, suppressed: true, midTurnLiveStatePending: true }
-            };
+        if (typeof liveInstance?.getLiveTurnPendingEvidence === "function" || typeof liveInstance?.hasLiveTurnPendingEvidence === "function") {
+          const live = readLivePendingEvidence(liveInstance);
+          if (live.pending) {
+            const taskId = readNonEmptyString(args.metadataEvent.taskId);
+            const attempt = taskId ? MeshRuntimeStore.getInstance().getCurrentTurnAttempt(args.meshId, taskId) : null;
+            const authority = evaluateAuthoritativeTranscriptCompletion({
+              metadataEvent: args.metadataEvent,
+              eventSessionId,
+              attempt
+            });
+            if (authoritativeEvidenceOutranksLivePending(authority, live)) {
+              LOG2.info("MeshEvents", `Accepted agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): fresh clean-path transcript evidence for the current attempt is newer than the stale ${live.kind ?? "live"} snapshot`);
+            } else {
+              const retryEligible = completionEligibleForLiveStateRetry({
+                metadataEvent: args.metadataEvent,
+                eventSessionId,
+                attempt
+              });
+              const heldForRetry = retryEligible && holdCompletionForLiveStateRetry(components, args, eventSessionId, Date.now());
+              LOG2.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): current live evidence remains pending (${live.kind ?? "unknown"}); transcript authority=${authority.authoritative ? "fresh_but_not_newer" : authority.reason}${heldForRetry ? " \u2014 bounded content-free retry armed" : ""}`);
+              traceMeshEventDrop("mid_turn_live_state_pending", traceCtx, heldForRetry ? "retry_held" : void 0);
+              return {
+                kind: "suppress",
+                result: {
+                  success: true,
+                  forwarded: 0,
+                  suppressed: true,
+                  midTurnLiveStatePending: true,
+                  ...heldForRetry ? { completionRetryHeld: true } : {}
+                }
+              };
+            }
           }
         }
         if (!readNonEmptyString(args.metadataEvent.taskId) && !sessionHasActiveAssignment(args.meshId, eventSessionId) && !findRecentTerminalLedgerEvidence({ meshId: args.meshId, sessionId: eventSessionId, nodeId: eventNodeId || void 0 }) && isWeakCompletionEvidence(args.metadataEvent)) {
@@ -58490,6 +58734,8 @@ ${cleanBody}`;
         // keeps event.taskId/meshActiveTaskId for free; this mirrors it for the remote relay.
         // Same taskId/meshActiveTaskId ordering the local unroutable trace uses.
         taskId: readNonEmptyString(payload.taskId) || readNonEmptyString(payload.meshActiveTaskId),
+        attemptId: readNonEmptyString(payload.attemptId) || readNonEmptyString(payload.meshActiveAttemptId),
+        ...typeof payload.dispatchNonce === "number" ? { dispatchNonce: payload.dispatchNonce } : typeof payload.meshActiveDispatchNonce === "number" ? { dispatchNonce: payload.meshActiveDispatchNonce } : {},
         targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId),
         providerType: readNonEmptyString(payload.providerType),
         providerSessionId: readNonEmptyString(payload.providerSessionId),
@@ -58516,6 +58762,7 @@ ${cleanBody}`;
         providerName: readNonEmptyString(payload.providerName),
         ...payload.sessionSettings && typeof payload.sessionSettings === "object" && !Array.isArray(payload.sessionSettings) ? { sessionSettings: payload.sessionSettings } : {},
         finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+        evidenceLevel: readNonEmptyString(payload.evidenceLevel),
         // T2: carry the worker's status-snapshot last-message preview across the machine
         // boundary so a summary-less completion still surfaces the assistant reply in the
         // coordinator's inbox mirror. resolveMeshSurfacedSessionPreview reads these
@@ -58782,6 +59029,10 @@ ${cleanBody}`;
     var REMOTE_IDLE_SESSION_TTL_MS;
     var meshByWorkspaceCache;
     var MESH_WORKSPACE_CACHE_TTL_MS;
+    var MID_TURN_COMPLETION_HOLD_RETRY_MS;
+    var MID_TURN_COMPLETION_HOLD_TTL_MS;
+    var heldLiveStateCompletions;
+    var heldLiveStateCompletionTimer;
     var lastPendingEventsPruneAt;
     var PENDING_EVENTS_PRUNE_INTERVAL_MS;
     var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
@@ -58816,9 +59067,14 @@ ${cleanBody}`;
         init_mesh_turn_ledger();
         init_mesh_turn_presentation();
         init_mesh_queue_assignment();
+        init_mesh_completion_live_gate();
         REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
         meshByWorkspaceCache = /* @__PURE__ */ new Map();
         MESH_WORKSPACE_CACHE_TTL_MS = 5e3;
+        MID_TURN_COMPLETION_HOLD_RETRY_MS = 250;
+        MID_TURN_COMPLETION_HOLD_TTL_MS = 5e3;
+        heldLiveStateCompletions = /* @__PURE__ */ new Map();
+        heldLiveStateCompletionTimer = null;
         lastPendingEventsPruneAt = 0;
         PENDING_EVENTS_PRUNE_INTERVAL_MS = 60 * 60 * 1e3;
         INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
@@ -86891,6 +87147,43 @@ ${body}
       isModalParked() {
         return this.resolveModalParkStatus() !== null;
       }
+      /**
+       * Provider-agnostic live-state observation for the mesh completion gate.
+       * `observedAt` is the PTY snapshot clock, not the time this accessor ran:
+       * after restart/rebind an old waiting_* frame must remain recognizably
+       * older than a newly-written authoritative transcript final.
+       */
+      getLiveTurnPendingEvidence() {
+        const adapterPending = this.hasAdapterPendingResponse();
+        const modalParked = this.isModalParked();
+        if (adapterPending || modalParked) {
+          let observedAt;
+          try {
+            const raw = this.adapter.getStatus({ allowParse: false });
+            if (typeof raw?.lastOutputAt === "number" && Number.isFinite(raw.lastOutputAt)) {
+              observedAt = raw.lastOutputAt;
+            }
+          } catch {
+          }
+          return {
+            pending: true,
+            kind: modalParked ? "modal" : "adapter",
+            ...observedAt !== void 0 ? { observedAt } : {}
+          };
+        }
+        try {
+          const probe = this.probeNativeTranscriptSignals();
+          if (probe?.snapshot?.available === true && Array.isArray(probe.messages) && hasTrailingToolActivityAfterFinalAssistant(probe.messages)) {
+            return {
+              pending: true,
+              kind: "transcript_tool",
+              observedAt: probe.snapshot.sampledAt
+            };
+          }
+        } catch {
+        }
+        return { pending: false };
+      }
       /**
        * MID-TURN-LIVE-STATE-GATE (broader false-idle RCA, mid-turn follow-up): a live,
        * synchronous re-check of whether this session's CURRENT turn genuinely still has
@@ -86925,15 +87218,7 @@ ${body}
        * can never wedge a session as "pending" forever.
        */
       hasLiveTurnPendingEvidence() {
-        if (this.hasAdapterPendingResponse() || this.isModalParked()) return true;
-        try {
-          const probe = this.probeNativeTranscriptSignals();
-          if (probe?.snapshot?.available === true && Array.isArray(probe.messages)) {
-            if (hasTrailingToolActivityAfterFinalAssistant(probe.messages)) return true;
-          }
-        } catch {
-        }
-        return false;
+        return this.getLiveTurnPendingEvidence().pending;
       }
       /**
        * PTY-OVERTRUST-DRAIN (Defect B). The deliverability/drain status the mesh
@@ -87622,8 +87907,12 @@ ${body}
         LOG2.debug("CLI", `[${this.type}] finalAssistantEvidence: present=${finalAssistantEvidence.present} source=${finalAssistantEvidence.source} adapterOwnsMessagesElsewhere=${adapterOwnsMessagesElsewhere} parsedStatus=${parsedStatus}`);
         if (finalAssistantEvidence.present && finalAssistantEvidence.source !== "unavailable") {
           pending.resolvedFinalMessages = Array.isArray(finalAssistantEvidence.messages) ? finalAssistantEvidence.messages : void 0;
+          pending.resolvedFinalEvidenceSource = finalAssistantEvidence.source;
+          pending.resolvedFinalEvidenceObservedAt = Date.now();
         } else {
           pending.resolvedFinalMessages = void 0;
+          pending.resolvedFinalEvidenceSource = void 0;
+          pending.resolvedFinalEvidenceObservedAt = void 0;
         }
         if (!finalAssistantEvidence.present) {
           if (adapterOwnsMessagesElsewhere) {
@@ -88579,12 +88868,40 @@ ${body}
           duration: pending.duration,
           busyEpoch: this.busyEpoch
         });
+        const finalSummary = this.cleanCompletionFinalSummary(pending);
+        const transcriptProfile = resolveTranscriptAuthorityProfile(this.provider);
+        const finalContentLength = typeof finalSummary === "string" ? finalSummary.trim().length : 0;
         this.emitGeneratingCompleted({
           chatTitle: pending.chatTitle,
           duration: pending.duration,
           timestamp: pending.timestamp,
           taskId: pending.taskId,
-          finalSummary: this.cleanCompletionFinalSummary(pending)
+          finalSummary,
+          evidenceLevel: "transcript",
+          completionDiagnostic: {
+            source: "clean_final_assistant",
+            cleanPath: true,
+            evidenceWeak: false,
+            finalAssistantPresent: true,
+            finalAssistantEvidenceSource: pending.resolvedFinalEvidenceSource ?? "parsed",
+            finalAssistantContentLength: finalContentLength,
+            transcriptEvidence: {
+              version: 1,
+              kind: "final_assistant",
+              cleanPath: true,
+              weak: false,
+              authorityClass: transcriptProfile.class,
+              timing: transcriptProfile.timing,
+              providerOwnsTranscript: transcriptProfile.providerOwnsTranscript,
+              observedAt: pending.resolvedFinalEvidenceObservedAt ?? Date.now(),
+              turnStartedAt: pending.turnStartedAt ?? null,
+              finalContentLength,
+              taskId: pending.taskId ?? null,
+              attemptId: typeof this.settings.meshActiveAttemptId === "string" ? this.settings.meshActiveAttemptId : null,
+              dispatchNonce: typeof this.settings.meshActiveDispatchNonce === "number" ? this.settings.meshActiveDispatchNonce : null,
+              sessionId: this.instanceId
+            }
+          }
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = null;
@@ -100783,7 +101100,7 @@ ${ptyResult.output.slice(-2e3)}`);
         return "";
       }
     }
-    function readRecord6(repoRoot) {
+    function readRecord7(repoRoot) {
       const path50 = (0, import_node_path3.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
       if (!(0, import_node_fs4.existsSync)(path50)) return null;
       try {
@@ -100824,7 +101141,7 @@ ${ptyResult.output.slice(-2e3)}`);
     function buildPreviewFreshness(repoRoot) {
       if (!isPreviewPipelineConfigured(repoRoot)) return null;
       const current = readCurrentMainCommit(repoRoot);
-      const record2 = readRecord6(repoRoot);
+      const record2 = readRecord7(repoRoot);
       const lastPreviewCommit = normalizeCommit(record2?.lastPreviewCommit);
       const targets = readTargetFreshness(record2, current.currentMainCommit);
       let status = "unknown";