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

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.133",
   "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

@@ -1332,7 +1332,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 +1363,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}`);