@orion-agents/orion-code 0.3.2 → 0.3.7

package/dist/runtime/thread-event-store.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreadEventStore = exports.ThreadEventStoreError = void 0;
+exports.threadEventStorePerformanceCountersV1 = threadEventStorePerformanceCountersV1;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const atomic_write_1 = require("../services/atomic-write");
@@ -21,6 +22,19 @@ exports.ThreadEventStoreError = ThreadEventStoreError;
 const DEFAULT_MAX_LOG_BYTES = 128 * 1024 * 1024;
 const DEFAULT_MAX_REPLAY_EVENTS = 10000;
 const DEFAULT_LOCK_WAIT_MS = 10000;
+const threadEventStorePerformance = {
+    logScans: 0,
+    bytesScanned: 0,
+    eventsScanned: 0,
+    scanReasons: {},
+};
+/** Process-local monotonic read counters for diagnostics and switch budgets. */
+function threadEventStorePerformanceCountersV1() {
+    return Object.freeze({
+        ...threadEventStorePerformance,
+        scanReasons: Object.freeze({ ...threadEventStorePerformance.scanReasons }),
+    });
+}
 /**
  * Append-only durable fact store for a single Thread.
  *
@@ -57,7 +71,12 @@ class ThreadEventStore {
         }
         const commit = this.withLogLock(() => {
             ensurePrivateDirectory(this.rootDir);
-            const head = this.loadVerifiedHead();
+            let head = this.loadVerifiedHead();
+            if (!(0, thread_projection_1.hasCurrentThreadProjectionShapeV1)(head.projection)) {
+                // An older projection cannot be incrementally advanced because it did
+                // not retain all diagnostic/compact history. Rebuild from facts once.
+                head = this.loadVerifiedHead(true, 'projection_schema_upgrade');
+            }
             if (head.discardedTailBytes > 0)
                 (0, fs_1.truncateSync)(this.logPath, head.safeByteLength);
             let seq = head.projection.cursor;
@@ -172,7 +191,7 @@ class ThreadEventStore {
         (0, runtime_protocol_v1_1.assertRuntimeEventEnvelopeV1)(event);
         return deepFreeze(event);
     }
-    replay(cursor = 0, limit = this.maxReplayEvents) {
+    replay(cursor = 0, limit = this.maxReplayEvents, reason = 'direct') {
         if (!Number.isSafeInteger(cursor) || cursor < 0) {
             throw new ThreadEventStoreError('ORION_THREAD_EVENT_CURSOR', 'Replay cursor must be a non-negative safe integer');
         }
@@ -181,7 +200,7 @@ class ThreadEventStore {
             throw new ThreadEventStoreError('ORION_THREAD_EVENT_LIMIT', `Replay limit ${safeLimit} exceeds ${this.maxReplayEvents}`);
         }
         return this.withLogLock(() => {
-            const scan = requireVerifiedScan(this.loadVerifiedHead(true));
+            const scan = requireVerifiedScan(this.loadVerifiedHead(true, `replay:${reason}`));
             const lastSeq = scan.events.length;
             if (cursor > lastSeq) {
                 throw new ThreadEventStoreError('ORION_THREAD_EVENT_CURSOR', `Replay cursor ${cursor} is ahead of durable cursor ${lastSeq}`);
@@ -202,7 +221,7 @@ class ThreadEventStore {
      * exact log identity/projection checkpoint remains current. Internal append
      * carries the proof forward because the hash-chained prefix cannot change.
      */
-    verifyDurablePrefix(cursor, eventDigest, projectionDigest) {
+    verifyDurablePrefix(cursor, eventDigest, projectionDigest, projectionDigestVersion) {
         if (!Number.isSafeInteger(cursor) ||
             cursor <= 0 ||
             !isSha256(eventDigest) ||
@@ -213,21 +232,31 @@ class ThreadEventStore {
             let head = this.loadVerifiedHead();
             if (cursor > head.projection.cursor)
                 return false;
-            const expected = { cursor, eventDigest, projectionDigest };
+            const expected = { cursor, eventDigest, projectionDigest, projectionDigestVersion };
             if (head.verifiedPrefixes.some(prefix => sameVerifiedPrefix(prefix, expected)))
                 return true;
-            head = this.loadVerifiedHead(true);
+            head = this.loadVerifiedHead(true, 'verify_durable_prefix');
             const scan = requireVerifiedScan(head);
             const events = scan.events.slice(0, cursor);
+            const resolvedProjectionDigestVersion = (0, thread_projection_1.resolveThreadProjectionDigestVersionV1)((0, thread_projection_1.projectThreadEvents)(this.threadId, events), projectionDigest, projectionDigestVersion);
             if (events.length !== cursor ||
                 (0, canonical_1.digestRuntimeValue)(events) !== eventDigest ||
-                (0, thread_projection_1.projectThreadEvents)(this.threadId, events).digest !== projectionDigest) {
+                resolvedProjectionDigestVersion === undefined) {
                 return false;
             }
+            const verified = {
+                cursor,
+                eventDigest,
+                projectionDigest,
+                projectionDigestVersion: resolvedProjectionDigestVersion,
+            };
             const next = {
                 ...head,
                 generation: head.generation + 1,
-                verifiedPrefixes: [...head.verifiedPrefixes, expected].sort((left, right) => left.cursor - right.cursor),
+                verifiedPrefixes: [
+                    ...head.verifiedPrefixes.filter(prefix => prefix.cursor !== cursor),
+                    verified,
+                ].sort((left, right) => left.cursor - right.cursor),
             };
             this.cachedHead = next;
             this.tryPersistVerifiedHead(next);
@@ -333,14 +362,14 @@ class ThreadEventStore {
      */
     loadAuthoritativeModelHistory() {
         return this.withLogLock(() => {
-            const scan = requireVerifiedScan(this.loadVerifiedHead(true));
+            const head = this.loadVerifiedHead();
             const state = readCompactState(this.compactStatePath, this.threadId);
             if (state)
                 this.assertCompactCheckpoint(state);
-            const turnState = readLatestDurableTurnState(scan.events, this.threadId);
+            const turnState = readLatestDurableTurnStateFromProjection(head.projection);
             if (!state && !turnState)
                 return undefined;
-            return resolveCompactAuthority(scan.events, state, this.threadId).history;
+            return resolveCompactAuthorityState(turnState, state).history;
         });
     }
     /**
@@ -350,7 +379,7 @@ class ThreadEventStore {
     captureCompactSource(turnId) {
         return this.withLogLock(() => {
             ensurePrivateDirectory(this.rootDir);
-            const head = this.loadVerifiedHead(true);
+            const head = this.loadVerifiedHead(true, 'capture_compact_source');
             const scan = requireVerifiedScan(head);
             const { projection } = head;
             assertActiveMaintenanceTurn(projection, turnId);
@@ -387,7 +416,7 @@ class ThreadEventStore {
             ensurePrivateDirectory(this.compactCheckpointsDir);
             validateCompactCommitInput(input, this.threadId);
             input.onBoundary('before_cas_recheck');
-            const head = this.loadVerifiedHead(true);
+            const head = this.loadVerifiedHead(true, 'compact_cas');
             const scan = requireVerifiedScan(head);
             const { projection } = head;
             const eventsAfterAnchor = scan.events.slice(input.expectedEventAnchor.cursor);
@@ -454,7 +483,10 @@ class ThreadEventStore {
     }
     listCompactEvents() {
         return this.withLogLock(() => {
-            const scan = requireVerifiedScan(this.loadVerifiedHead(true));
+            const projection = this.loadVerifiedHead().projection;
+            if (projection.compactEvents)
+                return projection.compactEvents;
+            const scan = requireVerifiedScan(this.loadVerifiedHead(true, 'legacy_compact_projection'));
             return deepFreeze(scan.events.filter((event) => event.payload.type === 'compact.started' ||
                 event.payload.type === 'compact.completed' ||
                 event.payload.type === 'compact.failed'));
@@ -511,7 +543,7 @@ class ThreadEventStore {
      * projection still match. Callers that need historical events explicitly
      * request a scan; cursor/projection/append paths stay O(head + projection).
      */
-    loadVerifiedHead(requireScan = false) {
+    loadVerifiedHead(requireScan = false, scanReason = 'unspecified') {
         ensurePrivateDirectory(this.rootDir);
         const logIdentity = readFileIdentity(this.logPath);
         if (this.cachedHead?.logFingerprint === logIdentity.fingerprint &&
@@ -528,6 +560,11 @@ class ThreadEventStore {
             }
         }
         const scan = scanThreadEventLog(this.logPath, this.threadId, this.maxLogBytes);
+        threadEventStorePerformance.logScans += 1;
+        threadEventStorePerformance.bytesScanned += scan.safeByteLength + scan.discardedTailBytes;
+        threadEventStorePerformance.eventsScanned += scan.events.length;
+        threadEventStorePerformance.scanReasons[scanReason] =
+            (threadEventStorePerformance.scanReasons[scanReason] ?? 0) + 1;
         this.onLogScan?.({
             threadId: this.threadId,
             bytes: scan.safeByteLength + scan.discardedTailBytes,
@@ -836,7 +873,7 @@ function retainVerifiedPrefixes(prefixes, scan, threadId) {
             return false;
         const events = scan.events.slice(0, prefix.cursor);
         return ((0, canonical_1.digestRuntimeValue)(events) === prefix.eventDigest &&
-            (0, thread_projection_1.projectThreadEvents)(threadId, events).digest === prefix.projectionDigest);
+            (0, thread_projection_1.resolveThreadProjectionDigestVersionV1)((0, thread_projection_1.projectThreadEvents)(threadId, events), prefix.projectionDigest, prefix.projectionDigestVersion) !== undefined);
     });
 }
 function requireVerifiedScan(head) {
@@ -869,12 +906,18 @@ function isStoredVerifiedPrefix(value, headCursor) {
         value.cursor > 0 &&
         value.cursor <= headCursor &&
         isSha256(value.eventDigest) &&
-        isSha256(value.projectionDigest));
+        isSha256(value.projectionDigest) &&
+        (value.projectionDigestVersion === undefined ||
+            value.projectionDigestVersion === 1 ||
+            value.projectionDigestVersion === thread_projection_1.CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1));
 }
 function sameVerifiedPrefix(left, right) {
     return (left.cursor === right.cursor &&
         left.eventDigest === right.eventDigest &&
-        left.projectionDigest === right.projectionDigest);
+        left.projectionDigest === right.projectionDigest &&
+        (left.projectionDigestVersion === right.projectionDigestVersion ||
+            left.projectionDigestVersion === undefined ||
+            right.projectionDigestVersion === undefined));
 }
 function isStoredLogIdentity(value) {
     return (isRecord(value) &&
@@ -961,6 +1004,9 @@ function assertActiveMaintenanceTurn(projection, turnId) {
 }
 function resolveCompactAuthority(events, compactState, threadId) {
     const turnState = readLatestDurableTurnState(events, threadId);
+    return resolveCompactAuthorityState(turnState, compactState);
+}
+function resolveCompactAuthorityState(turnState, compactState) {
     if (!turnState && !compactState) {
         throw new ThreadEventStoreError('ORION_THREAD_COMPACT_INVALID', 'Compact requires a durable TurnCommitV1 source');
     }
@@ -981,15 +1027,26 @@ function resolveCompactAuthority(events, compactState, threadId) {
         taskContextRevision: taskContextOwner.taskContextRevision,
     });
 }
+function readLatestDurableTurnStateFromProjection(projection) {
+    const commit = Object.values(projection.turns)
+        .map(turn => turn.commit)
+        .filter((value) => Boolean(value))
+        .sort((left, right) => left.seq - right.seq)
+        .at(-1);
+    return commit ? parseDurableTurnState(commit.receipt, commit.seq, projection.threadId) : null;
+}
 function readLatestDurableTurnState(events, threadId) {
     const event = [...events]
         .reverse()
         .find(candidate => candidate.payload.type === 'turn.committed');
     if (!event || event.payload.type !== 'turn.committed')
         return null;
+    return parseDurableTurnState(event.payload.data.receipt, event.seq, threadId);
+}
+function parseDurableTurnState(serializedReceipt, eventSeq, threadId) {
     let receipt;
     try {
-        receipt = JSON.parse(event.payload.data.receipt);
+        receipt = JSON.parse(serializedReceipt);
     }
     catch {
         throw compactCorrupt('TurnCommitV1 receipt is not valid JSON');
@@ -1022,7 +1079,7 @@ function readLatestDurableTurnState(events, threadId) {
         throw compactCorrupt('TurnCommitV1 history or TaskContext digest changed');
     }
     return deepFreeze({
-        eventSeq: event.seq,
+        eventSeq,
         history: structuredClone(history),
         historyDigest: receipt.historyDigest,
         taskContext: structuredClone(taskContext),

package/dist/runtime/thread-projection.d.ts

@@ -1,6 +1,15 @@
 import type { RuntimeEventEnvelopeV1, RuntimeEventTypeV1 } from './protocol/runtime-protocol-v1';
+import type { CompactRuntimeEventV1 } from './compact-transaction';
 export type ThreadProjectionStatusV1 = 'new' | 'active' | 'idle';
 export type TurnProjectionStatusV1 = 'active' | 'completed' | 'failed' | 'interrupted';
+/**
+ * Version of the canonical content included in a Thread projection digest.
+ *
+ * Version 1 predates head-only diagnostic and compact lifecycle fields.
+ * Version 2 covers the complete current projection shape.
+ */
+export type ThreadProjectionDigestVersionV1 = 1 | 2;
+export declare const CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1: ThreadProjectionDigestVersionV1;
 export type ItemProjectionStatusV1 = 'started' | 'completed' | 'failed' | 'interrupted' | 'indeterminate';
 export interface ItemProjectionV1 {
     readonly itemId: string;
@@ -66,6 +75,10 @@ export interface PlanReviewProjectionV1 {
     readonly feedback?: string;
     readonly feedbackDigest?: string;
 }
+export interface ThreadDiagnosticEventsV1 {
+    readonly latestCapability?: RuntimeEventEnvelopeV1;
+    readonly latestStepSnapshot?: RuntimeEventEnvelopeV1;
+}
 export interface ThreadProjectionV1 {
     readonly version: 1;
     readonly threadId: string;
@@ -76,6 +89,15 @@ export interface ThreadProjectionV1 {
     readonly items: Readonly<Record<string, ItemProjectionV1>>;
     readonly queue: readonly QueuedTurnProjectionV1[];
     readonly planReview?: PlanReviewProjectionV1;
+    /** Missing only on projections written before diagnostics became head-only. */
+    readonly diagnosticEvents?: ThreadDiagnosticEventsV1;
+    /**
+     * Compact lifecycle facts retained by new projections so fresh-process
+     * orphan recovery does not have to replay the full authoritative JSONL.
+     * Missing means a projection written by an older Orion version and forces
+     * the store to take the verified scan fallback.
+     */
+    readonly compactEvents?: readonly RuntimeEventEnvelopeV1<CompactRuntimeEventV1>[];
     readonly stepSnapshotDigests: readonly string[];
     readonly capabilityReceiptDigests: readonly string[];
     readonly toolInvocationIds: readonly string[];
@@ -91,6 +113,11 @@ interface MutableThreadProjectionV1 {
     items: Record<string, ItemProjectionV1>;
     queue: QueuedTurnProjectionV1[];
     planReview?: PlanReviewProjectionV1;
+    diagnosticEvents: {
+        latestCapability?: RuntimeEventEnvelopeV1;
+        latestStepSnapshot?: RuntimeEventEnvelopeV1;
+    };
+    compactEvents: RuntimeEventEnvelopeV1<CompactRuntimeEventV1>[];
     stepSnapshotDigests: string[];
     capabilityReceiptDigests: string[];
     toolInvocationIds: string[];
@@ -114,5 +141,14 @@ export declare function projectThreadEvents(threadId: string, events: readonly R
 export declare function advanceThreadProjection(projection: ThreadProjectionV1, events: readonly RuntimeEventEnvelopeV1[]): ThreadProjectionV1;
 export declare function applyThreadEvent(state: MutableThreadProjectionV1, event: RuntimeEventEnvelopeV1): void;
 export declare function verifyThreadProjectionDigest(projection: ThreadProjectionV1): boolean;
+/**
+ * Compute one explicitly versioned digest without weakening projection-file
+ * integrity. This is used only for immutable cutover-prefix compatibility.
+ */
+export declare function threadProjectionDigestForVersionV1(projection: ThreadProjectionV1, version: ThreadProjectionDigestVersionV1): string;
+/** Resolve an exact known digest scheme; missing metadata is inferred safely. */
+export declare function resolveThreadProjectionDigestVersionV1(projection: ThreadProjectionV1, digest: string, requestedVersion?: ThreadProjectionDigestVersionV1): ThreadProjectionDigestVersionV1 | undefined;
+/** Older persisted projections must be rebuilt before incremental advance. */
+export declare function hasCurrentThreadProjectionShapeV1(projection: ThreadProjectionV1): boolean;
 export {};
 //# sourceMappingURL=thread-projection.d.ts.map

package/dist/runtime/thread-projection.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreadProjectionInvariantError = void 0;
+exports.ThreadProjectionInvariantError = exports.CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1 = void 0;
 exports.projectThreadEvents = projectThreadEvents;
 exports.advanceThreadProjection = advanceThreadProjection;
 exports.applyThreadEvent = applyThreadEvent;
 exports.verifyThreadProjectionDigest = verifyThreadProjectionDigest;
+exports.threadProjectionDigestForVersionV1 = threadProjectionDigestForVersionV1;
+exports.resolveThreadProjectionDigestVersionV1 = resolveThreadProjectionDigestVersionV1;
+exports.hasCurrentThreadProjectionShapeV1 = hasCurrentThreadProjectionShapeV1;
 const canonical_1 = require("./protocol/canonical");
+exports.CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1 = 2;
 class ThreadProjectionInvariantError extends Error {
     constructor(message, seq, eventType) {
         super(`Thread projection invariant failed at seq ${seq} (${eventType}): ${message}`);
@@ -25,6 +29,8 @@ function projectThreadEvents(threadId, events) {
         turns: {},
         items: {},
         queue: [],
+        diagnosticEvents: {},
+        compactEvents: [],
         stepSnapshotDigests: [],
         capabilityReceiptDigests: [],
         toolInvocationIds: [],
@@ -65,6 +71,10 @@ function advanceThreadProjection(projection, events) {
         items: Object.fromEntries(Object.entries(projection.items).map(([id, item]) => [id, { ...item }])),
         queue: projection.queue.map(item => ({ ...item })),
         ...(projection.planReview ? { planReview: { ...projection.planReview } } : {}),
+        diagnosticEvents: projection.diagnosticEvents
+            ? structuredClone(projection.diagnosticEvents)
+            : {},
+        compactEvents: (projection.compactEvents ?? []).map(event => structuredClone(event)),
         stepSnapshotDigests: [...projection.stepSnapshotDigests],
         capabilityReceiptDigests: [...projection.capabilityReceiptDigests],
         toolInvocationIds: [...projection.toolInvocationIds],
@@ -148,6 +158,7 @@ function applyThreadEvent(state, event) {
                 throw invariant('step snapshot already exists', event);
             }
             state.stepSnapshotDigests.push(event.payload.data.digest);
+            state.diagnosticEvents.latestStepSnapshot = structuredClone(event);
             break;
         case 'capability.receipt':
             validateCapabilityReceipt(event);
@@ -155,6 +166,7 @@ function applyThreadEvent(state, event) {
                 throw invariant('capability receipt already exists', event);
             }
             state.capabilityReceiptDigests.push(event.payload.data.digest);
+            state.diagnosticEvents.latestCapability = structuredClone(event);
             break;
         case 'tool.receipt':
             if (state.toolInvocationIds.includes(event.payload.data.invocationId)) {
@@ -165,6 +177,8 @@ function applyThreadEvent(state, event) {
         case 'compact.started':
         case 'compact.completed':
         case 'compact.failed':
+            state.compactEvents.push(structuredClone(event));
+            break;
         case 'approval.requested':
             break;
         case 'item.delta':
@@ -177,6 +191,43 @@ function verifyThreadProjectionDigest(projection) {
     void _digest;
     return (0, canonical_1.digestRuntimeValue)(content) === projection.digest;
 }
+/**
+ * Compute one explicitly versioned digest without weakening projection-file
+ * integrity. This is used only for immutable cutover-prefix compatibility.
+ */
+function threadProjectionDigestForVersionV1(projection, version) {
+    const { digest: _digest, diagnosticEvents: _diagnosticEvents, compactEvents: _compactEvents, ...legacyContent } = projection;
+    void _digest;
+    void _diagnosticEvents;
+    void _compactEvents;
+    if (version === 1)
+        return (0, canonical_1.digestRuntimeValue)(legacyContent);
+    const content = {
+        ...legacyContent,
+        diagnosticEvents: projection.diagnosticEvents ?? {},
+        compactEvents: projection.compactEvents ?? [],
+    };
+    return (0, canonical_1.digestRuntimeValue)(content);
+}
+/** Resolve an exact known digest scheme; missing metadata is inferred safely. */
+function resolveThreadProjectionDigestVersionV1(projection, digest, requestedVersion) {
+    if (requestedVersion !== undefined) {
+        if (requestedVersion !== 1 && requestedVersion !== 2)
+            return undefined;
+        return threadProjectionDigestForVersionV1(projection, requestedVersion) === digest
+            ? requestedVersion
+            : undefined;
+    }
+    for (const version of [exports.CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1, 1]) {
+        if (threadProjectionDigestForVersionV1(projection, version) === digest)
+            return version;
+    }
+    return undefined;
+}
+/** Older persisted projections must be rebuilt before incremental advance. */
+function hasCurrentThreadProjectionShapeV1(projection) {
+    return projection.diagnosticEvents !== undefined && projection.compactEvents !== undefined;
+}
 function startTurn(state, event) {
     const turnId = requiredIdentity(event.turnId, 'turnId', event);
     if (state.activeTurnId)
@@ -517,6 +568,8 @@ function freezeProjection(state) {
         ])),
         items: Object.fromEntries(Object.entries(state.items).map(([id, item]) => [id, { ...item }])),
         queue: state.queue.map(item => ({ ...item })),
+        diagnosticEvents: structuredClone(state.diagnosticEvents),
+        compactEvents: state.compactEvents.map(event => structuredClone(event)),
         stepSnapshotDigests: [...state.stepSnapshotDigests],
         capabilityReceiptDigests: [...state.capabilityReceiptDigests],
         toolInvocationIds: [...state.toolInvocationIds],

package/dist/runtime/thread-runtime.d.ts

@@ -1,6 +1,6 @@
 import { RuntimeEventBufferV1, type RuntimeEventBufferOptionsV1 } from './runtime-event-buffer';
 import { type ThreadAdmissionOptionsV1, type ThreadCommandAdmissionV1, type ThreadTurnRequestV1 } from './thread-admission';
-import { ThreadEventStore } from './thread-event-store';
+import { ThreadEventStore, type ThreadEventReplayReasonV1 } from './thread-event-store';
 import { type AgentRuntimeCommandV1, type RuntimeEventEnvelopeV1 } from './protocol/runtime-protocol-v1';
 import type { CompactPrepareSourceReceiptV1 } from './compact-transaction';
 export interface ThreadCompactCandidateDraftV1 {
@@ -143,7 +143,7 @@ export declare class ThreadRuntimeV1 {
     unsubscribe(consumerId: string): void;
     /** Observe committed durable facts without acquiring ownership of the Thread lifecycle. */
     observeCommittedEvents(listener: (events: readonly RuntimeEventEnvelopeV1[]) => void): () => void;
-    replay(cursor?: number, limit?: number): import("./thread-event-store").ThreadEventReplayV1;
+    replay(cursor?: number, limit?: number, reason?: ThreadEventReplayReasonV1): import("./thread-event-store").ThreadEventReplayV1;
     getProjection(): import("./thread-projection").ThreadProjectionV1;
     getAdmissionSnapshot(): import("./thread-admission").ThreadAdmissionSnapshotV1;
     waitForIdle(): Promise<void>;

package/dist/runtime/thread-runtime.js

@@ -252,8 +252,8 @@ class ThreadRuntimeV1 {
             throw new Error('Closed Thread runtime cannot be observed');
         return this.store.subscribeCommitted(listener);
     }
-    replay(cursor = 0, limit) {
-        return this.store.replay(cursor, limit);
+    replay(cursor = 0, limit, reason) {
+        return this.store.replay(cursor, limit, reason);
     }
     getProjection() {
         return this.store.loadProjection();

package/dist/runtime/thread-session-index.d.ts

@@ -1,7 +1,15 @@
 import type { Message } from '../services/llm';
 import type { RuntimeEventEnvelopeV1 } from './protocol/runtime-protocol-v1';
 import type { ThreadLogIdentityV1 } from './thread-event-store';
-import type { ItemProjectionV1, ThreadProjectionV1 } from './thread-projection';
+import type { ItemProjectionV1, PlanReviewProjectionV1, ThreadProjectionV1, TurnProjectionStatusV1 } from './thread-projection';
+export interface ThreadSessionIndexPerformanceCountersV1 {
+    readonly indexBuilds: number;
+    readonly manifestReads: number;
+    readonly pageReads: number;
+    readonly bytesRead: number;
+}
+/** Process-local monotonic derived-index counters for Web performance evidence. */
+export declare function threadSessionIndexPerformanceCountersV1(): ThreadSessionIndexPerformanceCountersV1;
 export interface ThreadSessionTranscriptMessageV1 {
     readonly role: Message['role'];
     readonly content: string;
@@ -15,6 +23,12 @@ export interface ThreadSessionTurnCommitV1 {
     readonly seq: number;
     readonly receipt: string;
 }
+export interface ThreadSessionLatestTurnV1 {
+    readonly turnId: string;
+    readonly status: TurnProjectionStatusV1;
+    readonly startedSeq: number;
+    readonly terminalSeq?: number;
+}
 export interface ThreadSessionIndexHeadV1 {
     readonly cursor: number;
     readonly projectionDigest: string;
@@ -41,8 +55,10 @@ export interface ThreadSessionIndexManifestV1 {
     readonly updatedAt: number;
     readonly messageCount: number;
     readonly pages: readonly StoredTranscriptPagePointerV1[];
+    readonly latestTurn?: ThreadSessionLatestTurnV1;
     readonly latestTurnCommit?: ThreadSessionTurnCommitV1;
     readonly latestPlanTurnCommit?: ThreadSessionTurnCommitV1;
+    readonly planReview?: PlanReviewProjectionV1;
     readonly digest: string;
 }
 export interface ThreadSessionIndexedPageV1 {