@myagentroam/agent 0.11.55 → 0.11.57

package/dist/session/context-gc-protection.js

@@ -1,4 +1,8 @@
 import { completedNativeThinkingIdentity } from '../model/native-context.js';
+export const CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS = 10;
+export function contextGcProtectionMature(count) {
+    return count.rollouts >= CONTEXT_GC_TEXT_PROTECTION_ROLLOUTS && count.thinking >= 3;
+}
 /** One immutable boundary index, shared by all candidate anchors in this evaluation. */
 export function buildContextGcProtection(records, modelId, contextWindowTokens) {
     const configurations = new Map();

package/dist/session/context-gc-replacements.js

@@ -24,7 +24,7 @@ export function contextGcCodeModeInputReplacement(input, retainedInputs = []) {
         originalBytes: Buffer.byteLength(input.code),
         lines: lineCount(input.code),
         inputMode: input.inputMode,
-        contextGc: 'Completed Code Mode source was reclaimed after six successful rollouts. The paired output, images, completion evidence, and nested tool side effects remain in history.',
+        contextGc: 'Completed Code Mode source was reclaimed after the protection period. The paired output, images, completion evidence, and nested tool side effects remain in history.',
         retainedInputs
     });
     return input.inputMode === 'freeform' ? content : { code: content };
@@ -37,7 +37,7 @@ export function contextGcCodeModeOutputReplacement(originalContent, truncated, v
         truncated,
         preview,
         previewComplete: !truncated && preview === originalContent,
-        contextGc: 'Detailed Code Mode output was reclaimed after six successful rollouts. An incomplete preview is not the complete cell output. The source was not replayed and nested tool side effects were not changed.'
+        contextGc: 'Detailed Code Mode output was reclaimed after the protection period. An incomplete preview is not the complete cell output. The source was not replayed and nested tool side effects were not changed.'
     });
 }
 export function contextGcPatchResultFromCompletedPayload(payload) {
@@ -111,7 +111,7 @@ export function contextGcWebOutputReplacement(toolName, originalContent, truncat
         truncated,
         preview,
         previewComplete: preview === originalContent,
-        contextGc: 'Detailed web tool output was reclaimed after six successful rollouts. An incomplete preview is not the complete search result or page, and GC did not access the network.'
+        contextGc: 'Detailed web tool output was reclaimed after the protection period. An incomplete preview is not the complete search result or page, and GC did not access the network.'
     });
 }
 /** Tools with their own evidence and lifecycle policies are never handled as generic output. */
@@ -142,7 +142,7 @@ export function contextGcToolOutputReplacement(toolName, originalContent, trunca
         truncated,
         preview,
         previewComplete: !truncated && preview === originalContent,
-        contextGc: 'Detailed tool output was reclaimed after six successful rollouts. An incomplete preview is not the complete result; the tool was not replayed.'
+        contextGc: 'Detailed tool output was reclaimed after the protection period. An incomplete preview is not the complete result; the tool was not replayed.'
     });
 }
 export function contextGcSkillOutputReplacement(name, originalContent, successorCallId) {

package/dist/session/store/jsonl/fork-session.js

@@ -3,7 +3,7 @@ import { mkdir, rename, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { AgentError } from '../../../error.js';
 import { inlineMediaHistory } from '../../inline-media.js';
-import { copyToolResultResources } from '../../tool-result-resources.js';
+import { prepareToolResultResources, writeToolResultResourceIndex } from '../../tool-result-resources.js';
 import { syncJsonlDirectory } from './fs-durability.js';
 import { forkedPayload, stageSessionSegments } from './history.js';
 import { copyGeneratedImages, generatedImageFileNames } from './images.js';
@@ -63,14 +63,49 @@ export async function forkSessionOperation(source, records, input, sourceRoot, s
             }
         ];
         const retained = input.boundaryTurnId === null ? [] : records.slice(1, boundaryIndex + 1);
+        const resourcesByOwner = new Map();
+        for (const [resourceRef, { owner, bytes }] of await prepareToolResultResources(sourceDirectory, retained)) {
+            const resources = resourcesByOwner.get(owner) ?? [];
+            resources.push({ resourceRef, bytes });
+            resourcesByOwner.set(owner, resources);
+        }
+        const resourceLocators = new Map();
         const inlineState = inlineMediaHistory(retained).state;
         const stateAnchor = inlineState &&
             retained.findLast((record) => record.type === 'resource.window' || record.type === 'compact.completed');
         const forkIdentities = new Map();
         for (const record of retained) {
-            if (record.type === 'context.gc.completed' || record.type === 'responses.continuation')
+            if (record.type === 'context.gc.completed' ||
+                record.type === 'responses.continuation' ||
+                record.type === 'tool.resource')
                 continue;
+            const pendingLocators = [];
+            for (const { resourceRef, bytes } of resourcesByOwner.get(record.recordId) ?? []) {
+                const bodySequences = [];
+                // Small private records share normal segment durability and rollback boundaries.
+                for (let offset = 0; offset < Math.max(1, bytes.length); offset += 1024 * 1024) {
+                    const sequence = copied.length + 1;
+                    bodySequences.push(sequence);
+                    copied.push({
+                        recordId: randomUUID(),
+                        sequence,
+                        sessionId: target.id,
+                        type: 'tool.resource',
+                        payload: {
+                            resourceRef,
+                            dataBase64: bytes.subarray(offset, offset + 1024 * 1024).toString('base64')
+                        },
+                        ...(record.executionId === undefined ? {} : { executionId: record.executionId }),
+                        ...(record.turnId === undefined ? {} : { turnId: record.turnId }),
+                        timestamp: record.timestamp
+                    });
+                }
+                pendingLocators.push({ resourceRef, bodySequences });
+            }
+            resourcesByOwner.delete(record.recordId);
             const identity = { recordId: randomUUID(), sequence: copied.length + 1 };
+            for (const { resourceRef, bodySequences } of pendingLocators)
+                resourceLocators.set(resourceRef, { ...identity, bodySequences });
             forkIdentities.set(record.recordId, identity);
             copied.push({
                 ...identity,
@@ -95,7 +130,7 @@ export async function forkSessionOperation(source, records, input, sourceRoot, s
             await rename(file.temporaryPath, file.path);
         target.segments = staged.segments;
         target.nextSequence = copied.length + 1;
-        await copyToolResultResources(sourceDirectory, targetDirectory, copied);
+        await writeToolResultResourceIndex(targetDirectory, resourceLocators);
         await copyGeneratedImages(sourceRoot, publication.directory, generatedImageFileNames(retained));
         await copyResources(sourceDirectory, targetDirectory, retained);
         for (const path of [

package/dist/session/store/jsonl/history-replacement.d.ts

@@ -39,8 +39,9 @@ export type HistoryIndexOutcome = {
     readonly error: unknown;
 };
 /** Execute one rollback/clear transaction while its caller holds maintenance. */
-export declare function replaceSessionHistory(meta: SessionMeta, retained: readonly SessionRecord[], operation: {
+export declare function replaceSessionHistory(meta: SessionMeta, prefix: readonly SessionRecord[], operation: {
     kind: 'rollback';
+    reuseSegments: boolean;
 } | {
     kind: 'clear';
     clearedAt: string;

package/dist/session/store/jsonl/history-replacement.js

@@ -4,17 +4,26 @@ import { basename, join } from 'node:path';
 import { toolResultResourceFiles } from '../../tool-result-resources.js';
 import { beginSessionStorageTransaction, retiredSessionTrashPath, recoverSessionStorageTransaction } from './transaction-recovery.js';
 import { deriveExecutionState } from '../execution-state.js';
-import { renameIfExists, retainedSessionTitle, stageSessionSegments, stageUnreferencedImages } from './history.js';
+import { renameIfExists, retainedSessionTitle, stageRollbackSegments, stageSessionSegments, stageUnreferencedImages } from './history.js';
 import { generatedImageFileNames } from './images.js';
 import { CONTEXTUAL_WORLD_STATE_FILE } from './open-recovery.js';
 import { resourceFiles } from './resources.js';
 import { syncJsonlDirectory } from './fs-durability.js';
 /** Execute one rollback/clear transaction while its caller holds maintenance. */
-export async function replaceSessionHistory(meta, retained, operation, context) {
+export async function replaceSessionHistory(meta, prefix, operation, context) {
+    const retained = operation.kind === 'rollback'
+        ? prefix.filter((record) => record.type !== 'responses.continuation')
+        : prefix;
     const targetDirectory = context.targetGeneration === undefined
         ? context.directory
         : join(context.sessionDirectory, 'v2', context.targetGeneration);
-    const staged = await stageSessionSegments(targetDirectory, retained);
+    const incremental = operation.kind === 'rollback' &&
+        operation.reuseSegments &&
+        meta.storage?.encoding === 2 &&
+        meta.segments !== undefined;
+    const staged = incremental
+        ? await stageRollbackSegments(targetDirectory, prefix, meta.segments)
+        : await stageSessionSegments(targetDirectory, retained);
     const transactionId = randomUUID();
     const targetNextSequence = operation.kind === 'clear' ? 2 : (retained.at(-1)?.sequence ?? 0) + 1;
     const contextualWorldStatePath = join(context.directory, CONTEXTUAL_WORLD_STATE_FILE);
@@ -22,7 +31,9 @@ export async function replaceSessionHistory(meta, retained, operation, context)
     const originalTransactionId = meta.storageTransactionId;
     const originalPaths = await context.segmentPaths();
     const retiredPaths = await retiredSessionPaths(context.sessionDirectory, context.directory, targetDirectory);
-    const backups = originalPaths.map((path) => ({
+    const backups = originalPaths
+        .filter((path) => !staged.reused?.has(basename(path)))
+        .map((path) => ({
         path,
         backup: `${path}.${transactionId}.${operation.kind}-backup`
     }));
@@ -30,7 +41,7 @@ export async function replaceSessionHistory(meta, retained, operation, context)
         version: 1,
         id: transactionId,
         kind: operation.kind,
-        originalSegments: originalPaths.map((path) => basename(path)),
+        originalSegments: backups.map((item) => basename(item.path)),
         stagedSegments: staged.files.map((item) => ({
             path: basename(item.path),
             temporary: basename(item.temporaryPath)

package/dist/session/store/jsonl/history.d.ts

@@ -6,8 +6,13 @@ interface StagedSessionSegments {
         readonly temporaryPath: string;
     }[];
     readonly segments: NonNullable<SessionMeta['segments']>;
+    readonly reused?: ReadonlySet<string>;
 }
 export declare function stageSessionSegments(sessionDirectory: string, records: readonly SessionRecord[], operation?: 'rollback' | 'fork'): Promise<StagedSessionSegments>;
+/** Reuse intact files in ordered v2 histories; journal only replacements and removals. */
+export declare function stageRollbackSegments(directory: string, prefix: readonly SessionRecord[], originals: NonNullable<SessionMeta['segments']>): Promise<StagedSessionSegments & {
+    readonly reused: ReadonlySet<string>;
+}>;
 export declare function stageUnreferencedImages(sessionDirectory: string, directoryName: 'generated_images' | 'tool_results' | 'resources', retained: ReadonlySet<string>, transactionId: string): Promise<Array<{
     from: string;
     to: string;

package/dist/session/store/jsonl/history.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { AgentError } from '../../../error.js';
 import { parseInlineMediaState } from '../../inline-media.js';
 import { MAX_SEGMENT_BYTES } from './records.js';
+import { forEachTransactionFile } from './transaction-files.js';
 export async function renameIfExists(from, to) {
     try {
         await rename(from, to);
@@ -26,23 +27,9 @@ export async function stageSessionSegments(sessionDirectory, records, operation
         if (group === undefined)
             return;
         const number = segments.length + 1;
-        const path = join(sessionDirectory, `events-${String(number).padStart(6, '0')}.jsonl`);
-        const temporaryPath = `${path}.${transactionId}.${operation}-tmp`;
-        const handle = await open(temporaryPath, 'wx', 0o600);
-        files.push({ path, temporaryPath });
-        try {
-            await handle.writeFile(group.lines.join(''));
-            await handle.sync();
-        }
-        finally {
-            await handle.close();
-        }
-        segments.push({
-            number,
-            firstSequence: group.firstSequence,
-            lastSequence: group.lastSequence,
-            bytes: group.bytes
-        });
+        const staged = await writeStagedSegment(sessionDirectory, group, number, transactionId, operation);
+        files.push(staged.file);
+        segments.push(staged.segment);
         group = undefined;
     };
     try {
@@ -67,10 +54,86 @@ export async function stageSessionSegments(sessionDirectory, records, operation
         return { files, segments };
     }
     catch (error) {
-        await Promise.all(files.map((item) => rm(item.temporaryPath, { force: true }))).catch(() => undefined);
+        await forEachTransactionFile(files, (file) => rm(file.temporaryPath, { force: true }).catch(() => undefined));
+        throw error;
+    }
+}
+/** Reuse intact files in ordered v2 histories; journal only replacements and removals. */
+export async function stageRollbackSegments(directory, prefix, originals) {
+    const files = [];
+    const segments = [];
+    const reused = new Set();
+    const transactionId = randomUUID();
+    let offset = 0;
+    try {
+        for (const original of originals) {
+            const start = offset;
+            while (offset < prefix.length && prefix[offset].sequence <= original.lastSequence)
+                offset++;
+            const source = prefix.slice(start, offset);
+            if (source.length === 0)
+                break;
+            const retained = source.filter((record) => record.type !== 'responses.continuation');
+            if (retained.length === source.length && source.at(-1).sequence === original.lastSequence) {
+                reused.add(`events-${String(original.number).padStart(6, '0')}.jsonl`);
+                segments.push({ ...original });
+            }
+            else if (retained.length > 0) {
+                const lines = retained.map((record) => `${JSON.stringify(record)}\n`);
+                const staged = await writeStagedSegment(directory, {
+                    lines,
+                    bytes: lines.reduce((total, line) => total + Buffer.byteLength(line), 0),
+                    firstSequence: retained[0].sequence,
+                    lastSequence: retained.at(-1).sequence
+                }, original.number, transactionId, 'rollback');
+                files.push(staged.file);
+                segments.push(staged.segment);
+            }
+        }
+        return { files, segments, reused };
+    }
+    catch (error) {
+        await forEachTransactionFile(files, (file) => rm(file.temporaryPath, { force: true }).catch(() => undefined));
         throw error;
     }
 }
+async function writeStagedSegment(directory, group, number, transactionId, operation) {
+    const path = join(directory, `events-${String(number).padStart(6, '0')}.jsonl`);
+    const temporaryPath = `${path}.${transactionId}.${operation}-tmp`;
+    const handle = await open(temporaryPath, 'wx', 0o600);
+    let failed = false;
+    let failure;
+    try {
+        await handle.writeFile(group.lines.join(''));
+        await handle.sync();
+    }
+    catch (error) {
+        failed = true;
+        failure = error;
+    }
+    try {
+        await handle.close();
+    }
+    catch (error) {
+        if (!failed) {
+            failed = true;
+            failure = error;
+        }
+    }
+    if (failed) {
+        await rm(temporaryPath, { force: true }).catch(() => undefined);
+        throw failure;
+    }
+    return {
+        file: { path, temporaryPath },
+        segment: {
+            number,
+            firstSequence: group.firstSequence,
+            lastSequence: group.lastSequence,
+            bytes: group.bytes
+        }
+    };
+}
 export async function stageUnreferencedImages(sessionDirectory, directoryName, retained, transactionId) {
     const directory = join(sessionDirectory, directoryName);
     let names;
@@ -84,14 +147,12 @@ export async function stageUnreferencedImages(sessionDirectory, directoryName, r
     }
     const moved = [];
     try {
-        for (const name of names) {
-            if (retained.has(name))
-                continue;
+        await forEachTransactionFile(names.filter((name) => !retained.has(name)), async (name) => {
             const from = join(directory, name);
             const trash = join(directory, `.${name}.${transactionId}.rollback-trash`);
             await rename(from, trash);
             moved.push({ from: trash, to: from, trash });
-        }
+        });
         return moved;
     }
     catch (error) {
@@ -100,8 +161,7 @@ export async function stageUnreferencedImages(sessionDirectory, directoryName, r
     }
 }
 export async function restoreRenamedFiles(files) {
-    for (const file of files.toReversed())
-        await rename(file.from, file.to).catch(() => undefined);
+    await forEachTransactionFile(files, (file) => rename(file.from, file.to).catch(() => undefined));
 }
 export function retainedSessionTitle(records, fallback) {
     let title = fallback;

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

@@ -698,14 +698,28 @@ export class JsonlSessionStore {
             const meta = this.#shared.index.sessions.find((item) => item.id === sessionId);
             if (!meta)
                 throw new AgentError('MAR_AGENT_SESSION_NOT_FOUND', 'Session was not found.');
-            const records = await this.read(sessionId);
+            const indexedSegments = meta.segments;
+            let segmentIndex = 0;
+            let matchingSegments = indexedSegments !== undefined;
+            // Check optional cache bounds during the history read already required by rollback.
+            const records = await this.#serializeRecordOperation(sessionId, () => this.#readRecords(sessionId, undefined, (path, segment) => {
+                const indexed = indexedSegments?.[segmentIndex];
+                segmentIndex++;
+                matchingSegments &&=
+                    indexed !== undefined &&
+                        path === this.#segmentPath(sessionId, indexed.number, meta) &&
+                        segment[0]?.sequence === indexed.firstSequence &&
+                        segment.at(-1)?.sequence === indexed.lastSequence;
+            }));
             if (records[0]?.type !== 'session.created')
                 throw new AgentError('MAR_AGENT_SESSION_CORRUPT', 'Session history is corrupt.');
             const boundaryIndex = rollbackBoundaryIndex(records, input);
-            const retained = records
-                .slice(0, boundaryIndex + 1)
-                .filter((record) => record.type !== 'responses.continuation');
-            return await this.#replaceHistory(meta, retained, { kind: 'rollback' });
+            const retained = records.slice(0, boundaryIndex + 1);
+            // Migrated v1 histories may preserve duplicate or non-increasing sequences.
+            const reuseSegments = matchingSegments &&
+                segmentIndex === indexedSegments?.length &&
+                records.every((record, index) => index === 0 || record.sequence > records[index - 1].sequence);
+            return await this.#replaceHistory(meta, retained, { kind: 'rollback', reuseSegments });
         }
         catch (error) {
             failed = true;
@@ -1110,7 +1124,7 @@ export class JsonlSessionStore {
     async read(sessionId) {
         return this.#serializeRecordOperation(sessionId, () => this.#readRecords(sessionId));
     }
-    async #readRecords(sessionId, selectedMeta) {
+    async #readRecords(sessionId, selectedMeta, onSegment) {
         return withSessionReadPin(this.#sessionRoot(sessionId), async () => {
             this.#assertOpen();
             if (!selectedMeta)
@@ -1125,8 +1139,11 @@ export class JsonlSessionStore {
                 const records = [];
                 const meta = selectedMeta ?? this.#shared.index.sessions.find((item) => item.id === sessionId);
                 const encoding = meta?.storage?.encoding ?? 1;
-                for (const path of await this.#segmentPaths(sessionId, meta))
-                    records.push(...(await readRecords(path, encoding)));
+                for (const path of await this.#segmentPaths(sessionId, meta)) {
+                    const segment = await readRecords(path, encoding);
+                    onSegment?.(path, segment);
+                    records.push(...segment);
+                }
                 return records;
             }
             catch (cause) {

package/dist/session/store/jsonl/transaction-files.d.ts

@@ -0,0 +1,2 @@
+/** Stop scheduling on the first failure, then drain all in-flight filesystem operations. */
+export declare function forEachTransactionFile<T>(files: readonly T[], operation: (file: T) => Promise<unknown>): Promise<void>;

package/dist/session/store/jsonl/transaction-files.js

@@ -0,0 +1,22 @@
+/** Stop scheduling on the first failure, then drain all in-flight filesystem operations. */
+export async function forEachTransactionFile(files, operation) {
+    let next = 0;
+    let failed = false;
+    let failure;
+    await Promise.all(Array.from({ length: Math.min(8, files.length) }, async () => {
+        while (!failed && next < files.length) {
+            const file = files[next++];
+            try {
+                await operation(file);
+            }
+            catch (error) {
+                if (!failed) {
+                    failed = true;
+                    failure = error;
+                }
+            }
+        }
+    }));
+    if (failed)
+        throw failure;
+}

package/dist/session/store/jsonl/transaction-recovery.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { AgentError } from '../../../error.js';
+import { forEachTransactionFile } from './transaction-files.js';
 const JOURNAL = 'storage-transaction.json';
 const SEGMENT = /^events-\d{6}\.jsonl$/u;
 const TRANSACTION_ID = /^[0-9a-f-]{36}$/iu;
@@ -291,24 +292,24 @@ export async function recoverSessionStorageTransaction(directory, committedTrans
         ? directory
         : join(sessionDirectory, 'v2', transaction.targetGeneration);
     const originals = new Set(transaction.originalSegments);
-    for (const name of transaction.originalSegments) {
+    await forEachTransactionFile([...originals], async (name) => {
         const canonical = join(directory, name);
         const backup = `${canonical}.${transaction.id}.${transaction.kind}-backup`;
-        if (!(await exists(backup)))
-            continue;
         if (committed)
             await rm(backup, { force: true });
         else {
+            if (!(await exists(backup)))
+                return;
             await rm(canonical, { force: true });
             await rename(backup, canonical);
         }
-    }
+    });
     if (!committed)
-        for (const entry of transaction.stagedSegments)
+        await forEachTransactionFile(transaction.stagedSegments, async (entry) => {
             if (stagedDirectory !== directory || !originals.has(entry.path))
                 await rm(join(stagedDirectory, entry.path), { force: true });
-    for (const entry of transaction.stagedSegments)
-        await rm(join(stagedDirectory, entry.temporary), { force: true });
+        });
+    await forEachTransactionFile(transaction.stagedSegments, (entry) => rm(join(stagedDirectory, entry.temporary), { force: true }));
     if (!committed && transaction.targetGeneration !== undefined)
         await rm(stagedDirectory, { recursive: true, force: true });
     const sidecar = join(directory, 'context-world-state.json');
@@ -333,15 +334,13 @@ export async function recoverSessionStorageTransaction(directory, committedTrans
             throw error;
         }
         const suffix = `.${transaction.id}.rollback-trash`;
-        for (const name of names) {
-            if (!name.startsWith('.') || !name.endsWith(suffix))
-                continue;
+        await forEachTransactionFile(names.filter((name) => name.startsWith('.') && name.endsWith(suffix)), async (name) => {
             const trash = join(path, name);
             if (committed)
                 await rm(trash, { force: true });
             else
                 await rename(trash, join(path, name.slice(1, -suffix.length)));
-        }
+        });
     }
     for (const path of transaction.retiredPaths ?? []) {
         const source = join(sessionDirectory, path);
@@ -357,9 +356,7 @@ export async function recoverSessionStorageTransaction(directory, committedTrans
     await removeUnjournaledTransactionFiles(directory);
 }
 async function removeUnjournaledTransactionFiles(directory) {
-    for (const name of await readdir(directory))
-        if (isUnjournaledTransactionFile(name))
-            await rm(join(directory, name), { force: true });
+    await forEachTransactionFile((await readdir(directory)).filter(isUnjournaledTransactionFile), (name) => rm(join(directory, name), { force: true }));
 }
 async function exists(path) {
     try {

package/dist/session/tool-result-resources.d.ts

@@ -20,7 +20,16 @@ export declare function recordToolResources(record: Pick<SessionRecord, 'type' |
 /** A locator is only a hint: reads must verify its exact committed record identity. */
 export declare function bindToolResultResources(directory: string, record: SessionRecord, readRecord?: (sequence: number) => Promise<SessionRecord | undefined>, degrade?: boolean): Promise<void>;
 export declare function toolResultResourceFiles(records: readonly SessionRecord[]): Set<string>;
-export declare function copyToolResultResources(source: string, target: string, records: readonly SessionRecord[]): Promise<void>;
+export interface ToolResourceLocator {
+    sequence: number;
+    recordId: string;
+    bodySequences?: number[];
+}
+export declare function prepareToolResultResources(source: string, records: readonly SessionRecord[]): Promise<Map<string, {
+    owner: string;
+    bytes: Buffer;
+}>>;
+export declare function writeToolResultResourceIndex(target: string, locators: ReadonlyMap<string, ToolResourceLocator>): Promise<void>;
 export declare function completeToolResultResources(directory: string, record: SessionRecord): Promise<void>;
 export declare function cleanupUnreferencedToolResources(directory: string, readRecords: () => Promise<readonly SessionRecord[]>): Promise<void>;
 /** Caller must hold a stable history and resource generation for the entire read. */