@adhdev/daemon-core 0.9.82-rc.373 → 0.9.82-rc.375

package/src/mesh/coordinator-prompt.ts

@@ -33,6 +33,49 @@ import type {
 } from '../repo-mesh-types.js';
 import { DEFAULT_MESH_POLICY } from '../repo-mesh-types.js';
 
+/**
+ * Cheap, locally-derived "what just happened" snapshot for the coordinator
+ * prompt. Built at launch from the local ledger + work-queue stats — no remote
+ * peer probe. Surfaces the gap a fresh coordinator otherwise misses: it can't
+ * see recent failures / queue depth until it manually calls mesh_task_history.
+ *
+ * All fields are optional so callers that have nothing to report (or fail to
+ * read the ledger) simply omit the section — the prompt output stays identical
+ * to the pre-activity form in that case.
+ */
+export interface CoordinatorRecentActivity {
+    /** task_failed entries from the recent window, newest last. */
+    recentFailures?: Array<{
+        timestamp?: string;
+        nodeId?: string;
+        /** Short task title/message, already truncated by the caller. */
+        summary?: string;
+    }>;
+    /** Count of task_failed entries inside the recent (30-min) window. */
+    recentFailureCount?: number;
+    /** Pending (unclaimed) tasks in the work queue. */
+    pendingTasks?: number;
+    /** Assigned-but-not-yet-terminal tasks in the work queue. */
+    assignedTasks?: number;
+    /** Stalled tasks recorded in the ledger. */
+    stalledTasks?: number;
+    /** ISO timestamp of the most recent ledger activity, if any. */
+    lastActivityAt?: string | null;
+}
+
+/**
+ * One coordinator operating note — a runtime-accumulated lesson (provider
+ * quirk, pattern to avoid, recovery lesson) persisted in the ledger so it
+ * survives coordinator restarts and is provider-neutral (visible to codex /
+ * hermes / antigravity coordinators, not just Claude's memory).
+ */
+export interface CoordinatorOperatingNote {
+    text: string;
+    category?: 'provider_quirk' | 'pattern_to_avoid' | 'recovery_lesson';
+    createdAt?: string;
+    sourceCoordinator?: string;
+}
+
 // ─── Prompt Builder ─────────────────────────────
 
 export interface CoordinatorPromptContext {
@@ -46,6 +89,18 @@ export interface CoordinatorPromptContext {
      * stays identical to the pre-M3 form in that case.
      */
     missionSection?: string;
+    /**
+     * Gap1: recent ledger/queue activity surfaced so a freshly-launched
+     * coordinator sees recent failures + queue depth without first calling
+     * mesh_task_history. Omitted → no "## Recent Activity" section.
+     */
+    recentActivity?: CoordinatorRecentActivity;
+    /**
+     * Gap2-A: runtime-accumulated operating notes (provider-neutral lessons)
+     * read from the ledger at launch. Omitted/empty → no "## Operating Notes"
+     * section.
+     */
+    operatingNotes?: CoordinatorOperatingNote[];
 }
 
 /**
@@ -132,6 +187,14 @@ Repository: \`${mesh.repoIdentity}\`${mesh.defaultBranch ? `\nDefault branch: \`
         sections.push(ctx.missionSection.trim());
     }
 
+    // ── Recent Activity (Gap1) — only present when there's something to show ──
+    const recentActivity = buildRecentActivitySection(ctx.recentActivity);
+    if (recentActivity) sections.push(recentActivity);
+
+    // ── Operating Notes (Gap2-A) — only present when notes exist ──
+    const operatingNotes = buildOperatingNotesSection(ctx.operatingNotes);
+    if (operatingNotes) sections.push(operatingNotes);
+
     // ── Policy ──
     sections.push(buildPolicySection({ ...DEFAULT_MESH_POLICY, ...(mesh.policy || {}) }));
 
@@ -187,6 +250,8 @@ function readUserPromptFile(cliType: string | undefined, suffix: string): string
  *   {{cliType}}         — coordinator CLI type or empty
  *   {{nodes}}           — full node section (status if known, otherwise config)
  *   {{mission}}         — active mission summary section (empty when none)
+ *   {{recentActivity}}  — recent failures + queue depth section (empty when none)
+ *   {{operatingNotes}}  — accumulated operating notes section (empty when none)
  *   {{policy}}          — full policy section
  *   {{tools}}           — the canonical tools table
  *   {{workflow}}        — the canonical orchestration workflow
@@ -211,6 +276,8 @@ function expandPromptPlaceholders(template: string, ctx: CoordinatorPromptContex
         cliType: coordinatorCliType || '',
         nodes: nodesSection,
         mission: ctx.missionSection?.trim() || '',
+        recentActivity: buildRecentActivitySection(ctx.recentActivity) || '',
+        operatingNotes: buildOperatingNotesSection(ctx.operatingNotes) || '',
         policy: buildPolicySection({ ...DEFAULT_MESH_POLICY, ...(mesh.policy || {}) }),
         tools: TOOLS_SECTION,
         workflow: WORKFLOW_SECTION,
@@ -303,6 +370,83 @@ function indentFollowing(text: string, pad: string): string {
     return [lines[0], ...lines.slice(1).map(l => pad + l)].join('\n');
 }
 
+/**
+ * Gap1 — render the "## Recent Activity" section from the locally-derived
+ * activity snapshot. Returns '' (no section) when there's nothing worth
+ * surfacing: no recent failures, no queued work, no stalls. This keeps a quiet
+ * mesh's prompt identical to the pre-activity form.
+ */
+function buildRecentActivitySection(activity?: CoordinatorRecentActivity): string {
+    if (!activity) return '';
+    const failures = Array.isArray(activity.recentFailures) ? activity.recentFailures : [];
+    const pending = Number.isFinite(activity.pendingTasks) ? Number(activity.pendingTasks) : 0;
+    const assigned = Number.isFinite(activity.assignedTasks) ? Number(activity.assignedTasks) : 0;
+    const stalled = Number.isFinite(activity.stalledTasks) ? Number(activity.stalledTasks) : 0;
+    const recentFailureCount = Number.isFinite(activity.recentFailureCount)
+        ? Number(activity.recentFailureCount)
+        : failures.length;
+
+    // Nothing actionable to show → omit the section entirely.
+    if (failures.length === 0 && pending === 0 && assigned === 0 && stalled === 0 && recentFailureCount === 0) {
+        return '';
+    }
+
+    const lines: string[] = ['## Recent Activity', ''];
+    lines.push('A snapshot of this mesh\'s recent ledger/queue state at launch. Use it to decide what needs attention first; call `mesh_task_history` / `mesh_view_queue` for full detail.');
+    lines.push('');
+
+    const counts: string[] = [];
+    if (pending > 0) counts.push(`**${pending}** pending`);
+    if (assigned > 0) counts.push(`**${assigned}** assigned`);
+    if (stalled > 0) counts.push(`**${stalled}** stalled`);
+    if (recentFailureCount > 0) counts.push(`**${recentFailureCount}** failed in the last 30 min`);
+    if (counts.length) lines.push(`- Queue/ledger: ${counts.join(', ')}.`);
+    if (activity.lastActivityAt) lines.push(`- Last ledger activity: ${activity.lastActivityAt}.`);
+
+    if (failures.length > 0) {
+        // Newest first, capped to the 5 most recent so the prompt stays lean.
+        const recent = failures.slice(-5).reverse();
+        lines.push('', 'Recent failures (newest first):');
+        for (const f of recent) {
+            const when = f.timestamp ? `${f.timestamp} ` : '';
+            const node = f.nodeId ? `node \`${f.nodeId}\`` : 'unknown node';
+            const summary = (f.summary || '').trim();
+            lines.push(`- ${when}${node}${summary ? ` — ${summary}` : ''}`);
+        }
+        lines.push('', '_Check `mesh_task_history` before retrying; repeated failures on the same node mean reassign or escalate, not retry._');
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Gap2-A — render the "## Operating Notes" section from accumulated coordinator
+ * notes. Returns '' when there are none, so a mesh that has never recorded a
+ * note gets the unchanged prompt. Notes are runtime-accumulated lessons that
+ * persist across coordinator restarts and are provider-neutral.
+ */
+function buildOperatingNotesSection(notes?: CoordinatorOperatingNote[]): string {
+    const valid = Array.isArray(notes)
+        ? notes.filter(n => n && typeof n.text === 'string' && n.text.trim())
+        : [];
+    if (valid.length === 0) return '';
+
+    const categoryLabel: Record<string, string> = {
+        provider_quirk: 'provider quirk',
+        pattern_to_avoid: 'pattern to avoid',
+        recovery_lesson: 'recovery lesson',
+    };
+
+    const lines: string[] = ['## Operating Notes', ''];
+    lines.push('Lessons earlier coordinators on this mesh recorded via `mesh_record_note`. Treat them as accumulated operating knowledge — apply them. When you learn a durable lesson (a provider quirk, a pattern to avoid, a recovery lesson), record it with `mesh_record_note` so future coordinators inherit it.');
+    lines.push('');
+    for (const n of valid) {
+        const cat = n.category && categoryLabel[n.category] ? `[${categoryLabel[n.category]}] ` : '';
+        lines.push(`- ${cat}${n.text.trim()}`);
+    }
+    return lines.join('\n');
+}
+
 function buildPolicySection(policy: RepoMeshPolicy): string {
     const rules: string[] = [];
     if (policy.requirePreTaskCheckpoint) rules.push('- Create a git checkpoint **before** starting each task');
@@ -340,6 +484,7 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_read_chat\` | Read recent chat messages from a delegated agent session |
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger — dispatches, completions, failures. Use to understand what has been done before deciding next steps |
+| \`mesh_record_note\` | Record a durable, provider-neutral operating note (provider quirk / pattern to avoid / recovery lesson). Future coordinators see it under "## Operating Notes" at launch |
 | \`mesh_git_status\` | Check git status on a specific node |
 | \`mesh_read_node_logs\` | Fetch a remote node's daemon log tail directly over P2P (grep/since/byte-bounded, secrets redacted) — no session/PowerShell needed to debug a node's daemon |
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |

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

@@ -23,6 +23,7 @@ import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
 import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
+    findTerminalLedgerEvidenceForTask,
     hasDispatchAfterTerminal,
     hasUnterminalDirectDispatchLedgerEntry,
     buildNoProgressCompletionReconciliation,
@@ -393,6 +394,42 @@ function isWeakTerminalLedgerPayload(payload: Record<string, unknown> | undefine
     return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
 }
 
+// (FALSEIDLE-BGCHILD-b) A later genuine completion of the SAME task that carries a
+// substantively different — and fuller — final summary than the recorded terminal is the REAL
+// final that an earlier (false-idle) completion pre-empted, not a duplicate. The background-child
+// false idle is the nasty case the plain isWeakTerminalLedgerPayload supersession misses: the
+// early completion's screen parser DID see a prior/intermediate standard assistant, so it is
+// recorded as a STRONG terminal with a non-empty (but truncated) finalSummary. Without this the
+// providerSessionId/finalSummary dedup below swallows the genuine final and the coordinator is
+// stuck with the truncated mid-turn text forever (the one-shot-consumption symptom). Same-task,
+// new event is genuine, prior terminal summary is a strict prefix of (or otherwise shorter than)
+// the new one → treat as the corrected final and let it through. Conservative: requires the new
+// summary to be genuine evidence AND meaningfully longer, so an identical re-arrival or a SHORTER
+// later summary is still deduped.
+function supersedesTruncatedTerminalSummary(args: {
+    terminalPayload: Record<string, unknown>;
+    metadataEvent: Record<string, unknown>;
+    terminalTaskId: string;
+    eventTaskId: string;
+}): boolean {
+    // Only applies when both name the SAME task (a distinct task is handled by distinctTaskCompletion).
+    if (!args.terminalTaskId || !args.eventTaskId || args.terminalTaskId !== args.eventTaskId) return false;
+    if (!isGenuineCompletionEvidence(args.metadataEvent)) return false;
+    const terminalSummary = readNonEmptyString(args.terminalPayload.finalSummary);
+    const eventSummary = readNonEmptyString(args.metadataEvent.finalSummary);
+    if (!eventSummary) return false;
+    // Identical text → genuine duplicate, keep deduping.
+    if (terminalSummary === eventSummary) return false;
+    // The recorded terminal was a known-weak (false-idle) one → already handled by the weak
+    // supersession path; nothing extra to do here.
+    if (isWeakTerminalLedgerPayload(args.terminalPayload)) return false;
+    // No prior summary at all, or the new summary strictly extends / is meaningfully longer than
+    // the recorded one → the recorded terminal was the truncated pre-emption; supersede it.
+    if (!terminalSummary) return true;
+    if (eventSummary.startsWith(terminalSummary)) return true;
+    return eventSummary.length > terminalSummary.length + 32;
+}
+
 // The latest still-active direct-dispatch taskId for a session, resolved BEFORE the
 // completion flips the dispatch row terminal. Direct dispatches (mesh_send_task) have no
 // work-queue row, so this is the only taskId available to attribute the terminal ledger
@@ -654,6 +691,24 @@ export function tryAssignQueueTask(
         return false;
     }
 
+    const terminal = findTerminalLedgerEvidenceForTask({
+        meshId,
+        taskId: task.id,
+    });
+    if (terminal) {
+        const status = terminal.kind === 'task_completed' ? 'completed' : 'failed';
+        updateTaskStatus(meshId, task.id, status);
+        LOG.info('MeshQueue', `Skipped dispatch for terminal task ${task.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+        traceMeshEventDrop('dispatch_terminal_ledger', {
+            taskId: task.id,
+            sessionId,
+            nodeId,
+            meshId,
+            event: 'agent_command',
+        }, terminal.kind);
+        return false;
+    }
+
     LOG.info('MeshQueue', `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
 
     if (node?.daemonId && components.dispatchMeshCommand) {
@@ -1944,7 +1999,15 @@ function evaluateMeshEventSuppression(
             const terminalTaskId = readNonEmptyString(terminal.payload.taskId);
             const eventTaskId = readNonEmptyString(args.metadataEvent.taskId);
             const distinctTaskCompletion = !!eventTaskId && !!terminalTaskId && eventTaskId !== terminalTaskId;
-            if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion) {
+            // (FALSEIDLE-BGCHILD-b) Same-task genuine completion carrying a fuller summary than the
+            // recorded (truncated, false-idle-pre-empted) terminal supersedes it — see helper.
+            const supersedesTruncatedTerminal = supersedesTruncatedTerminalSummary({
+                terminalPayload: terminal.payload,
+                metadataEvent: args.metadataEvent,
+                terminalTaskId,
+                eventTaskId,
+            });
+            if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion && !supersedesTruncatedTerminal) {
                 const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
                 const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
                 const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);

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

@@ -85,6 +85,29 @@ function isWeakCompletionLedgerPayload(payload: Record<string, unknown> | undefi
     return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
 }
 
+export function findTerminalLedgerEvidenceForTask(args: {
+    meshId: string;
+    taskId?: string;
+    sessionId?: string;
+    nodeId?: string;
+    tail?: number;
+}): { id: string; kind: Extract<MeshLedgerKind, 'task_completed' | 'task_failed' | 'task_stalled'>; payload: Record<string, unknown>; timestamp: string } | null {
+    const taskId = readNonEmptyString(args.taskId);
+    if (!taskId) return null;
+    const entries = readLedgerEntries(args.meshId, { tail: args.tail ?? 500 });
+    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;
+        const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
+        if (terminalTaskId !== taskId) continue;
+        if (entry.kind === 'task_completed' && isWeakCompletionLedgerPayload(entry.payload)) continue;
+        if (args.sessionId && entry.sessionId && entry.sessionId !== args.sessionId) continue;
+        if (!args.sessionId && args.nodeId && entry.nodeId && !meshNodeIdMatches(entry as unknown as MeshNodeIdentified, args.nodeId)) continue;
+        return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+    }
+    return null;
+}
+
 function findDirectDispatchLedgerEntry(args: {
     meshId: string;
     taskId: string;

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

@@ -109,7 +109,7 @@ const MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
 // 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;
+const MESH_COMPLETION_SURFACE_MAX_CHARS = 16000;
 
 /**
  * The worker's final assistant text carried on a completion event — read from

package/src/mesh/mesh-ledger.ts

@@ -44,6 +44,11 @@ export type MeshLedgerKind =
     | 'direct_dispatch_pruned'
     | 'event_held'
     | 'task_reclaimed'
+    // Gap2-A: a coordinator-recorded operating note — a runtime-accumulated
+    // lesson (provider quirk, pattern to avoid, recovery lesson) persisted in
+    // the ledger so it survives coordinator restarts and is provider-neutral.
+    // payload: { text, category?, createdAt?, sourceCoordinator? }
+    | 'coordinator_operating_note'
     ;
 
 export interface MeshLedgerEntry {

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

@@ -58,10 +58,10 @@ import {
 import { readNonEmptyString, readMeshCompletionSummary } from './mesh-events-utils.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { expandDaemonIdForms, daemonIdsEquivalent } from '@adhdev/mesh-shared';
-import { getActiveDirectDispatches, getQueue, reclaimStrandedAssignedTask } from './mesh-work-queue.js';
+import { getActiveDirectDispatches, getQueue, reclaimStrandedAssignedTask, updateTaskStatus } from './mesh-work-queue.js';
 import { readLedgerEntries } from './mesh-ledger.js';
 import { pruneStaleDirectDispatches } from './mesh-active-work.js';
-import { reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
+import { findTerminalLedgerEvidenceForTask, reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
 import { extractFinalAssistantSummaryEvidence } from '../providers/chat-message-normalization.js';
 import type { ChatMessage } from '../types.js';
 
@@ -164,7 +164,12 @@ function daemonHostsMesh(mesh: LocalMeshEntry, daemonIds: string[]): boolean {
     const hostDaemonId = readNonEmptyString(host.hostDaemonId);
     // Host role but no pinned hostDaemonId → treat as host (single-daemon / legacy).
     if (!hostDaemonId) return true;
-    return daemonIds.includes(hostDaemonId);
+    return daemonIdListIncludes(daemonIds, hostDaemonId);
+}
+
+function daemonIdListIncludes(ids: readonly string[], id: string | undefined): boolean {
+    if (!id) return false;
+    return ids.some(candidate => candidate === id || daemonIdsEquivalent(candidate, id));
 }
 
 // Resolve EVERY id-form this daemon answers to FOR A GIVEN MESH: the runtime drain
@@ -183,8 +188,8 @@ function resolveCoordinatorSelfIds(mesh: LocalMeshEntry, drainDaemonIds: string[
     for (const node of mesh.nodes) {
         const nodeDaemonId = readNonEmptyString(node.daemonId);
         const nodeMachineId = readNonEmptyString(node.machineId);
-        const isSelf = (nodeDaemonId && drainDaemonIds.includes(nodeDaemonId))
-            || (nodeMachineId && drainDaemonIds.includes(nodeMachineId));
+        const isSelf = (nodeDaemonId && daemonIdListIncludes(drainDaemonIds, nodeDaemonId))
+            || (nodeMachineId && daemonIdListIncludes(drainDaemonIds, nodeMachineId));
         if (!isSelf) continue;
         if (nodeDaemonId) ids.add(nodeDaemonId);
         if (nodeMachineId) ids.add(nodeMachineId);
@@ -196,10 +201,17 @@ function resolveCoordinatorSelfIds(mesh: LocalMeshEntry, drainDaemonIds: string[
     // this daemon does not make this daemon the host; daemonHostsMesh still honours a
     // foreign hostDaemonId and rejects ownership.
     const hostDaemonId = readNonEmptyString(mesh.meshHost?.hostDaemonId);
-    if (hostDaemonId && ids.has(hostDaemonId)) ids.add(hostDaemonId);
+    if (hostDaemonId && daemonIdListIncludes([...ids], hostDaemonId)) ids.add(hostDaemonId);
     return [...ids];
 }
 
+// Observability: last-seen modal-park state per coordinator session, so we LOG.info
+// only on a TRANSITION (clear → parked, parked → cleared) instead of every 4s tick.
+// Per-process; a restart re-logs the first observation, which is desirable — it
+// re-confirms a coordinator that is still parked after the restart (the exact
+// "restart does not clear it" symptom the operator needs visibility into).
+const coordinatorModalParkState = new Map<string, boolean>();
+
 // Find live CLI coordinator instances on THIS daemon, keyed by mesh.
 function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
     const out: LiveCoordinator[] = [];
@@ -217,6 +229,20 @@ function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
         // and waiting_choice is absent from some of them (see cli-provider-instance).
         const modalParked = status === 'waiting_choice' || status === 'waiting_approval';
         const sessionId = readNonEmptyString(state.instanceId);
+        // Modal-park transition observability: a coordinator entering modal-park is what
+        // begins holding completion events under `modal_parked`; one leaving it is what
+        // drains them. Both transitions were previously SILENT (the operator had no log
+        // to diagnose a stuck/held completion), so emit a single line per edge.
+        const stateKey = `${meshId}::${sessionId || '?'}`;
+        const prevParked = coordinatorModalParkState.get(stateKey);
+        if (prevParked !== modalParked) {
+            coordinatorModalParkState.set(stateKey, modalParked);
+            if (modalParked) {
+                LOG.info('MeshReconcile', `Coordinator ${sessionId || '?'} (mesh ${meshId}) entered modal-park (status=${status}) — terminal events for it will be held until the modal is answered`);
+            } else if (prevParked === true) {
+                LOG.info('MeshReconcile', `Coordinator ${sessionId || '?'} (mesh ${meshId}) left modal-park (status=${status}) — held events will drain on this/next tick`);
+            }
+        }
         out.push({ meshId, instance: inst, sessionId, idle: status === 'idle', modalParked });
     }
     return out;
@@ -358,6 +384,23 @@ function recoverStrandedAssignedDispatches(meshId: string, store: MeshRuntimeSto
         const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? '');
         if (!Number.isFinite(dispatchedAtMs)) continue;              // no dispatch ts → can't age it
         if (nowMs - dispatchedAtMs < ASSIGNED_STRANDED_DEADLINE_MS) continue;  // still in confirm window
+        const terminal = findTerminalLedgerEvidenceForTask({
+            meshId,
+            taskId: row.id,
+        });
+        if (terminal) {
+            const status = terminal.kind === 'task_completed' ? 'completed' : 'failed';
+            updateTaskStatus(meshId, row.id, status);
+            LOG.warn('MeshReconcile', `Skipped stranded reclaim redispatch for terminal task ${row.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+            traceMeshEventDrop('assigned_stranded_terminal_ledger', {
+                taskId: row.id,
+                sessionId: row.assignedSessionId,
+                nodeId: row.assignedNodeId,
+                meshId,
+                event: 'agent:generating_completed',
+            }, terminal.kind);
+            continue;
+        }
         if (store.taskHasConfirmedDelivery(meshId, row.id)) continue;          // dispatched → PHASE 4's job
         const reclaimed = reclaimStrandedAssignedTask(meshId, row.id, {
             reason: 'assigned_stranded_dispatch_unconfirmed',
@@ -577,7 +620,73 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         // force-injected via generatingCoordinators — we never block the deadlock-break.)
         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)`);
+                // ── orphan escape (MUST precede the blanket modal-park hold) ──────────
+                // A modal-parked coordinator with no idle/generating sibling otherwise
+                // wedges EVERY pending event under `modal_parked` until that modal resolves
+                // — including a STRICT-routed completion whose originating coordinator
+                // session is GONE (an orphan: the worktree/session that produced it was
+                // removed, or that coordinator session died). Such an event will never be
+                // deliverable to its target session no matter what the modal-parked sibling
+                // does, so holding it under modal_parked is a permanent-held leak (the very
+                // "data restart re-reproduces it" symptom — the gate is reconstructed live
+                // from the still-parked modal, so a restart does not clear it). Route those
+                // orphan events through the strict-route hold/expire path so the bounded
+                // STRICT_SESSION_MATCH_TTL eventually expires them (recoverable, ledgered)
+                // instead of leaving them held forever. A strict event whose target session
+                // IS live but merely modal-parked is left to the blanket hold below (it is
+                // genuinely transiently blocked, not orphaned).
+                const liveSessionIds = new Set(
+                    meshCoordinators.map(c => readNonEmptyString(c.sessionId)).filter(Boolean),
+                );
+                let orphanEscaped = 0;
+                const hasPendingForOrphanPeek = !store
+                    || (() => { try { return store.pendingEventCount(meshId) > 0; } catch { return true; } })();
+                if (hasPendingForOrphanPeek) {
+                    // Identify which pending event NAMES correspond to orphan-targeted events
+                    // (a strict targetCoordinatorSessionId that matches no live coordinator).
+                    let peeked: readonly PendingMeshCoordinatorEvent[] = [];
+                    try {
+                        peeked = getPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : undefined);
+                    } catch { peeked = []; }
+                    const isOrphan = (e: PendingMeshCoordinatorEvent): boolean => {
+                        const want = readNonEmptyString(e.targetCoordinatorSessionId);
+                        return !!want && !liveSessionIds.has(want);
+                    };
+                    const orphanEventNames = new Set(peeked.filter(isOrphan).map(e => e.event));
+                    if (orphanEventNames.size > 0) {
+                        // The drain filter is event-NAME scoped (not per-row), so draining by the
+                        // orphan event names also pulls any non-orphan event sharing that name. Drain
+                        // them all, then re-route: orphan-targeted events go through the strict-route
+                        // hold/expire path (bounded TTL → eventually ledger-expired, recoverable);
+                        // non-orphan events of the same name are re-queued unchanged (queuedAt
+                        // preserved) so they remain genuinely held for their still-live, modal-parked
+                        // target. This is the same per-event strict routing PHASE 2 does below — just
+                        // reached here because the blanket modal-park short-circuit would otherwise
+                        // wedge the orphans forever.
+                        let drained: PendingMeshCoordinatorEvent[] = [];
+                        try {
+                            drained = drainPendingMeshCoordinatorEvents(
+                                meshId,
+                                drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
+                                { onlyEvents: orphanEventNames },
+                            );
+                        } catch (e: any) {
+                            LOG.warn('MeshReconcile', `Orphan-escape drain failed for mesh ${meshId}: ${e?.message || e}`);
+                            drained = [];
+                        }
+                        for (const pending of drained) {
+                            if (isOrphan(pending)) {
+                                holdOrExpireStrictUnmatchedEvent(pending, readNonEmptyString(pending.targetCoordinatorSessionId), meshId);
+                                orphanEscaped++;
+                            } else {
+                                // Still-live (modal-parked) target — re-queue unchanged so it is held
+                                // for the next modal-resolved tick, exactly like the blanket hold would.
+                                try { queuePendingMeshCoordinatorEvent(pending); } catch { /* best-effort re-queue */ }
+                            }
+                        }
+                    }
+                }
+                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${orphanEscaped > 0 ? `; ${orphanEscaped} orphan-targeted event(s) routed to strict-route TTL` : ''})`);
                 // 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.
@@ -896,7 +1005,7 @@ async function pullRemoteNodeQueues(
         // from ourselves over P2P is both wasteful and a self-dispatch hazard.
         if (!nodeDaemonId) continue;
         if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) continue;
-        if (candidateDaemonIds.includes(nodeDaemonId)) continue;
+        if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) continue;
 
         for (const pendingEventArgs of pulls) {
             let events: unknown;
@@ -972,7 +1081,7 @@ async function reconcileUnterminatedDirectDispatches(
         // A node is local when it has no daemonId, names this daemon, or actually
         // has a live instance here. Anything else is reached over P2P.
         const isLocalNode = !nodeDaemonId
-            || selfIds.includes(nodeDaemonId)
+            || daemonIdListIncludes(selfIds, nodeDaemonId)
             || daemonIdsEquivalent(nodeDaemonId, localDaemonId)
             || !!components.instanceManager.getInstance(sessionId);
 
@@ -1012,6 +1121,32 @@ async function reconcileUnterminatedDirectDispatches(
         const evidence = extractFinalAssistantSummaryEvidence(messages);
         if (!evidence.finalSummary) continue; // no assistant result yet — nothing to attribute
 
+        // STALE-SUMMARY guard (modal-parked / reused-session misattribution): a direct
+        // dispatch frequently reuses a session that already ran a PRIOR task. read_chat
+        // returns the tail of the WHOLE session, so extractFinalAssistantSummaryEvidence
+        // picks the latest user-facing assistant message — which, for a task that has
+        // barely started (the session momentarily reads idle between turns), is the prior
+        // task's final summary. The downstream reconcile proves the summary is after the
+        // LEDGER task_dispatched entry; here we additionally have the AUTHORITATIVE per-task
+        // dispatchedAt (the dispatch-store row, immune to ledger-ordering quirks), so when
+        // the selected transcript message is provably BEFORE this task's own dispatch we
+        // refuse it outright — it is a prior task's summary, not this task's output (the
+        // 2843ms-duration stale-summary bug where task 2e3f501e copy-pasted 4eca2d9d's
+        // summary). When the message carries no usable timestamp we do NOT block here: the
+        // downstream reconcile already rejects a non-JSON summary it cannot prove is
+        // post-dispatch (transcript_not_proven_after_dispatch), and a structured
+        // final_summary_json is self-attributing — so a timeless provider is not
+        // over-blocked while the provable-stale case is still caught.
+        const dispatchedAtMs = Date.parse(readNonEmptyString(dispatch.dispatchedAt));
+        const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? '');
+        if (Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs < dispatchedAtMs) {
+            LOG.info('MeshReconcile', `Stale-summary guard: skipping transcript reconcile for task ${taskId} on node ${nodeId} (mesh ${mesh.id}) — final assistant message (${evidence.transcriptMessageAt}) predates this task's dispatch (${dispatch.dispatchedAt}); it is a prior task's summary`);
+            traceMeshEventDrop('reconcile_stale_summary_before_dispatch', {
+                taskId, sessionId, nodeId, meshId: mesh.id, event: 'agent:generating_completed',
+            }, `transcriptAt=${evidence.transcriptMessageAt} < dispatchedAt=${dispatch.dispatchedAt}`);
+            continue;
+        }
+
         const providerSessionId = readNonEmptyString(payload.providerSessionId);
         const coordinatorDaemonId = selfIds.find(id => !!id);
         try {
@@ -1092,7 +1227,7 @@ async function collectLiveNodesWithSessions(
     return Promise.all(mesh.nodes.map(async (node) => {
         const nodeDaemonId = readNonEmptyString(node.daemonId);
         const isLocalNode = !nodeDaemonId
-            || selfIds.includes(nodeDaemonId)
+            || daemonIdListIncludes(selfIds, nodeDaemonId)
             || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
         let statusResult: unknown;
         try {

package/src/providers/chat-message-normalization.ts

@@ -1,7 +1,7 @@
 import type { ChatMessage } from '../types.js';
 import { flattenContent } from './contracts.js';
 
-export const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4_000;
+export const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16_000;
 
 export function extractFinalSummaryFromMessages(
   messages: ChatMessage[] | null | undefined,