@adhdev/daemon-core 0.9.82-rc.136 → 0.9.82-rc.138

package/src/mesh/mesh-events.ts

@@ -1,4 +1,4 @@
-import { appendFileSync, existsSync, readFileSync, unlinkSync } from 'fs';
+import { appendFileSync, existsSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import { loadConfig } from '../config/config.js';
@@ -7,7 +7,8 @@ import { detectCLI } from '../detection/cli-detector.js';
 import { LOG } from '../logging/logger.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';
+import { claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus, getQueue, recordTaskAutoLaunch, updateDirectDispatchStatus, cleanupTerminalDirectDispatches } from './mesh-work-queue.js';
+import { BeadsDB } from './beads-db.js';
 
 // ---------------------------------------------------------------------------
 // Remote Node Idle Session Tracking
@@ -25,6 +26,23 @@ interface RemoteIdleSession {
 const REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
 const remoteIdleSessions = new Map<string, RemoteIdleSession>(); // key: `${nodeId}:${sessionId}`
 
+// ---------------------------------------------------------------------------
+// Workspace-to-mesh lookup cache
+// ---------------------------------------------------------------------------
+// getMeshByRepo is called on every coordinator event for sessions without
+// meshNodeFor. Cache results for 5 seconds to avoid repeated config reads.
+const meshByWorkspaceCache = new Map<string, { mesh: any; cachedAt: number }>();
+const MESH_WORKSPACE_CACHE_TTL_MS = 5_000;
+
+function getCachedMeshByWorkspace(workspace: string): any {
+    const now = Date.now();
+    const cached = meshByWorkspaceCache.get(workspace);
+    if (cached && now - cached.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached.mesh;
+    const mesh = getMeshByRepo(workspace);
+    meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
+    return mesh;
+}
+
 function readWorkerResultMetadata(event: Record<string, unknown>): Record<string, unknown> | undefined {
     return readRecord(event.workerResult) || readRecord(event.meshWorkerResult) || readRecord(event.structuredResult);
 }
@@ -57,6 +75,12 @@ export interface PendingMeshCoordinatorEvent {
     metadataEvent: Record<string, unknown>;
     coordinatorMessage?: string;
     queuedAt: number;
+    /**
+     * When set, this event is intended for a specific coordinator daemon.
+     * Coordinators on other daemons should ignore it during drain.
+     * Absent on legacy events — treated as broadcast to any coordinator.
+     */
+    targetCoordinatorDaemonId?: string;
 }
 
 const REFINE_TERMINAL_EVENTS = new Set(['refine:completed', 'refine:failed']);
@@ -107,21 +131,37 @@ function hasPendingCoordinatorEventDuplicate(event: PendingMeshCoordinatorEvent)
     return readPendingMeshCoordinatorEventsFromDisk(event.meshId).some((pending) => buildPendingEventFingerprint(pending) === fingerprint);
 }
 
-function getPendingEventsPath(meshId: string): string {
+function getPendingEventsPath(meshId: string, coordinatorDaemonId?: string): string {
     const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    if (coordinatorDaemonId) {
+        const safeDaemon = coordinatorDaemonId.replace(/[^a-zA-Z0-9_-]/g, '_');
+        return join(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    }
     return join(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 
-function readPendingMeshCoordinatorEventsFromDisk(meshId?: string): PendingMeshCoordinatorEvent[] {
+function readPendingMeshCoordinatorEventsFromDisk(meshId?: string, coordinatorDaemonId?: string): 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 []; }
+    // Read coordinator-scoped file first; fall back to legacy shared file.
+    const paths = coordinatorDaemonId
+        ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)]
+        : [getPendingEventsPath(meshId)];
+    const events: PendingMeshCoordinatorEvent[] = [];
+    for (const path of paths) {
+        if (!existsSync(path)) continue;
+        try {
+            const raw = readFileSync(path, 'utf-8');
+            const parsed = raw.split('\n').filter(Boolean).flatMap(line => {
+                try { return [JSON.parse(line) as PendingMeshCoordinatorEvent]; } catch { return []; }
+            });
+            // If reading the shared file, filter to events that target this coordinator or are unscoped.
+            const filtered = (coordinatorDaemonId && path === getPendingEventsPath(meshId))
+                ? parsed.filter(e => !e.targetCoordinatorDaemonId || e.targetCoordinatorDaemonId === coordinatorDaemonId)
+                : parsed;
+            events.push(...filtered);
+        } catch { /* skip unreadable files */ }
+    }
+    return events;
 }
 
 function refineTerminalEventFromLedger(meshId: string, pending: readonly PendingMeshCoordinatorEvent[]): PendingMeshCoordinatorEvent[] {
@@ -139,7 +179,7 @@ function refineTerminalEventFromLedger(meshId: string, pending: readonly Pending
             .filter(value => !value.endsWith(':')),
     );
     const backfilled: PendingMeshCoordinatorEvent[] = [];
-    const entries = readLedgerEntries(meshId);
+    const entries = readLedgerEntries(meshId, { tail: 200 });
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
         if (entry.kind !== 'task_completed' && entry.kind !== 'task_failed') continue;
@@ -194,6 +234,19 @@ function reconcilePendingMeshCoordinatorEvents(meshId: string, events: PendingMe
     ];
 }
 
+const MAX_PENDING_EVENTS_BYTES = 100 * 1024; // 100 KB — keep the pending file small
+const MAX_PENDING_EVENTS_KEEP = 50;           // keep the last 50 events when trimming
+
+function trimPendingEventsIfNeeded(path: string): void {
+    try {
+        if (!existsSync(path)) return;
+        if (statSync(path).size <= MAX_PENDING_EVENTS_BYTES) return;
+        const lines = readFileSync(path, 'utf-8').split('\n').filter(Boolean);
+        if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
+        writeFileSync(path, lines.slice(-MAX_PENDING_EVENTS_KEEP).join('\n') + '\n', 'utf-8');
+    } catch { /* best-effort; if trim fails, append still proceeds */ }
+}
+
 export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean {
     try {
         if (hasPendingRefineTerminalEventDuplicate(event)) {
@@ -204,7 +257,11 @@ export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEv
             LOG.info('MeshEvents', `Suppressed duplicate pending ${event.event} for mesh ${event.meshId}`);
             return true;
         }
-        appendFileSync(getPendingEventsPath(event.meshId), JSON.stringify(event) + '\n', 'utf-8');
+        // Write to the coordinator-scoped file when the target coordinator is known;
+        // fall back to the shared file for legacy/unscoped events.
+        const path = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
+        trimPendingEventsIfNeeded(path);
+        appendFileSync(path, JSON.stringify(event) + '\n', 'utf-8');
         return true;
     } catch (e: any) {
         LOG.warn('MeshEvents', `Failed to persist pending coordinator event: ${e?.message || e}`);
@@ -212,29 +269,64 @@ export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEv
     }
 }
 
+// Atomically rename the file before reading so concurrent drains can't both consume
+// the same events. renameSync is atomic on POSIX (same filesystem); only one caller
+// wins the rename — the other gets ENOENT and returns null, preventing duplicate delivery.
+function atomicDrainFile(path: string): string | null {
+    const tmpPath = `${path}.draining`;
+    try {
+        renameSync(path, tmpPath);
+    } catch {
+        return null; // another drain already renamed it, or file doesn't exist
+    }
+    try {
+        const content = readFileSync(tmpPath, 'utf-8');
+        try { unlinkSync(tmpPath); } catch { /* already cleaned up */ }
+        return content;
+    } catch {
+        try { unlinkSync(tmpPath); } catch { /* best-effort cleanup */ }
+        return null;
+    }
+}
+
 /** Drain and return all pending coordinator events for meshId, removing them from disk. */
-export function drainPendingMeshCoordinatorEvents(meshId?: string): PendingMeshCoordinatorEvent[] {
+export function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): PendingMeshCoordinatorEvent[] {
     if (!meshId) return [];
-    const path = getPendingEventsPath(meshId);
-    if (!existsSync(path)) return [];
-    try {
-        const parsed = readPendingMeshCoordinatorEventsFromDisk(meshId);
-        try { unlinkSync(path); } catch { /* concurrent drain already removed it */ }
-        return reconcilePendingMeshCoordinatorEvents(meshId, parsed);
-    } catch { return []; }
+    const paths = coordinatorDaemonId
+        ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)]
+        : [getPendingEventsPath(meshId)];
+    const all: PendingMeshCoordinatorEvent[] = [];
+    for (const path of paths) {
+        const content = atomicDrainFile(path);
+        if (!content) continue;
+        const parsed = content.split('\n').filter(Boolean).flatMap(line => {
+            try { return [JSON.parse(line) as PendingMeshCoordinatorEvent]; } catch { return []; }
+        });
+        // If reading the shared file, filter to events that target this coordinator or are unscoped.
+        const filtered = (coordinatorDaemonId && path === getPendingEventsPath(meshId))
+            ? parsed.filter(e => !e.targetCoordinatorDaemonId || e.targetCoordinatorDaemonId === coordinatorDaemonId)
+            : parsed;
+        all.push(...filtered);
+    }
+    if (all.length === 0) return [];
+    return reconcilePendingMeshCoordinatorEvents(meshId, all);
 }
 
 /** Peek at pending coordinator events without draining (non-destructive). */
-export function getPendingMeshCoordinatorEvents(meshId?: string): readonly PendingMeshCoordinatorEvent[] {
+export function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): readonly PendingMeshCoordinatorEvent[] {
     if (!meshId) return [];
-    return reconcilePendingMeshCoordinatorEvents(meshId, readPendingMeshCoordinatorEventsFromDisk(meshId));
+    return reconcilePendingMeshCoordinatorEvents(meshId, readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId));
 }
 
-/** Explicitly clear all pending coordinator events for a mesh. */
-export function clearPendingMeshCoordinatorEvents(meshId?: string): void {
+/** Explicitly clear all pending coordinator events for a mesh (and coordinator if scoped). */
+export function clearPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): void {
     if (!meshId) return;
-    const path = getPendingEventsPath(meshId);
-    if (existsSync(path)) try { unlinkSync(path); } catch { /* already removed */ }
+    const paths = coordinatorDaemonId
+        ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)]
+        : [getPendingEventsPath(meshId)];
+    for (const path of paths) {
+        if (existsSync(path)) try { unlinkSync(path); } catch { /* already removed */ }
+    }
 }
 
 function readNonEmptyString(value: unknown): string {
@@ -319,7 +411,7 @@ function isIntentionalCleanupStopMetadata(event: Record<string, unknown>): boole
 function hasRecentIntentionalCleanupStop(meshId: string, sessionId?: string, nodeId?: string): boolean {
     if (!sessionId && !nodeId) return false;
     const cutoff = Date.now() - INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
-    const entries = readLedgerEntries(meshId);
+    const entries = readLedgerEntries(meshId, { tail: 200 });
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
         const timestamp = new Date(entry.timestamp).getTime();
@@ -344,7 +436,22 @@ function shouldSuppressIntentionalCleanupStop(args: {
 }
 
 const RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1000;
-const recentCompletionFingerprints = new Map<string, number>();
+
+function hasFingerprintSeen(fingerprint: string): boolean {
+    try {
+        return BeadsDB.getInstance().hasCompletionFingerprint(fingerprint);
+    } catch {
+        return false;
+    }
+}
+
+function recordFingerprintSeen(fingerprint: string): void {
+    try {
+        const db = BeadsDB.getInstance();
+        db.recordCompletionFingerprint(fingerprint, RECENT_COMPLETION_FINGERPRINT_TTL_MS);
+        db.sweepExpiredFingerprints();
+    } catch { /* best-effort; duplicate events are preferable to a crash */ }
+}
 
 function readEventTimestamp(value: unknown): number | null {
     if (typeof value === 'number' && Number.isFinite(value)) return value;
@@ -365,6 +472,10 @@ function buildMeshCompletionFingerprint(args: {
     providerSessionId?: string;
     timestamp?: number | null;
     finalSummary?: string;
+    /** When set, scopes the fingerprint to a specific coordinator daemon so
+     *  two coordinators processing events from their respective workers don't
+     *  suppress each other's completion events. */
+    coordinatorDaemonId?: string;
 }): string {
     const timestampPart = Number.isFinite(args.timestamp)
         ? String(args.timestamp)
@@ -376,6 +487,7 @@ function buildMeshCompletionFingerprint(args: {
         args.providerType || '',
         args.providerSessionId || '',
         timestampPart,
+        args.coordinatorDaemonId || '',
     ].join('::');
 }
 
@@ -387,27 +499,20 @@ function isDuplicateMeshCompletionEvent(args: {
     providerSessionId?: string;
     timestamp?: number | null;
     finalSummary?: string;
+    coordinatorDaemonId?: 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);
+    if (hasFingerprintSeen(fingerprint)) return true;
+    recordFingerprintSeen(fingerprint);
     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);
+    if (hasFingerprintSeen(fingerprint)) return true;
+    recordFingerprintSeen(fingerprint);
     return false;
 }
 
@@ -417,7 +522,10 @@ function findRecentTerminalLedgerEvidence(args: {
     nodeId?: string;
 }): { id: string; kind: MeshLedgerKind; payload: Record<string, unknown>; timestamp: string } | null {
     if (!args.sessionId && !args.nodeId) return null;
-    const entries = readLedgerEntries(args.meshId);
+    // Tail-limit: 200 entries gives a wide enough window to catch terminal events for active
+    // sessions while avoiding a full O(n) scan. If a terminal is older than 200 entries,
+    // the BeadsDB fingerprint dedup will still block duplicate processing downstream.
+    const entries = readLedgerEntries(args.meshId, { tail: 200 });
     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;
@@ -435,7 +543,8 @@ function findRecentTerminalLedgerEvidence(args: {
 // 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);
+    // 200-entry window matches findRecentTerminalLedgerEvidence for consistency.
+    const entries = readLedgerEntries(meshId, { tail: 200 });
     let pastTerminal = false;
     for (const entry of entries) {
         if (!pastTerminal) {
@@ -564,6 +673,13 @@ const autoLaunchInProgress = new Set<string>();
 const autoLaunchCooldownUntil = new Map<string, number>();
 const AUTO_LAUNCH_COOLDOWN_MS = 5_000;
 
+function sweepExpiredCooldowns(): void {
+    const now = Date.now();
+    for (const [key, until] of autoLaunchCooldownUntil) {
+        if (now >= until) autoLaunchCooldownUntil.delete(key);
+    }
+}
+
 function normalizeProviderPriority(policy: unknown): string[] {
     const raw = policy && typeof policy === 'object' && !Array.isArray(policy)
         ? (policy as Record<string, unknown>).providerPriority
@@ -770,12 +886,14 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
             const nodeId = readNonEmptyString(node?.id);
             if (!nodeId) continue;
             const launchKey = `${meshId}:${nodeId}`;
+            const now = Date.now();
             const cooldownUntil = autoLaunchCooldownUntil.get(launchKey) || 0;
+            if (cooldownUntil > 0 && now >= cooldownUntil) autoLaunchCooldownUntil.delete(launchKey);
             if (autoLaunchInProgress.has(launchKey)) {
                 markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'auto_launch_in_progress', nodeId });
                 continue;
             }
-            if (Date.now() < cooldownUntil) {
+            if (now < cooldownUntil) {
                 markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'auto_launch_cooldown', nodeId });
                 continue;
             }
@@ -825,13 +943,13 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                 if (!launchResult?.success) {
                     const reason = launchResult?.error || 'launch_cli_failed';
                     markAutoLaunch(meshId, task.id, { status: 'failed', reason, nodeId, providerType: resolved.providerType });
-                    autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+                    autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS); sweepExpiredCooldowns();
                     return false;
                 }
                 const sessionId = readNonEmptyString(launchResult.sessionId) || readNonEmptyString(launchResult.id) || readNonEmptyString(launchResult.runtimeSessionId);
                 if (!sessionId) {
                     markAutoLaunch(meshId, task.id, { status: 'failed', reason: 'launch_missing_session_id', nodeId, providerType: resolved.providerType });
-                    autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+                    autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS); sweepExpiredCooldowns();
                     return false;
                 }
                 markAutoLaunch(meshId, task.id, { status: 'completed', nodeId, providerType: resolved.providerType, sessionId });
@@ -1020,6 +1138,15 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
 }) {
     const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
     const eventNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+
+    // Resolve coordinator ownership early — used in fingerprinting and coordinator routing.
+    const sourceSession = args.sourceInstanceId
+        ? components.instanceManager.getInstance(args.sourceInstanceId)
+        : undefined;
+    const workerCoordinatorDaemonId = readNonEmptyString(
+        (sourceSession?.getState()?.settings as Record<string, unknown>)?.meshCoordinatorDaemonId,
+    );
+    const localDaemonId = readNonEmptyString(loadConfig().machineId);
     const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
         event: args.event,
         meshId: args.meshId,
@@ -1102,6 +1229,9 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
             timestamp: eventTimestamp,
             finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+            // Scope dedup to the coordinator daemon so two coordinators for the same mesh
+            // don't suppress each other's completion events via shared fingerprint table.
+            coordinatorDaemonId: workerCoordinatorDaemonId || undefined,
         });
         if (duplicateCompletion) {
             LOG.info('MeshEvents', `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
@@ -1121,9 +1251,9 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 occurredAt: eventTimestamp !== null ? new Date(eventTimestamp).toISOString() : undefined,
             });
             completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
+            updateDirectDispatchStatus(args.meshId, sessionId, 'completed');
+            setImmediate(() => cleanupTerminalDirectDispatches());
             if (nodeId && providerType) {
-                // 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);
                 });
@@ -1140,8 +1270,10 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const completedTask = sessionId && hasCompletionEvidence
             ? updateSessionTaskStatus(args.meshId, sessionId, 'completed')
             : null;
-        if (completedTask) {
+        if (completedTask && sessionId) {
             completedTaskForLedger = { id: completedTask.id };
+            updateDirectDispatchStatus(args.meshId, sessionId, 'completed');
+            setImmediate(() => cleanupTerminalDirectDispatches());
             try {
                 appendLedgerEntry(args.meshId, {
                     kind: 'task_completed',
@@ -1189,6 +1321,10 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         if (sessionId && nodeId) {
             remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
         }
+        if (sessionId) {
+            // Mark direct dispatch as acknowledged — the session started generating.
+            updateDirectDispatchStatus(args.meshId, sessionId, 'acked');
+        }
     } else if (args.event === 'agent:stopped') {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
@@ -1198,6 +1334,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         if (sessionId) {
             const failedTask = updateSessionTaskStatus(args.meshId, sessionId, 'failed');
             completedTaskForLedger = failedTask ? { id: failedTask.id } : null;
+            updateDirectDispatchStatus(args.meshId, sessionId, 'failed');
         }
     }
 
@@ -1320,6 +1457,10 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const instState = inst.getState();
         if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
         if (args.sourceInstanceId && instState.instanceId === args.sourceInstanceId) return false;
+        // If the worker knows which coordinator daemon launched it, only route to coordinators
+        // on that specific daemon. This prevents cross-contamination when multiple coordinator
+        // sessions run simultaneously for the same mesh on different daemons.
+        if (workerCoordinatorDaemonId && localDaemonId && workerCoordinatorDaemonId !== localDaemonId) return false;
         return true;
     });
 
@@ -1330,7 +1471,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     const isRefineTerminalEvent = REFINE_TERMINAL_EVENTS.has(args.event);
 
     if (coordinatorInstances.length === 0) {
-        // No CLI coordinator session found — buffer for MCP-based coordinators.
+        // No local CLI coordinator — buffer for MCP-based coordinator on the target daemon.
         if (queuePendingMeshCoordinatorEvent({
                 event: args.event,
                 meshId: args.meshId,
@@ -1343,8 +1484,11 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 },
                 coordinatorMessage: messageText,
                 queuedAt: Date.now(),
+                // Scope to the coordinator daemon that launched this worker so drain
+                // by other coordinators on the same daemon doesn't consume this event.
+                ...(workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}),
             })) {
-            LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
+            LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ''})`);
         }
         return { success: true, forwarded: 0 };
     }
@@ -1383,6 +1527,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 },
                 coordinatorMessage: messageText,
                 queuedAt: Date.now(),
+                ...(workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}),
             })) {
             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`);
@@ -1484,7 +1629,7 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
         if (!isMeshDelegate) return;
 
-        const mesh = meshIdFromRuntime ? getMeshWithCache(components, meshIdFromRuntime) : getMeshByRepo(workspace);
+        const mesh = meshIdFromRuntime ? getMeshWithCache(components, meshIdFromRuntime) : getCachedMeshByWorkspace(workspace);
         const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
         if (!meshId) return;