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

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

@@ -21,6 +21,47 @@
  * a static prompt, which is also fine.
  */
 import type { LocalMeshEntry, RepoMeshStatus } 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;
+}
 export interface CoordinatorPromptContext {
     mesh: LocalMeshEntry;
     status?: RepoMeshStatus;
@@ -32,6 +73,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[];
 }
 /**
  * Compose the final coordinator prompt from four layers, in this precedence:

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

@@ -14,7 +14,7 @@
  */
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed' | 'coordinator_operating_note';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;

package/dist/providers/cli-provider-instance.d.ts

@@ -87,6 +87,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private runtimeMessages;
     private lastPersistedHistoryMessages;
     private lastAcknowledgedUserInputAt;
+    private recentUserInputAcks;
     private lastNativeSourceCanonicalCheckAt;
     private lastNativeSourceCanonicalCacheKey;
     private cachedSqliteDb;
@@ -168,6 +169,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     isModalParked(): boolean;
     onEvent(event: string, data?: any): void;
     recordAcknowledgedUserInput(input: InputEnvelope | string): void;
+    /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
+    private pruneRecentUserInputAcks;
     dispose(): void;
     private completedDebounceTimer;
     private completedDebouncePending;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.374",
+  "version": "0.9.82-rc.375",
   "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.374",
+    "@adhdev/mesh-shared": "0.9.82-rc.375",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/high-family/mesh-coordinator-launch.ts

@@ -59,6 +59,71 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                         try { return buildMissionPromptSection(id); } catch { return ''; }
                     };
 
+                    // Gap1: surface recent ledger/queue activity (recent failures +
+                    // queue depth) so a freshly-launched coordinator sees them
+                    // without first calling mesh_task_history. All cheap local reads
+                    // — no remote peer probe. Best-effort: a read failure just omits
+                    // the section, never blocks launch.
+                    const buildRecentActivityBestEffort = async (id: string) => {
+                        try {
+                            const { getLedgerSummary, readLedgerEntries } = await import('../../mesh/mesh-ledger.js');
+                            const { getMeshQueueStats } = await import('../../mesh/mesh-work-queue.js');
+                            const summary = getLedgerSummary(id);
+                            const queue = getMeshQueueStats(id);
+                            const failureEntries = readLedgerEntries(id, { kind: ['task_failed'], tail: 5 });
+                            const recentFailures = failureEntries.map((e) => {
+                                const p = (e.payload || {}) as Record<string, unknown>;
+                                const raw = typeof p.taskSummary === 'string' ? p.taskSummary
+                                    : typeof p.message === 'string' ? p.message
+                                    : typeof p.error === 'string' ? p.error
+                                    : '';
+                                const summaryText = raw.length > 160 ? `${raw.slice(0, 160)}…` : raw;
+                                return {
+                                    timestamp: e.timestamp,
+                                    nodeId: e.nodeId,
+                                    summary: summaryText,
+                                };
+                            });
+                            return {
+                                recentFailures,
+                                recentFailureCount: summary.recentFailures,
+                                pendingTasks: queue.pending,
+                                assignedTasks: queue.assigned,
+                                stalledTasks: summary.taskStalled,
+                                lastActivityAt: summary.lastActivityAt,
+                            };
+                        } catch { return undefined; }
+                    };
+
+                    // Gap2-A: load accumulated operating notes (provider-neutral
+                    // lessons) from the ledger so they ride into the prompt. Newest
+                    // last; cap to the most recent 20 so the section stays lean.
+                    // Best-effort: a read failure just omits the section.
+                    const buildOperatingNotesBestEffort = async (id: string) => {
+                        try {
+                            const { readLedgerEntries } = await import('../../mesh/mesh-ledger.js');
+                            const noteEntries = readLedgerEntries(id, { kind: ['coordinator_operating_note'], tail: 20 });
+                            const notes = noteEntries
+                                .map((e) => {
+                                    const p = (e.payload || {}) as Record<string, unknown>;
+                                    const text = typeof p.text === 'string' ? p.text.trim() : '';
+                                    if (!text) return null;
+                                    const category: 'provider_quirk' | 'pattern_to_avoid' | 'recovery_lesson' | undefined =
+                                        p.category === 'provider_quirk' || p.category === 'pattern_to_avoid' || p.category === 'recovery_lesson'
+                                            ? p.category
+                                            : undefined;
+                                    return {
+                                        text,
+                                        category,
+                                        createdAt: typeof p.createdAt === 'string' ? p.createdAt : e.timestamp,
+                                        sourceCoordinator: typeof p.sourceCoordinator === 'string' ? p.sourceCoordinator : undefined,
+                                    };
+                                })
+                                .filter((n): n is NonNullable<typeof n> => n !== null);
+                            return notes.length ? notes : undefined;
+                        } catch { return undefined; }
+                    };
+
                     // Support inline mesh data from cloud (bypasses local meshes.json lookup)
                     let mesh: any;
                     if (args?.inlineMesh && typeof args.inlineMesh === 'object') {
@@ -164,7 +229,7 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                         // Build coordinator prompt first — fail closed on errors.
                         let cliCmdSystemPrompt = '';
                         try {
-                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id) });
+                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildOperatingNotesBestEffort(mesh.id) });
                         } catch (error: any) {
                             const message = error?.message || String(error);
                             LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);
@@ -382,7 +447,7 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                     // broken mesh state is visible instead of silently launching with weaker rules.
                     let systemPrompt = '';
                     try {
-                        systemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id) });
+                        systemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildOperatingNotesBestEffort(mesh.id) });
                     } catch (error: any) {
                         const message = error?.message || String(error);
                         LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);

package/src/commands/med-family/cli-agent.ts

@@ -96,15 +96,22 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
                 } catch { /* best-effort — dispatch still proceeds without the stamp */ }
             }
         }
-        const agentResult = await ctx.deps.cliManager.handleCliCommand('agent_command', args);
-        // Bug C fix (part 2): when dispatching a task to a mesh node session, override
-        // the dispatch acknowledgement risk reason to 'bootstrap_still_running' when
-        // the target node's worktree bootstrap is still running. Informational only —
-        // dispatch is NOT blocked.
+        // Bug C fix / bootstrapPending dispatch gap: a task dispatched to a mesh node
+        // whose worktree bootstrap is STILL running must NOT be injected yet. Before this
+        // gate the dispatch proceeded and the prompt landed in the session's input buffer
+        // while the provider (e.g. claude CLI) was not yet ready to consume it — the inject
+        // was silently swallowed (the chat bubble showed the text but the session never
+        // transitioned to generating and never claimed the task). The prior code only
+        // ANNOTATED the already-completed dispatch with 'bootstrap_still_running' after the
+        // fact, which did not close the gap. Defer instead: refuse the inject with a
+        // recoverable signal so the coordinator re-sends once the node is ready (the
+        // confirmed "re-send to a ready session works" path), mirroring the queued-delivery
+        // contract for busy sessions. send_chat only — non-task actions still pass through.
         const meshCtx = args?.meshContext as Record<string, unknown> | undefined;
         const dispatchNodeId = readStringValue(meshCtx?.nodeId);
         const dispatchMeshId = readStringValue(meshCtx?.meshId);
-        if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
+        const isSendChat = args?.action === 'send_chat';
+        if (isSendChat && dispatchNodeId && dispatchMeshId) {
             try {
                 const { getMesh } = await import('../../config/mesh-config.js');
                 const meshObj = getMesh(dispatchMeshId) ?? ctx.getCachedInlineMesh(dispatchMeshId);
@@ -114,16 +121,21 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
                 const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
                 if (bootstrapStatus === 'running') {
                     return {
-                        success: true,
-                        ...agentResult,
-                        dispatchAcknowledgementRisk: true,
-                        dispatchAcknowledgementRiskReason: 'bootstrap_still_running',
-                        nextAction: 'Wait for worktree_bootstrap_complete event before dispatching work to this node.',
+                        success: false,
+                        recoverable: true,
+                        dispatched: false,
+                        code: 'mesh_node_bootstrap_pending',
+                        reason: 'bootstrap_still_running',
+                        nodeId: dispatchNodeId,
+                        meshId: dispatchMeshId,
+                        ...(readStringValue(meshCtx?.taskId) ? { taskId: readStringValue(meshCtx?.taskId) } : {}),
+                        error: `Node '${dispatchNodeId}' worktree bootstrap is still running; a task injected now would land in the session input buffer before the provider is ready to consume it and be silently lost. Dispatch deferred.`,
+                        nextAction: 'Wait for the worktree_bootstrap_complete event (or poll mesh_status until the node session is ready), then re-send the task with mesh_send_task. Alternatively use mesh_enqueue_task so the queue auto-assigns it once a ready session is available.',
                     };
                 }
-            } catch { /* best-effort */ }
+            } catch { /* best-effort — if the bootstrap probe fails, fall through and dispatch */ }
         }
-        return agentResult;
+        return ctx.deps.cliManager.handleCliCommand('agent_command', args);
     },
 
     // ─── Logs ───

package/src/commands/med-family/fast-forward.ts

@@ -51,58 +51,90 @@ export const fastForwardHandlers: Record<string, MedFamilyHandler> = {
     },
 
     fast_forward_mesh_node: async (ctx: MedFamilyContext, args: any) => {
-        const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-        const nodeId = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
-        let workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
-        let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths)
-            ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
-            : undefined;
-        let nodeDaemonId: string | undefined;
-        let allowAutoPublishSubmoduleMainCommits = false;
-        if (meshId && nodeId) {
-            // preferInline so fast-forward can resolve inline-cache-only clone worktree nodes.
-            const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-            const mesh = meshRecord?.mesh;
-            const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-            if (!workspace) {
-                workspace = typeof node?.workspace === 'string' ? node.workspace.trim() : '';
+        // The whole handler is wrapped: the safety-gate evaluation (mesh resolution,
+        // git status/stash/submodule fan-out) can throw on some platforms — notably a
+        // win32 daemon whose git invocation parsing or slow submodule probe raises
+        // before fastForwardMeshNode's own guarded body runs. router.execute re-throws,
+        // so an escaping throw surfaces to the coordinator as an opaque
+        // "Daemon IPC command failed" instead of the structured blockingReasons result
+        // a mac node returns cleanly. Catch it and return the same blocked shape so the
+        // coordinator can read the reason and route, never an IPC crash. Mirrors the
+        // mesh_init handler's try-catch contract.
+        const workspaceForError = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
+        const meshIdForError = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+        const nodeIdForError = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
+        try {
+            const meshId = meshIdForError;
+            const nodeId = nodeIdForError;
+            let workspace = workspaceForError;
+            let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths)
+                ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
+                : undefined;
+            let nodeDaemonId: string | undefined;
+            let allowAutoPublishSubmoduleMainCommits = false;
+            if (meshId && nodeId) {
+                // preferInline so fast-forward can resolve inline-cache-only clone worktree nodes.
+                const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+                const mesh = meshRecord?.mesh;
+                const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
+                if (!workspace) {
+                    workspace = typeof node?.workspace === 'string' ? node.workspace.trim() : '';
+                }
+                if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
+                    submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string');
+                }
+                allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
+                nodeDaemonId = typeof node?.daemonId === 'string' ? node.daemonId.trim() : undefined;
             }
-            if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
-                submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string');
+            // If the target node belongs to a remote daemon, forward the command there.
+            // _meshDirectDispatch prevents re-forwarding (and P2P self-dial) when the stored
+            // daemonId uses a legacy format that doesn't match the receiving daemon's identity.
+            const selfDaemonId = ctx.deps.statusInstanceId;
+            // daemonIdsEquivalent: a legacy-form stored daemonId that resolves to THIS
+            // machine's core must be treated as local (not remote) so it is not forwarded /
+            // P2P self-dialed. Equivalent → local.
+            const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+            if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+                const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId!, 'fast_forward_mesh_node', {
+                    ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+                    workspace,
+                    _meshDirectDispatch: true,
+                });
+                return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
             }
-            allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
-            nodeDaemonId = typeof node?.daemonId === 'string' ? node.daemonId.trim() : undefined;
-        }
-        // If the target node belongs to a remote daemon, forward the command there.
-        // _meshDirectDispatch prevents re-forwarding (and P2P self-dial) when the stored
-        // daemonId uses a legacy format that doesn't match the receiving daemon's identity.
-        const selfDaemonId = ctx.deps.statusInstanceId;
-        // daemonIdsEquivalent: a legacy-form stored daemonId that resolves to THIS
-        // machine's core must be treated as local (not remote) so it is not forwarded /
-        // P2P self-dialed. Equivalent → local.
-        const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
-        if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
-            const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId!, 'fast_forward_mesh_node', {
-                ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+            const result = await (fastForwardMeshNode({
+                meshId: meshId || undefined,
+                nodeId: nodeId || undefined,
                 workspace,
-                _meshDirectDispatch: true,
-            });
-            return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
+                branch: typeof args?.branch === 'string' ? args.branch : undefined,
+                execute: args?.execute === true,
+                dryRun: args?.dryRun === true,
+                updateSubmodules: args?.updateSubmodules === true,
+                submoduleIgnorePaths,
+                mode: args?.mode === 'push' ? 'push' : 'merge',
+                pushSubmodules: args?.pushSubmodules === true,
+                allowAutoPublishSubmoduleMainCommits,
+            }) as Promise<unknown>);
+            return result as CommandRouterResult;
+        } catch (e: any) {
+            const errorMessage = e?.message || String(e);
+            return {
+                success: false,
+                code: 'fast_forward_safety_gate_error',
+                ...(meshIdForError ? { meshId: meshIdForError } : {}),
+                ...(nodeIdForError ? { nodeId: nodeIdForError } : {}),
+                workspace: workspaceForError,
+                mode: args?.mode === 'push' ? 'push' : 'merge',
+                allowed: false,
+                willRun: false,
+                executed: false,
+                // Surface the throw as a blocking reason instead of an opaque IPC crash
+                // so the coordinator gets the same structured shape a clean node returns.
+                blockingReasons: ['fast_forward_safety_gate_error'],
+                operationError: errorMessage,
+                error: errorMessage,
+            } as CommandRouterResult;
         }
-        const result = await (fastForwardMeshNode({
-            meshId: meshId || undefined,
-            nodeId: nodeId || undefined,
-            workspace,
-            branch: typeof args?.branch === 'string' ? args.branch : undefined,
-            execute: args?.execute === true,
-            dryRun: args?.dryRun === true,
-            updateSubmodules: args?.updateSubmodules === true,
-            submoduleIgnorePaths,
-            mode: args?.mode === 'push' ? 'push' : 'merge',
-            pushSubmodules: args?.pushSubmodules === true,
-            allowAutoPublishSubmoduleMainCommits,
-        }) as Promise<unknown>);
-        return result as CommandRouterResult;
     },
 
     refine_mesh_node: async (ctx: MedFamilyContext, args: any) => {

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 |