@adhdev/daemon-core 0.9.82-rc.9 → 0.9.82-rc.90

package/src/mesh/mesh-events.ts

@@ -1,63 +1,179 @@
+import { appendFileSync, existsSync, readFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import { loadConfig } from '../config/config.js';
 import { getMesh, getMeshByRepo } from '../config/mesh-config.js';
 import { detectCLI } from '../detection/cli-detector.js';
 import { LOG } from '../logging/logger.js';
-import { appendLedgerEntry, buildTaskCompletionEvidence, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
+import { appendLedgerEntry, buildTaskCompletionEvidence, getLedgerDir, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerKind, SessionRecoveryContext } from './mesh-ledger.js';
 import { claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus, getQueue, recordTaskAutoLaunch } from './mesh-work-queue.js';
 
 // ---------------------------------------------------------------------------
 // Remote Node Idle Session Tracking
 // ---------------------------------------------------------------------------
-// Tracks remote sessions that emitted 'agent:ready' so triggerMeshQueue 
-// can assign tasks to them.
+// Tracks remote sessions that emitted 'agent:ready' so triggerMeshQueue
+// can assign tasks to them. Each entry carries an expiresAt timestamp;
+// entries are swept on insertion to prevent unbounded growth.
 // ---------------------------------------------------------------------------
 interface RemoteIdleSession {
     nodeId: string;
     sessionId: string;
     providerType: string;
+    expiresAt: number;
 }
+const REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
 const remoteIdleSessions = new Map<string, RemoteIdleSession>(); // key: `${nodeId}:${sessionId}`
 
+function readWorkerResultMetadata(event: Record<string, unknown>): Record<string, unknown> | undefined {
+    return readRecord(event.workerResult) || readRecord(event.meshWorkerResult) || readRecord(event.structuredResult);
+}
+
+function sweepExpiredRemoteIdleSessions(): void {
+    const now = Date.now();
+    for (const [key, session] of remoteIdleSessions) {
+        if (session.expiresAt <= now) remoteIdleSessions.delete(key);
+    }
+}
+
 // ---------------------------------------------------------------------------
-// MCP coordinator pending-event queue
+// MCP coordinator pending-event queue — FILE-BASED PERSISTENCE
 // ---------------------------------------------------------------------------
 // When a mesh event fires but no CLI coordinator session is registered (e.g.
-// the coordinator is Claude Code running via MCP), we buffer the event here.
-// The MCP server drains this queue on every mesh_status / mesh_send_task poll.
+// the coordinator is Claude Code running via MCP), we persist the event to a
+// per-mesh JSONL file so it survives daemon restarts. The 50-entry hard cap
+// is removed; the file is drained atomically on each get_pending_mesh_events
+// call and limited to 100 KB to prevent runaway growth.
+//
+// File: <ledgerDir>/<meshId>.pending-events.jsonl
 // ---------------------------------------------------------------------------
 
 export interface PendingMeshCoordinatorEvent {
     event: string;
     meshId: string;
     nodeLabel: string;
+    nodeId?: string;
+    workspace?: string;
     metadataEvent: Record<string, unknown>;
+    coordinatorMessage?: string;
     queuedAt: number;
 }
 
-const MAX_PENDING_EVENTS = 50;
-const pendingMeshCoordinatorEvents: PendingMeshCoordinatorEvent[] = [];
+const REFINE_TERMINAL_EVENTS = new Set(['refine:completed', 'refine:failed']);
+
+function readRefineJobId(event: { metadataEvent?: Record<string, unknown> } | Record<string, unknown>): string {
+    const metadata = readRecord((event as any).metadataEvent) || event as Record<string, unknown>;
+    const result = readRecord(metadata.result);
+    const refineJob = readRecord(result?.refineJob);
+    return readNonEmptyString(metadata.jobId) || readNonEmptyString(refineJob?.jobId);
+}
+
+function buildRefineTerminalEventFingerprint(meshId: string, eventName: string, metadataEvent: Record<string, unknown>): string {
+    const jobId = readRefineJobId({ metadataEvent });
+    return jobId && REFINE_TERMINAL_EVENTS.has(eventName) ? `${meshId}::${eventName}::${jobId}` : '';
+}
+
+function hasPendingRefineTerminalEventDuplicate(event: PendingMeshCoordinatorEvent): boolean {
+    if (!REFINE_TERMINAL_EVENTS.has(event.event)) return false;
+    const jobId = readRefineJobId(event);
+    if (!jobId) return false;
+    return getPendingMeshCoordinatorEvents(event.meshId).some((pending) =>
+        pending.event === event.event && readRefineJobId(pending) === jobId,
+    );
+}
+
+function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent): string {
+    const metadata = readRecord(event.metadataEvent) || {};
+    const sessionId = resolveEventSessionId(metadata);
+    const providerSessionId = readNonEmptyString(metadata.providerSessionId);
+    const taskId = readNonEmptyString(metadata.taskId) || readNonEmptyString(readRecord(metadata.payload)?.taskId);
+    const jobId = readRefineJobId(event);
+    const timestamp = metadata.timestamp !== undefined && metadata.timestamp !== null ? String(metadata.timestamp) : '';
+    return [
+        event.meshId,
+        event.event,
+        event.nodeId || '',
+        sessionId || '',
+        providerSessionId || '',
+        taskId || '',
+        jobId || '',
+        timestamp || '',
+    ].join('::');
+}
+
+function hasPendingCoordinatorEventDuplicate(event: PendingMeshCoordinatorEvent): boolean {
+    const fingerprint = buildPendingEventFingerprint(event);
+    if (!fingerprint.trim()) return false;
+    return getPendingMeshCoordinatorEvents(event.meshId).some((pending) => buildPendingEventFingerprint(pending) === fingerprint);
+}
+
+function getPendingEventsPath(meshId: string): string {
+    const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return join(getLedgerDir(), `${safe}.pending-events.jsonl`);
+}
+
+export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean {
+    try {
+        if (hasPendingRefineTerminalEventDuplicate(event)) {
+            LOG.info('MeshEvents', `Suppressed duplicate pending ${event.event} for refine job ${readRefineJobId(event)}`);
+            return true;
+        }
+        if (hasPendingCoordinatorEventDuplicate(event)) {
+            LOG.info('MeshEvents', `Suppressed duplicate pending ${event.event} for mesh ${event.meshId}`);
+            return true;
+        }
+        appendFileSync(getPendingEventsPath(event.meshId), JSON.stringify(event) + '\n', 'utf-8');
+        return true;
+    } catch (e: any) {
+        LOG.warn('MeshEvents', `Failed to persist pending coordinator event: ${e?.message || e}`);
+        return false;
+    }
+}
 
-/** Drain and return all pending coordinator events, clearing the queue. */
-export function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[] {
-    return pendingMeshCoordinatorEvents.splice(0);
+/** Drain and return all pending coordinator events for meshId, removing them from disk. */
+export function drainPendingMeshCoordinatorEvents(meshId?: string): PendingMeshCoordinatorEvent[] {
+    if (!meshId) return [];
+    const path = getPendingEventsPath(meshId);
+    if (!existsSync(path)) return [];
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        try { unlinkSync(path); } catch { /* concurrent drain already removed it */ }
+        return raw.split('\n').filter(Boolean).flatMap(line => {
+            try { return [JSON.parse(line) as PendingMeshCoordinatorEvent]; } catch { return []; }
+        });
+    } catch { return []; }
 }
 
 /** Peek at pending coordinator events without draining (non-destructive). */
-export function getPendingMeshCoordinatorEvents(): readonly PendingMeshCoordinatorEvent[] {
-    return pendingMeshCoordinatorEvents.slice();
+export function getPendingMeshCoordinatorEvents(meshId?: string): readonly PendingMeshCoordinatorEvent[] {
+    if (!meshId) return [];
+    const path = getPendingEventsPath(meshId);
+    if (!existsSync(path)) return [];
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        return raw.split('\n').filter(Boolean).flatMap(line => {
+            try { return [JSON.parse(line) as PendingMeshCoordinatorEvent]; } catch { return []; }
+        });
+    } catch { return []; }
 }
 
-/** Explicitly clear all pending coordinator events. */
-export function clearPendingMeshCoordinatorEvents(): void {
-    pendingMeshCoordinatorEvents.splice(0);
+/** Explicitly clear all pending coordinator events for a mesh. */
+export function clearPendingMeshCoordinatorEvents(meshId?: string): void {
+    if (!meshId) return;
+    const path = getPendingEventsPath(meshId);
+    if (existsSync(path)) try { unlinkSync(path); } catch { /* already removed */ }
 }
 
 function readNonEmptyString(value: unknown): string {
     return typeof value === 'string' && value.trim() ? value.trim() : '';
 }
 
+function readRecord(value: unknown): Record<string, unknown> | undefined {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value as Record<string, unknown>
+        : undefined;
+}
+
 function resolveEventSessionId(event: Record<string, unknown>, fallback?: unknown): string {
     return readNonEmptyString(event.targetSessionId)
         || readNonEmptyString(event.sessionId)
@@ -72,6 +188,9 @@ const MESH_COORDINATOR_EVENTS = new Set([
     'agent:stopped',
     'agent:ready',
     'monitor:long_generating',
+    'refine:accepted',
+    'refine:completed',
+    'refine:failed',
 ]);
 
 const EVENT_TO_LEDGER_KIND: Record<string, MeshLedgerKind> = {
@@ -86,10 +205,21 @@ function isMeshCoordinatorEvent(eventName: unknown): eventName is string {
 }
 
 function formatCompletionMetadata(event: Record<string, unknown>): string {
+    const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === 'object'
+        ? event.completionDiagnostic as Record<string, unknown>
+        : null;
+    const diagnosticReason = completionDiagnostic
+        ? readNonEmptyString(completionDiagnostic.blockReason) || 'present'
+        : '';
+    const finalAssistantPresent = typeof completionDiagnostic?.finalAssistantPresent === 'boolean'
+        ? String(completionDiagnostic.finalAssistantPresent)
+        : '';
     const parts = [
         readNonEmptyString(event.targetSessionId) ? `session_id=${readNonEmptyString(event.targetSessionId)}` : '',
         readNonEmptyString(event.providerType) ? `provider=${readNonEmptyString(event.providerType)}` : '',
         readNonEmptyString(event.providerSessionId) ? `provider_session_id=${readNonEmptyString(event.providerSessionId)}` : '',
+        diagnosticReason ? `completion_diagnostic=${diagnosticReason}` : '',
+        finalAssistantPresent ? `final_assistant=${finalAssistantPresent}` : '',
     ].filter(Boolean);
     return parts.length > 0 ? ` (${parts.join('; ')})` : '';
 }
@@ -140,6 +270,74 @@ function shouldSuppressIntentionalCleanupStop(args: {
     return hasRecentIntentionalCleanupStop(args.meshId, args.sessionId, args.nodeId);
 }
 
+const RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1000;
+const recentCompletionFingerprints = new Map<string, number>();
+
+function readEventTimestamp(value: unknown): number | null {
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    if (typeof value === 'string' && value.trim()) {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) return numeric;
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed)) return parsed;
+    }
+    return null;
+}
+
+function buildMeshCompletionFingerprint(args: {
+    meshId: string;
+    event: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    timestamp?: number | null;
+    finalSummary?: string;
+}): string {
+    const timestampPart = Number.isFinite(args.timestamp)
+        ? String(args.timestamp)
+        : readNonEmptyString(args.finalSummary).slice(0, 200);
+    return [
+        args.meshId,
+        args.event,
+        args.sessionId,
+        args.providerType || '',
+        args.providerSessionId || '',
+        timestampPart,
+    ].join('::');
+}
+
+function isDuplicateMeshCompletionEvent(args: {
+    meshId: string;
+    event: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    timestamp?: number | null;
+    finalSummary?: string;
+}): boolean {
+    const fingerprint = buildMeshCompletionFingerprint(args);
+    if (!fingerprint) return false;
+    const now = Date.now();
+    for (const [key, seenAt] of recentCompletionFingerprints.entries()) {
+        if (now - seenAt > RECENT_COMPLETION_FINGERPRINT_TTL_MS) recentCompletionFingerprints.delete(key);
+    }
+    if (recentCompletionFingerprints.has(fingerprint)) return true;
+    recentCompletionFingerprints.set(fingerprint, now);
+    return false;
+}
+
+function isDuplicateRefineTerminalEvent(meshId: string, eventName: string, metadataEvent: Record<string, unknown>): boolean {
+    const fingerprint = buildRefineTerminalEventFingerprint(meshId, eventName, metadataEvent);
+    if (!fingerprint) return false;
+    const now = Date.now();
+    for (const [key, seenAt] of recentCompletionFingerprints.entries()) {
+        if (now - seenAt > RECENT_COMPLETION_FINGERPRINT_TTL_MS) recentCompletionFingerprints.delete(key);
+    }
+    if (recentCompletionFingerprints.has(fingerprint)) return true;
+    recentCompletionFingerprints.set(fingerprint, now);
+    return false;
+}
+
 
 export function tryAssignQueueTask(
     components: DaemonComponents,
@@ -170,7 +368,16 @@ export function tryAssignQueueTask(
                 message: task.message,
             }).catch((e: any) => {
                 LOG.error('MeshQueue', `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-                updateTaskStatus(meshId, task.id, 'failed');
+                // Revert to pending so the task can be retried rather than permanently failing
+                updateTaskStatus(meshId, task.id, 'pending');
+                try {
+                    appendLedgerEntry(meshId, {
+                        kind: 'dispatch_failed' as any,
+                        nodeId,
+                        sessionId,
+                        payload: { taskId: task.id, error: e?.message, retryable: true },
+                    });
+                } catch { /* ledger write is best-effort */ }
             });
             return true;
         }
@@ -565,6 +772,71 @@ function buildMeshSystemMessage(args: {
     if (args.event === 'monitor:long_generating') {
         return `[System] ${args.nodeLabel} has been generating for a long time${metadata}. Use mesh_read_chat once for a status check, but do not poll repeatedly.`;
     }
+    if (args.event === 'refine:accepted') {
+        const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
+        return `[System] Refinery accepted async job${jobId ? ` ${jobId}` : ''} for ${args.nodeLabel}. Completion/failure will be delivered as a terminal refine event; do not poll repeatedly.`;
+    }
+    if (args.event === 'refine:completed') {
+        const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
+        const result = readRecord(args.metadataEvent.result);
+        const validationSummary = readRecord(result?.validationSummary);
+        const patchEquivalence = readRecord(result?.patchEquivalence);
+        const finalConvergence = readRecord(result?.finalBranchConvergenceState);
+        const validationStatus = readNonEmptyString(validationSummary?.status);
+        const patchStatus = readNonEmptyString(patchEquivalence?.status)
+            || (patchEquivalence?.equivalent === true ? 'passed' : '');
+        const into = readNonEmptyString(result?.into);
+        const branch = readNonEmptyString(result?.branch);
+        const mergeStatus = result?.merged === true ? 'merged' : readNonEmptyString(finalConvergence?.status);
+        const convergenceStatus = readNonEmptyString(finalConvergence?.status);
+        const nextStep = readNonEmptyString(result?.nextStep)
+            || readNonEmptyString(finalConvergence?.nextStep)
+            || 'Continue from the updated mesh state.';
+        const details = [
+            jobId ? `job_id=${jobId}` : '',
+            branch && into ? `${branch}→${into}` : '',
+            validationStatus ? `validation=${validationStatus}` : '',
+            patchStatus ? `patch_equivalence=${patchStatus}` : '',
+            mergeStatus ? `merge=${mergeStatus}` : '',
+            convergenceStatus ? `final_convergence=${convergenceStatus}` : '',
+        ].filter(Boolean).join('; ');
+        return `[System] Refinery async job for ${args.nodeLabel} completed successfully${details ? ` (${details})` : ''}.\nNext step: ${nextStep}`;
+    }
+    if (args.event === 'refine:failed') {
+        const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
+        const result = readRecord(args.metadataEvent.result);
+        const validationSummary = readRecord(result?.validationSummary);
+        const patchEquivalence = readRecord(result?.patchEquivalence);
+        const finalConvergence = readRecord(result?.finalBranchConvergenceState);
+        const code = readNonEmptyString(result?.code);
+        const error = readNonEmptyString(result?.error);
+        const validationStatus = readNonEmptyString(validationSummary?.status);
+        const patchStatus = readNonEmptyString(patchEquivalence?.status)
+            || (patchEquivalence?.equivalent === true ? 'passed' : '');
+        const mergeStatus = result?.merged === true
+            ? 'merged'
+            : finalConvergence?.merged === false
+                ? 'not_merged'
+                : '';
+        const convergenceStatus = readNonEmptyString(result?.convergenceStatus)
+            || readNonEmptyString(finalConvergence?.status);
+        const blockedReason = readNonEmptyString(result?.blockedReason);
+        const nextStep = readNonEmptyString(result?.nextStep) || readNonEmptyString(finalConvergence?.nextStep);
+        const details = [
+            jobId ? `job_id=${jobId}` : '',
+            code ? `code=${code}` : '',
+            validationStatus ? `validation=${validationStatus}` : '',
+            patchStatus ? `patch_equivalence=${patchStatus}` : '',
+            mergeStatus ? `merge=${mergeStatus}` : '',
+            convergenceStatus ? `convergence=${convergenceStatus}` : '',
+            blockedReason ? `reason=${blockedReason}` : '',
+        ].filter(Boolean).join('; ');
+        const parts = [
+            `[System] Refinery async job for ${args.nodeLabel} failed${details ? ` (${details})` : ''}${error ? `: ${error}` : '.'}`,
+            nextStep ? `Next step: ${nextStep}` : 'Review the terminal refine event/ledger before retrying.',
+        ];
+        return parts.join('\n');
+    }
     return '';
 }
 
@@ -593,6 +865,28 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
     }
 
+    if (isDuplicateRefineTerminalEvent(args.meshId, args.event, args.metadataEvent)) {
+        LOG.info('MeshEvents', `Suppressed duplicate ${args.event} for refine job ${readRefineJobId({ metadataEvent: args.metadataEvent })}`);
+        return { success: true, forwarded: 0, suppressed: true, duplicateRefineTerminalEvent: true };
+    }
+
+    const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
+    if (args.event === 'agent:generating_completed' && eventSessionId) {
+        const duplicateCompletion = isDuplicateMeshCompletionEvent({
+            meshId: args.meshId,
+            event: args.event,
+            sessionId: eventSessionId,
+            providerType: readNonEmptyString(args.metadataEvent.providerType) || undefined,
+            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
+            timestamp: eventTimestamp,
+            finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+        });
+        if (duplicateCompletion) {
+            LOG.info('MeshEvents', `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
+            return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true };
+        }
+    }
+
     // ── Task Queue & Ledger ──
     let completedTaskForLedger: { id?: string } | null = null;
     if (args.event === 'agent:generating_completed') {
@@ -601,20 +895,27 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
         
         if (sessionId) {
-            const completedTask = updateSessionTaskStatus(args.meshId, sessionId, 'completed');
+            const completedTask = updateSessionTaskStatus(args.meshId, sessionId, 'completed', {
+                occurredAt: eventTimestamp !== null ? new Date(eventTimestamp).toISOString() : undefined,
+            });
             completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
             if (nodeId && providerType) {
-                // Short delay to allow completion event to propagate before pulling next
-                setTimeout(() => {
+                // Queue state is already updated above; setImmediate avoids the
+                // 500 ms artificial delay while still deferring past this call frame.
+                setImmediate(() => {
                     tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-                }, 500);
+                });
             }
         }
     } else if (args.event === 'agent:ready') {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
-        const completedTask = sessionId
+        const providerSessionId = readNonEmptyString(args.metadataEvent.providerSessionId) || undefined;
+        const finalSummary = readNonEmptyString(args.metadataEvent.finalSummary) || undefined;
+        const workerResult = readWorkerResultMetadata(args.metadataEvent);
+        const hasCompletionEvidence = !!finalSummary || !!workerResult;
+        const completedTask = sessionId && hasCompletionEvidence
             ? updateSessionTaskStatus(args.meshId, sessionId, 'completed')
             : null;
         if (completedTask) {
@@ -630,15 +931,17 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                         nodeLabel: args.nodeLabel,
                         taskId: completedTask.id,
                         completedViaReady: true,
-                        providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
-                        finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                        providerSessionId,
+                        finalSummary,
+                        workerResult,
                         evidence: buildTaskCompletionEvidence({
                             event: 'agent:ready',
                             nodeId,
                             sessionId,
                             providerType: providerType || undefined,
-                            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
-                            finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                            providerSessionId,
+                            finalSummary,
+                            workerResult,
                         }),
                     },
                 });
@@ -648,13 +951,15 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
         
         if (sessionId && nodeId && providerType) {
-            remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
-            setTimeout(() => {
+            sweepExpiredRemoteIdleSessions();
+            remoteIdleSessions.set(`${nodeId}:${sessionId}`, {
+                nodeId, sessionId, providerType,
+                expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS,
+            });
+            setImmediate(() => {
                 const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-                if (assigned) {
-                    remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
-                }
-            }, 500);
+                if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+            });
         }
     } else if (args.event === 'agent:generating_started') {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
@@ -669,7 +974,8 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
         }
         if (sessionId) {
-            updateSessionTaskStatus(args.meshId, sessionId, 'failed');
+            const failedTask = updateSessionTaskStatus(args.meshId, sessionId, 'failed');
+            completedTaskForLedger = failedTask ? { id: failedTask.id } : null;
         }
     }
 
@@ -679,14 +985,18 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             const ledgerNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined;
             const ledgerSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || undefined;
             const ledgerProviderType = readNonEmptyString(args.metadataEvent.providerType) || undefined;
+            const providerSessionId = readNonEmptyString(args.metadataEvent.providerSessionId) || undefined;
+            const finalSummary = readNonEmptyString(args.metadataEvent.finalSummary) || undefined;
+            const workerResult = readWorkerResultMetadata(args.metadataEvent);
             const completionEvidence = ledgerKind === 'task_completed' && ledgerNodeId && ledgerSessionId
                 ? buildTaskCompletionEvidence({
                     event: 'agent:generating_completed',
                     nodeId: ledgerNodeId,
                     sessionId: ledgerSessionId,
                     providerType: ledgerProviderType,
-                    providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
-                    finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                    providerSessionId,
+                    finalSummary,
+                    workerResult,
                 })
                 : undefined;
             appendLedgerEntry(args.meshId, {
@@ -698,8 +1008,12 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                     event: args.event,
                     nodeLabel: args.nodeLabel,
                     taskId: completedTaskForLedger?.id || undefined,
-                    providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
-                    finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                    providerSessionId,
+                    finalSummary,
+                    workerResult,
+                    completionDiagnostic: args.metadataEvent.completionDiagnostic && typeof args.metadataEvent.completionDiagnostic === 'object'
+                        ? args.metadataEvent.completionDiagnostic
+                        : undefined,
                     evidence: completionEvidence,
                 },
             });
@@ -772,6 +1086,14 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
     }
 
+    const messageText = buildMeshSystemMessage({
+        event: args.event,
+        nodeLabel: args.nodeLabel,
+        metadataEvent: args.metadataEvent,
+        recoveryContext,
+    });
+    if (!messageText) return { success: false, error: 'unsupported mesh event' };
+
     const coordinatorInstances = components.instanceManager.getByCategory('cli').filter((inst) => {
         const instState = inst.getState();
         if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
@@ -779,31 +1101,53 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         return true;
     });
 
+    // Refine terminal events (refine:completed, refine:failed) are coordinator-delivered
+    // synchronously; only buffer them for MCP when no CLI coordinator is present.
+    // Agent runtime events (agent:*) use dual delivery so both CLI and MCP coordinators
+    // receive them regardless of whether a live CLI coordinator session is active.
+    const isRefineTerminalEvent = REFINE_TERMINAL_EVENTS.has(args.event);
+
     if (coordinatorInstances.length === 0) {
         // No CLI coordinator session found — buffer for MCP-based coordinators.
-        if (pendingMeshCoordinatorEvents.length < MAX_PENDING_EVENTS) {
-            pendingMeshCoordinatorEvents.push({
+        if (queuePendingMeshCoordinatorEvent({
                 event: args.event,
                 meshId: args.meshId,
                 nodeLabel: args.nodeLabel,
+                nodeId: args.nodeId || undefined,
+                workspace: readNonEmptyString(args.metadataEvent.workspace),
                 metadataEvent: {
                     ...args.metadataEvent,
                     ...(recoveryContext ? { recoveryContext } : {}),
                 },
+                coordinatorMessage: messageText,
                 queuedAt: Date.now(),
-            });
+            })) {
             LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
         }
         return { success: true, forwarded: 0 };
     }
 
-    const messageText = buildMeshSystemMessage({
-        event: args.event,
-        nodeLabel: args.nodeLabel,
-        metadataEvent: args.metadataEvent,
-        recoveryContext,
-    });
-    if (!messageText) return { success: false, error: 'unsupported mesh event' };
+    // CLI coordinator is present. For non-refine events, also buffer for MCP coordinators
+    // 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) {
+        if (queuePendingMeshCoordinatorEvent({
+                event: args.event,
+                meshId: args.meshId,
+                nodeLabel: args.nodeLabel,
+                nodeId: args.nodeId || undefined,
+                workspace: readNonEmptyString(args.metadataEvent.workspace),
+                metadataEvent: {
+                    ...args.metadataEvent,
+                    ...(recoveryContext ? { recoveryContext } : {}),
+                },
+                coordinatorMessage: messageText,
+                queuedAt: Date.now(),
+            })) {
+            LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
+        }
+    }
 
     for (const coord of coordinatorInstances) {
         const coordState = coord.getState();
@@ -834,6 +1178,15 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
             providerType: readNonEmptyString(payload.providerType),
             providerSessionId: readNonEmptyString(payload.providerSessionId),
             finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+            jobId: readNonEmptyString(payload.jobId),
+            interactionId: readNonEmptyString(payload.interactionId),
+            status: readNonEmptyString(payload.status),
+            targetDaemonId: readNonEmptyString(payload.targetDaemonId),
+            startedAt: readNonEmptyString(payload.startedAt),
+            completedAt: readNonEmptyString(payload.completedAt),
+            retryOfJobId: readNonEmptyString(payload.retryOfJobId),
+            ...(payload.result && typeof payload.result === 'object' && !Array.isArray(payload.result) ? { result: payload.result } : {}),
+            ...(payload.timestamp !== undefined ? { timestamp: payload.timestamp } : {}),
             intentional: payload.intentional === true,
             intentionalStop: payload.intentionalStop === true,
             operatorCleanup: payload.operatorCleanup === true,