maka-agent 0.2.0-dev.5.20260830 → 0.2.0-dev.50.20260925

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

@@ -16,29 +16,50 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { createHash } from 'node:crypto';
 import { mkdirSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
+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, isPartialRuntimeEvent, isTerminalRuntimeEvent, TOOL_BOUNDARY_PROTOCOL_V1, } from '@maka/core/runtime-event';
+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 { canonicalToolArgsHash, stableJsonStringify } from '@maka/core/tool-args-identity';
+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 { decodePersistedAgentRunHeader } from '@maka/core/agent-run';
-import { markPersisted } from '@maka/core/persisted-value';
-import { scanToolLedger, ToolLedgerCorruptionError, ToolLedgerRejectionError, validateGenericToolLedgerAppend, validateToolLedgerEventLane, validateToolLedgerTransition, } from '@maka/core/tool-ledger-scanner';
-import { buildImmutableRuntimePrefix, decodeContinuationClaim, } from '@maka/core/runtime-boundary';
+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, SQLITE_RUNTIME_SCHEMA_VERSION, } from './sqlite-runtime-schema.js';
+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';
 import { registerWorkspaceBaselineAuthorityWriterInternal, } from './workspace-version-authority-internal.js';
 import { assertEvidenceReadBudget, measureEvidenceRows, } from './bounded-evidence.js';
+import { assertFoldedSearchTerm, recallFoldedMatchClause, registerRecallFoldFunction, } from './recall-fold.js';
 import { immutableSteeringMessageId, isRuntimeStorageSafeId } from './runtime-event-invariants.js';
 import { assertNoReservedWorkspaceAuthorityAppend } from './runtime-event-authority.js';
+import { rebuildTranscriptTurnExtents, recordTranscriptTurnExtent, RuntimeTranscriptQuery, TERMINAL_RUNTIME_EVENT_SQL, } from './runtime-transcript-query.js';
 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) {
@@ -46,12 +67,32 @@ function assertRuntimeEventScanBudget(budget) {
         }
     }
 }
+function assertImmutableRuntimePrefixProofReadBudget(budget) {
+    for (const [name, value] of Object.entries(budget)) {
+        if (!Number.isSafeInteger(value) || value < 1) {
+            throw new Error(`Invalid immutable RuntimeEvent prefix proof ${name}`);
+        }
+    }
+}
 function requireRuntimeEventScanCount(value) {
     if (!Number.isSafeInteger(value) || value < 0) {
         throw new Error('Invalid RuntimeEvent scan measurement');
     }
     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;
@@ -73,10 +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');
         }
@@ -88,9 +145,9 @@ export class SqliteRuntimeStore {
             assertRecoveryAuthorityCapability(this.db);
             assertContinuationAuthorityCapability(this.db);
             assertWorkspaceVersionAuthorityCapability(this.db);
+            registerRecallFoldFunction(this.db);
             if (!options.readOnly) {
                 this.registerWorkspaceBaselineAuthorityWriter();
-                this.refreshToolLedgerHealth();
             }
             return;
         }
@@ -113,9 +170,9 @@ export class SqliteRuntimeStore {
             assertRecoveryAuthorityCapability(this.db);
             assertContinuationAuthorityCapability(this.db);
             assertWorkspaceVersionAuthorityCapability(this.db);
+            registerRecallFoldFunction(this.db);
             if (!options.readOnly) {
                 this.registerWorkspaceBaselineAuthorityWriter();
-                this.refreshToolLedgerHealth();
             }
         }
         catch (error) {
@@ -139,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
@@ -182,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);
@@ -210,25 +270,27 @@ export class SqliteRuntimeStore {
             if (events.some(isToolLedgerBearingEvent)) {
                 this.assertToolLedgerTransition(events, 'generic_append');
             }
-            const created = events.map((event) => this.importRuntimeEventSync(event));
+            // Batch imports preserve already-persisted history, including legacy
+            // terminal/tool gaps that recovery will classify when projections are
+            // rebuilt. New terminal writes through appendRuntimeEvent must obey the
+            // unsettled-operation invariant below.
+            const created = events.map((event) => this.importRuntimeEventSync(event, true));
             return { created };
         });
     }
     async importConversationCopyRuntimeEvents(sessionId, batches) {
         assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
-        const runIds = new Set();
         const canonicalBatches = batches.map(({ runId, events }) => {
             assertRuntimeStorageSafeId(runId, 'Invalid run id');
-            if (runIds.has(runId)) {
-                throw new Error(`Conversation copy contains duplicate run ${runId}`);
-            }
-            runIds.add(runId);
             return {
                 runId,
                 events: events.map(canonicalizeRuntimeEventForStorage),
             };
         });
         const canonicalEvents = canonicalBatches.flatMap(({ events }) => events);
+        if (new Set(canonicalEvents.map(({ id }) => id)).size !== canonicalEvents.length) {
+            throw new Error('Conversation copy contains duplicate RuntimeEvents');
+        }
         for (const { runId, events } of canonicalBatches) {
             for (const event of events) {
                 assertNoReservedWorkspaceAuthorityAppend(event);
@@ -245,7 +307,12 @@ export class SqliteRuntimeStore {
             throw new Error(`Conversation copy RuntimeEvent ledger is corrupt: ${scan.issues[0]?.code ?? 'unknown'}`);
         }
         this.transaction(() => {
+            const eventsByRun = new Map();
             for (const { runId, events } of canonicalBatches) {
+                eventsByRun.set(runId, [...(eventsByRun.get(runId) ?? []), ...events]);
+            }
+            const newRunIds = new Set();
+            for (const [runId, events] of eventsByRun) {
                 const existing = this.db
                     .prepare(`
               SELECT event_id, session_id, invocation_id, run_id, turn_id, payload_json
@@ -257,10 +324,14 @@ export class SqliteRuntimeStore {
                 if (existing.length > 0 && !isDeepStrictEqual(existing, events)) {
                     throw new Error(`Conversation copy RuntimeEvent identity conflict for run ${runId}`);
                 }
-                if (existing.length === 0) {
-                    for (const event of events)
-                        this.insertRuntimeEvent(event, event.ts, true);
-                }
+                if (existing.length === 0)
+                    newRunIds.add(runId);
+            }
+            for (const { runId, events } of canonicalBatches) {
+                if (!newRunIds.has(runId))
+                    continue;
+                for (const event of events)
+                    this.insertRuntimeEvent(event, event.ts, true);
             }
             if (canonicalEvents.some(isToolLedgerBearingEvent)) {
                 this.rebuildToolProjectionsFromRuntimeEventsSync(sessionId);
@@ -270,6 +341,443 @@ export class SqliteRuntimeStore {
     async readRuntimeEvents(sessionId, runId) {
         return this.readRuntimeEventsSync(sessionId, runId);
     }
+    transcriptQuery() {
+        return new RuntimeTranscriptQuery(this.db, (sessionId, invocationId) => {
+            // By invocation rather than by run: both shelves key their opening on it,
+            // so a page's records cost the page instead of the Session's Turns.
+            const opening = this.readInvocationOpeningsSync(sessionId, {
+                direction: 'asc',
+                invocationId,
+            }).at(0);
+            if (!opening)
+                throw new Error(`Transcript invocation ${invocationId} is missing`);
+            return this.completeInvocationRecordSync(opening);
+        });
+    }
+    async readTranscriptHighWater(sessionId) {
+        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        return this.readTransaction(() => this.transcriptQuery().highWater(sessionId));
+    }
+    async readTranscriptRun(sessionId, request, project) {
+        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        return this.readTransaction(() => this.transcriptQuery().run(sessionId, request, project));
+    }
+    async readTranscriptTurns(sessionId, request) {
+        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        return this.readTransaction(() => this.transcriptQuery().turns(sessionId, request));
+    }
+    async readTranscriptTurnCrossing(sessionId, ordinal) {
+        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        return this.readTransaction(() => this.transcriptQuery().crossing(sessionId, ordinal));
+    }
+    /**
+     * Enumerate a Session's invocations: the opening fact names each one, and its
+     * highest-sequence event says whether it ended.
+     *
+     * Invocations that predate the opening fact could not be given one without
+     * rewriting an immutable sequence, so the migration parked their openings in
+     * `runtime_legacy_invocation_openings`. Both shelves are merged here and the
+     * result says nothing about which one a record came from: an opening is an
+     * opening, and a consumer that branched on its storage would be encoding the
+     * migration window into its own logic.
+     */
+    async listSessionInvocations(sessionId) {
+        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');
+        return this.readTransaction(() => {
+            const row = this.readInvocationOpeningsSync(sessionId, { direction: 'asc', runId }).at(0);
+            return row ? this.completeInvocationRecordSync(row) : undefined;
+        });
+    }
+    /**
+     * The first page of a Session's invocations, plus whether more exist.
+     *
+     * The extra row this reads past the limit is the whole truncation signal, so a
+     * caller never has to count a Session it declined to load.
+     */
+    async listSessionInvocationsBounded(sessionId, limit) {
+        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        assertInvocationSearchLimit(limit);
+        return this.readTransaction(() => {
+            const rows = this.readInvocationOpeningsSync(sessionId, {
+                direction: 'asc',
+                limit: limit + 1,
+            });
+            return {
+                invocations: rows.slice(0, limit).map((row) => this.completeInvocationRecordSync(row)),
+                truncated: rows.length > limit,
+            };
+        });
+    }
+    /** One newest-first page of a Session's invocations. */
+    async listSessionInvocationsPage(sessionId, input) {
+        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        assertInvocationSearchLimit(input.limit);
+        if (input.before) {
+            assertRuntimeStorageSafeId(input.before.invocationId, 'Invalid invocation page cursor');
+            if (!Number.isFinite(input.before.openedAt)) {
+                throw new Error('Invalid invocation page cursor');
+            }
+        }
+        return this.readTransaction(() => {
+            const rows = this.readInvocationOpeningsSync(sessionId, {
+                direction: 'desc',
+                limit: input.limit + 1,
+                ...(input.before ? { before: input.before } : {}),
+            });
+            const page = rows.slice(0, input.limit);
+            const last = page.at(-1);
+            return {
+                invocations: page.map((row) => this.completeInvocationRecordSync(row)),
+                nextCursor: rows.length > input.limit && last
+                    ? { openedAt: last.openedAt, invocationId: last.invocationId }
+                    : null,
+            };
+        });
+    }
+    /**
+     * One invocation named by its own identity.
+     *
+     * Absence throws rather than returning `undefined`: every caller here holds an
+     * invocation id that some durable fact already handed it, so a missing opening
+     * is corruption and not a branch a reader should be asked to handle.
+     */
+    async readInvocation(sessionId, invocationId) {
+        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        assertRuntimeStorageSafeId(invocationId, 'Invalid invocation id');
+        return this.readTransaction(() => {
+            const row = this.readInvocationOpeningsSync(sessionId, {
+                direction: 'asc',
+                invocationId,
+            }).at(0);
+            if (!row)
+                throw new Error(`Runtime invocation not found: ${invocationId}`);
+            return this.completeInvocationRecordSync(row);
+        });
+    }
+    /**
+     * Read invocation openings off both shelves as one ordered sequence.
+     *
+     * Every writer of an opening event stamps `committed_at` with the event's own
+     * timestamp, so that column orders the event shelf by the same value the
+     * record reports as `openedAt` and the legacy shelf keeps under `opened_at`.
+     * Ordering and paging therefore happen in SQL, and a bounded caller decodes
+     * only the openings it asked for.
+     */
+    readInvocationOpeningsSync(sessionId, options) {
+        const order = options.direction === 'desc' ? 'DESC' : 'ASC';
+        const rows = this.db
+            .prepare(`
+        SELECT * FROM (
+          SELECT
+            event_id AS event_id,
+            invocation_id AS invocation_id,
+            run_id AS run_id,
+            turn_id AS turn_id,
+            committed_at AS opened_at,
+            payload_json AS opening_json,
+            1 AS from_events
+          FROM runtime_events
+          WHERE session_id = :sessionId AND event_kind = 'invocation_opened'
+            ${options.runId === undefined ? '' : 'AND run_id = :runId'}
+            ${options.invocationId === undefined ? '' : 'AND invocation_id = :invocationId'}
+          UNION ALL
+          SELECT
+            NULL,
+            legacy.invocation_id,
+            legacy.run_id,
+            legacy.turn_id,
+            legacy.opened_at,
+            legacy.opening_json,
+            0
+          FROM runtime_legacy_invocation_openings AS legacy
+          WHERE legacy.session_id = :sessionId
+            ${options.runId === undefined ? '' : 'AND legacy.run_id = :runId'}
+            ${options.invocationId === undefined ? '' : 'AND legacy.invocation_id = :invocationId'}
+            AND NOT EXISTS (
+              SELECT 1 FROM runtime_events
+              WHERE runtime_events.invocation_id = legacy.invocation_id
+                AND runtime_events.event_kind = 'invocation_opened'
+            )
+        )
+        WHERE (
+            :beforeOpenedAt IS NULL
+            OR opened_at < :beforeOpenedAt
+            OR (opened_at = :beforeOpenedAt AND invocation_id < :beforeInvocationId)
+          )
+        ORDER BY opened_at ${order}, invocation_id ${order}
+        LIMIT :limit
+      `)
+            .all({
+            sessionId,
+            ...(options.invocationId === undefined ? {} : { invocationId: options.invocationId }),
+            ...(options.runId === undefined ? {} : { runId: options.runId }),
+            beforeOpenedAt: options.before?.openedAt ?? null,
+            beforeInvocationId: options.before?.invocationId ?? null,
+            limit: options.limit ?? -1,
+        });
+        return rows.map((row) => {
+            if (row.from_events !== 1) {
+                return {
+                    sessionId,
+                    invocationId: row.invocation_id,
+                    runId: row.run_id,
+                    turnId: row.turn_id,
+                    openedAt: row.opened_at,
+                    opening: decodeRuntimeInvocationOpened(JSON.parse(row.opening_json)),
+                };
+            }
+            const event = decodeRuntimeEventStorageRow({
+                event_id: row.event_id ?? '',
+                session_id: sessionId,
+                invocation_id: row.invocation_id,
+                run_id: row.run_id,
+                turn_id: row.turn_id,
+                payload_json: row.opening_json,
+            });
+            const opening = runtimeEventInvocationOpening(event);
+            if (!opening) {
+                throw new Error(`RuntimeEvent ${event.id} is indexed as an opening fact but is not one`);
+            }
+            return {
+                sessionId: event.sessionId,
+                invocationId: event.invocationId,
+                runId: event.runId,
+                turnId: event.turnId,
+                openedAt: event.ts,
+                opening,
+            };
+        });
+    }
+    /**
+     * An invocation's ending is its first terminal event, wherever it sits.
+     *
+     * The store seals a run on that event, so for anything it wrote itself the
+     * first terminal is also the only one and the last event. Ledgers written
+     * before the seal existed can carry a straggler after the terminal, and
+     * reading those as unfinished would contradict every other reader of the same
+     * rule: recovery, the read model and continuation resume all take the first
+     * terminal. A ledger that somehow holds two is corrupt, and saying so is the
+     * job of those readers — this inventory feeds Session lists, so it reports the
+     * ending it can see rather than poisoning the whole Session over one run.
+     */
+    completeInvocationRecordSync(record) {
+        const terminalRow = this.db
+            .prepare(`
+        SELECT event_id, session_id, invocation_id, run_id, turn_id, payload_json
+        FROM runtime_events
+        WHERE invocation_id = ?
+          AND ${TERMINAL_RUNTIME_EVENT_SQL}
+        ORDER BY event_seq ASC
+        LIMIT 1
+      `)
+            .get(record.invocationId);
+        const terminal = terminalRow ? decodeRuntimeEventStorageRow(terminalRow) : undefined;
+        return {
+            ...record,
+            ...(terminal && isTerminalRuntimeEvent(terminal) ? { terminalEvent: terminal } : {}),
+        };
+    }
     async scanRuntimeEvents(sessionId, runId, budget, visit) {
         assertRuntimeEventScanBudget(budget);
         return this.readTransaction(() => {
@@ -552,6 +1060,65 @@ export class SqliteRuntimeStore {
             turnId: first.turnId,
         }, decoded);
     }
+    async readImmutableRuntimePrefixProof(input, budget) {
+        assertImmutableRuntimePrefixProofReadBudget(budget);
+        if (input.upToEventSeq !== undefined &&
+            (!Number.isSafeInteger(input.upToEventSeq) || input.upToEventSeq <= 0)) {
+            throw new Error('Invalid immutable RuntimeEvent prefix high-water');
+        }
+        const highWater = input.upToEventSeq ?? null;
+        const cursor = this.db
+            .prepare(`
+        SELECT event_id, session_id, invocation_id, run_id, turn_id, event_seq,
+          length(CAST(payload_json AS BLOB)) AS stored_bytes,
+          CASE WHEN length(CAST(payload_json AS BLOB)) <= ? THEN payload_json END AS payload_json
+        FROM runtime_events
+        WHERE session_id = ? AND run_id = ?
+          AND (? IS NULL OR event_seq <= ?)
+        ORDER BY event_seq ASC
+      `)
+            .iterate(budget.maxRecordBytes, input.sessionId, input.runId, highWater, highWater)[Symbol.iterator]();
+        const firstRow = cursor.next();
+        if (firstRow.done)
+            throw new Error('immutable RuntimeEvent prefix is empty');
+        let count = 0;
+        let bytes = 0;
+        let lastEventSeq = 0;
+        const decode = function* () {
+            let step = firstRow;
+            while (!step.done) {
+                const row = step.value;
+                count += 1;
+                if (count > budget.maxEvents) {
+                    throw new Error('Immutable RuntimeEvent prefix proof exceeds its event limit');
+                }
+                const payloadJson = row.payload_json;
+                if (payloadJson === null) {
+                    throw new Error('Immutable RuntimeEvent prefix proof exceeds its record byte limit');
+                }
+                bytes += requireRuntimeEventScanCount(row.stored_bytes);
+                if (bytes > budget.maxBytes) {
+                    throw new Error('Immutable RuntimeEvent prefix proof exceeds its byte limit');
+                }
+                lastEventSeq = requireRuntimeEventScanCount(row.event_seq);
+                yield {
+                    eventSeq: lastEventSeq,
+                    event: decodeRuntimeEventStorageRow({ ...row, payload_json: payloadJson }),
+                };
+                step = cursor.next();
+            }
+        };
+        const proof = buildImmutableRuntimePrefixProof({
+            sessionId: firstRow.value.session_id,
+            invocationId: firstRow.value.invocation_id,
+            runId: firstRow.value.run_id,
+            turnId: firstRow.value.turn_id,
+        }, decode());
+        if (input.upToEventSeq !== undefined && lastEventSeq !== input.upToEventSeq) {
+            throw new Error(`immutable RuntimeEvent prefix high-water ${input.upToEventSeq} is unavailable`);
+        }
+        return proof;
+    }
     async claimContinuation(input) {
         const claim = decodeContinuationClaim(input.claim);
         if (claim.target.sessionId === WORKSPACE_AUTHORITY_SESSION_ID ||
@@ -574,12 +1141,12 @@ export class SqliteRuntimeStore {
             const conflict = this.readContinuationClaimRow(`claim_id = ?
           OR target_invocation_id = ?
           OR target_run_id = ?
-          OR (target_session_id = ? AND target_turn_id = ?)
+          OR (? = 0 AND target_session_id = ? AND target_turn_id = ?)
           OR (
             source_session_id = ?
             AND source_run_id = ?
             AND source_event_high_water = ?
-          )`, claim.claimId, claim.target.invocationId, claim.target.runId, claim.target.sessionId, claim.target.turnId, source.identity.sessionId, source.identity.runId, source.position.lastEventSeq);
+          )`, claim.claimId, claim.target.invocationId, claim.target.runId, claim.targetOpening.source.kind === 'handoff' ? 1 : 0, claim.target.sessionId, claim.target.turnId, source.identity.sessionId, source.identity.runId, source.position.lastEventSeq);
             if (conflict) {
                 return { kind: 'conflict', claim: decodeContinuationClaimRow(conflict) };
             }
@@ -605,24 +1172,24 @@ export class SqliteRuntimeStore {
               target_invocation_id,
               target_run_id,
               target_turn_id,
-              target_run_header_json,
+              target_opening_json,
               claimed_at,
               protocol_version
             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
           `)
-                    .run(claim.claimId, source.identity.sessionId, source.identity.invocationId, source.identity.runId, source.identity.turnId, source.position.lastEventSeq, source.prefixDigest, claim.boundaryDigest, boundaryJson, claim.providerProjectionVersion, claim.providerReplayDigest, claim.target.sessionId, claim.target.invocationId, claim.target.runId, claim.target.turnId, stableJsonStringify(claim.targetRunHeader), claim.claimedAt);
+                    .run(claim.claimId, source.identity.sessionId, source.identity.invocationId, source.identity.runId, source.identity.turnId, source.position.lastEventSeq, source.prefixDigest, claim.boundaryDigest, boundaryJson, claim.providerProjectionVersion, claim.providerReplayDigest, claim.target.sessionId, claim.target.invocationId, claim.target.runId, claim.target.turnId, stableJsonStringify(claim.targetOpening), claim.claimedAt);
             }
             catch (error) {
                 const raced = this.readContinuationClaimRow('boundary_digest = ?', claim.boundaryDigest) ??
                     this.readContinuationClaimRow(`claim_id = ?
               OR target_invocation_id = ?
               OR target_run_id = ?
-              OR (target_session_id = ? AND target_turn_id = ?)
+              OR (? = 0 AND target_session_id = ? AND target_turn_id = ?)
               OR (
                 source_session_id = ?
                 AND source_run_id = ?
                 AND source_event_high_water = ?
-              )`, claim.claimId, claim.target.invocationId, claim.target.runId, claim.target.sessionId, claim.target.turnId, source.identity.sessionId, source.identity.runId, source.position.lastEventSeq);
+              )`, claim.claimId, claim.target.invocationId, claim.target.runId, claim.targetOpening.source.kind === 'handoff' ? 1 : 0, claim.target.sessionId, claim.target.turnId, source.identity.sessionId, source.identity.runId, source.position.lastEventSeq);
                 if (!raced)
                     throw error;
                 const racedClaim = decodeContinuationClaimRow(raced);
@@ -644,6 +1211,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(`
@@ -663,7 +1275,7 @@ export class SqliteRuntimeStore {
           target_invocation_id,
           target_run_id,
           target_turn_id,
-          target_run_header_json,
+          target_opening_json,
           claimed_at,
           start_event_id,
           start_kind,
@@ -721,25 +1333,183 @@ 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
+     * containing one of the folded terms. The answer is a superset of the true
+     * matches, never an answer: the caller projects each candidate Session and
+     * re-runs the real predicate on the projected, redacted text.
+     *
+     * Every event payload is scanned, whatever its kind: a message's visible
+     * text — a user or model `text`, a `function_call` intent, the string values
+     * of a `function_response` result — is a JSON string value of the event that
+     * carries it, so a term inside the projected text is inside the payload
+     * (escaped forms excepted, which the caller routes around). Kinds that never
+     * project only cost the scan a little work.
+     *
+     * A Session with an in-flight partial stream is offered unconditionally: its
+     * arriving text lives in segments a per-row `instr` could straddle, and the
+     * read model presents that text as settled.
+     */
+    async listSessionsWithRuntimeEventText(sessionIds, terms) {
+        if (sessionIds.length === 0 || terms.length === 0)
+            return [];
+        for (const sessionId of sessionIds)
+            assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        for (const term of terms)
+            assertFoldedSearchTerm(term);
+        const sessions = sessionIds.map(() => '?').join(', ');
+        const rows = this.db
+            .prepare(`
+        SELECT DISTINCT session_id
+          FROM runtime_events
+         WHERE session_id IN (${sessions})
+           AND (${recallFoldedMatchClause('payload_json', terms.length)})
+        UNION
+        SELECT DISTINCT session_id
+          FROM runtime_partial_snapshots
+         WHERE session_id IN (${sessions})
+        `)
+            .all(...sessionIds, ...terms, ...sessionIds);
+        return rows.map((row) => {
+            if (typeof row.session_id !== 'string')
+                throw new Error('Invalid recall candidate row');
+            return row.session_id;
+        });
+    }
+    /**
+     * How many ledger events could project to a searchable message, for
+     * recall's idf term. Counted by event kind rather than by projecting, so it
+     * is cheap and identical whichever path recall takes to find its hits.
+     */
+    async countRuntimeEventMessages(sessionIds) {
+        if (sessionIds.length === 0)
+            return 0;
+        for (const sessionId of sessionIds)
+            assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        const sessions = sessionIds.map(() => '?').join(', ');
+        const row = this.db
+            .prepare(`
+        SELECT count(*) AS total
+          FROM runtime_events
+         WHERE session_id IN (${sessions})
+           AND event_kind IN ('text', 'function_call', 'function_response')
+        `)
+            .get(...sessionIds);
+        return typeof row?.total === 'number' ? row.total : 0;
     }
     async readSessionRuntimeEvents(sessionId) {
         const rows = this.db
@@ -788,6 +1558,58 @@ export class SqliteRuntimeStore {
             return { ordinal: row.ordinal, event };
         });
     }
+    async resequenceSessionEventOrdinals(sessionId) {
+        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        this.transaction(() => {
+            // Lifted above the range first: the second statement renumbers into the
+            // space these rows occupy, and (session_id, ordinal) is a primary key.
+            // Shifting up rather than below zero keeps every intermediate value
+            // inside the table's own `ordinal > 0`, and lands them past the 1..N the
+            // renumber assigns, since the count cannot exceed the maximum.
+            const { shift } = this.db
+                .prepare(`
+        SELECT COALESCE(MAX(ordinal), 0) AS shift
+        FROM runtime_session_event_ordinals
+        WHERE session_id = ?
+      `)
+                .get(sessionId);
+            this.db
+                .prepare(`
+        UPDATE runtime_session_event_ordinals
+        SET ordinal = ordinal + :shift
+        WHERE session_id = :sessionId
+      `)
+                .run({ sessionId, shift });
+            this.db
+                .prepare(`
+        WITH opening AS (
+          SELECT invocation_id, CAST(json_extract(payload_json, '$.ts') AS INTEGER) AS opened_at
+          FROM runtime_events
+          WHERE session_id = :sessionId AND event_kind = 'invocation_opened'
+        ),
+        ordered AS MATERIALIZED (
+          SELECT
+            o.event_id AS event_id,
+            ROW_NUMBER() OVER (
+              ORDER BY COALESCE(opening.opened_at, e.committed_at), e.invocation_id, o.ordinal
+            ) AS ordinal
+          FROM runtime_session_event_ordinals o
+          JOIN runtime_events e ON e.event_id = o.event_id
+          LEFT JOIN opening ON opening.invocation_id = e.invocation_id
+          WHERE o.session_id = :sessionId
+        )
+        UPDATE runtime_session_event_ordinals
+        SET ordinal = (
+          SELECT ordered.ordinal
+          FROM ordered
+          WHERE ordered.event_id = runtime_session_event_ordinals.event_id
+        )
+        WHERE session_id = :sessionId
+      `)
+                .run({ sessionId });
+            rebuildTranscriptTurnExtents(this.db, sessionId);
+        });
+    }
     async #commitWorkspaceBaseline(input, rootId) {
         const events = buildWorkspaceBaselineAuthorityEvents(input);
         return this.transaction(() => {
@@ -1063,8 +1885,7 @@ export class SqliteRuntimeStore {
         });
     }
     registerWorkspaceBaselineAuthorityWriter() {
-        const readWorkspaceHead = this.readWorkspaceHead.bind(this);
-        registerWorkspaceBaselineAuthorityWriterInternal(this, (input, rootId) => this.#commitWorkspaceBaseline(input, rootId), (input, rootId) => this.#commitWorkspaceSuccessor(input, rootId), (input, rootId) => this.#commitManagedMutationTerminal(input, rootId), (rootId) => this.#bindWorkspaceStorageRoot(rootId), readWorkspaceHead, (workspaceInstanceId) => this.#readActiveManagedMutation(workspaceInstanceId));
+        registerWorkspaceBaselineAuthorityWriterInternal(this, (input, rootId) => this.#commitWorkspaceBaseline(input, rootId), (input, rootId) => this.#commitWorkspaceSuccessor(input, rootId), (input, rootId) => this.#commitManagedMutationTerminal(input, rootId), (rootId) => this.#bindWorkspaceStorageRoot(rootId), (workspaceInstanceId) => this.#readActiveManagedMutation(workspaceInstanceId));
     }
     async #readActiveManagedMutation(workspaceInstanceId) {
         return this.readTransaction(() => {
@@ -1800,25 +2621,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
@@ -1833,9 +2666,69 @@ 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());
     }
+    /** Rebuild one Session's disposable tool projections while its owner holds a fence. */
+    async rebuildToolProjectionsForSession(sessionId) {
+        await this.transaction(() => this.rebuildToolProjectionsFromRuntimeEventsSync(sessionId));
+    }
+    /**
+     * Repair terminal projections for unsettled tools without decoding the
+     * Session's full RuntimeEvent history. Bundle export is a compatibility
+     * boundary: unrelated historical payloads may be byte-preserved and newer
+     * or older than the RuntimeEvent schema understood by this build.
+     */
+    async rebuildTerminalToolProjectionsForSessions(sessionIds) {
+        const operations = await this.listUnsettledToolOperations(sessionIds);
+        if (operations.length === 0)
+            return;
+        this.transaction(() => {
+            const dispatchSequence = this.db.prepare(`
+        SELECT event_seq
+        FROM runtime_events
+        WHERE event_id = ? AND session_id = ? AND invocation_id = ?
+      `);
+            const firstTerminal = this.db.prepare(`
+        SELECT event_id, event_seq, committed_at
+        FROM runtime_events
+        WHERE session_id = ? AND invocation_id = ?
+          AND ${TERMINAL_RUNTIME_EVENT_SQL}
+        ORDER BY event_seq ASC, event_id ASC
+        LIMIT 1
+      `);
+            const insertJournal = this.db.prepare(`
+        INSERT INTO tool_journal_events (
+          journal_event_id, operation_id, invocation_id, run_id, turn_id, state,
+          runtime_event_id, canonical_args_hash, recovery_mode, committed_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            const updateOperation = this.db.prepare(`
+        UPDATE tool_operations
+        SET current_state = ?, version = version + 1
+        WHERE operation_id = ? AND current_state = 'prepared' AND result_event_id IS NULL
+      `);
+            for (const operation of operations) {
+                if (!operation.dispatchEventId)
+                    continue;
+                const dispatch = dispatchSequence.get(operation.dispatchEventId, operation.sessionId, operation.invocationId);
+                if (!dispatch)
+                    continue;
+                const terminal = firstTerminal.get(operation.sessionId, operation.invocationId);
+                if (!terminal || terminal.event_seq <= dispatch.event_seq)
+                    continue;
+                const state = operation.toolName === 'AskUserQuestion' && operation.recoveryMode === 'never_auto_retry'
+                    ? 'abandoned'
+                    : 'interrupted_unknown';
+                insertJournal.run(journalEventIdFor(operation.operationId, terminal.event_id, state), operation.operationId, operation.invocationId, operation.runId, operation.turnId, state, terminal.event_id, operation.canonicalArgsHash, operation.recoveryMode, terminal.committed_at);
+                const updated = updateOperation.run(state, operation.operationId);
+                if (updated.changes !== 1) {
+                    throw new Error(`Tool operation projection changed during export: ${operation.operationId}`);
+                }
+            }
+        });
+    }
     rebuildToolProjectionsFromRuntimeEventsSync(sessionId) {
         const statement = this.db.prepare(`
         SELECT event_id, session_id, invocation_id, run_id, turn_id,
@@ -1849,6 +2742,14 @@ export class SqliteRuntimeStore {
             : statement.all(sessionId));
         const events = rows.map(decodeRuntimeEventStorageRow);
         const eventOrder = new Map(events.map((event, index) => [event.id, index]));
+        const runtimeInvocationKey = (event) => JSON.stringify([event.sessionId, event.invocationId]);
+        const terminalEventsByInvocation = new Map();
+        for (const event of events) {
+            if (isTerminalRuntimeEvent(event) &&
+                !terminalEventsByInvocation.has(runtimeInvocationKey(event))) {
+                terminalEventsByInvocation.set(runtimeInvocationKey(event), event);
+            }
+        }
         const committedAt = new Map(rows.map((row, index) => [events[index].id, row.committed_at]));
         const scan = scanToolLedger(events);
         if (scan.hasCorruption) {
@@ -1906,6 +2807,21 @@ export class SqliteRuntimeStore {
             }
             const reconcileEvent = recovery.kind === 'valid' ? recovery.reconcileEvent : undefined;
             const decisionEvent = recovery.kind === 'valid' ? recovery.decisionEvent : undefined;
+            const decision = recovery.kind === 'valid' ? recovery.decision : undefined;
+            const terminalEvent = terminalEventsByInvocation.get(runtimeInvocationKey(event));
+            const terminalAfterDispatch = terminalEvent !== undefined &&
+                requireRuntimeEventOrder(eventOrder, terminalEvent.id) >
+                    requireRuntimeEventOrder(eventOrder, event.id);
+            const abandoned = !decision &&
+                !operation.responseEvent &&
+                dispatch.toolName === 'AskUserQuestion' &&
+                dispatch.recoveryMode === 'never_auto_retry' &&
+                terminalAfterDispatch;
+            // A terminal invocation closes the tool's execution window, but does not
+            // prove whether an external side effect completed. Preserve that
+            // uncertainty in the query projection without rewriting the immutable
+            // RuntimeEvent history.
+            const interruptedUnknown = !decision && !operation.responseEvent && !abandoned && terminalAfterDispatch;
             this.db
                 .prepare(`
           INSERT INTO tool_journal_events (
@@ -1916,14 +2832,17 @@ export class SqliteRuntimeStore {
                 .run(`${dispatch.operationId}_prepared`, dispatch.operationId, event.invocationId, event.runId, event.turnId, event.id, dispatch.canonicalArgsHash, dispatch.recoveryMode, committedAt.get(event.id) ?? event.ts);
             journalEvents += 1;
             const response = operation.responseEvent;
-            const decision = recovery.kind === 'valid' ? recovery.decision : undefined;
             const currentState = decision
                 ? decision.disposition === 'completed'
                     ? 'recovery_completed'
                     : 'recovery_parked'
                 : response
                     ? 'outcome_committed'
-                    : 'prepared';
+                    : abandoned
+                        ? 'abandoned'
+                        : interruptedUnknown
+                            ? 'interrupted_unknown'
+                            : 'prepared';
             const tail = [
                 ...(reconcileEvent
                     ? [{ event: reconcileEvent, state: 'reconcile_observed' }]
@@ -1939,6 +2858,12 @@ export class SqliteRuntimeStore {
                         },
                     ]
                     : []),
+                ...(abandoned && terminalEvent
+                    ? [{ event: terminalEvent, state: 'abandoned' }]
+                    : []),
+                ...(interruptedUnknown && terminalEvent
+                    ? [{ event: terminalEvent, state: 'interrupted_unknown' }]
+                    : []),
             ].sort((a, b) => requireRuntimeEventOrder(eventOrder, a.event.id) -
                 requireRuntimeEventOrder(eventOrder, b.event.id));
             this.db
@@ -1958,7 +2883,7 @@ export class SqliteRuntimeStore {
               runtime_event_id, canonical_args_hash, recovery_mode, metadata_json, committed_at
             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
           `)
-                    .run(journalEventIdFor(dispatch.operationId, item.event, item.state), dispatch.operationId, item.event.invocationId, item.event.runId, item.event.turnId, item.state, item.event.id, dispatch.canonicalArgsHash, dispatch.recoveryMode, item.event.actions?.toolRecovery
+                    .run(journalEventIdFor(dispatch.operationId, item.event.id, item.state), dispatch.operationId, item.event.invocationId, item.event.runId, item.event.turnId, item.state, item.event.id, dispatch.canonicalArgsHash, dispatch.recoveryMode, item.event.actions?.toolRecovery
                     ? JSON.stringify(item.event.actions.toolRecovery)
                     : null, committedAt.get(item.event.id) ?? item.event.ts);
                 journalEvents += 1;
@@ -1986,6 +2911,11 @@ export class SqliteRuntimeStore {
         const dispatchEvent = dispatchJson
             ? decodeRuntimeEvent(JSON.parse(dispatchJson))
             : undefined;
+        if (dispatchEvent?.actions?.toolDispatch?.resultProjectionVersion === 1 &&
+            input.runtimeEvent.content?.kind === 'function_response' &&
+            input.runtimeEvent.content.modelProjection === undefined) {
+            throw new Error('Projected Tool Result T2 requires its durable model projection');
+        }
         if (dispatchEvent?.actions?.toolDispatch?.managedMutation) {
             const reservation = this.db
                 .prepare(`
@@ -2089,13 +3019,21 @@ 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 {
-            const result = operation();
+            result = operation();
             this.db.exec('COMMIT');
-            return result;
         }
         catch (error) {
             try {
@@ -2104,8 +3042,38 @@ 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) {
+        if (this.uncommittedEventSessions.size === 0 && this.databaseLease) {
+            this.databaseLease.onTransactionSettled((committed) => this.settleEventCommits(committed));
+        }
+        this.uncommittedEventSessions.add(sessionId);
+    }
+    settleEventCommits(committed) {
+        const sessionIds = [...this.uncommittedEventSessions];
+        this.uncommittedEventSessions.clear();
+        if (!committed)
+            return;
+        for (const sessionId of sessionIds) {
+            for (const listener of this.eventCommitListeners)
+                listener(sessionId);
+        }
+    }
+    subscribeRuntimeEventCommits(listener) {
+        this.eventCommitListeners.add(listener);
+        return () => this.eventCommitListeners.delete(listener);
     }
     readTransaction(operation) {
         if (this.databaseLease)
@@ -2145,7 +3113,7 @@ export class SqliteRuntimeStore {
           target_invocation_id,
           target_run_id,
           target_turn_id,
-          target_run_header_json,
+          target_opening_json,
           claimed_at,
           start_event_id,
           start_kind,
@@ -2175,7 +3143,7 @@ export class SqliteRuntimeStore {
           target_invocation_id,
           target_run_id,
           target_turn_id,
-          target_run_header_json,
+          target_opening_json,
           claimed_at,
           start_event_id,
           start_kind,
@@ -2196,6 +3164,7 @@ export class SqliteRuntimeStore {
             target.invocationId,
             target.sessionId,
             target.runId,
+            claim.targetOpening.source.kind === 'handoff' ? 1 : 0,
             target.sessionId,
             target.turnId,
         ];
@@ -2205,7 +3174,7 @@ export class SqliteRuntimeStore {
         FROM runtime_events
         WHERE invocation_id = ?
           OR (session_id = ? AND run_id = ?)
-          OR (session_id = ? AND turn_id = ?)
+          OR (? = 0 AND session_id = ? AND turn_id = ?)
         LIMIT 1
       `)
             .get(...values);
@@ -2217,7 +3186,7 @@ export class SqliteRuntimeStore {
           FROM runtime_partial_snapshots
           WHERE invocation_id = ?
             OR (session_id = ? AND run_id = ?)
-            OR (session_id = ? AND turn_id = ?)
+            OR (? = 0 AND session_id = ? AND turn_id = ?)
           LIMIT 1
         `)
             .get(...values) !== undefined);
@@ -2242,6 +3211,7 @@ export class SqliteRuntimeStore {
     }
     assertContinuationBoundaryMatchesLedger(claim) {
         const lastIndex = claim.boundary.segments.length - 1;
+        let previousPrefix;
         for (const [index, segment] of claim.boundary.segments.entries()) {
             let prefix;
             try {
@@ -2269,74 +3239,299 @@ export class SqliteRuntimeStore {
                     ? 'Continuation source boundary changed'
                     : `Continuation ancestor boundary changed for ${segment.identity.runId}`);
             }
+            const opening = prefix.events[0]?.content;
+            const repeatsTurn = previousPrefix?.identity.turnId === prefix.identity.turnId;
+            if (repeatsTurn ||
+                (opening?.kind === 'invocation_opened' && opening.source.kind === 'handoff')) {
+                if (!previousPrefix ||
+                    opening?.kind !== 'invocation_opened' ||
+                    opening.source.kind !== 'handoff') {
+                    throw new Error('Same-turn boundary requires an authenticated handoff edge');
+                }
+                const row = this.readContinuationClaimRow('claim_id = ?', opening.source.claimId);
+                const state = row && this.decodeContinuationClaimStateRow(row);
+                if (!state ||
+                    state.startEventId !== prefix.events[0]?.id ||
+                    !isDeepStrictEqual(state.claim.boundary.segments, claim.boundary.segments.slice(0, index)) ||
+                    !continuationStartEventMatchesClaim(prefix.events[0], state.claim, state.startKind)) {
+                    throw new Error('Same-turn boundary handoff claim does not authenticate its lineage');
+                }
+                assertHandoffClaimSource(state.claim, previousPrefix);
+            }
             if (index === lastIndex) {
+                assertHandoffClaimSource(claim, prefix);
                 const terminalEvents = prefix.events.filter(isTerminalRuntimeEvent);
                 const terminal = terminalEvents[0];
                 if (terminalEvents.length !== 1 || !terminal || prefix.events.at(-1)?.id !== terminal.id) {
                     throw new Error('Continuation source boundary must end with exactly one terminal RuntimeEvent');
                 }
             }
+            previousPrefix = prefix;
         }
     }
     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;
@@ -2407,16 +3602,27 @@ export class SqliteRuntimeStore {
         }
     }
     assertContinuationAuthorityAllowsEvent(event, authorizedPendingClaimId, exactRetry = false) {
-        for (const row of this.readContinuationClaimRows()) {
+        const rows = this.readContinuationClaimRows();
+        const ownClaim = rows.find((row) => row.target_session_id === event.sessionId &&
+            row.target_invocation_id === event.invocationId &&
+            row.target_run_id === event.runId &&
+            row.target_turn_id === event.turnId);
+        const ownHandoff = ownClaim && decodeContinuationClaimRow(ownClaim);
+        for (const row of rows) {
             const claim = decodeContinuationClaimRow(row);
             const source = claim.boundary.segments.find((segment) => segment.identity.sessionId === event.sessionId && segment.identity.runId === event.runId);
             if (source && !exactRetry) {
                 throw new Error(`RuntimeEvent source boundary is sealed by continuation claim ${claim.claimId}`);
             }
+            if (source && exactRetry)
+                continue;
             const target = claim.target;
             const collidesWithTarget = event.invocationId === target.invocationId ||
                 (event.sessionId === target.sessionId && event.runId === target.runId) ||
-                (event.sessionId === target.sessionId && event.turnId === target.turnId);
+                (event.sessionId === target.sessionId &&
+                    event.turnId === target.turnId &&
+                    !(ownHandoff?.targetOpening.source.kind === 'handoff' &&
+                        ownHandoff.boundary.segments.some((segment) => segment.identity.runId === target.runId)));
             if (!collidesWithTarget)
                 continue;
             if (event.sessionId !== target.sessionId ||
@@ -2436,11 +3642,7 @@ export class SqliteRuntimeStore {
         SELECT event_id, session_id, invocation_id, run_id, turn_id, payload_json
         FROM runtime_events
         WHERE session_id = ? AND run_id = ?
-          AND (
-            json_extract(payload_json, '$.actions.endInvocation') = 1
-            OR json_extract(payload_json, '$.status')
-              IN ('completed', 'failed', 'aborted', 'cancelled')
-          )
+          AND ${TERMINAL_RUNTIME_EVENT_SQL}
         ORDER BY event_seq ASC
       `)
             .all(event.sessionId, event.runId);
@@ -2449,7 +3651,7 @@ export class SqliteRuntimeStore {
             throw new RunSealedError(event.runId);
         }
     }
-    importRuntimeEventSync(event) {
+    importRuntimeEventSync(event, allowLegacyTerminalWithUnsettledOperation = false) {
         const canonicalEvent = canonicalizeRuntimeEventForStorage(event);
         this.assertInvocationIdentity([canonicalEvent]);
         const partial = partialRuntimeStream(canonicalEvent);
@@ -2468,6 +3670,21 @@ export class SqliteRuntimeStore {
         // consult either.
         if (!existing) {
             this.assertContinuationAuthorityAllowsEvent(canonicalEvent);
+            if (isTerminalRuntimeEvent(canonicalEvent) && !allowLegacyTerminalWithUnsettledOperation) {
+                const unresolved = this.db
+                    .prepare(`
+            SELECT operation_id FROM tool_operations
+            WHERE invocation_id = ?
+              AND current_state = 'prepared'
+              AND result_event_id IS NULL
+              AND dispatch_event_id IS NOT NULL
+            LIMIT 1
+          `)
+                    .get(canonicalEvent.invocationId);
+                if (unresolved && typeof unresolved.operation_id === 'string') {
+                    throw new Error(`Cannot terminalize invocation ${canonicalEvent.invocationId} with unsettled tool operation ${unresolved.operation_id}`);
+                }
+            }
             this.assertRunNotSealed(canonicalEvent);
         }
         if (isToolLedgerBearingEvent(canonicalEvent)) {
@@ -2512,21 +3729,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);
@@ -2542,6 +3766,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);
@@ -2572,7 +3799,12 @@ export class SqliteRuntimeStore {
         VALUES (?, ?, ?)
       `)
             .run(canonicalEvent.sessionId, ordinal, canonicalEvent.id);
+        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) {
@@ -2746,93 +3978,6 @@ function toolJournalRecordFromRow(row) {
         committedAt: row.committed_at,
     };
 }
-function assertPreparedInput(input) {
-    if (input.journalEventId !== `${input.operationId}_prepared`) {
-        throw new Error('T1 journal identity must be derived from the tool operation');
-    }
-    assertNoReservedRecoveryFact(input.runtimeEvent);
-    assertNoReservedRecoveryFact(input.dispatchRuntimeEvent);
-    const content = input.runtimeEvent.content;
-    if (content?.kind !== 'function_call')
-        throw new Error('T1 requires a function_call RuntimeEvent');
-    if (content.id !== input.providerToolCallId || content.name !== input.toolName) {
-        throw new Error('T1 RuntimeEvent identity does not match the tool operation');
-    }
-    let derivedArgsHash;
-    try {
-        derivedArgsHash = canonicalToolArgsHash(content.name, content.args);
-    }
-    catch {
-        throw new Error('T1 argument hash does not match its canonical function call');
-    }
-    if (derivedArgsHash !== input.canonicalArgsHash ||
-        validateToolLedgerEventLane(input.runtimeEvent).ok !== true) {
-        throw new Error('T1 argument hash does not match its canonical function call');
-    }
-    const dispatch = input.dispatchRuntimeEvent.actions?.toolDispatch;
-    if (!dispatch ||
-        input.dispatchRuntimeEvent.content !== undefined ||
-        input.dispatchRuntimeEvent.partial ||
-        dispatch.operationId !== input.operationId ||
-        dispatch.providerToolCallId !== input.providerToolCallId ||
-        dispatch.toolName !== input.toolName ||
-        dispatch.canonicalArgsHash !== input.canonicalArgsHash ||
-        dispatch.recoveryMode !== input.recoveryMode ||
-        validateToolLedgerEventLane(input.dispatchRuntimeEvent).ok !== true) {
-        throw new Error('T1 requires a matching tool-dispatch RuntimeEvent');
-    }
-    assertSameRuntimeIdentity(input.runtimeEvent, input.dispatchRuntimeEvent, 'T1');
-}
-function assertOutcomeInput(input) {
-    if (input.journalEventId !== `${input.operationId}_outcome`) {
-        throw new Error('T2 journal identity must be derived from the tool operation');
-    }
-    assertNoReservedRecoveryFact(input.runtimeEvent);
-    const content = input.runtimeEvent.content;
-    if (content?.kind !== 'function_response') {
-        throw new Error('T2 requires a function_response RuntimeEvent');
-    }
-    if (input.runtimeEvent.refs?.operationId !== input.operationId ||
-        input.runtimeEvent.refs?.toolCallId !== content.id) {
-        throw new Error('T2 requires operation and tool-call refs on the function_response RuntimeEvent');
-    }
-    if (validateToolLedgerEventLane(input.runtimeEvent).ok !== true) {
-        throw new Error('T2 requires one canonical function-response semantic lane');
-    }
-}
-function assertPreparedIdentity(operation, input) {
-    const event = input.runtimeEvent;
-    const matches = operation.invocationId === event.invocationId &&
-        operation.runId === event.runId &&
-        operation.turnId === event.turnId &&
-        operation.providerToolCallId === input.providerToolCallId &&
-        operation.toolName === input.toolName &&
-        operation.canonicalArgsHash === input.canonicalArgsHash &&
-        operation.recoveryMode === input.recoveryMode &&
-        operation.callEventId === event.id &&
-        operation.dispatchEventId === input.dispatchRuntimeEvent.id;
-    if (!matches)
-        throw new Error(`Tool operation identity conflict for ${input.operationId}`);
-}
-function assertSameRuntimeIdentity(first, second, boundary) {
-    if (first.sessionId !== second.sessionId ||
-        first.invocationId !== second.invocationId ||
-        first.runId !== second.runId ||
-        first.turnId !== second.turnId) {
-        throw new Error(`${boundary} RuntimeEvents do not share one execution identity`);
-    }
-}
-function assertOutcomeIdentity(operation, event) {
-    const content = event.content;
-    const matches = content?.kind === 'function_response' &&
-        operation.invocationId === event.invocationId &&
-        operation.runId === event.runId &&
-        operation.turnId === event.turnId &&
-        operation.providerToolCallId === content.id &&
-        operation.toolName === content.name;
-    if (!matches)
-        throw new Error(`Tool operation outcome identity conflict for ${operation.operationId}`);
-}
 function assertRuntimeEventIdentity(event) {
     decodeRuntimeEvent(event);
     for (const [field, value] of Object.entries({
@@ -2912,8 +4057,16 @@ function requireRuntimeEventOrder(eventOrder, eventId) {
         throw new Error(`Missing RuntimeEvent order for ${eventId}`);
     return order;
 }
-function journalEventIdFor(operationId, event, state) {
-    return state === 'outcome_committed' ? `${operationId}_outcome` : `${event.id}_journal`;
+function journalEventIdFor(operationId, eventId, state) {
+    if (state === 'outcome_committed')
+        return `${operationId}_outcome`;
+    if (state === 'abandoned' || state === 'interrupted_unknown') {
+        // One invocation terminal can close multiple tool operations. Its journal
+        // fact is therefore unique per operation, unlike per-operation recovery
+        // events whose RuntimeEvent ids are already distinct.
+        return `${operationId}_${eventId}_journal`;
+    }
+    return `${eventId}_journal`;
 }
 function assertRecoveryAuthorityCapability(db) {
     const row = db
@@ -2924,45 +4077,7 @@ function assertRecoveryAuthorityCapability(db) {
     }
 }
 function assertContinuationStartEvent(claim, event, startKind) {
-    const start = event.actions?.continuationStart;
-    const runtimeProtocol = event.actions?.runtimeProtocol;
-    const actionKeys = event.actions ? Object.keys(event.actions) : [];
-    const validActionShape = actionKeys.includes('continuationStart') &&
-        actionKeys.every((key) => key === 'continuationStart' || key === 'runtimeProtocol') &&
-        actionKeys.length === (runtimeProtocol === undefined ? 1 : 2);
-    const validRuntimeProtocol = runtimeProtocol === undefined ||
-        (startKind === 'runtime_admission' &&
-            runtimeProtocol.toolBoundary === TOOL_BOUNDARY_PROTOCOL_V1);
-    const source = claim.boundary.segments.at(-1);
-    if (event.sessionId !== claim.target.sessionId ||
-        event.invocationId !== claim.target.invocationId ||
-        event.runId !== claim.target.runId ||
-        event.turnId !== claim.target.turnId ||
-        event.ts < claim.claimedAt ||
-        event.partial ||
-        event.role !== 'system' ||
-        event.author !== 'system' ||
-        event.status !== undefined ||
-        event.content !== undefined ||
-        !event.actions ||
-        !validActionShape ||
-        !validRuntimeProtocol ||
-        !start ||
-        start.protocol !== 'continuation_start_v2' ||
-        start.provenance !== startKind ||
-        start.claimId !== claim.claimId ||
-        start.boundaryDigest !== claim.boundaryDigest ||
-        start.replayManifestDigest !== claim.boundary.manifestDigest ||
-        start.providerProjectionVersion !== claim.providerProjectionVersion ||
-        start.providerReplayDigest !== claim.providerReplayDigest ||
-        !isDeepStrictEqual(start.immediateSource, {
-            sessionId: source.identity.sessionId,
-            invocationId: source.identity.invocationId,
-            runId: source.identity.runId,
-            turnId: source.identity.turnId,
-            highWater: source.position.lastEventSeq,
-            prefixDigest: source.prefixDigest,
-        })) {
+    if (!continuationStartEventMatchesClaim(event, claim, startKind)) {
         throw new Error('Invalid continuation-start authority event');
     }
 }
@@ -2978,6 +4093,24 @@ 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');
+    }
+}
 function assertWorkspaceVersionAuthorityCapability(db) {
     const row = db
         .prepare('SELECT version FROM runtime_capabilities WHERE capability = ?')
@@ -3180,114 +4313,12 @@ function decodeRuntimePartialStorageRow(row) {
 function decodeStoredRuntimeEvent(storedJson) {
     return decodeRuntimeEvent(JSON.parse(storedJson));
 }
-function runtimeEventKind(event) {
-    return (event.content?.kind ??
-        event.status ??
-        (event.actions?.workspaceFact ? 'workspace_fact' : undefined) ??
-        (event.actions?.toolDispatch ? 'tool_dispatch' : undefined) ??
-        (event.actions?.endInvocation ? 'invocation_end' : 'runtime_fact'));
-}
-function mergeRuntimePartialSnapshots(immutableEvents, snapshots) {
-    const { leading, afterEvent } = groupRuntimePartialSnapshots(snapshots);
-    const merged = leading.sort(compareRuntimePartialSnapshots).map(({ event }) => event);
-    for (const event of immutableEvents) {
-        merged.push(event);
-        const anchored = afterEvent.get(event.id);
-        if (!anchored)
-            continue;
-        merged.push(...anchored.sort(compareRuntimePartialSnapshots).map((snapshot) => snapshot.event));
-        afterEvent.delete(event.id);
-    }
-    for (const orphaned of afterEvent.values()) {
-        merged.push(...orphaned.sort(compareRuntimePartialSnapshots).map((snapshot) => snapshot.event));
-    }
-    return merged;
-}
-function groupRuntimePartialSnapshots(snapshots) {
-    const leading = [];
-    const afterEvent = new Map();
-    for (const snapshot of snapshots) {
-        if (!snapshot.afterEventId) {
-            leading.push(snapshot);
-            continue;
-        }
-        const grouped = afterEvent.get(snapshot.afterEventId) ?? [];
-        grouped.push(snapshot);
-        afterEvent.set(snapshot.afterEventId, grouped);
-    }
-    return { leading, afterEvent };
-}
-function compareRuntimePartialSnapshots(left, right) {
-    return left.event.ts - right.event.ts || left.event.id.localeCompare(right.event.id);
-}
-function partialRuntimeStream(event) {
-    if (!event.partial || event.status !== undefined || event.actions)
-        return undefined;
-    const content = event.content;
-    let identity;
-    let text = '';
-    if (content?.kind === 'text' &&
-        content.attachments === undefined &&
-        event.refs?.providerEventId &&
-        hasOnlyKeys(event.refs, ['providerEventId'])) {
-        identity = `${content.kind}:provider:${event.refs.providerEventId}`;
-        text = content.text;
-    }
-    else if (content?.kind === 'thinking' &&
-        content.signature === undefined &&
-        event.refs?.providerEventId &&
-        hasOnlyKeys(event.refs, ['providerEventId'])) {
-        identity = `${content.kind}:provider:${event.refs.providerEventId}`;
-        text = content.text;
-    }
-    else if (!content && event.refs?.toolCallId && hasOnlyKeys(event.refs, ['toolCallId'])) {
-        identity = `tool:call:${event.refs.toolCallId}`;
-    }
-    if (!identity)
-        return undefined;
-    const key = runtimePartialStreamKey(identity, event);
-    const snapshot = content?.kind === 'text' || content?.kind === 'thinking'
-        ? { ...event, content: { ...content, text: '' } }
-        : event;
-    return { key, snapshot, text };
-}
-function completedPartialRuntimeStreamKey(event) {
-    if (event.partial)
-        return undefined;
-    const content = event.content;
-    let identity;
-    if ((content?.kind === 'text' || content?.kind === 'thinking') && event.refs?.providerEventId) {
-        identity = `${content.kind}:provider:${event.refs.providerEventId}`;
-    }
-    else if (content?.kind === 'function_response' && event.refs?.toolCallId) {
-        identity = `tool:call:${event.refs.toolCallId}`;
-    }
-    return identity ? runtimePartialStreamKey(identity, event) : undefined;
-}
-function runtimePartialStreamKey(identity, event) {
-    return createHash('sha256')
-        .update(JSON.stringify([
-        identity,
-        event.sessionId,
-        event.invocationId,
-        event.runId,
-        event.turnId,
-        event.branch ?? null,
-        event.role,
-        event.author,
-    ]))
-        .digest('hex');
-}
-function hasOnlyKeys(value, allowed) {
-    const allowedSet = new Set(allowed);
-    return Object.keys(value).every((key) => allowedSet.has(key));
-}
 function decodeContinuationClaimRow(row) {
     if (row.protocol_version !== 1) {
         throw new Error(`Unsupported continuation claim protocol ${row.protocol_version}`);
     }
     const boundary = JSON.parse(row.boundary_json);
-    const targetRunHeader = decodePersistedAgentRunHeader(markPersisted(JSON.parse(row.target_run_header_json)));
+    const targetOpening = JSON.parse(row.target_opening_json);
     const claim = decodeContinuationClaim({
         protocol: 'continuation_claim_v1',
         claimId: row.claim_id,
@@ -3301,7 +4332,7 @@ function decodeContinuationClaimRow(row) {
             runId: row.target_run_id,
             turnId: row.target_turn_id,
         },
-        targetRunHeader,
+        targetOpening,
         claimedAt: row.claimed_at,
     });
     const source = claim.boundary.segments.at(-1);