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

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,21 @@ 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.
+     */
+    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.16",
   "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.16",
+    "@adhdev/session-host-core": "1.0.28-rc.16",
     "@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/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,63 @@ 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 },
+                };
+            }
+        }
+        // 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 +1158,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         eventNodeId,
         eventTimestamp,
         workerCoordinatorDaemonId,
+        components,
     });
     if (suppression) {
         if (suppression.kind === 'reconcile') {

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).

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

@@ -42,7 +42,7 @@ import {
     claimAntigravityConversation,
     releaseAntigravityOwner,
 } from './native-history/antigravity-claim-registry.js';
-import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind, extractFinalSummaryFromMessages, extractFinalSummaryFromMessagesAfter, readChatMessageTimestampMs } from './chat-message-normalization.js';
+import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind, extractFinalSummaryFromMessages, extractFinalSummaryFromMessagesAfter, readChatMessageTimestampMs, hasTrailingToolActivityAfterFinalAssistant } from './chat-message-normalization.js';
 import { workingDirBasename } from './working-dir.js';
 import { ManualAttendanceTracker } from './manual-attendance.js';
 import { buildCliStructuredInputPrompt } from './cli-provider-input-prompt.js';
@@ -1209,6 +1209,24 @@ export class CliProviderInstance implements ProviderInstance {
         return this.resolveModalParkStatus() !== null;
     }
 
+    /**
+     * 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.
+     */
+    hasLiveTurnPendingEvidence(): boolean {
+        return this.hasAdapterPendingResponse() || this.isModalParked();
+    }
+
     /**
      * PTY-OVERTRUST-DRAIN (Defect B). The deliverability/drain status the mesh
      * reconcile loop must consult — the RAW adapter turn-state, with the
@@ -1824,7 +1842,24 @@ export class CliProviderInstance implements ProviderInstance {
         // `completionHasFinalAssistantMessage(...) && !hasAdapterPendingResponse()` pairing already
         // used by the no-progress monitor reconcile path.
         const turnClosed = !this.hasAdapterPendingResponse();
-        if (this.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt)) {
+        // TX-FSM Stage 2.1 (KIMI-PARSED-RACE): a native-source provider that ALSO ships a
+        // tui.transcriptPty scrape (kimi, like opencode/cursor-cli) keeps that scrape purely
+        // for LIVE status convenience — the manifest itself says "Chat is authoritative from
+        // nativeHistory; this PTY extraction only keeps live status available". But the parsed
+        // scrape carries no tool-activity concept at all (transcriptPty only extracts
+        // assistant/user text bullets), so an interim narration bullet Kimi renders just before
+        // firing a tool call ("코드와 로그를 병행으로 확인하겠습니다.") satisfies
+        // completionHasFinalAssistantMessage identically to a genuine final answer — and this
+        // early-return fires BEFORE the richer external-native evidence below is ever consulted,
+        // defeating the trailing-tool-activity veto and quiet-dwell guard added below it for
+        // this exact defect (live Kimi declaring completion on an interim transcript while the
+        // PTY kept generating). Skip the parsed short-circuit for the lease-gated canary
+        // (busyLeaseGateEnabled: kimi/codex-cli today) so the authoritative native transcript is
+        // judged first; codex-cli ships no transcriptPty so this is a no-op for it. Falls back to
+        // the parsed evidence below when the native transcript is unresolved (fail-open, same as
+        // before Stage 2.1).
+        const preferNativeOverParsed = (this.adapter as any)?.chatMessagesOwnedExternally === true && this.busyLeaseGateEnabled();
+        if (!preferNativeOverParsed && this.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt)) {
             return {
                 present: turnClosed,
                 messages: Array.isArray(parsedMessages) ? parsedMessages : [],
@@ -1850,8 +1885,19 @@ export class CliProviderInstance implements ProviderInstance {
             // the injected task's onTurnStarted fires, currentTurnStartedAt/currentTurnTaskId
             // bind to it and a real final bubble still fires completion normally.
             const injectedTaskGenerating = this.injectedTaskHasStartedGenerating();
+            // TX-FSM Stage 2.1 (KIMI-PARSED-RACE, trailing-tool-activity veto): mirrors the
+            // mesh coordinator's pollAssignedTaskTerminalEvidence guard (ledger 84594b15) on
+            // the WORKER's own local evidence. A native-source transcript that captures
+            // tool.call/tool.result as kind:'tool' bubbles (kimi's nativeHistory.records, after
+            // the provider-manifest fix) proves the last VISIBLE assistant bubble was narration
+            // ("Let me check the logs...") that fired a tool call, not the turn's genuine final
+            // answer. A provider whose native transcript never records tool activity (nothing to
+            // veto on) is unaffected — this can only ever turn a false present:true into false,
+            // never the reverse.
+            const trailingToolActivity = hasTrailingToolActivityAfterFinalAssistant(externalMessages as any);
             const present = injectedTaskGenerating
                 && turnClosed
+                && !trailingToolActivity
                 && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt);
             // Dashboard tail-repair cache: this runs on EVERY completion check
             // (mesh AND non-mesh — the non-mesh path suppresses the
@@ -1873,6 +1919,18 @@ export class CliProviderInstance implements ProviderInstance {
             };
         }
 
+        // TX-FSM Stage 2.1: the native transcript is unresolved (no session pinned yet, file
+        // not yet written) for a provider whose parsed short-circuit was skipped above — fall
+        // back to the parsed evidence now rather than reporting present:false forever. Fail-open,
+        // identical to the pre-Stage-2.1 behaviour for this narrow (transcript-unavailable) case.
+        if (preferNativeOverParsed && this.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt)) {
+            return {
+                present: turnClosed,
+                messages: Array.isArray(parsedMessages) ? parsedMessages : [],
+                source: 'parsed',
+            };
+        }
+
         return {
             present: false,
             messages: Array.isArray(parsedMessages) ? parsedMessages : [],
@@ -2336,6 +2394,43 @@ export class CliProviderInstance implements ProviderInstance {
             } catch { /* defensive: dwell read is best-effort — fall through to emit */ }
         }
 
+        // TX-FSM Stage 2.2 (KIMI-POST-FINAL-WEDGE): quiet-dwell protection for a
+        // lease-gated NATIVE-SOURCE provider's OWN evidence
+        // (source==='external-native', reached because preferNativeOverParsed skipped the
+        // parsed short-circuit above). Use the authoritative transcript file's mtime snapshot,
+        // produced by the SAME native-history read that supplied finalAssistantEvidence above,
+        // rather than raw PTY output recency. Kimi repaints its idle prompt/status after the
+        // genuine final answer, so lastOutputAt may advance forever even though wire.jsonl is
+        // quiet; using that cosmetic clock wedged the pending completion. Conversely, before a
+        // tool.call lands the interim narration itself has just advanced wire.jsonl, so the
+        // transcript clock preserves the narrow pre-tool quiet-dwell protection.
+        //
+        // The snapshot is bounded and fail-open: ageMs below the existing dwell holds and
+        // retries; a quiet transcript releases, while an unavailable/unresolved/clockless
+        // snapshot cannot block completion. Deliberately NOT scoped to
+        // allowMissingAssistantTimeout: this defect surfaces on a plain interactive session's
+        // own idle/completion notification just as much as a mesh worker's, so restricting it to
+        // autonomous mesh sessions would leave every non-mesh kimi session unprotected. A
+        // provider outside the lease canary (or without adapterOwnsMessagesElsewhere) never
+        // reaches this branch — untouched.
+        if (adapterOwnsMessagesElsewhere
+            && finalAssistantEvidence.source === 'external-native'
+            && this.busyLeaseGateEnabled()) {
+            try {
+                const snapshot = this.lastTranscriptSignalSnapshot;
+                const transcriptAgeMs = snapshot?.available === true
+                    && typeof snapshot.detail?.ageMs === 'number'
+                    && Number.isFinite(snapshot.detail.ageMs)
+                    ? snapshot.detail.ageMs
+                    : undefined;
+                if (typeof transcriptAgeMs === 'number') {
+                    if (transcriptAgeMs < PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS) {
+                        return { reason: 'native_source_final_assistant_quiet_dwell', terminal: false };
+                    }
+                }
+            } catch { /* defensive: transcript dwell is best-effort — fail open */ }
+        }
+
         return null;
     }
 
@@ -3150,10 +3245,16 @@ export class CliProviderInstance implements ProviderInstance {
         // the settle window — so the single sample reads 'idle' even though the turn is still in
         // flight (it re-enters generating ~0.5s later). Require instead that the session stayed
         // CONTINUOUSLY idle since the debounce was armed: (1) no entry into a busy phase
-        // (busyEpoch unchanged), and (2) no new raw PTY output (lastOutputAt did not advance).
-        // Either signal ⇒ the idle was not continuous ⇒ cancel; the still-live turn re-arms its
-        // own completion when it genuinely finishes. This only ever cancels (never emits more),
-        // so shared behaviour for claude/codex/antigravity is strictly stricter, never looser.
+        // (busyEpoch unchanged), and (2) on the FIRST settle check, no new raw PTY output
+        // (lastOutputAt did not advance).
+        //
+        // Once a finalization block has claimed the pending completion (loggedBlockReason is
+        // set), its own bounded retry/evidence policy owns release. Re-applying the raw-output
+        // cancellation on every retry lets cosmetic idle redraws (notably Kimi's prompt/status
+        // repaint) delete the pending after a genuine final assistant has landed. The adapter
+        // emits no second idle edge for that already-idle turn, so deletion becomes a permanent
+        // internal-generating wedge. Busy re-entry remains an unconditional cancel above:
+        // busyEpoch is the structural continuity signal and must win even after a hold.
         if (typeof pending.busyEpochAtArm === 'number' && this.busyEpoch !== pending.busyEpochAtArm) {
             LOG.info('CLI', `[${this.type}] cancelled pending completed (busy re-entry during settle: epoch ${pending.busyEpochAtArm}→${this.busyEpoch})`);
             if (this.completionTraceOn()) this.recordCompletionGateTrace('cancel', {
@@ -3169,7 +3270,8 @@ export class CliProviderInstance implements ProviderInstance {
             return;
         }
         const latestOutputAt = typeof (latestStatus as any)?.lastOutputAt === 'number' ? (latestStatus as any).lastOutputAt as number : undefined;
-        if (typeof pending.lastOutputAtArm === 'number'
+        if (!pending.loggedBlockReason
+            && typeof pending.lastOutputAtArm === 'number'
             && typeof latestOutputAt === 'number'
             && latestOutputAt > pending.lastOutputAtArm) {
             LOG.info('CLI', `[${this.type}] cancelled pending completed (new PTY output during settle: ${pending.lastOutputAtArm}→${latestOutputAt})`);