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

package/dist/mesh/mesh-events-stale.d.ts

@@ -1,4 +1,52 @@
 import type { MeshLedgerKind } from './mesh-ledger.js';
+export interface TranscriptSynthCausalAdmission {
+    /**
+     * Synchronous re-check of a resolvable LOCAL live instance's CURRENT turn state — the
+     * same hasLiveTurnPendingEvidence() discriminator the 3a48f660 mid-turn gate uses on the
+     * native-event path. A pending verdict VETOES an eager transcript synth. Fail-open by
+     * construction: absent (remote/unknown session, separate-process caller), not a function,
+     * or throwing → no veto; the caller's bounded transcript evidence/settle behavior remains
+     * the operative net, so a missing transcript source never wedges.
+     */
+    liveTurnPendingEvidence?: () => boolean;
+    /**
+     * The caller is a BOUNDED last-resort backstop firing at its max-wait (the acked-hold
+     * death deadline, the delivered-no-turn redrive deadline). A bounded backstop overrides
+     * the live-pending veto — preserving the genuine-final fail-open / max-wait semantics —
+     * but NEVER overrides the trailing-tool veto (a stale weak interim summary must not
+     * become final merely because a timeout fired while newer transcript/tool activity
+     * exists).
+     */
+    boundedBackstop?: boolean;
+    /**
+     * The caller's transcript read shows tool/terminal activity AFTER the latest final-looking
+     * assistant bubble (hasTrailingToolActivityAfterFinalAssistant) — the bubble is interim
+     * narration ("Let me explore…"), the turn is still executing. Absolute veto: the worker is
+     * demonstrably alive and mid-turn, so even a bounded backstop keeps holding (the hold is
+     * still released by the session-death read-failure backstop and the stranded-reclaim /
+     * orphan-prune nets, so this cannot wedge forever).
+     */
+    trailingToolActivityAfterFinalAssistant?: boolean;
+}
+export type TranscriptSynthAdmissionVerdict = {
+    admitted: true;
+} | {
+    admitted: false;
+    reason: 'live_turn_pending_evidence' | 'trailing_tool_activity_after_final_assistant';
+};
+export declare function evaluateTranscriptSynthAdmission(admission?: TranscriptSynthCausalAdmission): TranscriptSynthAdmissionVerdict;
+/**
+ * Resolve the liveTurnPendingEvidence probe for `sessionId` from a components-shaped object
+ * (anything exposing instanceManager.getInstance). Returns undefined when no live instance
+ * resolves or the instance does not expose hasLiveTurnPendingEvidence — the fail-open
+ * remote/unknown case. Shared by every transcript-synth caller so the probe is resolved ONE
+ * way (UNIFY: same discriminator as the 3a48f660 native-event gate).
+ */
+export declare function resolveLiveTurnPendingEvidence(components: {
+    instanceManager?: {
+        getInstance?: (sessionId: string) => unknown;
+    };
+} | undefined, sessionId: string): (() => boolean) | undefined;
 export declare function findRecentTerminalLedgerEvidence(args: {
     meshId: string;
     sessionId?: string;
@@ -64,6 +112,17 @@ export declare function reconcileDirectDispatchCompletionFromTranscript(args: {
      * Direct-dispatch callers omit it → the gates apply exactly as before (no regression).
      */
     preValidatedTranscriptEvidence?: boolean;
+    /**
+     * MID-TURN-CAUSAL-ADMISSION (rc.16): causal admission evidence for the unified guard —
+     * see TranscriptSynthCausalAdmission. Every transcript-synth caller (PHASE 4 reconcile,
+     * watchdog transcript propagation, MCP mesh_status poll) passes what it knows; the choke
+     * point evaluates it BEFORE writing the terminal ledger or queuing the coordinator
+     * completion. A veto returns { reconciled: false, reason } — callers treat that exactly
+     * like their other not-yet-proven outcomes (hold and re-evaluate next tick), so the held
+     * completion re-evaluates the causal evidence every pass and releases exactly once after
+     * the state clears (the terminal-ledger dedup above makes the release idempotent).
+     */
+    causalAdmission?: TranscriptSynthCausalAdmission;
     source?: string;
 }): {
     reconciled: boolean;

package/dist/providers/cli-provider-instance.d.ts

@@ -368,6 +368,25 @@ export declare class CliProviderInstance implements ProviderInstance {
      * 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(): boolean;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "1.0.28-rc.16",
+  "version": "1.0.28-rc.18",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,8 +49,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "1.0.28-rc.16",
-    "@adhdev/session-host-core": "1.0.28-rc.16",
+    "@adhdev/mesh-shared": "1.0.28-rc.18",
+    "@adhdev/session-host-core": "1.0.28-rc.18",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/cli-state-engine.ts

@@ -729,7 +729,25 @@ export class CliStateEngine {
         if (!session) return;
 
         const { status, messages } = session;
-        const modal = (session as any).activeModal ?? session.modal ?? null;
+        // RC17-APPROVAL-NO-MODAL: a provider's own detectStatus/parseSession script can
+        // report status='waiting_approval' with a modal object whose buttons array is
+        // empty (a half-rendered approval frame, or — as observed live on a Claude
+        // session with no actionable modal anywhere in the raw PTY — a bare status flip
+        // with no real prompt at all). Previously this raw modal was latched straight
+        // into this.activeModal and dispatched through applyWaitingApproval's
+        // ALREADY-actionable branch (line ~1042 below), which sets status +
+        // fires agent:waiting_approval unconditionally — the "!modal" hysteresis/warn
+        // path (the one place button-validity was actually enforced) only runs when the
+        // modal is null, not when it merely has no buttons. Treat a buttons-empty modal
+        // as no modal here so it flows into that same proven hysteresis: it warns, waits
+        // out approvalCooldown, and never fires an event unless a LATER settle pass
+        // observes a genuinely actionable modal. Mirrors hasNonEmptyCliModalButtons used
+        // elsewhere (resolveModal, stabilizeFlappingApprovalStatus) — same predicate,
+        // applied at the point the modal first enters the FSM.
+        const rawModal = (session as any).activeModal ?? session.modal ?? null;
+        const modal = rawModal && Array.isArray(rawModal.buttons) && rawModal.buttons.some(
+            (button: unknown) => typeof button === 'string' && button.trim().length > 0,
+        ) ? rawModal : null;
         const parsedStatus = (session as any).parsedStatus ?? null;
         const parsedMessages = normalizeCliParsedMessages(messages, {
             scope: null,

package/src/commands/chat-commands-read.ts

@@ -24,7 +24,7 @@ import {
     type ChatSourceTransitionCause,
 } from '../chat/source-resolver.js';
 import type { ChatMessage } from '../types.js';
-import { filterUserFacingChatMessages, isActivityChatMessage, isUserFacingChatMessage, normalizeChatMessages } from '../providers/chat-message-normalization.js';
+import { filterUserFacingChatMessages, isActivityChatMessage, isUserFacingChatMessage, normalizeChatMessages, hasTrailingToolActivityAfterFinalAssistant } from '../providers/chat-message-normalization.js';
 import {
     READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS,
     type RuntimeChatMessageMerger,
@@ -2480,11 +2480,43 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     });
                 }
             }
+            // RC17-NATIVE-FINAL-ASSISTANT-MIDTURN: hasFinalVisibleAssistantMessage only
+            // checks that the LAST visible native-transcript message is a non-empty
+            // assistant/model bubble — it has no notion of whether that bubble is
+            // actually the end of the turn. A live Claude repro showed this reconciling
+            // generating→idle on an INTERIM narration bubble ("Starting the collector
+            // now, before the two-turn protocol.") emitted mid-turn, well before the
+            // real two-turn protocol/tool work ran — exactly the false-completion class
+            // rc.16 (9452bd03/6677a565) closed for the mesh-event ingress via
+            // hasTrailingToolActivityAfterFinalAssistant + hasLiveTurnPendingEvidence.
+            // This read_chat status ingress is a SEPARATE consumer of the same
+            // native-final-assistant signal (it feeds the `status` field returned to
+            // read_chat/dashboard, not the mesh agent:generating_completed event) and
+            // never got the equivalent veto. This reconciliation exists precisely for a
+            // PTY/adapter status detector that never transitions to idle on its own (see
+            // read-chat-completed-session-fallback.test.ts's antigravity stuck-busy
+            // case: isProcessing() stays true forever, empty PTY messages, and native
+            // history is the only signal that ever resolves it) — so gating on the
+            // adapter's own pending-response bit here would neuter this reconciliation
+            // for that exact intended case. Apply only STRUCTURAL, evidence-based vetoes
+            // instead, mirroring rc.16's hasLiveTurnPendingEvidence: trailing tool/
+            // terminal activity after the final-looking assistant bubble, scanned in (a)
+            // the native messages being judged — the transcript's own admission that its
+            // "final" bubble kept going — and (b) the live PTY-parsed tail
+            // (returnedMessages), which carries no native-transcript write-lag and is
+            // exactly how a live Claude repro was caught: the native JSONL's last row was
+            // still the interim narration bubble (no trailing tool row landed there yet),
+            // but the PTY had already rendered the very next "Auto-approved: Yes\nBash
+            // command" tool activity. The antigravity stuck-busy case has an EMPTY PTY
+            // message list, so (b) is a no-op there (the function short-circuits false on
+            // an empty/absent array) and the existing regression is unaffected.
             if (
                 isGeneratingLikeStatus(selectedStatus)
                 && selectedTranscriptAuthority === 'provider'
                 && !hasNonEmptyModalButtons(activeModal)
                 && hasFinalVisibleAssistantMessage(selectedMessages)
+                && !hasTrailingToolActivityAfterFinalAssistant(selectedMessages as any)
+                && !hasTrailingToolActivityAfterFinalAssistant(returnedMessages as any)
             ) {
                 selectedStatus = 'idle';
                 selectedMessages = finalizeStreamingMessagesWhenIdle(selectedMessages, selectedStatus);

package/src/index.ts

@@ -536,6 +536,7 @@ export {
   CHAT_MESSAGE_ACTIVITY_SOURCES,
   CHAT_MESSAGE_INTERNAL_SOURCES,
   classifyChatMessageVisibility,
+  hasTrailingToolActivityAfterFinalAssistant,
   isUserFacingChatMessage,
   isActivityChatMessage,
   isInternalChatMessage,

package/src/mesh/mesh-completion-synthesis.ts

@@ -25,7 +25,7 @@ import { daemonIdListIncludes } from './mesh-reconcile-identity.js';
 import { getActiveDirectDispatches, getQueue } from './mesh-work-queue.js';
 import { readLedgerEntries } from './mesh-ledger.js';
 import { pruneStaleDirectDispatches } from './mesh-active-work.js';
-import { reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
+import { reconcileDirectDispatchCompletionFromTranscript, resolveLiveTurnPendingEvidence } from './mesh-events-stale.js';
 import { extractFinalAssistantSummaryEvidence, hasTrailingToolActivityAfterFinalAssistant, readChatMessageTimestampMs } from '../providers/chat-message-normalization.js';
 import type { ChatMessage } from '../types.js';
 import {
@@ -230,6 +230,29 @@ export async function reconcileUnterminatedDirectDispatches(
         const messages = Array.isArray(payload.messages) ? payload.messages as ChatMessage[] : [];
         const evidence = extractFinalAssistantSummaryEvidence(messages);
 
+        // MID-TURN-CAUSAL-ADMISSION (rc.16, trailing-tool veto): the latest final-LOOKING
+        // assistant bubble is followed by tool/terminal activity — the worker emitted interim
+        // narration ("Let me find…") and is still running tools; the bubble is a preamble,
+        // not a turn end. This is the exact false-completion shape of the verified incidents
+        // (weak synth after an interim progress sentence while tools continued), and PHASE 4
+        // previously never ran the veto pollAssignedTaskTerminalEvidence has. The veto applies
+        // to EVERY synth path below — never-acked first-idle, acked fast-track, AND the death
+        // deadline: a stale weak interim summary must not become final merely because a
+        // timeout fired while newer transcript/tool activity exists. The fast-track streak is
+        // reset so the continuous idle-with-final-assistant run must restart from the genuine
+        // final bubble. This cannot wedge: the next tick re-reads and re-evaluates (a genuine
+        // final assistant lands AFTER the last tool call, completing one tick later), and the
+        // hold is still released by the session-death read-failure backstop / stranded-reclaim
+        // / orphan-prune nets if the worker truly goes away.
+        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}) — 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;
@@ -357,6 +380,17 @@ export async function reconcileUnterminatedDirectDispatches(
                 // 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) {

package/src/mesh/mesh-event-forwarding.ts

@@ -687,6 +687,31 @@ function evaluateMeshEventSuppression(
                 };
             }
         }
+        // NO-DISPATCH-NATIVE-COMPLETION-GATE (rc.16 follow-up): a session that was launched
+        // but never given ANY task can still emit its own native agent:generating_completed off
+        // a startup/greeting artifact (e.g. cursor-cli's "→ Plan, search, build anything" idle
+        // prompt right after boot) — the WARMUPGAP note on markSessionTerminal below already
+        // recognizes this shape (no echoed taskId, no active assignment) but only skips the
+        // dispatch-row side effect; the event itself still becomes a coordinator-visible
+        // task_completed. Suppress it outright here, narrowly: the event carries no taskId, the
+        // session holds no active assignment (queue OR direct-dispatch), AND the session has NO
+        // terminal ledger history at all (a session with a PRIOR terminal has been dispatched at
+        // least once before and falls through to the existing terminal/dedup logic below
+        // unchanged). Structural/causal only — no message-content inspection. A completion that
+        // is NOT weak (a real final summary / worker result, not a bare false-idle status flag)
+        // still passes through: a session that was somehow handed a genuine answer without a
+        // tracked dispatch must not have that answer silently dropped.
+        if (!readNonEmptyString(args.metadataEvent.taskId)
+            && !sessionHasActiveAssignment(args.meshId, eventSessionId)
+            && !findRecentTerminalLedgerEvidence({ meshId: args.meshId, sessionId: eventSessionId, nodeId: eventNodeId || undefined })
+            && 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 — 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 },
+            };
+        }
         // CAUSAL-COMPLETION-GATE (Fix A): fail closed ONLY for the scoped auto-launch race —
         // an in-window, still-'pending' task whose autoLaunch record names this exact session,
         // with neither a consumed delivery nor a matching task_dispatched ledger entry. Every

package/src/mesh/mesh-events-stale.ts

@@ -5,6 +5,7 @@ import { markSessionDeliveriesTerminal } from './mesh-delivery-policy.js';
 import { queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { readNonEmptyString, readRecord, resolveEventSessionId, readWorkerResultMetadata, isWeakCompletionEvidence, buildMeshSystemMessage } from './mesh-events-utils.js';
 import { recordDebugTrace } from '../logging/debug-trace.js';
+import { LOG } from '../logging/logger.js';
 import { meshNodeIdMatches, sessionIdsEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 
 // EARLYNOTIFY-GATEBYPASS (d): every completed-emit producer that bypasses the CLI-provider
@@ -40,6 +41,88 @@ function recordSynthCompletionGateTrace(stage: string, payload: Record<string, u
 const DIRECT_DISPATCH_RECONCILE_GRACE_MS = 60_000;
 const DIRECT_DISPATCH_IDLE_SESSION_RECONCILE_GRACE_MS = 120_000;
 
+// ---------------------------------------------------------------------------
+// MID-TURN-CAUSAL-ADMISSION (rc.16 unified completion ingress)
+// ---------------------------------------------------------------------------
+// Verified incidents: the coordinator received a WEAK synthesized completion mid-turn —
+// after an interim narration bubble ("Let me find…") — while the worker's raw PTY still
+// showed `Working (43s)` and further tool calls continued. Every transcript-synth ingress
+// (reconcile-loop PHASE 4, the assigned-stranded watchdog's transcript propagation, the MCP
+// mesh_status poll) funnels through reconcileDirectDispatchCompletionFromTranscript, which
+// queues the coordinator completion DIRECTLY — bypassing the injectMeshSystemMessage →
+// evaluateMeshEventSuppression → hasLiveTurnPendingEvidence gate (3a48f660) that protects
+// the native provider-event path. evaluateTranscriptSynthAdmission is the ONE reusable
+// causal admission point closing that bypass: every synth caller passes its causal evidence
+// through the `causalAdmission` arg and the choke point enforces it uniformly.
+export interface TranscriptSynthCausalAdmission {
+    /**
+     * Synchronous re-check of a resolvable LOCAL live instance's CURRENT turn state — the
+     * same hasLiveTurnPendingEvidence() discriminator the 3a48f660 mid-turn gate uses on the
+     * native-event path. A pending verdict VETOES an eager transcript synth. Fail-open by
+     * construction: absent (remote/unknown session, separate-process caller), not a function,
+     * or throwing → no veto; the caller's bounded transcript evidence/settle behavior remains
+     * the operative net, so a missing transcript source never wedges.
+     */
+    liveTurnPendingEvidence?: () => boolean;
+    /**
+     * The caller is a BOUNDED last-resort backstop firing at its max-wait (the acked-hold
+     * death deadline, the delivered-no-turn redrive deadline). A bounded backstop overrides
+     * the live-pending veto — preserving the genuine-final fail-open / max-wait semantics —
+     * but NEVER overrides the trailing-tool veto (a stale weak interim summary must not
+     * become final merely because a timeout fired while newer transcript/tool activity
+     * exists).
+     */
+    boundedBackstop?: boolean;
+    /**
+     * The caller's transcript read shows tool/terminal activity AFTER the latest final-looking
+     * assistant bubble (hasTrailingToolActivityAfterFinalAssistant) — the bubble is interim
+     * narration ("Let me explore…"), the turn is still executing. Absolute veto: the worker is
+     * demonstrably alive and mid-turn, so even a bounded backstop keeps holding (the hold is
+     * still released by the session-death read-failure backstop and the stranded-reclaim /
+     * orphan-prune nets, so this cannot wedge forever).
+     */
+    trailingToolActivityAfterFinalAssistant?: boolean;
+}
+
+export type TranscriptSynthAdmissionVerdict =
+    | { admitted: true }
+    | { admitted: false; reason: 'live_turn_pending_evidence' | 'trailing_tool_activity_after_final_assistant' };
+
+export function evaluateTranscriptSynthAdmission(admission?: TranscriptSynthCausalAdmission): TranscriptSynthAdmissionVerdict {
+    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 { /* fail open — never block on a diagnostic throw */ }
+        if (pending) return { admitted: false, reason: 'live_turn_pending_evidence' };
+    }
+    return { admitted: true };
+}
+
+/**
+ * Resolve the liveTurnPendingEvidence probe for `sessionId` from a components-shaped object
+ * (anything exposing instanceManager.getInstance). Returns undefined when no live instance
+ * resolves or the instance does not expose hasLiveTurnPendingEvidence — the fail-open
+ * remote/unknown case. Shared by every transcript-synth caller so the probe is resolved ONE
+ * way (UNIFY: same discriminator as the 3a48f660 native-event gate).
+ */
+export function resolveLiveTurnPendingEvidence(
+    components: { instanceManager?: { getInstance?: (sessionId: string) => unknown } } | undefined,
+    sessionId: string,
+): (() => boolean) | undefined {
+    try {
+        const instance = components?.instanceManager?.getInstance?.(sessionId) as
+            { hasLiveTurnPendingEvidence?: () => boolean } | undefined;
+        if (typeof instance?.hasLiveTurnPendingEvidence !== 'function') return undefined;
+        const probe = instance.hasLiveTurnPendingEvidence.bind(instance);
+        return () => probe();
+    } catch {
+        return undefined; // resolution itself failed → fail open
+    }
+}
+
 export function findRecentTerminalLedgerEvidence(args: {
     meshId: string;
     sessionId?: string;
@@ -229,6 +312,17 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
      * Direct-dispatch callers omit it → the gates apply exactly as before (no regression).
      */
     preValidatedTranscriptEvidence?: boolean;
+    /**
+     * MID-TURN-CAUSAL-ADMISSION (rc.16): causal admission evidence for the unified guard —
+     * see TranscriptSynthCausalAdmission. Every transcript-synth caller (PHASE 4 reconcile,
+     * watchdog transcript propagation, MCP mesh_status poll) passes what it knows; the choke
+     * point evaluates it BEFORE writing the terminal ledger or queuing the coordinator
+     * completion. A veto returns { reconciled: false, reason } — callers treat that exactly
+     * like their other not-yet-proven outcomes (hold and re-evaluate next tick), so the held
+     * completion re-evaluates the causal evidence every pass and releases exactly once after
+     * the state clears (the terminal-ledger dedup above makes the release idempotent).
+     */
+    causalAdmission?: TranscriptSynthCausalAdmission;
     source?: string;
 }): { reconciled: boolean; kind?: MeshLedgerKind; alreadyTerminal?: boolean; workerResult?: unknown; ledgerEntryId?: string; reason?: string } {
     const finalSummary = readNonEmptyString(args.finalSummary);
@@ -251,6 +345,21 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
         return { reconciled: false, alreadyTerminal: true, reason: 'terminal_ledger_entry_exists' };
     }
 
+    // MID-TURN-CAUSAL-ADMISSION (rc.16): the unified guard every gate-bypassing synth must
+    // pass. Ordered BEFORE any ledger write / queue so a vetoed synth leaves no trace other
+    // than the completion-gate trace (observability parity with the synth-fire trace below).
+    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} — 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 || new Date().toISOString();

package/src/mesh/mesh-reconcile-loop.ts

@@ -64,7 +64,7 @@ import { getQueue, reclaimStrandedAssignedTask, updateTaskStatus } from './mesh-
 import { resolveSessionBusyVerdict, runContinuousAutoFastForwardScan, runPendingCoordinatorCatchupScan } from './mesh-queue-assignment.js';
 import { readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerEntry } from './mesh-ledger.js';
-import { findTerminalLedgerEvidenceForTask, reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
+import { findTerminalLedgerEvidenceForTask, reconcileDirectDispatchCompletionFromTranscript, resolveLiveTurnPendingEvidence } from './mesh-events-stale.js';
 import {
     resolveCoordinatorDaemonIds,
     daemonHostsMesh,
@@ -945,18 +945,24 @@ async function evaluateEarlyIdleTranscriptArm(
 // synth is marked WEAK so the worker's own later emit can still supersede it rather than being
 // dropped as a duplicate. That is the dedup guarantee: at most one [System] completion surfaces.
 //
-// Returns true if a terminal ledger for this task now exists (freshly written OR already present) —
-// the caller then skips its own bare-payload ledger write, which lacked the finalSummary entirely.
+// Returns 'propagated' if a terminal ledger for this task now exists (freshly written OR
+// already present) — the caller then skips its own bare-payload ledger write, which lacked
+// the finalSummary entirely. Returns 'deferred' when the MID-TURN-CAUSAL-ADMISSION guard
+// vetoed the synth on live mid-turn evidence — the caller must HOLD (no row flip, no bare
+// ledger write) and re-evaluate next tick. Returns 'unavailable' when propagation could not
+// run — the caller falls back to its bare ledger write (unchanged legacy behavior).
 function propagateWatchdogTranscriptCompletion(
+    components: DaemonComponents,
     meshId: string,
     row: { id: string; assignedNodeId?: string; assignedSessionId?: string; assignedProviderType?: string; dispatchTimestamp?: string },
     evidence: AssignedTaskTerminalEvidence,
     source: string,
-): boolean {
+    opts?: { boundedBackstop?: boolean },
+): 'propagated' | 'deferred' | 'unavailable' {
     const sessionId = readNonEmptyString(row.assignedSessionId) || evidence.sessionId;
     if (!sessionId || !readNonEmptyString(evidence.finalSummary)) {
         // No routable session or no summary to carry — fall back to the caller's bare ledger write.
-        return false;
+        return 'unavailable';
     }
     try {
         const result = reconcileDirectDispatchCompletionFromTranscript({
@@ -972,15 +978,30 @@ function propagateWatchdogTranscriptCompletion(
             // 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,
         });
         // reconciled → freshly queued the coordinator completion; alreadyTerminal → a terminal
         // ledger (a real emit that raced in, or a prior watchdog synth) is already present. Either
         // way a finalSummary-bearing completion has been (or will be) delivered; the caller must NOT
         // add its summary-less ledger row on top.
-        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'; // mid-turn causal evidence — HOLD; do not complete this tick
+        }
+        return 'unavailable';
     } catch {
-        return false; // best-effort — fall back to the caller's bare ledger write
+        return 'unavailable'; // best-effort — fall back to the caller's bare ledger write
     }
 }
 
@@ -1062,6 +1083,29 @@ async function recoverStrandedAssignedDispatches(
                     minFinalAssistantAgeMs: ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS,
                 });
                 if (terminalEvidence) {
+                    // MID-TURN-CAUSAL-ADMISSION (rc.16): propagate FIRST. When the unified guard
+                    // defers (the LOCAL live adapter still reports the turn pending — transcript
+                    // idle-with-final-assistant can straddle a genuinely mid-turn worker), HOLD
+                    // the entire completion: no row flip, no bare ledger write, no queued event.
+                    // The streak resets so it re-accumulates; the next qualifying tick re-polls
+                    // and re-evaluates, releasing exactly once after the live state clears.
+                    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) — 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);
                     // WATCHDOG-FINALSUMMARY-LOST: propagate the completion to the coordinator WITH the
@@ -1069,9 +1113,7 @@ async function recoverStrandedAssignedDispatches(
                     // generating_completed produces — instead of only tracing a structural DROP. When
                     // propagation delivered (or a terminal ledger already exists), skip the bare
                     // summary-less ledger write below; only fall back to it if propagation could not run.
-                    const propagated = propagateWatchdogTranscriptCompletion(
-                        meshId, row, terminalEvidence, 'early_idle_transcript_evidence',
-                    );
+                    const propagated = propagation === 'propagated';
                     if (!propagated && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
                         try {
                             appendLedgerEntry(meshId, {
@@ -1388,9 +1430,14 @@ async function recoverStrandedAssignedDispatches(
                 // WATCHDOG-FINALSUMMARY-LOST: propagate the finalSummary-bearing completion to the
                 // coordinator (same [System] notification as the native path); only fall back to the
                 // bare summary-less ledger write when propagation could not run.
-                const propagated = propagateWatchdogTranscriptCompletion(
-                    meshId, row, terminalEvidence, 'redrive_deadline_transcript_evidence',
+                // MID-TURN-CAUSAL-ADMISSION: this is the BOUNDED max-wait net (the 15-min
+                // delivered-no-turn deadline) — boundedBackstop preserves the genuine-final
+                // fail-open semantics against the live-pending veto.
+                const propagation = propagateWatchdogTranscriptCompletion(
+                    components, meshId, row, terminalEvidence, 'redrive_deadline_transcript_evidence',
+                    { boundedBackstop: true },
                 );
+                const propagated = propagation === 'propagated';
                 if (!propagated && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
                     try {
                         appendLedgerEntry(meshId, {

package/src/providers/cli-provider-instance.ts

@@ -1222,9 +1222,35 @@ export class CliProviderInstance implements ProviderInstance {
      * 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(): boolean {
-        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 as ChatMessage[])) return true;
+            }
+        } catch { /* fail open — a probe error must never fabricate pending evidence */ }
+        return false;
     }
 
     /**