@adhdev/daemon-standalone 1.0.28-rc.16 → 1.0.28-rc.17

package/dist/index.js

@@ -33262,10 +33262,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "3a48f660f00c3bf2e42ba36df7789edbc654b99c" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "3a48f660" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28-rc.16" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-26T16:41:21.955Z" : void 0);
+      const commit = readInjected(true ? "9452bd039720355425e62fc7469808a0dda3ab80" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "9452bd03" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.28-rc.17" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-27T01:42:48.643Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -49047,6 +49047,31 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     function recordSynthCompletionGateTrace(stage, payload) {
       recordDebugTrace({ category: "completion-gate", stage, level: "debug", payload });
     }
+    function evaluateTranscriptSynthAdmission(admission) {
+      if (!admission) return { admitted: true };
+      if (admission.trailingToolActivityAfterFinalAssistant === true) {
+        return { admitted: false, reason: "trailing_tool_activity_after_final_assistant" };
+      }
+      if (!admission.boundedBackstop && typeof admission.liveTurnPendingEvidence === "function") {
+        let pending = false;
+        try {
+          pending = admission.liveTurnPendingEvidence() === true;
+        } catch {
+        }
+        if (pending) return { admitted: false, reason: "live_turn_pending_evidence" };
+      }
+      return { admitted: true };
+    }
+    function resolveLiveTurnPendingEvidence(components, sessionId) {
+      try {
+        const instance = components?.instanceManager?.getInstance?.(sessionId);
+        if (typeof instance?.hasLiveTurnPendingEvidence !== "function") return void 0;
+        const probe = instance.hasLiveTurnPendingEvidence.bind(instance);
+        return () => probe();
+      } catch {
+        return void 0;
+      }
+    }
     function findRecentTerminalLedgerEvidence(args) {
       if (!args.sessionId && !args.nodeId) return null;
       const entries = readLedgerEntries(args.meshId, { tail: 200 });
@@ -49167,6 +49192,17 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       })) {
         return { reconciled: false, alreadyTerminal: true, reason: "terminal_ledger_entry_exists" };
       }
+      const admission = evaluateTranscriptSynthAdmission(args.causalAdmission);
+      if (!admission.admitted) {
+        LOG2.info("MeshEvents", `Transcript synth vetoed for task ${args.taskId} session ${args.sessionId} (source ${args.source || "direct_task_transcript_reconciliation"}): ${admission.reason} \u2014 holding the completion; it re-evaluates on the next reconcile pass`);
+        recordSynthCompletionGateTrace("synth-veto", {
+          producer: "transcript_reconcile",
+          source: args.source || "direct_task_transcript_reconciliation",
+          taskId: args.taskId,
+          reason: admission.reason
+        });
+        return { reconciled: false, reason: admission.reason };
+      }
       const nodeId = readNonEmptyString(args.nodeId) || dispatch?.nodeId;
       const providerType = readNonEmptyString(args.providerType) || dispatch?.providerType || readNonEmptyString(dispatch?.payload.providerType);
       const completedAt = args.completedAt || (/* @__PURE__ */ new Date()).toISOString();
@@ -49329,6 +49365,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_events_pending();
         init_mesh_events_utils();
         init_debug_trace();
+        init_logger();
         init_dist();
         DIRECT_DISPATCH_RECONCILE_GRACE_MS = 6e4;
         DIRECT_DISPATCH_IDLE_SESSION_RECONCILE_GRACE_MS = 12e4;
@@ -55750,6 +55787,14 @@ ${cleanBody}`;
             };
           }
         }
+        if (!readNonEmptyString(args.metadataEvent.taskId) && !sessionHasActiveAssignment(args.meshId, eventSessionId) && !findRecentTerminalLedgerEvidence({ meshId: args.meshId, sessionId: eventSessionId, nodeId: eventNodeId || void 0 }) && isWeakCompletionEvidence(args.metadataEvent)) {
+          LOG2.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): no taskId, no active assignment, and no prior terminal ledger evidence \u2014 a pre-dispatch startup/greeting artifact, not a real task completion`);
+          traceMeshEventDrop("no_dispatch_native_completion", traceCtx);
+          return {
+            kind: "suppress",
+            result: { success: true, forwarded: 0, suppressed: true, noDispatchNativeCompletion: true }
+          };
+        }
         const inWindowTask = findInWindowUnclaimedAutoLaunchTask(args.meshId, eventSessionId, Date.now());
         if (inWindowTask) {
           const causalEvidence = MeshRuntimeStore.getInstance().taskDeliveryConsumed(args.meshId, inWindowTask.id) || hasMatchingTaskDispatchedLedgerEntry(args.meshId, inWindowTask.id, eventSessionId);
@@ -57501,6 +57546,18 @@ ${cleanBody}`;
         }
         const messages = Array.isArray(payload.messages) ? payload.messages : [];
         const evidence = extractFinalAssistantSummaryEvidence(messages);
+        if (hasTrailingToolActivityAfterFinalAssistant(messages)) {
+          setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
+          LOG2.info("MeshReconcile", `Mid-turn causal admission: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) \u2014 the latest final-looking assistant bubble is followed by trailing tool/terminal activity (interim narration; the turn is still executing); holding the transcript synth`);
+          traceMeshEventDrop("reconcile_synth_veto_trailing_tool_activity", {
+            taskId,
+            sessionId,
+            nodeId,
+            meshId: mesh.id,
+            event: "agent:generating_completed"
+          });
+          continue;
+        }
         if (isAcked) {
           const ackedAtMs = Date.parse(readNonEmptyString(dispatch.updatedAt));
           const sinceAckMs = Number.isFinite(ackedAtMs) ? nowMs - ackedAtMs : Number.POSITIVE_INFINITY;
@@ -57575,6 +57632,17 @@ ${cleanBody}`;
             // The ledger-recovered dispatching-coordinator daemon (inside the reconcile fn)
             // takes PRIORITY over this arg; this remains the best-available fallback.
             ...coordinatorDaemonId ? { targetCoordinatorDaemonId: coordinatorDaemonId } : {},
+            // MID-TURN-CAUSAL-ADMISSION (rc.16): pass the LOCAL live adapter's synchronous
+            // turn-state probe into the unified choke point — a pending verdict vetoes this
+            // eager synth (never-acked first-idle / acked fast-track). The death-deadline
+            // backstop is the bounded max-wait net and overrides the veto (genuine-final
+            // fail-open preserved); a remote/missing live source resolves to undefined and
+            // fails open onto the bounded transcript evidence above. The trailing-tool veto
+            // already ran at the top of this tick.
+            causalAdmission: {
+              liveTurnPendingEvidence: resolveLiveTurnPendingEvidence(components, sessionId),
+              boundedBackstop: backstopKind === "ackedHoldDeathDeadlineFired"
+            },
             source: "daemon_reconcile_transcript_completion"
           });
           if (result.reconciled) {
@@ -58018,10 +58086,10 @@ ${cleanBody}`;
       if (profile) return profile.emitsPtyTurnEvents === false;
       return verdict === "UNKNOWN";
     }
-    function propagateWatchdogTranscriptCompletion(meshId, row, evidence, source) {
+    function propagateWatchdogTranscriptCompletion(components, meshId, row, evidence, source, opts) {
       const sessionId = readNonEmptyString(row.assignedSessionId) || evidence.sessionId;
       if (!sessionId || !readNonEmptyString(evidence.finalSummary)) {
-        return false;
+        return "unavailable";
       }
       try {
         const result = reconcileDirectDispatchCompletionFromTranscript({
@@ -58037,11 +58105,26 @@ ${cleanBody}`;
           // The watchdog poll already enforced idle + post-dispatch + no-trailing-tool + streak;
           // skip the reconcile's own grace/transcript_not_proven gates (dedup backstops remain).
           preValidatedTranscriptEvidence: true,
+          // MID-TURN-CAUSAL-ADMISSION (rc.16): the transcript poll's structural evidence can
+          // still straddle a genuinely mid-turn LOCAL worker (the incident shape: transcript
+          // reads idle-with-final-assistant while the raw PTY is mid-tool). Route the live
+          // adapter's synchronous probe through the unified choke point. The EARLY-IDLE
+          // caller is an eager path (no opts) → a pending verdict defers; the redrive-deadline
+          // caller passes boundedBackstop (the max-wait net) → the veto yields, preserving the
+          // genuine-final fail-open semantics.
+          causalAdmission: {
+            liveTurnPendingEvidence: resolveLiveTurnPendingEvidence(components, sessionId),
+            boundedBackstop: opts?.boundedBackstop === true
+          },
           source
         });
-        return result.reconciled || result.alreadyTerminal === true;
+        if (result.reconciled || result.alreadyTerminal === true) return "propagated";
+        if (result.reason === "live_turn_pending_evidence" || result.reason === "trailing_tool_activity_after_final_assistant") {
+          return "deferred";
+        }
+        return "unavailable";
       } catch {
-        return false;
+        return "unavailable";
       }
     }
     async function recoverStrandedAssignedDispatches(components, mesh, store, localDaemonId, selfIds = []) {
@@ -58075,14 +58158,28 @@ ${cleanBody}`;
               minFinalAssistantAgeMs: ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS
             });
             if (terminalEvidence) {
-              assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
-              updateTaskStatus(meshId, row.id, terminalEvidence.outcome);
-              const propagated = propagateWatchdogTranscriptCompletion(
+              const propagation = propagateWatchdogTranscriptCompletion(
+                components,
                 meshId,
                 row,
                 terminalEvidence,
                 "early_idle_transcript_evidence"
               );
+              if (propagation === "deferred") {
+                assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
+                LOG2.info("MeshReconcile", `Deferred early transcript completion for task ${row.id} on mesh ${meshId} (node=${row.assignedNodeId ?? "?"} session=${row.assignedSessionId ?? "?"}): the live adapter still reports the turn pending (mid-tool / streaming / modal) \u2014 holding; the completion re-evaluates next tick`);
+                traceMeshEventDrop("early_idle_completion_deferred_live_pending", {
+                  taskId: row.id,
+                  sessionId: row.assignedSessionId,
+                  nodeId: row.assignedNodeId,
+                  meshId,
+                  event: "agent:generating_completed"
+                });
+                continue;
+              }
+              assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
+              updateTaskStatus(meshId, row.id, terminalEvidence.outcome);
+              const propagated = propagation === "propagated";
               if (!propagated && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
                 try {
                   appendLedgerEntry(meshId, {
@@ -58257,12 +58354,15 @@ ${cleanBody}`;
           if (terminalEvidence) {
             deliveredNoTurnUnknownStreak.delete(streakKey);
             updateTaskStatus(meshId, row.id, terminalEvidence.outcome);
-            const propagated = propagateWatchdogTranscriptCompletion(
+            const propagation = propagateWatchdogTranscriptCompletion(
+              components,
               meshId,
               row,
               terminalEvidence,
-              "redrive_deadline_transcript_evidence"
+              "redrive_deadline_transcript_evidence",
+              { boundedBackstop: true }
             );
+            const propagated = propagation === "propagated";
             if (!propagated && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
               try {
                 appendLedgerEntry(meshId, {
@@ -65678,6 +65778,7 @@ ${lastSnapshot}`;
       handleGitCommand: () => handleGitCommand,
       hasCdpManager: () => hasCdpManager,
       hasPendingDependents: () => hasPendingDependents,
+      hasTrailingToolActivityAfterFinalAssistant: () => hasTrailingToolActivityAfterFinalAssistant,
       hashSignatureParts: () => hashSignatureParts,
       initDaemonComponents: () => initDaemonComponents2,
       insertDirectDispatch: () => insertDirectDispatch,
@@ -84082,9 +84183,36 @@ ${body}
        * OR isModalParked() (a live approval/choice modal) — so a session this method reports
        * pending is, by construction, one the local finalization gate would also refuse to
        * finalize right now.
+       *
+       * NATIVE-TRAILING-TOOL-GATE (rc.16 follow-up): the three adapter-state discriminators
+       * above are blind to a background shell tool that keeps a turn alive without the adapter
+       * reporting a pending response — e.g. a backgrounded `sleep 40 &` between narration
+       * bubbles on a write-lag native-source provider (claude-cli), which is deliberately
+       * un-floored (noExternalTranscriptSource omitted, mission f2f6da1b owner decision) so its
+       * transcript write-lag emits promptly. That un-flooring is correct for the ordinary
+       * fraction-of-a-second trail, but it also means the growth-hold / busy-lease protections
+       * in getCompletedFinalizationBlock never engage for claude-cli, so an interim final-
+       * LOOKING bubble followed by continuing tool calls can still finalize as a completion
+       * while the transcript demonstrably shows the turn still executing. Close that gap here,
+       * narrowly: for a native-source provider only, reuse the SAME bounded transcript read the
+       * class's own completion judgment already performs (probeNativeTranscriptSignals) and
+       * apply the SAME trailing-tool-activity veto the transcript-synth admission choke point
+       * uses (hasTrailingToolActivityAfterFinalAssistant) — the latest final-looking assistant
+       * bubble followed by tool/terminal activity is interim narration, not a turn end. Fail-open
+       * by construction: a non-native-source class (probe returns null), an unresolved
+       * transcript, or a read error never reaches the veto, so a missing/unavailable transcript
+       * can never wedge a session as "pending" forever.
        */
       hasLiveTurnPendingEvidence() {
-        return this.hasAdapterPendingResponse() || this.isModalParked();
+        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;
       }
       /**
        * PTY-OVERTRUST-DRAIN (Defect B). The deliverability/drain status the mesh