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

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/mesh/mesh-queue-assignment.d.ts

@@ -31,6 +31,7 @@ interface AwaitClaimBackoffState {
 }
 export declare function __resetAutoLaunchAwaitClaimBackoffForTests(): void;
 export declare function __seedAutoLaunchAwaitClaimBackoffForTests(meshId: string, taskId: string, state: AwaitClaimBackoffState): void;
+export declare function isIdleSessionState(state: any): boolean;
 /** Active assignments that hold the one-active-per-node / global-parallel invariant
  *  (everything except read-only diagnoses, which run unbounded by the write cap). */
 export declare function activeWriteAssignedCount(meshId: string): number;

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

@@ -355,6 +355,40 @@ export declare class CliProviderInstance implements ProviderInstance {
     private isTransientToolConsent;
     /** True when this session is parked on a modal awaiting a human answer. */
     isModalParked(): boolean;
+    /**
+     * 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
+     * unresolved work. Public wrapper so the coordinator (mesh-event-forwarding) can
+     * independently re-verify an incoming agent:generating_completed for a LOCAL session
+     * before trusting it — defense-in-depth against a race where the completion emit and the
+     * coordinator's receipt straddle a state change (screen-redraw parse artifact, decoupled-
+     * immediate emit). Reuses the EXACT same discriminators this instance's own finalization
+     * gate (getCompletedFinalizationBlock) uses — hasAdapterPendingResponse() (adapter
+     * isWaitingForResponse / currentTurnScope / isProcessing() / a non-empty partial response)
+     * 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;
     /**
      * PTY-OVERTRUST-DRAIN (Defect B). The deliverability/drain status the mesh
      * reconcile loop must consult — the RAW adapter turn-state, with the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "1.0.28-rc.15",
+  "version": "1.0.28-rc.17",
   "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.15",
-    "@adhdev/session-host-core": "1.0.28-rc.15",
+    "@adhdev/mesh-shared": "1.0.28-rc.17",
+    "@adhdev/session-host-core": "1.0.28-rc.17",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -1161,7 +1161,13 @@ export class ProviderCliAdapter implements CliAdapter {
                     : 1;
                 this.staticIdlePollStreak += 1;
                 if (this.staticIdlePollStreak >= requiredStreak) {
-                    this.engine.confirmPollStaticIdle('poll_static_idle');
+                    if (this.engine.confirmPollStaticIdle('poll_static_idle')) {
+                        // This transition originates from the read-only status poll rather
+                        // than PTY output. Propagate it through the same instance callback as
+                        // output-driven FSM transitions so completion bookkeeping observes
+                        // generating→idle and can arm/finalize the pending completion.
+                        this.onStatusChange?.();
+                    }
                     this.staticIdlePollStreak = 0;
                 }
             } else {

package/src/commands/med-family/cli-agent.ts

@@ -15,6 +15,7 @@ import { getRecentActivity } from '../../config/recent-activity.js';
 import { getSavedProviderSessions } from '../../config/saved-sessions.js';
 import { listProviderHistorySessions } from '../../config/chat-history.js';
 import { buildMeshWorkerRelayStamp, readNonEmptyString } from '../../mesh/mesh-events-utils.js';
+import { isIdleSessionState } from '../../mesh/mesh-queue-assignment.js';
 import { LOG } from '../../logging/logger.js';
 import { readStringValue } from '../router.js';
 import type { MedFamilyContext, MedFamilyHandler } from './types.js';
@@ -231,8 +232,8 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
         // completion event sits in the pending queue until a read_chat reconcile drains
         // it. Stamping here makes a reused/relaunched remote session relay-safe at
         // dispatch time even when it was not launched via mesh_launch_session.
+        const dispatchSessionId = readStringValue(args?.targetSessionId, (args as any)?.sessionId, (args as any)?.instanceId);
         {
-            const dispatchSessionId = readStringValue(args?.targetSessionId, (args as any)?.sessionId, (args as any)?.instanceId);
             const dispatchMeshContext = args?.meshContext as Record<string, unknown> | undefined;
             if (dispatchSessionId && dispatchMeshContext) {
                 try {
@@ -289,18 +290,36 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
                 // by the local queue-claim gate too so remote and local dispatch agree on when to defer.
                 const { shouldDeferDispatchForBootstrap } = await import('../../mesh/worktree-bootstrap-config.js');
                 if (shouldDeferDispatchForBootstrap(nodeObj as any)) {
-                    return {
-                        success: false,
-                        recoverable: true,
-                        dispatched: false,
-                        code: 'mesh_node_bootstrap_pending',
-                        reason: 'bootstrap_still_running',
-                        nodeId: dispatchNodeId,
-                        meshId: dispatchMeshId,
-                        ...(readStringValue(meshCtx?.taskId) ? { taskId: readStringValue(meshCtx?.taskId) } : {}),
-                        error: `Node '${dispatchNodeId}' worktree bootstrap is still running; a task injected now would land in the session input buffer before the provider is ready to consume it and be silently lost. Dispatch deferred.`,
-                        nextAction: 'Wait for the worktree_bootstrap_complete event (or poll mesh_status until the node session is ready), then re-send the task with mesh_send_task. Alternatively use mesh_enqueue_task so the queue auto-assigns it once a ready session is available.',
-                    };
+                    // BOOTSTRAP-POLICY-CONSISTENCY (Fix B, rc.15 orchestration RCA): the node-level
+                    // worktreeBootstrap.status flag is COARSE — it can read stale 'running' (the
+                    // detached async persist chain lags the inline stamp) even though the explicit
+                    // mesh_send_task caller already independently confirmed, via its own live
+                    // get_status_metadata probe, that the PINNED target session is genuinely ready.
+                    // Refusing that dispatch anyway is a false block. Narrowest safe override: only
+                    // when the caller named a specific target session AND that session's live status
+                    // — re-probed here via the same isIdleSessionState liveness check the queue
+                    // assignment gate uses — is independently confirmed idle right now. A session
+                    // that is starting / generating / waiting_approval / any other non-idle status
+                    // never qualifies, so this can never mask a genuinely half-built worktree.
+                    const dispatchSessionState = dispatchSessionId
+                        ? ctx.deps.instanceManager?.getInstance?.(dispatchSessionId)?.getState?.()
+                        : undefined;
+                    const sessionConfirmedReady = !!dispatchSessionState && isIdleSessionState(dispatchSessionState);
+                    if (!sessionConfirmedReady) {
+                        return {
+                            success: false,
+                            recoverable: true,
+                            dispatched: false,
+                            code: 'mesh_node_bootstrap_pending',
+                            reason: 'bootstrap_still_running',
+                            nodeId: dispatchNodeId,
+                            meshId: dispatchMeshId,
+                            ...(readStringValue(meshCtx?.taskId) ? { taskId: readStringValue(meshCtx?.taskId) } : {}),
+                            error: `Node '${dispatchNodeId}' worktree bootstrap is still running; a task injected now would land in the session input buffer before the provider is ready to consume it and be silently lost. Dispatch deferred.`,
+                            nextAction: 'Wait for the worktree_bootstrap_complete event (or poll mesh_status until the node session is ready), then re-send the task with mesh_send_task. Alternatively use mesh_enqueue_task so the queue auto-assigns it once a ready session is available.',
+                        };
+                    }
+                    LOG.info('MeshQueue', `Overriding stale worktreeBootstrap 'running' flag for node ${dispatchNodeId}: explicit target session ${dispatchSessionId} is independently confirmed idle/ready — dispatching mesh_send_task directly.`);
                 }
             } catch { /* best-effort — if the bootstrap probe fails, fall through and dispatch */ }
         }

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

@@ -505,6 +505,50 @@ function resolveActiveDirectDispatchTaskId(meshId: string, sessionId: string): s
     }
 }
 
+// ---------------------------------------------------------------------------
+// CAUSAL-COMPLETION-GATE (Fix A, rc.15 orchestration RCA): auto-launch sessions can emit a
+// spurious agent:generating_completed before the task was ever delivered to / consumed by the
+// session — a freshly spawned worker's boot/idle-prompt output can be misread by the provider's
+// own completion detector as a finished turn (totalMessages=0: the worker never actually
+// processed the task). The provider's weak/false-idle self-report is not guaranteed to catch a
+// pure boot artifact, so this is an INDEPENDENT, coordinator-side check scoped to the exact race:
+// a task still 'pending' whose in-window autoLaunch record names THIS session. For that narrow
+// case we require causal evidence — the delivery was consumed (taskDeliveryConsumed) or a
+// task_dispatched ledger entry proves the turn actually started — before letting the completion
+// through. An already-claimed/dispatched task (the overwhelming majority of completions) never
+// matches (its status is no longer 'pending'), so this never broadens into general suppression.
+// ---------------------------------------------------------------------------
+
+// The in-window, not-yet-claimed queue task (if any) whose autoLaunch record names this exact
+// session. Bounded to AUTO_LAUNCH_AWAIT_CLAIM_MS — the same window the claim-churn/respawn guards
+// use — so a task whose autoLaunch attempt is long expired (and has since moved on to backoff /
+// direct-dispatch fallback, or a fresh auto-launch attempt) is never matched here.
+function findInWindowUnclaimedAutoLaunchTask(meshId: string, sessionId: string, nowMs: number): MeshWorkQueueEntry | undefined {
+    return getQueue(meshId, { status: ['pending'] }).find(task => {
+        const al = task.autoLaunch;
+        if (!al || al.status !== 'completed' || !al.sessionId) return false;
+        if (!sessionIdsEquivalent(al.sessionId, sessionId)) return false;
+        const launchedAtMs = Date.parse(al.updatedAt);
+        return Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+    });
+}
+
+// Turn-start evidence distinct from taskDeliveryConsumed: a task_dispatched ledger entry naming
+// BOTH this taskId and this sessionId proves the coordinator itself recorded a genuine dispatch
+// of this task onto this session. A task still 'pending' (the only case this gate applies to)
+// normally has no such entry — task_dispatched is written when the claim transitions the row to
+// 'assigned' — so this is a defensive alternate signal, not the expected path.
+function hasMatchingTaskDispatchedLedgerEntry(meshId: string, taskId: string, sessionId: string): boolean {
+    const entries = readLedgerEntries(meshId, { tail: 200 });
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.kind !== 'task_dispatched') continue;
+        if (!sessionIdsEquivalent(entry.sessionId, sessionId)) continue;
+        if (readNonEmptyString(entry.payload?.taskId) === taskId) return true;
+    }
+    return false;
+}
+
 // Coordinator-side suppression/reconcile gate for an incoming mesh event. Each clause is a
 // closed dedup/suppression concern that only inspects the event + already-resolved context and
 // either (a) returns a `suppress` result the caller forwards verbatim, (b) returns a `reconcile`
@@ -528,12 +572,13 @@ function evaluateMeshEventSuppression(
         eventNodeId: string;
         eventTimestamp: number | null;
         workerCoordinatorDaemonId: string | undefined;
+        components: DaemonComponents;
     },
 ):
     | { kind: 'suppress'; result: { success: true; forwarded: 0; suppressed: true; [extra: string]: unknown } }
     | { kind: 'reconcile'; metadataEvent: Record<string, unknown> }
     | null {
-    const { traceCtx, eventSessionId, eventNodeId, eventTimestamp, workerCoordinatorDaemonId } = ctx;
+    const { traceCtx, eventSessionId, eventNodeId, eventTimestamp, workerCoordinatorDaemonId, components } = ctx;
 
     const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
         event: args.event,
@@ -603,6 +648,88 @@ function evaluateMeshEventSuppression(
         }
     }
     if (args.event === 'agent:generating_completed' && eventSessionId) {
+        // MID-TURN-LIVE-STATE-GATE (broader false-idle RCA, mid-turn follow-up): before trusting
+        // ANY incoming completion, independently re-verify a resolvable LOCAL live instance's
+        // CURRENT turn state — not just the event's self-reported diagnostic — via the exact same
+        // discriminators the instance's OWN emission gate (getCompletedFinalizationBlock) uses
+        // (adapter pending-response: isWaitingForResponse / currentTurnScope / isProcessing() /
+        // a non-empty partial response; or a live approval/choice modal). A screen-redraw parse
+        // artifact, a decoupled-immediate emit, or a TOCTOU between emit and receipt can let a
+        // genuinely mid-turn session's completion reach here; this is a stateless, synchronous
+        // safety net for that race.
+        //
+        // Scope: ONLY when components.instanceManager.getInstance(sessionId) resolves a live
+        // instance exposing hasLiveTurnPendingEvidence() — i.e. a co-located worker/coordinator or
+        // single-daemon (standalone) topology. A REMOTE session (no live instance on this daemon)
+        // is untouched by this gate — absence of a resolvable instance is NOT treated as pending
+        // evidence, so a remote/unknown session is never fail-closed here; its existing async
+        // reconcile-loop protections (evaluateEarlyIdleTranscriptArm, transcript trailing-tool-
+        // activity checks) remain the operative safety net, unchanged.
+        //
+        // Bounded / never wedges: this SUPPRESSES only the ONE premature event and persists no new
+        // hold state — it relies on the adapter's OWN bounded finalization retry (which already
+        // owns re-emitting once genuinely idle, COMPLETED_FINALIZATION_MAX_WAIT_MS) plus the
+        // existing reconcile-loop completion nets (PHASE 4 transcript synth, assigned-stranded
+        // deadline, acked-hold death backstop) as fail-open backstops if the adapter's re-emit is
+        // itself ever lost. A later genuine completion (pending evidence cleared) is NOT touched by
+        // this gate and is processed normally.
+        const liveInstance = components.instanceManager?.getInstance?.(eventSessionId) as
+            { hasLiveTurnPendingEvidence?: () => boolean } | undefined;
+        if (typeof liveInstance?.hasLiveTurnPendingEvidence === 'function') {
+            let midTurnPending = false;
+            try { midTurnPending = liveInstance.hasLiveTurnPendingEvidence() === true; } catch { /* fail open — never block on a diagnostic throw */ }
+            if (midTurnPending) {
+                LOG.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) — 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 },
+                };
+            }
+        }
+        // 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
+        // other completion (already-claimed tasks, direct dispatches, expired auto-launch
+        // windows) falls through unchanged to the existing dedup/terminal-ledger logic below.
+        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);
+            if (!causalEvidence) {
+                LOG.warn('MeshEvents', `Suppressed premature agent:generating_completed for auto-launch session ${eventSessionId} (mesh ${args.meshId}): task ${inWindowTask.id} delivery not yet consumed and no turn-start evidence — likely a boot artifact before the task was ever dispatched`);
+                traceMeshEventDrop('autolaunch_completion_before_causal_evidence', traceCtx, `taskId=${inWindowTask.id}`);
+                return {
+                    kind: 'suppress',
+                    result: { success: true, forwarded: 0, suppressed: true, autoLaunchCausalGateFailed: true, taskId: inWindowTask.id },
+                };
+            }
+        }
         const terminal = findRecentTerminalLedgerEvidence({
             meshId: args.meshId,
             sessionId: eventSessionId,
@@ -1056,6 +1183,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         eventNodeId,
         eventTimestamp,
         workerCoordinatorDaemonId,
+        components,
     });
     if (suppression) {
         if (suppression.kind === 'reconcile') {

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-queue-assignment.ts

@@ -1331,7 +1331,12 @@ function isTerminalSessionStatus(status: string): boolean {
     return ['stopped', 'failed', 'terminated', 'exited', 'closed'].includes(status);
 }
 
-function isIdleSessionState(state: any): boolean {
+// Exported (Fix B, rc.15 orchestration RCA) so the explicit mesh_send_task dispatch path
+// (med-family/cli-agent.ts) can reuse the SAME status/liveness probe to independently confirm a
+// pinned target session is genuinely ready before overriding the coarse worktreeBootstrap
+// 'running' defer for that one session. Never returns true for 'starting' / 'waiting_approval' /
+// 'generating' / any other non-idle status — those still refuse the override.
+export function isIdleSessionState(state: any): boolean {
     const status = readNonEmptyString(state?.status).toLowerCase();
     if (isTerminalSessionStatus(status)) return false;
     return status === 'idle' || state?.activeChat?.status === 'waiting_input';
@@ -1387,6 +1392,19 @@ function nodeHasActiveMeshWork(components: DaemonComponents, meshId: string, nod
 
 function isLaunchableNode(node: any): boolean {
     if (!node || node.status === 'disabled' || node.status === 'removed') return false;
+    // BOOTSTRAP-POLICY-CONSISTENCY (Fix B, rc.15 orchestration RCA): a worktree node whose
+    // bootstrap is still 'running' must be excluded from auto-launch candidacy, not merely
+    // deferred at claim time. Before this, isLaunchableNode passed a bootstrapping node through,
+    // so maybeAutoLaunchOneQueueSession could spawn a session (launch_cli) on it — an ORPHAN,
+    // since tryAssignQueueTask's own bootstrap gate (mirrors this same predicate) then defers the
+    // claim onto that freshly-spawned session anyway, leaving it stranded with nothing assigned
+    // while the node's real bootstrap-driven session comes up separately. Reusing
+    // shouldDeferDispatchForBootstrap (rather than a raw status check) keeps this in agreement
+    // with the claim gate's stale-running backstop: a 'running' stamp old enough and verified
+    // git-clean is treated as silently complete and does not block launch.
+    if (shouldDeferDispatchForBootstrap(node as { worktreeBootstrap?: { status?: string; startedAt?: string; updatedAt?: string; completedAt?: string }; workspace?: string })) {
+        return false;
+    }
     // Delegate the health gate to the shared resolver so the auto-launch gate and the
     // MAGI fan-out planner agree on exactly what "launchable health" means (online /
     // unknown / absent pass; degraded / offline / dirty / wrong_branch are blocked).