@adhdev/daemon-core 0.9.82-rc.342 → 0.9.82-rc.344

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

@@ -42,6 +42,12 @@ export interface MeshWorkerRelayStamp {
     meshNodeFor?: string;
     meshNodeId?: string;
     meshCoordinatorDaemonId?: string;
+    // The ORIGINATING coordinator SESSION (not just its daemon). Carried so a worker's
+    // completion event can be routed back to the exact coordinator session that
+    // dispatched the work, even when several coordinator sessions share one daemon
+    // (the multi-coordinator misroute). Optional + absent on legacy dispatches, in
+    // which case routing falls back to the daemon-level anchor (current behaviour).
+    meshCoordinatorSessionId?: string;
     launchedByCoordinator?: boolean;
 }
 
@@ -63,6 +69,7 @@ export function buildMeshWorkerRelayStamp(
         meshId?: unknown;
         nodeId?: unknown;
         coordinatorDaemonId?: unknown;
+        coordinatorSessionId?: unknown;
     } | undefined,
 ): MeshWorkerRelayStamp | undefined {
     if (!meshContext) return undefined;
@@ -80,9 +87,17 @@ export function buildMeshWorkerRelayStamp(
         stamp.meshCoordinatorDaemonId = coordinatorDaemonId;
     }
 
+    // Session-level anchor (multi-coordinator routing): stamp the originating
+    // coordinator session id so the completion event can target the exact session.
+    // Carried over P2P to remote workers so a remote worker's echo returns it.
+    const coordinatorSessionId = readNonEmptyString(meshContext.coordinatorSessionId);
+    if (coordinatorSessionId && !readNonEmptyString(settings.meshCoordinatorSessionId)) {
+        stamp.meshCoordinatorSessionId = coordinatorSessionId;
+    }
+
     // A dispatch from a coordinator is itself proof of delegation; stamp it when the
     // session is being given any mesh routing context but has no marker yet.
-    if ((meshId || nodeId || coordinatorDaemonId) && settings.launchedByCoordinator !== true) {
+    if ((meshId || nodeId || coordinatorDaemonId || coordinatorSessionId) && settings.launchedByCoordinator !== true) {
         stamp.launchedByCoordinator = true;
     }
 
@@ -109,6 +124,30 @@ export function readWorkerResultMetadata(event: Record<string, unknown>): Record
 
 const MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
 
+// Cap for the worker final summary surfaced INLINE into the coordinator's chat
+// (buildMeshSystemMessage). Larger than the mirror preview cap because this is the
+// coordinator-facing payload that replaces a "go call mesh_read_chat" instruction —
+// it should carry enough of the worker's result to act on without a second round-trip,
+// while still bounding what is written into the coordinator PTY.
+const MESH_COMPLETION_SURFACE_MAX_CHARS = 4000;
+
+/**
+ * The worker's final assistant text carried on a completion event — read from
+ * `finalSummary` (and the `workerResult.summary` / `result.summary` fallbacks some
+ * paths use). Returns '' when the event carries no assistant text (lifecycle events
+ * without a summary). Shared by the coordinator chat surface (buildMeshSystemMessage)
+ * and the held-event ledger audit record so both read the summary the same way.
+ */
+export function readMeshCompletionSummary(metadataEvent: Record<string, unknown>): string {
+    const workerResult = readWorkerResultMetadata(metadataEvent);
+    const resultRecord = readRecord(metadataEvent.result);
+    return readNonEmptyString(metadataEvent.finalSummary)
+        || readNonEmptyString(workerResult?.summary)
+        || readNonEmptyString(workerResult?.finalSummary)
+        || readNonEmptyString(resultRecord?.summary)
+        || readNonEmptyString(resultRecord?.finalSummary);
+}
+
 /**
  * A coordinator that surfaces a REMOTE worker's mesh session has no local instance for
  * it, so the status snapshot's getLastDisplayMessage has nothing to read and the only
@@ -126,13 +165,7 @@ const MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
 export function resolveMeshSurfacedSessionPreview(
     metadataEvent: Record<string, unknown>,
 ): { preview: string; role: 'assistant'; receivedAt: number } | undefined {
-    const workerResult = readWorkerResultMetadata(metadataEvent);
-    const resultRecord = readRecord(metadataEvent.result);
-    const summaryText = readNonEmptyString(metadataEvent.finalSummary)
-        || readNonEmptyString(workerResult?.summary)
-        || readNonEmptyString(workerResult?.finalSummary)
-        || readNonEmptyString(resultRecord?.summary)
-        || readNonEmptyString(resultRecord?.finalSummary);
+    const summaryText = readMeshCompletionSummary(metadataEvent);
     if (!summaryText) return undefined;
     const truncationSuffix = '...[truncated]';
     const preview = summaryText.length > MESH_SURFACED_PREVIEW_MAX_CHARS
@@ -186,7 +219,26 @@ export function buildMeshSystemMessage(args: {
         if (args.metadataEvent.source === 'no_progress_reconciliation') {
             return `[System] ${args.nodeLabel} already has completion evidence${metadata}. The no-progress monitor reconciled the terminal handoff and marked the session complete; wait for the queued completion event/status refresh before doing any manual transcript check.`;
         }
-        const reviewNote = args.metadataEvent.reviewRecommended === true
+        const reviewRecommended = args.metadataEvent.reviewRecommended === true;
+        // Auto-surface the worker's final summary directly into the coordinator chat so it
+        // does not have to call mesh_read_chat just to see the result. The summary IS the
+        // worker's final assistant message; embedding it here replaces the previous
+        // "go call mesh_read_chat" instruction with the answer itself. This rides the
+        // existing (non-modal) coordinator delivery channel — it does not write into a
+        // parked harness modal. Falls back to the read_chat instruction only when the event
+        // genuinely carries no summary (so behaviour is unchanged for summary-less events).
+        const completionSummary = readMeshCompletionSummary(args.metadataEvent);
+        if (completionSummary) {
+            const truncationSuffix = '\n…[truncated — call mesh_read_chat once for the full transcript]';
+            const surfaced = completionSummary.length > MESH_COMPLETION_SURFACE_MAX_CHARS
+                ? `${completionSummary.slice(0, MESH_COMPLETION_SURFACE_MAX_CHARS - truncationSuffix.length)}${truncationSuffix}`
+                : completionSummary;
+            const verifyNote = reviewRecommended
+                ? ' Completion evidence is insufficient — verify via git status or provider_session_id before assuming the task is done.'
+                : '';
+            return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. Its final summary is included below — read it directly and only call mesh_read_chat if you need the full transcript.${verifyNote}\n\n--- ${args.nodeLabel} final summary ---\n${surfaced}`;
+        }
+        const reviewNote = reviewRecommended
             ? ' Completion evidence is insufficient — verify via git status or provider_session_id before assuming the task is done. Use mesh_read_chat once if needed, but do not poll repeatedly.'
             : ' Use mesh_read_chat once to review its final progress, but do not poll repeatedly.';
         return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path;${reviewNote}`;

package/src/mesh/mesh-ledger.ts

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

package/src/mesh/mesh-reconcile-loop.ts

@@ -45,8 +45,9 @@ import type { LocalMeshEntry } from '../repo-mesh-types.js';
 import { loadConfig } from '../config/config.js';
 import { listMeshes } from '../config/mesh-config.js';
 import { LOG } from '../logging/logger.js';
-import { drainPendingMeshCoordinatorEvents } from './mesh-events-pending.js';
+import { drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, buildPendingEventFingerprint, queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
+import { appendLedgerEntry } from './mesh-ledger.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { handleMeshForwardEvent, shouldForceInjectMeshEvent, MESH_FORCE_INJECT_EVENTS, triggerMeshQueue } from './mesh-events-coordinator.js';
 import {
@@ -54,7 +55,7 @@ import {
     ackUnresolvedDelegateForward,
     expireStaleUnresolvedDelegateForwards,
 } from './mesh-unresolved-forward-outbox.js';
-import { readNonEmptyString } from './mesh-events-utils.js';
+import { readNonEmptyString, readMeshCompletionSummary } from './mesh-events-utils.js';
 import { getActiveDirectDispatches, getQueue } from './mesh-work-queue.js';
 import { readLedgerEntries } from './mesh-ledger.js';
 import { pruneStaleDirectDispatches } from './mesh-active-work.js';
@@ -97,6 +98,11 @@ function resolveReconcileIntervalMs(): number {
 interface LiveCoordinator {
     meshId: string;
     instance: ReturnType<DaemonComponents['instanceManager']['getInstance']>;
+    // Runtime session id of this coordinator instance (getState().instanceId). PHASE 2
+    // strict-matches an event's targetCoordinatorSessionId against this so a completion
+    // routes back to the exact originating coordinator session, not a sibling on the same
+    // daemon (the multi-coordinator misroute).
+    sessionId: string;
     idle: boolean;
     // True when the coordinator session is parked on a harness modal awaiting a
     // human answer — claude-cli AskUserQuestion (waiting_choice) or a tool-consent
@@ -205,7 +211,8 @@ function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
         // Lowercase literal compare — the SessionStatus enum is forked across modules
         // and waiting_choice is absent from some of them (see cli-provider-instance).
         const modalParked = status === 'waiting_choice' || status === 'waiting_approval';
-        out.push({ meshId, instance: inst, idle: status === 'idle', modalParked });
+        const sessionId = readNonEmptyString(state.instanceId);
+        out.push({ meshId, instance: inst, sessionId, idle: status === 'idle', modalParked });
     }
     return out;
 }
@@ -225,6 +232,71 @@ function injectPendingIntoCoordinator(
     });
 }
 
+// Held-event ledger dedup: fingerprints of held terminal events already written as an
+// `event_held` ledger audit record in THIS process. Prevents the 4s reconcile tick from
+// re-logging the same held event every interval while a coordinator stays modal-parked.
+// Per-process only (not persisted) — if the daemon restarts while an event is still held
+// it is re-logged once, which is desirable: it re-confirms the event is still undelivered.
+const heldEventLedgerRecorded = new Set<string>();
+
+// C1 (data safety): when a terminal completion/approval/bootstrap event cannot be
+// delivered because the only coordinators are modal-parked, the event is held at
+// drained=0 in the pending queue (SQLite + JSONL) for a later tick. That queue is
+// disk-persisted but carries no operator-visible audit trail and can be silently
+// dropped by the pending-file trim (100 KB / 50-entry cap). To guarantee a held
+// completion's worker summary is never silently lost, mirror each held terminal event
+// into the coordinator's mesh ledger as an `event_held` entry — auditable and
+// recoverable (the finalSummary survives even if the pending copy is later trimmed or
+// the coordinator session is force-resolved before re-drain). Idempotent per process
+// via heldEventLedgerRecorded so a long modal park does not spam the ledger.
+function recordHeldTerminalEventsToLedger(
+    meshId: string,
+    drainDaemonIds: string[],
+    reason: string,
+    heldForCoordinatorCount: number,
+): void {
+    let pending: readonly PendingMeshCoordinatorEvent[];
+    try {
+        pending = getPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : undefined);
+    } catch {
+        return; // best-effort audit — never let a peek failure break the tick
+    }
+    for (const event of pending) {
+        // Only audit terminal/force-inject events (completion / approval / stop / refine·
+        // bootstrap). Silent lifecycle events (agent:ready / generating_started) carry no
+        // worker output to preserve and re-drain harmlessly, so they need no audit trail.
+        if (!shouldForceInjectMeshEvent(event.event)) continue;
+        const fingerprint = buildPendingEventFingerprint(event);
+        const key = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ''}::${event.queuedAt}`}`;
+        if (heldEventLedgerRecorded.has(key)) continue;
+        heldEventLedgerRecorded.add(key);
+        const finalSummary = readMeshCompletionSummary(event.metadataEvent);
+        try {
+            appendLedgerEntry(meshId, {
+                kind: 'event_held',
+                ...(event.nodeId ? { nodeId: event.nodeId } : {}),
+                payload: {
+                    event: event.event,
+                    reason,
+                    recoverable: true,
+                    heldForCoordinators: heldForCoordinatorCount,
+                    nodeLabel: event.nodeLabel,
+                    ...(event.workspace ? { workspace: event.workspace } : {}),
+                    targetCoordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
+                    queuedAt: event.queuedAt,
+                    ...(fingerprint ? { fingerprint } : {}),
+                    ...(finalSummary ? { finalSummary } : {}),
+                },
+            });
+            LOG.info('MeshReconcile', `Ledger-recorded held ${event.event} for mesh ${meshId} (reason ${reason}) — recoverable from ledger`);
+        } catch (e: any) {
+            // Failed to persist — drop the dedup marker so the next tick retries.
+            heldEventLedgerRecorded.delete(key);
+            LOG.warn('MeshReconcile', `Failed to ledger-record held ${event.event} for mesh ${meshId}: ${e?.message || e}`);
+        }
+    }
+}
+
 // One reconcile tick. Two independent phases:
 //
 //   PHASE 1 — Remote queue pull (the fix for remote worktree completions never
@@ -426,6 +498,24 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         if (targetCoordinators.length === 0) {
             if (modalParkedCoordinators.length > 0) {
                 LOG.info('MeshReconcile', `Reconcile skip → modal-parked: holding pending event(s) for mesh ${meshId} (${modalParkedCoordinators.length} coordinator(s) awaiting a modal answer; events left queued)`);
+                // C1: mirror held terminal events into the ledger so a held completion's
+                // worker summary is auditable/recoverable even if the modal is never
+                // resolved, the coordinator restarts, or the pending file is later trimmed.
+                // The events stay queued (drained=0) for re-drain on a later tick; this only
+                // adds the durable audit copy. Idempotent per process — only newly-held
+                // events are logged. O(1)-gated: skip the peek when the queue is empty.
+                let hasPending = true;
+                if (store) {
+                    try { hasPending = store.pendingEventCount(meshId) > 0; } catch { /* peek below */ }
+                }
+                if (hasPending) {
+                    recordHeldTerminalEventsToLedger(
+                        meshId,
+                        drainDaemonIds.length > 0 ? drainDaemonIds : (localDaemonId ? [localDaemonId] : []),
+                        'modal_parked',
+                        modalParkedCoordinators.length,
+                    );
+                }
             }
             continue;
         }
@@ -453,6 +543,26 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         const mode = forceOnly ? 'force-drain → generating' : 'inject → idle';
         LOG.info('MeshReconcile', `Reconcile ${mode}: ${pendingEvents.length} pending event(s) → ${targetCoordinators.length} coordinator(s) for mesh ${meshId}`);
         for (const pending of pendingEvents) {
+            // Strict session routing (multi-coordinator): when the event names an
+            // originating coordinator session, deliver ONLY to the live coordinator whose
+            // session id matches — a sibling coordinator on the same daemon must NOT receive
+            // another coordinator's completion. When the event carries no session id (legacy /
+            // version-skewed / single-coordinator), fall back to the daemon-level set
+            // (unchanged behaviour — regression-0 for the common case).
+            const wantSession = readNonEmptyString(pending.targetCoordinatorSessionId);
+            if (wantSession) {
+                const matched = targetCoordinators.filter(c => c.sessionId === wantSession);
+                if (matched.length === 0) {
+                    // The originating coordinator session is not deliverable on this daemon
+                    // right now (gone, or modal-parked and excluded from targets). Strict mode
+                    // does NOT broadcast to siblings — hold the event for a later tick, and
+                    // ledger-expire it past a TTL so it can never wedge forever.
+                    holdOrExpireStrictUnmatchedEvent(pending, wantSession, meshId);
+                    continue;
+                }
+                for (const c of matched) injectPendingIntoCoordinator(c.instance, pending);
+                continue;
+            }
             for (const c of targetCoordinators) {
                 injectPendingIntoCoordinator(c.instance, pending);
             }
@@ -460,6 +570,56 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
     }
 }
 
+// Strict-routing TTL: how long a drained completion whose originating coordinator session
+// is not currently deliverable is held (re-queued for re-drain) before it is ledger-
+// expired. Bounded so a coordinator session that never returns cannot wedge the event
+// forever; broad enough to ride out a transient modal-park / brief restart.
+const STRICT_SESSION_MATCH_TTL_MS = 60_000;
+
+// Re-queue (hold) a strict-routed event whose coordinator session is not live, or — once it
+// has aged past STRICT_SESSION_MATCH_TTL_MS — ledger-expire it (recoverable) and drop it.
+// We deliberately do NOT broadcast an aged-out event to sibling coordinators: that is the
+// very misroute strict routing exists to prevent. The drain already marked the row drained=1,
+// so re-queuing re-persists a fresh undrained copy (dedup keys on drained=0 only); queuedAt is
+// preserved so the TTL measures the event's true age across re-queues.
+function holdOrExpireStrictUnmatchedEvent(
+    pending: PendingMeshCoordinatorEvent,
+    wantSession: string,
+    meshId: string,
+): void {
+    const queuedAt = typeof pending.queuedAt === 'number' ? pending.queuedAt : Date.now();
+    if (Date.now() - queuedAt <= STRICT_SESSION_MATCH_TTL_MS) {
+        try {
+            queuePendingMeshCoordinatorEvent(pending); // preserves queuedAt → true age retained
+            LOG.info('MeshReconcile', `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} — re-queued (${pending.event})`);
+        } catch (e: any) {
+            LOG.warn('MeshReconcile', `Strict route re-queue failed for ${pending.event} on mesh ${meshId}: ${e?.message || e}`);
+        }
+        return;
+    }
+    const finalSummary = readMeshCompletionSummary(pending.metadataEvent || {});
+    try {
+        appendLedgerEntry(meshId, {
+            kind: 'event_held',
+            ...(pending.nodeId ? { nodeId: pending.nodeId } : {}),
+            payload: {
+                event: pending.event,
+                reason: 'strict_route_expired',
+                recoverable: true,
+                targetCoordinatorSessionId: wantSession,
+                targetCoordinatorDaemonId: pending.targetCoordinatorDaemonId ?? null,
+                nodeLabel: pending.nodeLabel,
+                ...(pending.workspace ? { workspace: pending.workspace } : {}),
+                queuedAt,
+                ...(finalSummary ? { finalSummary } : {}),
+            },
+        });
+        LOG.warn('MeshReconcile', `Strict route expire: coordinator session ${wantSession} never returned for mesh ${meshId} — recorded to ledger (recoverable), dropped (${pending.event})`);
+    } catch (e: any) {
+        LOG.warn('MeshReconcile', `Failed to ledger-expire strict-unmatched ${pending.event} for mesh ${meshId}: ${e?.message || e}`);
+    }
+}
+
 // Cloud-only: retry the worker-side unresolved-delegate forward outbox. For each
 // durably-queued entry, push it to its coordinator daemon over P2P (mesh_forward_event)
 // and ack (mark drained) ONLY on a successful, non-rejected response. A failed or
@@ -791,6 +951,13 @@ function buildForwardPayloadFromPending(event: any): Record<string, unknown> {
         meshId: readNonEmptyString(event?.meshId),
         nodeId: readNonEmptyString(event?.nodeId) || readNonEmptyString(metadata.meshNodeId),
         workspace: readNonEmptyString(event?.workspace) || readNonEmptyString(metadata.workspace),
+        // Preserve the originating coordinator session id across the relay. It is normally
+        // carried inside metadataEvent.meshCoordinatorSessionId (spread below), but pass the
+        // top-level field through explicitly too so the handleMeshForwardEvent whitelist
+        // recovers it regardless of which carrier the producing daemon used.
+        ...(readNonEmptyString(event?.targetCoordinatorSessionId)
+            ? { targetCoordinatorSessionId: readNonEmptyString(event.targetCoordinatorSessionId) }
+            : {}),
         ...metadata,
     };
 }

package/src/mesh/mesh-runtime-store.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from 'fs';
 import { dirname, join } from 'path';
+import { LOG } from '../logging/logger.js';
 import { loadBetterSqlite3 } from '../system/load-better-sqlite3.js';
 import { getLedgerDir } from './mesh-ledger.js';
 import { nodeSatisfiesRequiredTags } from './mesh-work-queue.js';
@@ -23,6 +24,8 @@ function legacyQueuePath(meshId: string): string {
     return join(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
 
+let loggedMigrationFailure = false;
+
 function meshRuntimeStorePath(): string {
     const dir = getLedgerDir();
     const nextPath = join(dir, 'mesh-runtime.db');
@@ -39,9 +42,23 @@ function meshRuntimeStorePath(): string {
                 renameSync(legacyCompanion, `${nextPath}${suffix}`);
             }
         }
-    } catch {
-        // Best-effort compatibility for existing installs. If migration fails,
-        // opening the new store will create a clean DB instead of blocking boot.
+    } catch (err: any) {
+        // Migration failed — most commonly win32 EPERM when a handle to the
+        // legacy DB is still open. Do NOT fall through to opening `nextPath`:
+        // that would create a fresh EMPTY store while the existing data stays
+        // stranded in the legacy file (split-brain / silent data loss). Instead
+        // keep using whichever file actually holds the data in-place — the next
+        // boot retries the rename. If the main rename already landed (only a
+        // companion file failed), the data is at nextPath; otherwise it is still
+        // at legacyPath.
+        if (!loggedMigrationFailure) {
+            loggedMigrationFailure = true;
+            LOG.warn(
+                'MeshRuntimeStore',
+                `Legacy beads.db→mesh-runtime.db migration failed; using existing DB in-place to avoid data loss: ${err?.message || err}`,
+            );
+        }
+        return existsSync(nextPath) ? nextPath : legacyPath;
     }
     return nextPath;
 }
@@ -69,9 +86,26 @@ export class MeshRuntimeStore {
         this.migrate();
     }
 
+    private static loggedGetInstanceFailure = false;
+
     static getInstance(): MeshRuntimeStore {
         if (!this.instance) {
-            this.instance = new MeshRuntimeStore(meshRuntimeStorePath());
+            try {
+                this.instance = new MeshRuntimeStore(meshRuntimeStorePath());
+            } catch (err: any) {
+                // SQLite store could not be opened (e.g. better-sqlite3 native
+                // load failure, locked/corrupt DB). Callers wrap getInstance in
+                // try/catch and silently degrade to JSONL-only — surface ONE warn
+                // so that degraded mode is diagnosable, then re-throw unchanged.
+                if (!MeshRuntimeStore.loggedGetInstanceFailure) {
+                    MeshRuntimeStore.loggedGetInstanceFailure = true;
+                    LOG.warn(
+                        'MeshRuntimeStore',
+                        `getInstance failed; callers will degrade to JSONL-only: ${err?.message || err}`,
+                    );
+                }
+                throw err;
+            }
         }
         return this.instance;
     }

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

@@ -350,6 +350,14 @@ export interface MeshWorkQueueEntry {
     };
     /** ISO timestamp when the task was dispatched (assigned) to a node/session. Used for precise matching on completion. */
     dispatchTimestamp?: string;
+    /**
+     * (3) The ORIGINATING coordinator session that enqueued this task. Stamped onto the
+     * worker at dispatch (meshCoordinatorSessionId) so the task's completion routes back to
+     * the exact coordinator session — even when several coordinator sessions share one
+     * daemon. Rides in the queue payload JSON (no column migration); absent on legacy rows
+     * → daemon-level routing fallback (backward + version-skew safe).
+     */
+    sourceCoordinatorSessionId?: string;
     createdAt: string;
     updatedAt: string;
 }
@@ -566,6 +574,8 @@ export function enqueueTask(
         missionId?: string;
         /** Explicit task id for batch/template flows (M5). Random UUID when omitted. */
         id?: string;
+        /** (3) Originating coordinator session id (for session-anchored completion routing). */
+        sourceCoordinatorSessionId?: string;
     } & MeshQueueMutationOptions,
 ): MeshWorkQueueEntry {
     requireMeshHostQueueOwner(opts);
@@ -603,6 +613,9 @@ export function enqueueTask(
             requiredTags: resolvedRequiredTags,
             ...(dependsOn.length > 0 ? { dependsOn } : {}),
             ...(typeof opts?.missionId === 'string' && opts.missionId.trim() ? { missionId: opts.missionId.trim() } : {}),
+            ...(typeof opts?.sourceCoordinatorSessionId === 'string' && opts.sourceCoordinatorSessionId.trim()
+                ? { sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId.trim() }
+                : {}),
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
         };

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

@@ -879,7 +879,7 @@ export class CliProviderInstance implements ProviderInstance {
      * completion events silently drop because the forwarder has nothing to
      * match against.
      */
-    attachMeshAssignment(assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string }): void {
+    attachMeshAssignment(assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void {
         if (!assignment?.meshId) return;
         this.settings = {
             ...this.settings,
@@ -887,6 +887,9 @@ export class CliProviderInstance implements ProviderInstance {
             ...(assignment.nodeId ? { meshNodeId: assignment.nodeId } : {}),
             ...(assignment.taskId ? { meshActiveTaskId: assignment.taskId } : {}),
             ...(assignment.coordinatorDaemonId ? { meshCoordinatorDaemonId: assignment.coordinatorDaemonId } : {}),
+            // Session-level routing anchor: the originating coordinator session, so this
+            // worker's completion events route back to the exact session that dispatched it.
+            ...(assignment.coordinatorSessionId ? { meshCoordinatorSessionId: assignment.coordinatorSessionId } : {}),
         };
         this.adapter.updateRuntimeSettings?.(this.settings);
     }

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

@@ -310,7 +310,7 @@ export class ProviderInstanceManager {
      *  --direct so the worker's completion event has a coordinator routing
      *  marker in state.settings). Returns true if the instance existed and
      *  the stamp was applied. */
-    attachMeshAssignmentToInstance(instanceId: string, assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string }): boolean {
+    attachMeshAssignmentToInstance(instanceId: string, assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): boolean {
         const inst = this.instances.get(instanceId);
         if (!inst || typeof inst.attachMeshAssignment !== 'function') {
             try {

package/src/providers/provider-instance.ts

@@ -220,7 +220,7 @@ export interface ProviderInstance {
     /** Stamp a direct-dispatch mesh task assignment so generating_completed
      *  events route back to the originating coordinator. Cleared by
      *  detachMeshAssignment when the task reaches a terminal state. */
-    attachMeshAssignment?(assignment: { meshId: string; nodeId?: string; taskId?: string }): void;
+    attachMeshAssignment?(assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void;
     detachMeshAssignment?(): void;
 
     /** Refresh static provider definition/scripts without restarting the live runtime. */

package/src/providers/spec/fsm-driver.ts

@@ -145,13 +145,23 @@ function countNewlines(s: string): number {
 
 const SUBMIT_DELAY_FLOOR_MS = 200;
 
-// win32 ConPTY submit reliability: after the text settles we write the submit
-// key (CR) as its OWN keystroke, then repeat it once after a short gap. The
-// repeat is the safety net for the case where ConPTY drops/coalesces the first
-// lone CR; on an already-submitted prompt the second CR lands on an empty input
-// and is a harmless no-op. The gap must be long enough that the TUI has redrawn
-// after the first CR before the second arrives.
-const WIN32_SUBMIT_REPEAT_GAP_MS = 300;
+// win32 ConPTY submit reliability. A MULTILINE message creates an Ink
+// paste/newline-accumulation window during which a lone CR is absorbed as a
+// literal newline instead of submitting; the window's length is
+// nondeterministic (observed 0–~2s, driven by ConPTY byte timing), so neither a
+// fixed delay nor a fixed CR count reliably submits. (A/B PTY testing on win32
+// ConPTY: single-line submits on the FIRST CR; multiline needs a *variable*
+// number of CRs as the window expires — a fixed double-CR fails outright, and
+// bracketed-paste wrapping does NOT help.) So we VERIFY instead of guessing:
+// write the text, then resend the submit key on a fixed cadence until the FSM
+// observes the agent has actually left the idle composer (status flips away from
+// 'idle' — i.e. it submitted and is generating / showing a modal), bounded by a
+// retry budget. Once submission is observed we stop so we don't spam Enter into
+// the next turn. Single-line messages satisfy the check after the first CR, so
+// their behaviour is unchanged. CRs absorbed as newlines during the window are
+// trimmed by the TUI on submit.
+const WIN32_SUBMIT_RESEND_GAP_MS = 350;
+const WIN32_SUBMIT_MAX_RESENDS = 14;
 
 export function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text: string): number {
     const lines = countNewlines(text);
@@ -217,6 +227,10 @@ export class FsmDriver implements ISpecDriver {
      *  after a re-prime we don't re-inject until the screen changes (which
      *  resets the stall reference) or another full stall window lapses. */
     private lastRefocusAt = 0;
+    /** Timer driving the win32 verification-based submit resend loop (see
+     *  WIN32_SUBMIT_* and scheduleWin32Submit). Re-arms itself until the FSM
+     *  leaves idle (submitted) or the resend budget is spent. */
+    private win32SubmitTimer: ReturnType<typeof setTimeout> | null = null;
 
     private currentEval: CurrentEval | null = null;
     private stateHistory: HistoryEntry[] = [];
@@ -334,6 +348,7 @@ export class FsmDriver implements ISpecDriver {
         this.delegateTimers.clear();
         if (this.wakeTimer) { clearTimeout(this.wakeTimer); this.wakeTimer = null; }
         if (this.stallTimer) { clearTimeout(this.stallTimer); this.stallTimer = null; }
+        if (this.win32SubmitTimer) { clearTimeout(this.win32SubmitTimer); this.win32SubmitTimer = null; }
         this.specWatcher?.close();
         this.adapter.kill();
     }
@@ -841,25 +856,19 @@ export class FsmDriver implements ISpecDriver {
         const beforeSubmit = resolveSubmitDelayMs(sm.delay_ms_before_submit, text);
 
         // win32 ConPTY submit: the text and the submit key (CR) must NOT be
-        // combined into one PTY write. Ink-based TUIs (claude-cli) treat a single
-        // write that carries text + a trailing CR as a bracketed/multi-line paste
-        // and absorb the CR as a literal newline in the input box instead of a
-        // submit keystroke — the prompt sits typed-but-unsent until the user hits
-        // Enter manually. (A previous "atomic write" attempt regressed exactly
-        // this way.) Instead, write the text, let it settle so the TUI leaves any
-        // paste-accumulation state, then deliver the CR as its OWN keystroke. We
-        // send the CR twice with a short gap: ConPTY can drop/coalesce the first
-        // lone CR, and a second CR on an already-submitted (now empty) prompt is a
-        // harmless no-op. perChar typing simulation is skipped on win32;
-        // correctness of submission wins over the typing visual there.
+        // combined into one PTY write — Ink-based TUIs (claude-cli) treat a
+        // single write that carries text + a trailing CR as a bracketed/multi-line
+        // paste and absorb the CR as a literal newline. So we write the text on
+        // its own, then resend the submit key on a fixed cadence, VERIFYING after
+        // each that the agent actually left the idle composer (status flipped away
+        // from 'idle'). This handles the nondeterministic multiline
+        // paste-accumulation window where a variable number of CRs is needed; a
+        // fixed double-CR fails for multiline (see WIN32_SUBMIT_* above). perChar
+        // typing simulation is skipped on win32; correctness of submission wins
+        // over the typing visual there.
         if (process.platform === 'win32') {
-            const submitTwice = (): void => {
-                this.adapter.send_keys(sm.submit_key);
-                setTimeout(() => this.adapter.send_keys(sm.submit_key), WIN32_SUBMIT_REPEAT_GAP_MS);
-            };
             this.adapter.send_keys(text);
-            if (beforeSubmit > 0) setTimeout(submitTwice, beforeSubmit);
-            else submitTwice();
+            this.scheduleWin32Submit(sm.submit_key, beforeSubmit);
             return;
         }
 
@@ -881,6 +890,37 @@ export class FsmDriver implements ISpecDriver {
         }, perChar);
     }
 
+    /** The agent's current coarse status, derived from the FSM node we're in. */
+    private currentStatus(): 'idle' | 'generating' | 'approval' {
+        const st = stateById(this.spec, this.currentStateId);
+        return st ? statusForState(st) : 'idle';
+    }
+
+    /**
+     * win32 verification-based submit. Sends the submit key, waits a gap, and if
+     * the FSM is still 'idle' (the prompt did not submit — the CR was absorbed as
+     * a multiline-paste newline) resends, up to WIN32_SUBMIT_MAX_RESENDS. The
+     * first CR always fires (so a stale/edge status never suppresses the submit);
+     * subsequent resends are gated on still being idle, and stop the instant the
+     * agent leaves idle (submitted → generating / approval). This converges the
+     * nondeterministic multiline window without spamming Enter into the next turn.
+     */
+    private scheduleWin32Submit(submitKey: string, initialDelayMs: number): void {
+        if (this.win32SubmitTimer) { clearTimeout(this.win32SubmitTimer); this.win32SubmitTimer = null; }
+        const fire = (attempt: number): void => {
+            this.win32SubmitTimer = null;
+            this.adapter.send_keys(submitKey);
+            if (attempt + 1 >= WIN32_SUBMIT_MAX_RESENDS) return;
+            this.win32SubmitTimer = setTimeout(() => {
+                // Left the idle composer → it submitted; stop resending.
+                if (this.currentStatus() !== 'idle') { this.win32SubmitTimer = null; return; }
+                fire(attempt + 1);
+            }, WIN32_SUBMIT_RESEND_GAP_MS);
+        };
+        if (initialDelayMs > 0) this.win32SubmitTimer = setTimeout(() => fire(0), initialDelayMs);
+        else fire(0);
+    }
+
     private handleClickControl(controlId: string, payload?: unknown): void {
         const ctl = (this.spec.control_bar ?? []).find(c => c.id === controlId);
         if (!ctl) return;