@orion-agents/orion-code 0.3.1 → 0.3.4

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.
  *
@@ -172,7 +186,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 +195,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}`);
@@ -216,7 +230,7 @@ class ThreadEventStore {
             const expected = { cursor, eventDigest, projectionDigest };
             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);
             if (events.length !== cursor ||
@@ -333,14 +347,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 +364,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 +401,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 +468,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 +528,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 +545,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,
@@ -961,6 +983,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 +1006,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 +1058,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,4 +1,5 @@
 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';
 export type ItemProjectionStatusV1 = 'started' | 'completed' | 'failed' | 'interrupted' | 'indeterminate';
@@ -51,6 +52,25 @@ export interface QueuedTurnProjectionV1 {
     readonly deadline: number;
     readonly queuedSeq: number;
 }
+export interface PlanReviewProjectionV1 {
+    readonly reviewId: string;
+    readonly revision: string;
+    readonly planDigest: string;
+    readonly planReceiptDigest: string;
+    readonly status: 'awaiting_review' | 'approved' | 'continued' | 'cancelled';
+    readonly createdAt: number;
+    readonly createdModel: string;
+    readonly returnMode: 'build' | 'auto';
+    readonly requestedSeq: number;
+    readonly resolvedAt?: number;
+    readonly resolvedSeq?: number;
+    readonly feedback?: string;
+    readonly feedbackDigest?: string;
+}
+export interface ThreadDiagnosticEventsV1 {
+    readonly latestCapability?: RuntimeEventEnvelopeV1;
+    readonly latestStepSnapshot?: RuntimeEventEnvelopeV1;
+}
 export interface ThreadProjectionV1 {
     readonly version: 1;
     readonly threadId: string;
@@ -60,6 +80,16 @@ export interface ThreadProjectionV1 {
     readonly turns: Readonly<Record<string, TurnProjectionV1>>;
     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[];
@@ -74,6 +104,12 @@ interface MutableThreadProjectionV1 {
     turns: Record<string, TurnProjectionV1>;
     items: Record<string, ItemProjectionV1>;
     queue: QueuedTurnProjectionV1[];
+    planReview?: PlanReviewProjectionV1;
+    diagnosticEvents: {
+        latestCapability?: RuntimeEventEnvelopeV1;
+        latestStepSnapshot?: RuntimeEventEnvelopeV1;
+    };
+    compactEvents: RuntimeEventEnvelopeV1<CompactRuntimeEventV1>[];
     stepSnapshotDigests: string[];
     capabilityReceiptDigests: string[];
     toolInvocationIds: string[];

package/dist/runtime/thread-projection.js

@@ -25,6 +25,8 @@ function projectThreadEvents(threadId, events) {
         turns: {},
         items: {},
         queue: [],
+        diagnosticEvents: {},
+        compactEvents: [],
         stepSnapshotDigests: [],
         capabilityReceiptDigests: [],
         toolInvocationIds: [],
@@ -64,6 +66,11 @@ 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],
@@ -111,6 +118,12 @@ function applyThreadEvent(state, event) {
         case 'turn.committed':
             commitTurn(state, event);
             break;
+        case 'plan.review_requested':
+            requestPlanReview(state, event);
+            break;
+        case 'plan.review_resolved':
+            resolvePlanReview(state, event);
+            break;
         case 'turn.completed':
             finishTurn(state, event, 'completed');
             break;
@@ -141,6 +154,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);
@@ -148,6 +162,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)) {
@@ -158,6 +173,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':
@@ -319,6 +336,86 @@ function commitTurn(state, event) {
         },
     };
 }
+function requestPlanReview(state, event) {
+    if (event.payload.type !== 'plan.review_requested') {
+        throw invariant('invalid plan review request payload', event);
+    }
+    const turnId = requiredIdentity(event.turnId, 'turnId', event);
+    const turn = state.turns[turnId];
+    if (!turn?.commit)
+        throw invariant('plan review requires a committed planning turn', event);
+    if (state.planReview?.status === 'awaiting_review') {
+        throw invariant('another plan is already awaiting review', event);
+    }
+    let commit;
+    let receipt;
+    try {
+        commit = JSON.parse(turn.commit.receipt);
+        receipt = JSON.parse(String(commit.planReceipt ?? ''));
+    }
+    catch {
+        throw invariant('plan review is not bound to a valid PlanReceipt', event);
+    }
+    const { digest, ...content } = receipt;
+    const data = event.payload.data;
+    if (commit.planReceiptDigest !== data.planReceiptDigest ||
+        digest !== data.planReceiptDigest ||
+        (0, canonical_1.digestRuntimeValue)(content) !== data.planReceiptDigest ||
+        receipt.planDigest !== data.planDigest ||
+        receipt.threadId !== state.threadId ||
+        receipt.turnId !== turnId) {
+        throw invariant('plan review failed PlanReceipt integrity validation', event);
+    }
+    state.planReview = {
+        reviewId: data.reviewId,
+        revision: data.revision,
+        planDigest: data.planDigest,
+        planReceiptDigest: data.planReceiptDigest,
+        status: 'awaiting_review',
+        createdAt: data.createdAt,
+        createdModel: data.createdModel,
+        returnMode: data.returnMode,
+        requestedSeq: event.seq,
+    };
+}
+function resolvePlanReview(state, event) {
+    if (event.payload.type !== 'plan.review_resolved') {
+        throw invariant('invalid plan review resolution payload', event);
+    }
+    const current = state.planReview;
+    const data = event.payload.data;
+    if (!current || current.status !== 'awaiting_review') {
+        throw invariant('no plan is awaiting review', event);
+    }
+    if (current.reviewId !== data.reviewId ||
+        current.revision !== data.previousRevision ||
+        current.planDigest !== data.planDigest) {
+        throw invariant('plan review resolution is stale', event);
+    }
+    if (data.action === 'continue' && (!data.feedback || !data.feedbackDigest)) {
+        throw invariant('continue plan review requires a feedback digest', event);
+    }
+    const feedback = data.feedback?.trim();
+    if (data.action === 'continue' && (0, canonical_1.digestRuntimeValue)(feedback) !== data.feedbackDigest) {
+        throw invariant('plan review feedback digest is invalid', event);
+    }
+    if (data.action !== 'continue' && (data.feedback || data.feedbackDigest)) {
+        throw invariant('only continue plan review may bind feedback', event);
+    }
+    state.planReview = {
+        ...current,
+        revision: data.revision,
+        status: data.action === 'approve'
+            ? 'approved'
+            : data.action === 'continue'
+                ? 'continued'
+                : 'cancelled',
+        resolvedAt: data.resolvedAt,
+        resolvedSeq: event.seq,
+        ...(feedback ? { feedback } : {}),
+        ...(data.feedbackDigest ? { feedbackDigest: data.feedbackDigest } : {}),
+    };
+}
 function startItem(state, event) {
     const turnId = requiredIdentity(event.turnId, 'turnId', event);
     const stepId = requiredIdentity(event.stepId, 'stepId', event);
@@ -430,6 +527,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 {

package/dist/runtime/thread-session-index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreadSessionIndexError = void 0;
+exports.threadSessionIndexPerformanceCountersV1 = threadSessionIndexPerformanceCountersV1;
 exports.buildThreadSessionIndexV1 = buildThreadSessionIndexV1;
 exports.advanceThreadSessionIndexV1 = advanceThreadSessionIndexV1;
 exports.loadThreadSessionIndexManifestV1 = loadThreadSessionIndexManifestV1;
@@ -12,6 +13,16 @@ const atomic_write_1 = require("../services/atomic-write");
 const canonical_1 = require("./protocol/canonical");
 const TRANSCRIPT_PAGE_ITEMS = 100;
 const MAX_MANIFEST_PAGES = 100000;
+const threadSessionIndexPerformance = {
+    indexBuilds: 0,
+    manifestReads: 0,
+    pageReads: 0,
+    bytesRead: 0,
+};
+/** Process-local monotonic derived-index counters for Web performance evidence. */
+function threadSessionIndexPerformanceCountersV1() {
+    return Object.freeze({ ...threadSessionIndexPerformance });
+}
 class ThreadSessionIndexError extends Error {
     constructor(code, message) {
         super(message);
@@ -21,6 +32,7 @@ class ThreadSessionIndexError extends Error {
 }
 exports.ThreadSessionIndexError = ThreadSessionIndexError;
 function buildThreadSessionIndexV1(input) {
+    threadSessionIndexPerformance.indexBuilds += 1;
     const previous = readManifest(manifestPath(input.rootDir, input.threadId), input.threadId);
     const messages = projectTranscriptMessages(input.projection.items, input.events);
     const pages = [];
@@ -36,6 +48,7 @@ function buildThreadSessionIndexV1(input) {
         updatedAt: input.events.at(-1)?.timestamp ?? 0,
         messageCount: messages.length,
         pages,
+        ...(input.projection.planReview ? { planReview: input.projection.planReview } : {}),
         ...commits,
     });
     writeManifest(input.rootDir, manifest);
@@ -63,7 +76,22 @@ function advanceThreadSessionIndexV1(input) {
     }
     const pages = [...current.pages];
     let messageCount = current.messageCount;
-    for (let start = 0; start < messages.length; start += TRANSCRIPT_PAGE_ITEMS) {
+    let messageOffset = 0;
+    const partialTail = pages.at(-1);
+    if (partialTail &&
+        partialTail.end === messageCount &&
+        partialTail.end - partialTail.start < TRANSCRIPT_PAGE_ITEMS &&
+        messages.length > 0) {
+        const existing = readPage(input.rootDir, input.threadId, partialTail);
+        const appended = messages.slice(0, Math.min(messages.length, TRANSCRIPT_PAGE_ITEMS - existing.items.length));
+        pages[pages.length - 1] = writeImmutablePage(input.rootDir, input.threadId, partialTail.start, [
+            ...existing.items,
+            ...appended,
+        ]);
+        messageOffset = appended.length;
+        messageCount += appended.length;
+    }
+    for (let start = messageOffset; start < messages.length; start += TRANSCRIPT_PAGE_ITEMS) {
         const chunk = messages.slice(start, start + TRANSCRIPT_PAGE_ITEMS);
         pages.push(writeImmutablePage(input.rootDir, input.threadId, messageCount, chunk));
         messageCount += chunk.length;
@@ -77,8 +105,10 @@ function advanceThreadSessionIndexV1(input) {
         updatedAt: input.nextHead.lastEventTimestamp,
         messageCount,
         pages,
+        ...(nextCommits.latestTurn ? { latestTurn: nextCommits.latestTurn } : {}),
         latestTurnCommit: nextCommits.latestTurnCommit ?? current.latestTurnCommit,
         latestPlanTurnCommit: nextCommits.latestPlanTurnCommit ?? current.latestPlanTurnCommit,
+        ...(input.projection.planReview ? { planReview: input.projection.planReview } : {}),
     });
     writeManifest(input.rootDir, manifest);
     return true;
@@ -155,10 +185,12 @@ function createManifest(input) {
         updatedAt: input.updatedAt,
         messageCount: input.messageCount,
         pages: input.pages.map(page => ({ ...page })),
+        ...(input.latestTurn ? { latestTurn: { ...input.latestTurn } } : {}),
         ...(input.latestTurnCommit ? { latestTurnCommit: { ...input.latestTurnCommit } } : {}),
         ...(input.latestPlanTurnCommit
             ? { latestPlanTurnCommit: { ...input.latestPlanTurnCommit } }
             : {}),
+        ...(input.planReview ? { planReview: { ...input.planReview } } : {}),
     };
     return deepFreeze({ ...content, digest: (0, canonical_1.digestRuntimeValue)(content) });
 }
@@ -168,7 +200,9 @@ function latestAuthorityCommits(projection, events) {
             .filter(event => event.payload.type === 'turn.committed' && event.turnId)
             .map(event => event.turnId))
         : undefined;
-    const commits = Object.values(projection.turns)
+    const orderedTurns = Object.values(projection.turns).sort((left, right) => left.startedSeq - right.startedSeq);
+    const latestTurnProjection = orderedTurns.at(-1);
+    const commits = orderedTurns
         .filter(turn => !committedTurns || committedTurns.has(turn.turnId))
         .flatMap(turn => (turn.commit ? [{ seq: turn.commit.seq, receipt: turn.commit.receipt }] : []))
         .sort((left, right) => left.seq - right.seq);
@@ -177,6 +211,18 @@ function latestAuthorityCommits(projection, events) {
         .reverse()
         .find(commit => turnCommitContainsPlan(commit.receipt));
     return {
+        ...(latestTurnProjection
+            ? {
+                latestTurn: {
+                    turnId: latestTurnProjection.turnId,
+                    status: latestTurnProjection.status,
+                    startedSeq: latestTurnProjection.startedSeq,
+                    ...(latestTurnProjection.terminalSeq !== undefined
+                        ? { terminalSeq: latestTurnProjection.terminalSeq }
+                        : {}),
+                },
+            }
+            : {}),
         ...(latestTurnCommit ? { latestTurnCommit } : {}),
         ...(latestPlanTurnCommit ? { latestPlanTurnCommit } : {}),
     };
@@ -208,7 +254,7 @@ function writeManifest(rootDir, manifest) {
     fsyncDirectory(rootDir);
 }
 function readManifest(path, threadId) {
-    const value = readRegularJson(path);
+    const value = readRegularJson(path, 'manifest');
     if (!isRecord(value))
         return null;
     const { digest: _digest, ...content } = value;
@@ -238,13 +284,44 @@ function readManifest(path, threadId) {
     }
     if (nextStart !== value.messageCount)
         return null;
+    if (value.latestTurn !== undefined && !isLatestTurn(value.latestTurn))
+        return null;
     if (value.latestTurnCommit !== undefined && !isTurnCommit(value.latestTurnCommit))
         return null;
     if (value.latestPlanTurnCommit !== undefined && !isTurnCommit(value.latestPlanTurnCommit)) {
         return null;
     }
+    if (value.planReview !== undefined && !isPlanReview(value.planReview))
+        return null;
     return deepFreeze(value);
 }
+function isPlanReview(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.reviewId === 'string' &&
+        value.reviewId.length > 0 &&
+        typeof value.revision === 'string' &&
+        value.revision.length > 0 &&
+        isSha256(value.planDigest) &&
+        isSha256(value.planReceiptDigest) &&
+        ['awaiting_review', 'approved', 'continued', 'cancelled'].includes(String(value.status)) &&
+        nonNegativeSafeInteger(value.createdAt) &&
+        typeof value.createdModel === 'string' &&
+        value.createdModel.length > 0 &&
+        ['build', 'auto'].includes(String(value.returnMode)) &&
+        positiveSafeInteger(value.requestedSeq) &&
+        (value.resolvedAt === undefined || nonNegativeSafeInteger(value.resolvedAt)) &&
+        (value.resolvedSeq === undefined || positiveSafeInteger(value.resolvedSeq)) &&
+        (value.feedback === undefined || typeof value.feedback === 'string') &&
+        (value.feedbackDigest === undefined || isSha256(value.feedbackDigest)));
+}
+function isLatestTurn(value) {
+    return (isRecord(value) &&
+        typeof value.turnId === 'string' &&
+        ['active', 'completed', 'failed', 'interrupted'].includes(String(value.status)) &&
+        positiveSafeInteger(value.startedSeq) &&
+        (value.terminalSeq === undefined || positiveSafeInteger(value.terminalSeq)));
+}
 function readPage(rootDir, threadId, pointer) {
     if ((0, path_1.basename)(pointer.file) !== pointer.file)
         throw indexCorrupt('Transcript page path escaped.');
@@ -258,7 +335,7 @@ function readPage(rootDir, threadId, pointer) {
     return page;
 }
 function readStoredPage(path, threadId) {
-    const value = readRegularJson(path);
+    const value = readRegularJson(path, 'page');
     if (!isRecord(value))
         return null;
     const { digest: _digest, ...content } = value;
@@ -435,13 +512,19 @@ function isItemTerminalEvent(event) {
 function isMessageRole(value) {
     return value === 'system' || value === 'user' || value === 'assistant' || value === 'tool';
 }
-function readRegularJson(path) {
+function readRegularJson(path, kind) {
     let fd;
     try {
         fd = (0, fs_1.openSync)(path, fs_1.constants.O_RDONLY | (typeof fs_1.constants.O_NOFOLLOW === 'number' ? fs_1.constants.O_NOFOLLOW : 0));
         if (!(0, fs_1.fstatSync)(fd).isFile())
             return undefined;
-        return JSON.parse((0, fs_1.readFileSync)(fd, 'utf8'));
+        const bytes = (0, fs_1.readFileSync)(fd);
+        threadSessionIndexPerformance.bytesRead += bytes.byteLength;
+        if (kind === 'manifest')
+            threadSessionIndexPerformance.manifestReads += 1;
+        else
+            threadSessionIndexPerformance.pageReads += 1;
+        return JSON.parse(bytes.toString('utf8'));
     }
     catch {
         return undefined;

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

@@ -1,7 +1,8 @@
 import type { Message } from '../services/llm';
 import { type SessionHistoryRecoveryDiagnosticV1, type SessionHistoryResolvedSourceV1 } from './session-history-recovery';
 import { ThreadEventStore, type ThreadReadModelHeadV1 } from './thread-event-store';
-import { type ThreadSessionTranscriptMessageV1, type ThreadSessionTurnCommitV1 } from './thread-session-index';
+import { type ThreadSessionLatestTurnV1, type ThreadSessionTranscriptMessageV1, type ThreadSessionTurnCommitV1 } from './thread-session-index';
+import type { PlanReviewProjectionV1 } from './thread-projection';
 export type { ThreadSessionTranscriptMessageV1, ThreadSessionTurnCommitV1, } from './thread-session-index';
 /** Metadata/transcript projection that never needs to decode model history. */
 export interface ThreadSessionSummaryV1 {
@@ -72,8 +73,10 @@ export interface ThreadSessionSnapshotPageV1 {
         readonly lastRecordHash: string | null;
         readonly log: ThreadReadModelHeadV1['log'];
     };
+    readonly latestTurn?: ThreadSessionLatestTurnV1;
     readonly latestTurnCommit?: ThreadSessionTurnCommitV1;
     readonly latestPlanTurnCommit?: ThreadSessionTurnCommitV1;
+    readonly planReview?: PlanReviewProjectionV1;
 }
 export declare class ThreadSessionViewError extends Error {
     readonly code = "ORION_THREAD_SESSION_VIEW_INVALID";