@adhdev/daemon-core 0.9.82-rc.195 → 0.9.82-rc.197

package/src/mesh/{beads-db.ts → mesh-runtime-store.ts}

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, statSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from 'fs';
 import { dirname, join } from 'path';
 import { createRequire } from 'module';
 import { getLedgerDir } from './mesh-ledger.js';
@@ -26,8 +26,31 @@ function legacyQueuePath(meshId: string): string {
     return join(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
 
-export class BeadsDB {
-    private static instance: BeadsDB | undefined;
+function meshRuntimeStorePath(): string {
+    const dir = getLedgerDir();
+    const nextPath = join(dir, 'mesh-runtime.db');
+    if (existsSync(nextPath)) return nextPath;
+
+    const legacyPath = join(dir, 'beads.db');
+    if (!existsSync(legacyPath)) return nextPath;
+
+    try {
+        renameSync(legacyPath, nextPath);
+        for (const suffix of ['-wal', '-shm']) {
+            const legacyCompanion = `${legacyPath}${suffix}`;
+            if (existsSync(legacyCompanion)) {
+                renameSync(legacyCompanion, `${nextPath}${suffix}`);
+            }
+        }
+    } catch {
+        // Best-effort compatibility for existing installs. If migration fails,
+        // opening the new store will create a clean DB instead of blocking boot.
+    }
+    return nextPath;
+}
+
+export class MeshRuntimeStore {
+    private static instance: MeshRuntimeStore | undefined;
     private readonly db: DatabaseHandle;
     private readonly dbPath: string;
     private readonly migratedMeshIds = new Set<string>();
@@ -49,9 +72,9 @@ export class BeadsDB {
         this.migrate();
     }
 
-    static getInstance(): BeadsDB {
+    static getInstance(): MeshRuntimeStore {
         if (!this.instance) {
-            this.instance = new BeadsDB(join(getLedgerDir(), 'beads.db'));
+            this.instance = new MeshRuntimeStore(meshRuntimeStorePath());
         }
         return this.instance;
     }
@@ -120,6 +143,49 @@ export class BeadsDB {
                 metadata TEXT,
                 PRIMARY KEY (node_id, session_id)
             );
+
+            CREATE TABLE IF NOT EXISTS mesh_session_delivery (
+                id TEXT PRIMARY KEY,
+                mesh_id TEXT NOT NULL,
+                node_id TEXT,
+                session_id TEXT,
+                provider_type TEXT,
+                task_id TEXT,
+                kind TEXT NOT NULL,
+                priority INTEGER NOT NULL DEFAULT 0,
+                message TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'queued',
+                deliver_after TEXT,
+                expires_at TEXT,
+                attempt_count INTEGER NOT NULL DEFAULT 0,
+                source_coordinator_session_id TEXT,
+                source_coordinator_daemon_id TEXT,
+                last_error TEXT,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_session_delivery_mesh_status
+                ON mesh_session_delivery(mesh_id, status, created_at);
+            CREATE INDEX IF NOT EXISTS idx_mesh_session_delivery_session
+                ON mesh_session_delivery(mesh_id, session_id, status);
+            CREATE INDEX IF NOT EXISTS idx_mesh_session_delivery_task
+                ON mesh_session_delivery(mesh_id, task_id);
+
+            CREATE TABLE IF NOT EXISTS mesh_completion_conflicts (
+                id TEXT PRIMARY KEY,
+                mesh_id TEXT NOT NULL,
+                fingerprint TEXT NOT NULL,
+                conflicting_task_id TEXT,
+                conflicting_session_id TEXT,
+                original_task_id TEXT,
+                original_session_id TEXT,
+                event TEXT NOT NULL,
+                created_at TEXT NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_completion_conflicts_mesh
+                ON mesh_completion_conflicts(mesh_id, created_at);
         `);
     }
 
@@ -149,13 +215,13 @@ export class BeadsDB {
     }
 
     private maybeCheckpointWal(): void {
-        if (++this.walWriteCounter < BeadsDB.WAL_CHECK_INTERVAL) return;
+        if (++this.walWriteCounter < MeshRuntimeStore.WAL_CHECK_INTERVAL) return;
         this.walWriteCounter = 0;
         try {
             const walPath = `${this.dbPath}-wal`;
             if (!existsSync(walPath)) return;
             const size = statSync(walPath).size;
-            if (size < BeadsDB.WAL_MAX_BYTES) return;
+            if (size < MeshRuntimeStore.WAL_MAX_BYTES) return;
             process.stderr.write(
                 `[adhdev-mesh] WAL file ${Math.round(size / 1024 / 1024)}MB exceeds threshold; forcing checkpoint\n`,
             );
@@ -524,4 +590,180 @@ export class BeadsDB {
     pruneExpiredRemoteIdleSessions(): void {
         this.db.prepare('DELETE FROM remote_idle_sessions WHERE expires_at <= ?').run(Date.now());
     }
+
+    // ── Session Delivery Queue ───────────────────────────────────────────────
+
+    insertSessionDelivery(entry: {
+        id: string;
+        meshId: string;
+        nodeId?: string;
+        sessionId?: string;
+        providerType?: string;
+        taskId?: string;
+        kind: string;
+        priority?: number;
+        message: string;
+        status: string;
+        deliverAfter?: string;
+        expiresAt?: string;
+        sourceCoordinatorSessionId?: string;
+        sourceCoordinatorDaemonId?: string;
+        createdAt: string;
+        updatedAt: string;
+    }): void {
+        this.db.prepare(`
+            INSERT OR REPLACE INTO mesh_session_delivery (
+                id, mesh_id, node_id, session_id, provider_type, task_id, kind, priority,
+                message, status, deliver_after, expires_at, attempt_count,
+                source_coordinator_session_id, source_coordinator_daemon_id,
+                last_error, created_at, updated_at
+            ) VALUES (
+                @id, @meshId, @nodeId, @sessionId, @providerType, @taskId, @kind, @priority,
+                @message, @status, @deliverAfter, @expiresAt, 0,
+                @sourceCoordinatorSessionId, @sourceCoordinatorDaemonId,
+                NULL, @createdAt, @updatedAt
+            )
+        `).run({
+            id: entry.id,
+            meshId: entry.meshId,
+            nodeId: entry.nodeId ?? null,
+            sessionId: entry.sessionId ?? null,
+            providerType: entry.providerType ?? null,
+            taskId: entry.taskId ?? null,
+            kind: entry.kind,
+            priority: entry.priority ?? 0,
+            message: entry.message,
+            status: entry.status,
+            deliverAfter: entry.deliverAfter ?? null,
+            expiresAt: entry.expiresAt ?? null,
+            sourceCoordinatorSessionId: entry.sourceCoordinatorSessionId ?? null,
+            sourceCoordinatorDaemonId: entry.sourceCoordinatorDaemonId ?? null,
+            createdAt: entry.createdAt,
+            updatedAt: entry.updatedAt,
+        });
+        this.maybeCheckpointWal();
+    }
+
+    updateSessionDeliveryStatus(id: string, status: string, opts?: { lastError?: string; incrementAttempt?: boolean }): void {
+        const now = new Date().toISOString();
+        if (opts?.incrementAttempt) {
+            this.db.prepare(`
+                UPDATE mesh_session_delivery
+                SET status = @status, last_error = @lastError, attempt_count = attempt_count + 1, updated_at = @updatedAt
+                WHERE id = @id
+            `).run({ id, status, lastError: opts?.lastError ?? null, updatedAt: now });
+        } else {
+            this.db.prepare(`
+                UPDATE mesh_session_delivery
+                SET status = @status, last_error = @lastError, updated_at = @updatedAt
+                WHERE id = @id
+            `).run({ id, status, lastError: opts?.lastError ?? null, updatedAt: now });
+        }
+    }
+
+    getActiveSessionDeliveries(meshId: string, sessionId?: string): Array<{
+        id: string; meshId: string; nodeId: string | null; sessionId: string | null;
+        providerType: string | null; taskId: string | null; kind: string; priority: number;
+        message: string; status: string; deliverAfter: string | null; expiresAt: string | null;
+        attemptCount: number; sourceCoordinatorSessionId: string | null;
+        sourceCoordinatorDaemonId: string | null; lastError: string | null;
+        createdAt: string; updatedAt: string;
+    }> {
+        const now = new Date().toISOString();
+        const sql = sessionId
+            ? `SELECT * FROM mesh_session_delivery WHERE mesh_id = ? AND session_id = ? AND status NOT IN ('delivered','completed','failed','expired','cancelled') AND (expires_at IS NULL OR expires_at > ?) ORDER BY priority DESC, created_at ASC`
+            : `SELECT * FROM mesh_session_delivery WHERE mesh_id = ? AND status NOT IN ('delivered','completed','failed','expired','cancelled') AND (expires_at IS NULL OR expires_at > ?) ORDER BY priority DESC, created_at ASC`;
+        const rows = sessionId
+            ? this.db.prepare(sql).all(meshId, sessionId, now) as Array<Record<string, unknown>>
+            : this.db.prepare(sql).all(meshId, now) as Array<Record<string, unknown>>;
+        return rows.map(r => ({
+            id: r.id as string,
+            meshId: r.mesh_id as string,
+            nodeId: r.node_id as string | null,
+            sessionId: r.session_id as string | null,
+            providerType: r.provider_type as string | null,
+            taskId: r.task_id as string | null,
+            kind: r.kind as string,
+            priority: r.priority as number,
+            message: r.message as string,
+            status: r.status as string,
+            deliverAfter: r.deliver_after as string | null,
+            expiresAt: r.expires_at as string | null,
+            attemptCount: r.attempt_count as number,
+            sourceCoordinatorSessionId: r.source_coordinator_session_id as string | null,
+            sourceCoordinatorDaemonId: r.source_coordinator_daemon_id as string | null,
+            lastError: r.last_error as string | null,
+            createdAt: r.created_at as string,
+            updatedAt: r.updated_at as string,
+        }));
+    }
+
+    expireStaleSessionDeliveries(meshId: string): void {
+        const now = new Date().toISOString();
+        this.db.prepare(`
+            UPDATE mesh_session_delivery
+            SET status = 'expired', updated_at = ?
+            WHERE mesh_id = ? AND expires_at IS NOT NULL AND expires_at <= ?
+              AND status NOT IN ('delivered','completed','failed','expired','cancelled')
+        `).run(now, meshId, now);
+    }
+
+    deleteSessionDeliveries(meshId: string): void {
+        this.db.prepare('DELETE FROM mesh_session_delivery WHERE mesh_id = ?').run(meshId);
+    }
+
+    // ── Completion Conflict Diagnostics ──────────────────────────────────────
+
+    recordCompletionConflict(entry: {
+        id: string;
+        meshId: string;
+        fingerprint: string;
+        conflictingTaskId?: string;
+        conflictingSessionId?: string;
+        originalTaskId?: string;
+        originalSessionId?: string;
+        event: string;
+        createdAt: string;
+    }): void {
+        this.db.prepare(`
+            INSERT OR IGNORE INTO mesh_completion_conflicts
+                (id, mesh_id, fingerprint, conflicting_task_id, conflicting_session_id,
+                 original_task_id, original_session_id, event, created_at)
+            VALUES (@id, @meshId, @fingerprint, @conflictingTaskId, @conflictingSessionId,
+                    @originalTaskId, @originalSessionId, @event, @createdAt)
+        `).run({
+            id: entry.id,
+            meshId: entry.meshId,
+            fingerprint: entry.fingerprint,
+            conflictingTaskId: entry.conflictingTaskId ?? null,
+            conflictingSessionId: entry.conflictingSessionId ?? null,
+            originalTaskId: entry.originalTaskId ?? null,
+            originalSessionId: entry.originalSessionId ?? null,
+            event: entry.event,
+            createdAt: entry.createdAt,
+        });
+        this.maybeCheckpointWal();
+    }
+
+    getRecentCompletionConflicts(meshId: string, limitMs: number = 60 * 60 * 1000): Array<{
+        id: string; meshId: string; fingerprint: string; conflictingTaskId: string | null;
+        conflictingSessionId: string | null; originalTaskId: string | null;
+        originalSessionId: string | null; event: string; createdAt: string;
+    }> {
+        const cutoff = new Date(Date.now() - limitMs).toISOString();
+        const rows = this.db.prepare(
+            'SELECT * FROM mesh_completion_conflicts WHERE mesh_id = ? AND created_at >= ? ORDER BY created_at DESC LIMIT 50'
+        ).all(meshId, cutoff) as Array<Record<string, unknown>>;
+        return rows.map(r => ({
+            id: r.id as string,
+            meshId: r.mesh_id as string,
+            fingerprint: r.fingerprint as string,
+            conflictingTaskId: r.conflicting_task_id as string | null,
+            conflictingSessionId: r.conflicting_session_id as string | null,
+            originalTaskId: r.original_task_id as string | null,
+            originalSessionId: r.original_session_id as string | null,
+            event: r.event as string,
+            createdAt: r.created_at as string,
+        }));
+    }
 }

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

@@ -1,7 +1,7 @@
 import { randomUUID } from 'crypto';
 import { requireMeshHostQueueOwner } from './mesh-host-ownership.js';
 import type { RepoMeshDaemonRole } from '../repo-mesh-types.js';
-import { BeadsDB } from './beads-db.js';
+import { MeshRuntimeStore } from './mesh-runtime-store.js';
 
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
 export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
@@ -145,15 +145,15 @@ export function nodeSatisfiesRequiredTags(requiredTags: unknown, capabilityTags:
 }
 
 function withQueueLock<T>(_meshId: string, fn: () => T): T {
-    return BeadsDB.getInstance().transaction(fn);
+    return MeshRuntimeStore.getInstance().transaction(fn);
 }
 
 function readQueue(meshId: string): MeshWorkQueueEntry[] {
-    return BeadsDB.getInstance().getQueueEntries(meshId);
+    return MeshRuntimeStore.getInstance().getQueueEntries(meshId);
 }
 
 function writeQueue(meshId: string, queue: MeshWorkQueueEntry[]): void {
-    BeadsDB.getInstance().replaceQueue(meshId, queue);
+    MeshRuntimeStore.getInstance().replaceQueue(meshId, queue);
 }
 
 /**
@@ -181,7 +181,7 @@ export function enqueueTask(
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
     };
-    BeadsDB.getInstance().insertQueueEntry(entry);
+    MeshRuntimeStore.getInstance().insertQueueEntry(entry);
     return entry;
 }
 
@@ -189,18 +189,18 @@ export function enqueueTask(
  * Get all tasks in the queue, optionally filtered by status.
  */
 export function getQueue(meshId: string, opts?: { status?: MeshTaskStatus[] }): MeshWorkQueueEntry[] {
-    return BeadsDB.getInstance().getQueueEntries(meshId, opts?.status?.length ? opts.status : undefined);
+    return MeshRuntimeStore.getInstance().getQueueEntries(meshId, opts?.status?.length ? opts.status : undefined);
 }
 
 export function getMeshQueueRevision(meshId: string): string {
-    return BeadsDB.getInstance().getQueueRevision(meshId);
+    return MeshRuntimeStore.getInstance().getQueueRevision(meshId);
 }
 
 /**
  * Find the next pending task that this node is allowed to claim, and mark it as assigned.
  */
 export function claimNextTask(meshId: string, nodeId: string, sessionId: string, capabilityTags?: string[]): MeshWorkQueueEntry | null {
-    return BeadsDB.getInstance().claimNextQueueTask(meshId, nodeId, sessionId, capabilityTags);
+    return MeshRuntimeStore.getInstance().claimNextQueueTask(meshId, nodeId, sessionId, capabilityTags);
 }
 
 /**
@@ -215,10 +215,10 @@ export function updateTaskStatus(
 ): MeshWorkQueueEntry | null {
     requireMeshHostQueueOwner(opts);
     return withQueueLock(meshId, () => {
-        const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+        const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
         entry.status = status;
-        BeadsDB.getInstance().updateQueueEntry(entry);
+        MeshRuntimeStore.getInstance().updateQueueEntry(entry);
         return entry;
     });
 }
@@ -229,11 +229,11 @@ export function recordTaskAutoLaunch(
     autoLaunch: Omit<NonNullable<MeshWorkQueueEntry['autoLaunch']>, 'updatedAt'>,
 ): MeshWorkQueueEntry | null {
     return withQueueLock(meshId, () => {
-        const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+        const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
         const now = new Date().toISOString();
         entry.autoLaunch = { ...autoLaunch, updatedAt: now };
-        BeadsDB.getInstance().updateQueueEntry(entry);
+        MeshRuntimeStore.getInstance().updateQueueEntry(entry);
         return entry;
     });
 }
@@ -248,13 +248,13 @@ export function cancelTask(
 ): MeshWorkQueueEntry | null {
     requireMeshHostQueueOwner(opts);
     return withQueueLock(meshId, () => {
-        const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+        const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
         const now = new Date().toISOString();
         entry.status = 'cancelled';
         entry.cancelledAt = now;
         if (opts?.reason) entry.cancelReason = opts.reason;
-        BeadsDB.getInstance().updateQueueEntry(entry);
+        MeshRuntimeStore.getInstance().updateQueueEntry(entry);
         return entry;
     });
 }
@@ -276,7 +276,7 @@ export function requeueTask(
 ): MeshWorkQueueEntry | null {
     requireMeshHostQueueOwner(opts);
     return withQueueLock(meshId, () => {
-        const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+        const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
         entry.status = 'pending';
         delete entry.assignedNodeId;
@@ -290,7 +290,7 @@ export function requeueTask(
         entry.requeuedAt = new Date().toISOString();
         entry.requeueCount = (entry.requeueCount || 0) + 1;
         if (opts?.reason) entry.requeueReason = opts.reason;
-        BeadsDB.getInstance().updateQueueEntry(entry);
+        MeshRuntimeStore.getInstance().updateQueueEntry(entry);
         return entry;
     });
 }
@@ -306,10 +306,10 @@ export function updateSessionTaskStatus(
 ): MeshWorkQueueEntry | null {
     return withQueueLock(meshId, () => {
         const occurredAtIso = opts?.occurredAt ? new Date(opts.occurredAt).toISOString() : undefined;
-        const entry = BeadsDB.getInstance().findAssignedBySession(meshId, sessionId, occurredAtIso);
+        const entry = MeshRuntimeStore.getInstance().findAssignedBySession(meshId, sessionId, occurredAtIso);
         if (!entry) return null;
         entry.status = status;
-        BeadsDB.getInstance().updateQueueEntry(entry);
+        MeshRuntimeStore.getInstance().updateQueueEntry(entry);
         return entry;
     });
 }
@@ -339,7 +339,7 @@ export interface MeshWorkQueueStats {
  * Return aggregate queue statistics for the given mesh.
  */
 export function getMeshQueueStats(meshId: string): MeshWorkQueueStats {
-    const rows = BeadsDB.getInstance().getQueueStatsByStatus(meshId);
+    const rows = MeshRuntimeStore.getInstance().getQueueStatsByStatus(meshId);
     const counts: Record<string, number> = {};
     for (const r of rows) counts[r.status] = r.count;
     const pending = counts['pending'] ?? 0;
@@ -358,33 +358,33 @@ export function getMeshQueueStats(meshId: string): MeshWorkQueueStats {
         cancelled,
         activeCounts: { pending, assigned },
         historicalCounts: { completed, failed, cancelled },
-        activeAssignments: BeadsDB.getInstance().getActiveAssignmentDetails(meshId),
+        activeAssignments: MeshRuntimeStore.getInstance().getActiveAssignmentDetails(meshId),
     };
 }
 
 export function __replaceMeshQueueForTests(meshId: string, queue: MeshWorkQueueEntry[]): void {
-    BeadsDB.getInstance().transaction(() => {
-        BeadsDB.getInstance().replaceQueue(meshId, queue);
+    MeshRuntimeStore.getInstance().transaction(() => {
+        MeshRuntimeStore.getInstance().replaceQueue(meshId, queue);
     });
 }
 
 export function __clearMeshQueueForTests(meshId: string): void {
-    BeadsDB.getInstance().deleteQueue(meshId);
+    MeshRuntimeStore.getInstance().deleteQueue(meshId);
 }
 
 export function __clearDirectDispatchesForTests(meshId: string): void {
-    BeadsDB.getInstance().deleteDirectDispatches(meshId);
+    MeshRuntimeStore.getInstance().deleteDirectDispatches(meshId);
 }
 
-export function __resetBeadsDBForTests(): void {
-    BeadsDB.resetForTests();
+export function __resetMeshRuntimeStoreForTests(): void {
+    MeshRuntimeStore.resetForTests();
 }
 
 // ── Direct Dispatch Tracking ─────────────────────────────────────────────────
 // Persists direct (non-queue) task dispatches so buildMeshActiveWork can read
-// active work from BeadsDB instead of scanning ledger JSONL entries.
+// active work from MeshRuntimeStore instead of scanning ledger JSONL entries.
 
-export type DirectDispatchRecord = ReturnType<BeadsDB['getActiveDirectDispatches']>[number];
+export type DirectDispatchRecord = ReturnType<MeshRuntimeStore['getActiveDirectDispatches']>[number];
 
 export function insertDirectDispatch(
     meshId: string,
@@ -401,7 +401,7 @@ export function insertDirectDispatch(
     },
 ): void {
     try {
-        BeadsDB.getInstance().insertDirectDispatch({ ...data, meshId });
+        MeshRuntimeStore.getInstance().insertDirectDispatch({ ...data, meshId });
     } catch (e: any) {
         process.stderr.write(`[adhdev-mesh] insertDirectDispatch failed for task ${data.taskId}: ${e?.message || e}\n`);
     }
@@ -409,7 +409,7 @@ export function insertDirectDispatch(
 
 export function getActiveDirectDispatches(meshId: string): DirectDispatchRecord[] {
     try {
-        return BeadsDB.getInstance().getActiveDirectDispatches(meshId);
+        return MeshRuntimeStore.getInstance().getActiveDirectDispatches(meshId);
     } catch {
         return [];
     }
@@ -421,18 +421,18 @@ export function updateDirectDispatchStatus(
     status: 'acked' | 'completed' | 'failed' | 'stale',
 ): void {
     try {
-        BeadsDB.getInstance().updateDirectDispatchStatus(meshId, sessionId, status);
+        MeshRuntimeStore.getInstance().updateDirectDispatchStatus(meshId, sessionId, status);
     } catch { /* best-effort */ }
 }
 
 export function cleanupTerminalDirectDispatches(olderThanMs = 7 * 24 * 60 * 60_000): void {
     try {
-        BeadsDB.getInstance().cleanupTerminalDirectDispatches(olderThanMs);
+        MeshRuntimeStore.getInstance().cleanupTerminalDirectDispatches(olderThanMs);
     } catch { /* best-effort */ }
 }
 
 export function markStaleDirectDispatches(meshId: string, olderThanMs = 60 * 60_000): void {
     try {
-        BeadsDB.getInstance().markStaleDirectDispatches(meshId, olderThanMs);
+        MeshRuntimeStore.getInstance().markStaleDirectDispatches(meshId, olderThanMs);
     } catch { /* best-effort */ }
 }

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

@@ -724,16 +724,24 @@ export class CliProviderInstance implements ProviderInstance {
                 ? visibleStatus
                 : (suppressStaleParsedBusyStatus ? visibleStatus : (parsedChatStatus || visibleStatus)));
 
+        // If an AskUserQuestion prompt is awaiting user input, overlay status as
+        // waiting_choice. This is distinct from waiting_approval (tool-use consent)
+        // — the engine's isWaitingForResponse state is unchanged, so completion
+        // tracking continues normally once the user responds.
+        const hasInteractivePrompt = !!this.activeInteractivePrompt;
+        const finalStatus = hasInteractivePrompt ? 'waiting_choice' : visibleStatus;
+        const finalChatStatus = hasInteractivePrompt ? 'waiting_choice' : activeChatStatus;
+
         return {
             type: this.type,
             name: this.provider.name,
             category: 'cli',
-            status: visibleStatus,
+            status: finalStatus,
             mode: this.presentationMode,
             activeChat: {
                 id: activeChatId,
                 title: parsedStatus?.title || dirName,
-                status: activeChatStatus,
+                status: finalChatStatus,
                 messages: statusMessages,
                 activeModal: autoApproveActive ? null : (parsedStatus?.activeModal ?? adapterStatus.activeModal),
                 activeInteractivePrompt: this.activeInteractivePrompt,
@@ -1265,6 +1273,7 @@ export class CliProviderInstance implements ProviderInstance {
         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);
+        LOG.debug('CLI', `[${this.type}] finalAssistantEvidence: present=${finalAssistantEvidence.present} source=${finalAssistantEvidence.source} adapterOwnsMessagesElsewhere=${adapterOwnsMessagesElsewhere} parsedStatus=${parsedStatus}`);
         if (!finalAssistantEvidence.present) {
             if (adapterOwnsMessagesElsewhere) {
                 if (finalAssistantEvidence.source === 'external-native') {
@@ -1273,19 +1282,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;
                     }
+                    LOG.debug('CLI', `[${this.type}] external-native probe result: lastRole=${probe?.lastRole} contentLen=${probe?.contentLen}`);
+                    if (probe?.lastRole === 'assistant' && (probe.contentLen ?? 0) > 0) {
+                        return null;
+                    }
                     if (this.type === 'antigravity-cli') {
                         return null;
                     }
                     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, allowTimeout: allowMissingAssistantTimeout };
                 }
             } else {
+                LOG.debug('CLI', `[${this.type}] missing_final_assistant (not ownsExternal) requiresFinalAssistant=${!!(this.provider as any).requiresFinalAssistantBeforeIdle}`);
                 return {
                     reason: 'missing_final_assistant',
                     terminal: (this.provider as any).requiresFinalAssistantBeforeIdle === true,
@@ -1331,6 +1341,7 @@ export class CliProviderInstance implements ProviderInstance {
         const latestVisibleStatus = externalNativeFinal && isCliGeneratingLikeStatus(latestStatus.status)
             ? 'idle'
             : (latestAutoApproveActive ? '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?.()}`);
         if (latestVisibleStatus !== 'idle') {
             LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
             this.completedDebouncePending = null;
@@ -1342,6 +1353,7 @@ export class CliProviderInstance implements ProviderInstance {
         if (block) {
             const blockReason = block.reason;
             const waitedMs = Date.now() - pending.firstObservedAt;
+            LOG.debug('CLI', `[${this.type}] finalization block: reason=${blockReason} terminal=${block.terminal} waitedMs=${waitedMs} maxWait=${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})`);
@@ -1485,10 +1497,18 @@ export class CliProviderInstance implements ProviderInstance {
         if (newStatus !== this.lastStatus) {
             LOG.info('CLI', `[${this.type}] status: ${this.lastStatus} → ${newStatus}`);
             if (this.lastStatus === 'idle' && newStatus === 'generating') {
+                // If a completion event is already pending and the turn has ended
+                // (generatingStartedAt===0), the PTY is painting its prompt area
+                // after completing. Ignore this blip — do not cancel the pending
+                // completion and do not advance lastStatus to generating.
+                if (this.completedDebouncePending && this.generatingStartedAt === 0) {
+                    LOG.debug('CLI', `[${this.type}] ignoring post-completion PTY generating blip (generatingStartedAt=0)`);
+                    return;
+                }
                 this.suppressIdleHistoryReplay = false;
                 // Cancel any pending completed event (multi-step: idle→generating resume)
                 if (this.completedDebouncePending) {
-                    LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed generating)`);
+                    LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed generating) generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!(this.adapter as any)?.isWaitingForResponse}`);
                     if (this.completedDebounceTimer) { clearTimeout(this.completedDebounceTimer); this.completedDebounceTimer = null; }
                     this.completedDebouncePending = null;
                 }
@@ -1586,7 +1606,10 @@ export class CliProviderInstance implements ProviderInstance {
                         firstObservedAt: now,
                         previousStatus: this.lastStatus,
                     };
-                    this.scheduleCompletedDebounceFlush(3000);
+                    const ownsExternalHistory = !!(this.adapter as any)?.chatMessagesOwnedExternally;
+                    const flushDelay = ownsExternalHistory ? 0 : 3000;
+                    LOG.debug('CLI', `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
+                    this.scheduleCompletedDebounceFlush(flushDelay);
                 }
             } else if (newStatus === 'idle' && this.lastStatus === 'starting') {
                 this.pushEvent({ event: 'agent:ready', chatTitle, timestamp: now });

package/src/providers/provider-instance.ts

@@ -16,7 +16,7 @@ import type { InteractivePrompt } from './types/interactive-prompt.js';
 
 // ─── ProviderState — Discriminated union by category ─────────────
 
-export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'waiting_choice' | 'error' | 'stopped' | 'starting';
 
 export interface ProviderRuntimeWriteOwner {
     clientId: string;