maka-agent 0.2.0-dev.46.20260922 → 0.2.0-dev.48.20260923

package/node_modules/@maka/storage/dist/sqlite-runtime-store.js

@@ -24,11 +24,12 @@ import { assertHandoffClaimSource } from '@maka/core/runtime-handoff';
 import { buildWorkspaceBaselineAuthorityEvents, buildWorkspaceSuccessorAuthorityEvent, scanWorkspaceBaselineAuthority, WORKSPACE_AUTHORITY_SESSION_ID, WORKSPACE_VERSION_AUTHORITY_CAPABILITY_V1, } from '@maka/core/workspace-version-authority';
 import { decodeRuntimeEvent, decodeRuntimeInvocationOpened, isPartialRuntimeEvent, isTerminalRuntimeEvent, runtimeEventInvocationOpening, } from '@maka/core/runtime-event';
 import { RunSealedError, RUNTIME_CONTINUATION_AUTHORITY_V1, TOOL_RECOVERY_BUNDLE_CAPABILITY_V1, } from '@maka/core/runtime-event-store';
+import { mayBeTranscriptLedgerInvocationId, } from '@maka/core/runtime-invocation';
 import { stableJsonStringify } from '@maka/core/tool-args-identity';
 import { mergeRuntimePartialSnapshots, groupRuntimePartialSnapshots, compareRuntimePartialSnapshots, partialRuntimeStream, completedPartialRuntimeStreamKey, } from './runtime-partial-values.js';
 import { assertPreparedInput, assertOutcomeInput, assertPreparedIdentity, assertOutcomeIdentity, } from './tool-commit-validation.js';
 import { encodeCanonicalRuntimeEvent } from '@maka/core/canonical-runtime-event';
-import { scanToolLedger, ToolLedgerCorruptionError, ToolLedgerRejectionError, validateGenericToolLedgerAppend, validateToolLedgerTransition, } from '@maka/core/tool-ledger-scanner';
+import { scanToolLedger, referencedToolOperationIds, ToolLedgerReducer, ToolLedgerCorruptionError, ToolLedgerRejectionError, validateGenericToolLedgerAppend, validateIncrementalToolLedgerTransition, } from '@maka/core/tool-ledger-scanner';
 import { buildImmutableRuntimePrefix, buildImmutableRuntimePrefixProof, continuationStartEventMatchesClaim, decodeContinuationClaim, } from '@maka/core/runtime-boundary';
 import { assertToolRecoveryEventBundle, interpretScannedToolRecovery, } from '@maka/core/tool-recovery-bundle';
 import { configureSqliteRuntimeDatabase, migrateSqliteRuntimeDatabase, readUserVersion, RUNTIME_RECOVERY_AUTHORITY_CAPABILITY, RUNTIME_RECOVERY_AUTHORITY_CAPABILITY_VERSION, RUNTIME_CONTINUATION_AUTHORITY_CAPABILITY, RUNTIME_CONTINUATION_AUTHORITY_CAPABILITY_VERSION, RUNTIME_WORKSPACE_VERSION_AUTHORITY_CAPABILITY, RUNTIME_WORKSPACE_VERSION_AUTHORITY_CAPABILITY_VERSION, runtimeEventKind, SQLITE_RUNTIME_SCHEMA_VERSION, } from './sqlite-runtime-schema.js';
@@ -41,6 +42,24 @@ import { rebuildTranscriptTurnExtents, recordTranscriptTurnExtent, RuntimeTransc
 export { SQLITE_RUNTIME_SCHEMA_VERSION } from './sqlite-runtime-schema.js';
 const RUNTIME_EVENT_SCAN_BATCH_SIZE = 128;
 const RUNTIME_PARTIAL_SEGMENT_TARGET_BYTES = 64 * 1024;
+const RECOVERY_MESSAGE_QUERY_BATCH_SIZE = 400;
+const TOOL_LEDGER_CACHE_EVENT_OVERHEAD_BYTES = 1024;
+const DEFAULT_TOOL_LEDGER_CACHE_BUDGET = {
+    maxEntries: 32,
+    maxEstimatedBytes: 16 * 1024 * 1024,
+    maxSingleEntryEstimatedBytes: 8 * 1024 * 1024,
+};
+const IMMUTABLE_STEERING_SQL_PREDICATE = `
+  event_kind = 'text'
+  AND CASE
+    WHEN json_valid(payload_json)
+    THEN json_extract(payload_json, '$.partial')
+  END = 0
+  AND CASE
+    WHEN json_valid(payload_json)
+    THEN json_extract(payload_json, '$.content.steering')
+  END = 1
+`;
 function assertRuntimeEventScanBudget(budget) {
     for (const [name, value] of Object.entries(budget)) {
         if (!Number.isSafeInteger(value) || value < 1) {
@@ -61,6 +80,19 @@ function requireRuntimeEventScanCount(value) {
     }
     return value;
 }
+function normalizeToolLedgerCacheBudget(override) {
+    const budget = { ...DEFAULT_TOOL_LEDGER_CACHE_BUDGET, ...override };
+    for (const [name, value] of Object.entries(budget)) {
+        if (!Number.isSafeInteger(value) || value < 1) {
+            throw new Error(`Invalid tool ledger cache ${name}`);
+        }
+    }
+    return budget;
+}
+function estimateToolLedgerCacheBytes(storedPayloadBytes, eventCount) {
+    const estimate = storedPayloadBytes * 2 + eventCount * TOOL_LEDGER_CACHE_EVENT_OVERHEAD_BYTES;
+    return Number.isSafeInteger(estimate) ? estimate : Number.MAX_SAFE_INTEGER;
+}
 const require = createRequire(import.meta.url);
 function loadDatabaseSync() {
     return require('node:sqlite').DatabaseSync;
@@ -82,12 +114,26 @@ export class SqliteRuntimeStore {
     workspaceVersionAuthorityCapability = WORKSPACE_VERSION_AUTHORITY_CAPABILITY_V1;
     db;
     databaseLease;
-    toolLedgerHealth;
+    toolLedgerCacheBudget;
+    toolLedgerCache = new Map();
+    toolLedgerCacheEstimatedBytes = 0;
+    toolLedgerCacheEventCount = 0;
+    toolLedgerCacheMetrics = {
+        hits: 0,
+        misses: 0,
+        budgetEvictions: 0,
+        terminalEvictions: 0,
+        transientEntries: 0,
+    };
+    uncommittedToolLedgerStates = new Map();
+    toolLedgerCacheVersion;
+    localCommittedWriteRevision = 0;
     closed = false;
     uncommittedEventSessions = new Set();
     eventCommitListeners = new Set();
     constructor(path, options = {}) {
         this.options = options;
+        this.toolLedgerCacheBudget = normalizeToolLedgerCacheBudget(options.toolLedgerCacheBudget);
         if (options.readOnly && options.databaseLease) {
             throw new Error('Operational state database leases cannot be opened read-only');
         }
@@ -102,7 +148,6 @@ export class SqliteRuntimeStore {
             registerRecallFoldFunction(this.db);
             if (!options.readOnly) {
                 this.registerWorkspaceBaselineAuthorityWriter();
-                this.refreshToolLedgerHealth();
             }
             return;
         }
@@ -128,7 +173,6 @@ export class SqliteRuntimeStore {
             registerRecallFoldFunction(this.db);
             if (!options.readOnly) {
                 this.registerWorkspaceBaselineAuthorityWriter();
-                this.refreshToolLedgerHealth();
             }
         }
         catch (error) {
@@ -152,6 +196,8 @@ export class SqliteRuntimeStore {
         if (this.closed)
             return;
         this.closed = true;
+        this.clearToolLedgerCache();
+        this.uncommittedToolLedgerStates.clear();
         if (this.databaseLease)
             this.databaseLease.close();
         else
@@ -195,6 +241,7 @@ export class SqliteRuntimeStore {
                 existing.at(-1)?.id !== canonicalEvent.id) {
                 throw new Error('Terminal RuntimeEvent must be the immutable ledger tail');
             }
+            this.invalidateToolLedgerCacheForInvocation(canonicalEvent.invocationId);
             return;
         }
         const existingTerminal = existing.find(isTerminalRuntimeEvent);
@@ -334,6 +381,202 @@ export class SqliteRuntimeStore {
         assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
         return this.readTransaction(() => this.readInvocationOpeningsSync(sessionId, { direction: 'asc' }).map((row) => this.completeInvocationRecordSync(row)));
     }
+    async listInvocationRecoveryInventory(sessionIds) {
+        const selectedSessionIds = [...new Set(sessionIds)];
+        for (const sessionId of selectedSessionIds) {
+            assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        }
+        if (selectedSessionIds.length === 0)
+            return [];
+        const selectedJson = JSON.stringify(selectedSessionIds);
+        return this.readTransaction(() => {
+            const eventRows = this.db
+                .prepare(`
+          WITH selected(session_id) AS (SELECT value FROM json_each(?))
+          SELECT
+            opening.rowid AS opening_rowid,
+            opening.session_id AS session_id,
+            opening.invocation_id AS invocation_id,
+            1 AS from_events,
+            NULL AS run_id,
+            NULL AS turn_id,
+            NULL AS opened_at,
+            (
+              SELECT terminal.rowid
+              FROM runtime_events AS terminal INDEXED BY runtime_events_terminal
+              WHERE terminal.invocation_id = opening.invocation_id
+                AND ${TERMINAL_RUNTIME_EVENT_SQL.replaceAll('payload_json', 'terminal.payload_json')}
+              ORDER BY terminal.event_seq
+              LIMIT 1
+            ) AS terminal_rowid
+          FROM selected
+          JOIN runtime_events AS opening INDEXED BY runtime_events_by_session_kind
+            ON opening.session_id = selected.session_id
+            AND opening.event_kind = 'invocation_opened'
+        `)
+                .all(selectedJson);
+            const legacyRows = this.db
+                .prepare(`
+          WITH selected(session_id) AS (SELECT value FROM json_each(?))
+          SELECT
+            NULL AS opening_rowid,
+            legacy.session_id AS session_id,
+            legacy.invocation_id AS invocation_id,
+            legacy.run_id AS run_id,
+            legacy.turn_id AS turn_id,
+            legacy.opened_at AS opened_at,
+            0 AS from_events,
+            (
+              SELECT terminal.rowid
+              FROM runtime_events AS terminal INDEXED BY runtime_events_terminal
+              WHERE terminal.invocation_id = legacy.invocation_id
+                AND ${TERMINAL_RUNTIME_EVENT_SQL.replaceAll('payload_json', 'terminal.payload_json')}
+              ORDER BY terminal.event_seq
+              LIMIT 1
+            ) AS terminal_rowid
+          FROM selected
+          JOIN runtime_legacy_invocation_openings AS legacy
+            ON legacy.session_id = selected.session_id
+          WHERE NOT EXISTS (
+              SELECT 1 FROM runtime_events AS opening
+              WHERE opening.invocation_id = legacy.invocation_id
+                AND opening.event_kind = 'invocation_opened'
+            )
+        `)
+                .all(selectedJson);
+            const handoffRows = this.db
+                .prepare(`
+          WITH selected(session_id) AS (SELECT value FROM json_each(?))
+          SELECT
+            terminal.rowid AS terminal_rowid,
+            terminal.event_id AS event_id,
+            terminal.session_id AS session_id,
+            terminal.invocation_id AS invocation_id,
+            terminal.run_id AS run_id,
+            terminal.turn_id AS turn_id,
+            terminal.payload_json AS payload_json
+          FROM selected
+          JOIN runtime_events AS terminal INDEXED BY runtime_events_by_session_kind
+            ON terminal.session_id = selected.session_id
+            AND terminal.event_kind = 'invocation_end'
+          WHERE CASE
+            WHEN json_valid(terminal.payload_json)
+            THEN json_type(terminal.payload_json, '$.actions.handoffPause')
+          END IS NOT NULL
+        `)
+                .all(selectedJson);
+            const handoffByRowId = new Map(handoffRows.map((row) => [row.terminal_rowid, row]));
+            const eventIdentity = this.db.prepare(`
+        SELECT event_id, session_id, invocation_id, run_id, turn_id, committed_at
+        FROM runtime_events
+        WHERE rowid = ?
+      `);
+            const eventCandidate = this.db.prepare(`
+        SELECT event_id, session_id, invocation_id, run_id, turn_id, committed_at, payload_json
+        FROM runtime_events
+        WHERE rowid = ?
+      `);
+            const legacyCandidate = this.db.prepare(`
+        SELECT opening_json
+        FROM runtime_legacy_invocation_openings
+        WHERE invocation_id = ?
+      `);
+            return [...eventRows, ...legacyRows]
+                .sort((a, b) => a.session_id.localeCompare(b.session_id) ||
+                a.invocation_id.localeCompare(b.invocation_id))
+                .map((row) => {
+                const base = { sessionId: row.session_id, invocationId: row.invocation_id };
+                const handoff = row.terminal_rowid === null ? undefined : handoffByRowId.get(row.terminal_rowid);
+                const needsCandidate = row.terminal_rowid === null || handoff !== undefined;
+                const needsIdentity = needsCandidate || mayBeTranscriptLedgerInvocationId(row.invocation_id);
+                if (!needsIdentity)
+                    return base;
+                let identity;
+                let openingJson;
+                let openingEventId;
+                if (row.from_events === 1) {
+                    if (row.opening_rowid === null) {
+                        throw new Error(`Runtime invocation opening row is missing: ${row.invocation_id}`);
+                    }
+                    const detail = (needsCandidate ? eventCandidate : eventIdentity).get(row.opening_rowid);
+                    if (!detail ||
+                        detail.session_id !== row.session_id ||
+                        detail.invocation_id !== row.invocation_id) {
+                        throw new Error(`Runtime invocation opening identity changed: ${row.invocation_id}`);
+                    }
+                    identity = {
+                        sessionId: detail.session_id,
+                        invocationId: detail.invocation_id,
+                        runId: detail.run_id,
+                        turnId: detail.turn_id,
+                        openedAt: detail.committed_at,
+                    };
+                    openingEventId = detail.event_id;
+                    openingJson = detail.payload_json;
+                }
+                else {
+                    if (row.run_id === null || row.turn_id === null || row.opened_at === null) {
+                        throw new Error(`Legacy invocation opening identity is incomplete: ${row.invocation_id}`);
+                    }
+                    identity = {
+                        sessionId: row.session_id,
+                        invocationId: row.invocation_id,
+                        runId: row.run_id,
+                        turnId: row.turn_id,
+                        openedAt: row.opened_at,
+                    };
+                    if (needsCandidate) {
+                        openingJson = legacyCandidate.get(row.invocation_id)?.opening_json;
+                    }
+                }
+                if (!needsCandidate)
+                    return { ...base, identity };
+                if (typeof openingJson !== 'string') {
+                    throw new Error(`Runtime invocation opening payload is missing: ${row.invocation_id}`);
+                }
+                let opening;
+                if (row.from_events === 1) {
+                    const event = decodeRuntimeEventStorageRow({
+                        event_id: openingEventId ?? '',
+                        session_id: identity.sessionId,
+                        invocation_id: identity.invocationId,
+                        run_id: identity.runId,
+                        turn_id: identity.turnId,
+                        payload_json: openingJson,
+                    });
+                    const decoded = runtimeEventInvocationOpening(event);
+                    if (!decoded) {
+                        throw new Error(`RuntimeEvent ${event.id} is indexed as an opening fact but is not one`);
+                    }
+                    opening = decoded;
+                }
+                else {
+                    opening = decodeRuntimeInvocationOpened(JSON.parse(openingJson));
+                }
+                let terminalEvent;
+                if (handoff) {
+                    if (handoff.session_id !== identity.sessionId ||
+                        handoff.invocation_id !== identity.invocationId ||
+                        handoff.run_id !== identity.runId ||
+                        handoff.turn_id !== identity.turnId) {
+                        throw new Error(`Runtime handoff terminal identity changed: ${row.invocation_id}`);
+                    }
+                    terminalEvent = decodeRuntimeEventStorageRow(handoff);
+                    if (!isTerminalRuntimeEvent(terminalEvent)) {
+                        throw new Error(`Runtime handoff fact is not terminal: ${terminalEvent.id}`);
+                    }
+                }
+                return {
+                    ...base,
+                    candidate: {
+                        ...identity,
+                        opening,
+                        ...(terminalEvent ? { terminalEvent } : {}),
+                    },
+                };
+            });
+        });
+    }
     async readRunInvocation(sessionId, runId) {
         assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
         assertRuntimeStorageSafeId(runId, 'Invalid run id');
@@ -964,6 +1207,51 @@ export class SqliteRuntimeStore {
         const row = this.readContinuationClaimRow('boundary_digest = ?', boundaryDigest);
         return row ? this.decodeContinuationClaimStateRow(row) : undefined;
     }
+    async listUnsettledContinuationClaimsForRecovery(sessionIds) {
+        const selectedSessionIds = [...new Set(sessionIds)];
+        for (const sessionId of selectedSessionIds) {
+            assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        }
+        if (selectedSessionIds.length === 0)
+            return [];
+        const rows = this.db
+            .prepare(`
+        WITH selected(session_id) AS (SELECT value FROM json_each(?))
+        SELECT
+          claim.claim_id,
+          claim.source_session_id,
+          claim.source_invocation_id,
+          claim.source_run_id,
+          claim.source_turn_id,
+          claim.source_event_high_water,
+          claim.source_prefix_digest,
+          claim.boundary_digest,
+          claim.boundary_json,
+          claim.provider_projection_version,
+          claim.provider_replay_digest,
+          claim.target_session_id,
+          claim.target_invocation_id,
+          claim.target_run_id,
+          claim.target_turn_id,
+          claim.target_opening_json,
+          claim.claimed_at,
+          claim.start_event_id,
+          claim.start_kind,
+          claim.protocol_version
+        FROM selected
+        JOIN runtime_continuation_claims AS claim
+          ON claim.target_session_id = selected.session_id
+        WHERE NOT EXISTS (
+          SELECT 1
+          FROM runtime_events AS terminal INDEXED BY runtime_events_terminal
+          WHERE terminal.invocation_id = claim.target_invocation_id
+            AND ${TERMINAL_RUNTIME_EVENT_SQL.replaceAll('payload_json', 'terminal.payload_json')}
+        )
+        ORDER BY claim.claimed_at ASC, claim.claim_id ASC
+      `)
+            .all(JSON.stringify(selectedSessionIds));
+        return rows.map((row) => this.decodeContinuationClaimStateRow(row));
+    }
     async listContinuationClaimsForRecovery(sessionId) {
         const rows = this.db
             .prepare(`
@@ -1041,25 +1329,119 @@ export class SqliteRuntimeStore {
     async readImmutableSteeringMessageProof(sessionId, messageId) {
         assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
         assertRuntimeStorageSafeId(messageId, 'Invalid message id');
-        const matches = this.readImmutableSessionRuntimeEvents(sessionId).filter((event) => immutableSteeringMessageId(event) === messageId);
+        const matches = this.readImmutableSteeringMessageEvents(sessionId, messageId);
         if (matches.length > 1) {
             throw new Error(`Immutable steering message identity conflict: ${messageId}`);
         }
         return matches[0] ? Object.freeze({ event: matches[0] }) : undefined;
     }
-    async repairImmutableSteeringMessageProofsForRecovery(sessionId) {
-        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
-        const messages = new Map();
-        for (const event of this.readImmutableSessionRuntimeEvents(sessionId)) {
-            const messageId = immutableSteeringMessageId(event);
-            if (!messageId)
-                continue;
-            const existing = messages.get(messageId);
-            if (existing && !isDeepStrictEqual(existing, event)) {
-                throw new Error(`Immutable steering message identity conflict: ${messageId}`);
+    async readRecoveryMessageEvents(input) {
+        assertRuntimeStorageSafeId(input.sessionId, 'Invalid session id');
+        assertEvidenceReadBudget(input.budget);
+        const turnIds = distinctSafeRuntimeIds(input.turnIds, 'Invalid recovery Turn id');
+        const eventIds = distinctSafeRuntimeIds(input.eventIds, 'Invalid recovery event id');
+        const selectedEventIds = new Set();
+        const measuredRows = [];
+        const measureEventsById = (ids) => {
+            for (const batch of batches(ids, RECOVERY_MESSAGE_QUERY_BATCH_SIZE)) {
+                const placeholders = batch.map(() => '?').join(', ');
+                const rows = this.db
+                    .prepare(`
+            SELECT event_id, session_id,
+                   length(CAST(payload_json AS BLOB)) AS stored_bytes
+              FROM runtime_events
+             WHERE event_id IN (${placeholders})
+          `)
+                    .all(...batch);
+                for (const row of rows) {
+                    if (typeof row.event_id !== 'string' || typeof row.session_id !== 'string') {
+                        throw new Error('Invalid recovery RuntimeEvent measurement row');
+                    }
+                    if (row.session_id !== input.sessionId || selectedEventIds.has(row.event_id))
+                        continue;
+                    selectedEventIds.add(row.event_id);
+                    measuredRows.push({ event_id: row.event_id, stored_bytes: row.stored_bytes });
+                    if (measuredRows.length > input.budget.maxRecords)
+                        return false;
+                }
+            }
+            return true;
+        };
+        if (!measureEventsById(eventIds))
+            return { status: 'limit_exceeded' };
+        const additionalTurnEventIds = new Set();
+        for (const batch of batches(turnIds, RECOVERY_MESSAGE_QUERY_BATCH_SIZE)) {
+            const placeholders = batch.map(() => '?').join(', ');
+            const rows = this.db
+                .prepare(`
+          SELECT event_id
+            FROM runtime_events
+           WHERE session_id = ?
+             AND turn_id IN (${placeholders})
+             AND event_kind = 'text'
+             AND CASE
+               WHEN json_valid(payload_json)
+               THEN json_extract(payload_json, '$.partial')
+             END = 0
+             AND CASE
+               WHEN json_valid(payload_json)
+               THEN json_extract(payload_json, '$.role')
+             END = 'user'
+             AND coalesce(CASE
+               WHEN json_valid(payload_json)
+               THEN json_extract(payload_json, '$.content.steering')
+             END, 0) = 0
+           LIMIT ?
+        `)
+                .all(input.sessionId, ...batch, input.budget.maxRecords + 1);
+            for (const row of rows) {
+                if (typeof row.event_id !== 'string') {
+                    throw new Error('Invalid recovery RuntimeEvent identity row');
+                }
+                if (!selectedEventIds.has(row.event_id))
+                    additionalTurnEventIds.add(row.event_id);
+                if (selectedEventIds.size + additionalTurnEventIds.size > input.budget.maxRecords) {
+                    return { status: 'limit_exceeded' };
+                }
+            }
+        }
+        if (!measureEventsById([...additionalTurnEventIds]))
+            return { status: 'limit_exceeded' };
+        const measurement = measureEvidenceRows(measuredRows, input.budget, 'Invalid recovery RuntimeEvent evidence measurement row');
+        if (!measurement)
+            return { status: 'limit_exceeded' };
+        const storedBytesById = new Map(measuredRows.map((row) => [row.event_id, requireRuntimeEventScanCount(row.stored_bytes)]));
+        const events = new Map();
+        for (const batch of batches([...selectedEventIds], RECOVERY_MESSAGE_QUERY_BATCH_SIZE)) {
+            const placeholders = batch.map(() => '?').join(', ');
+            const rows = this.db
+                .prepare(`
+          SELECT event_id, session_id, invocation_id, run_id, turn_id, payload_json,
+                 length(CAST(payload_json AS BLOB)) AS stored_bytes
+            FROM runtime_events
+           WHERE event_id IN (${placeholders})
+        `)
+                .all(...batch);
+            for (const row of rows) {
+                const event = decodeRuntimeEventStorageRow(row);
+                if (event.sessionId !== input.sessionId)
+                    continue;
+                if (storedBytesById.get(event.id) !== requireRuntimeEventScanCount(row.stored_bytes)) {
+                    throw new Error('Recovery RuntimeEvent evidence changed while reading');
+                }
+                events.set(event.id, event);
             }
-            messages.set(messageId, event);
         }
+        if (events.size !== selectedEventIds.size) {
+            throw new Error('Recovery RuntimeEvent evidence changed while reading');
+        }
+        return {
+            status: 'complete',
+            records: [...events.values()].sort((left, right) => left.ts - right.ts ||
+                left.runId.localeCompare(right.runId) ||
+                left.id.localeCompare(right.id)),
+            ...measurement,
+        };
     }
     /**
      * Narrows recall to the Sessions whose ledger could project a message
@@ -2235,25 +2617,37 @@ export class SqliteRuntimeStore {
     async readToolOperation(operationId) {
         return this.readToolOperationSync(operationId);
     }
-    async listUnsettledToolOperations(sessionId) {
+    async listUnsettledToolOperations(sessionIds) {
+        const selectedSessionIds = sessionIds === undefined
+            ? undefined
+            : [...new Set(typeof sessionIds === 'string' ? [sessionIds] : sessionIds)];
+        if (selectedSessionIds?.length === 0)
+            return [];
         const query = `
-      SELECT operation_id, invocation_id, run_id, turn_id, provider_tool_call_id,
-        tool_name, canonical_args_hash, recovery_mode, current_state,
-        call_event_id, dispatch_event_id, result_event_id, version
+      SELECT call_event.session_id,
+        tool_operations.operation_id, tool_operations.invocation_id,
+        tool_operations.run_id, tool_operations.turn_id,
+        tool_operations.provider_tool_call_id, tool_operations.tool_name,
+        tool_operations.canonical_args_hash, tool_operations.recovery_mode,
+        tool_operations.current_state, tool_operations.call_event_id,
+        tool_operations.dispatch_event_id, tool_operations.result_event_id,
+        tool_operations.version
       FROM tool_operations
-      WHERE current_state = 'prepared'
-        AND result_event_id IS NULL
-        AND dispatch_event_id IS NOT NULL
-        ${sessionId === undefined
+      JOIN runtime_events AS call_event
+        ON call_event.event_id = tool_operations.call_event_id
+      WHERE tool_operations.current_state = 'prepared'
+        AND tool_operations.result_event_id IS NULL
+        AND tool_operations.dispatch_event_id IS NOT NULL
+        ${selectedSessionIds === undefined
             ? ''
-            : 'AND call_event_id IN (SELECT event_id FROM runtime_events WHERE session_id = ?)'}
-      ORDER BY invocation_id ASC, operation_id ASC
+            : 'AND call_event.session_id IN (SELECT value FROM json_each(?))'}
+      ORDER BY tool_operations.invocation_id ASC, tool_operations.operation_id ASC
     `;
         const statement = this.db.prepare(query);
-        const rows = (sessionId === undefined
+        const rows = (selectedSessionIds === undefined
             ? statement.all()
-            : statement.all(sessionId));
-        return rows.map(toolOperationFromRow);
+            : statement.all(JSON.stringify(selectedSessionIds)));
+        return rows.map((row) => ({ sessionId: row.session_id, ...toolOperationFromRow(row) }));
     }
     async readToolJournal(operationId) {
         const rows = this.db
@@ -2268,6 +2662,7 @@ export class SqliteRuntimeStore {
             .all(operationId);
         return rows.map(toolJournalRecordFromRow);
     }
+    /** Explicit full-workspace integrity audit and disposable projection rebuild. */
     async rebuildToolProjectionsFromRuntimeEvents() {
         return this.transaction(() => this.rebuildToolProjectionsFromRuntimeEventsSync());
     }
@@ -2529,8 +2924,16 @@ export class SqliteRuntimeStore {
         }
     }
     transaction(operation) {
-        if (this.databaseLease)
-            return this.databaseLease.transaction('write', operation);
+        if (this.databaseLease) {
+            const nested = this.db.isTransaction;
+            return this.databaseLease.transaction('write', () => {
+                // A sibling lease may have changed the shared transaction view since
+                // this store last used its reconstructible cache.
+                if (nested)
+                    this.clearToolLedgerCache();
+                return operation();
+            });
+        }
         this.db.exec('BEGIN IMMEDIATE');
         let result;
         try {
@@ -2544,10 +2947,17 @@ export class SqliteRuntimeStore {
             catch {
                 // Preserve the protocol failure that caused rollback.
             }
+            // Reducers may have loaded rows written earlier in this transaction as
+            // their immutable base. Bump the local view even on rollback so the next
+            // admission discards that phantom base before retrying.
+            this.localCommittedWriteRevision += 1;
             this.settleEventCommits(false);
+            this.settleToolLedgerStates(false);
             throw error;
         }
+        this.localCommittedWriteRevision += 1;
         this.settleEventCommits(true);
+        this.settleToolLedgerStates(true);
         return result;
     }
     noteEventCommit(sessionId) {
@@ -2765,64 +3175,268 @@ export class SqliteRuntimeStore {
         }
     }
     assertToolLedgerTransition(candidateEvents, expectedTransition) {
-        this.assertWorkspaceToolLedgerHealthy();
-        // Tool-call identity is scoped by invocation. Reading unrelated invocations here turns
-        // concurrent subagents into repeated whole-workspace scans without strengthening the
-        // transition check; event and operation uniqueness remain enforced by SQLite keys.
-        const rows = [];
-        const invocationIds = [...new Set(candidateEvents.map((event) => event.invocationId))].sort();
+        const canonicalEncodings = candidateEvents.map(encodeCanonicalRuntimeEvent);
+        const canonicalEvents = canonicalEncodings.map(({ event }) => event);
+        const entry = this.toolLedgerCacheEntry(canonicalEvents);
+        const appendedEncodings = canonicalEncodings.filter(({ event }) => entry.reducer.event(event.id) === undefined);
+        const validation = validateIncrementalToolLedgerTransition({
+            reducer: entry.reducer,
+            candidateEvents: canonicalEvents,
+            expectedTransition,
+        });
+        if (!validation.ok) {
+            if (validation.source === 'existing') {
+                throw new ToolLedgerCorruptionError(validation.code, validation.eventId);
+            }
+            throw new ToolLedgerRejectionError(validation.code, validation.eventId);
+        }
+        if (validation.appendedEvents === 0)
+            return;
+        this.noteToolLedgerState(entry, validation.checkpoint, canonicalEvents.map((event) => event.invocationId), {
+            eventCount: validation.appendedEvents,
+            estimatedBytes: estimateToolLedgerCacheBytes(appendedEncodings.reduce((bytes, encoding) => bytes + Buffer.byteLength(encoding.json, 'utf8'), 0), validation.appendedEvents),
+        });
+    }
+    toolLedgerCacheEntry(candidateEvents) {
+        const currentVersion = this.currentToolLedgerCacheVersion();
+        if (this.toolLedgerCacheVersion !== currentVersion)
+            this.refreshToolLedgerCacheVersion();
+        const directInvocationIds = new Set(candidateEvents.map((event) => event.invocationId));
+        const directOperationIds = referencedToolOperationIds(candidateEvents);
+        for (const invocationId of this.toolLedgerOperationInvocations(directOperationIds)) {
+            directInvocationIds.add(invocationId);
+        }
+        for (const [key, entry] of this.toolLedgerCache) {
+            if (entry.seedInvocationIds.size === directInvocationIds.size &&
+                [...directInvocationIds].every((invocationId) => entry.seedInvocationIds.has(invocationId))) {
+                this.toolLedgerCacheMetrics.hits += 1;
+                this.touchToolLedgerCacheEntry(key, entry);
+                return entry;
+            }
+        }
+        this.toolLedgerCacheMetrics.misses += 1;
+        const invocationIds = new Set(directInvocationIds);
+        const operationIds = new Set(directOperationIds);
+        const resolvedOperationIds = new Set();
+        const loadedInvocationIds = new Set();
+        const scopedEvents = [];
+        let storedPayloadBytes = 0;
         const readInvocation = this.db.prepare(`
-      SELECT event_id, session_id, invocation_id, run_id, turn_id, payload_json
+      SELECT event_id, session_id, invocation_id, run_id, turn_id, event_seq, payload_json,
+             length(CAST(payload_json AS BLOB)) AS stored_bytes
       FROM runtime_events
       WHERE invocation_id = ?
       ORDER BY event_seq ASC, event_id ASC
     `);
-        for (const invocationId of invocationIds) {
-            rows.push(...readInvocation.all(invocationId));
+        while (true) {
+            const pendingOperationIds = [...operationIds].filter((operationId) => !resolvedOperationIds.has(operationId));
+            if (pendingOperationIds.length > 0) {
+                for (const operationId of pendingOperationIds)
+                    resolvedOperationIds.add(operationId);
+                for (const invocationId of this.toolLedgerOperationInvocations(pendingOperationIds)) {
+                    invocationIds.add(invocationId);
+                }
+            }
+            const pendingInvocationIds = [...invocationIds]
+                .filter((invocationId) => !loadedInvocationIds.has(invocationId))
+                .sort();
+            if (pendingInvocationIds.length === 0 && pendingOperationIds.length === 0)
+                break;
+            for (const invocationId of pendingInvocationIds) {
+                loadedInvocationIds.add(invocationId);
+                const rows = readInvocation.all(invocationId);
+                for (const row of rows) {
+                    storedPayloadBytes += requireRuntimeEventScanCount(row.stored_bytes);
+                    const event = decodeRuntimeEventStorageRow(row);
+                    scopedEvents.push({ event, eventSeq: row.event_seq });
+                    if (event.refs?.parentOperationId)
+                        operationIds.add(event.refs.parentOperationId);
+                }
+            }
         }
-        const validation = validateToolLedgerTransition({
-            existingEvents: rows.map(decodeRuntimeEventStorageRow),
-            candidateEvents: candidateEvents.map(canonicalizeRuntimeEventForStorage),
-            expectedTransition,
-        });
-        if (!validation.ok) {
-            throw new ToolLedgerRejectionError(validation.code, validation.eventId);
+        const sortedSeedInvocationIds = [...directInvocationIds].sort();
+        const sortedInvocationIds = [...invocationIds].sort();
+        const key = JSON.stringify([sortedSeedInvocationIds, sortedInvocationIds]);
+        const existing = this.toolLedgerCache.get(key);
+        if (existing) {
+            this.touchToolLedgerCacheEntry(key, existing);
+            return existing;
+        }
+        scopedEvents.sort((left, right) => left.event.invocationId.localeCompare(right.event.invocationId) ||
+            left.eventSeq - right.eventSeq ||
+            left.event.id.localeCompare(right.event.id));
+        const entry = {
+            reducer: new ToolLedgerReducer(scopedEvents.map(({ event }) => event)),
+            seedInvocationIds: new Set(sortedSeedInvocationIds),
+            invocationIds: new Set(sortedInvocationIds),
+            eventCount: scopedEvents.length,
+            estimatedBytes: estimateToolLedgerCacheBytes(storedPayloadBytes, scopedEvents.length),
+        };
+        if (this.toolLedgerEntryExceedsAdmissionBudget(entry)) {
+            this.toolLedgerCacheMetrics.transientEntries += 1;
+            return entry;
+        }
+        this.retainToolLedgerCacheEntry(key, entry);
+        this.trimToolLedgerCache();
+        return entry;
+    }
+    toolLedgerOperationInvocations(operationIds) {
+        const ids = [...new Set(operationIds)].sort();
+        if (ids.length === 0)
+            return new Set();
+        const placeholders = ids.map(() => '?').join(', ');
+        const rows = this.db
+            .prepare(`
+        SELECT DISTINCT invocation_id
+        FROM runtime_events
+        WHERE event_kind = 'tool_dispatch'
+          AND CASE
+            WHEN json_valid(payload_json)
+              THEN json_extract(payload_json, '$.actions.toolDispatch.operationId')
+          END IN (${placeholders})
+      `)
+            .all(...ids);
+        return new Set(rows.map((row) => row.invocation_id));
+    }
+    noteToolLedgerState(entry, checkpoint, invocationIds, delta) {
+        const reducer = entry.reducer;
+        const existing = this.uncommittedToolLedgerStates.get(reducer);
+        if (existing) {
+            for (const invocationId of invocationIds)
+                existing.changedInvocationIds.add(invocationId);
+            this.adjustToolLedgerCacheEntry(entry, delta);
+            return;
         }
+        if (this.uncommittedToolLedgerStates.size === 0 && this.databaseLease) {
+            this.databaseLease.onTransactionSettled((committed) => this.settleToolLedgerStates(committed));
+        }
+        this.uncommittedToolLedgerStates.set(reducer, {
+            checkpoint,
+            changedInvocationIds: new Set(invocationIds),
+            entry,
+            estimatedBytesBefore: entry.estimatedBytes,
+            eventCountBefore: entry.eventCount,
+        });
+        this.adjustToolLedgerCacheEntry(entry, delta);
     }
-    assertWorkspaceToolLedgerHealthy() {
-        const dataVersion = this.runtimeDataVersion();
-        if (!this.toolLedgerHealth || this.toolLedgerHealth.dataVersion !== dataVersion) {
-            this.refreshToolLedgerHealth();
+    settleToolLedgerStates(committed) {
+        const states = [...this.uncommittedToolLedgerStates.entries()];
+        this.uncommittedToolLedgerStates.clear();
+        if (states.length === 0)
+            return;
+        if (!committed) {
+            for (const [reducer, state] of states.reverse()) {
+                reducer.rollback(state.checkpoint);
+                this.restoreToolLedgerCacheEntry(state);
+            }
+            this.trimToolLedgerCache();
+            return;
         }
-        const health = this.toolLedgerHealth;
-        if (health.decodeFailure)
-            throw health.decodeFailure.error;
-        if (health.issue) {
-            // Pre-existing damage, not a bad candidate. Note the reach of "refused":
-            // this gate is only ever consulted for tool-bearing events, so a damaged
-            // ledger refuses tool facts and takes everything else. Callers that treat
-            // this as "the store is gone" are overreading it — see the note on the
-            // latch in `AgentRun.enqueueRuntimeEventStore`.
-            throw new ToolLedgerCorruptionError(health.issue.code, health.issue.eventId);
+        const retained = new Set(states.map(([reducer]) => reducer));
+        const changedInvocationIds = new Set(states.flatMap(([, state]) => [...state.changedInvocationIds]));
+        for (const [key, entry] of this.toolLedgerCache) {
+            if (retained.has(entry.reducer))
+                continue;
+            if ([...entry.invocationIds].some((id) => changedInvocationIds.has(id))) {
+                this.deleteToolLedgerCacheEntry(key);
+            }
+        }
+        for (const [reducer, state] of states)
+            reducer.commit(state.checkpoint);
+        this.toolLedgerCacheVersion = this.currentToolLedgerCacheVersion();
+        this.trimToolLedgerCache();
+    }
+    refreshToolLedgerCacheVersion() {
+        if (this.uncommittedToolLedgerStates.size > 0) {
+            throw new Error('Cannot invalidate tool ledger state during an open write transaction');
+        }
+        this.clearToolLedgerCache();
+        this.toolLedgerCacheVersion = this.currentToolLedgerCacheVersion();
+    }
+    retainToolLedgerCacheEntry(key, entry) {
+        entry.cacheKey = key;
+        this.toolLedgerCache.set(key, entry);
+        this.toolLedgerCacheEstimatedBytes += entry.estimatedBytes;
+        this.toolLedgerCacheEventCount += entry.eventCount;
+    }
+    touchToolLedgerCacheEntry(key, entry) {
+        this.toolLedgerCache.delete(key);
+        this.toolLedgerCache.set(key, entry);
+    }
+    adjustToolLedgerCacheEntry(entry, delta) {
+        entry.estimatedBytes += delta.estimatedBytes;
+        entry.eventCount += delta.eventCount;
+        if (entry.cacheKey && this.toolLedgerCache.get(entry.cacheKey) === entry) {
+            this.toolLedgerCacheEstimatedBytes += delta.estimatedBytes;
+            this.toolLedgerCacheEventCount += delta.eventCount;
         }
     }
-    refreshToolLedgerHealth() {
-        const dataVersion = this.runtimeDataVersion();
-        try {
-            const rows = this.db
-                .prepare(`
-          SELECT event_id, session_id, invocation_id, run_id, turn_id, payload_json
-          FROM runtime_events
-          ORDER BY invocation_id ASC, event_seq ASC, event_id ASC
-        `)
-                .all();
-            const scan = scanToolLedger(rows.map(decodeRuntimeEventStorageRow));
-            this.toolLedgerHealth = { dataVersion, issue: scan.issues[0] };
+    restoreToolLedgerCacheEntry(state) {
+        const entry = state.entry;
+        if (entry.cacheKey && this.toolLedgerCache.get(entry.cacheKey) === entry) {
+            this.toolLedgerCacheEstimatedBytes += state.estimatedBytesBefore - entry.estimatedBytes;
+            this.toolLedgerCacheEventCount += state.eventCountBefore - entry.eventCount;
         }
-        catch (error) {
-            this.toolLedgerHealth = { dataVersion, decodeFailure: { error } };
+        entry.estimatedBytes = state.estimatedBytesBefore;
+        entry.eventCount = state.eventCountBefore;
+    }
+    deleteToolLedgerCacheEntry(key, reason) {
+        const entry = this.toolLedgerCache.get(key);
+        if (!entry)
+            return;
+        this.toolLedgerCache.delete(key);
+        if (entry.cacheKey === key)
+            entry.cacheKey = undefined;
+        this.toolLedgerCacheEstimatedBytes -= entry.estimatedBytes;
+        this.toolLedgerCacheEventCount -= entry.eventCount;
+        if (reason === 'budget')
+            this.toolLedgerCacheMetrics.budgetEvictions += 1;
+        if (reason === 'terminal')
+            this.toolLedgerCacheMetrics.terminalEvictions += 1;
+    }
+    clearToolLedgerCache() {
+        for (const entry of this.toolLedgerCache.values())
+            entry.cacheKey = undefined;
+        this.toolLedgerCache.clear();
+        this.toolLedgerCacheEstimatedBytes = 0;
+        this.toolLedgerCacheEventCount = 0;
+    }
+    invalidateToolLedgerCacheForInvocation(invocationId) {
+        for (const [key, entry] of this.toolLedgerCache) {
+            if (entry.invocationIds.has(invocationId)) {
+                this.deleteToolLedgerCacheEntry(key, 'terminal');
+            }
         }
     }
+    toolLedgerEntryExceedsAdmissionBudget(entry) {
+        return entry.estimatedBytes > this.toolLedgerCacheBudget.maxSingleEntryEstimatedBytes;
+    }
+    toolLedgerCacheExceedsBudget() {
+        return (this.toolLedgerCache.size > this.toolLedgerCacheBudget.maxEntries ||
+            this.toolLedgerCacheEstimatedBytes > this.toolLedgerCacheBudget.maxEstimatedBytes);
+    }
+    trimToolLedgerCache() {
+        for (;;) {
+            let victim;
+            for (const [key, entry] of this.toolLedgerCache) {
+                if (this.uncommittedToolLedgerStates.has(entry.reducer))
+                    continue;
+                if (this.toolLedgerEntryExceedsAdmissionBudget(entry)) {
+                    victim = key;
+                    break;
+                }
+            }
+            if (!victim && this.toolLedgerCacheExceedsBudget()) {
+                victim = [...this.toolLedgerCache].find(([, entry]) => !this.uncommittedToolLedgerStates.has(entry.reducer))?.[0];
+            }
+            if (!victim)
+                return;
+            this.deleteToolLedgerCacheEntry(victim, 'budget');
+        }
+    }
+    currentToolLedgerCacheVersion() {
+        return `${this.runtimeDataVersion()}:${this.databaseLease?.writeViewRevision() ?? this.localCommittedWriteRevision}`;
+    }
     runtimeDataVersion() {
         const row = this.db.prepare('PRAGMA data_version').get();
         return row.data_version;
@@ -3005,21 +3619,28 @@ export class SqliteRuntimeStore {
         const messageId = immutableSteeringMessageId(event);
         if (!messageId)
             return;
-        const matches = this.readImmutableSessionRuntimeEvents(event.sessionId).filter((candidate) => immutableSteeringMessageId(candidate) === messageId);
+        const matches = this.readImmutableSteeringMessageEvents(event.sessionId, messageId);
         if (matches.some((candidate) => !isDeepStrictEqual(candidate, event))) {
             throw new Error(`Immutable steering message identity conflict: ${messageId}`);
         }
     }
-    readImmutableSessionRuntimeEvents(sessionId) {
+    readImmutableSteeringMessageEvents(sessionId, messageId) {
         const rows = this.db
             .prepare(`
-      SELECT event_id, session_id, invocation_id, run_id, turn_id, payload_json
-      FROM runtime_events
-      WHERE session_id = ?
-      ORDER BY committed_at ASC, event_id ASC
-    `)
-            .all(sessionId);
-        return rows.map(decodeRuntimeEventStorageRow);
+        SELECT event_id, session_id, invocation_id, run_id, turn_id, payload_json
+          FROM runtime_events
+         WHERE session_id = ?
+           AND ${IMMUTABLE_STEERING_SQL_PREDICATE}
+           AND CASE
+             WHEN json_valid(payload_json)
+             THEN json_extract(payload_json, '$.refs.providerEventId')
+           END = ?
+         ORDER BY committed_at ASC, event_id ASC
+      `)
+            .all(sessionId, messageId);
+        return rows
+            .map(decodeRuntimeEventStorageRow)
+            .filter((event) => immutableSteeringMessageId(event) === messageId);
     }
     insertRuntimeEvent(event, committedAt, allowExactDuplicate, authorizedPendingContinuationClaimId) {
         const encoding = encodeCanonicalRuntimeEvent(event);
@@ -3035,6 +3656,9 @@ export class SqliteRuntimeStore {
             if (!allowExactDuplicate) {
                 throw new Error(`RuntimeEvent ${canonicalEvent.id} already exists outside this tool transaction`);
             }
+            if (isTerminalRuntimeEvent(canonicalEvent)) {
+                this.invalidateToolLedgerCacheForInvocation(canonicalEvent.invocationId);
+            }
             return this.runtimeEventSeq(canonicalEvent.id);
         }
         this.assertContinuationAuthorityAllowsEvent(canonicalEvent, authorizedPendingContinuationClaimId);
@@ -3068,6 +3692,9 @@ export class SqliteRuntimeStore {
         recordTranscriptTurnExtent(this.db, { ...canonicalEvent, kind: runtimeEventKind(canonicalEvent) }, ordinal);
         this.noteEventCommit(canonicalEvent.sessionId);
         this.deleteCompletedPartialSnapshot(canonicalEvent);
+        if (isTerminalRuntimeEvent(canonicalEvent)) {
+            this.invalidateToolLedgerCacheForInvocation(canonicalEvent.invocationId);
+        }
         return next;
     }
     deleteCompletedPartialSnapshot(event) {
@@ -3348,6 +3975,19 @@ function assertRuntimeStorageSafeId(value, message) {
     if (!isRuntimeStorageSafeId(value))
         throw new Error(message);
 }
+function distinctSafeRuntimeIds(values, message) {
+    const result = new Set();
+    for (const value of values) {
+        assertRuntimeStorageSafeId(value, message);
+        result.add(value);
+    }
+    return [...result];
+}
+function* batches(values, size) {
+    for (let offset = 0; offset < values.length; offset += size) {
+        yield values.slice(offset, offset + size);
+    }
+}
 function assertInvocationSearchLimit(limit) {
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 256) {
         throw new RangeError('Runtime invocation search limit must be an integer between 1 and 256');