@adhdev/daemon-standalone 1.0.28-rc.24 → 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 ? "6abc12466a3077bd6bc096332ce9073ff8d4d975" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "6abc1246" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28-rc.24" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-29T05:49:00.948Z" : 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;
     }
@@ -36902,16 +36902,31 @@ ${error48.message || ""}`;
       } catch {
       }
     }
+    function sizeRotationPath(logFile, generation) {
+      return logFile.replace(/\.log$/, `.${generation}.log`);
+    }
+    function rotateSizeGenerations(logFile, maxGenerations = MAX_SIZE_ROTATION_GENERATIONS) {
+      if (maxGenerations < 1) return;
+      const oldest = sizeRotationPath(logFile, maxGenerations);
+      try {
+        fs32.unlinkSync(oldest);
+      } catch {
+      }
+      for (let generation = maxGenerations - 1; generation >= 1; generation--) {
+        const source = sizeRotationPath(logFile, generation);
+        const destination = sizeRotationPath(logFile, generation + 1);
+        try {
+          fs32.renameSync(source, destination);
+        } catch {
+        }
+      }
+      fs32.renameSync(logFile, sizeRotationPath(logFile, 1));
+    }
     function rotateSizeIfNeeded() {
       try {
         const stat2 = fs32.statSync(currentLogFile);
         if (stat2.size > MAX_LOG_SIZE) {
-          const backup = currentLogFile.replace(".log", ".1.log");
-          try {
-            fs32.unlinkSync(backup);
-          } catch {
-          }
-          fs32.renameSync(currentLogFile, backup);
+          rotateSizeGenerations(currentLogFile);
         }
       } catch {
       }
@@ -37020,6 +37035,7 @@ ${error48.message || ""}`;
     var LOG_DIR;
     var MAX_LOG_SIZE;
     var MAX_LOG_DAYS;
+    var MAX_SIZE_ROTATION_GENERATIONS;
     var currentDate;
     var currentLogFile;
     var writeCount;
@@ -37045,6 +37061,7 @@ ${error48.message || ""}`;
         LOG_DIR = path9.join(ADHDEV_HOME, "logs");
         MAX_LOG_SIZE = 5 * 1024 * 1024;
         MAX_LOG_DAYS = 7;
+        MAX_SIZE_ROTATION_GENERATIONS = 3;
         try {
           fs32.mkdirSync(LOG_DIR, { recursive: true });
         } catch {
@@ -43569,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;
@@ -48671,6 +48688,9 @@ ${rendered}`, "utf-8");
         state: "connected",
         transport: transport && transport !== "unknown" ? transport : "direct",
         reported: true,
+        directPeerTruthSatisfied: true,
+        authority: "live_peer",
+        cached: false,
         reason: "Live peer git snapshot reported by the selected coordinator.",
         lastStateChangeAt: readStringValue(connection.lastStateChangeAt) ?? timestamp2
       };
@@ -49344,6 +49364,7 @@ ${rendered}`, "utf-8");
       const now = args.now ?? Date.now;
       const connection = readObjectRecord(status.connection);
       const connectionState = readStringValue(connection.state);
+      const directPeerTruthSatisfied = readBooleanValue(connection.directPeerTruthSatisfied);
       const git = readObjectRecord(status.git);
       const hasGit = readBooleanValue(git.isGitRepo) === true || !!readStringValue(git.branch, git.headCommit, git.head, git.upstream);
       const connectionFreshAt = toIsoTimestamp(connection.lastCommandAt ?? connection.lastConnectedAt ?? connection.lastStateChangeAt);
@@ -49365,12 +49386,12 @@ ${rendered}`, "utf-8");
       } else if (readBooleanValue(status.gitProbePending) === true) {
         dataSource = "pending";
         reachable = connectionReachable;
+      } else if (hasGit) {
+        dataSource = "cached";
+        reachable = directTruthUnavailable ? false : connectionReachable;
       } else if (directTruthUnavailable) {
         dataSource = "unreachable";
         reachable = false;
-      } else if (hasGit) {
-        dataSource = "cached";
-        reachable = connectionReachable;
       } else if (!daemonId) {
         dataSource = "unconfigured";
         reachable = null;
@@ -49392,6 +49413,8 @@ ${rendered}`, "utf-8");
         dataSource,
         probeOk,
         reachable,
+        directPeerTruthSatisfied: isSelfNode || liveTruthProbed ? true : directPeerTruthSatisfied ?? false,
+        projection: dataSource === "cached" ? "cached" : "live_or_absent",
         lastProbeAt: lastProbeAt ?? null,
         ageMs: ageMs2,
         staleness
@@ -57248,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;
@@ -57264,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);
@@ -57553,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)) {
@@ -58467,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),
@@ -58493,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
@@ -58759,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;
@@ -58793,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;
@@ -67877,6 +68156,7 @@ ${lastSnapshot}`;
       MAGI_NEEDS_VERIFICATION_PREVIEW_CAP: () => MAGI_NEEDS_VERIFICATION_PREVIEW_CAP,
       MAGI_RAW_ANSWER_CAP: () => MAGI_RAW_ANSWER_CAP,
       MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
+      MAX_SIZE_ROTATION_GENERATIONS: () => MAX_SIZE_ROTATION_GENERATIONS,
       MESH_CONVERGE_FAST_FORWARD_TAG: () => MESH_CONVERGE_FAST_FORWARD_TAG,
       MESH_CONVERGE_REFINE_TAG: () => MESH_CONVERGE_REFINE_TAG,
       MESH_JSON_CONFIG_LOCATIONS: () => MESH_JSON_CONFIG_LOCATIONS,
@@ -69800,10 +70080,57 @@ ${lastSnapshot}`;
       }
       return String(error48 || "mesh relay command failed");
     }
+    function readStructuredFailure(error48) {
+      if (!error48 || typeof error48 !== "object") return {};
+      const value = error48;
+      return {
+        ...typeof value.code === "string" ? { code: value.code } : {},
+        ...typeof value.reason === "string" ? { reason: value.reason } : {},
+        ...value.transport === "p2p" || value.transport === "unknown" ? { transport: value.transport } : {},
+        ...typeof value.recoverable === "boolean" ? { recoverable: value.recoverable } : {},
+        ...typeof value.retryRecommended === "boolean" ? { retryRecommended: value.retryRecommended } : {},
+        ...typeof value.nextAction === "string" ? { nextAction: value.nextAction } : {},
+        ...typeof value.noFallbackReason === "string" ? { noFallbackReason: value.noFallbackReason } : {},
+        ...typeof value.meshCode === "string" ? { meshCode: value.meshCode } : {},
+        ...typeof value.connectionState === "string" ? { connectionState: value.connectionState } : {},
+        ...typeof value.nextRetryAt === "string" ? { nextRetryAt: value.nextRetryAt } : {},
+        ...typeof value.authEpoch === "number" ? { authEpoch: value.authEpoch } : {}
+      };
+    }
+    function reasonForCode(code) {
+      switch (code) {
+        case "p2p_timeout":
+          return "daemon_mesh_p2p_timeout";
+        case "p2p_not_connected":
+          return "daemon_mesh_p2p_not_connected";
+        case "p2p_datachannel_closed":
+          return "daemon_mesh_p2p_datachannel_closed";
+        case "p2p_no_route":
+          return "daemon_mesh_p2p_no_route";
+        case "p2p_daemon_offline":
+          return "daemon_mesh_target_offline";
+        case "p2p_unavailable":
+          return "daemon_mesh_p2p_transport_unavailable";
+        case "mesh_logic_or_provider_failure":
+          return "mesh_logic_or_provider_failure";
+      }
+    }
     function classifyP2pRelayFailure(error48, _context = {}) {
       const message = messageFromError(error48);
       const lower = message.toLowerCase();
-      const hasP2pSignal = /p2p|datachannel|node-datachannel|webrtc|ice|mesh_relay_command|daemon_mesh_p2p_transport/i.test(message);
+      const structured = readStructuredFailure(error48);
+      if (structured.code && structured.code !== "mesh_logic_or_provider_failure" && structured.transport === "p2p") {
+        return {
+          code: structured.code,
+          reason: structured.reason || reasonForCode(structured.code),
+          transport: "p2p",
+          recoverable: structured.recoverable ?? true,
+          retryRecommended: structured.retryRecommended ?? true,
+          nextAction: structured.nextAction || P2P_NEXT_ACTION,
+          noFallbackReason: structured.noFallbackReason || NO_FALLBACK_REASON
+        };
+      }
+      const hasP2pSignal = /p2p|peer|datachannel|node-datachannel|webrtc|ice|mesh_relay_command|daemon_mesh_p2p_transport/i.test(message);
       const hasFailureSignal = /unavailable|missing|failed|failure|timeout|timed out|not connected|closed|disconnected|offline|no route|route unavailable|cannot send|cannot establish/i.test(message);
       if (/requires targetdaemonid and command|providerpriority|no inference provider|permission denied|read-only|not a member/i.test(message)) {
         return {
@@ -69830,7 +70157,7 @@ ${lastSnapshot}`;
       } else if (/closed|disconnected/i.test(message) && (hasP2pSignal || /state changed/i.test(message))) {
         code = "p2p_datachannel_closed";
         reason = "daemon_mesh_p2p_datachannel_closed";
-      } else if (/not connected|cannot send|cannot establish/i.test(message) && hasP2pSignal) {
+      } else if (/not connected|cannot send|cannot establish|probe gave up/i.test(message) && hasP2pSignal) {
         code = "p2p_not_connected";
         reason = "daemon_mesh_p2p_not_connected";
       } else if (hasP2pSignal && hasFailureSignal) {
@@ -69863,12 +70190,17 @@ ${lastSnapshot}`;
     }
     function buildP2pRelayFailurePayload(error48, context = {}) {
       const classification = classifyP2pRelayFailure(error48, context);
+      const structured = readStructuredFailure(error48);
       return {
         success: false,
         ...classification,
         error: messageFromError(error48),
         ...context.command ? { command: context.command } : {},
-        ...context.targetDaemonId ? { targetDaemonId: context.targetDaemonId } : {}
+        ...context.targetDaemonId ? { targetDaemonId: context.targetDaemonId } : {},
+        ...context.meshCode || structured.meshCode ? { meshCode: context.meshCode || structured.meshCode } : {},
+        ...context.connectionState || structured.connectionState ? { connectionState: context.connectionState || structured.connectionState } : {},
+        ...context.nextRetryAt || structured.nextRetryAt ? { nextRetryAt: context.nextRetryAt || structured.nextRetryAt } : {},
+        ...(context.authEpoch ?? structured.authEpoch) !== void 0 ? { authEpoch: context.authEpoch ?? structured.authEpoch } : {}
       };
     }
     var P2pRelayFailureError = class extends Error {
@@ -69881,19 +70213,37 @@ ${lastSnapshot}`;
       noFallbackReason;
       command;
       targetDaemonId;
+      meshCode;
+      connectionState;
+      nextRetryAt;
+      authEpoch;
       constructor(message, context = {}) {
         super(message);
         this.name = "P2pRelayFailureError";
-        const payload = buildP2pRelayFailurePayload(message, context);
-        this.code = payload.code;
+        const payload = buildP2pRelayFailurePayload({
+          message,
+          ...context.code ? { code: context.code } : {},
+          ...context.recoverable !== void 0 ? { recoverable: context.recoverable } : {},
+          ...context.retryRecommended !== void 0 ? { retryRecommended: context.retryRecommended } : {},
+          transport: context.code ? "p2p" : void 0,
+          meshCode: context.meshCode,
+          connectionState: context.connectionState,
+          nextRetryAt: context.nextRetryAt,
+          authEpoch: context.authEpoch
+        }, context);
+        this.code = context.code ?? payload.code;
         this.reason = payload.reason;
         this.transport = payload.transport;
-        this.recoverable = payload.recoverable;
-        this.retryRecommended = payload.retryRecommended;
+        this.recoverable = context.recoverable ?? payload.recoverable;
+        this.retryRecommended = context.retryRecommended ?? payload.retryRecommended;
         this.nextAction = payload.nextAction;
         this.noFallbackReason = payload.noFallbackReason;
         this.command = context.command;
         this.targetDaemonId = context.targetDaemonId;
+        this.meshCode = context.meshCode;
+        this.connectionState = context.connectionState;
+        this.nextRetryAt = context.nextRetryAt;
+        this.authEpoch = context.authEpoch;
       }
     };
     init_state_store();
@@ -81195,6 +81545,12 @@ ${body}
       }
       return getCurrentDaemonLogPath();
     }
+    function sizeRotationPaths(primaryPath) {
+      return Array.from(
+        { length: MAX_SIZE_ROTATION_GENERATIONS },
+        (_, index) => primaryPath.replace(/\.log$/, `.${index + 1}.log`)
+      );
+    }
     function clampTailBytes(tailBytes) {
       if (!Number.isFinite(tailBytes) || tailBytes <= 0) return DEFAULT_TAIL_BYTES;
       return Math.min(Math.floor(tailBytes), MAX_TAIL_BYTES);
@@ -81303,17 +81659,17 @@ ${body}
       const platform10 = process.platform;
       const limitBytes = clampTailBytes(args.tailBytes);
       const primaryPath = resolveLogPath(args.date);
-      const backupPath = primaryPath.replace(/\.log$/, ".1.log");
+      const backupPaths = sizeRotationPaths(primaryPath);
       const primaryExists = fs16.existsSync(primaryPath);
-      const backupExists = fs16.existsSync(backupPath);
-      if (!primaryExists && !backupExists) {
+      const existingBackupPaths = backupPaths.filter((backupPath) => fs16.existsSync(backupPath));
+      if (!primaryExists && existingBackupPaths.length === 0) {
         return errorResult(
           `No daemon log file at ${primaryPath} (dir: ${getDaemonLogDir()})`,
           primaryPath,
           platform10
         );
       }
-      const logPath = primaryExists ? primaryPath : backupPath;
+      const logPath = primaryExists ? primaryPath : existingBackupPaths[0];
       const hasGrep = typeof args.grep === "string" && args.grep.trim().length > 0;
       const hasSince = Number.isFinite(args.sinceMs);
       const filterMode = hasGrep || hasSince;
@@ -81342,7 +81698,7 @@ ${body}
       let scannedBytes = 0;
       let allLines = [];
       try {
-        for (const p of [backupExists ? backupPath : null, primaryExists ? primaryPath : null]) {
+        for (const p of [...existingBackupPaths].reverse().concat(primaryExists ? [primaryPath] : [])) {
           if (!p) continue;
           const buf = fs16.readFileSync(p);
           scannedBytes += buf.length;
@@ -86791,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
@@ -86825,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
@@ -87522,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) {
@@ -88479,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;
@@ -100683,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 {
@@ -100724,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";
@@ -101132,6 +101549,7 @@ ${ptyResult.output.slice(-2e3)}`);
             finalizeMeshNodeStatus({ status: fallback, node, daemonId, isSelfNode: false, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
             return fallback;
           });
+          const cachedProjectionNodeIds = nodeStatuses.filter((status) => status?.dataFreshness?.projection === "cached" && status?.dataFreshness?.directPeerTruthSatisfied === false).map((status) => readStringValue(status?.nodeId)).filter(Boolean);
           const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : ctx.deps.statusInstanceId || void 0;
           const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
           const unroutableDeliveries = getRecentUnroutableDeliveries();
@@ -101192,7 +101610,8 @@ ${ptyResult.output.slice(-2e3)}`);
                   peerAttemptedCount: effectiveDirectTruth.peerAttemptedCount,
                   peerConfirmedCount: effectiveDirectTruth.peerConfirmedCount,
                   unavailableNodeIds: effectiveDirectTruth.unavailableNodeIds,
-                  partialNodeFailures: effectiveDirectTruth.unavailableNodeIds
+                  partialNodeFailures: effectiveDirectTruth.unavailableNodeIds,
+                  cachedProjectionNodeIds
                 }
               } : {},
               historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary", "historicalSessions"]