@adhdev/daemon-core 0.9.82-rc.186 → 0.9.82-rc.188

package/src/mesh/mesh-events.ts

@@ -608,6 +608,166 @@ function hasUnterminalDirectDispatchLedgerEntry(meshId: string, sessionId: strin
     return false;
 }
 
+function findDirectDispatchLedgerEntry(args: {
+    meshId: string;
+    taskId: string;
+    sessionId?: string;
+}): { id: string; timestamp: string; nodeId?: string; sessionId?: string; providerType?: string; payload: Record<string, unknown> } | null {
+    const entries = readLedgerEntries(args.meshId, { tail: 500 });
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.kind !== 'task_dispatched') continue;
+        const payloadTaskId = readNonEmptyString(entry.payload?.taskId);
+        if (payloadTaskId !== args.taskId) continue;
+        if (args.sessionId && entry.sessionId && entry.sessionId !== args.sessionId) continue;
+        return {
+            id: entry.id,
+            timestamp: entry.timestamp,
+            nodeId: entry.nodeId,
+            sessionId: entry.sessionId,
+            providerType: entry.providerType,
+            payload: entry.payload || {},
+        };
+    }
+    return null;
+}
+
+function hasTerminalLedgerAfterDispatch(args: {
+    meshId: string;
+    taskId: string;
+    sessionId?: string;
+    dispatchEntryId?: string;
+    dispatchTimestamp?: string;
+}): boolean {
+    const entries = readLedgerEntries(args.meshId, { tail: 500 });
+    let afterDispatch = !args.dispatchEntryId && !args.dispatchTimestamp;
+    const dispatchTime = args.dispatchTimestamp ? new Date(args.dispatchTimestamp).getTime() : Number.NaN;
+    for (const entry of entries) {
+        if (!afterDispatch) {
+            if (args.dispatchEntryId && entry.id === args.dispatchEntryId) {
+                afterDispatch = true;
+                continue;
+            }
+            if (!args.dispatchEntryId && Number.isFinite(dispatchTime)) {
+                const entryTime = new Date(entry.timestamp).getTime();
+                if (Number.isFinite(entryTime) && entryTime >= dispatchTime) afterDispatch = true;
+            }
+            if (!afterDispatch) continue;
+        }
+        if (entry.kind !== 'task_completed' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') continue;
+        const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
+        if (terminalTaskId && terminalTaskId === args.taskId) return true;
+        if (terminalTaskId && terminalTaskId !== args.taskId) continue;
+        if (args.sessionId && entry.sessionId === args.sessionId) return true;
+    }
+    return false;
+}
+
+export function reconcileDirectDispatchCompletionFromTranscript(args: {
+    meshId: string;
+    nodeId?: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    taskId: string;
+    finalSummary: string;
+    transcriptMessageAt?: string;
+    completedAt?: string;
+    targetCoordinatorDaemonId?: string;
+    source?: string;
+}): { reconciled: boolean; kind?: MeshLedgerKind; alreadyTerminal?: boolean; workerResult?: unknown; ledgerEntryId?: string; reason?: string } {
+    const finalSummary = readNonEmptyString(args.finalSummary);
+    if (!args.meshId || !args.taskId || !args.sessionId || !finalSummary) {
+        return { reconciled: false, reason: 'missing_required_completion_evidence' };
+    }
+
+    const dispatch = findDirectDispatchLedgerEntry({
+        meshId: args.meshId,
+        taskId: args.taskId,
+        sessionId: args.sessionId,
+    });
+    if (hasTerminalLedgerAfterDispatch({
+        meshId: args.meshId,
+        taskId: args.taskId,
+        sessionId: args.sessionId,
+        dispatchEntryId: dispatch?.id,
+        dispatchTimestamp: dispatch?.timestamp,
+    })) {
+        return { reconciled: false, alreadyTerminal: true, reason: 'terminal_ledger_entry_exists' };
+    }
+
+    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();
+    const evidence = buildTaskCompletionEvidence({
+        event: 'agent:generating_completed',
+        nodeId: nodeId || 'unknown',
+        sessionId: args.sessionId,
+        providerType,
+        providerSessionId: readNonEmptyString(args.providerSessionId),
+        finalSummary,
+        completedAt,
+    });
+    const workerResult = evidence.workerResult;
+    const dispatchTime = dispatch?.timestamp ? new Date(dispatch.timestamp).getTime() : Number.NaN;
+    const transcriptTime = args.transcriptMessageAt ? new Date(args.transcriptMessageAt).getTime() : Number.NaN;
+    const transcriptAfterDispatch = Number.isFinite(dispatchTime) && Number.isFinite(transcriptTime) && transcriptTime >= dispatchTime;
+    if (workerResult.source !== 'final_summary_json' && !transcriptAfterDispatch) {
+        return { reconciled: false, reason: 'transcript_not_proven_after_dispatch' };
+    }
+    const workerFailed = workerResult.status === 'failed' || (workerResult.status !== 'completed' && workerResult.errors.length > 0);
+    const kind: MeshLedgerKind = workerFailed ? 'task_failed' : 'task_completed';
+
+    const entry = appendLedgerEntry(args.meshId, {
+        kind,
+        nodeId: nodeId || undefined,
+        sessionId: args.sessionId,
+        providerType: providerType || undefined,
+        payload: {
+            event: 'agent:generating_completed',
+            source: args.source || 'direct_task_transcript_reconciliation',
+            taskId: args.taskId,
+            providerSessionId: readNonEmptyString(args.providerSessionId),
+            finalSummary,
+            workerResult,
+            completionDiagnostic: {
+                reason: 'direct_task_transcript_reconciliation',
+                dispatchEntryId: dispatch?.id,
+                dispatchTimestamp: dispatch?.timestamp,
+                transcriptMessageAt: readNonEmptyString(args.transcriptMessageAt),
+                transcriptFinalAssistantPresent: true,
+            },
+            evidence,
+        },
+    });
+    updateDirectDispatchStatus(args.meshId, args.sessionId, kind === 'task_completed' ? 'completed' : 'failed');
+    setImmediate(() => cleanupTerminalDirectDispatches());
+    queuePendingMeshCoordinatorEvent({
+        event: kind === 'task_completed' ? 'agent:generating_completed' : 'agent:stopped',
+        meshId: args.meshId,
+        nodeLabel: nodeId ? `Node '${nodeId}'` : 'Remote agent',
+        nodeId: nodeId || undefined,
+        metadataEvent: {
+            targetSessionId: args.sessionId,
+            providerType: providerType || undefined,
+            providerSessionId: readNonEmptyString(args.providerSessionId),
+            finalSummary,
+            taskId: args.taskId,
+            workerResult,
+            completionDiagnostic: {
+                reason: 'direct_task_transcript_reconciliation',
+                terminalLedgerKind: kind,
+                terminalLedgerId: entry.id,
+            },
+        },
+        coordinatorMessage: undefined,
+        queuedAt: Date.now(),
+        ...(readNonEmptyString(args.targetCoordinatorDaemonId) ? { targetCoordinatorDaemonId: readNonEmptyString(args.targetCoordinatorDaemonId) } : {}),
+    });
+
+    return { reconciled: true, kind, workerResult, ledgerEntryId: entry.id };
+}
+
 function buildLongGeneratingCompletionReconciliation(args: {
     meshId: string;
     nodeId?: string;
@@ -1019,13 +1179,69 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
     return false;
 }
 
+export interface MeshQueueTriggerResult {
+    success: true;
+    meshId: string;
+    pendingBefore: number;
+    assignedBefore: number;
+    pendingAfter: number;
+    assignedAfter: number;
+    claimed: boolean;
+    newlyAssignedTasks: Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+    }>;
+    localIdleSessionsChecked: number;
+    remoteIdleSessionsChecked: number;
+    skippedSessions: Array<{
+        nodeId?: string;
+        sessionId?: string;
+        reason: string;
+        status?: string;
+    }>;
+    autoLaunchStarted: boolean;
+    noIdleMeshSessionAvailable?: boolean;
+}
+
+function countQueueStatus(meshId: string, status: 'pending' | 'assigned'): number {
+    return getQueue(meshId, { status: [status] as any }).length;
+}
+
+function getQueueStatusById(meshId: string): Map<string, string> {
+    return new Map(getQueue(meshId).map(task => [task.id, task.status]));
+}
+
 /**
  * Triggers a queue check for all nodes in the mesh.
  * Called when a new task is enqueued, in case nodes are already idle.
  */
-export async function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<void> {
+export async function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<MeshQueueTriggerResult> {
     const mesh = getMeshWithCache(components, meshId);
-    if (!mesh) return;
+    const pendingBefore = countQueueStatus(meshId, 'pending');
+    const assignedBefore = countQueueStatus(meshId, 'assigned');
+    const beforeStatus = getQueueStatusById(meshId);
+    const skippedSessions: MeshQueueTriggerResult['skippedSessions'] = [];
+    let localIdleSessionsChecked = 0;
+    let remoteIdleSessionsChecked = 0;
+    let autoLaunchStarted = false;
+    if (!mesh) {
+        return {
+            success: true,
+            meshId,
+            pendingBefore,
+            assignedBefore,
+            pendingAfter: pendingBefore,
+            assignedAfter: assignedBefore,
+            claimed: false,
+            newlyAssignedTasks: [],
+            localIdleSessionsChecked,
+            remoteIdleSessionsChecked,
+            skippedSessions: [{ reason: 'mesh_not_found' }],
+            autoLaunchStarted,
+            noIdleMeshSessionAvailable: true,
+        };
+    }
 
     // Find all CLI instances that belong to this mesh and are idle
     const cliInstances = components.instanceManager.getByCategory('cli');
@@ -1042,14 +1258,30 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
         // Only genuinely idle live sessions can pull work. Restored/stopped
         // records are kept for transcript/recovery visibility, but assigning
         // queue items to them strands tasks in assigned/pending without chat.
-        if (!isIdleSessionState(state)) continue;
+        if (!isIdleSessionState(state)) {
+            const status = readNonEmptyString(state.status).toLowerCase();
+            skippedSessions.push({
+                nodeId,
+                sessionId: readNonEmptyString(state.instanceId),
+                reason: isTerminalSessionStatus(status) ? 'terminal_session' : 'session_not_idle',
+                status: status || undefined,
+            });
+            continue;
+        }
 
         const sessionId = state.instanceId;
         const providerType = state.type || readNonEmptyString(settings.providerType);
         
         if (providerType) {
             // Try to assign a task to this idle node
+            localIdleSessionsChecked += 1;
             tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
+        } else {
+            skippedSessions.push({
+                nodeId,
+                sessionId,
+                reason: 'provider_type_missing',
+            });
         }
     }
 
@@ -1058,6 +1290,7 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
         // Find if this node is in the same mesh
         const node = mesh.nodes.find((n: any) => n.id === idle.nodeId);
         if (node) {
+            remoteIdleSessionsChecked += 1;
             const assigned = tryAssignQueueTask(components, meshId, idle.nodeId, idle.sessionId, idle.providerType);
             if (assigned) {
                 remoteIdleSessions.delete(key);
@@ -1065,7 +1298,34 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
         }
     }
 
-    await maybeAutoLaunchOneQueueSession(components, meshId, mesh);
+    autoLaunchStarted = await maybeAutoLaunchOneQueueSession(components, meshId, mesh);
+    const afterQueue = getQueue(meshId);
+    const pendingAfter = afterQueue.filter(task => task.status === 'pending').length;
+    const assignedAfter = afterQueue.filter(task => task.status === 'assigned').length;
+    const newlyAssignedTasks = afterQueue
+        .filter(task => task.status === 'assigned' && beforeStatus.get(task.id) !== 'assigned')
+        .map(task => ({
+            id: task.id,
+            nodeId: task.assignedNodeId,
+            sessionId: task.assignedSessionId,
+        }));
+    return {
+        success: true,
+        meshId,
+        pendingBefore,
+        assignedBefore,
+        pendingAfter,
+        assignedAfter,
+        claimed: newlyAssignedTasks.length > 0,
+        newlyAssignedTasks,
+        localIdleSessionsChecked,
+        remoteIdleSessionsChecked,
+        skippedSessions,
+        autoLaunchStarted,
+        ...(pendingAfter > 0 && newlyAssignedTasks.length === 0 && localIdleSessionsChecked === 0 && remoteIdleSessionsChecked === 0 && !autoLaunchStarted
+            ? { noIdleMeshSessionAvailable: true }
+            : {}),
+    };
 }
 
 async function maybeAutoFastForwardIdleNode(components: DaemonComponents, args: {

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

@@ -372,6 +372,10 @@ export function __clearMeshQueueForTests(meshId: string): void {
     BeadsDB.getInstance().deleteQueue(meshId);
 }
 
+export function __clearDirectDispatchesForTests(meshId: string): void {
+    BeadsDB.getInstance().deleteDirectDispatches(meshId);
+}
+
 export function __resetBeadsDBForTests(): void {
     BeadsDB.resetForTests();
 }

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

@@ -64,6 +64,7 @@ function getMessageTime(message: unknown): number {
 type CompletedFinalizationBlock = {
     reason: string;
     terminal?: boolean;
+    allowTimeout?: boolean;
 };
 
 type CompletionFinalAssistantEvidence = {
@@ -72,6 +73,12 @@ type CompletionFinalAssistantEvidence = {
     source: 'parsed' | 'external-native' | 'unavailable';
 };
 
+type ExternalNativeFinalReconciliation = {
+    fingerprint: string;
+    finalSummary: string;
+    evidence: CompletionFinalAssistantEvidence;
+};
+
 type ExternalTranscriptProbe = {
     readAt: number;
     msgCount: number;
@@ -368,6 +375,8 @@ export class CliProviderInstance implements ProviderInstance {
     private historyWriter: ChatHistoryWriter;
     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: {
@@ -586,9 +595,13 @@ export class CliProviderInstance implements ProviderInstance {
             typeof adapterStatus?.providerSessionId === 'string' ? adapterStatus.providerSessionId : '',
         );
         const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, Date.now());
-        const visibleStatus = parseErrorMessage || parsedStatus?.status === 'error'
+        let visibleStatus = parseErrorMessage || parsedStatus?.status === 'error'
             ? 'error'
             : (autoApproveActive ? 'generating' : adapterStatus.status);
+        const externalNativeFinal = this.getExternalNativeFinalReconciliation(parsedStatus?.messages, adapterStatus);
+        if (externalNativeFinal && isCliGeneratingLikeStatus(visibleStatus)) {
+            visibleStatus = 'idle';
+        }
         const runtime = this.adapter.getRuntimeMetadata();
         this.maybeAppendRuntimeRecoveryMessage(runtime);
         let parsedMessages = Array.isArray(parsedStatus?.messages)
@@ -613,7 +626,12 @@ export class CliProviderInstance implements ProviderInstance {
         if (suppressFreshLaunchStartupReplay) {
             parsedMessages = [];
         }
-        const activeChatId = this.providerSessionId || runtime?.runtimeId || this.instanceId;
+        // Adapter runtime metadata is transport-owned and is not guaranteed to
+        // identify this conversation. Spec adapters historically exposed the
+        // provider spec id (for example "codex-cli") as runtimeId, which made
+        // concurrent sessions share one activeChat identity until their native
+        // provider session ids were discovered.
+        const activeChatId = this.providerSessionId || this.instanceId;
         const historyMessageCount = Number.isFinite(parsedStatus?.historyMessageCount)
             ? Math.max(0, Number(parsedStatus.historyMessageCount))
             : null;
@@ -782,7 +800,22 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     updateSettings(newSettings: Record<string, any>): void {
-        this.settings = { ...newSettings };
+        const runtimeMeshSettings: Record<string, any> = {};
+        for (const key of [
+            'meshNodeFor',
+            'meshNodeId',
+            'meshActiveTaskId',
+            'meshCoordinatorFor',
+            'meshCoordinatorDaemonId',
+            'meshCoordinatorNodeId',
+            'spawnedSessionVisibility',
+            'launchedByCoordinator',
+        ]) {
+            if (this.settings[key] !== undefined && newSettings[key] === undefined) {
+                runtimeMeshSettings[key] = this.settings[key];
+            }
+        }
+        this.settings = { ...newSettings, ...runtimeMeshSettings };
         this.adapter.updateRuntimeSettings?.(this.settings);
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
@@ -878,6 +911,8 @@ export class CliProviderInstance implements ProviderInstance {
         if (!content) return;
 
         const receivedAt = Date.now();
+        this.lastAcknowledgedUserInputAt = receivedAt;
+        this.externalBusyIdleFingerprint = '';
         const dedupKey = `user_input_ack:${crypto
             .createHash('sha256')
             .update(`${this.instanceId}:${content}:${receivedAt}`)
@@ -1043,6 +1078,59 @@ 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;
@@ -1132,12 +1220,13 @@ export class CliProviderInstance implements ProviderInstance {
         return true;
     }
 
-    private getCompletedFinalizationBlock(latestVisibleStatus: string, pending: CompletedDebouncePending): CompletedFinalizationBlock | null {
+    private getCompletedFinalizationBlock(latestVisibleStatus: string, pending: CompletedDebouncePending, opts?: { externalNativeFinal?: ExternalNativeFinalReconciliation | null }): CompletedFinalizationBlock | null {
         if (latestVisibleStatus !== 'idle') return { reason: `status:${latestVisibleStatus}`, terminal: true };
 
         const adapterAny = this.adapter as any;
         const approvalResolvedIdle = pending.previousStatus === 'waiting_approval';
-        if (!approvalResolvedIdle) {
+        const externalNativeFinal = opts?.externalNativeFinal || null;
+        if (!approvalResolvedIdle && !externalNativeFinal) {
             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 };
@@ -1146,7 +1235,7 @@ export class CliProviderInstance implements ProviderInstance {
         const partial = typeof this.adapter.getPartialResponse === 'function'
             ? this.adapter.getPartialResponse()
             : '';
-        if (typeof partial === 'string' && partial.trim()) return { reason: 'partial_response_pending', terminal: true };
+        if (!externalNativeFinal && typeof partial === 'string' && partial.trim()) return { reason: 'partial_response_pending', terminal: true };
 
         let parsed: any;
         try {
@@ -1158,12 +1247,14 @@ 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) };
         }
         if (parsed?.activeModal || parsed?.modal) return { reason: 'parsed_modal_active', terminal: true };
         const adapterOwnsMessagesElsewhere = (this.adapter as any)?.chatMessagesOwnedExternally === true;
         const finalAssistantEvidence = this.completionFinalAssistantEvidence(parsed?.messages);
+        const allowMissingAssistantTimeout = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
         if (!finalAssistantEvidence.present) {
             if (adapterOwnsMessagesElsewhere) {
                 if (finalAssistantEvidence.source === 'external-native') {
@@ -1172,19 +1263,20 @@ export class CliProviderInstance implements ProviderInstance {
                         LOG.info('CLI', `[${this.type}] external transcript probe: msgCount=${probe.msgCount} lastRole=${probe.lastRole || 'none'} lastKind=${probe.lastKind || 'none'} contentLen=${probe.contentLen} sourceMtime=${probe.sourceMtimeMs ?? 'unknown'} mtimeAge=${probe.mtimeAgeMs ?? 'unknown'}ms`);
                         pending.loggedTranscriptProbe = true;
                     }
-                    return { reason: 'missing_final_assistant', terminal: true };
+                    return { reason: 'missing_final_assistant', terminal: true, allowTimeout: allowMissingAssistantTimeout };
                 }
                 // SpecCliAdapter never populates parsed.messages — chat history flows
                 // through the daemon's native-history pipeline, not the status hook.
                 // If that pipeline is unavailable, keep the old skip behavior for
                 // providers that have not opted into strict final-assistant evidence.
                 if ((this.provider as any).requiresFinalAssistantBeforeIdle === true) {
-                    return { reason: 'missing_final_assistant', terminal: true };
+                    return { reason: 'missing_final_assistant', terminal: true, allowTimeout: allowMissingAssistantTimeout };
                 }
             } else {
                 return {
                     reason: 'missing_final_assistant',
                     terminal: (this.provider as any).requiresFinalAssistantBeforeIdle === true,
+                    allowTimeout: allowMissingAssistantTimeout,
                 };
             }
         }
@@ -1222,7 +1314,10 @@ export class CliProviderInstance implements ProviderInstance {
 
         const latestStatus = this.adapter.getStatus({ allowParse: false });
         const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
-        const latestVisibleStatus = latestAutoApproveActive ? 'generating' : latestStatus.status;
+        const externalNativeFinal = this.getExternalNativeFinalReconciliation(undefined, latestStatus);
+        const latestVisibleStatus = externalNativeFinal && isCliGeneratingLikeStatus(latestStatus.status)
+            ? 'idle'
+            : (latestAutoApproveActive ? 'generating' : latestStatus.status);
         if (latestVisibleStatus !== 'idle') {
             LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
             this.completedDebouncePending = null;
@@ -1230,11 +1325,11 @@ export class CliProviderInstance implements ProviderInstance {
             return;
         }
 
-        const block = this.getCompletedFinalizationBlock(latestVisibleStatus, pending);
+        const block = this.getCompletedFinalizationBlock(latestVisibleStatus, pending, { externalNativeFinal });
         if (block) {
             const blockReason = block.reason;
             const waitedMs = Date.now() - pending.firstObservedAt;
-            if (block.terminal || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
+            if ((block.terminal && !block.allowTimeout) || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
                 if (pending.loggedBlockReason !== blockReason) {
                     LOG.info('CLI', `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
                     pending.loggedBlockReason = blockReason;
@@ -1274,7 +1369,18 @@ export class CliProviderInstance implements ProviderInstance {
             chatTitle: pending.chatTitle,
             duration: pending.duration,
             timestamp: pending.timestamp,
-            finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages),
+            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,
+                },
+            } : {}),
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = null;
@@ -1351,7 +1457,10 @@ export class CliProviderInstance implements ProviderInstance {
         const parsedStatus = null;
         const rawStatus = adapterStatus.status;
         const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, now);
-        const newStatus = autoApproveActive ? 'generating' : rawStatus;
+        const externalNativeFinal = this.getExternalNativeFinalReconciliation(undefined, adapterStatus);
+        const newStatus = externalNativeFinal && isCliGeneratingLikeStatus(rawStatus)
+            ? 'idle'
+            : (autoApproveActive ? '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/contracts.d.ts

@@ -401,7 +401,62 @@ export interface ProviderModule {
     spawnArgBuilder?: (config: Record<string, string>) => string[];
     /** ACP agent auth methods (multiple supported — in priority order) */
     auth?: AcpAuthMethod[];
+    /**
+     * Repo Mesh coordinator capability and MCP ingestion behavior.
+     * Providers must declare this rather than relying on daemon hardcoded CLI quirks.
+     */
+    meshCoordinator?: ProviderMeshCoordinatorConfig;
+}
+export type MeshCoordinatorMcpConfigMode = 'auto_import' | 'manual' | 'none';
+export type MeshCoordinatorMcpConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
+export interface ProviderMeshCoordinatorConfig {
+    supported: boolean;
+    reason?: string;
+    mcpConfig?: {
+        mode: MeshCoordinatorMcpConfigMode;
+        format?: MeshCoordinatorMcpConfigFormat;
+        path?: string;
+        serverName?: string;
+        configPathCommand?: string;
+        requiresRestart?: boolean;
+        instructions?: string;
+        template?: string;
+    };
+    systemPromptInjection?: MeshCoordinatorSystemPromptInjection;
+    delegatedWorkerIsolation?: MeshCoordinatorDelegatedWorkerIsolation;
 }
+export type MeshCoordinatorSystemPromptInjection = {
+    mode: 'cli_arg';
+    flag: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    template: string;
+} | {
+    mode: 'context_file';
+    path: string;
+    wrapper?: string;
+} | {
+    mode: 'env_var';
+    name: string;
+};
+export interface MeshCoordinatorDelegatedWorkerIsolation {
+    env?: {
+        unset?: string[];
+    };
+    args?: MeshCoordinatorDelegatedWorkerArgRule[];
+}
+export type MeshCoordinatorDelegatedWorkerArgRule = {
+    mode: 'empty_mcp_config';
+    flag: string;
+    strictFlag?: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    key: string;
+    value: string;
+    dedupeKey?: string;
+};
 export interface ProviderResumeCapability {
     supported: boolean;
     stopStrategy?: 'command' | 'ctrl_c';