@adhdev/daemon-core 0.9.82-rc.48 → 0.9.82-rc.481

package/src/mesh/mesh-ledger.ts

@@ -13,11 +13,18 @@
  * Safety:  mode 0o600, atomic append via appendFileSync
  */
 
-import { existsSync, mkdirSync, readFileSync, appendFileSync, statSync, renameSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, renameSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { randomUUID } from 'crypto';
 import { getConfigDir } from '../config/config.js';
+import { daemonIdsEquivalent, sessionIdsEquivalent } from '@adhdev/mesh-shared';
 import { EventEmitter } from 'events';
+import { MeshRuntimeStore } from './mesh-runtime-store.js';
+import {
+    coordinatorIdentityFromEmitFields,
+    MESH_PROTOCOL_VERSION_V2,
+    type MeshLedgerOriginatingCoordinatorV2,
+} from './contracts.js';
 // ─── Types ──────────────────────────────────────
 
 export type MeshLedgerKind =
@@ -26,16 +33,55 @@ export type MeshLedgerKind =
     | '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'
+    // Audit marker written by mesh_requeue_held_events when a recoverable `event_held`
+    // entry is restored to the pending queue (event_held→pending). Keyed by the source
+    // held-ledger-entry id so a second requeue pass skips already-recovered entries
+    // (no double-requeue). payload: { heldEntryId, event, requeued: boolean, reason?, dedupSuppressed?: boolean }
+    | 'event_held_requeued'
+    | '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'
+    // Retraction of a coordinator_operating_note. Append-only (history preserved);
+    // readers filter out the targeted note so it leaves the prompt/list. Targets by
+    // note id (exact) and/or by trimmed-text fingerprint (matches all notes with that
+    // text). payload: { targetNoteId?, targetFingerprint?, reason?, forgottenAt? }
+    | 'coordinator_operating_note_tombstone'
+    // Mission audit trail: mission record mutations (mesh_mission_upsert) so the
+    // ledger captures mission lifecycle, not just task events. Without these a
+    // mission create / goal rewrite / status transition left no ledger trace,
+    // breaking audit continuity and post-restart recovery.
+    // mission_created       payload: { missionId, title, goalSummary, goalLength, goalTruncated, status }
+    // mission_status_changed payload: { missionId, title, fromStatus, toStatus }
+    // mission_goal_updated  payload: { missionId, title, prevGoalSummary, nextGoalSummary, prevGoalLength, nextGoalLength, goalTruncated }
+    | 'mission_created'
+    | 'mission_status_changed'
+    | 'mission_goal_updated'
+    // MAGI (Multi-Agent Ground-truth Insight) cross-verification activity. Persisted
+    // so a wait=false fan-out and its later synthesis survive coordinator restarts and
+    // are foldable into mesh_status (keyed by consensusGroupId).
+    // magi_dispatched payload: { source:'magi', consensusGroupId, missionId?, panel?, question?, replicaCount }
+    // magi_synthesis  payload: { source:'magi', consensusGroupId, missionId?, panel?, question?, synthesis }
+    | 'magi_dispatched'
+    | 'magi_synthesis'
     ;
 
 export interface MeshLedgerEntry {
@@ -61,6 +107,51 @@ export function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind
             || payload.source === 'mesh_remove_node');
 }
 
+export type MeshWorkerResultStatus = 'completed' | 'failed' | 'blocked' | 'partial' | 'unknown';
+export type MeshProcessArtifactKind = 'process' | 'log' | 'port' | 'window' | 'session' | 'file' | 'url' | 'other';
+
+export interface MeshValidationResultArtifact {
+    command?: string;
+    status: 'passed' | 'failed' | 'skipped' | 'unknown';
+    durationMs?: number;
+    outputPath?: string;
+    summary?: string;
+}
+
+export interface MeshProcessArtifact {
+    kind: MeshProcessArtifactKind;
+    id?: string;
+    label?: string;
+    locator?: string;
+    pid?: number;
+    port?: number;
+    url?: string;
+    path?: string;
+    sessionId?: string;
+    keepRunning?: boolean;
+    metadata?: Record<string, unknown>;
+}
+
+export interface MeshWorkerResultArtifact {
+    status: MeshWorkerResultStatus;
+    classification?: string;
+    changedFiles: string[];
+    validationResults: MeshValidationResultArtifact[];
+    gitStatus?: Record<string, unknown>;
+    processArtifacts: MeshProcessArtifact[];
+    errors: string[];
+    nextAction?: string;
+    requiresUserAction: boolean;
+    // NOTIF Defect-2b: `parseable_answer` = the final summary held a parseable JSON
+    // ANSWER (e.g. a MAGI claim_audit / rca envelope) that is NOT worker-result-shaped
+    // (no status + changedFiles/errors/…). It is still concrete evidence that the worker
+    // produced a real, parseable answer — so it must NOT be labelled evidenceLevel
+    // 'insufficient' — but it is NOT a self-attributing worker result, so it is deliberately
+    // distinct from 'final_summary_json' and stays subject to the direct-dispatch grace gate
+    // in mesh-events-stale.ts (which keys on `!== 'final_summary_json'`).
+    source: 'explicit_metadata' | 'final_summary_json' | 'parseable_answer' | 'default';
+}
+
 export interface MeshTaskCompletionEvidence {
     source: 'agent_status_event';
     event: 'agent:generating_completed' | 'agent:ready';
@@ -74,6 +165,7 @@ export interface MeshTaskCompletionEvidence {
         providerSessionId?: string;
         finalSummaryAvailable: boolean;
     };
+    workerResult: MeshWorkerResultArtifact;
     git: {
         status: 'deferred';
         reason: string;
@@ -96,6 +188,7 @@ export interface BuildTaskCompletionEvidenceOptions {
     providerType?: string;
     providerSessionId?: string;
     finalSummary?: string;
+    workerResult?: Record<string, unknown>;
     completedAt?: string;
 }
 
@@ -116,6 +209,12 @@ export interface ReadLedgerOptions {
     tail?: number;
     since?: string;
     kind?: MeshLedgerKind[];
+    /**
+     * Filter to entries whose nodeId is equivalent to this daemon id. Matched via
+     * daemonIdsEquivalent (not raw ===) so caller-supplied identifiers in any form
+     * (mach_X vs daemon_mach_X) resolve correctly — see the canon-identity defect class.
+     */
+    node?: string;
 }
 
 export interface ReadLedgerSliceOptions {
@@ -160,11 +259,58 @@ export interface AppendRemoteLedgerResult {
 // ─── Constants ──────────────────────────────────
 
 const LEDGER_DIR_NAME = 'mesh-ledger';
-const MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024; // 10 MB
+const MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024; // 10 MB — full rotation threshold
+const COMPACT_THRESHOLD_BYTES = 2 * 1024 * 1024; // 2 MB — compaction threshold
+const ARCHIVE_TERMINAL_OLDER_THAN_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 const RECENT_FAILURE_WINDOW_MS = 30 * 60 * 1000; // 30 minutes
+
+// Kinds that accumulate indefinitely and are safe to archive after ARCHIVE_TERMINAL_OLDER_THAN_MS.
+// Non-terminal kinds (dispatched, sessions, nodes, checkpoints) are always kept in the active file.
+//
+// session_auto_launch is telemetry, NOT audit: it records the queue-assignment
+// decision on each tick (mostly phase:'skipped' — nothing was launched). No reader
+// consults it back from the ledger (unlike task_dispatched, which getSessionRecoveryContext
+// scans and which therefore MUST stay non-archivable). It is the single largest
+// avoidable ledger consumer after node/dispatch history, so archiving it after the
+// 7-day window is the volume fix — recent entries still surface for diagnosis (and the
+// per-tick dedup keeps live volume bounded), old ones move to the archive JSONL and out
+// of the runtime store. This preserves observability while removing the standing bulk.
+const ARCHIVABLE_KINDS: ReadonlySet<MeshLedgerKind> = new Set([
+    'task_completed',
+    'task_failed',
+    'task_stalled',
+    'recovery_attempted',
+    'session_auto_launch',
+] as MeshLedgerKind[]);
 const DEFAULT_LEDGER_SLICE_LIMIT = 100;
 export const MAX_LEDGER_SLICE_LIMIT = 500;
 
+// ─── Operating-note growth control ──────────────
+// coordinator_operating_note is append-only and, unlike task_* entries, is never
+// archived by compactLedger (it is not in ARCHIVABLE_KINDS — it must survive
+// restarts and there is no time-based cutoff for a "lesson"). Without dedicated
+// controls the note set grows without bound and duplicate/stale notes crowd the
+// bounded tail that rides into the coordinator prompt. These three constants back
+// the three growth controls: dedupe-on-record, tombstone/forget, keep-latest-N.
+
+// Kind marking an operating note as retracted. A tombstone is itself an
+// append-only ledger entry (history is never destroyed); readers filter out the
+// notes it targets. payload: { targetNoteId?, targetFingerprint?, reason? }
+export const OPERATING_NOTE_KIND: MeshLedgerKind = 'coordinator_operating_note';
+export const OPERATING_NOTE_TOMBSTONE_KIND: MeshLedgerKind = 'coordinator_operating_note_tombstone';
+
+// Dedupe window: when recording a note, if the same trimmed text already appears
+// among the most recent OPERATING_NOTE_DEDUPE_WINDOW notes, the record is a no-op
+// (the existing entry is returned). Keeps the prompt tail from filling with the
+// same lesson recorded 20 times.
+export const OPERATING_NOTE_DEDUPE_WINDOW = 40;
+
+// Keep-latest-N: pruneOperatingNotes retains at most this many live (non-tombstoned)
+// operating notes, removing the oldest surplus and any tombstoned notes from the
+// store. The prompt reads a much smaller tail (20), so this bound never trims what
+// a coordinator actually sees while still capping unbounded store growth.
+export const OPERATING_NOTE_KEEP_LATEST = 100;
+
 // ─── Path Helpers ───────────────────────────────
 
 export function getLedgerDir(): string {
@@ -186,8 +332,294 @@ function getRotatedPath(meshId: string, index: number): string {
     return join(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 
+function getArchivePath(meshId: string): string {
+    const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return join(getLedgerDir(), `${safe}.archive.jsonl`);
+}
+
+function getRotatedArchivePath(meshId: string, index: number): string {
+    const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return join(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
+}
+
+function getArchivedCountsPath(meshId: string): string {
+    const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return join(getLedgerDir(), `${safe}.archived-counts.json`);
+}
+
+function rotateArchiveFile(meshId: string, archivePath: string): void {
+    let index = 1;
+    while (existsSync(getRotatedArchivePath(meshId, index))) {
+        index++;
+        if (index > 5) break;
+    }
+    if (index > 5) index = 5;
+    try {
+        renameSync(archivePath, getRotatedArchivePath(meshId, index));
+    } catch (e: any) {
+        process.stderr.write(`[adhdev-mesh] Archive rotation failed for mesh ${meshId}: ${e?.message || e}\n`);
+    }
+}
+
+interface LedgerArchivedCounts {
+    taskCompleted: number;
+    taskFailed: number;
+    taskStalled: number;
+    recoveryAttempted: number;
+    totalArchived: number;
+    lastArchivedAt: string;
+}
+
+function readArchivedCounts(meshId: string): LedgerArchivedCounts {
+    const path = getArchivedCountsPath(meshId);
+    if (!existsSync(path)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: '' };
+    try { return JSON.parse(readFileSync(path, 'utf-8')) as LedgerArchivedCounts; } catch { return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: '' }; }
+}
+
+function updateArchivedCounts(meshId: string, archived: MeshLedgerEntry[]): void {
+    const counts = readArchivedCounts(meshId);
+    for (const e of archived) {
+        if (e.kind === 'task_completed') counts.taskCompleted++;
+        else if (e.kind === 'task_failed') counts.taskFailed++;
+        else if (e.kind === 'task_stalled') counts.taskStalled++;
+        else if (e.kind === 'recovery_attempted') counts.recoveryAttempted++;
+    }
+    counts.totalArchived += archived.length;
+    counts.lastArchivedAt = new Date().toISOString();
+    try { writeFileSync(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: 'utf-8', mode: 0o600 }); } catch { /* best-effort */ }
+}
+
+// ─── Worker Result Footer ───────────────────────
+
+/**
+ * Footer to append to worker task messages so workers output structured results
+ * that the daemon parses via extractJsonObjectFromSummary / normalizeMeshWorkerResult.
+ *
+ * Usage: append buildWorkerTaskFooter() to the task message in mesh_send_task /
+ * mesh_enqueue_task. The coordinator prompt rules instruct coordinators to do this.
+ */
+export function buildWorkerTaskFooter(): string {
+    return `
+
+---
+When your task is done, end your final response with a JSON code block in this exact format (omit fields that don't apply):
+\`\`\`json
+{
+  "status": "completed",
+  "changedFiles": ["src/foo.ts", "tests/foo.test.ts"],
+  "gitStatus": { "branch": "feat/your-branch", "committed": true, "pushed": false },
+  "validationResults": [{ "command": "npm test", "status": "passed" }],
+  "errors": [],
+  "nextAction": "optional guidance for the coordinator"
+}
+\`\`\`
+Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
+}
+
+// ─── Ledger Compaction ──────────────────────────
+
+/**
+ * Compact the active ledger file for a mesh by moving old terminal entries
+ * (task_completed, task_failed, task_stalled, recovery_attempted older than 7 days)
+ * to <meshId>.archive.jsonl, keeping the active file lean.
+ *
+ * Non-terminal entries (dispatch, sessions, node lifecycle) are always retained.
+ * Called automatically from appendLedgerEntry when the file exceeds COMPACT_THRESHOLD_BYTES.
+ */
+export function compactLedger(meshId: string): { archivedCount: number; retainedCount: number } {
+    const filePath = getLedgerPath(meshId);
+    if (!existsSync(filePath)) return { archivedCount: 0, retainedCount: 0 };
+
+    const cutoff = Date.now() - ARCHIVE_TERMINAL_OLDER_THAN_MS;
+    const entries = readLedgerEntries(meshId);
+
+    const keep: MeshLedgerEntry[] = [];
+    const archive: MeshLedgerEntry[] = [];
+    for (const entry of entries) {
+        if (ARCHIVABLE_KINDS.has(entry.kind) && new Date(entry.timestamp).getTime() < cutoff) {
+            archive.push(entry);
+        } else {
+            keep.push(entry);
+        }
+    }
+
+    if (archive.length === 0) return { archivedCount: 0, retainedCount: keep.length };
+
+    // Append archived entries to the archive file, rotate if it exceeds 50MB
+    const archivePath = getArchivePath(meshId);
+    try {
+        if (existsSync(archivePath) && statSync(archivePath).size > 50 * 1024 * 1024) {
+            rotateArchiveFile(meshId, archivePath);
+        }
+        const archiveLines = archive.map(e => JSON.stringify(e)).join('\n') + '\n';
+        appendFileSync(archivePath, archiveLines, { encoding: 'utf-8', mode: 0o600 });
+        updateArchivedCounts(meshId, archive);
+    } catch (e: any) {
+        process.stderr.write(`[adhdev-mesh] Ledger archive write failed for mesh ${meshId}: ${e?.message || e}\n`);
+        return { archivedCount: 0, retainedCount: entries.length };
+    }
+
+    // Rewrite active file with retained entries only
+    try {
+        const keepLines = keep.length ? keep.map(e => JSON.stringify(e)).join('\n') + '\n' : '';
+        writeFileSync(filePath, keepLines, { encoding: 'utf-8', mode: 0o600 });
+        invalidateLedgerCache(meshId);
+    } catch (e: any) {
+        process.stderr.write(`[adhdev-mesh] Ledger compaction rewrite failed for mesh ${meshId}: ${e?.message || e}\n`);
+        return { archivedCount: archive.length, retainedCount: keep.length };
+    }
+
+    // G2: mirror the compaction in SQLite so the runtime store matches the active
+    // ledger set. Archived entries live on in the JSONL archive files (export/debug).
+    try {
+        MeshRuntimeStore.getInstance().deleteLedgerEntries(meshId, archive.map(e => e.id));
+        invalidateLedgerCache(meshId);
+    } catch { /* best-effort; summary counts absorb the difference via archived counts */ }
+
+    return { archivedCount: archive.length, retainedCount: keep.length };
+}
+
 // ─── Core API ───────────────────────────────────
 
+function readNonEmptyString(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function readStringArray(value: unknown): string[] {
+    if (!Array.isArray(value)) return [];
+    return value.map(item => readNonEmptyString(item)).filter(Boolean) as string[];
+}
+
+function extractJsonObjectFromSummary(summary?: string): Record<string, unknown> | undefined {
+    const text = readNonEmptyString(summary);
+    if (!text) return undefined;
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidates = [fenced?.[1], text].filter(Boolean) as string[];
+    for (const candidate of candidates) {
+        const trimmed = candidate.trim();
+        if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                // Require at least one mesh worker result field to avoid false positives
+                // (e.g. JSON from tool call outputs or log lines in the final summary).
+                const hasWorkerShape = 'status' in parsed && (
+                    'changedFiles' in parsed || 'errors' in parsed
+                    || 'gitStatus' in parsed || 'nextAction' in parsed
+                    || 'validationResults' in parsed
+                );
+                if (hasWorkerShape) return parsed;
+            }
+        } catch { /* try next candidate */ }
+    }
+    return undefined;
+}
+
+function normalizeValidationResults(value: unknown): MeshValidationResultArtifact[] {
+    if (!Array.isArray(value)) return [];
+    return value
+        .filter(item => item && typeof item === 'object' && !Array.isArray(item))
+        .map((item: any) => {
+            const status = ['passed', 'failed', 'skipped', 'unknown'].includes(item.status) ? item.status : 'unknown';
+            return {
+                ...(readNonEmptyString(item.command) ? { command: readNonEmptyString(item.command) } : {}),
+                status,
+                ...(Number.isFinite(Number(item.durationMs)) ? { durationMs: Number(item.durationMs) } : {}),
+                ...(readNonEmptyString(item.outputPath) ? { outputPath: readNonEmptyString(item.outputPath) } : {}),
+                ...(readNonEmptyString(item.summary) ? { summary: readNonEmptyString(item.summary) } : {}),
+            };
+        });
+}
+
+function normalizeProcessArtifacts(value: unknown): MeshProcessArtifact[] {
+    if (!Array.isArray(value)) return [];
+    const kinds = new Set(['process', 'log', 'port', 'window', 'session', 'file', 'url', 'other']);
+    return value
+        .filter(item => item && typeof item === 'object' && !Array.isArray(item))
+        .map((item: any) => ({
+            kind: kinds.has(item.kind) ? item.kind : 'other',
+            ...(readNonEmptyString(item.id) ? { id: readNonEmptyString(item.id) } : {}),
+            ...(readNonEmptyString(item.label) ? { label: readNonEmptyString(item.label) } : {}),
+            ...(readNonEmptyString(item.locator) ? { locator: readNonEmptyString(item.locator) } : {}),
+            ...(Number.isFinite(Number(item.pid)) ? { pid: Number(item.pid) } : {}),
+            ...(Number.isFinite(Number(item.port)) ? { port: Number(item.port) } : {}),
+            ...(readNonEmptyString(item.url) ? { url: readNonEmptyString(item.url) } : {}),
+            ...(readNonEmptyString(item.path) ? { path: readNonEmptyString(item.path) } : {}),
+            ...(readNonEmptyString(item.sessionId) ? { sessionId: readNonEmptyString(item.sessionId) } : {}),
+            ...(typeof item.keepRunning === 'boolean' ? { keepRunning: item.keepRunning } : {}),
+            ...(item.metadata && typeof item.metadata === 'object' && !Array.isArray(item.metadata) ? { metadata: item.metadata as Record<string, unknown> } : {}),
+        }));
+}
+
+export function normalizeMeshWorkerResult(input?: Record<string, unknown>, source: MeshWorkerResultArtifact['source'] = 'explicit_metadata'): MeshWorkerResultArtifact {
+    const raw = input && typeof input === 'object' ? input : {};
+    const status = ['completed', 'failed', 'blocked', 'partial', 'unknown'].includes(String(raw.status))
+        ? raw.status as MeshWorkerResultStatus
+        : 'unknown';
+    const gitStatus = raw.gitStatus && typeof raw.gitStatus === 'object' && !Array.isArray(raw.gitStatus)
+        ? raw.gitStatus as Record<string, unknown>
+        : undefined;
+    return {
+        status,
+        ...(readNonEmptyString(raw.classification) ? { classification: readNonEmptyString(raw.classification) } : {}),
+        changedFiles: readStringArray(raw.changedFiles),
+        validationResults: normalizeValidationResults(raw.validationResults),
+        ...(gitStatus ? { gitStatus } : {}),
+        processArtifacts: normalizeProcessArtifacts(raw.processArtifacts),
+        errors: readStringArray(raw.errors),
+        ...(readNonEmptyString(raw.nextAction) ? { nextAction: readNonEmptyString(raw.nextAction) } : {}),
+        requiresUserAction: raw.requiresUserAction === true,
+        source,
+    };
+}
+
+/**
+ * NOTIF Defect-2b: does the summary contain ANY parseable JSON object answer (not just a
+ * worker-result-shaped one)? Some providers (and every MAGI replica) emit a complete, valid
+ * answer as a JSON envelope that has no `status`/`changedFiles` worker-result fields, so
+ * extractJsonObjectFromSummary returns undefined and the completion is mislabelled
+ * source='default' → evidenceLevel='insufficient' even though a real answer was produced.
+ * This is a conservative existence check: it only returns true when a JSON object actually
+ * parses out of the summary (raw or fenced), so an empty / prose-only / unparseable summary
+ * still resolves to 'default'.
+ */
+function summaryHasParseableJsonAnswer(summary?: string): boolean {
+    const text = readNonEmptyString(summary);
+    if (!text) return false;
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidates = [fenced?.[1], text].filter(Boolean) as string[];
+    for (const candidate of candidates) {
+        const trimmed = candidate.trim();
+        if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+                && Object.keys(parsed).length > 0) {
+                return true;
+            }
+        } catch { /* try next candidate */ }
+    }
+    return false;
+}
+
+function resolveWorkerResult(opts: BuildTaskCompletionEvidenceOptions): MeshWorkerResultArtifact {
+    if (opts.workerResult && typeof opts.workerResult === 'object') {
+        return normalizeMeshWorkerResult(opts.workerResult, 'explicit_metadata');
+    }
+    const parsed = extractJsonObjectFromSummary(opts.finalSummary);
+    if (parsed) {
+        return normalizeMeshWorkerResult(parsed, 'final_summary_json');
+    }
+    // NOTIF Defect-2b: no worker-result-shaped JSON, but a parseable JSON answer IS present
+    // (the common MAGI / answer-only case). Treat it as concrete evidence so the completion is
+    // not labelled 'insufficient', while keeping the worker-result fields empty (status stays
+    // 'unknown') — we only know an answer parsed, not its task outcome.
+    if (summaryHasParseableJsonAnswer(opts.finalSummary)) {
+        return normalizeMeshWorkerResult(undefined, 'parseable_answer');
+    }
+    return normalizeMeshWorkerResult(undefined, 'default');
+}
+
 export function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOptions): MeshTaskCompletionEvidence {
     const providerSessionId = opts.providerSessionId?.trim() || undefined;
     const providerType = opts.providerType?.trim() || undefined;
@@ -204,6 +636,7 @@ export function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOpt
             providerSessionId,
             finalSummaryAvailable: typeof opts.finalSummary === 'string' && opts.finalSummary.trim().length > 0,
         },
+        workerResult: resolveWorkerResult(opts),
         git: {
             status: 'deferred',
             reason: 'ordinary_completion_git_status_not_checked',
@@ -220,6 +653,32 @@ export function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOpt
     };
 }
 
+/**
+ * Build the v2 originating-coordinator stamp for a task_dispatched ledger entry
+ * (B2a / design decision §2). This is the source of truth from which a worker's
+ * completion emit later restores `dispatchedBy` — it records which coordinator
+ * dispatched the task, so the terminal event can be routed (unicast) back to it.
+ *
+ * Nested under `payload.originatingCoordinator`; additive, so existing readers
+ * of the task_dispatched payload are unaffected. Returns undefined when no
+ * coordinator daemon id is known (the pre-v2 path) so the caller omits the stamp
+ * entirely rather than writing a malformed identity — those entries stay v1 and
+ * are broadcast-treated during rollout.
+ */
+export function buildLedgerOriginatingCoordinatorStamp(fields: {
+    coordinatorDaemonId?: string | null;
+    coordinatorRunId?: string | null;
+    coordinatorSessionId?: string | null;
+}): MeshLedgerOriginatingCoordinatorV2 | undefined {
+    const originatingCoordinator = coordinatorIdentityFromEmitFields({
+        daemonId: fields.coordinatorDaemonId,
+        coordinatorRunId: fields.coordinatorRunId,
+        sessionId: fields.coordinatorSessionId,
+    });
+    if (!originatingCoordinator) return undefined;
+    return { originatingCoordinator, protocolVersion: MESH_PROTOCOL_VERSION_V2 };
+}
+
 /**
  * Append a new entry to the mesh ledger.
  * Handles file creation, rotation on size overflow, and atomic writes.
@@ -230,6 +689,23 @@ export function appendLedgerEntry(
     meshId: string,
     partial: Omit<MeshLedgerEntry, 'id' | 'meshId' | 'timestamp'>,
 ): MeshLedgerEntry {
+    // Fix (1) dedupe-on-record: for a coordinator_operating_note, if the same
+    // trimmed text already appears among the most recent OPERATING_NOTE_DEDUPE_WINDOW
+    // notes, do NOT append a duplicate — return the existing entry so the bounded
+    // prompt tail can't be crowded by the same lesson recorded repeatedly. Other
+    // kinds (task_completed, …) are untouched.
+    if (partial.kind === OPERATING_NOTE_KIND) {
+        const text = operatingNoteText(partial.payload);
+        if (text) {
+            const recentNotes = readLedgerEntries(meshId, {
+                kind: [OPERATING_NOTE_KIND],
+                tail: OPERATING_NOTE_DEDUPE_WINDOW,
+            });
+            const existing = recentNotes.find(e => operatingNoteText(e.payload) === text);
+            if (existing) return existing;
+        }
+    }
+
     const entry: MeshLedgerEntry = {
         id: randomUUID(),
         meshId,
@@ -239,28 +715,188 @@ export function appendLedgerEntry(
 
     const filePath = getLedgerPath(meshId);
 
-    // Rotate if file exceeds max size
+    // Compact or rotate based on file size
     if (existsSync(filePath)) {
         try {
             const stat = statSync(filePath);
             if (stat.size >= MAX_FILE_SIZE_BYTES) {
                 rotateLedgerFile(meshId, filePath);
+            } else if (stat.size >= COMPACT_THRESHOLD_BYTES) {
+                compactLedger(meshId);
             }
         } catch {
             // stat failed — proceed with append anyway
         }
     }
 
+    // Write to SQLite (G2: primary runtime read/write path)
+    try {
+        MeshRuntimeStore.getInstance().appendLedgerEntry({
+            id: entry.id,
+            meshId: entry.meshId,
+            timestamp: entry.timestamp,
+            kind: entry.kind,
+            nodeId: entry.nodeId ?? null,
+            sessionId: entry.sessionId ?? null,
+            providerType: entry.providerType ?? null,
+            payload: entry.payload,
+        });
+    } catch {
+        // SQLite write failed but the JSONL append below still records the entry.
+        // Reset the one-time import flag so the next read re-imports from JSONL
+        // and the store self-heals instead of silently missing this entry.
+        ledgerImportDone.delete(meshId);
+    }
+
+    // Also write to JSONL (retained as export/import/debug/legacy artifact)
     try {
         const line = JSON.stringify(entry) + '\n';
         appendFileSync(filePath, line, { encoding: 'utf-8', mode: 0o600 });
+        invalidateLedgerCache(meshId);
         meshLedgerEvents.emit('append', meshId, entry);
+        // Fix (3) keep-latest-N: operating notes are never archived by compactLedger,
+        // so cap their store footprint here. Runs only when a note (or its tombstone)
+        // is recorded, and is a no-op until the live-note count exceeds the bound.
+        if (entry.kind === OPERATING_NOTE_KIND || entry.kind === OPERATING_NOTE_TOMBSTONE_KIND) {
+            try { pruneOperatingNotes(meshId); } catch { /* prune is best-effort */ }
+        }
         return entry;
     } catch (e: any) {
         throw new Error(`Failed to append to ledger for mesh ${meshId}: ${e.message}`);
     }
 }
 
+// ─── Operating-note growth controls ─────────────
+
+/** Extract the trimmed note text from a coordinator_operating_note payload. */
+function operatingNoteText(payload: Record<string, unknown> | undefined): string | undefined {
+    const text = payload && typeof payload.text === 'string' ? payload.text.trim() : '';
+    return text || undefined;
+}
+
+/**
+ * Set of trimmed-text fingerprints and note ids retracted by tombstone entries in
+ * the given entry set. A tombstone targets by note id and/or by text fingerprint.
+ */
+function collectOperatingNoteTombstones(entries: MeshLedgerEntry[]): { ids: Set<string>; fingerprints: Set<string> } {
+    const ids = new Set<string>();
+    const fingerprints = new Set<string>();
+    for (const e of entries) {
+        if (e.kind !== OPERATING_NOTE_TOMBSTONE_KIND) continue;
+        const p = e.payload || {};
+        const targetId = typeof p.targetNoteId === 'string' ? p.targetNoteId.trim() : '';
+        const targetFp = typeof p.targetFingerprint === 'string' ? p.targetFingerprint.trim() : '';
+        if (targetId) ids.add(targetId);
+        if (targetFp) fingerprints.add(targetFp);
+    }
+    return { ids, fingerprints };
+}
+
+/** True if the operating note is retracted by any tombstone in `tombstones`. */
+export function isOperatingNoteTombstoned(
+    entry: Pick<MeshLedgerEntry, 'id' | 'payload'>,
+    tombstones: { ids: Set<string>; fingerprints: Set<string> },
+): boolean {
+    if (tombstones.ids.has(entry.id)) return true;
+    const text = operatingNoteText(entry.payload);
+    return text ? tombstones.fingerprints.has(text) : false;
+}
+
+/**
+ * Fix (2) supersede/remove: append a tombstone that retracts a coordinator
+ * operating note. Targets by note id and/or by exact trimmed text (a text target
+ * retracts every note with that text). History is preserved — the notes stay in
+ * the ledger but readers filter them out. Returns how many currently-live notes
+ * the tombstone will hide.
+ */
+export function tombstoneOperatingNote(
+    meshId: string,
+    target: { noteId?: string; text?: string; reason?: string },
+): { tombstone: MeshLedgerEntry; matched: number } {
+    const noteId = typeof target.noteId === 'string' ? target.noteId.trim() : '';
+    const fingerprint = typeof target.text === 'string' ? target.text.trim() : '';
+    if (!noteId && !fingerprint) {
+        throw new Error('tombstoneOperatingNote requires a noteId or text target');
+    }
+
+    // Count currently-live matches (not already tombstoned) for the caller's report.
+    const notes = readOperatingNotes(meshId);
+    const matched = notes.filter(n =>
+        (noteId && n.id === noteId) || (fingerprint && operatingNoteText(n.payload) === fingerprint),
+    ).length;
+
+    const tombstone = appendLedgerEntry(meshId, {
+        kind: OPERATING_NOTE_TOMBSTONE_KIND,
+        payload: {
+            ...(noteId ? { targetNoteId: noteId } : {}),
+            ...(fingerprint ? { targetFingerprint: fingerprint } : {}),
+            ...(target.reason && target.reason.trim() ? { reason: target.reason.trim() } : {}),
+            forgottenAt: new Date().toISOString(),
+        },
+    });
+    return { tombstone, matched };
+}
+
+/**
+ * Read live operating notes (tombstoned notes filtered out), oldest→newest.
+ * `tail` bounds the number of live notes returned (the freshest N).
+ */
+export function readOperatingNotes(meshId: string, opts?: { tail?: number }): MeshLedgerEntry[] {
+    const raw = getCachedRawEntries(meshId);
+    const tombstones = collectOperatingNoteTombstones(raw);
+    let notes = raw.filter(e => e.kind === OPERATING_NOTE_KIND && !isOperatingNoteTombstoned(e, tombstones));
+    if (opts?.tail && opts.tail > 0 && notes.length > opts.tail) {
+        notes = notes.slice(-opts.tail);
+    }
+    return notes;
+}
+
+/**
+ * Fix (3) keep-latest-N prune for coordinator_operating_note. Removes, from the
+ * store, (a) every note retracted by a tombstone, and (b) the oldest live notes
+ * beyond `keepLatest`. Tombstone entries themselves are retained as an audit trail
+ * of what was forgotten. Returns the number of note entries removed.
+ */
+export function pruneOperatingNotes(meshId: string, keepLatest: number = OPERATING_NOTE_KEEP_LATEST): number {
+    const raw = getCachedRawEntries(meshId);
+    const tombstones = collectOperatingNoteTombstones(raw);
+
+    const removeIds: string[] = [];
+    const liveNotes: MeshLedgerEntry[] = [];
+    for (const e of raw) {
+        if (e.kind !== OPERATING_NOTE_KIND) continue;
+        if (isOperatingNoteTombstoned(e, tombstones)) {
+            removeIds.push(e.id); // tombstoned notes are pruned first
+        } else {
+            liveNotes.push(e);
+        }
+    }
+
+    // Drop the oldest live notes beyond keepLatest; the freshest (prompt tail) survive.
+    const bound = Math.max(0, Math.floor(keepLatest));
+    if (liveNotes.length > bound) {
+        for (const e of liveNotes.slice(0, liveNotes.length - bound)) removeIds.push(e.id);
+    }
+
+    if (removeIds.length === 0) return 0;
+
+    try {
+        MeshRuntimeStore.getInstance().deleteLedgerEntries(meshId, removeIds);
+    } catch { /* store unavailable — JSONL rewrite below still trims */ }
+
+    // Rewrite the JSONL mirror without the pruned note entries so the export
+    // artifact stays consistent with the store.
+    try {
+        const remaining = readLedgerFile(meshId).filter(e => !removeIds.includes(e.id));
+        const filePath = getLedgerPath(meshId);
+        const lines = remaining.length ? remaining.map(e => JSON.stringify(e)).join('\n') + '\n' : '';
+        writeFileSync(filePath, lines, { encoding: 'utf-8', mode: 0o600 });
+    } catch { /* JSONL rewrite best-effort; store is the primary read path */ }
+
+    invalidateLedgerCache(meshId);
+    return removeIds.length;
+}
+
 function clampLedgerSliceLimit(limit: unknown): number {
     if (typeof limit !== 'number' || !Number.isFinite(limit)) return DEFAULT_LEDGER_SLICE_LIMIT;
     return Math.max(1, Math.min(MAX_LEDGER_SLICE_LIMIT, Math.floor(limit)));
@@ -285,8 +921,9 @@ export function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEnt
     if (entries.length === 0) return { accepted: 0, skippedDuplicate: 0, rejectedInvalid: 0, entries: [] };
     const ledgerPath = getLedgerPath(meshId);
 
-    // Read existing to deduplicate by ID
-    const existing = new Set(readLedgerEntries(meshId).map(e => e.id));
+    // Dedup against recent entries only — P2P replication is incremental (cursor-based),
+    // so duplicates appear in the recent tail, not deep history.
+    const existing = new Set(readLedgerEntries(meshId, { tail: 1000 }).map(e => e.id));
     const validEntries: MeshLedgerEntry[] = [];
     let rejectedInvalid = 0;
     let skippedDuplicate = 0;
@@ -307,9 +944,24 @@ export function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEnt
         return { accepted: 0, skippedDuplicate, rejectedInvalid, entries: [] };
     }
 
+    // G2: write to SQLite (primary runtime store); INSERT OR IGNORE dedups by id.
+    try {
+        MeshRuntimeStore.getInstance().importLedgerEntries(validEntries.map(e => ({
+            id: e.id,
+            meshId: e.meshId,
+            timestamp: e.timestamp,
+            kind: e.kind,
+            nodeId: e.nodeId ?? null,
+            sessionId: e.sessionId ?? null,
+            providerType: e.providerType ?? null,
+            payload: e.payload ?? {},
+        })));
+    } catch { /* best-effort; JSONL append below still records the entries */ }
+
     try {
         const lines = validEntries.map(e => JSON.stringify(e)).join('\n') + '\n';
         appendFileSync(ledgerPath, lines, { encoding: 'utf-8', mode: 0o600 });
+        invalidateLedgerCache(meshId);
         for (const entry of validEntries) {
             meshLedgerEvents.emit('append', meshId, entry);
         }
@@ -319,103 +971,155 @@ export function appendRemoteLedgerEntries(meshId: string, entries: MeshLedgerEnt
     }
 }
 
-/**
- * Read ledger entries with optional filtering.
- */
-export function readLedgerEntries(meshId: string, opts?: ReadLedgerOptions): MeshLedgerEntry[] {
+// ─── Ledger Read Cache ─────────────────────────
+// Absorbs repeated reads within a single event-processing burst (e.g. agent:stopped
+// triggers shouldSuppressIntentionalCleanupStop, findRecentTerminalLedgerEvidence,
+// hasDispatchAfterTerminal, and getSessionRecoveryContext — all reading the same store).
+// TTL is 100ms: short enough to stay current, long enough to cover one event cycle.
+// Cache is invalidated on every write (append, remote import, compaction).
+
+const ledgerReadCache = new Map<string, { entries: MeshLedgerEntry[]; cachedAt: number }>();
+const LEDGER_CACHE_TTL_MS = 100;
+
+function readLedgerFile(meshId: string): MeshLedgerEntry[] {
     const filePath = getLedgerPath(meshId);
     if (!existsSync(filePath)) return [];
-
     let content: string;
+    try { content = readFileSync(filePath, 'utf-8'); } catch { return []; }
+    const entries: MeshLedgerEntry[] = [];
+    for (const line of content.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+            const entry = JSON.parse(line) as MeshLedgerEntry;
+            if (entry.id && entry.kind) entries.push(entry);
+        } catch { /* skip malformed lines */ }
+    }
+    return entries;
+}
+
+// ─── G2: One-Time JSONL → SQLite Import ─────────
+// On the first SQLite read for a mesh (per store instance), import any legacy
+// JSONL entries into mesh_event_ledger. INSERT OR IGNORE makes this idempotent:
+// dual-written entries are skipped, only pre-cutover legacy entries are added.
+// Keyed by the store instance so MeshRuntimeStore.resetForTests() (fresh DB)
+// naturally re-imports.
+
+let ledgerImportStoreRef: MeshRuntimeStore | undefined;
+const ledgerImportDone = new Set<string>();
+
+function ensureLedgerImported(store: MeshRuntimeStore, meshId: string): void {
+    if (ledgerImportStoreRef !== store) {
+        ledgerImportDone.clear();
+        ledgerImportStoreRef = store;
+    }
+    if (ledgerImportDone.has(meshId)) return;
+    ledgerImportDone.add(meshId);
+    const fileEntries = readLedgerFile(meshId);
+    if (fileEntries.length === 0) return;
     try {
-        content = readFileSync(filePath, 'utf-8');
+        store.importLedgerEntries(fileEntries.map(e => ({
+            id: e.id,
+            meshId: e.meshId,
+            timestamp: e.timestamp,
+            kind: e.kind,
+            nodeId: e.nodeId ?? null,
+            sessionId: e.sessionId ?? null,
+            providerType: e.providerType ?? null,
+            payload: e.payload ?? {},
+        })));
+    } catch { /* import is best-effort; reads fall back to JSONL on store failure */ }
+}
+
+function readLedgerFromStore(meshId: string): MeshLedgerEntry[] {
+    const store = MeshRuntimeStore.getInstance();
+    ensureLedgerImported(store, meshId);
+    return store.readLedgerEntriesOrdered(meshId).map(r => ({
+        id: r.id,
+        meshId: r.meshId,
+        timestamp: r.timestamp,
+        kind: r.kind as MeshLedgerKind,
+        ...(r.nodeId ? { nodeId: r.nodeId } : {}),
+        ...(r.sessionId ? { sessionId: r.sessionId } : {}),
+        ...(r.providerType ? { providerType: r.providerType } : {}),
+        payload: (r.payload && typeof r.payload === 'object' ? r.payload : {}) as Record<string, unknown>,
+    }));
+}
+
+function getCachedRawEntries(meshId: string): MeshLedgerEntry[] {
+    const now = Date.now();
+    const cached = ledgerReadCache.get(meshId);
+    if (cached && now - cached.cachedAt < LEDGER_CACHE_TTL_MS) return cached.entries;
+    let entries: MeshLedgerEntry[];
+    try {
+        // G2: SQLite mesh_event_ledger is the primary runtime read path.
+        entries = readLedgerFromStore(meshId);
     } catch {
-        return [];
+        // Store unavailable — fall back to the JSONL export artifact.
+        entries = readLedgerFile(meshId);
     }
+    ledgerReadCache.set(meshId, { entries, cachedAt: now });
+    return entries;
+}
 
-    const lines = content.split('\n').filter(line => line.trim());
-    let entries: MeshLedgerEntry[] = [];
+function invalidateLedgerCache(meshId: string): void {
+    ledgerReadCache.delete(meshId);
+}
 
-    for (const line of lines) {
-        try {
-            const entry = JSON.parse(line) as MeshLedgerEntry;
-            if (!entry.id || !entry.kind) continue;
-            entries.push(entry);
-        } catch {
-            // Skip malformed lines
-        }
-    }
+/**
+ * Test helper: clear all runtime ledger state for a mesh — SQLite rows, read
+ * cache, and the one-time import flag. JSONL files are the caller's concern.
+ */
+export function __clearMeshLedgerForTests(meshId: string): void {
+    try {
+        MeshRuntimeStore.getInstance().clearLedgerForMesh(meshId);
+    } catch { /* store unavailable — nothing to clear */ }
+    ledgerReadCache.delete(meshId);
+    ledgerImportDone.delete(meshId);
+}
+
+/**
+ * Read ledger entries with optional filtering.
+ * G2: SQLite (mesh_event_ledger) is the primary read path; legacy JSONL is
+ * imported once per store instance and otherwise retained as an
+ * export/import/debug artifact only.
+ */
+export function readLedgerEntries(meshId: string, opts?: ReadLedgerOptions): MeshLedgerEntry[] {
+    let entries = getCachedRawEntries(meshId);
 
-    // Apply filters
     if (opts?.since) {
         const sinceDate = new Date(opts.since).getTime();
-        if (!isNaN(sinceDate)) {
-            entries = entries.filter(e => new Date(e.timestamp).getTime() >= sinceDate);
-        }
+        if (!isNaN(sinceDate)) entries = entries.filter(e => new Date(e.timestamp).getTime() >= sinceDate);
     }
-
     if (opts?.kind?.length) {
         const kindSet = new Set(opts.kind);
         entries = entries.filter(e => kindSet.has(e.kind));
     }
-
-    // Apply tail (return last N entries)
+    if (opts?.node && opts.node.trim()) {
+        const node = opts.node.trim();
+        entries = entries.filter(e => e.nodeId && daemonIdsEquivalent(e.nodeId, node));
+    }
     if (opts?.tail && opts.tail > 0 && entries.length > opts.tail) {
         entries = entries.slice(-opts.tail);
     }
-
     return entries;
 }
 
 /**
- * Read a bounded, cursor-addressable ledger slice for local-first/P2P replication.
- * The result is intentionally small and self-describing so coordinators can query
- * remote daemons on demand without Cloud/D1 becoming a ledger data-plane.
- */
-export function readLedgerSlice(meshId: string, opts?: ReadLedgerSliceOptions): MeshLedgerSlice {
-    const limit = clampLedgerSliceLimit(opts?.limit);
-    let entries = readLedgerEntries(meshId, { since: opts?.since, kind: opts?.kind });
-    const afterId = typeof opts?.afterId === 'string' && opts.afterId.trim() ? opts.afterId.trim() : null;
-    if (afterId) {
-        const index = entries.findIndex(entry => entry.id === afterId);
-        entries = index >= 0 ? entries.slice(index + 1) : entries;
-    }
-    const bounded = entries.slice(0, limit);
-    return {
-        protocol: 'adhdev.mesh.ledger.slice.v1',
-        meshId,
-        entries: bounded,
-        cursor: {
-            afterId,
-            nextAfterId: bounded.length ? bounded[bounded.length - 1].id : afterId,
-            limit,
-            hasMore: entries.length > bounded.length,
-        },
-        summary: getLedgerSummary(meshId),
-        sourceOfTruth: {
-            kind: 'local_jsonl',
-            path: getLedgerPath(meshId),
-            bounded: true,
-            maxLimit: MAX_LEDGER_SLICE_LIMIT,
-        },
-    };
-}
-
-/**
- * Get a summary of mesh activity from the ledger.
+ * Build a ledger summary from pre-loaded entries. Used by both getLedgerSummary
+ * and readLedgerSlice so they share a single getCachedRawEntries() call.
  */
-export function getLedgerSummary(meshId: string): MeshLedgerSummary {
-    const entries = readLedgerEntries(meshId);
+function buildLedgerSummary(meshId: string, entries: MeshLedgerEntry[]): MeshLedgerSummary {
+    const archived = readArchivedCounts(meshId);
     const now = Date.now();
     const recentFailureCutoff = now - RECENT_FAILURE_WINDOW_MS;
 
     const summary: MeshLedgerSummary = {
         meshId,
-        totalEntries: entries.length,
+        totalEntries: entries.length + archived.totalArchived,
         taskDispatched: 0,
-        taskCompleted: 0,
-        taskFailed: 0,
-        taskStalled: 0,
+        taskCompleted: archived.taskCompleted,
+        taskFailed: archived.taskFailed,
+        taskStalled: archived.taskStalled,
         sessionLaunched: 0,
         checkpointCreated: 0,
         lastActivityAt: null,
@@ -450,6 +1154,79 @@ export function getLedgerSummary(meshId: string): MeshLedgerSummary {
     return summary;
 }
 
+/**
+ * Read a bounded, cursor-addressable ledger slice for local-first/P2P replication.
+ * The result is intentionally small and self-describing so coordinators can query
+ * remote daemons on demand without Cloud/D1 becoming a ledger data-plane.
+ */
+export function readLedgerSlice(meshId: string, opts?: ReadLedgerSliceOptions): MeshLedgerSlice {
+    const limit = clampLedgerSliceLimit(opts?.limit);
+    // Load raw entries once and share between filtering, pagination, and summary.
+    const rawEntries = getCachedRawEntries(meshId);
+
+    let entries: MeshLedgerEntry[] = rawEntries;
+    if (opts?.since) {
+        const sinceDate = new Date(opts.since).getTime();
+        if (!isNaN(sinceDate)) entries = entries.filter(e => new Date(e.timestamp).getTime() >= sinceDate);
+    }
+    if (opts?.kind?.length) {
+        const kindSet = new Set(opts.kind);
+        entries = entries.filter(e => kindSet.has(e.kind));
+    }
+
+    const afterId = typeof opts?.afterId === 'string' && opts.afterId.trim() ? opts.afterId.trim() : null;
+    if (afterId) {
+        const index = entries.findIndex(entry => entry.id === afterId);
+        entries = index >= 0 ? entries.slice(index + 1) : entries;
+    }
+    const bounded = entries.slice(0, limit);
+    return {
+        protocol: 'adhdev.mesh.ledger.slice.v1',
+        meshId,
+        entries: bounded,
+        cursor: {
+            afterId,
+            nextAfterId: bounded.length ? bounded[bounded.length - 1].id : afterId,
+            limit,
+            hasMore: entries.length > bounded.length,
+        },
+        summary: buildLedgerSummary(meshId, rawEntries),
+        sourceOfTruth: {
+            kind: 'local_jsonl',
+            path: getLedgerPath(meshId),
+            bounded: true,
+            maxLimit: MAX_LEDGER_SLICE_LIMIT,
+        },
+    };
+}
+
+/**
+ * G4: Read a bounded ledger slice from the SQLite mesh_event_ledger table.
+ * This is the preferred P2P reconcile read path; JSONL files are retained as
+ * export/import/debug/legacy artifacts only.
+ *
+ * Returns a shape structurally compatible with MeshLedgerSlice (minus the
+ * JSONL-specific `summary` and `sourceOfTruth.path` fields) so callers can
+ * pass it to buildMeshLedgerReplicaEvidence without modification.
+ */
+export function readLedgerSliceFromStore(meshId: string, opts?: ReadLedgerSliceOptions): ReturnType<typeof MeshRuntimeStore.prototype.readLedgerSlice> {
+    return MeshRuntimeStore.getInstance().readLedgerSlice(meshId, {
+        afterId: opts?.afterId,
+        since: opts?.since,
+        // ReadLedgerSliceOptions allows kind as array; SQLite path takes a single kind string.
+        // Pass first kind value if provided; callers needing multi-kind filtering should use readLedgerSlice (JSONL).
+        kind: opts?.kind?.length ? opts.kind[0] : undefined,
+        limit: opts?.limit,
+    });
+}
+
+/**
+ * Get a summary of mesh activity from the ledger.
+ */
+export function getLedgerSummary(meshId: string): MeshLedgerSummary {
+    return buildLedgerSummary(meshId, getCachedRawEntries(meshId));
+}
+
 // ─── Recovery Context ───────────────────────────
 
 export interface SessionRecoveryContext {
@@ -484,46 +1261,64 @@ export function getSessionRecoveryContext(
     },
 ): SessionRecoveryContext {
     const maxRetries = opts.maxRetries ?? 1;
-    const entries = readLedgerEntries(meshId);
+    // tail:500 is sufficient — task_dispatched is never archived (only terminal kinds are),
+    // so dispatch history is always present. The 30-min failure window means we never need
+    // more than a few dozen recent entries for consecutiveNodeFailures. Bounding to 500
+    // avoids a full O(n) scan for meshes with many historical entries.
+    const entries = readLedgerEntries(meshId, { tail: 500 });
 
-    // Find the last task_dispatched for this session or node
+    // Single backward pass: find last task_dispatched AND count consecutive recent failures.
+    const now = Date.now();
+    const recentWindow = now - RECENT_FAILURE_WINDOW_MS;
     let lastDispatch: MeshLedgerEntry | null = null;
+    let consecutiveNodeFailures = 0;
+    let failureCountDone = false;
     for (let i = entries.length - 1; i >= 0; i--) {
         const e = entries[i];
-        if (e.kind !== 'task_dispatched') continue;
-        if (opts.sessionId && e.sessionId === opts.sessionId) { lastDispatch = e; break; }
-        if (opts.nodeId && e.nodeId === opts.nodeId) { lastDispatch = e; break; }
+        const ts = new Date(e.timestamp).getTime();
+
+        // Failure counting: scan until we exit the recent window or hit a chain-breaker
+        if (!failureCountDone) {
+            if (ts < recentWindow) {
+                failureCountDone = true;
+            } else if (opts.nodeId && !daemonIdsEquivalent(e.nodeId, opts.nodeId)) {
+                // Entry for a different node — skip for failure counting but continue scanning for dispatch
+            } else if (e.kind === 'task_failed') {
+                if (!isIntentionalCleanupStopEntry(e)) consecutiveNodeFailures++;
+            } else if (e.kind === 'task_completed' || e.kind === 'task_dispatched') {
+                // A completion or new dispatch breaks the consecutive failure chain
+                failureCountDone = true;
+            }
+        }
+
+        // Dispatch search: find the last dispatch matching this session or node
+        if (lastDispatch === null && e.kind === 'task_dispatched') {
+            if (opts.sessionId && sessionIdsEquivalent(e.sessionId, opts.sessionId)) { lastDispatch = e; }
+            else if (!opts.sessionId && opts.nodeId && daemonIdsEquivalent(e.nodeId, opts.nodeId)) { lastDispatch = e; }
+        }
+
+        // Stop once both tasks are done
+        if (lastDispatch !== null && failureCountDone) break;
     }
 
     const lastTaskMessage = typeof lastDispatch?.payload?.message === 'string'
         ? lastDispatch.payload.message
         : null;
 
-    // Count consecutive recent failures for this node (within 30 min window)
-    const now = Date.now();
-    const recentWindow = now - RECENT_FAILURE_WINDOW_MS;
-    let consecutiveNodeFailures = 0;
-    for (let i = entries.length - 1; i >= 0; i--) {
-        const e = entries[i];
-        if (new Date(e.timestamp).getTime() < recentWindow) break;
-        if (opts.nodeId && e.nodeId !== opts.nodeId) continue;
-        if (e.kind === 'task_failed') {
-            if (isIntentionalCleanupStopEntry(e)) continue;
-            consecutiveNodeFailures++;
-        } else if (e.kind === 'task_completed' || e.kind === 'task_dispatched') {
-            // A completion or new dispatch breaks the consecutive failure chain
-            break;
-        }
-    }
-
-    // Count how many times the same task was attempted (match by message prefix)
+    // Count how many times the same task was attempted.
+    // Prefer exact taskId match (payload.taskId) to avoid 200-char prefix collisions.
     let taskAttemptCount = 0;
-    if (lastTaskMessage) {
-        const prefix = lastTaskMessage.slice(0, 200);
-        for (const e of entries) {
-            if (e.kind === 'task_dispatched' && typeof e.payload?.message === 'string') {
-                if (e.payload.message.startsWith(prefix)) {
-                    taskAttemptCount++;
+    if (lastDispatch) {
+        const taskId = typeof lastDispatch.payload?.taskId === 'string' ? lastDispatch.payload.taskId : null;
+        if (taskId) {
+            for (const e of entries) {
+                if (e.kind === 'task_dispatched' && e.payload?.taskId === taskId) taskAttemptCount++;
+            }
+        } else if (lastTaskMessage) {
+            const prefix = lastTaskMessage.slice(0, 200);
+            for (const e of entries) {
+                if (e.kind === 'task_dispatched' && typeof e.payload?.message === 'string') {
+                    if (e.payload.message.startsWith(prefix)) taskAttemptCount++;
                 }
             }
         }
@@ -573,7 +1368,8 @@ function rotateLedgerFile(meshId: string, currentPath: string): void {
 
     try {
         renameSync(currentPath, getRotatedPath(meshId, index));
-    } catch {
+    } catch (e: any) {
         // Rotation failed — the next append will just grow the file
+        process.stderr.write(`[adhdev-mesh] Ledger rotation failed for mesh ${meshId}: ${e?.message || e}. File will continue to grow.\n`);
     }
 }