@adhdev/daemon-core 0.9.82-rc.272 → 0.9.82-rc.274

package/dist/mesh/mesh-events-coordinator.d.ts

@@ -28,6 +28,7 @@ export interface MeshQueueTriggerResult {
 }
 export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<MeshQueueTriggerResult>;
 export declare function isMeshCoordinatorEvent(eventName: unknown): eventName is string;
+export declare function shouldForceInjectMeshEvent(eventName: unknown): boolean;
 export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
     success: boolean;
     forwarded: number;
@@ -40,7 +41,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -53,7 +53,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -66,7 +65,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -79,7 +77,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -92,7 +89,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateApproval?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -105,7 +101,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateApproval?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -118,11 +113,9 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateApproval?: undefined;
     duplicateCompletion?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
-    remoteForwarded: boolean;
     suppressed?: undefined;
     intentionalCleanupStop?: undefined;
     terminalLedgerEvidence?: undefined;
@@ -132,19 +125,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-} | {
-    success: boolean;
-    forwarded: number;
-    suppressed?: undefined;
-    intentionalCleanupStop?: undefined;
-    terminalLedgerEvidence?: undefined;
-    terminalLedgerKind?: undefined;
-    duplicateRefineTerminalEvent?: undefined;
-    duplicateApproval?: undefined;
-    duplicateCompletion?: undefined;
-    duplicateStopped?: undefined;
-    error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     error: string;

package/dist/mesh/mesh-events-pending.d.ts

@@ -18,13 +18,6 @@ export declare function readRefineJobId(event: {
     metadataEvent?: Record<string, unknown>;
 } | Record<string, unknown>): string;
 export declare function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent): string;
-/**
- * R3: record that an event was direct-injected into a live coordinator on `coordinatorDaemonId`.
- * That coordinator's own drain (get_pending_mesh_events with the same coordinatorDaemonId) will
- * skip the queued copy, so it receives the event exactly once instead of twice (PTY + poll).
- * Other consumers (unscoped drainers, other daemons) are unaffected — they did not get the inject.
- */
-export declare function markMeshCoordinatorEventDirectDelivered(coordinatorDaemonId: string, event: PendingMeshCoordinatorEvent): void;
 export declare function hasPendingCoordinatorEventDuplicate(event: PendingMeshCoordinatorEvent): boolean;
 export declare function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean;
 /** Drain and return all pending coordinator events for meshId, removing them from disk. */

package/dist/mesh/mesh-events.d.ts

@@ -1,5 +1,6 @@
 export type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
-export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, markMeshCoordinatorEventDirectDelivered, } from './mesh-events-pending.js';
+export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, } from './mesh-events-pending.js';
 export { reconcileDirectDispatchCompletionFromTranscript, } from './mesh-events-stale.js';
+export { setupMeshReconcileLoop, runMeshReconcileTick, } from './mesh-reconcile-loop.js';
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';
 export { tryAssignQueueTask, triggerMeshQueue, handleMeshForwardEvent, setupMeshEventForwarding, isMeshCoordinatorEvent, __resetIdleAutoFastForwardForTests, __resetMeshWorkspaceCacheForTests, } from './mesh-events-coordinator.js';

package/dist/mesh/mesh-missions.d.ts

@@ -50,6 +50,16 @@ export declare function summarizeMissionTasks(meshId: string, missionId: string)
 export declare function summarizeMeshMission(meshId: string, mission: MeshMissionRecord): MeshMissionSummary;
 /** Active mission summaries for mesh_status / coordinator prompt injection. */
 export declare function getActiveMeshMissionSummaries(meshId: string): MeshMissionSummary[];
+/**
+ * Mission summaries for the mesh_status dashboard surface: every active/paused
+ * mission plus a capped, newest-first slice of completed/abandoned history so
+ * the dashboard can render a collapsible "history" section without unbounded
+ * payload growth. Returned newest-first within each group (active/paused first,
+ * then history), so the frontend can split on `status` directly.
+ */
+export declare function getMeshStatusMissionSummaries(meshId: string, options?: {
+    historyLimit?: number;
+}): MeshMissionSummary[];
 /**
  * M3-3: render active missions as a prompt section for {{mission}}.
  * Empty string when no active mission — the prompt stays byte-identical to

package/dist/mesh/mesh-reconcile-loop.d.ts

@@ -0,0 +1,7 @@
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+export declare function runMeshReconcileTick(components: DaemonComponents): Promise<void>;
+interface ReconcileLoopHandle {
+    stop(): void;
+}
+export declare function setupMeshReconcileLoop(components: DaemonComponents): ReconcileLoopHandle;
+export {};

package/dist/repo-mesh-types.d.ts

@@ -11,6 +11,7 @@
  * IMPORTANT: This file must remain runtime-free (types only).
  */
 import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
+import type { MeshMissionSummary } from './mesh/mesh-missions.js';
 export interface RepoMesh {
     id: string;
     name: string;
@@ -337,6 +338,13 @@ export interface RepoMeshStatus {
     nodes: RepoMeshNodeStatus[];
     queue?: RepoMeshQueueStatus;
     ledger?: RepoMeshLedgerStatus;
+    /**
+     * Mission summaries for the dashboard overview. Active/paused missions plus a
+     * capped, newest-first slice of completed/abandoned history. Omitted by older
+     * daemons — the dashboard must treat this as optional and render an empty
+     * state when absent. Split on each entry's `status` for live vs. history.
+     */
+    missions?: MeshMissionSummary[];
 }
 export type { RepoMeshSessionStatus } from '@adhdev/mesh-shared';
 import type { RepoMeshSessionStatus } from '@adhdev/mesh-shared';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.272",
+  "version": "0.9.82-rc.274",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.272",
+    "@adhdev/mesh-shared": "0.9.82-rc.274",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/boot/daemon-lifecycle.ts

@@ -37,6 +37,7 @@ import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import type { IdeProviderInstance } from '../providers/ide-provider-instance.js';
 import { createDefaultGitCommandServices } from '../git/git-commands.js';
 import { setupMeshEventForwarding } from '../mesh/mesh-events.js';
+import { setupMeshReconcileLoop } from '../mesh/mesh-reconcile-loop.js';
 import { loadMeshCoordinatorRegistry } from '../mesh/coordinator-registry.js';
 import { applyProcessHardening } from './process-hardening.js';
 import { installProviderProcessShim } from '../providers/sdk/v1/sandbox/require-whitelist.js';
@@ -117,6 +118,11 @@ export interface DaemonComponents {
     // subscriptions). Injected by daemon-cloud; absent/no-op on standalone. Replaces cloud's
     // former separate instanceManager.onEvent listener so the event path stays single-listener.
     onMeshCoordinatorEventForwarded?: (payload: Record<string, unknown>) => void;
+    // Periodic queue → live-coordinator reconcile loop handle. Set during
+    // initDaemonComponents, stopped during shutdownDaemonComponents. Drives the
+    // single-model (queue + polling) delivery: drains the pending-events queue
+    // on a fixed interval and injects into live CLI coordinators when idle.
+    meshReconcileLoop?: { stop(): void };
 }
 
 export interface DaemonDevSupportOptions {
@@ -341,7 +347,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
     // 10. Start instance ticking
     instanceManager.startTicking(config.tickIntervalMs ?? 5_000);
 
-    const components = {
+    const components: DaemonComponents = {
         providerLoader,
         instanceManager,
         cliManager,
@@ -358,8 +364,14 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         onMeshCoordinatorEventForwarded: config.onMeshCoordinatorEventForwarded,
     };
 
-    // 11. Setup Mesh Event Forwarding
+    // 11. Setup Mesh Event Forwarding (queue persistence) + periodic reconcile loop.
+    // injectMeshSystemMessage now ONLY persists events to the pending-events queue;
+    // the reconcile loop drains that queue on a fixed interval and injects into live
+    // CLI coordinators when idle (and, in cloud mode, pulls remote worker daemons'
+    // queues over P2P). This is the single-model (queue + polling) replacement for the
+    // old spontaneous-forward push paths.
     setupMeshEventForwarding(components);
+    components.meshReconcileLoop = setupMeshReconcileLoop(components);
 
     // 12. Resume any refine jobs that were interrupted by a previous daemon restart.
     setImmediate(() => void router.resumePendingRefineJobsOnStartup());
@@ -404,11 +416,13 @@ export async function shutdownDaemonComponents(components: DaemonComponents): Pr
     const {
         poller, cdpInitializer, agentStreamManager,
         cliManager, instanceManager, cdpManagers,
+        meshReconcileLoop,
     } = components;
 
     // 1. Stop timers
     poller.stop();
     cdpInitializer.stop();
+    try { meshReconcileLoop?.stop(); } catch { /* noop */ }
 
     // 2. Dispose agent stream
     try {

package/src/commands/router.ts

@@ -5259,27 +5259,17 @@ export class DaemonCommandRouter {
             }
 
             case 'launch_cli': {
-                // Worker launch envelope hardening: a mesh worker session must carry
-                // meshCoordinatorDaemonId so completion events route back to the
-                // coordinator (the cloud relay and the daemon-core forwarder both key on
-                // it). mesh_launch_session resolves coordinatorNode.daemonId || ctx.localDaemonId
-                // upstream, but for a freshly-cloned local worktree both can be empty. When the
-                // launch is a coordinator-driven worker on this machine and the id is missing,
-                // stamp this daemon's own id — worker and coordinator are co-located here.
-                {
-                    const launchSettings = (args?.settings && typeof args.settings === 'object')
-                        ? args.settings as Record<string, unknown>
-                        : undefined;
-                    const isMeshWorkerLaunch = !!launchSettings
-                        && (readStringValue(launchSettings.meshNodeFor) || launchSettings.launchedByCoordinator === true);
-                    const hasCoordinatorDaemonId = !!launchSettings && !!readStringValue(launchSettings.meshCoordinatorDaemonId);
-                    if (launchSettings && isMeshWorkerLaunch && !hasCoordinatorDaemonId) {
-                        try {
-                            const localDaemonId = readStringValue(loadConfig().machineId);
-                            if (localDaemonId) launchSettings.meshCoordinatorDaemonId = localDaemonId;
-                        } catch { /* best-effort — launch proceeds without the stamp */ }
-                    }
-                }
+                // The coordinator routing anchor (meshCoordinatorDaemonId) is stamped
+                // upstream by mesh_launch_session, which resolves
+                // coordinatorNode.daemonId || ctx.localDaemonId || ctx.localMachineId and
+                // fail-closes for a remote node when none resolve. We deliberately do NOT
+                // self-stamp this daemon's own id when the field is missing: for a
+                // P2P-relayed remote worker launch, stamping the worker's own id would make
+                // the self-forward gate (mesh-events-coordinator: sameDaemonId) treat the
+                // worker as its own coordinator, suppressing the spontaneous completion-event
+                // forward and leaving the event in the pending inbox until a read_chat
+                // reconcile drains it. If the anchor is genuinely absent here, leave it
+                // absent rather than poison the routing.
                 const launchResult = await this.deps.cliManager.handleCliCommand(cmd, args);
                 // Bug C fix (part 1): when launching a mesh node worker session, surface
                 // bootstrapPending:true if the node's worktree bootstrap is still running.
@@ -8428,6 +8418,8 @@ export class DaemonCommandRouter {
                         nodes: mesh.nodes || [],
                         liveSessionRecords: liveMeshSessions,
                     });
+                    const { getMeshStatusMissionSummaries } = await import('../mesh/mesh-missions.js');
+                    const missions = getMeshStatusMissionSummaries(meshId);
                     const statusResult = {
                         success: true,
                         meshId: mesh.id,
@@ -8470,6 +8462,7 @@ export class DaemonCommandRouter {
                         nodes: nodeStatuses,
                         queue: { tasks: queue, summary: queueSummary },
                         ledger: { entries: ledgerEntries, summary: ledgerSummary },
+                        ...(missions.length > 0 ? { missions } : {}),
                         ...(asyncRefineJobs.length > 0 ? { asyncRefineJobs } : {}),
                         ...(historicalSessions ? { historicalSessions } : {}),
                         ...(pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}),

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

@@ -10,7 +10,7 @@ import { buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, claimNextTask,
 import { fastForwardMeshNode } from './mesh-fast-forward.js';
 import { createSessionDelivery, markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompletionConflict } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, markMeshCoordinatorEventDirectDelivered } from './mesh-events-pending.js';
+import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent } from './mesh-routing.js';
 import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
@@ -27,7 +27,6 @@ import {
     resolveEventSessionId,
     readRefineJobId,
     readWorkerResultMetadata,
-    sameDaemonId,
 } from './mesh-events-utils.js';
 
 // ---------------------------------------------------------------------------
@@ -986,7 +985,7 @@ const MESH_FORCE_INJECT_EVENTS = new Set([
     'worktree_bootstrap_failed',
 ]);
 
-function shouldForceInjectMeshEvent(eventName: unknown): boolean {
+export function shouldForceInjectMeshEvent(eventName: unknown): boolean {
     return typeof eventName === 'string' && MESH_FORCE_INJECT_EVENTS.has(eventName);
 }
 
@@ -1007,7 +1006,6 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     const workerCoordinatorDaemonId = readNonEmptyString(
         (sourceSession?.getState()?.settings as Record<string, unknown>)?.meshCoordinatorDaemonId,
     );
-    const localDaemonId = readNonEmptyString(loadConfig().machineId);
 
     // R2: cloud P2P dashboard metadata sync. The cloud daemon used to do this from its own
     // relay listener; now the single core forwarder invokes the injected hook (no-op on
@@ -1392,82 +1390,24 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     });
     if (!messageText) return { success: false, error: 'unsupported mesh event' };
 
-    const coordinatorInstances = components.instanceManager.getByCategory('cli').filter((inst) => {
-        const instState = inst.getState();
-        if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
-        if (args.sourceInstanceId && instState.instanceId === args.sourceInstanceId) return false;
-        // canonicalize: the worker stamps the prefixed daemon id (standalone_/daemon_) while
-        // localDaemonId is the raw machineId — a literal !== wrongly excludes the local coordinator.
-        if (workerCoordinatorDaemonId && localDaemonId && !sameDaemonId(workerCoordinatorDaemonId, localDaemonId)) return false;
-        return true;
-    });
-
-    if (coordinatorInstances.length === 0) {
-        // R2: the coordinator is not a live instance on THIS daemon. If it lives on a remote
-        // daemon, forward over the injected transport (dispatchMeshCommand, supplied by cloud as
-        // P2P; absent/no-op on standalone). This replaces cloud's separate
-        // relayRemoteMeshCoordinatorEvent listener — remote delivery is now part of the single
-        // core forwarder path, so local-vs-remote is one code path and standalone == cloud for
-        // the local case. The pending queue remains the fallback when there is no remote target
-        // or the transport send fails (e.g. P2P down), so MCP coordinators can still backfill.
-        const remoteCoordinatorDaemonId = workerCoordinatorDaemonId && localDaemonId && !sameDaemonId(workerCoordinatorDaemonId, localDaemonId)
-            ? workerCoordinatorDaemonId
-            : '';
-        if (remoteCoordinatorDaemonId && components.dispatchMeshCommand) {
-            const forwardPayload: Record<string, unknown> = {
-                event: args.event,
-                meshId: args.meshId,
-                nodeId: args.nodeId || undefined,
-                workspace: readNonEmptyString(args.metadataEvent.workspace),
-                ...args.metadataEvent,
-                ...(recoveryContext ? { recoveryContext } : {}),
-            };
-            components.dispatchMeshCommand(remoteCoordinatorDaemonId, 'mesh_forward_event', forwardPayload)
-                .then(() => {
-                    LOG.info('MeshEvents', `Forwarded ${args.event} for mesh ${args.meshId} to remote coordinator daemon ${remoteCoordinatorDaemonId.slice(0, 12)}…`);
-                })
-                .catch((error: any) => {
-                    LOG.warn('MeshEvents', `Remote forward of ${args.event} failed (${error?.message || error}); queuing for backfill`);
-                    queuePendingMeshCoordinatorEvent({
-                        event: args.event,
-                        meshId: args.meshId,
-                        nodeLabel: args.nodeLabel,
-                        nodeId: args.nodeId || undefined,
-                        workspace: readNonEmptyString(args.metadataEvent.workspace),
-                        metadataEvent: { ...args.metadataEvent, ...(recoveryContext ? { recoveryContext } : {}) },
-                        coordinatorMessage: messageText,
-                        queuedAt: Date.now(),
-                        targetCoordinatorDaemonId: remoteCoordinatorDaemonId,
-                    });
-                });
-            return { success: true, forwarded: 0, remoteForwarded: true };
-        }
-        if (queuePendingMeshCoordinatorEvent({
-                event: args.event,
-                meshId: args.meshId,
-                nodeLabel: args.nodeLabel,
-                nodeId: args.nodeId || undefined,
-                workspace: readNonEmptyString(args.metadataEvent.workspace),
-                metadataEvent: {
-                    ...args.metadataEvent,
-                    ...(recoveryContext ? { recoveryContext } : {}),
-                },
-                coordinatorMessage: messageText,
-                queuedAt: Date.now(),
-                ...(workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}),
-            })) {
-            LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ''})`);
-        }
-        return { success: true, forwarded: 0 };
-    }
-
-    // All events — terminal and non-terminal — are queued for MCP coordinator
-    // delivery via the pending-events file/SQLite path. This ensures that MCP
-    // coordinators (which poll via get_pending_mesh_events / mesh_status) always
-    // receive terminal events even when a live CLI coordinator session is present.
-    // Previously, terminal events skipped the queue and were only direct-injected
-    // into live CLI coordinators via send_message, which silently dropped them
-    // when the coordinator was in a generating state.
+    // ── Queue-only delivery (single-model: queue + periodic poll) ──────────────
+    // Every mesh coordinator event — terminal or not, local-coordinator or
+    // remote — is persisted to the pending-events queue (SQLite + JSONL) and
+    // NOTHING is pushed here. The old spontaneous-forward paths were removed:
+    //   - F1 remote P2P `mesh_forward_event` dispatch (network/stamp-dependent,
+    //     silently dropped on P2P failure or missing meshCoordinatorDaemonId)
+    //   - F3 live-CLI PTY `send_message` fire-and-forget inject (silently
+    //     dropped when the coordinator was generating)
+    // Delivery to a live CLI coordinator now happens via setupMeshReconcileLoop,
+    // which drains this queue on a fixed interval and injects into the coordinator
+    // only when it is idle. A pure stdio MCP (LLM) coordinator — which has no live
+    // CLI session to inject into — drains the queue itself when it calls a mesh
+    // tool (mesh_status / mesh_read_chat). Either way the queue is the single
+    // source of truth and the only thing this function writes to.
+    //
+    // targetCoordinatorDaemonId scopes the event to a specific coordinator daemon
+    // (unicast) when the worker carries one, so the reconcile loop on the right
+    // daemon drains it and other daemons skip it. Absent → broadcast/backfill.
     const pendingEvent = {
         event: args.event,
         meshId: args.meshId,
@@ -1483,30 +1423,9 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         ...(workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}),
     };
     if (queuePendingMeshCoordinatorEvent(pendingEvent)) {
-        LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
-    }
-
-    // R3: the live coordinators below receive this event directly in their PTY. They (or their
-    // MCP client) also poll get_pending_mesh_events with coordinatorDaemonId = this daemon, which
-    // would re-deliver the queued copy → the user saw the same completion twice. Mark the event
-    // direct-delivered to THIS daemon so that coordinator's own drain skips it. The queue entry
-    // stays for every OTHER consumer (idle / MCP-only / remote) that did not get the direct inject.
-    // markMeshCoordinatorEventDirectDelivered canonicalizes the id internally so the raw
-    // machineId here matches the prefixed instanceId (standalone_mach_X) the coordinator drains with.
-    if (localDaemonId) {
-        markMeshCoordinatorEventDirectDelivered(localDaemonId, pendingEvent);
-    }
-
-    const forceInject = shouldForceInjectMeshEvent(args.event);
-    for (const coord of coordinatorInstances) {
-        const coordState = coord.getState();
-        LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}${forceInject ? ' (force)' : ''}`);
-        coord.onEvent('send_message', {
-            input: { text: messageText, textFallback: messageText },
-            ...(forceInject ? { force: true } : {}),
-        });
+        LOG.info('MeshEvents', `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ''})`);
     }
-    return { success: true, forwarded: coordinatorInstances.length };
+    return { success: true, forwarded: 0 };
 }
 
 export function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>) {
@@ -1563,10 +1482,15 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
 
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
-        // --- Coordinator idle auto-flush ---
-        // When a coordinator session becomes idle, flush any pending coordinator events
-        // that accumulated while it was generating. This runs before the delegate routing
-        // below so that coordinator-own idle transitions are handled first.
+        // --- Coordinator idle auto-flush (fast path) ---
+        // When a coordinator session becomes idle, immediately flush any pending
+        // coordinator events that accumulated while it was generating, rather than
+        // waiting up to one reconcile interval for setupMeshReconcileLoop to do it.
+        // Both paths drain the SAME queue via drainPendingMeshCoordinatorEvents,
+        // whose SQLite drained=1 marking is atomic — whichever fires first consumes
+        // the events and the other gets nothing, so there is no double-delivery.
+        // This runs before the delegate routing below so that coordinator-own idle
+        // transitions are handled first.
         // Exception: a coordinator that is itself a direct-dispatch target still needs
         // to go through delegate routing so that the dispatching coordinator receives a
         // pendingCoordinatorEvents entry for the completion.

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

@@ -4,7 +4,7 @@ import { randomUUID } from 'crypto';
 import { LOG } from '../logging/logger.js';
 import { getLedgerDir, readLedgerEntries } from './mesh-ledger.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { buildMeshSystemMessage, canonicalDaemonId, readNonEmptyString, readRecord, resolveEventSessionId } from './mesh-events-utils.js';
+import { buildMeshSystemMessage, readNonEmptyString, readRecord, resolveEventSessionId } from './mesh-events-utils.js';
 
 // ---------------------------------------------------------------------------
 // MCP coordinator pending-event queue — FILE-BASED PERSISTENCE
@@ -83,46 +83,11 @@ export function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent)
     ].join('::');
 }
 
-// R3: TTL for the direct-delivered marker. A coordinator polls get_pending_mesh_events
-// well within this window after a terminal event; after it expires the marker is swept and
-// a late/duplicate drain would (harmlessly) re-surface — but by then the event is long gone
-// from the queue too. 10 minutes mirrors the completion-fingerprint TTL.
-const DIRECT_DELIVERED_TTL_MS = 10 * 60 * 1000;
-
-/**
- * R3: record that an event was direct-injected into a live coordinator on `coordinatorDaemonId`.
- * That coordinator's own drain (get_pending_mesh_events with the same coordinatorDaemonId) will
- * skip the queued copy, so it receives the event exactly once instead of twice (PTY + poll).
- * Other consumers (unscoped drainers, other daemons) are unaffected — they did not get the inject.
- */
-export function markMeshCoordinatorEventDirectDelivered(
-    coordinatorDaemonId: string,
-    event: PendingMeshCoordinatorEvent,
-): void {
-    // Canonicalize so the raw machineId used at inject time and the prefixed instanceId the
-    // coordinator drains with resolve to the same key.
-    const canonical = canonicalDaemonId(coordinatorDaemonId);
-    if (!canonical) return;
-    const fingerprint = buildPendingEventFingerprint(event);
-    if (!fingerprint.trim()) return;
-    try {
-        const store = MeshRuntimeStore.getInstance();
-        store.recordDirectDelivered(canonical, fingerprint, DIRECT_DELIVERED_TTL_MS);
-        store.sweepExpiredDirectDelivered();
-    } catch { /* best-effort — a duplicate is preferable to a crash */ }
-}
-
-function wasDirectDeliveredToCoordinator(coordinatorDaemonId: string, event: PendingMeshCoordinatorEvent): boolean {
-    const canonical = canonicalDaemonId(coordinatorDaemonId);
-    if (!canonical) return false;
-    const fingerprint = buildPendingEventFingerprint(event);
-    if (!fingerprint.trim()) return false;
-    try {
-        return MeshRuntimeStore.getInstance().wasDirectDelivered(canonical, fingerprint);
-    } catch {
-        return false;
-    }
-}
+// NOTE: the former R3 "direct-delivered" marker (markMeshCoordinatorEventDirectDelivered /
+// wasDirectDeliveredToCoordinator) was removed when spontaneous PTY direct-inject was retired.
+// Delivery is now queue-drain-only: an event is consumed by exactly one drainer via the atomic
+// SQLite drained=1 marking, so there is no PTY-vs-poll double-delivery left to dedup against.
+// The dormant mesh_direct_delivered_events table / store helpers remain (harmless) but unused.
 
 export function hasPendingCoordinatorEventDuplicate(event: PendingMeshCoordinatorEvent): boolean {
     const fingerprint = buildPendingEventFingerprint(event);
@@ -362,14 +327,11 @@ export function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDa
         for (const event of filtered) pushUnique(event);
     }
     if (merged.length === 0) return [];
-    // R3: when this drain is scoped to a coordinator daemon, exclude events that were already
-    // direct-injected into that coordinator's live CLI session. Unscoped drains (no daemon id)
-    // keep everything — they belong to consumers that never received the direct inject.
-    const deliverable = coordinatorDaemonId
-        ? merged.filter(event => !wasDirectDeliveredToCoordinator(coordinatorDaemonId, event))
-        : merged;
-    if (deliverable.length === 0) return [];
-    return reconcilePendingMeshCoordinatorEvents(meshId, deliverable);
+    // (Former R3 direct-delivered dedup removed.) Spontaneous PTY direct-inject no
+    // longer exists — delivery is now queue-drain-only (reconcile loop or MCP pull),
+    // so an event is consumed by exactly one drainer via the atomic SQLite drained=1
+    // marking. There is no PTY-vs-poll double path left to dedup against.
+    return reconcilePendingMeshCoordinatorEvents(meshId, merged);
 }
 
 /** Peek at pending coordinator events without draining (non-destructive). */
@@ -404,13 +366,9 @@ export function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaem
         pushUnique(event);
     }
 
-    // R3: hide events already direct-delivered to this coordinator from its status peek, so
-    // mesh_status doesn't report a "pending" event the coordinator has in fact already received.
-    const deliverable = coordinatorDaemonId
-        ? merged.filter(event => !wasDirectDeliveredToCoordinator(coordinatorDaemonId, event))
-        : merged;
-
-    return reconcilePendingMeshCoordinatorEvents(meshId, deliverable);
+    // (Former R3 direct-delivered filter removed — no PTY direct-inject path exists
+    // anymore, so a peeked pending event has genuinely not yet been consumed.)
+    return reconcilePendingMeshCoordinatorEvents(meshId, merged);
 }
 
 /**

package/src/mesh/mesh-events.ts

@@ -11,13 +11,17 @@ export {
     drainPendingMeshCoordinatorEvents,
     getPendingMeshCoordinatorEvents,
     clearPendingMeshCoordinatorEvents,
-    markMeshCoordinatorEventDirectDelivered,
 } from './mesh-events-pending.js';
 
 export {
     reconcileDirectDispatchCompletionFromTranscript,
 } from './mesh-events-stale.js';
 
+export {
+    setupMeshReconcileLoop,
+    runMeshReconcileTick,
+} from './mesh-reconcile-loop.js';
+
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';
 export {
     tryAssignQueueTask,

package/src/mesh/mesh-missions.ts

@@ -125,6 +125,27 @@ export function getActiveMeshMissionSummaries(meshId: string): MeshMissionSummar
     return getMeshMissions(meshId, ['active']).map(mission => summarizeMeshMission(meshId, mission));
 }
 
+/**
+ * Mission summaries for the mesh_status dashboard surface: every active/paused
+ * mission plus a capped, newest-first slice of completed/abandoned history so
+ * the dashboard can render a collapsible "history" section without unbounded
+ * payload growth. Returned newest-first within each group (active/paused first,
+ * then history), so the frontend can split on `status` directly.
+ */
+export function getMeshStatusMissionSummaries(
+    meshId: string,
+    options?: { historyLimit?: number },
+): MeshMissionSummary[] {
+    const historyLimit = Math.max(0, options?.historyLimit ?? 10);
+    const all = getMeshMissions(meshId);
+    const live = all.filter(m => m.status === 'active' || m.status === 'paused');
+    const history = all
+        .filter(m => m.status === 'completed' || m.status === 'abandoned')
+        .sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''))
+        .slice(0, historyLimit);
+    return [...live, ...history].map(mission => summarizeMeshMission(meshId, mission));
+}
+
 /**
  * M3-3: render active missions as a prompt section for {{mission}}.
  * Empty string when no active mission — the prompt stays byte-identical to