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

package/dist/index.mjs

@@ -786,10 +786,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "3a48f660f00c3bf2e42ba36df7789edbc654b99c" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "3a48f660" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:40:47.778Z" : 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 version = 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:15.160Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -16439,6 +16439,31 @@ var init_debug_trace = __esm({
 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 });
@@ -16559,6 +16584,17 @@ function reconcileDirectDispatchCompletionFromTranscript(args) {
   })) {
     return { reconciled: false, alreadyTerminal: true, reason: "terminal_ledger_entry_exists" };
   }
+  const admission = evaluateTranscriptSynthAdmission(args.causalAdmission);
+  if (!admission.admitted) {
+    LOG.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();
@@ -16720,6 +16756,7 @@ var init_mesh_events_stale = __esm({
     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;
@@ -23093,6 +23130,14 @@ function evaluateMeshEventSuppression(args, ctx) {
         };
       }
     }
+    if (!readNonEmptyString(args.metadataEvent.taskId) && !sessionHasActiveAssignment(args.meshId, eventSessionId) && !findRecentTerminalLedgerEvidence({ meshId: args.meshId, sessionId: eventSessionId, nodeId: eventNodeId || void 0 }) && isWeakCompletionEvidence(args.metadataEvent)) {
+      LOG.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);
@@ -24849,6 +24894,18 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     }
     const messages = Array.isArray(payload.messages) ? payload.messages : [];
     const evidence = extractFinalAssistantSummaryEvidence(messages);
+    if (hasTrailingToolActivityAfterFinalAssistant(messages)) {
+      setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
+      LOG.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;
@@ -24923,6 +24980,17 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
         // 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) {
@@ -25368,10 +25436,10 @@ async function evaluateEarlyIdleTranscriptArm(components, mesh, store, row, loca
   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({
@@ -25387,11 +25455,26 @@ function propagateWatchdogTranscriptCompletion(meshId, row, evidence, source) {
       // 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 = []) {
@@ -25425,14 +25508,28 @@ async function recoverStrandedAssignedDispatches(components, mesh, store, localD
           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);
+            LOG.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, {
@@ -25607,12 +25704,15 @@ async function recoverStrandedAssignedDispatches(components, mesh, store, localD
       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, {
@@ -51187,9 +51287,36 @@ var CliProviderInstance = class _CliProviderInstance {
    * 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
@@ -78413,6 +78540,7 @@ export {
   handleGitCommand,
   hasCdpManager,
   hasPendingDependents,
+  hasTrailingToolActivityAfterFinalAssistant,
   hashSignatureParts,
   initDaemonComponents,
   insertDirectDispatch,