@adhdev/daemon-core 0.9.82-rc.132 → 0.9.82-rc.134

package/dist/mesh/mesh-active-work.d.ts

@@ -21,6 +21,12 @@ export interface MeshActiveWorkRecord {
     terminalKind?: string;
     terminalAt?: string;
     staleReason?: string;
+    /**
+     * When true, the session targeted by this direct dispatch still exists in the live mesh
+     * but did not transition to generating — the dispatch was not acknowledged by the provider.
+     * Distinct from historical/orphaned stale entries where the node/session is gone.
+     */
+    staleDispatchUnacknowledged?: boolean;
 }
 export interface MeshActiveWorkSummary {
     totalActiveCount: number;
@@ -34,10 +40,15 @@ export interface MeshActiveWorkSummary {
     statusCounts: Record<MeshActiveWorkStatus, number>;
     staleDirectCount: number;
     /**
-     * When staleDirectCount > 0, this note clarifies that stale direct records are
-     * historical/recovery evidence — orphaned ledger entries whose original node or session
-     * is no longer present in the live mesh. They are NOT active or unresolved work items.
-     * The active queue (queue source) is the authoritative source for pending/assigned work.
+     * Count of stale direct entries where the target session still exists in the live mesh
+     * but never transitioned to generating — these are fresh dispatch failures, not historical orphans.
+     * Requires immediate recovery: launch a fresh session and retry the task.
+     */
+    staleDirectUnacknowledgedCount?: number;
+    /**
+     * When staleDirectCount > 0, this note clarifies what kind of stale records exist.
+     * Fresh unacknowledged dispatches carry an actionable recovery note; orphaned historical
+     * entries carry the "historical evidence only" note. Both may coexist.
      */
     staleDirectNote?: string;
 }

package/dist/mesh/mesh-events.d.ts

@@ -32,6 +32,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateRefineTerminalEvent?: undefined;
     duplicateCompletion?: undefined;
     error?: undefined;
+    bufferedForGeneratingCoordinator?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -42,6 +43,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateRefineTerminalEvent?: undefined;
     duplicateCompletion?: undefined;
     error?: undefined;
+    bufferedForGeneratingCoordinator?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -52,6 +54,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     terminalLedgerKind?: undefined;
     duplicateCompletion?: undefined;
     error?: undefined;
+    bufferedForGeneratingCoordinator?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -62,6 +65,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     terminalLedgerKind?: undefined;
     duplicateRefineTerminalEvent?: undefined;
     error?: undefined;
+    bufferedForGeneratingCoordinator?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -72,6 +76,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     terminalLedgerKind?: undefined;
     duplicateRefineTerminalEvent?: undefined;
     error?: undefined;
+    bufferedForGeneratingCoordinator?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -82,6 +87,18 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateRefineTerminalEvent?: undefined;
     duplicateCompletion?: undefined;
     error?: undefined;
+    bufferedForGeneratingCoordinator?: undefined;
+} | {
+    success: boolean;
+    forwarded: number;
+    bufferedForGeneratingCoordinator: boolean;
+    suppressed?: undefined;
+    intentionalCleanupStop?: undefined;
+    terminalLedgerEvidence?: undefined;
+    terminalLedgerKind?: undefined;
+    duplicateRefineTerminalEvent?: undefined;
+    duplicateCompletion?: undefined;
+    error?: undefined;
 } | {
     success: boolean;
     error: string;

package/package.json

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

package/src/mesh/coordinator-prompt.ts

@@ -211,7 +211,7 @@ function buildRulesSection(coordinatorCliType?: string): string {
 
 - **Minimize coordinator context.** The coordinator's job is routing, not implementing. Do not read source files, run commands, or analyze code directly — delegate all of that to node agents. Your context should stay lean.
 - **Delegate analysis too.** If you need to understand a bug or explore the codebase, send that investigation as a task to the queue or a node. Do not do it yourself.
-- **Respect explicit provider requests.** If the user names an agent/provider, pass the matching provider type to \`mesh_launch_session\`: Hermes → \`hermes-cli\`, Claude Code/Claude → \`claude-cli\`, Codex → \`codex-cli\`, Gemini → \`gemini-cli\`. Never substitute \`claude-cli\` just because the coordinator itself is Claude Code.
+- **Respect explicit provider requests.** If the user names an agent/provider, pass the matching provider type to \`mesh_launch_session\`: Hermes → \`hermes-cli\`, Claude Code/Claude → \`claude-cli\`, Codex → \`codex-cli\`, Gemini → \`gemini-cli\`, Antigravity → \`antigravity-cli\`. Never substitute \`claude-cli\` just because the coordinator itself is Claude Code.
 - **Front-load new task messages.** When calling \`mesh_enqueue_task\` or \`mesh_send_task\` for a new task, include everything the agent needs: what files to touch, what the problem is, what the fix should look like. The agent won't ask follow-up questions.
 - **Avoid context-wasting restarts.** For follow-up, retry, commit/push, preview, or cleanup work on the same issue, prefer the existing idle session and send only the delta from its last verified state. Start a fresh chat/session only for genuinely independent work, explicit provider/user request, unsafe transcript contamination, or required branch/worktree isolation.
 - **Don't inspect code.** Treat delegated agent summaries as self-reports, not verification. Verify side effects via \`mesh_git_status\` (including related repo freshness when configured), not by reading source files.

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

@@ -23,6 +23,12 @@ export interface MeshActiveWorkRecord {
     terminalKind?: string;
     terminalAt?: string;
     staleReason?: string;
+    /**
+     * When true, the session targeted by this direct dispatch still exists in the live mesh
+     * but did not transition to generating — the dispatch was not acknowledged by the provider.
+     * Distinct from historical/orphaned stale entries where the node/session is gone.
+     */
+    staleDispatchUnacknowledged?: boolean;
 }
 
 export interface MeshActiveWorkSummary {
@@ -37,10 +43,15 @@ export interface MeshActiveWorkSummary {
     statusCounts: Record<MeshActiveWorkStatus, number>;
     staleDirectCount: number;
     /**
-     * When staleDirectCount > 0, this note clarifies that stale direct records are
-     * historical/recovery evidence — orphaned ledger entries whose original node or session
-     * is no longer present in the live mesh. They are NOT active or unresolved work items.
-     * The active queue (queue source) is the authoritative source for pending/assigned work.
+     * Count of stale direct entries where the target session still exists in the live mesh
+     * but never transitioned to generating — these are fresh dispatch failures, not historical orphans.
+     * Requires immediate recovery: launch a fresh session and retry the task.
+     */
+    staleDirectUnacknowledgedCount?: number;
+    /**
+     * When staleDirectCount > 0, this note clarifies what kind of stale records exist.
+     * Fresh unacknowledged dispatches carry an actionable recovery note; orphaned historical
+     * entries carry the "historical evidence only" note. Both may coexist.
      */
     staleDirectNote?: string;
 }
@@ -163,6 +174,7 @@ export function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]):
         statusCounts[item.status] += 1;
     }
     const staleDirectCount = activeWork.filter(item => item.source === 'direct' && item.staleReason).length;
+    const staleDirectUnacknowledgedCount = activeWork.filter(item => item.source === 'direct' && item.staleDispatchUnacknowledged).length;
     return {
         totalActiveCount: activeWork.length,
         queueActiveCount: sourceCounts.queue,
@@ -174,6 +186,7 @@ export function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]):
         sourceCounts,
         statusCounts,
         staleDirectCount,
+        ...(staleDirectUnacknowledgedCount > 0 ? { staleDirectUnacknowledgedCount } : {}),
         ...(staleDirectCount > 0 ? { staleDirectNote: 'Stale direct records are orphaned ledger entries whose node/session no longer exists. They are historical recovery evidence only — not active or unresolved work. The queue (source: queue) is authoritative for pending/assigned tasks.' } : {}),
     };
 }
@@ -216,11 +229,25 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
         const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
         const status = terminalStatus || live.status || 'assigned';
         const terminalRow = Boolean(terminal && terminal.kind !== 'task_approval_needed');
-        const ledgerOnlyStaleReason = !terminalRow && (status === 'idle' || (!terminalStatus && !live.status))
+        // dispatchedToIdleSession is recorded by mesh_send_task when the target session was idle
+        // at dispatch time. Combined with status === 'idle', it confirms no runtime transition.
+        const dispatchedToIdleSession = dispatch.payload?.dispatchedToIdleSession === true;
+        // Flag stale when no terminal event AND either:
+        // - session is now idle (dispatch not acknowledged), OR
+        // - no live status reported (node/session absent from live mesh), OR
+        // - payload flagged idle-at-dispatch AND session is still not generating (redundant guard for clarity).
+        const isNoTransition = !terminalStatus && !live.status;
+        const isIdleUnacknowledged = status === 'idle';
+        const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || (dispatchedToIdleSession && isIdleUnacknowledged))
             ? 'direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition'
             : undefined;
         const message = readString(dispatch.payload?.message) || readString(dispatch.payload?.summary) || '';
         const { title, summary } = summarizeMessage(message);
+        // A dispatch is a fresh unacknowledged failure when the node and session both still exist
+        // in the live mesh but the session never transitioned to generating. This is distinct from
+        // historical/orphaned stale entries where the node or session is gone from the live mesh.
+        // fresh-unacknowledged: ledgerOnlyStaleReason is set (session didn't ack) AND no live.staleReason (node/session is present)
+        const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
         const record: MeshActiveWorkRecord = {
             taskId,
             source: 'direct',
@@ -240,6 +267,7 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
             terminalKind: terminal?.kind,
             terminalAt: terminal?.timestamp,
             staleReason: live.staleReason || ledgerOnlyStaleReason,
+            ...(isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}),
         };
         if (terminalRow) {
             terminalDirectWork.push(record);
@@ -257,8 +285,19 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
     terminalDirectWork.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
     const summary = buildMeshActiveWorkSummary(records);
     summary.staleDirectCount = staleDirectWork.length;
+    const unacknowledgedCount = staleDirectWork.filter(r => r.staleDispatchUnacknowledged).length;
+    if (unacknowledgedCount > 0) {
+        summary.staleDirectUnacknowledgedCount = unacknowledgedCount;
+    }
+    // Build a note that accurately describes what's in the stale set.
+    // When there are fresh unacknowledged entries (node/session still live, session never started),
+    // use the actionable recovery note instead of the misleading "historical evidence only" note.
     const staleDirectWorkNote = staleDirectWork.length > 0
-        ? 'These are orphaned ledger entries whose original node or session no longer exists in the live mesh. They are historical/recovery evidence only — not active or unresolved work. Do not treat staleDirectCount as a status mismatch; use the queue (source: queue) as authoritative for pending/assigned tasks.'
+        ? unacknowledgedCount > 0 && unacknowledgedCount === staleDirectWork.length
+            ? `${unacknowledgedCount} direct dispatch(es) were not acknowledged by the target session — the session received the agent_command but never transitioned to generating. This is a fresh dispatch failure, not historical noise. Recovery: launch a fresh session on the same node and retry the task, or use mesh_enqueue_task for queue-based assignment.`
+            : unacknowledgedCount > 0
+                ? `${unacknowledgedCount} of ${staleDirectWork.length} stale direct record(s) are fresh unacknowledged dispatch failures (session still live but never transitioned to generating); the rest are orphaned historical entries whose node/session no longer exists. Fresh unacknowledged dispatches need recovery: launch a fresh session and retry. Orphaned entries are historical evidence only — not active or unresolved work.`
+                : 'These are orphaned ledger entries whose original node or session no longer exists in the live mesh. They are historical/recovery evidence only — not active or unresolved work. Do not treat staleDirectCount as a status mismatch; use the queue (source: queue) as authoritative for pending/assigned tasks.'
         : undefined;
     if (staleDirectWorkNote) {
         summary.staleDirectNote = staleDirectWorkNote;

package/src/mesh/mesh-events.ts

@@ -415,22 +415,38 @@ function findRecentTerminalLedgerEvidence(args: {
     meshId: string;
     sessionId?: string;
     nodeId?: string;
-}): { kind: MeshLedgerKind; payload: Record<string, unknown>; timestamp: string } | null {
+}): { id: string; kind: MeshLedgerKind; payload: Record<string, unknown>; timestamp: string } | null {
     if (!args.sessionId && !args.nodeId) return null;
     const entries = readLedgerEntries(args.meshId);
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
         if (entry.kind !== 'task_completed' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') continue;
         if (args.sessionId && entry.sessionId === args.sessionId) {
-            return { kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+            return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
         }
         if (!args.sessionId && args.nodeId && entry.nodeId === args.nodeId) {
-            return { kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+            return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
         }
     }
     return null;
 }
 
+// Returns true when a task_dispatched entry for the given session appears AFTER the terminal
+// entry (identified by terminalId) in ledger order. Positional (append) order is used rather
+// than timestamp comparison because both entries may share the same millisecond.
+function hasDispatchAfterTerminal(meshId: string, sessionId: string, terminalId: string): boolean {
+    const entries = readLedgerEntries(meshId);
+    let pastTerminal = false;
+    for (const entry of entries) {
+        if (!pastTerminal) {
+            if (entry.id === terminalId) pastTerminal = true;
+            continue;
+        }
+        if (entry.kind === 'task_dispatched' && entry.sessionId === sessionId) return true;
+    }
+    return false;
+}
+
 function buildLongGeneratingCompletionReconciliation(args: {
     meshId: string;
     nodeId?: string;
@@ -1060,17 +1076,22 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             nodeId: eventNodeId || undefined,
         });
         if (terminal?.kind === 'task_completed' && !sessionHasActiveAssignment(args.meshId, eventSessionId)) {
-            const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
-            const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
-            const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);
-            const eventFinalSummary = readNonEmptyString(args.metadataEvent.finalSummary);
-            if (
-                (terminalProviderSessionId && terminalProviderSessionId === eventProviderSessionId)
-                || (terminalFinalSummary && terminalFinalSummary === eventFinalSummary)
-                || args.metadataEvent.source === 'long_generating_reconciliation'
-            ) {
-                LOG.info('MeshEvents', `Suppressed duplicate completion with existing terminal ledger evidence for mesh ${args.meshId} session ${eventSessionId}`);
-                return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true, terminalLedgerEvidence: true };
+            // If a new task_dispatched was recorded for this session after the prior terminal,
+            // this completion belongs to the new task — never suppress it as a duplicate.
+            const newDispatchAfterTerminal = hasDispatchAfterTerminal(args.meshId, eventSessionId, terminal.id);
+            if (!newDispatchAfterTerminal) {
+                const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
+                const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
+                const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);
+                const eventFinalSummary = readNonEmptyString(args.metadataEvent.finalSummary);
+                if (
+                    (terminalProviderSessionId && terminalProviderSessionId === eventProviderSessionId)
+                    || (terminalFinalSummary && terminalFinalSummary === eventFinalSummary)
+                    || args.metadataEvent.source === 'long_generating_reconciliation'
+                ) {
+                    LOG.info('MeshEvents', `Suppressed duplicate completion with existing terminal ledger evidence for mesh ${args.meshId} session ${eventSessionId}`);
+                    return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true, terminalLedgerEvidence: true };
+                }
             }
         }
         const duplicateCompletion = isDuplicateMeshCompletionEvent({
@@ -1332,7 +1353,24 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     // that poll via get_pending_mesh_events (dual delivery). Refine terminal events are
     // forwarded directly only — they must not accumulate in the pending queue when a live
     // coordinator already received them.
-    if (!isRefineTerminalEvent) {
+    //
+    // Exception: if ALL live CLI coordinator instances are in a generating/active state
+    // when a refine terminal event fires (e.g. a Codex CLI coordinator that triggered an
+    // async refine job and is still in the generating turn that sent it), the coordinator
+    // cannot immediately receive send_message input. Buffer the event to the pending queue
+    // so it is available via get_pending_mesh_events when the coordinator returns to idle.
+    // Critically: do NOT attempt send_message injection into a generating PTY coordinator for
+    // terminal refine events — injecting text into an active PTY can corrupt the input stream
+    // and leave the coordinator stuck in generating state, unable to process the refine result.
+    const allCoordinatorsGenerating = isRefineTerminalEvent && coordinatorInstances.every((inst) => {
+        const s = inst.getState();
+        const status = readNonEmptyString(s.status).toLowerCase();
+        const activeChatStatus = readNonEmptyString(s.activeChat?.status).toLowerCase();
+        return status === 'generating' || status === 'streaming' || status === 'long_generating'
+            || activeChatStatus === 'generating' || activeChatStatus === 'streaming';
+    });
+
+    if (!isRefineTerminalEvent || allCoordinatorsGenerating) {
         if (queuePendingMeshCoordinatorEvent({
                 event: args.event,
                 meshId: args.meshId,
@@ -1346,10 +1384,23 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 coordinatorMessage: messageText,
                 queuedAt: Date.now(),
             })) {
-            LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
+            if (allCoordinatorsGenerating) {
+                LOG.info('MeshEvents', `Queued ${args.event} for generating CLI coordinator (mesh ${args.meshId}) — will be delivered via get_pending_mesh_events when coordinator returns to idle`);
+            } else {
+                LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
+            }
         }
     }
 
+    // When all CLI coordinators are actively generating and a terminal refine event fires,
+    // skip send_message injection entirely. The event is already buffered to the pending queue.
+    // Injecting into a generating PTY coordinator can corrupt its input stream and cause it to
+    // remain stuck in generating state, never processing the refine result.
+    // The coordinator will drain pending events via get_pending_mesh_events on its next idle cycle.
+    if (allCoordinatorsGenerating) {
+        return { success: true, forwarded: 0, bufferedForGeneratingCoordinator: true };
+    }
+
     for (const coord of coordinatorInstances) {
         const coordState = coord.getState();
         LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}`);

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

@@ -899,7 +899,16 @@ export class CliProviderInstance implements ProviderInstance {
         if (!isCliGeneratingLikeStatus(parsedRawStatus)) return false;
         if (adapterRawStatus !== 'idle') return false;
         if (hasNonEmptyCliModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
-        return !this.hasAdapterPendingResponse();
+        if (this.hasAdapterPendingResponse()) return false;
+        // Do not suppress when the adapter's raw response buffer is still non-empty.
+        // This catches the case where isWaitingForResponse has already flipped to false
+        // (so getPartialResponse() returns '') but the provider's native parser still
+        // reports generating because it's parsing buffered content. Suppressing the
+        // finalization block here would emit a false completion event while the provider
+        // session is still actively processing its response stream.
+        const adapterAny = this.adapter as any;
+        if (typeof adapterAny?.responseBuffer === 'string' && adapterAny.responseBuffer.trim()) return false;
+        return true;
     }
 
     private getCompletedFinalizationBlock(latestVisibleStatus: string): CompletedFinalizationBlock | null {
@@ -1122,12 +1131,30 @@ export class CliProviderInstance implements ProviderInstance {
                 }
             } else if (newStatus === 'idle' && (this.lastStatus === 'generating' || this.lastStatus === 'waiting_approval')) {
                 const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
-                // If debounce still pending (generating lasted < 1s), cancel both events
+                // If debounce still pending (generating lasted < 1s), cancel both UI events.
+                // Still emit agent:generating_completed so mesh orchestration can record
+                // task_completed for direct dispatches that complete faster than the debounce.
                 if (this.generatingDebouncePending) {
-                    LOG.info('CLI', `[${this.type}] suppressed short generating (${now - this.generatingStartedAt}ms)`);
+                    const shortDurationMs = this.generatingStartedAt ? now - this.generatingStartedAt : 0;
+                    LOG.info('CLI', `[${this.type}] suppressed short generating (${shortDurationMs}ms)`);
                     if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }
                     this.generatingDebouncePending = null;
                     this.generatingStartedAt = 0;
+                    // Emit completion for mesh task association even though the UI generating
+                    // started/completed pair is suppressed (too short for visible UI update).
+                    let shortFinalSummary: string | undefined;
+                    try { shortFinalSummary = extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages); } catch { /* best-effort */ }
+                    this.pushEvent({
+                        event: 'agent:generating_completed',
+                        chatTitle,
+                        duration: 0,
+                        timestamp: now,
+                        finalSummary: shortFinalSummary,
+                        completionDiagnostic: {
+                            reason: 'short_generating_suppressed',
+                            shortDurationMs,
+                        },
+                    });
                 } else {
                     // Debounce completed, then require the rich transcript path that read_chat
                     // uses to show an idle turn whose last user-facing message is assistant.