@myagentroam/agent 0.10.60 → 0.10.61

package/dist/agent-core/session/store/jsonl-store.js

@@ -11,8 +11,8 @@ import { contextGcBaseFromRecords, contextGcBaseSequence, contextGcMinimumUsageG
 import { bindToolResultResources, cleanupUnreferencedToolResources, completeToolResultResources, copyToolResultResources, readToolResultResource, toolResultResourceFiles, writeToolResultResource } from '../tool-result-resources.js';
 import { beginSessionStorageTransaction, isUnjournaledTransactionFile, recoverSessionStorageTransaction } from '../transaction-recovery.js';
 import { extensionCheckpointFromPayload, indexExtensionCheckpoint, restoreExtensionCheckpoint, updateSessionCurrentState } from './current-state.js';
-import { decodeSessionListCursor, encodeSessionListCursor, mergeFirstUserMessagePreviewCache, normalizeSessionSource, persistSessionIndex, readSessionIndex, sessionListFilter, sessionMatchesFilter, sessionTreeIds } from './directory-index.js';
-import { deriveExecutionState, executionModelFromRecord, isCompactCheckpoint, sameResumeIndex, userMessagePreviewFromRecord } from './execution-state.js';
+import { decodeSessionListCursor, encodeSessionListCursor, mergeSessionDerivedCache, normalizeSessionSource, persistSessionIndex, readSessionIndex, sessionListFilter, sessionMatchesFilter, sessionTreeIds } from './directory-index.js';
+import { deriveExecutionState, executionModelFromRecord, isCompactCheckpoint, isNativeUserTurn, sameResumeIndex, userMessagePreviewFromRecord } from './execution-state.js';
 import { forkedPayload, renameIfExists, restoreRenamedFiles, retainedSessionTitle, stageSessionSegments, stageUnreferencedImages } from './history.js';
 import { MAX_INPUT_IMAGES, copyGeneratedImages, copyInputImages, generatedImageFileNames, inputImageReference, inputImageReferences, inputImageReferencesFromRecords, readInputImageBytes, recoverPendingInputImages, validInputImageFileName, writeInputImages } from './images.js';
 import { MAX_SEGMENT_BYTES, appendRecordBytes, readRecordPageFromTail, readRecords, readRecordsFromHead, readRecordsFromTail, repairSegmentTail, segmentNumberFromPath } from './records.js';
@@ -158,7 +158,7 @@ export class JsonlSessionStore {
             closed: false,
             indexDirty: false,
             dirtySessionVersions: new Map(),
-            previewOnlyDirtySessions: new Set(),
+            derivedOnlyDirtySessions: new Set(),
             pendingPublishIds: new Set(),
             codeStateWrites: new Map(),
             recordWrites: new Map(),
@@ -185,15 +185,15 @@ export class JsonlSessionStore {
             if (!disk)
                 throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Session index is missing.');
             const dirty = new Map(this.#shared.dirtySessionVersions);
-            const previewOnly = new Set(this.#shared.previewOnlyDirtySessions);
+            const derivedOnly = new Set(this.#shared.derivedOnlyDirtySessions);
             const sessions = new Map(disk.sessions.map((session) => [session.id, session]));
             const created = new Set(createdIds);
             for (const session of this.#shared.index.sessions) {
                 const current = sessions.get(session.id);
                 // Disk membership is authoritative: a stale in-memory snapshot cannot revive a deletion.
                 if (created.has(session.id) || (current && dirty.has(session.id)))
-                    sessions.set(session.id, current && previewOnly.has(session.id)
-                        ? mergeFirstUserMessagePreviewCache(current, session)
+                    sessions.set(session.id, current && derivedOnly.has(session.id)
+                        ? mergeSessionDerivedCache(current, session)
                         : structuredClone(session));
             }
             for (const deletedId of typeof deletedIds === 'string' ? [deletedIds] : (deletedIds ?? []))
@@ -202,7 +202,7 @@ export class JsonlSessionStore {
                 version: 1,
                 revision: createdIds.length > 0 ||
                     deletedIds !== undefined ||
-                    [...dirty.keys()].some((id) => !previewOnly.has(id))
+                    [...dirty.keys()].some((id) => !derivedOnly.has(id))
                     ? Math.max(disk.revision, this.#shared.index.revision) + 1
                     : disk.revision,
                 sessions: [...sessions.values()]
@@ -214,7 +214,7 @@ export class JsonlSessionStore {
                     continue;
                 if (this.#shared.dirtySessionVersions.get(id) === version) {
                     this.#shared.dirtySessionVersions.delete(id);
-                    this.#shared.previewOnlyDirtySessions.delete(id);
+                    this.#shared.derivedOnlyDirtySessions.delete(id);
                 }
             }
             for (const id of created)
@@ -257,8 +257,8 @@ export class JsonlSessionStore {
                 const current = local.get(session.id);
                 if (!current || !this.#shared.dirtySessionVersions.has(session.id))
                     return session;
-                return this.#shared.previewOnlyDirtySessions.has(session.id)
-                    ? mergeFirstUserMessagePreviewCache(session, current)
+                return this.#shared.derivedOnlyDirtySessions.has(session.id)
+                    ? mergeSessionDerivedCache(session, current)
                     : current;
             })
                 .concat(this.#shared.index.sessions.filter((session) => this.#shared.pendingPublishIds.has(session.id) && !published.has(session.id)))
@@ -299,6 +299,7 @@ export class JsonlSessionStore {
             automaticTitlePending: input.title === undefined,
             resume: {
                 version: 1,
+                userTurns: 0,
                 todoRevision: 0,
                 executionModelIndexed: true,
                 firstUserMessageIndexed: true
@@ -366,7 +367,7 @@ export class JsonlSessionStore {
             }
         }
     }
-    sessionDirectory(sessionId) {
+    #sessionDirectory(sessionId) {
         this.#assertOpen();
         if (!this.#shared.index.sessions.some((session) => session.id === sessionId) &&
             !this.#shared.pendingSessions.has(sessionId))
@@ -374,7 +375,7 @@ export class JsonlSessionStore {
         return join(this.#shared.root, 'sessions', sessionId);
     }
     async readContextualWorldState(sessionId) {
-        const path = join(this.sessionDirectory(sessionId), CONTEXTUAL_WORLD_STATE_FILE);
+        const path = join(this.#sessionDirectory(sessionId), CONTEXTUAL_WORLD_STATE_FILE);
         try {
             const pathInfo = await lstat(path);
             if (!pathInfo.isFile())
@@ -403,7 +404,7 @@ export class JsonlSessionStore {
         }
     }
     async writeContextualWorldState(sessionId, state) {
-        const directory = this.sessionDirectory(sessionId);
+        const directory = this.#sessionDirectory(sessionId);
         const meta = this.#shared.index.sessions.find((item) => item.id === sessionId);
         if (!meta)
             throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
@@ -431,21 +432,21 @@ export class JsonlSessionStore {
             return [];
         if (images.length > MAX_INPUT_IMAGES)
             throw new MarAgentError('MAR_AGENT_HOST_LIMIT_EXCEEDED', 'Too many image inputs were provided.');
-        const directory = join(this.sessionDirectory(sessionId), 'input_images');
+        const directory = join(this.#sessionDirectory(sessionId), 'input_images');
         return writeInputImages(directory, images);
     }
     async writeToolResultResource(sessionId, text) {
         this.#assertOpen();
         if (!this.#shared.index.sessions.some((item) => item.id === sessionId))
             throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
-        return writeToolResultResource(this.sessionDirectory(sessionId), text);
+        return writeToolResultResource(this.#sessionDirectory(sessionId), text);
     }
     async readToolResultResource(sessionId, input) {
         this.#assertOpen();
         await this.#refreshIndex();
         if (!this.#shared.index.sessions.some((item) => item.id === sessionId))
             throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
-        return readToolResultResource(this.sessionDirectory(sessionId), sessionId, input, async (sequence) => {
+        return readToolResultResource(this.#sessionDirectory(sessionId), sessionId, input, async (sequence) => {
             await this.#refreshIndex();
             return (await this.readPage(sessionId, { beforeSequence: sequence + 1, limit: 1 })).records.find((record) => record.sequence === sequence);
         });
@@ -455,7 +456,7 @@ export class JsonlSessionStore {
         const references = inputImageReferences(value);
         if (references.length === 0)
             return [];
-        const directory = join(this.sessionDirectory(sessionId), 'input_images');
+        const directory = join(this.#sessionDirectory(sessionId), 'input_images');
         const images = [];
         for (const reference of references) {
             const data = await readInputImageBytes(directory, reference);
@@ -485,7 +486,7 @@ export class JsonlSessionStore {
         const reference = inputImageReference(record.payload.images[input.imageIndex]);
         if (reference === undefined)
             return undefined;
-        const data = await readInputImageBytes(join(this.sessionDirectory(sessionId), 'input_images'), reference);
+        const data = await readInputImageBytes(join(this.#sessionDirectory(sessionId), 'input_images'), reference);
         return {
             name: reference.name,
             mimeType: reference.mimeType,
@@ -520,6 +521,7 @@ export class JsonlSessionStore {
                 automaticTitlePending: false,
                 resume: {
                     version: 1,
+                    userTurns: 0,
                     todoRevision: 0,
                     executionModelIndexed: true,
                     firstUserMessageIndexed: true
@@ -566,7 +568,7 @@ export class JsonlSessionStore {
                     });
                 }
                 // A fork is unpublished until every segment and referenced image is durable.
-                const staged = await stageSessionSegments(this.sessionDirectory(target.id), copied, 'fork');
+                const staged = await stageSessionSegments(this.#sessionDirectory(target.id), copied, 'fork');
                 for (const file of staged.files)
                     await rename(file.temporaryPath, file.path);
                 target.segments = staged.segments;
@@ -574,9 +576,9 @@ export class JsonlSessionStore {
                 this.#shared.segments.set(target.id, staged.segments.length);
                 for (const record of copied)
                     this.#applyRecordToResumeIndex(target, record);
-                await copyToolResultResources(this.sessionDirectory(sourceSessionId), this.sessionDirectory(target.id), copied);
-                await copyGeneratedImages(this.sessionDirectory(sourceSessionId), this.sessionDirectory(target.id), generatedImageFileNames(retained));
-                await copyInputImages(this.sessionDirectory(sourceSessionId), this.sessionDirectory(target.id), inputImageReferencesFromRecords(retained));
+                await copyToolResultResources(this.#sessionDirectory(sourceSessionId), this.#sessionDirectory(target.id), copied);
+                await copyGeneratedImages(this.#sessionDirectory(sourceSessionId), this.#sessionDirectory(target.id), generatedImageFileNames(retained));
+                await copyInputImages(this.#sessionDirectory(sourceSessionId), this.#sessionDirectory(target.id), inputImageReferencesFromRecords(retained));
                 target.lastActivityAt = target.createdAt;
                 this.#shared.pendingSessions.delete(target.id);
                 this.#shared.index = {
@@ -654,102 +656,7 @@ export class JsonlSessionStore {
             const retained = records
                 .slice(0, boundaryIndex + 1)
                 .filter((record) => record.type !== 'responses.continuation');
-            const staged = await stageSessionSegments(this.sessionDirectory(sessionId), retained);
-            const transactionId = randomUUID();
-            const targetNextSequence = (retained.at(-1)?.sequence ?? 0) + 1;
-            const contextualWorldStatePath = join(this.sessionDirectory(sessionId), CONTEXTUAL_WORLD_STATE_FILE);
-            const contextualWorldStateBackup = `${contextualWorldStatePath}.${targetNextSequence}.${transactionId}.rollback-backup`;
-            let contextualWorldStateStaged = false;
-            let generatedTrash = [];
-            let inputTrash = [];
-            const originalMeta = structuredClone(meta);
-            const originalIndexRevision = this.#shared.index.revision;
-            const originalSegment = this.#shared.segments.get(sessionId);
-            const originalPaths = await this.#segmentPaths(sessionId);
-            const backups = originalPaths.map((path) => ({
-                path,
-                backup: `${path}.${transactionId}.rollback-backup`
-            }));
-            const transaction = {
-                version: 1,
-                id: transactionId,
-                kind: 'rollback',
-                originalSegments: originalPaths.map((path) => basename(path)),
-                stagedSegments: staged.files.map((item) => ({
-                    path: basename(item.path),
-                    temporary: basename(item.temporaryPath)
-                })),
-                sidecarBackup: basename(contextualWorldStateBackup)
-            };
-            const installedPaths = [];
-            let committed = false;
-            try {
-                await beginSessionStorageTransaction(this.sessionDirectory(sessionId), transaction);
-                contextualWorldStateStaged = await renameIfExists(contextualWorldStatePath, contextualWorldStateBackup);
-                generatedTrash = await stageUnreferencedImages(this.sessionDirectory(sessionId), 'generated_images', new Set(generatedImageFileNames(retained)), transactionId);
-                inputTrash = await stageUnreferencedImages(this.sessionDirectory(sessionId), 'input_images', new Set(inputImageReferencesFromRecords(retained).map((image) => image.fileName)), transactionId);
-                inputTrash.push(...(await stageUnreferencedImages(this.sessionDirectory(sessionId), 'tool_results', toolResultResourceFiles(retained), transactionId)));
-                for (const item of backups)
-                    await rename(item.path, item.backup);
-                for (const item of staged.files) {
-                    await rename(item.temporaryPath, item.path);
-                    installedPaths.push(item.path);
-                }
-                const state = deriveExecutionState(retained);
-                const completedAt = new Date().toISOString();
-                meta.title = retainedSessionTitle(retained, meta.title);
-                meta.lastActivityAt = completedAt;
-                meta.nextSequence = targetNextSequence;
-                meta.storageTransactionId = transactionId;
-                meta.automaticTitlePending = state.automaticTitlePending;
-                meta.resume = state.resume;
-                meta.segments = staged.segments;
-                this.#shared.segments.set(sessionId, staged.segments.at(-1)?.number ?? 1);
-                this.#shared.index.revision++;
-                this.#markIndexDirty(sessionId);
-                await this.#saveIndex();
-                committed = true;
-                await recoverSessionStorageTransaction(this.sessionDirectory(sessionId), transactionId);
-                return {
-                    id: meta.id,
-                    title: meta.title,
-                    workspace: meta.workspace,
-                    createdAt: meta.createdAt,
-                    lastActivityAt: meta.lastActivityAt,
-                    source: normalizeSessionSource(meta.source)
-                };
-            }
-            catch (error) {
-                if (!committed) {
-                    committed = await this.#storageTransactionCommitted(sessionId, transactionId);
-                    if (committed) {
-                        this.#shared.dirtySessionVersions.delete(sessionId);
-                        this.#shared.indexDirty = this.#shared.dirtySessionVersions.size > 0;
-                        await recoverSessionStorageTransaction(this.sessionDirectory(sessionId), transactionId);
-                    }
-                }
-                if (!committed) {
-                    await Promise.all(installedPaths.map((path) => rm(path, { force: true }))).catch(() => undefined);
-                    await restoreRenamedFiles(backups.map((item) => ({ from: item.backup, to: item.path })));
-                    if (contextualWorldStateStaged)
-                        await restoreRenamedFiles([
-                            { from: contextualWorldStateBackup, to: contextualWorldStatePath }
-                        ]);
-                    await restoreRenamedFiles([...generatedTrash, ...inputTrash]);
-                    restoreSessionMeta(meta, originalMeta);
-                    this.#shared.index.revision = originalIndexRevision;
-                    if (originalSegment === undefined)
-                        this.#shared.segments.delete(sessionId);
-                    else
-                        this.#shared.segments.set(sessionId, originalSegment);
-                    this.#markIndexDirty(sessionId);
-                    await recoverSessionStorageTransaction(this.sessionDirectory(sessionId), originalMeta.storageTransactionId);
-                }
-                throw error;
-            }
-            finally {
-                await Promise.all(staged.files.map((item) => rm(item.temporaryPath, { force: true }))).catch(() => undefined);
-            }
+            return await this.#replaceHistory(meta, retained, { kind: 'rollback' });
         }
         finally {
             await release();
@@ -817,100 +724,120 @@ export class JsonlSessionStore {
                     }
                 }
             ];
-            const staged = await stageSessionSegments(this.sessionDirectory(sessionId), retained);
-            const transactionId = randomUUID();
-            const contextualWorldStatePath = join(this.sessionDirectory(sessionId), CONTEXTUAL_WORLD_STATE_FILE);
-            const contextualWorldStateBackup = `${contextualWorldStatePath}.2.${transactionId}.clear-backup`;
-            let contextualWorldStateStaged = false;
-            let generatedTrash = [];
-            let inputTrash = [];
-            const originalMeta = structuredClone(meta);
-            const originalIndexRevision = this.#shared.index.revision;
-            const originalSegment = this.#shared.segments.get(sessionId);
-            const originalPaths = await this.#segmentPaths(sessionId);
-            const backups = originalPaths.map((path) => ({
-                path,
-                backup: `${path}.${transactionId}.clear-backup`
-            }));
-            const transaction = {
-                version: 1,
-                id: transactionId,
-                kind: 'clear',
-                originalSegments: originalPaths.map((path) => basename(path)),
-                stagedSegments: staged.files.map((item) => ({
-                    path: basename(item.path),
-                    temporary: basename(item.temporaryPath)
-                })),
-                sidecarBackup: basename(contextualWorldStateBackup)
-            };
-            const installedPaths = [];
-            let committed = false;
-            try {
-                await beginSessionStorageTransaction(this.sessionDirectory(sessionId), transaction);
-                contextualWorldStateStaged = await renameIfExists(contextualWorldStatePath, contextualWorldStateBackup);
-                generatedTrash = await stageUnreferencedImages(this.sessionDirectory(sessionId), 'generated_images', new Set(), transactionId);
-                inputTrash = await stageUnreferencedImages(this.sessionDirectory(sessionId), 'input_images', new Set(), transactionId);
-                inputTrash.push(...(await stageUnreferencedImages(this.sessionDirectory(sessionId), 'tool_results', new Set(), transactionId)));
-                for (const item of backups)
-                    await rename(item.path, item.backup);
-                for (const item of staged.files) {
-                    await rename(item.temporaryPath, item.path);
-                    installedPaths.push(item.path);
-                }
-                meta.lastActivityAt = clearedAt;
-                meta.nextSequence = retained.length + 1;
+            return await this.#replaceHistory(meta, retained, { kind: 'clear', clearedAt });
+        }
+        finally {
+            await release();
+        }
+    }
+    /** Called only while rollback or clear holds the maintenance lease. */
+    async #replaceHistory(meta, retained, operation) {
+        const sessionId = meta.id;
+        const staged = await stageSessionSegments(this.#sessionDirectory(sessionId), retained);
+        const transactionId = randomUUID();
+        const targetNextSequence = operation.kind === 'clear' ? 2 : (retained.at(-1)?.sequence ?? 0) + 1;
+        const contextualWorldStatePath = join(this.#sessionDirectory(sessionId), CONTEXTUAL_WORLD_STATE_FILE);
+        const contextualWorldStateBackup = `${contextualWorldStatePath}.${targetNextSequence}.${transactionId}.${operation.kind}-backup`;
+        let contextualWorldStateStaged = false;
+        let generatedTrash = [];
+        let inputTrash = [];
+        const originalMeta = structuredClone(meta);
+        const originalIndexRevision = this.#shared.index.revision;
+        const originalSegment = this.#shared.segments.get(sessionId);
+        const originalPaths = await this.#segmentPaths(sessionId);
+        const backups = originalPaths.map((path) => ({
+            path,
+            backup: `${path}.${transactionId}.${operation.kind}-backup`
+        }));
+        const transaction = {
+            version: 1,
+            id: transactionId,
+            kind: operation.kind,
+            originalSegments: originalPaths.map((path) => basename(path)),
+            stagedSegments: staged.files.map((item) => ({
+                path: basename(item.path),
+                temporary: basename(item.temporaryPath)
+            })),
+            sidecarBackup: basename(contextualWorldStateBackup)
+        };
+        const installedPaths = [];
+        let committed = false;
+        try {
+            await beginSessionStorageTransaction(this.#sessionDirectory(sessionId), transaction);
+            contextualWorldStateStaged = await renameIfExists(contextualWorldStatePath, contextualWorldStateBackup);
+            generatedTrash = await stageUnreferencedImages(this.#sessionDirectory(sessionId), 'generated_images', operation.kind === 'rollback' ? new Set(generatedImageFileNames(retained)) : new Set(), transactionId);
+            inputTrash = await stageUnreferencedImages(this.#sessionDirectory(sessionId), 'input_images', operation.kind === 'rollback'
+                ? new Set(inputImageReferencesFromRecords(retained).map((image) => image.fileName))
+                : new Set(), transactionId);
+            inputTrash.push(...(await stageUnreferencedImages(this.#sessionDirectory(sessionId), 'tool_results', operation.kind === 'rollback' ? toolResultResourceFiles(retained) : new Set(), transactionId)));
+            for (const item of backups)
+                await rename(item.path, item.backup);
+            for (const item of staged.files) {
+                await rename(item.temporaryPath, item.path);
+                installedPaths.push(item.path);
+            }
+            if (operation.kind === 'rollback') {
+                const state = deriveExecutionState(retained);
+                const completedAt = new Date().toISOString();
+                meta.title = retainedSessionTitle(retained, meta.title);
+                meta.lastActivityAt = completedAt;
+                meta.nextSequence = targetNextSequence;
                 meta.storageTransactionId = transactionId;
-                meta.resume = { version: 1, todoRevision: 0, firstUserMessageIndexed: true };
-                meta.segments = staged.segments;
-                this.#shared.segments.set(sessionId, 1);
-                this.#shared.index.revision++;
-                this.#markIndexDirty(sessionId);
-                await this.#saveIndex();
-                committed = true;
-                await recoverSessionStorageTransaction(this.sessionDirectory(sessionId), transactionId);
-                return {
-                    id: meta.id,
-                    title: meta.title,
-                    workspace: meta.workspace,
-                    createdAt: meta.createdAt,
-                    lastActivityAt: meta.lastActivityAt,
-                    source: normalizeSessionSource(meta.source)
-                };
+                meta.automaticTitlePending = state.automaticTitlePending;
+                meta.resume = state.resume;
             }
-            catch (error) {
-                if (!committed) {
-                    committed = await this.#storageTransactionCommitted(sessionId, transactionId);
-                    if (committed) {
-                        this.#shared.dirtySessionVersions.delete(sessionId);
-                        this.#shared.indexDirty = this.#shared.dirtySessionVersions.size > 0;
-                        await recoverSessionStorageTransaction(this.sessionDirectory(sessionId), transactionId);
-                    }
-                }
-                if (!committed) {
-                    await Promise.all(installedPaths.map((path) => rm(path, { force: true }))).catch(() => undefined);
-                    await restoreRenamedFiles(backups.map((item) => ({ from: item.backup, to: item.path })));
-                    if (contextualWorldStateStaged)
-                        await restoreRenamedFiles([
-                            { from: contextualWorldStateBackup, to: contextualWorldStatePath }
-                        ]);
-                    await restoreRenamedFiles([...generatedTrash, ...inputTrash]);
-                    restoreSessionMeta(meta, originalMeta);
-                    this.#shared.index.revision = originalIndexRevision;
-                    if (originalSegment === undefined)
-                        this.#shared.segments.delete(sessionId);
-                    else
-                        this.#shared.segments.set(sessionId, originalSegment);
-                    this.#markIndexDirty(sessionId);
-                    await recoverSessionStorageTransaction(this.sessionDirectory(sessionId), originalMeta.storageTransactionId);
+            else {
+                meta.lastActivityAt = operation.clearedAt;
+                meta.nextSequence = targetNextSequence;
+                meta.storageTransactionId = transactionId;
+                meta.resume = { version: 1, userTurns: 0, todoRevision: 0, firstUserMessageIndexed: true };
+            }
+            meta.segments = staged.segments;
+            this.#shared.segments.set(sessionId, operation.kind === 'clear' ? 1 : (staged.segments.at(-1)?.number ?? 1));
+            this.#shared.index.revision++;
+            this.#markIndexDirty(sessionId);
+            await this.#saveIndex();
+            committed = true;
+            await recoverSessionStorageTransaction(this.#sessionDirectory(sessionId), transactionId);
+            return {
+                id: meta.id,
+                title: meta.title,
+                workspace: meta.workspace,
+                createdAt: meta.createdAt,
+                lastActivityAt: meta.lastActivityAt,
+                source: normalizeSessionSource(meta.source)
+            };
+        }
+        catch (error) {
+            if (!committed) {
+                committed = await this.#storageTransactionCommitted(sessionId, transactionId);
+                if (committed) {
+                    this.#shared.dirtySessionVersions.delete(sessionId);
+                    this.#shared.indexDirty = this.#shared.dirtySessionVersions.size > 0;
+                    await recoverSessionStorageTransaction(this.#sessionDirectory(sessionId), transactionId);
                 }
-                throw error;
             }
-            finally {
-                await Promise.all(staged.files.map((item) => rm(item.temporaryPath, { force: true }))).catch(() => undefined);
+            if (!committed) {
+                await Promise.all(installedPaths.map((path) => rm(path, { force: true }))).catch(() => undefined);
+                await restoreRenamedFiles(backups.map((item) => ({ from: item.backup, to: item.path })));
+                if (contextualWorldStateStaged)
+                    await restoreRenamedFiles([
+                        { from: contextualWorldStateBackup, to: contextualWorldStatePath }
+                    ]);
+                await restoreRenamedFiles([...generatedTrash, ...inputTrash]);
+                restoreSessionMeta(meta, originalMeta);
+                this.#shared.index.revision = originalIndexRevision;
+                if (originalSegment === undefined)
+                    this.#shared.segments.delete(sessionId);
+                else
+                    this.#shared.segments.set(sessionId, originalSegment);
+                this.#markIndexDirty(sessionId);
+                await recoverSessionStorageTransaction(this.#sessionDirectory(sessionId), originalMeta.storageTransactionId);
             }
+            throw error;
         }
         finally {
-            await release();
+            await Promise.all(staged.files.map((item) => rm(item.temporaryPath, { force: true }))).catch(() => undefined);
         }
     }
     async getSession(sessionId) {
@@ -970,7 +897,7 @@ export class JsonlSessionStore {
             payload: input.payload
         };
         JSON.stringify(record); // Reject malformed payloads before binding resources.
-        await bindToolResultResources(this.sessionDirectory(sessionId), record, (sequence) => this.#readRecordAtSequence(before, sequence), true);
+        await bindToolResultResources(this.#sessionDirectory(sessionId), record, (sequence) => this.#readRecordAtSequence(before, sequence), true);
         const serialized = `${JSON.stringify(record)}\n`;
         let segment = await this.#currentSegment(sessionId);
         let path = this.#segmentPath(sessionId, segment);
@@ -990,6 +917,12 @@ export class JsonlSessionStore {
         }
         catch (error) {
             // A failed write/sync/close can leave a complete record on disk.
+            const current = this.#shared.index.sessions.find((item) => item.id === sessionId) ?? before;
+            if (current.resume?.userTurns !== undefined) {
+                delete current.resume.userTurns;
+                if (published)
+                    this.#markIndexDirty(sessionId);
+            }
             const lease = this.#shared.writerLeases.get(sessionId);
             if (lease) {
                 delete lease.codeState;
@@ -1024,7 +957,7 @@ export class JsonlSessionStore {
             this.#markIndexDirty(sessionId);
         }
         updateSessionCurrentState(this.#shared.writerLeases.get(sessionId), record.type, serialized);
-        await completeToolResultResources(this.sessionDirectory(sessionId), record);
+        await completeToolResultResources(this.#sessionDirectory(sessionId), record);
         if (record.type === 'turn.user' &&
             isObject(record.payload) &&
             Array.isArray(record.payload.images))
@@ -1032,7 +965,7 @@ export class JsonlSessionStore {
                 if (isObject(image) &&
                     typeof image.fileName === 'string' &&
                     validInputImageFileName(image.fileName))
-                    await rm(join(this.sessionDirectory(sessionId), 'input_images', `.${image.fileName}.pending`), { force: true }).catch(() => undefined);
+                    await rm(join(this.#sessionDirectory(sessionId), 'input_images', `.${image.fileName}.pending`), { force: true }).catch(() => undefined);
         return record;
     }
     async read(sessionId) {
@@ -1169,9 +1102,6 @@ export class JsonlSessionStore {
             return this.#rebuildExecutionState(meta);
         }
     }
-    async readContext(sessionId) {
-        return (await this.readExecutionState(sessionId)).contextRecords;
-    }
     /** Compare the planned sequence inside the existing record writer queue. */
     async commitContextGc(sessionId, draft, planningRecords) {
         this.#assertOpen();
@@ -1391,7 +1321,7 @@ export class JsonlSessionStore {
             const current = disk.sessions.find((item) => item.id === sessionId);
             if (!current)
                 throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
-            await recoverSessionStorageTransaction(this.sessionDirectory(sessionId), current.storageTransactionId);
+            await recoverSessionStorageTransaction(this.#sessionDirectory(sessionId), current.storageTransactionId);
             await recoverContextualWorldStateTransactions(this.#shared.root, current);
             await this.#refreshIndex();
             await this.#reconcileTail(sessionId);
@@ -1512,6 +1442,8 @@ export class JsonlSessionStore {
         const resume = meta.resume;
         if (resume?.version !== 1 || !Number.isSafeInteger(resume.todoRevision))
             return;
+        if (resume.userTurns !== undefined && isNativeUserTurn(record))
+            resume.userTurns++;
         if (resume.firstUserMessageIndexed === true && resume.firstUserMessagePreview === undefined) {
             const preview = userMessagePreviewFromRecord(record);
             if (preview !== undefined)
@@ -1602,6 +1534,73 @@ export class JsonlSessionStore {
             contextRecords: state.contextRecords
         };
     }
+    /** Counts native input records, not the post-Compact model context. */
+    async userTurnCount(sessionId) {
+        return this.#serializeRecordOperation(sessionId, async () => {
+            this.#assertOpen();
+            await this.#refreshIndex();
+            const before = this.#shared.index.sessions.find((session) => session.id === sessionId);
+            if (!before)
+                throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+            const indexed = before.resume?.userTurns;
+            if (indexed !== undefined && this.#shared.writerLeases.has(sessionId))
+                return indexed;
+            const nextSequence = before.nextSequence;
+            const transactionId = before.storageTransactionId;
+            const paths = await this.#segmentPaths(sessionId);
+            let count = indexed ?? 0;
+            let lastSequence = 0;
+            let reachedPrefix = false;
+            if (indexed !== undefined) {
+                // No local writer: a previous writer may have committed bytes but not its index.
+                for (const path of [...paths].reverse()) {
+                    for await (const record of readRecordsFromTail(path)) {
+                        lastSequence = Math.max(lastSequence, record.sequence);
+                        if (record.sequence < nextSequence) {
+                            reachedPrefix = true;
+                            break;
+                        }
+                        if (isNativeUserTurn(record))
+                            count++;
+                    }
+                    if (reachedPrefix)
+                        break;
+                }
+            }
+            if (indexed === undefined || lastSequence < nextSequence - 1) {
+                count = 0;
+                lastSequence = 0;
+                for (const path of paths) {
+                    for await (const record of readRecordsFromHead(path)) {
+                        lastSequence = record.sequence;
+                        if (isNativeUserTurn(record))
+                            count++;
+                    }
+                }
+            }
+            await this.#refreshIndex();
+            const current = this.#shared.index.sessions.find((session) => session.id === sessionId);
+            if (!current)
+                throw new MarAgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
+            if (current.storageTransactionId !== transactionId) {
+                // The indexed prefix no longer belongs to this history. Fall back to the
+                // ordinary physical read boundary without caching or a conflict error.
+                count = 0;
+                for (const path of await this.#segmentPaths(sessionId))
+                    for await (const record of readRecordsFromHead(path))
+                        if (isNativeUserTurn(record))
+                            count++;
+                return count;
+            }
+            if (current.nextSequence === nextSequence &&
+                lastSequence === nextSequence - 1 &&
+                current.resume?.userTurns === undefined) {
+                (current.resume ??= { version: 1, todoRevision: 0 }).userTurns = count;
+                this.#markIndexDirty(sessionId, true);
+            }
+            return count;
+        });
+    }
     async firstUserMessagePreview(sessionId) {
         this.#assertOpen();
         await this.#refreshIndex();
@@ -1750,11 +1749,11 @@ export class JsonlSessionStore {
         if (this.#leaseClosed || this.#shared.closed)
             throw new MarAgentError('MAR_AGENT_DISPOSED', 'Session store is closed.');
     }
-    #markIndexDirty(sessionId, previewOnly = false) {
-        if (!previewOnly)
-            this.#shared.previewOnlyDirtySessions.delete(sessionId);
+    #markIndexDirty(sessionId, derivedOnly = false) {
+        if (!derivedOnly)
+            this.#shared.derivedOnlyDirtySessions.delete(sessionId);
         else if (!this.#shared.dirtySessionVersions.has(sessionId))
-            this.#shared.previewOnlyDirtySessions.add(sessionId);
+            this.#shared.derivedOnlyDirtySessions.add(sessionId);
         this.#shared.indexDirty = true;
         this.#shared.dirtySessionVersions.set(sessionId, (this.#shared.dirtySessionVersions.get(sessionId) ?? 0) + 1);
     }
@@ -1796,8 +1795,8 @@ export class JsonlSessionStore {
         const latestPath = paths.at(-1);
         await repairSegmentTail(latestPath);
         const records = await readRecords(latestPath);
-        await recoverPendingInputImages(this.sessionDirectory(sessionId), () => this.#readRecords(sessionId));
-        await cleanupUnreferencedToolResources(this.sessionDirectory(sessionId), () => this.#readRecords(sessionId));
+        await recoverPendingInputImages(this.#sessionDirectory(sessionId), () => this.#readRecords(sessionId));
+        await cleanupUnreferencedToolResources(this.#sessionDirectory(sessionId), () => this.#readRecords(sessionId));
         const last = records.at(-1);
         const match = /events-(\d{6})\.jsonl$/.exec(latestPath);
         const segment = Number(match?.[1] ?? 1);