@adhdev/daemon-core 0.9.82-rc.350 → 0.9.82-rc.352

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

@@ -7,6 +7,7 @@ import { LOG } from '../logging/logger.js';
 import { appendLedgerEntry, buildTaskCompletionEvidence, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerKind, SessionRecoveryContext } from './mesh-ledger.js';
 import { buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus, getQueue, recordTaskAutoLaunch, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents } from './mesh-work-queue.js';
+import type { MeshWorkQueueEntry } from './mesh-work-queue.js';
 import { fastForwardMeshNode } from './mesh-fast-forward.js';
 import { createSessionDelivery, markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompletionConflict } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
@@ -17,7 +18,7 @@ import { enqueueUnresolvedDelegateForward, peekUnresolvedDelegateForwards, ackUn
 import { getLastDisplayMessage } from '../status/snapshot.js';
 import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy } from '../repo-mesh-types.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
-import { normalizeMeshNodeId, meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared';
+import { normalizeMeshNodeId, meshNodeIdMatches, expandDaemonIdForms, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
     hasDispatchAfterTerminal,
@@ -35,16 +36,16 @@ import {
 } from './mesh-events-utils.js';
 
 // The set of coordinator-daemon ids this daemon answers to when draining the
-// pending-events queue (canonical status id + bare machineId). Mirrors
-// resolveCoordinatorDaemonIds in mesh-reconcile-loop — a unicast event may be
-// stamped with either id depending on which dispatch path created the worker.
+// pending-events queue. Mirrors resolveCoordinatorDaemonIds in mesh-reconcile-loop:
+// a unicast event may be stamped with the status id, the bare machineId, OR the
+// config-form node daemonId (`daemon_<machineId>`) depending on which dispatch path
+// created the worker. We expand to EVERY equivalent form so a `daemon_<machineId>`
+// completion matches a coordinator that knows itself as bare `<machineId>` (the
+// base-node completion-surface bug) and vice versa.
 function resolveCoordinatorDrainDaemonIds(components: DaemonComponents): string[] {
-    const ids = new Set<string>();
     const statusInstanceId = readNonEmptyString((components as { statusInstanceId?: string }).statusInstanceId);
-    if (statusInstanceId) ids.add(statusInstanceId);
     const machineId = readNonEmptyString(loadConfig().machineId);
-    if (machineId) ids.add(machineId);
-    return [...ids];
+    return expandDaemonIdForms([statusInstanceId, machineId]);
 }
 
 // ---------------------------------------------------------------------------
@@ -251,10 +252,148 @@ function isDuplicateRefineTerminalEvent(meshId: string, eventName: string, metad
     return false;
 }
 
+// A worker/coordinator "false idle": the provider dropped to idle WITHOUT a confirmed
+// final assistant message for the turn (a finalization timeout, or a "scheduled fallback"
+// idle). This is the signal cli-provider-instance emits as
+// completionDiagnostic.blockReason='missing_final_assistant' / finalAssistantPresent=false.
+// Such a completion is NOT trustworthy terminal evidence: it must neither permanently
+// terminate a direct-dispatch task nor suppress the genuine completion a later turn
+// (commonly driven by a coordinator nudge / re-dispatch) produces.
+function isFalseIdleCompletion(metadataEvent: Record<string, unknown>): boolean {
+    const diag = readRecord(metadataEvent.completionDiagnostic);
+    if (!diag) return false;
+    return diag.finalAssistantPresent === false || diag.blockReason === 'missing_final_assistant';
+}
+
+// The genuine-completion counterpart: a real final summary / worker result is present and
+// the completion is not flagged as a missing-final-assistant false idle. Used to decide
+// whether a new completion may supersede a prior WEAK (false-idle) terminal.
+function isGenuineCompletionEvidence(metadataEvent: Record<string, unknown>): boolean {
+    if (isFalseIdleCompletion(metadataEvent)) return false;
+    return !!readWorkerResultMetadata(metadataEvent) || !!readNonEmptyString(metadataEvent.finalSummary);
+}
+
+// True when a terminal ledger payload was recorded from WEAK completion evidence (a false
+// idle): insufficient evidence level, review-recommended, or a missing-final-assistant
+// completion diagnostic. A weak terminal is non-authoritative — a later genuine completion
+// (live path) or a transcript reconcile (fallback path) may supersede it.
+function isWeakTerminalLedgerPayload(payload: Record<string, unknown> | undefined): boolean {
+    if (!payload) return false;
+    if (payload.evidenceLevel === 'insufficient' || payload.reviewRecommended === true) return true;
+    const diag = readRecord(payload.completionDiagnostic);
+    return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
+}
+
+// The latest still-active direct-dispatch taskId for a session, resolved BEFORE the
+// completion flips the dispatch row terminal. Direct dispatches (mesh_send_task) have no
+// work-queue row, so this is the only taskId available to attribute the terminal ledger
+// entry (and thus mesh task-stats) to — without it the terminal carries no taskId and the
+// task surfaces as status='unknown' / terminalKind=null in computeMeshTaskStats.
+function resolveActiveDirectDispatchTaskId(meshId: string, sessionId: string): string | undefined {
+    try {
+        const matches = getActiveDirectDispatches(meshId).filter(d => d.sessionId === sessionId);
+        if (!matches.length) return undefined;
+        // getActiveDirectDispatches returns rows ordered by dispatched_at ASC; the last is
+        // the most recent dispatch (the re-dispatch / nudge whose completion this is).
+        return readNonEmptyString(matches[matches.length - 1].taskId) || undefined;
+    } catch {
+        return undefined;
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Queue assignment
 // ---------------------------------------------------------------------------
 
+// Per-dispatch confirmation timeout (Bug B). A dispatch promise that never settles —
+// a saturated remote P2P relay that hangs, or a transport that resolves only after
+// the worker acks — would otherwise leave the just-claimed queue row 'assigned' with
+// its delivery stuck 'delivering' forever: the .catch that requeues never fires, and
+// PHASE 3 reconcile skips the row (it counts 0 pending). Racing the dispatch against
+// this timeout guarantees a hung dispatch deterministically returns the task to
+// 'pending' for re-dispatch. Generous so a merely-slow-but-live dispatch (a cold
+// remote relay) is never reclaimed early; the reconcile assigned-stranded watchdog is
+// the durable cross-restart backstop for a timer lost to a daemon restart.
+const DISPATCH_CONFIRM_TIMEOUT_MS = 120_000;
+
+interface DeliverTaskContext {
+    meshId: string;
+    nodeId: string;
+    sessionId: string;
+    providerType: string;
+    task: MeshWorkQueueEntry;
+    transport: 'remote' | 'local';
+    sourceCoordinatorSessionId?: string;
+    sourceCoordinatorDaemonId?: string;
+}
+
+// CONS scope 3: the SINGLE source of truth for dispatching a claimed task to its
+// session. The remote (P2P dispatchMeshCommand) and local (cliManager.handleCliCommand)
+// branches differ ONLY in the transport call — the delivery record, the delivered/failed
+// transitions, the pending-requeue-on-failure, the dispatch_failed ledger entry, AND the
+// Bug B hang timeout are identical and live here once so a future change to the dispatch
+// lifecycle cannot drift between the two paths. The caller passes a `dispatchThunk` that
+// performs only the transport-specific send and returns its promise.
+function deliverTaskToSession(dispatchThunk: () => Promise<unknown>, ctx: DeliverTaskContext): void {
+    const delivery = createSessionDelivery({
+        meshId: ctx.meshId,
+        nodeId: ctx.nodeId,
+        sessionId: ctx.sessionId,
+        providerType: ctx.providerType,
+        taskId: ctx.task.id,
+        kind: 'task',
+        message: ctx.task.message,
+        status: 'delivering',
+        ...(ctx.sourceCoordinatorSessionId ? { sourceCoordinatorSessionId: ctx.sourceCoordinatorSessionId } : {}),
+        ...(ctx.sourceCoordinatorDaemonId ? { sourceCoordinatorDaemonId: ctx.sourceCoordinatorDaemonId } : {}),
+    });
+
+    // Invoke the transport synchronously (preserves the prior fire-and-forget timing,
+    // and lets a synchronous throw fall into the same failure path as a rejection).
+    let dispatchPromise: Promise<unknown>;
+    try {
+        dispatchPromise = Promise.resolve(dispatchThunk());
+    } catch (e) {
+        dispatchPromise = Promise.reject(e);
+    }
+
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const guarded = Promise.race([
+        dispatchPromise,
+        new Promise<never>((_, reject) => {
+            timer = setTimeout(
+                () => reject(new Error(`dispatch_confirm_timeout after ${DISPATCH_CONFIRM_TIMEOUT_MS}ms`)),
+                DISPATCH_CONFIRM_TIMEOUT_MS,
+            );
+            // Never keep the process alive solely for this confirm-timeout timer.
+            if (typeof (timer as { unref?: () => void })?.unref === 'function') (timer as { unref: () => void }).unref();
+        }),
+    ]);
+
+    guarded.then(() => {
+        if (timer) clearTimeout(timer);
+        updateSessionDeliveryStatus(delivery.id, 'delivered');
+    }).catch((e: any) => {
+        if (timer) clearTimeout(timer);
+        // A dispatch failure (transport reject OR hang timeout) is most often transient —
+        // a busy/refusing adapter, or a relay that never acked — not a permanent task
+        // failure. Marking the task terminal here would permanently kill tasks a later
+        // tick delivers fine. Return it to 'pending' and record a retryable dispatch_failed
+        // ledger entry so the reconcile loop re-dispatches it. Identical for both transports.
+        LOG.error('MeshQueue', `Failed to dispatch task via ${ctx.transport} to node ${ctx.nodeId}: ${e?.message}`);
+        updateSessionDeliveryStatus(delivery.id, 'failed', { lastError: e?.message, incrementAttempt: true });
+        updateTaskStatus(ctx.meshId, ctx.task.id, 'pending');
+        try {
+            appendLedgerEntry(ctx.meshId, {
+                kind: 'dispatch_failed' as any,
+                nodeId: ctx.nodeId,
+                sessionId: ctx.sessionId,
+                payload: { taskId: ctx.task.id, deliveryId: delivery.id, error: e?.message, retryable: true, transport: ctx.transport },
+            });
+        } catch { /* ledger write is best-effort */ }
+    });
+}
+
 export function tryAssignQueueTask(
     components: DaemonComponents,
     meshId: string,
@@ -288,45 +427,36 @@ export function tryAssignQueueTask(
             // completion back to that exact session (multi-coordinator). Carried over P2P
             // to the remote worker, which echoes it on its completion event.
             const sourceCoordinatorSessionId = readNonEmptyString(task.sourceCoordinatorSessionId) || undefined;
-            const delivery = createSessionDelivery({
-                meshId,
-                nodeId,
-                sessionId,
-                providerType,
-                taskId: task.id,
-                kind: 'task',
-                message: task.message,
-                status: 'delivering',
-                ...(sourceCoordinatorSessionId ? { sourceCoordinatorSessionId } : {}),
-                ...(localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {}),
-            });
-            components.dispatchMeshCommand(node.daemonId, 'agent_command', {
-                targetSessionId: sessionId,
-                cliType: providerType,
-                action: 'send_chat',
-                message: task.message,
-                meshContext: {
+            const dispatchMeshCommand = components.dispatchMeshCommand;
+            const remoteDaemonId = node.daemonId;
+            // CONS3: only the transport call differs — everything else (delivery record,
+            // status transitions, requeue-on-failure, ledger, Bug B hang timeout) is in
+            // the shared deliverTaskToSession helper.
+            deliverTaskToSession(
+                () => dispatchMeshCommand(remoteDaemonId, 'agent_command', {
+                    targetSessionId: sessionId,
+                    cliType: providerType,
+                    action: 'send_chat',
+                    message: task.message,
+                    meshContext: {
+                        meshId,
+                        nodeId,
+                        taskId: task.id,
+                        ...(localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {}),
+                        ...(sourceCoordinatorSessionId ? { coordinatorSessionId: sourceCoordinatorSessionId } : {}),
+                    },
+                }),
+                {
                     meshId,
                     nodeId,
-                    taskId: task.id,
-                    ...(localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {}),
-                    ...(sourceCoordinatorSessionId ? { coordinatorSessionId: sourceCoordinatorSessionId } : {}),
+                    sessionId,
+                    providerType,
+                    task,
+                    transport: 'remote',
+                    ...(sourceCoordinatorSessionId ? { sourceCoordinatorSessionId } : {}),
+                    ...(localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {}),
                 },
-            }).then(() => {
-                updateSessionDeliveryStatus(delivery.id, 'delivered');
-            }).catch((e: any) => {
-                LOG.error('MeshQueue', `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-                updateSessionDeliveryStatus(delivery.id, 'failed', { lastError: e?.message, incrementAttempt: true });
-                updateTaskStatus(meshId, task.id, 'pending');
-                try {
-                    appendLedgerEntry(meshId, {
-                        kind: 'dispatch_failed' as any,
-                        nodeId,
-                        sessionId,
-                        payload: { taskId: task.id, deliveryId: delivery.id, error: e?.message, retryable: true },
-                    });
-                } catch { /* ledger write is best-effort */ }
-            });
+            );
             return true;
         }
     }
@@ -363,44 +493,26 @@ export function tryAssignQueueTask(
         }
     } catch { /* best-effort — dispatch still proceeds */ }
 
-    const delivery = createSessionDelivery({
-        meshId,
-        nodeId,
-        sessionId,
-        providerType,
-        taskId: task.id,
-        kind: 'task',
-        message: task.message,
-        status: 'delivering',
-        ...(readNonEmptyString(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) } : {}),
-        ...(readNonEmptyString(loadConfig().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString(loadConfig().machineId) } : {}),
-    });
-    components.cliManager.handleCliCommand('agent_command', {
-        targetSessionId: sessionId,
-        cliType: providerType,
-        action: 'send_chat',
-        message: task.message,
-    }).then(() => {
-        updateSessionDeliveryStatus(delivery.id, 'delivered');
-    }).catch((e: any) => {
-        // Mirror the remote-dispatch catch above: a local dispatch failure is most often a
-        // transient busy/refusal (e.g. the adapter rejected send_chat while mid-generation),
-        // not a permanent task failure. Marking the task terminal 'failed' here with no ledger
-        // and no retry permanently killed tasks that a later tick would have delivered fine.
-        // Return the task to 'pending' and record a retryable dispatch_failed ledger entry so
-        // the reconcile loop re-dispatches it, exactly as the remote branch does.
-        LOG.error('MeshQueue', `Failed to dispatch task locally to node ${nodeId}: ${e?.message}`);
-        updateSessionDeliveryStatus(delivery.id, 'failed', { lastError: e?.message, incrementAttempt: true });
-        updateTaskStatus(meshId, task.id, 'pending');
-        try {
-            appendLedgerEntry(meshId, {
-                kind: 'dispatch_failed' as any,
-                nodeId,
-                sessionId,
-                payload: { taskId: task.id, deliveryId: delivery.id, error: e?.message, retryable: true },
-            });
-        } catch { /* ledger write is best-effort */ }
-    });
+    // CONS3: same shared dispatch lifecycle as the remote branch — only the transport
+    // (cliManager.handleCliCommand) differs.
+    deliverTaskToSession(
+        () => components.cliManager.handleCliCommand('agent_command', {
+            targetSessionId: sessionId,
+            cliType: providerType,
+            action: 'send_chat',
+            message: task.message,
+        }),
+        {
+            meshId,
+            nodeId,
+            sessionId,
+            providerType,
+            task,
+            transport: 'local',
+            ...(readNonEmptyString(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) } : {}),
+            ...(readNonEmptyString(loadConfig().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString(loadConfig().machineId) } : {}),
+        },
+    );
 
     return true;
 }
@@ -880,7 +992,12 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
 
         const candidateNodes = Array.isArray(mesh?.nodes)
             ? mesh.nodes.filter((node: any) => {
-                if (task.targetNodeId && readMeshNodeId(node) !== task.targetNodeId) return false;
+                // Bug A: match the target pin with the shared 3-form (id / nodeId / node_id)
+                // normalizer, mirroring the remote-idle drain (meshNodeIdMatches at the
+                // getRemoteIdleSessions filter). A strict `readMeshNodeId(node) !== targetNodeId`
+                // dropped a target node whose identity arrived under a different form (a freshly
+                // mesh_clone_node'd worktree), emptying candidateNodes and mislabelling the skip.
+                if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
                 // Skip nodes that can never satisfy requiredTags regardless of which provider
                 // from providerPriority is selected. A node satisfies tags if at least one
                 // provider in its priority list would produce matching capability tags.
@@ -895,7 +1012,20 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
             })
             : [];
         if (!candidateNodes.length) {
-            markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'no_node_satisfies_required_tags', nodeId: task.targetNodeId });
+            // Bug A: distinguish the two ways the candidate set empties. A task pinned to a
+            // targetNodeId whose node is absent from the mesh (or whose id arrived under a
+            // different form) is a ROUTING miss — report it as `target_node_id_unmatched`, not
+            // the hard-coded `no_node_satisfies_required_tags`, which mislabelled a 3-form
+            // node-id mismatch as a capability failure and sent diagnosis down the wrong path.
+            // Only fall back to the tag reason when no target pin is in play, or the pin DID
+            // match a node but its tags excluded it (a genuine capability miss).
+            const targetPinUnmatched = !!task.targetNodeId
+                && !(Array.isArray(mesh?.nodes) && mesh.nodes.some((n: any) => meshNodeIdMatches(n, task.targetNodeId)));
+            markAutoLaunch(meshId, task.id, {
+                status: 'skipped',
+                reason: targetPinUnmatched ? 'target_node_id_unmatched' : 'no_node_satisfies_required_tags',
+                nodeId: task.targetNodeId,
+            });
             continue;
         }
 
@@ -1555,7 +1685,17 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         });
         if (terminal?.kind === 'task_completed' && !sessionHasActiveAssignment(args.meshId, eventSessionId)) {
             const newDispatchAfterTerminal = hasDispatchAfterTerminal(args.meshId, eventSessionId, terminal.id);
-            if (!newDispatchAfterTerminal) {
+            // Fix B (re-dispatch 2nd-completion routing): a prior terminal recorded from a FALSE
+            // idle (weak evidence / no confirmed final assistant) must NOT permanently suppress a
+            // later GENUINE completion of the same session. providerSessionId is stable across a
+            // session's turns, so the providerSessionId/finalSummary dedup below would otherwise
+            // swallow the real 2nd-turn completion that a coordinator nudge (direct re-dispatch)
+            // drove — exactly the missed-event bug. When the prior terminal was weak and the new
+            // event carries genuine completion evidence, let it through so it is recorded and
+            // re-attributed to the latest task (the normal task_completed path below).
+            const supersedesWeakTerminal = isWeakTerminalLedgerPayload(terminal.payload)
+                && isGenuineCompletionEvidence(args.metadataEvent);
+            if (!newDispatchAfterTerminal && !supersedesWeakTerminal) {
                 const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
                 const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
                 const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);
@@ -1606,7 +1746,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
     }
 
-    function markSessionTerminal(sessionId: string, outcome: 'completed' | 'failed', occurredAtMs?: number | null): { id?: string } | null {
+    function markSessionTerminal(sessionId: string, outcome: 'completed' | 'failed', occurredAtMs?: number | null, opts?: { tentativeIfDirect?: boolean }): { id?: string } | null {
         // C2: prefer an exact taskId match when the completion event carries one —
         // it's immune to coordinator↔worker clock skew that can hide the assigned row.
         const eventTaskId = readNonEmptyString(args.metadataEvent.taskId) || undefined;
@@ -1614,20 +1754,36 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : undefined,
             taskId: eventTaskId,
         });
-        updateDirectDispatchStatus(args.meshId, sessionId, outcome);
+        // Fix A (early-terminal prevention): a false-idle completion (no confirmed final
+        // assistant) for a DIRECT dispatch — i.e. no work-queue row matched — must not flip the
+        // dispatch row terminal. Leaving it active lets the reconcile loop (PHASE 4) re-read the
+        // transcript and record the genuine completion once the worker truly finishes (commonly
+        // after a coordinator nudge / re-dispatch). A matched queue task, or a completion with
+        // genuine evidence, is marked terminal as before.
+        const leaveDirectDispatchActive = !task && opts?.tentativeIfDirect === true;
+        if (!leaveDirectDispatchActive) {
+            updateDirectDispatchStatus(args.meshId, sessionId, outcome);
+        }
         markSessionDeliveriesTerminal(args.meshId, sessionId, outcome);
         setImmediate(() => cleanupTerminalDirectDispatches());
         return task ? { id: task.id } : null;
     }
 
     let completedTaskForLedger: { id?: string } | null = null;
+    // Fix B: direct-dispatch taskId used to attribute the terminal ledger entry when no
+    // work-queue row matches (resolved BEFORE markSessionTerminal flips the dispatch terminal).
+    let directDispatchTaskIdForLedger: string | undefined;
     if (args.event === 'agent:generating_completed') {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
 
         if (sessionId) {
-            completedTaskForLedger = markSessionTerminal(sessionId, 'completed', eventTimestamp);
+            directDispatchTaskIdForLedger = resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
+            // A false-idle completion of a direct dispatch is recorded but kept tentative (the
+            // dispatch row stays active for the reconcile fallback); a genuine completion is terminal.
+            const isFalseIdle = isFalseIdleCompletion(args.metadataEvent);
+            completedTaskForLedger = markSessionTerminal(sessionId, 'completed', eventTimestamp, { tentativeIfDirect: isFalseIdle });
             if (nodeId && providerType) {
                 runIdleMaintenanceThenAssignQueue(components, { meshId: args.meshId, nodeId, sessionId, providerType });
             }
@@ -1729,6 +1885,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             } catch { /* best-effort */ }
         }
         if (sessionId) {
+            directDispatchTaskIdForLedger = resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
             completedTaskForLedger = markSessionTerminal(sessionId, 'failed');
         }
     }
@@ -1761,7 +1918,10 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 payload: {
                     event: args.event,
                     nodeLabel: args.nodeLabel,
-                    taskId: completedTaskForLedger?.id || undefined,
+                    // Fix B: fall back to the direct-dispatch taskId when no work-queue row
+                    // matched, so the terminal entry is attributable in mesh task-stats
+                    // (otherwise the direct task shows status='unknown' / terminalKind=null).
+                    taskId: completedTaskForLedger?.id || directDispatchTaskIdForLedger || undefined,
                     providerSessionId,
                     finalSummary,
                     workerResult,

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

@@ -5,6 +5,7 @@ import { LOG } from '../logging/logger.js';
 import { getLedgerDir, readLedgerEntries, appendLedgerEntry } from './mesh-ledger.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { buildMeshSystemMessage, readNonEmptyString, readRecord, resolveEventSessionId, readMeshCompletionSummary } from './mesh-events-utils.js';
+import { expandDaemonIdForms } from '@adhdev/mesh-shared';
 
 // ---------------------------------------------------------------------------
 // MCP coordinator pending-event queue — FILE-BASED PERSISTENCE
@@ -48,24 +49,22 @@ export interface PendingMeshCoordinatorEvent {
 const REFINE_TERMINAL_EVENTS = new Set(['refine:completed', 'refine:failed']);
 
 /** Normalise a coordinator-daemon-id argument (single id, list, or undefined) into a
- *  de-duplicated list of non-empty strings. The first entry is treated as primary for
- *  per-daemon JSONL file naming; all entries are accepted by drain/peek targeting. */
+ *  de-duplicated list of non-empty strings, EXPANDED to every equivalent daemon-id
+ *  form (bare `mach_X` ≡ `daemon_mach_X` ≡ `standalone_mach_X`).
+ *
+ *  A coordinator resolves its own id through one path (status instanceId, the config-
+ *  form node daemonId, or the bare machineId) but a worker stamps a completion's
+ *  `coordinator_daemon_id` through another, so the two are routinely in DIFFERENT
+ *  forms of the SAME machine. The scope filter is an exact-string match, so without
+ *  expansion a `daemon_mach_X`-scoped completion is silently skipped by a coordinator
+ *  that only knows itself as bare `mach_X` (the base-node completion-surface bug).
+ *  Expanding here fixes every drain/peek/surface caller uniformly. The first ORIGINAL
+ *  id stays at [0] so per-daemon JSONL file naming keeps its primary; expansion stays
+ *  within one machine core so a different coordinator's events are never claimed. */
 function normalizeCoordinatorDaemonIds(
     coordinatorDaemonId?: string | null | ReadonlyArray<string>,
 ): string[] {
-    const raw = Array.isArray(coordinatorDaemonId)
-        ? coordinatorDaemonId
-        : coordinatorDaemonId != null ? [coordinatorDaemonId] : [];
-    const seen = new Set<string>();
-    const out: string[] = [];
-    for (const id of raw) {
-        if (typeof id !== 'string') continue;
-        const trimmed = id.trim();
-        if (!trimmed || seen.has(trimmed)) continue;
-        seen.add(trimmed);
-        out.push(trimmed);
-    }
-    return out;
+    return expandDaemonIdForms(coordinatorDaemonId);
 }
 
 export function readRefineJobId(event: { metadataEvent?: Record<string, unknown> } | Record<string, unknown>): string {
@@ -303,6 +302,7 @@ export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEv
         const fingerprint = buildPendingEventFingerprint(event);
 
         // G3: Write to SQLite inbox (primary path going forward)
+        let sqliteOk = false;
         try {
             MeshRuntimeStore.getInstance().insertPendingEvent({
                 id: randomUUID(),
@@ -313,14 +313,22 @@ export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEv
                 fingerprint: fingerprint || null,
                 queuedAt: event.queuedAt,
             });
+            sqliteOk = true;
         } catch {
             // SQLite write failure is non-fatal; JSONL fallback below still works.
         }
 
-        // Also write to JSONL (retained as legacy/export artifact)
-        const path = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
-        trimPendingEventsIfNeeded(path);
-        appendFileSync(path, JSON.stringify(event) + '\n', 'utf-8');
+        // Also write to JSONL (retained as legacy/export artifact). Best-effort once
+        // SQLite (the primary store) has the event: a JSONL append failure (disk full,
+        // permissions) must NOT report the whole persist as failed when SQLite holds it.
+        try {
+            const path = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
+            trimPendingEventsIfNeeded(path);
+            appendFileSync(path, JSON.stringify(event) + '\n', 'utf-8');
+        } catch (e: any) {
+            if (!sqliteOk) throw e; // neither store has it — surface as a real failure
+            LOG.warn('MeshEvents', `JSONL append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
+        }
         return true;
     } catch (e: any) {
         LOG.warn('MeshEvents', `Failed to persist pending coordinator event: ${e?.message || e}`);

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

@@ -74,6 +74,17 @@ export function hasUnterminalDirectDispatchLedgerEntry(meshId: string, sessionId
     return false;
 }
 
+// True when a terminal ledger payload was recorded from WEAK completion evidence (a false
+// idle): insufficient evidence level, review-recommended, or a missing-final-assistant
+// completion diagnostic. Mirrors isWeakTerminalLedgerPayload in mesh-events-coordinator —
+// a weak terminal is non-authoritative and may be superseded by a genuine completion.
+function isWeakCompletionLedgerPayload(payload: Record<string, unknown> | undefined): boolean {
+    if (!payload) return false;
+    if (payload.evidenceLevel === 'insufficient' || payload.reviewRecommended === true) return true;
+    const diag = readRecord(payload.completionDiagnostic);
+    return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
+}
+
 function findDirectDispatchLedgerEntry(args: {
     meshId: string;
     taskId: string;
@@ -121,6 +132,12 @@ function hasTerminalLedgerAfterDispatch(args: {
             if (!afterDispatch) continue;
         }
         if (entry.kind !== 'task_completed' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') continue;
+        // Fix C (reconcile fallback expansion): a task_completed recorded from a FALSE idle
+        // (weak evidence / no confirmed final assistant) is NOT authoritative terminal
+        // evidence. Skip it so the transcript reconcile can still synthesize the GENUINE
+        // completion for a re-dispatched / prematurely-terminated direct task instead of
+        // bailing with alreadyTerminal.
+        if (entry.kind === 'task_completed' && isWeakCompletionLedgerPayload(entry.payload)) continue;
         const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
         if (terminalTaskId && terminalTaskId === args.taskId) return true;
         if (terminalTaskId && terminalTaskId !== args.taskId) continue;

package/src/mesh/mesh-ledger.ts

@@ -43,6 +43,7 @@ export type MeshLedgerKind =
     | 'delivery_unroutable'
     | 'direct_dispatch_pruned'
     | 'event_held'
+    | 'task_reclaimed'
     ;
 
 export interface MeshLedgerEntry {