@adhdev/daemon-core 0.9.82-rc.252 → 0.9.82-rc.254

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

@@ -56,7 +56,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private runtimeMessages;
     private lastPersistedHistoryMessages;
     private lastAcknowledgedUserInputAt;
-    private externalBusyIdleFingerprint;
     private lastNativeSourceCanonicalCheckAt;
     private lastNativeSourceCanonicalCacheKey;
     private cachedSqliteDb;
@@ -133,8 +132,6 @@ export declare class CliProviderInstance implements ProviderInstance {
     private readExternalCompletionMessages;
     private completionFinalAssistantEvidence;
     private completionFinalSummary;
-    private externalNativeFinalFingerprint;
-    private getExternalNativeFinalReconciliation;
     private buildCompletedFinalizationDiagnostic;
     private hasAdapterPendingResponse;
     private shouldSuppressStaleParsedBusyStatus;

package/dist/providers/spec/fsm-driver.d.ts

@@ -10,6 +10,7 @@ export type DashboardEvent = {
         id: string;
         label: string;
         title: string | null;
+        status: 'idle' | 'generating' | 'approval';
     };
     modal: {
         title: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.252",
+  "version": "0.9.82-rc.254",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -627,10 +627,12 @@ function reconcileInlineMeshCache(cached: any, incoming: any): any {
         if (nodeId) cachedById.set(nodeId, node);
     }
 
+    const mergedIncomingIds = new Set<string>();
     const nodes = incomingNodes.map((incomingNode: any) => {
         const nodeId = readInlineMeshNodeId(incomingNode);
         const cachedNode = nodeId ? cachedById.get(nodeId) : undefined;
         if (!cachedNode && preserveCachedMembership) return null;
+        if (nodeId) mergedIncomingIds.add(nodeId);
         if (!cachedNode) return incomingNode;
         if (hasInlineMeshTransientNodeState(incomingNode)) {
             return { ...cachedNode, ...incomingNode };
@@ -638,6 +640,21 @@ function reconcileInlineMeshCache(cached: any, incoming: any): any {
         return { ...stripInlineMeshTransientNodeState(cachedNode), ...incomingNode };
     }).filter(Boolean);
 
+    // When the cached membership is authoritative (newer than the incoming
+    // snapshot), nodes that exist only in the cache must survive reconciliation.
+    // A freshly cloned worktree node lives only in the coordinator's cache until
+    // the next snapshot catches up; iterating incomingNodes alone would silently
+    // drop it, making the node invisible to get_mesh / membership reads even
+    // though worktree_bootstrap_complete already fired.
+    if (preserveCachedMembership) {
+        for (const cachedNode of cachedNodes) {
+            const nodeId = readInlineMeshNodeId(cachedNode);
+            if (nodeId && !mergedIncomingIds.has(nodeId)) {
+                nodes.push(cachedNode);
+            }
+        }
+    }
+
     return {
         ...cached,
         ...incoming,
@@ -6005,7 +6022,16 @@ export class DaemonCommandRouter {
                 if (ownerFailure) return ownerFailure;
 
                 try {
-                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+                    // Resolve with preferInline so the clone writes the new node into the
+                    // same representation that get_mesh reads back. The MCP coordinator
+                    // passes inlineMesh on every mesh command, so when it owns an inline
+                    // mesh the membership read path (get_mesh, preferInline: true) returns
+                    // the inline cache. Without preferInline here, clone could resolve to a
+                    // local-config mesh and write the node only to config — leaving the
+                    // inline cache (and therefore get_mesh / refreshMeshFromDaemon) without
+                    // the node, so the new worktree node is never visible in live mesh
+                    // membership even though worktree_bootstrap_complete fires.
+                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
                     const mesh = meshRecord?.mesh;
                     if (!mesh) return { success: false, error: 'Mesh not found' };
 
@@ -6064,6 +6090,13 @@ export class DaemonCommandRouter {
                             policy: { ...(sourceNode.policy || {}) },
                         });
                         if (!node) return { success: false, error: 'Failed to register worktree node' };
+                        // Also reconcile the freshly-registered node into any warmed inline
+                        // cache for this mesh. get_mesh (preferInline: true) reads the inline
+                        // cache first when one exists; if we only wrote to local config the
+                        // node would be invisible to membership reads. updateInlineMeshNode is
+                        // a no-op when no inline cache is present.
+                        const inlineForReconcile = this.getCachedInlineMesh(meshId);
+                        if (inlineForReconcile) this.updateInlineMeshNode(meshId, inlineForReconcile, node);
                         this.invalidateAggregateMeshStatus(meshId);
                     }
 

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

@@ -438,7 +438,21 @@ function nodeHasActiveAssignment(meshId: string, nodeId: string): boolean {
 }
 
 function sessionHasActiveAssignment(meshId: string, sessionId: string): boolean {
-    return getQueue(meshId, { status: ['assigned'] as any }).some(task => task.assignedSessionId === sessionId);
+    if (getQueue(meshId, { status: ['assigned'] as any }).some(task => task.assignedSessionId === sessionId)) {
+        return true;
+    }
+    // Direct dispatches (mesh_send_task) are tracked in mesh_direct_dispatches, not the
+    // work queue. A session completing a still-active direct dispatch IS an active
+    // assignment — without this, findRecentTerminalLedgerEvidence dedup wrongly suppresses
+    // the canonical agent:generating_completed for direct-dispatch tasks (validation/general),
+    // so the coordinator polling get_pending_mesh_events never observes task_completed and the
+    // session goes silently idle. This check runs before markSessionTerminal marks the
+    // dispatch terminal, so the in-flight dispatch is still observable here.
+    try {
+        if (getActiveDirectDispatches(meshId).some(d => d.sessionId === sessionId)) return true;
+        if (hasUnterminalDirectDispatchLedgerEntry(meshId, sessionId)) return true;
+    } catch { /* best-effort — fall through to false */ }
+    return false;
 }
 
 function liveSessionCountForNode(components: DaemonComponents, meshId: string, nodeId: string): number {
@@ -927,6 +941,27 @@ export function isMeshCoordinatorEvent(eventName: unknown): eventName is string
     return typeof eventName === 'string' && MESH_COORDINATOR_EVENTS.has(eventName);
 }
 
+// Terminal events that the coordinator is actively blocked waiting on. When the
+// coordinator CLI session dispatches a task (e.g. mesh_send_task) it stays in
+// `generating` until the result arrives — but a generating coordinator queues
+// incoming send_message calls into its adapter's pendingOutboundQueue, which is
+// only flushed on the coordinator's OWN idle transition. That transition can't
+// happen until it receives this very event → deadlock. We force-inject these so
+// they bypass the busy send-guard and land in the PTY while generating.
+const MESH_FORCE_INJECT_EVENTS = new Set([
+    'agent:generating_completed',
+    'agent:stopped',
+    'agent:waiting_approval',
+    'refine:completed',
+    'refine:failed',
+    'worktree_bootstrap_complete',
+    'worktree_bootstrap_failed',
+]);
+
+function shouldForceInjectMeshEvent(eventName: unknown): boolean {
+    return typeof eventName === 'string' && MESH_FORCE_INJECT_EVENTS.has(eventName);
+}
+
 function injectMeshSystemMessage(components: DaemonComponents, args: {
     meshId: string;
     sourceInstanceId?: string;
@@ -1362,10 +1397,14 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
     }
 
+    const forceInject = shouldForceInjectMeshEvent(args.event);
     for (const coord of coordinatorInstances) {
         const coordState = coord.getState();
-        LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}`);
-        coord.onEvent('send_message', { input: { text: messageText, textFallback: messageText } });
+        LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}${forceInject ? ' (force)' : ''}`);
+        coord.onEvent('send_message', {
+            input: { text: messageText, textFallback: messageText },
+            ...(forceInject ? { force: true } : {}),
+        });
     }
     return { success: true, forwarded: coordinatorInstances.length };
 }
@@ -1424,6 +1463,58 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
 
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
+        // --- Coordinator idle auto-flush ---
+        // When a coordinator session becomes idle, flush any pending coordinator events
+        // that accumulated while it was generating. This runs before the delegate routing
+        // below so that coordinator-own idle transitions are handled first.
+        // Exception: a coordinator that is itself a direct-dispatch target still needs
+        // to go through delegate routing so that the dispatching coordinator receives a
+        // pendingCoordinatorEvents entry for the completion.
+        if (event.event === 'agent:ready' || event.event === 'agent:generating_completed') {
+            const flushInstanceId = readNonEmptyString(event.instanceId);
+            if (flushInstanceId) {
+                const flushSource = components.instanceManager.getInstance(flushInstanceId);
+                if (flushSource && flushSource.category === 'cli') {
+                    const flushState = flushSource.getState();
+                    const flushSettings = flushState.settings && typeof flushState.settings === 'object' ? flushState.settings as Record<string, unknown> : {};
+                    const coordinatorMeshId = readNonEmptyString(flushSettings.meshCoordinatorFor);
+                    if (coordinatorMeshId) {
+                        const status = readNonEmptyString(flushState.status).toLowerCase();
+                        if (status === 'idle') {
+                            try {
+                                const localDaemonId = readNonEmptyString(loadConfig().machineId) || undefined;
+                                const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, localDaemonId);
+                                if (pendingEvents.length > 0) {
+                                    LOG.info('MeshEvents', `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId} on coordinator idle`);
+                                    for (const pending of pendingEvents) {
+                                        if (!pending.coordinatorMessage) continue;
+                                        const forcePending = shouldForceInjectMeshEvent(pending.event);
+                                        flushSource.onEvent('send_message', {
+                                            input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage },
+                                            ...(forcePending ? { force: true } : {}),
+                                        });
+                                    }
+                                }
+                            } catch (e: any) {
+                                LOG.warn('MeshEvents', `Failed to auto-flush pending coordinator events: ${e?.message || e}`);
+                            }
+                        }
+                        // Skip delegate routing unless this coordinator session is itself
+                        // a direct-dispatch target — in that case fall through so the
+                        // dispatching coordinator gets a pendingCoordinatorEvents entry.
+                        let hasDirectDispatch = false;
+                        try {
+                            hasDirectDispatch =
+                                getActiveDirectDispatches(coordinatorMeshId).some(d => d.sessionId === flushInstanceId)
+                                || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, flushInstanceId);
+                        } catch { /* best-effort */ }
+                        if (!hasDirectDispatch) return;
+                    }
+                }
+            }
+        }
+
+        // --- Delegate event routing ---
         if (!isMeshCoordinatorEvent(event.event)) return;
 
         const instanceId = readNonEmptyString(event.instanceId);
@@ -1475,36 +1566,4 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
             metadataEvent: event,
         });
     });
-
-    // Auto-flush pending coordinator events when a coordinator session becomes idle.
-    components.instanceManager.onEvent((event) => {
-        if (event.event !== 'agent:ready' && event.event !== 'agent:generating_completed') return;
-
-        const instanceId = readNonEmptyString(event.instanceId);
-        if (!instanceId) return;
-
-        const sourceInstance = components.instanceManager.getInstance(instanceId);
-        if (!sourceInstance || sourceInstance.category !== 'cli') return;
-        const state = sourceInstance.getState();
-        const settings = state.settings && typeof state.settings === 'object' ? state.settings as Record<string, unknown> : {};
-
-        const coordinatorMeshId = readNonEmptyString(settings.meshCoordinatorFor);
-        if (!coordinatorMeshId) return;
-
-        const status = readNonEmptyString(state.status).toLowerCase();
-        if (status !== 'idle') return;
-
-        try {
-            const localDaemonId = readNonEmptyString(loadConfig().machineId) || undefined;
-            const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, localDaemonId);
-            if (pendingEvents.length === 0) return;
-            LOG.info('MeshEvents', `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId} on coordinator idle`);
-            for (const pending of pendingEvents) {
-                if (!pending.coordinatorMessage) continue;
-                sourceInstance.onEvent('send_message', { input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage } });
-            }
-        } catch (e: any) {
-            LOG.warn('MeshEvents', `Failed to auto-flush pending coordinator events: ${e?.message || e}`);
-        }
-    });
 }

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

@@ -185,12 +185,20 @@ function refineTerminalEventFromLedger(meshId: string, pending: readonly Pending
 
 function reconcilePendingMeshCoordinatorEvents(meshId: string, events: PendingMeshCoordinatorEvent[]): PendingMeshCoordinatorEvent[] {
     const backfilled = refineTerminalEventFromLedger(meshId, events);
-    if (backfilled.length === 0) return events;
-    const terminalJobIds = new Set(backfilled.map(event => readRefineJobId(event)).filter(Boolean));
-    return [
-        ...events.filter(event => !(event.event === 'refine:accepted' && terminalJobIds.has(readRefineJobId(event)))),
-        ...backfilled,
-    ];
+    // A refine:accepted event is a provisional "job accepted, result to follow" signal.
+    // Once its terminal (completed/failed) counterpart for the same jobId exists — whether
+    // already direct-queued into the pending store OR backfilled from the ledger here — the
+    // accepted is superseded and is dropped so the coordinator isn't shown stale duplicate
+    // noise alongside the terminal outcome.
+    const terminalJobIds = new Set(
+        [...events.filter(event => REFINE_TERMINAL_EVENTS.has(event.event)), ...backfilled]
+            .map(event => readRefineJobId(event))
+            .filter(Boolean),
+    );
+    const reconciled = terminalJobIds.size === 0
+        ? events
+        : events.filter(event => !(event.event === 'refine:accepted' && terminalJobIds.has(readRefineJobId(event))));
+    return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
 }
 
 const MAX_PENDING_EVENTS_BYTES = 100 * 1024; // 100 KB — keep the pending file small

package/src/mesh/mesh-work-queue.ts

@@ -22,7 +22,6 @@ export interface MeshTaskModeValidationResult {
 
 const LIVE_DEBUG_READONLY_FORBIDDEN: Array<{ label: string; pattern: RegExp }> = [
     { label: 'source_edit', pattern: /\b(edit|modify|patch|apply\s+patch|write\s+(?:to\s+)?(?:file|source)|overwrite|delete\s+file|remove\s+file|create\s+file|touch\s+file)\b/i },
-    { label: 'git_mutation', pattern: /\b(?:git\s+(?:add|commit|push|reset|rebase|clean|checkout|switch|merge|tag|restore|rm|mv|stash|worktree\s+(?:add|remove|move))|push\b)/i },
     { label: 'checkpoint', pattern: /\b(checkpoint|mesh_checkpoint)\b/i },
     { label: 'deploy_or_version_bump', pattern: /\b(deploy|wrangler\s+deploy|version[-\s]?bump|npm\s+version|release|npm\s+publish|yarn\s+publish|pnpm\s+publish)\b/i },
     { label: 'destructive_shell', pattern: /\b(rm\s+-rf|mv\s+\S+\s+\S+|truncate\s|tee\s+\S+|sed\s+-i|shred\b)\b/i },
@@ -30,6 +29,61 @@ const LIVE_DEBUG_READONLY_FORBIDDEN: Array<{ label: string; pattern: RegExp }> =
     { label: 'container_mutation', pattern: /\b(docker\s+(?:build|run|exec|push|tag|rmi|rm|create|start|stop|kill)|kubectl\s+(?:apply|delete|patch|replace|create|scale))\b/i },
 ];
 
+/**
+ * Git subcommands that mutate the working tree, index, refs, or remote.
+ * `stash` and `checkout` are intentionally absent here: they have read-only
+ * variants (`git stash list`/`show`, `git checkout-index`) and are classified
+ * token-by-token in {@link detectGitMutation} rather than by bare keyword.
+ */
+const GIT_MUTATION_SUBCOMMANDS = new Set([
+    'add', 'commit', 'push', 'reset', 'rebase', 'clean', 'switch', 'merge',
+    'tag', 'restore', 'rm', 'mv', 'cherry-pick', 'revert', 'pull', 'fetch',
+    'am', 'apply', 'gc', 'prune',
+]);
+
+/**
+ * Read-only `git stash` variants. Any other `git stash <x>` (pop/apply/drop/
+ * push/save/clear, or bare `git stash` which defaults to push) is a mutation.
+ */
+const GIT_STASH_READONLY_SUBCOMMANDS = new Set(['list', 'show']);
+
+/**
+ * Detects a true git mutation in free-text task message, token-aware so that
+ * read-only diagnostics (`git stash list`, `git stash show --stat`,
+ * `git checkout-index`, `git status`, `git diff`, `git log`, ...) are allowed.
+ * Returns true only when a genuine mutating git invocation is present.
+ */
+function detectGitMutation(message: string): boolean {
+    const re = /\bgit\s+([a-z][a-z0-9-]*)/gi;
+    let match: RegExpExecArray | null;
+    while ((match = re.exec(message)) !== null) {
+        const sub = match[1].toLowerCase();
+        if (GIT_MUTATION_SUBCOMMANDS.has(sub)) return true;
+        if (sub === 'stash') {
+            // Token following `git stash`; read-only only for list/show.
+            const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
+            const next = after ? after[1].toLowerCase() : '';
+            if (!GIT_STASH_READONLY_SUBCOMMANDS.has(next)) return true; // bare stash = push, or pop/apply/drop/...
+        } else if (sub === 'checkout') {
+            // `git checkout <ref/path>` mutates; `git checkout-index` is matched
+            // as its own token by the regex (sub === 'checkout-index') and is read-only.
+            return true;
+        } else if (sub === 'submodule') {
+            // `git submodule update` mutates; `git submodule status` is read-only.
+            const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
+            const next = after ? after[1].toLowerCase() : '';
+            if (next === 'update' || next === 'add' || next === 'sync' || next === 'deinit') return true;
+        } else if (sub === 'worktree') {
+            const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
+            const next = after ? after[1].toLowerCase() : '';
+            if (next === 'add' || next === 'remove' || next === 'move' || next === 'prune') return true;
+        }
+        // checkout-index, stash-with-no-next-already-handled, status/diff/log/show/
+        // rev-parse/branch/submodule status fall through as read-only.
+    }
+    return false;
+}
+
 export function normalizeMeshTaskMode(value: unknown): MeshTaskMode | undefined {
     if (typeof value !== 'string') return undefined;
     const normalized = value.trim() as MeshTaskMode;
@@ -44,9 +98,13 @@ export function validateMeshTaskModeRequest(mode: unknown, message: string): Mes
     if (taskMode !== 'live_debug_readonly') {
         return { valid: true, taskMode, violations: [] };
     }
+    const text = message || '';
     const violations = LIVE_DEBUG_READONLY_FORBIDDEN
-        .filter(rule => rule.pattern.test(message || ''))
+        .filter(rule => rule.pattern.test(text))
         .map(rule => rule.label);
+    if (detectGitMutation(text)) {
+        violations.push('git_mutation');
+    }
     return {
         valid: violations.length === 0,
         taskMode,

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

@@ -73,12 +73,6 @@ type CompletionFinalAssistantEvidence = {
     source: 'parsed' | 'external-native' | 'unavailable';
 };
 
-type ExternalNativeFinalReconciliation = {
-    fingerprint: string;
-    finalSummary: string;
-    evidence: CompletionFinalAssistantEvidence;
-};
-
 type ExternalTranscriptProbe = {
     readAt: number;
     msgCount: number;
@@ -376,7 +370,6 @@ export class CliProviderInstance implements ProviderInstance {
     private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     private lastPersistedHistoryMessages: PersistableCliHistoryMessage[] = [];
     private lastAcknowledgedUserInputAt = 0;
-    private externalBusyIdleFingerprint = '';
     private lastNativeSourceCanonicalCheckAt = 0;
     private lastNativeSourceCanonicalCacheKey: string | undefined = undefined;
     private cachedSqliteDb: {
@@ -599,17 +592,11 @@ export class CliProviderInstance implements ProviderInstance {
         let visibleStatus = parseErrorMessage || parsedStatus?.status === 'error'
             ? 'error'
             : (autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status);
-        const externalNativeFinal = this.getExternalNativeFinalReconciliation(parsedStatus?.messages, adapterStatus);
-        if (externalNativeFinal && isCliGeneratingLikeStatus(visibleStatus)) {
-            visibleStatus = 'idle';
-        }
-        // Adapter raw status can lag behind parsed/native evidence: if the spec driver
-        // has not yet emitted a state_changed(idle) event but the parsed transcript
-        // already shows a final assistant turn, treat the session as idle so that
-        // getState() agrees with what detectStatusTransition already recorded via
-        // lastStatus. Without this guard, getState() returns 'generating' even after
-        // the instance's lastStatus has flipped to 'idle', causing the dashboard to
-        // show a perpetual generating spinner.
+        // getState() must agree with the status the FSM-driven detectStatusTransition()
+        // already committed to lastStatus. The adapter's own status is authoritative; we do
+        // not second-guess it with native-transcript shape. Only reconcile a generating-like
+        // read down to idle when our own lastStatus has already flipped idle (avoids a
+        // perpetual dashboard spinner during the brief window before the next getStatus()).
         if (isCliGeneratingLikeStatus(visibleStatus) && this.lastStatus === 'idle') {
             visibleStatus = 'idle';
         }
@@ -885,7 +872,13 @@ export class CliProviderInstance implements ProviderInstance {
             assertProviderSupportsDeclaredInput(this.provider, input);
             const promptText = buildCliStructuredInputPrompt(input);
             if (promptText) {
-                void this.adapter.sendMessage(promptText).catch((e: any) => {
+                // force:true bypasses the busy/generating send guard so terminal mesh
+                // events (completion/failure/bootstrap) land in a coordinator session that
+                // is itself parked in `generating` while awaiting that very event.
+                // Without it the message is queued and only flushed on the coordinator's
+                // own idle transition — which never happens until it receives the message.
+                const force = data?.force === true;
+                void this.adapter.sendMessage(promptText, force ? { force: true } : {}).catch((e: any) => {
                     LOG.warn('CLI', `[${this.type}] send_message failed: ${e?.message || e}`);
                 });
             }
@@ -934,7 +927,6 @@ export class CliProviderInstance implements ProviderInstance {
 
         const receivedAt = Date.now();
         this.lastAcknowledgedUserInputAt = receivedAt;
-        this.externalBusyIdleFingerprint = '';
         const dedupKey = `user_input_ack:${crypto
             .createHash('sha256')
             .update(`${this.instanceId}:${content}:${receivedAt}`)
@@ -1100,59 +1092,6 @@ export class CliProviderInstance implements ProviderInstance {
         return extractFinalSummaryFromMessages(evidence.messages as any);
     }
 
-    private externalNativeFinalFingerprint(evidence: CompletionFinalAssistantEvidence): string {
-        const messages = Array.isArray(evidence.messages) ? evidence.messages : [];
-        const visibleMessages = messages.filter((message: any) => isUserFacingChatMessage(message as ChatMessage));
-        const lastVisible = visibleMessages[visibleMessages.length - 1] as ChatMessage | undefined;
-        const content = lastVisible ? flattenContent(lastVisible.content).trim() : '';
-        const receivedAt = lastVisible ? getMessageTime(lastVisible) : 0;
-        const probe = this.lastExternalCompletionProbe;
-        return crypto
-            .createHash('sha256')
-            .update([
-                this.type,
-                this.providerSessionId || '',
-                probe?.sourcePath || '',
-                String(probe?.sourceMtimeMs || 0),
-                String(receivedAt || 0),
-                content.slice(-500),
-            ].join('\0'))
-            .digest('hex')
-            .slice(0, 24);
-    }
-
-    private getExternalNativeFinalReconciliation(parsedMessages: unknown, adapterStatus: any): ExternalNativeFinalReconciliation | null {
-        const rawStatus = typeof adapterStatus?.status === 'string' ? adapterStatus.status.trim() : '';
-        if (!isCliGeneratingLikeStatus(rawStatus)) return null;
-        if (hasNonEmptyCliModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal)) return null;
-
-        const evidence = this.completionFinalAssistantEvidence(parsedMessages);
-        if (evidence.source !== 'external-native' || !evidence.present) return null;
-
-        const messages = Array.isArray(evidence.messages) ? evidence.messages : [];
-        const visibleMessages = messages.filter((message: any) => isUserFacingChatMessage(message as ChatMessage));
-        const lastVisible = visibleMessages[visibleMessages.length - 1] as ChatMessage | undefined;
-        const lastMessageAt = lastVisible ? getMessageTime(lastVisible) : 0;
-        const sourceMtimeMs = Number(this.lastExternalCompletionProbe?.sourceMtimeMs || 0);
-        const minEvidenceAt = Math.max(
-            this.startedAt > 0 ? this.startedAt - 5_000 : 0,
-            this.generatingStartedAt > 0 ? this.generatingStartedAt - 5_000 : 0,
-            this.lastAcknowledgedUserInputAt > 0 ? this.lastAcknowledgedUserInputAt - 1_000 : 0,
-        );
-        if (minEvidenceAt > 0 && lastMessageAt > 0 && lastMessageAt < minEvidenceAt && sourceMtimeMs < minEvidenceAt) {
-            return null;
-        }
-
-        const finalSummary = extractFinalSummaryFromMessages(evidence.messages as any);
-        if (!finalSummary) return null;
-        const fingerprint = this.externalNativeFinalFingerprint(evidence);
-        if (fingerprint === this.externalBusyIdleFingerprint) {
-            return { fingerprint, finalSummary, evidence };
-        }
-        this.externalBusyIdleFingerprint = fingerprint;
-        return { fingerprint, finalSummary, evidence };
-    }
-
     private buildCompletedFinalizationDiagnostic(args: {
         blockReason: string;
         latestStatus?: any;
@@ -1242,13 +1181,12 @@ export class CliProviderInstance implements ProviderInstance {
         return true;
     }
 
-    private getCompletedFinalizationBlock(latestVisibleStatus: string, pending: CompletedDebouncePending, opts?: { externalNativeFinal?: ExternalNativeFinalReconciliation | null }): CompletedFinalizationBlock | null {
+    private getCompletedFinalizationBlock(latestVisibleStatus: string, pending: CompletedDebouncePending): CompletedFinalizationBlock | null {
         if (latestVisibleStatus !== 'idle') return { reason: `status:${latestVisibleStatus}`, terminal: true };
 
         const adapterAny = this.adapter as any;
         const approvalResolvedIdle = pending.previousStatus === 'waiting_approval';
-        const externalNativeFinal = opts?.externalNativeFinal || null;
-        if (!approvalResolvedIdle && !externalNativeFinal) {
+        if (!approvalResolvedIdle) {
             if (adapterAny?.isWaitingForResponse === true) return { reason: 'adapter_waiting_for_response', terminal: true };
             if (adapterAny?.currentTurnScope) return { reason: 'adapter_turn_scope_active', terminal: true };
             if (this.hasAdapterPendingResponse()) return { reason: 'adapter_pending_response', terminal: true };
@@ -1257,7 +1195,7 @@ export class CliProviderInstance implements ProviderInstance {
         const partial = typeof this.adapter.getPartialResponse === 'function'
             ? this.adapter.getPartialResponse()
             : '';
-        if (!externalNativeFinal && typeof partial === 'string' && partial.trim()) return { reason: 'partial_response_pending', terminal: true };
+        if (typeof partial === 'string' && partial.trim()) return { reason: 'partial_response_pending', terminal: true };
 
         let parsed: any;
         try {
@@ -1269,7 +1207,6 @@ export class CliProviderInstance implements ProviderInstance {
         const parsedStatus = typeof parsed?.status === 'string' ? parsed.status : 'unknown';
         if (parsedStatus !== 'idle') {
             const adapterStatus = this.adapter.getStatus({ allowParse: false });
-            if (externalNativeFinal && isCliGeneratingLikeStatus(parsedStatus)) return null;
             if (this.shouldSuppressStaleParsedBusyStatus(parsed, adapterStatus)) return null;
             return { reason: `parsed_status:${parsedStatus}`, terminal: isCliGeneratingLikeStatus(parsedStatus) };
         }
@@ -1341,11 +1278,8 @@ export class CliProviderInstance implements ProviderInstance {
 
         const latestStatus = this.adapter.getStatus({ allowParse: false });
         const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
-        const externalNativeFinal = this.getExternalNativeFinalReconciliation(undefined, latestStatus);
-        const latestVisibleStatus = externalNativeFinal && isCliGeneratingLikeStatus(latestStatus.status)
-            ? 'idle'
-            : (latestAutoApproveActive || this.autoApproveBusy ? 'generating' : latestStatus.status);
-        LOG.debug('CLI', `[${this.type}] flush attempt: adapterStatus=${latestStatus.status} latestVisible=${latestVisibleStatus} externalNativeFinal=${!!externalNativeFinal} generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!(this.adapter as any)?.isWaitingForResponse} hasPartial=${!!this.adapter.getPartialResponse?.()}`);
+        const latestVisibleStatus = latestAutoApproveActive || this.autoApproveBusy ? 'generating' : latestStatus.status;
+        LOG.debug('CLI', `[${this.type}] flush attempt: adapterStatus=${latestStatus.status} latestVisible=${latestVisibleStatus} generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!(this.adapter as any)?.isWaitingForResponse} hasPartial=${!!this.adapter.getPartialResponse?.()}`);
         if (latestVisibleStatus !== 'idle') {
             LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
             this.completedDebouncePending = null;
@@ -1353,7 +1287,7 @@ export class CliProviderInstance implements ProviderInstance {
             return;
         }
 
-        const block = this.getCompletedFinalizationBlock(latestVisibleStatus, pending, { externalNativeFinal });
+        const block = this.getCompletedFinalizationBlock(latestVisibleStatus, pending);
         if (block) {
             const blockReason = block.reason;
             const waitedMs = Date.now() - pending.firstObservedAt;
@@ -1398,18 +1332,7 @@ export class CliProviderInstance implements ProviderInstance {
             chatTitle: pending.chatTitle,
             duration: pending.duration,
             timestamp: pending.timestamp,
-            finalSummary: externalNativeFinal?.finalSummary || this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages),
-            ...(externalNativeFinal ? {
-                completionDiagnostic: {
-                    providerType: this.type,
-                    sessionId: this.instanceId,
-                    providerSessionId: this.providerSessionId || null,
-                    reconciliationReason: 'external_native_final_assistant_while_adapter_busy',
-                    finalAssistantPresent: true,
-                    finalAssistantEvidenceSource: externalNativeFinal.evidence.source,
-                    externalFinalFingerprint: externalNativeFinal.fingerprint,
-                },
-            } : {}),
+            finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages),
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = null;
@@ -1486,15 +1409,13 @@ export class CliProviderInstance implements ProviderInstance {
         const parsedStatus = null;
         const rawStatus = adapterStatus.status;
         const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, now);
-        const externalNativeFinal = this.getExternalNativeFinalReconciliation(undefined, adapterStatus);
         // During the autoApproveBusy window (2s after firing approval key), the PTY
         // can briefly report 'idle' before the next generating phase starts. Treat that
         // transient idle as 'generating' to suppress a spurious agent:generating_completed
-        // push notification. externalNativeFinal still wins to allow hard-stop overrides.
+        // push notification. The adapter's status is otherwise authoritative — native
+        // transcript shape does NOT override the FSM's busy/idle decision.
         const autoApproveHoldIdle = this.autoApproveBusy && rawStatus === 'idle';
-        const newStatus = externalNativeFinal && isCliGeneratingLikeStatus(rawStatus)
-            ? 'idle'
-            : (autoApproveActive || autoApproveHoldIdle ? 'generating' : rawStatus);
+        const newStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : rawStatus;
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
         const chatTitle = `${this.provider.name} · ${dirName}`;
         const partial = this.adapter.getPartialResponse();

package/src/providers/spec/cli-adapter.ts

@@ -68,7 +68,7 @@ export class SpecCliAdapter implements CliAdapter {
         native_history?: NativeHistoryConfig;
     };
     private lastEvent: DashboardEvent | null = null;
-    private latestState: { id: string; label: string; title: string | null } | null = null;
+    private latestState: { id: string; label: string; title: string | null; status: 'idle' | 'generating' | 'approval' } | null = null;
     private latestModal: { title: string | null; buttons: { index: number; label: string }[] } | null = null;
     private statusCallback: (() => void) | null = null;
     private ptyDataCallback: ((data: string) => void) | null = null;
@@ -159,21 +159,25 @@ export class SpecCliAdapter implements CliAdapter {
         const state = this.latestState;
         if (!state) return { status: 'starting', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
 
+        // The FSM state is authoritative for status. We do NOT infer status from whether
+        // a modal was parsed this frame: a modal/approval state whose buttons briefly fail
+        // to parse (PTY repaint) must still report waiting_approval, not collapse to idle —
+        // that collapse fired false completions while a session sat at an approval prompt.
         const modal = this.latestModal;
-        const lc = state.id.toLowerCase();
-        if (modal) {
+        if (state.status === 'approval') {
             return {
                 status: 'waiting_approval',
                 messages: [],
-                activeModal: {
-                    message: modal.title ?? state.label,
-                    buttons: modal.buttons.map(b => b.label),
-                },
+                // Surface buttons when we have them; an approval state with no parsed
+                // modal this frame still stays waiting_approval (no activeModal yet).
+                activeModal: modal
+                    ? { message: modal.title ?? state.label, buttons: modal.buttons.map(b => b.label) }
+                    : null,
                 activeInteractivePrompt: this.activeInteractivePrompt,
                 ...sessionFields,
             };
         }
-        if (lc === 'busy' || lc === 'generating') {
+        if (state.status === 'generating') {
             return { status: 'generating', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };
         }
         return { status: 'idle', messages: [], activeModal: null, activeInteractivePrompt: this.activeInteractivePrompt, ...sessionFields };