@modelprofile.com/flexharness 2.1.0 → 3.0.1

package/dist_ts/classes.stores.js

@@ -1,24 +1,249 @@
 import * as plugins from './plugins.js';
-import { FlexHarnessStoreConflictError, FlexHarnessStoreFormatError, FlexHarnessValidationError, } from './errors.js';
-import { assertFlexHarnessSnapshot, cloneSerializable } from './utils.json.js';
-function validateSave(snapshot, expectedRevision) {
-    assertFlexHarnessSnapshot(snapshot);
+import { FlexHarnessStoreCommitUncertainError, FlexHarnessStoreConflictError, FlexHarnessStoreFormatError, FlexHarnessValidationError, } from './errors.js';
+import { assertFlexPermissionSnapshot, assertFlexProjectionSnapshot, assertFlexScopeSnapshot, assertJsonSerializable, cloneSerializable, } from './utils.json.js';
+function validateIdentifier(value, name) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new FlexHarnessValidationError(`${name} must be a non-empty string.`);
+    }
+}
+function validateExpectedRevision(expectedRevision) {
     if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
         throw new FlexHarnessValidationError('expectedRevision must be a non-negative integer.');
     }
+}
+function validateSnapshotSave(snapshot, expectedRevision, validator) {
+    validator(snapshot);
+    validateExpectedRevision(expectedRevision);
     if (snapshot.revision !== expectedRevision + 1) {
         throw new FlexHarnessStoreFormatError(`Snapshot revision ${snapshot.revision} must equal expected revision ${expectedRevision} plus one.`);
     }
     return cloneSerializable(snapshot);
 }
-export class InMemoryFlexHarnessStore {
+function providerKey(storageKey, sessionId) {
+    validateIdentifier(storageKey, 'storageKey');
+    validateIdentifier(sessionId, 'sessionId');
+    return JSON.stringify([storageKey, sessionId]);
+}
+function assertProjectionSession(snapshot, sessionId) {
+    for (const message of snapshot.messages) {
+        if (message.sessionId !== sessionId) {
+            throw new FlexHarnessStoreFormatError(`Projection message "${message.messageId}" does not belong to session "${sessionId}".`);
+        }
+    }
+    for (const terminal of snapshot.stagedTerminals) {
+        if (terminal.userMessage.sessionId !== sessionId
+            || terminal.assistantMessage.sessionId !== sessionId) {
+            throw new FlexHarnessStoreFormatError(`Staged terminal "${terminal.runId}" does not belong to session "${sessionId}".`);
+        }
+    }
+}
+function normalizeJsonObjectUndefined(value, path = '$') {
+    const seen = new WeakSet();
+    const visit = (current, currentPath) => {
+        if (current === null
+            || typeof current === 'string'
+            || typeof current === 'boolean')
+            return current;
+        if (typeof current === 'number') {
+            if (!Number.isFinite(current)) {
+                throw new FlexHarnessStoreFormatError(`${currentPath} contains a non-finite number.`);
+            }
+            return current;
+        }
+        if (typeof current !== 'object') {
+            throw new FlexHarnessStoreFormatError(`${currentPath} contains ${typeof current}, which is not JSON-safe.`);
+        }
+        if (seen.has(current)) {
+            throw new FlexHarnessStoreFormatError(`${currentPath} contains a circular reference.`);
+        }
+        const prototype = Object.getPrototypeOf(current);
+        if (!Array.isArray(current) && prototype !== Object.prototype && prototype !== null) {
+            throw new FlexHarnessStoreFormatError(`${currentPath} contains a non-plain object.`);
+        }
+        if (Object.getOwnPropertySymbols(current).length > 0) {
+            throw new FlexHarnessStoreFormatError(`${currentPath} contains a symbol-keyed property.`);
+        }
+        seen.add(current);
+        if (Array.isArray(current)) {
+            const result = current.map((entry, index) => {
+                if (!(index in current) || entry === undefined) {
+                    throw new FlexHarnessStoreFormatError(`${currentPath}[${index}] is not JSON-safe.`);
+                }
+                return visit(entry, `${currentPath}[${index}]`);
+            });
+            seen.delete(current);
+            return result;
+        }
+        const result = {};
+        for (const key of Object.getOwnPropertyNames(current)) {
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (!descriptor.enumerable || !('value' in descriptor)) {
+                throw new FlexHarnessStoreFormatError(`${currentPath}.${key} is not a plain JSON property.`);
+            }
+            if (descriptor.value !== undefined) {
+                result[key] = visit(descriptor.value, `${currentPath}.${key}`);
+            }
+        }
+        seen.delete(current);
+        return result;
+    };
+    const normalized = visit(value, path);
+    assertJsonSerializable(normalized, path);
+    return normalized;
+}
+function assertNonEmptyString(value, path) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new FlexHarnessStoreFormatError(`${path} must be a non-empty string.`);
+    }
+}
+function assertNonNegativeInteger(value, path) {
+    if (!Number.isSafeInteger(value) || Number(value) < 0) {
+        throw new FlexHarnessStoreFormatError(`${path} must be a non-negative integer.`);
+    }
+}
+function assertExactKeys(value, keys, path) {
+    const invalidKey = Object.keys(value).find((key) => !keys.includes(key));
+    if (invalidKey) {
+        throw new FlexHarnessStoreFormatError(`${path}.${invalidKey} is not supported.`);
+    }
+}
+function assertRecord(value, path) {
+    if (!value
+        || typeof value !== 'object'
+        || Array.isArray(value)
+        || (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)) {
+        throw new FlexHarnessStoreFormatError(`${path} must be a plain object.`);
+    }
+}
+function createAgentEventSnapshot(sessionId, events, revision) {
+    return {
+        schemaVersion: 2,
+        sessionId,
+        revision,
+        updatedAt: events.reduce((latest, event) => Math.max(latest, event.timestamp), 0),
+        events: normalizeJsonObjectUndefined([...events], '$events'),
+    };
+}
+function validateAgentEventSnapshot(value, sessionId) {
+    assertJsonSerializable(value, '$snapshot');
+    try {
+        return plugins.validateAgentEventSnapshotV2(value, sessionId);
+    }
+    catch (error) {
+        throw new FlexHarnessStoreFormatError(`$snapshot is not a canonical schema-2 Agent event snapshot: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+}
+function validateAgentEventArchive(value, sessionId, archiveId) {
+    assertJsonSerializable(value, '$archive');
+    try {
+        return plugins.validateAgentEventArchiveV2(value, sessionId, archiveId);
+    }
+    catch (error) {
+        throw new FlexHarnessStoreFormatError(`$archive is not a canonical schema-2 Agent event archive: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+}
+function validateToolJobSnapshot(value) {
+    assertJsonSerializable(value, '$snapshot');
+    assertRecord(value, '$snapshot');
+    assertExactKeys(value, ['schemaVersion', 'revision', 'updatedAt', 'jobs'], '$snapshot');
+    if (value.schemaVersion !== 1) {
+        throw new FlexHarnessStoreFormatError('Tool job snapshot schemaVersion must be 1.');
+    }
+    assertNonNegativeInteger(value.revision, '$snapshot.revision');
+    assertNonNegativeInteger(value.updatedAt, '$snapshot.updatedAt');
+    if (!Array.isArray(value.jobs)) {
+        throw new FlexHarnessStoreFormatError('$snapshot.jobs must be an array.');
+    }
+    const executionIds = new Set();
+    for (let index = 0; index < value.jobs.length; index++) {
+        const path = `$snapshot.jobs[${index}]`;
+        assertRecord(value.jobs[index], path);
+        const job = value.jobs[index];
+        assertExactKeys(job, [
+            'executionId',
+            'type',
+            'state',
+            'request',
+            'exitCode',
+            'stdout',
+            'stderr',
+            'signal',
+            'startedAt',
+            'updatedAt',
+            'finishedAt',
+        ], path);
+        assertNonEmptyString(job.executionId, `${path}.executionId`);
+        if (executionIds.has(job.executionId)) {
+            throw new FlexHarnessStoreFormatError(`$snapshot.jobs contains duplicate job "${job.executionId}".`);
+        }
+        executionIds.add(job.executionId);
+        assertNonEmptyString(job.type, `${path}.type`);
+        if (!['running', 'finished', 'failed', 'aborted'].includes(String(job.state))) {
+            throw new FlexHarnessStoreFormatError(`${path}.state is invalid.`);
+        }
+        if (job.request !== undefined) {
+            const requestPath = `${path}.request`;
+            assertRecord(job.request, requestPath);
+            assertExactKeys(job.request, ['type', 'command', 'cwd', 'timeoutMs', 'metadata'], requestPath);
+            assertNonEmptyString(job.request.type, `${requestPath}.type`);
+            if (job.request.command !== undefined) {
+                const commandPath = `${requestPath}.command`;
+                assertRecord(job.request.command, commandPath);
+                assertExactKeys(job.request.command, ['executable', 'args'], commandPath);
+                assertNonEmptyString(job.request.command.executable, `${commandPath}.executable`);
+                if (!Array.isArray(job.request.command.args)) {
+                    throw new FlexHarnessStoreFormatError(`${commandPath}.args must be an array.`);
+                }
+                for (let argumentIndex = 0; argumentIndex < job.request.command.args.length; argumentIndex++) {
+                    if (typeof job.request.command.args[argumentIndex] !== 'string') {
+                        throw new FlexHarnessStoreFormatError(`${commandPath}.args[${argumentIndex}] must be a string.`);
+                    }
+                }
+            }
+            if (job.request.cwd !== undefined && typeof job.request.cwd !== 'string') {
+                throw new FlexHarnessStoreFormatError(`${requestPath}.cwd must be a string.`);
+            }
+            if (job.request.timeoutMs !== undefined) {
+                assertNonNegativeInteger(job.request.timeoutMs, `${requestPath}.timeoutMs`);
+            }
+            if (job.request.metadata !== undefined) {
+                assertRecord(job.request.metadata, `${requestPath}.metadata`);
+            }
+        }
+        if (job.exitCode !== undefined && job.exitCode !== null && !Number.isSafeInteger(job.exitCode)) {
+            throw new FlexHarnessStoreFormatError(`${path}.exitCode must be an integer or null.`);
+        }
+        for (const key of ['stdout', 'stderr', 'signal']) {
+            if (job[key] !== undefined && typeof job[key] !== 'string') {
+                throw new FlexHarnessStoreFormatError(`${path}.${key} must be a string.`);
+            }
+        }
+        for (const key of ['startedAt', 'updatedAt', 'finishedAt']) {
+            if (job[key] !== undefined)
+                assertNonNegativeInteger(job[key], `${path}.${key}`);
+        }
+    }
+    return value;
+}
+function createToolJobSnapshot(jobs, revision) {
+    const snapshot = {
+        schemaVersion: 1,
+        revision,
+        updatedAt: Date.now(),
+        jobs: normalizeJsonObjectUndefined([...jobs], '$jobs'),
+    };
+    return validateToolJobSnapshot(snapshot);
+}
+class InMemoryScopeStore {
     snapshots = new Map();
     async load(storageKey) {
+        validateIdentifier(storageKey, 'storageKey');
         const snapshot = this.snapshots.get(storageKey);
         return snapshot ? cloneSerializable(snapshot) : undefined;
     }
     async save(storageKey, snapshot, expectedRevision) {
-        const validated = validateSave(snapshot, expectedRevision);
+        validateIdentifier(storageKey, 'storageKey');
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexScopeSnapshot);
         const actualRevision = this.snapshots.get(storageKey)?.revision ?? 0;
         if (actualRevision !== expectedRevision) {
             throw new FlexHarnessStoreConflictError(storageKey, expectedRevision, actualRevision);
@@ -26,86 +251,392 @@ export class InMemoryFlexHarnessStore {
         this.snapshots.set(storageKey, validated);
     }
 }
-/**
- * Atomic and CAS-safe across instances in this process. It intentionally does not
- * claim cross-process safety because no operating-system lock is held.
- */
-export class JsonFileFlexHarnessStore {
-    static fileQueues = new Map();
-    directory;
-    constructor(options) {
-        if (!options.directory) {
-            throw new FlexHarnessValidationError('JsonFileFlexHarnessStore requires a directory.');
+class InMemoryProjectionStore {
+    snapshots = new Map();
+    async load(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        const snapshot = this.snapshots.get(key);
+        return snapshot ? cloneSerializable(snapshot) : undefined;
+    }
+    async save(storageKey, sessionId, snapshot, expectedRevision) {
+        const key = providerKey(storageKey, sessionId);
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexProjectionSnapshot);
+        assertProjectionSession(validated, sessionId);
+        const actualRevision = this.snapshots.get(key)?.revision ?? 0;
+        if (actualRevision !== expectedRevision) {
+            throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
         }
-        this.directory = plugins.path.resolve(options.directory);
+        this.snapshots.set(key, validated);
     }
-    async load(storageKey) {
-        const filePath = this.filePath(storageKey);
-        return JsonFileFlexHarnessStore.inFileQueue(filePath, async () => {
-            await this.preparePath(filePath);
-            return this.readSnapshot(filePath);
-        });
+    async deleteSession(storageKey, sessionId) {
+        this.snapshots.delete(providerKey(storageKey, sessionId));
     }
-    async save(storageKey, snapshot, expectedRevision) {
-        const validated = validateSave(snapshot, expectedRevision);
-        const filePath = this.filePath(storageKey);
-        await JsonFileFlexHarnessStore.inFileQueue(filePath, async () => {
-            await this.preparePath(filePath);
-            const current = await this.readSnapshot(filePath);
-            const actualRevision = current?.revision ?? 0;
-            if (actualRevision !== expectedRevision) {
-                throw new FlexHarnessStoreConflictError(storageKey, expectedRevision, actualRevision);
+}
+class InMemoryPermissionStore {
+    snapshots = new Map();
+    async load(storageKey, sessionId) {
+        const snapshot = this.snapshots.get(providerKey(storageKey, sessionId));
+        return snapshot ? cloneSerializable(snapshot) : undefined;
+    }
+    async save(storageKey, sessionId, snapshot, expectedRevision) {
+        const key = providerKey(storageKey, sessionId);
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexPermissionSnapshot);
+        const actualRevision = this.snapshots.get(key)?.revision ?? 0;
+        if (actualRevision !== expectedRevision) {
+            throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+        }
+        this.snapshots.set(key, validated);
+    }
+    async deleteSession(storageKey, sessionId) {
+        this.snapshots.delete(providerKey(storageKey, sessionId));
+    }
+}
+class InMemoryAgentEventStore {
+    sessionId;
+    eventSchemaVersion = 2;
+    snapshot;
+    archives = new Map();
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+    }
+    assertSession(sessionId) {
+        if (sessionId !== this.sessionId) {
+            throw new FlexHarnessValidationError(`Agent event store is bound to session "${this.sessionId}", not "${sessionId}".`);
+        }
+    }
+    async load(sessionId) {
+        this.assertSession(sessionId);
+        return this.snapshot ? cloneSerializable(this.snapshot) : undefined;
+    }
+    async save(sessionId, events, expectedRevision) {
+        this.assertSession(sessionId);
+        validateExpectedRevision(expectedRevision);
+        const snapshot = createAgentEventSnapshot(sessionId, events, expectedRevision + 1);
+        validateAgentEventSnapshot(snapshot, sessionId);
+        const actualRevision = this.snapshot?.revision ?? 0;
+        if (actualRevision !== expectedRevision) {
+            throw new plugins.AgentEventStoreConflictError(sessionId, expectedRevision, actualRevision);
+        }
+        this.snapshot = cloneSerializable(snapshot);
+        return snapshot.revision;
+    }
+    async archive(archive) {
+        this.assertSession(archive.sessionId);
+        const normalized = normalizeJsonObjectUndefined(archive, '$archive');
+        const validated = validateAgentEventArchive(normalized, this.sessionId, archive.archiveId);
+        const existing = this.archives.get(archive.archiveId);
+        if (existing) {
+            if (JSON.stringify(existing.events.map((event) => event.id))
+                !== JSON.stringify(validated.events.map((event) => event.id))) {
+                throw new Error(`Archive "${archive.archiveId}" already exists with different events.`);
             }
-            await this.writeSnapshot(filePath, validated);
-        });
+            return;
+        }
+        this.archives.set(archive.archiveId, cloneSerializable(validated));
+    }
+    async loadArchive(sessionId, archiveId) {
+        this.assertSession(sessionId);
+        validateIdentifier(archiveId, 'archiveId');
+        const archive = this.archives.get(archiveId);
+        return archive ? cloneSerializable(archive) : undefined;
+    }
+    clear() {
+        this.snapshot = undefined;
+        this.archives.clear();
+    }
+}
+class InMemoryAgentEventStoreProvider {
+    stores = new Map();
+    getStore(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        let store = this.stores.get(key);
+        if (!store) {
+            store = new InMemoryAgentEventStore(sessionId);
+            this.stores.set(key, store);
+        }
+        return store;
+    }
+    async deleteSession(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        const store = this.stores.get(key);
+        if (!store)
+            return;
+        store.clear();
+        this.stores.delete(key);
+    }
+}
+class InMemoryToolJobStore {
+    snapshot;
+    async load(abortSignal) {
+        abortSignal?.throwIfAborted();
+        return this.snapshot ? cloneSerializable(this.snapshot) : undefined;
+    }
+    async save(jobs, expectedRevision, abortSignal) {
+        abortSignal?.throwIfAborted();
+        validateExpectedRevision(expectedRevision);
+        const snapshot = createToolJobSnapshot(jobs, expectedRevision + 1);
+        const actualRevision = this.snapshot?.revision ?? 0;
+        if (actualRevision !== expectedRevision) {
+            throw new plugins.ToolJobStoreConflictError(expectedRevision, actualRevision);
+        }
+        this.snapshot = cloneSerializable(snapshot);
+        return snapshot.revision;
+    }
+    clear() {
+        this.snapshot = undefined;
+    }
+}
+class InMemoryToolJobStoreProvider {
+    stores = new Map();
+    getStore(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        let store = this.stores.get(key);
+        if (!store) {
+            store = new InMemoryToolJobStore();
+            this.stores.set(key, store);
+        }
+        return store;
+    }
+    async deleteSession(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        const store = this.stores.get(key);
+        if (!store)
+            return;
+        store.clear();
+        this.stores.delete(key);
+    }
+}
+export class InMemoryFlexHarnessStores {
+    scopes = new InMemoryScopeStore();
+    projections = new InMemoryProjectionStore();
+    permissions = new InMemoryPermissionStore();
+    agentEvents = new InMemoryAgentEventStoreProvider();
+    jobs = new InMemoryToolJobStoreProvider();
+}
+const jsonDomains = ['scopes', 'projections', 'permissions', 'events', 'archives', 'jobs'];
+function aggregateStoreErrors(errors, message) {
+    return errors.length === 1 ? errors[0] : new AggregateError(errors, message);
+}
+class JsonFileRoot {
+    static fileQueues = new Map();
+    directory;
+    retainedFileHandles = new Set();
+    fileHandleClosures = new Map();
+    constructor(directory) {
+        this.directory = plugins.path.resolve(directory);
     }
-    static inFileQueue(filePath, operation) {
-        const previous = JsonFileFlexHarnessStore.fileQueues.get(filePath) ?? Promise.resolve();
+    static inQueue(key, operation) {
+        const previous = JsonFileRoot.fileQueues.get(key) ?? Promise.resolve();
         const result = previous.catch(() => undefined).then(operation);
         const barrier = result.then(() => undefined, () => undefined);
-        JsonFileFlexHarnessStore.fileQueues.set(filePath, barrier);
+        JsonFileRoot.fileQueues.set(key, barrier);
         void barrier.then(() => {
-            if (JsonFileFlexHarnessStore.fileQueues.get(filePath) === barrier) {
-                JsonFileFlexHarnessStore.fileQueues.delete(filePath);
-            }
+            if (JsonFileRoot.fileQueues.get(key) === barrier)
+                JsonFileRoot.fileQueues.delete(key);
         });
         return result;
     }
-    filePath(storageKey) {
-        const digest = plugins.crypto.createHash('sha256').update(storageKey).digest('hex');
-        return plugins.path.join(this.directory, `${digest}.json`);
+    digest(value) {
+        return plugins.crypto.createHash('sha256').update(value).digest('hex');
+    }
+    scopePath(domain, storageKey) {
+        validateIdentifier(storageKey, 'storageKey');
+        return plugins.path.join(this.directory, domain, `${this.digest(storageKey)}.json`);
+    }
+    sessionPath(domain, storageKey, sessionId) {
+        validateIdentifier(storageKey, 'storageKey');
+        validateIdentifier(sessionId, 'sessionId');
+        return plugins.path.join(this.directory, domain, this.digest(storageKey), `${this.digest(sessionId)}.json`);
+    }
+    archivePath(storageKey, sessionId, archiveId) {
+        validateIdentifier(archiveId, 'archiveId');
+        return plugins.path.join(this.archiveSessionPath(storageKey, sessionId), `${this.digest(archiveId)}.json`);
     }
-    async preparePath(filePath) {
+    archiveSessionPath(storageKey, sessionId) {
+        validateIdentifier(storageKey, 'storageKey');
+        validateIdentifier(sessionId, 'sessionId');
+        return plugins.path.join(this.directory, 'archives', this.digest(storageKey), this.digest(sessionId));
+    }
+    eventQueueKey(storageKey, sessionId) {
+        return `event:${this.sessionPath('events', storageKey, sessionId)}`;
+    }
+    async prepareRoot() {
+        await this.retryRetainedFileHandles();
         await plugins.fs.mkdir(this.directory, { recursive: true, mode: 0o700 });
         await plugins.fs.chmod(this.directory, 0o700);
-        await this.cleanupTemps(filePath);
+        await Promise.all(jsonDomains.map(async (domain) => {
+            const path = plugins.path.join(this.directory, domain);
+            await plugins.fs.mkdir(path, { recursive: true, mode: 0o700 });
+            await plugins.fs.chmod(path, 0o700);
+        }));
+    }
+    closeFileHandle(handle) {
+        const existing = this.fileHandleClosures.get(handle);
+        if (existing)
+            return existing;
+        let closure;
+        closure = handle.close().then(() => {
+            this.retainedFileHandles.delete(handle);
+        }, (error) => {
+            this.retainedFileHandles.add(handle);
+            throw error;
+        }).finally(() => {
+            if (this.fileHandleClosures.get(handle) === closure) {
+                this.fileHandleClosures.delete(handle);
+            }
+        });
+        this.fileHandleClosures.set(handle, closure);
+        return closure;
+    }
+    async retryRetainedFileHandles() {
+        const results = await Promise.allSettled([...this.retainedFileHandles].map((handle) => this.closeFileHandle(handle)));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            throw aggregateStoreErrors(errors, 'Failed to close retained JSON store file handles.');
+        }
+    }
+    async dispose() {
+        await Promise.allSettled([...this.fileHandleClosures.values()]);
+        await this.retryRetainedFileHandles();
+    }
+    async prepareDirectory(directory) {
+        await this.prepareRoot();
+        await plugins.fs.mkdir(directory, { recursive: true, mode: 0o700 });
+        let current = directory;
+        while (current !== this.directory && current.startsWith(`${this.directory}${plugins.path.sep}`)) {
+            await plugins.fs.chmod(current, 0o700);
+            current = plugins.path.dirname(current);
+        }
     }
     async cleanupTemps(filePath) {
+        const directory = plugins.path.dirname(filePath);
         const prefix = `${plugins.path.basename(filePath)}.`;
-        const entries = await plugins.fs.readdir(this.directory, { withFileTypes: true });
-        await Promise.all(entries
+        const entries = await plugins.fs.readdir(directory, { withFileTypes: true });
+        const cleanupResults = await Promise.allSettled(entries
             .filter((entry) => entry.isFile() && entry.name.startsWith(prefix) && entry.name.endsWith('.tmp'))
             .map(async (entry) => {
             try {
-                await plugins.fs.unlink(plugins.path.join(this.directory, entry.name));
+                await plugins.fs.unlink(plugins.path.join(directory, entry.name));
             }
             catch (error) {
-                if (error.code !== 'ENOENT') {
+                if (error.code !== 'ENOENT')
                     throw error;
-                }
             }
         }));
+        const cleanupErrors = cleanupResults
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (cleanupErrors.length > 0) {
+            throw aggregateStoreErrors(cleanupErrors, `Failed to clean temporary files for ${filePath}.`);
+        }
     }
-    async readSnapshot(filePath) {
+    async attemptDirectorySync(directory) {
+        let handle;
+        let syncError;
+        let closeError;
+        try {
+            handle = await plugins.fs.open(directory, 'r');
+            await handle.sync();
+        }
+        catch (error) {
+            syncError = error;
+        }
+        if (handle) {
+            try {
+                await this.closeFileHandle(handle);
+            }
+            catch (error) {
+                closeError = error;
+            }
+        }
+        return { syncError, closeError };
+    }
+    async writeExact(handle, serialized) {
+        let offset = 0;
+        while (offset < serialized.length) {
+            const { bytesWritten } = await handle.write(serialized, offset, serialized.length - offset, offset);
+            if (bytesWritten === 0) {
+                throw new Error('Writing the store temporary file made no progress.');
+            }
+            offset += bytesWritten;
+        }
+    }
+    async syncParentAfterWrite(filePath, serialized) {
+        const directory = plugins.path.dirname(filePath);
+        const firstAttempt = await this.attemptDirectorySync(directory);
+        if (firstAttempt.syncError === undefined && firstAttempt.closeError === undefined)
+            return;
+        let comparisonError;
+        try {
+            const persisted = await plugins.fs.readFile(filePath);
+            if (!persisted.equals(serialized)) {
+                throw new Error(`Destination bytes at ${filePath} do not match the committed write.`);
+            }
+        }
+        catch (error) {
+            comparisonError = error;
+        }
+        const retryAttempt = await this.attemptDirectorySync(directory);
+        if (comparisonError === undefined
+            && retryAttempt.syncError === undefined
+            && firstAttempt.closeError === undefined
+            && retryAttempt.closeError === undefined)
+            return;
+        const errors = [
+            firstAttempt.syncError,
+            firstAttempt.closeError,
+            comparisonError,
+            retryAttempt.syncError,
+            retryAttempt.closeError,
+        ].filter((error) => error !== undefined);
+        throw new FlexHarnessStoreCommitUncertainError(filePath, 'write', {
+            cause: aggregateStoreErrors(errors, `Could not confirm the store write at ${filePath}.`),
+        });
+    }
+    async syncParentAfterDelete(deletedPath, operation) {
+        const directory = plugins.path.dirname(deletedPath);
+        const firstAttempt = await this.attemptDirectorySync(directory);
+        if (firstAttempt.syncError === undefined && firstAttempt.closeError === undefined)
+            return;
+        let comparisonError;
+        try {
+            await plugins.fs.stat(deletedPath);
+            comparisonError = new Error(`Deleted path ${deletedPath} still exists.`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                comparisonError = error;
+        }
+        const retryAttempt = await this.attemptDirectorySync(directory);
+        if (comparisonError === undefined
+            && retryAttempt.syncError === undefined
+            && firstAttempt.closeError === undefined
+            && retryAttempt.closeError === undefined)
+            return;
+        const errors = [
+            firstAttempt.syncError,
+            firstAttempt.closeError,
+            comparisonError,
+            retryAttempt.syncError,
+            retryAttempt.closeError,
+        ]
+            .filter((error) => error !== undefined);
+        throw new FlexHarnessStoreCommitUncertainError(deletedPath, operation, {
+            cause: aggregateStoreErrors(errors, `Could not confirm the store deletion at ${deletedPath}.`),
+        });
+    }
+    async read(filePath, validate) {
+        await this.prepareDirectory(plugins.path.dirname(filePath));
         let serialized;
         try {
             await plugins.fs.chmod(filePath, 0o600);
             serialized = await plugins.fs.readFile(filePath, 'utf8');
         }
         catch (error) {
-            if (error.code === 'ENOENT') {
+            if (error.code === 'ENOENT')
                 return undefined;
-            }
             throw error;
         }
         let parsed;
@@ -113,44 +644,406 @@ export class JsonFileFlexHarnessStore {
             parsed = JSON.parse(serialized);
         }
         catch (error) {
-            throw new FlexHarnessStoreFormatError(`Malformed JSON snapshot at ${filePath}.`, {
-                cause: error,
-            });
+            throw new FlexHarnessStoreFormatError(`Malformed JSON at ${filePath}.`, { cause: error });
         }
         try {
-            assertFlexHarnessSnapshot(parsed);
+            return validate(parsed);
         }
         catch (error) {
             if (error instanceof FlexHarnessStoreFormatError) {
-                throw new FlexHarnessStoreFormatError(`Invalid snapshot at ${filePath}: ${error.message}`, {
+                throw new FlexHarnessStoreFormatError(`Invalid JSON at ${filePath}: ${error.message}`, {
                     cause: error,
                 });
             }
             throw error;
         }
-        return cloneSerializable(parsed);
     }
-    async writeSnapshot(filePath, snapshot) {
+    async write(filePath, value) {
+        assertJsonSerializable(value);
+        const serialized = Buffer.from(`${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        const directory = plugins.path.dirname(filePath);
+        await this.prepareDirectory(directory);
+        await this.cleanupTemps(filePath);
         const tempPath = `${filePath}.${process.pid}.${plugins.crypto.randomUUID()}.tmp`;
-        let fileHandle;
+        let handle;
+        let operationError;
+        let operationFailed = false;
+        let renamed = false;
         try {
-            fileHandle = await plugins.fs.open(tempPath, 'wx', 0o600);
-            await fileHandle.writeFile(`${JSON.stringify(snapshot, null, 2)}\n`, 'utf8');
-            await fileHandle.sync();
-            await fileHandle.close();
-            fileHandle = undefined;
-            await plugins.fs.chmod(tempPath, 0o600);
+            handle = await plugins.fs.open(tempPath, 'wx', 0o600);
+            await this.writeExact(handle, serialized);
+            await handle.sync();
+            await this.closeFileHandle(handle);
+            handle = undefined;
             await plugins.fs.rename(tempPath, filePath);
-            await plugins.fs.chmod(filePath, 0o600);
+            renamed = true;
+            await this.syncParentAfterWrite(filePath, serialized);
         }
-        finally {
-            await fileHandle?.close().catch(() => undefined);
-            await plugins.fs.unlink(tempPath).catch((error) => {
-                if (error.code !== 'ENOENT') {
-                    throw error;
-                }
+        catch (error) {
+            operationError = error;
+            operationFailed = true;
+        }
+        const cleanupErrors = [];
+        if (handle) {
+            try {
+                await this.closeFileHandle(handle);
+            }
+            catch (error) {
+                cleanupErrors.push(error);
+            }
+        }
+        try {
+            await plugins.fs.unlink(tempPath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                cleanupErrors.push(error);
+        }
+        if (!operationFailed && cleanupErrors.length === 0)
+            return;
+        if (renamed
+            && operationError instanceof FlexHarnessStoreCommitUncertainError
+            && cleanupErrors.length === 0) {
+            throw operationError;
+        }
+        const errors = [];
+        if (operationFailed)
+            errors.push(operationError);
+        errors.push(...cleanupErrors);
+        const cause = aggregateStoreErrors(errors, `Store write or cleanup failed at ${filePath}.`);
+        if (renamed) {
+            throw new FlexHarnessStoreCommitUncertainError(filePath, 'write', { cause });
+        }
+        throw cause;
+    }
+    async deleteFile(filePath) {
+        await this.prepareDirectory(plugins.path.dirname(filePath));
+        try {
+            await plugins.fs.unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        await this.syncParentAfterDelete(filePath, 'delete-file');
+    }
+    async deleteDirectory(directory) {
+        await this.prepareDirectory(plugins.path.dirname(directory));
+        await plugins.fs.rm(directory, { recursive: true, force: true });
+        await this.syncParentAfterDelete(directory, 'delete-directory');
+    }
+}
+class JsonScopeStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async load(storageKey) {
+        const filePath = this.root.scopePath('scopes', storageKey);
+        return JsonFileRoot.inQueue(filePath, async () => {
+            const snapshot = await this.root.read(filePath, (value) => {
+                assertFlexScopeSnapshot(value);
+                return value;
+            });
+            return snapshot ? cloneSerializable(snapshot) : undefined;
+        });
+    }
+    async save(storageKey, snapshot, expectedRevision) {
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexScopeSnapshot);
+        const filePath = this.root.scopePath('scopes', storageKey);
+        await JsonFileRoot.inQueue(filePath, async () => {
+            const current = await this.root.read(filePath, (value) => {
+                assertFlexScopeSnapshot(value);
+                return value;
             });
+            const actualRevision = current?.revision ?? 0;
+            if (actualRevision !== expectedRevision) {
+                throw new FlexHarnessStoreConflictError(storageKey, expectedRevision, actualRevision);
+            }
+            await this.root.write(filePath, validated);
+        });
+    }
+}
+class JsonProjectionStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async load(storageKey, sessionId) {
+        const filePath = this.root.sessionPath('projections', storageKey, sessionId);
+        return JsonFileRoot.inQueue(filePath, async () => {
+            const snapshot = await this.root.read(filePath, (value) => {
+                assertFlexProjectionSnapshot(value);
+                assertProjectionSession(value, sessionId);
+                return value;
+            });
+            return snapshot ? cloneSerializable(snapshot) : undefined;
+        });
+    }
+    async save(storageKey, sessionId, snapshot, expectedRevision) {
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexProjectionSnapshot);
+        assertProjectionSession(validated, sessionId);
+        const filePath = this.root.sessionPath('projections', storageKey, sessionId);
+        await JsonFileRoot.inQueue(filePath, async () => {
+            const current = await this.root.read(filePath, (value) => {
+                assertFlexProjectionSnapshot(value);
+                assertProjectionSession(value, sessionId);
+                return value;
+            });
+            const actualRevision = current?.revision ?? 0;
+            if (actualRevision !== expectedRevision) {
+                throw new FlexHarnessStoreConflictError(providerKey(storageKey, sessionId), expectedRevision, actualRevision);
+            }
+            await this.root.write(filePath, validated);
+        });
+    }
+    async deleteSession(storageKey, sessionId) {
+        const filePath = this.root.sessionPath('projections', storageKey, sessionId);
+        await JsonFileRoot.inQueue(filePath, () => this.root.deleteFile(filePath));
+    }
+}
+class JsonPermissionStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async load(storageKey, sessionId) {
+        const filePath = this.root.sessionPath('permissions', storageKey, sessionId);
+        return JsonFileRoot.inQueue(filePath, async () => {
+            const snapshot = await this.root.read(filePath, (value) => {
+                assertFlexPermissionSnapshot(value);
+                return value;
+            });
+            return snapshot ? cloneSerializable(snapshot) : undefined;
+        });
+    }
+    async save(storageKey, sessionId, snapshot, expectedRevision) {
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexPermissionSnapshot);
+        const filePath = this.root.sessionPath('permissions', storageKey, sessionId);
+        await JsonFileRoot.inQueue(filePath, async () => {
+            const current = await this.root.read(filePath, (value) => {
+                assertFlexPermissionSnapshot(value);
+                return value;
+            });
+            const actualRevision = current?.revision ?? 0;
+            if (actualRevision !== expectedRevision) {
+                throw new FlexHarnessStoreConflictError(providerKey(storageKey, sessionId), expectedRevision, actualRevision);
+            }
+            await this.root.write(filePath, validated);
+        });
+    }
+    async deleteSession(storageKey, sessionId) {
+        const filePath = this.root.sessionPath('permissions', storageKey, sessionId);
+        await JsonFileRoot.inQueue(filePath, () => this.root.deleteFile(filePath));
+    }
+}
+async function clearJsonAgentEventSession(root, storageKey, sessionId) {
+    const filePath = root.sessionPath('events', storageKey, sessionId);
+    const archiveDirectory = root.archiveSessionPath(storageKey, sessionId);
+    await JsonFileRoot.inQueue(root.eventQueueKey(storageKey, sessionId), async () => {
+        await root.deleteFile(filePath);
+        await root.deleteDirectory(archiveDirectory);
+    });
+}
+class JsonAgentEventStore {
+    root;
+    storageKey;
+    sessionId;
+    eventSchemaVersion = 2;
+    constructor(root, storageKey, sessionId) {
+        this.root = root;
+        this.storageKey = storageKey;
+        this.sessionId = sessionId;
+    }
+    assertSession(sessionId) {
+        if (sessionId !== this.sessionId) {
+            throw new FlexHarnessValidationError(`Agent event store is bound to session "${this.sessionId}", not "${sessionId}".`);
         }
     }
+    async load(sessionId) {
+        this.assertSession(sessionId);
+        const filePath = this.root.sessionPath('events', this.storageKey, this.sessionId);
+        return JsonFileRoot.inQueue(this.root.eventQueueKey(this.storageKey, this.sessionId), async () => {
+            const snapshot = await this.root.read(filePath, (value) => validateAgentEventSnapshot(value, this.sessionId));
+            return snapshot ? cloneSerializable(snapshot) : undefined;
+        });
+    }
+    async save(sessionId, events, expectedRevision) {
+        this.assertSession(sessionId);
+        validateExpectedRevision(expectedRevision);
+        const snapshot = createAgentEventSnapshot(sessionId, events, expectedRevision + 1);
+        validateAgentEventSnapshot(snapshot, sessionId);
+        const filePath = this.root.sessionPath('events', this.storageKey, this.sessionId);
+        return JsonFileRoot.inQueue(this.root.eventQueueKey(this.storageKey, this.sessionId), async () => {
+            const current = await this.root.read(filePath, (value) => validateAgentEventSnapshot(value, this.sessionId));
+            const actualRevision = current?.revision ?? 0;
+            if (actualRevision !== expectedRevision) {
+                throw new plugins.AgentEventStoreConflictError(sessionId, expectedRevision, actualRevision);
+            }
+            await this.root.write(filePath, snapshot);
+            return snapshot.revision;
+        });
+    }
+    async archive(archive) {
+        this.assertSession(archive.sessionId);
+        const normalized = normalizeJsonObjectUndefined(archive, '$archive');
+        const validated = validateAgentEventArchive(normalized, this.sessionId, archive.archiveId);
+        const filePath = this.root.archivePath(this.storageKey, this.sessionId, archive.archiveId);
+        await JsonFileRoot.inQueue(this.root.eventQueueKey(this.storageKey, this.sessionId), async () => {
+            const current = await this.root.read(filePath, (value) => validateAgentEventArchive(value, this.sessionId, archive.archiveId));
+            if (current) {
+                if (JSON.stringify(current.events.map((event) => event.id))
+                    !== JSON.stringify(validated.events.map((event) => event.id))) {
+                    throw new Error(`Archive "${archive.archiveId}" already exists with different events.`);
+                }
+                return;
+            }
+            await this.root.write(filePath, validated);
+        });
+    }
+    async loadArchive(sessionId, archiveId) {
+        this.assertSession(sessionId);
+        const filePath = this.root.archivePath(this.storageKey, this.sessionId, archiveId);
+        return JsonFileRoot.inQueue(this.root.eventQueueKey(this.storageKey, this.sessionId), async () => {
+            const archive = await this.root.read(filePath, (value) => validateAgentEventArchive(value, this.sessionId, archiveId));
+            return archive ? cloneSerializable(archive) : undefined;
+        });
+    }
+    async clear() {
+        await clearJsonAgentEventSession(this.root, this.storageKey, this.sessionId);
+    }
+}
+class JsonAgentEventStoreProvider {
+    root;
+    stores = new Map();
+    constructor(root) {
+        this.root = root;
+    }
+    getStore(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        let store = this.stores.get(key);
+        if (!store) {
+            store = new JsonAgentEventStore(this.root, storageKey, sessionId);
+            this.stores.set(key, store);
+        }
+        return store;
+    }
+    releaseSession(storageKey, sessionId) {
+        this.stores.delete(providerKey(storageKey, sessionId));
+    }
+    async deleteSession(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        const store = this.stores.get(key);
+        if (store) {
+            await store.clear();
+        }
+        else {
+            await clearJsonAgentEventSession(this.root, storageKey, sessionId);
+        }
+        this.stores.delete(key);
+    }
+}
+async function clearJsonToolJobSession(root, storageKey, sessionId) {
+    const filePath = root.sessionPath('jobs', storageKey, sessionId);
+    await JsonFileRoot.inQueue(filePath, () => root.deleteFile(filePath));
+}
+class JsonToolJobStore {
+    root;
+    storageKey;
+    sessionId;
+    constructor(root, storageKey, sessionId) {
+        this.root = root;
+        this.storageKey = storageKey;
+        this.sessionId = sessionId;
+    }
+    filePath() {
+        return this.root.sessionPath('jobs', this.storageKey, this.sessionId);
+    }
+    async load(abortSignal) {
+        abortSignal?.throwIfAborted();
+        const filePath = this.filePath();
+        return JsonFileRoot.inQueue(filePath, async () => {
+            abortSignal?.throwIfAborted();
+            const snapshot = await this.root.read(filePath, validateToolJobSnapshot);
+            abortSignal?.throwIfAborted();
+            return snapshot ? cloneSerializable(snapshot) : undefined;
+        });
+    }
+    async save(jobs, expectedRevision, abortSignal) {
+        abortSignal?.throwIfAborted();
+        validateExpectedRevision(expectedRevision);
+        const snapshot = createToolJobSnapshot(jobs, expectedRevision + 1);
+        const filePath = this.filePath();
+        return JsonFileRoot.inQueue(filePath, async () => {
+            abortSignal?.throwIfAborted();
+            const current = await this.root.read(filePath, validateToolJobSnapshot);
+            const actualRevision = current?.revision ?? 0;
+            if (actualRevision !== expectedRevision) {
+                throw new plugins.ToolJobStoreConflictError(expectedRevision, actualRevision);
+            }
+            abortSignal?.throwIfAborted();
+            await this.root.write(filePath, snapshot);
+            return snapshot.revision;
+        });
+    }
+    async clear() {
+        await clearJsonToolJobSession(this.root, this.storageKey, this.sessionId);
+    }
+}
+class JsonToolJobStoreProvider {
+    root;
+    stores = new Map();
+    constructor(root) {
+        this.root = root;
+    }
+    getStore(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        let store = this.stores.get(key);
+        if (!store) {
+            store = new JsonToolJobStore(this.root, storageKey, sessionId);
+            this.stores.set(key, store);
+        }
+        return store;
+    }
+    releaseSession(storageKey, sessionId) {
+        this.stores.delete(providerKey(storageKey, sessionId));
+    }
+    async deleteSession(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        const store = this.stores.get(key);
+        if (store) {
+            await store.clear();
+        }
+        else {
+            await clearJsonToolJobSession(this.root, storageKey, sessionId);
+        }
+        this.stores.delete(key);
+    }
+}
+/**
+ * Atomic and CAS-safe across instances in this process. No operating-system lock
+ * is held, so this store intentionally does not claim cross-process safety.
+ */
+export class JsonFileFlexHarnessStores {
+    scopes;
+    projections;
+    permissions;
+    agentEvents;
+    jobs;
+    root;
+    constructor(options) {
+        if (!options?.directory?.trim()) {
+            throw new FlexHarnessValidationError('JsonFileFlexHarnessStores requires a directory.');
+        }
+        this.root = new JsonFileRoot(options.directory);
+        this.scopes = new JsonScopeStore(this.root);
+        this.projections = new JsonProjectionStore(this.root);
+        this.permissions = new JsonPermissionStore(this.root);
+        this.agentEvents = new JsonAgentEventStoreProvider(this.root);
+        this.jobs = new JsonToolJobStoreProvider(this.root);
+    }
+    dispose() {
+        return this.root.dispose();
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stores.js","sourceRoot":"","sources":["../ts/classes.stores.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stores.js","sourceRoot":"","sources":["../ts/classes.stores.ts"],"names":[],"mappings":"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"}