@modelprofile.com/flexharness 10.24.0 → 10.24.1

package/dist_ts/classes.flexharness.core.js

@@ -0,0 +1,1538 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessClosedError, FlexHarnessExternalError, FlexHarnessImportedSessionError, FlexHarnessNotFoundError, FlexHarnessRunError, FlexHarnessSessionBusyError, FlexHarnessStoreConflictError, FlexHarnessStoreCommitUncertainError, FlexHarnessValidationError, modelLimitErrorInfo, } from './errors.js';
+import { InMemoryFlexHarnessStores } from './classes.stores.js';
+import { assertJsonSerializable, cloneSerializable, deepFreeze, resolveJsonLimits, } from './utils.json.js';
+import { hydrateAgentMessages } from './utils.prompt.js';
+import { normalizeAgentSessionPolicy, normalizeBuiltInTools, normalizeSlashCommands, normalizeToolCatalogOptions, normalizeSubagents, requireHarnessStores, resolveBoundedPositiveInteger, resolveCallbackLimits, resolvePromptQueueLimits, resolveReversionMaintenanceTimeoutMs, resolveReversionLimits, } from './utils.harnessoptions.js';
+import { jsonBytes, maxMessagePageCursorBytes, maxTransferIdentifierBytes, publicSnapshot, requireTransferIdentifier, } from './utils.transfer.js';
+import { resolveSessionImportLimits } from './utils.sessionimport.js';
+import { validateIdentifier, validateProjectedErrorInfo } from './utils.validation.js';
+import { createSessionMetricsOperation, createSessionMetricsState, } from './utils.sessionmetrics.js';
+import { scopeRetirementMessage, externalErrorFallback, requireSessionGeneration, combineErrors, terminalActivityError, isAbortError, } from './utils.flexharness.js';
+import { FlexHarnessResults } from './classes.flexharness.results.js';
+import { FlexHarnessToolDispatch } from './classes.flexharness.tooldispatch.js';
+import { FlexHarnessToolProviders } from './classes.flexharness.providers.js';
+import { FlexHarnessCompaction } from './classes.flexharness.compaction.js';
+import { FlexHarnessSessionConfigurations } from './classes.flexharness.configurations.js';
+import { FlexHarnessPermissions } from './classes.flexharness.permissions.js';
+import { FlexHarnessRunCallbacks } from './classes.flexharness.callbacks.js';
+import { FlexHarnessDelegatedRunAdmission } from './classes.flexharness.admission.js';
+import { FlexHarnessProjectManagement } from './classes.flexharness.projects.js';
+import { FlexHarnessSessionImports } from './classes.flexharness.imports.js';
+import { FlexHarnessSlashCommands } from './classes.flexharness.slashcommands.js';
+import { FlexHarnessSubagents } from './classes.flexharness.subagents.js';
+import { FlexHarnessPromptQueue } from './classes.flexharness.prompts.js';
+import { FlexHarnessReversions } from './classes.flexharness.reversions.js';
+import { FlexHarnessSessionDeletion } from './classes.flexharness.deletion.js';
+import { FlexHarnessLifecycle } from './classes.flexharness.lifecycle.js';
+import { FlexHarnessRuns } from './classes.flexharness.runs.js';
+import { FlexHarnessSessions } from './classes.flexharness.sessions.js';
+const defaultMaxSubagentDepth = 6;
+const maximumMaxSubagentDepth = 8;
+const defaultMaxSubagentCallsPerRun = 32;
+const maximumMaxSubagentCallsPerRun = 128;
+const repairCancellationMessage = 'The process stopped before this run completed.';
+function deriveLegacySessionGenerationId(storageKey, sessionId, createdAt) {
+    const digest = plugins.crypto.createHash('sha256').update(JSON.stringify([
+        'flexharness-legacy-session-generation-v1',
+        storageKey,
+        sessionId,
+        createdAt,
+    ])).digest('hex');
+    return `legacy_${digest}`;
+}
+/**
+ * The engine behind {@link FlexHarness}: its options, scope state, events and error projection, and
+ * the services that implement its API.
+ */
+export class FlexHarnessCore {
+    scopeResolver;
+    modelResolver;
+    sessionConfigurationResolver;
+    toolProvider;
+    resourceToolProviderResolver;
+    executionContextProvider;
+    delegatedRunAdmissionProvider;
+    stores;
+    agentSessionPolicy;
+    toolOutputLimits;
+    callbackLimits;
+    promptQueueLimits;
+    reversionLimits;
+    sessionImportLimits;
+    reversionMaintenanceTimeoutMs;
+    turnReversionProvider;
+    reversionPolicy;
+    externalErrorProjector;
+    subagents;
+    builtInTools;
+    toolCatalogOptions;
+    slashCommands;
+    maxSubagentDepth;
+    maxSubagentCallsPerRun;
+    stateLoads = new Map();
+    scopeAdmissions = new Map();
+    listeners = new Set();
+    trustedInternalErrors = new WeakSet();
+    sequence = 0;
+    closed = false;
+    results = new FlexHarnessResults(this);
+    toolDispatch = new FlexHarnessToolDispatch(this);
+    providers = new FlexHarnessToolProviders(this);
+    compaction = new FlexHarnessCompaction(this);
+    configurations = new FlexHarnessSessionConfigurations(this);
+    permissions = new FlexHarnessPermissions(this);
+    callbacks = new FlexHarnessRunCallbacks(this);
+    admission = new FlexHarnessDelegatedRunAdmission(this);
+    projects = new FlexHarnessProjectManagement(this);
+    imports = new FlexHarnessSessionImports(this);
+    commands = new FlexHarnessSlashCommands(this);
+    subagentTasks = new FlexHarnessSubagents(this);
+    prompts = new FlexHarnessPromptQueue(this);
+    reversions = new FlexHarnessReversions(this);
+    deletion = new FlexHarnessSessionDeletion(this);
+    lifecycle = new FlexHarnessLifecycle(this);
+    runs = new FlexHarnessRuns(this);
+    sessions = new FlexHarnessSessions(this);
+    constructor(options) {
+        if (!options || typeof options !== 'object') {
+            throw new FlexHarnessValidationError('FlexHarness options are required.');
+        }
+        this.scopeResolver = options.scopeResolver;
+        this.modelResolver = options.modelResolver;
+        this.sessionConfigurationResolver = options.sessionConfigurationResolver;
+        this.toolProvider = options.toolProvider;
+        this.resourceToolProviderResolver = options.resourceToolProviderResolver;
+        this.executionContextProvider = options.executionContextProvider;
+        this.delegatedRunAdmissionProvider = options.delegatedRunAdmissionProvider;
+        this.stores = requireHarnessStores(options.stores ?? new InMemoryFlexHarnessStores());
+        this.agentSessionPolicy = normalizeAgentSessionPolicy(options.agentSessionPolicy);
+        this.toolOutputLimits = resolveJsonLimits(options.toolOutputLimits);
+        this.callbackLimits = resolveCallbackLimits(options.callbackLimits);
+        this.promptQueueLimits = resolvePromptQueueLimits(options.promptQueueLimits);
+        this.reversionLimits = resolveReversionLimits(options.reversionLimits);
+        this.sessionImportLimits = resolveSessionImportLimits(options.sessionImportLimits);
+        this.reversionMaintenanceTimeoutMs = resolveReversionMaintenanceTimeoutMs(options);
+        this.turnReversionProvider = options.turnReversionProvider;
+        this.reversionPolicy = options.reversionPolicy ?? 'transcript-optional';
+        if (!['transcript-optional', 'workspace-required'].includes(this.reversionPolicy)) {
+            throw new FlexHarnessValidationError('reversionPolicy must be "transcript-optional" or "workspace-required".');
+        }
+        const protocolVersion = this.turnReversionProvider
+            && 'protocolVersion' in this.turnReversionProvider
+            ? this.turnReversionProvider.protocolVersion
+            : 1;
+        if (protocolVersion !== 1 && protocolVersion !== 2) {
+            throw new FlexHarnessValidationError('Turn reversion provider protocolVersion is invalid.');
+        }
+        if (this.reversionPolicy === 'workspace-required' && protocolVersion !== 2) {
+            throw new FlexHarnessValidationError('workspace-required reversion policy requires a protocolVersion 2 turn reversion provider.');
+        }
+        this.externalErrorProjector = options.externalErrorProjector;
+        this.subagents = normalizeSubagents(options.subagents);
+        this.builtInTools = normalizeBuiltInTools(options.builtInTools);
+        const toolCatalogOptions = normalizeToolCatalogOptions(options.toolCatalog);
+        this.toolCatalogOptions = Object.freeze({
+            declarations: toolCatalogOptions.declarations,
+            outputTypeDepth: toolCatalogOptions.outputTypeDepth,
+            describeTopMatch: toolCatalogOptions.describeTopMatch,
+            ...(toolCatalogOptions.codeMode ? { codeMode: { limits: toolCatalogOptions.codeMode } } : {}),
+        });
+        this.slashCommands = normalizeSlashCommands(options.slashCommands);
+        this.maxSubagentDepth = resolveBoundedPositiveInteger(options.maxSubagentDepth, 'maxSubagentDepth', defaultMaxSubagentDepth, maximumMaxSubagentDepth);
+        this.maxSubagentCallsPerRun = resolveBoundedPositiveInteger(options.maxSubagentCallsPerRun, 'maxSubagentCallsPerRun', defaultMaxSubagentCallsPerRun, maximumMaxSubagentCallsPerRun);
+    }
+    /**
+     * Opens a section that changes what a view of the session shows and emits the events that
+     * describe the change. Closing is idempotent; close it once the events are emitted or the
+     * change is rolled back.
+     */
+    openPublication(state, sessionId) {
+        let release;
+        const section = new Promise((resolve) => {
+            release = resolve;
+        });
+        let sections = state.publications.get(sessionId);
+        if (!sections) {
+            sections = new Set();
+            state.publications.set(sessionId, sections);
+        }
+        sections.add(section);
+        return () => {
+            const current = state.publications.get(sessionId);
+            if (!current?.delete(section))
+                return;
+            if (current.size === 0)
+                state.publications.delete(sessionId);
+            release();
+        };
+    }
+    subscribe(listener) {
+        this.assertOpen();
+        this.listeners.add(listener);
+        let subscribed = true;
+        return () => {
+            if (!subscribed)
+                return;
+            subscribed = false;
+            this.listeners.delete(listener);
+        };
+    }
+    projectExternalError(run, error, source) {
+        if ((typeof error === 'object' && error !== null) || typeof error === 'function') {
+            if (error === run.ownerCancellation
+                || error === run.callbackError
+                || this.trustedInternalErrors.has(error))
+                return error;
+        }
+        return this.projectOperationError(error, source, run.scopeId, run.sessionId, run.runId);
+    }
+    projectOperationError(error, source, scopeId, sessionId, runId) {
+        if ((typeof error === 'object' && error !== null) && this.trustedInternalErrors.has(error)) {
+            return error;
+        }
+        const defaultInfo = modelLimitErrorInfo(error) ?? externalErrorFallback;
+        let info = defaultInfo;
+        if (this.externalErrorProjector) {
+            try {
+                info = validateProjectedErrorInfo(this.externalErrorProjector(error, {
+                    source,
+                    scopeId,
+                    sessionId,
+                    runId,
+                }));
+            }
+            catch {
+                info = defaultInfo;
+            }
+        }
+        return this.trustInternalError(new FlexHarnessExternalError(info));
+    }
+    trustInternalError(error) {
+        Object.freeze(error);
+        this.trustedInternalErrors.add(error);
+        return error;
+    }
+    canonicalOutcomes(events) {
+        const outcomes = new Map();
+        const remember = (generationId, outcome) => {
+            const existing = outcomes.get(generationId);
+            if (existing && existing !== outcome) {
+                throw new FlexHarnessValidationError(`Generation "${generationId}" has conflicting canonical outcomes.`);
+            }
+            outcomes.set(generationId, outcome);
+        };
+        for (const event of events) {
+            if (event.type === 'generation-outcome')
+                remember(event.generationId, event.outcome);
+            if (event.type === 'context-compaction') {
+                for (const transaction of event.archivedTransactions ?? []) {
+                    remember(transaction.generationId, transaction.outcome);
+                }
+            }
+        }
+        return outcomes;
+    }
+    async durableCanonicalOutcomes(stored) {
+        const snapshot = await stored.eventStore.load(stored.session.sessionId);
+        return this.canonicalOutcomes(snapshot?.events ?? []);
+    }
+    async loadState(storageKey, scopeId, scope, compactorLifecycleController) {
+        const snapshot = cloneSerializable(await this.stores.scopes.load(storageKey) ?? {
+            schemaVersion: 1,
+            revision: 0,
+            sessions: [],
+            tombstones: [],
+        });
+        let scopeChanged = false;
+        const repairedGenerationSequence = snapshot.revision + 1;
+        for (const session of snapshot.sessions) {
+            if (session.sessionGenerationId !== undefined)
+                continue;
+            session.sessionGenerationId = deriveLegacySessionGenerationId(storageKey, session.sessionId, session.createdAt);
+            session.sessionGenerationSequence = repairedGenerationSequence;
+            scopeChanged = true;
+        }
+        for (const tombstone of snapshot.tombstones) {
+            if (tombstone.sessionGenerationId !== undefined)
+                continue;
+            tombstone.sessionGenerationId = deriveLegacySessionGenerationId(storageKey, tombstone.sessionId, tombstone.deletedAt);
+            tombstone.sessionGenerationSequence = repairedGenerationSequence;
+            scopeChanged = true;
+        }
+        const state = {
+            storageKey,
+            compactorLifecycleController,
+            scopeIdHint: scopeId,
+            scopeContext: { scopeId, scope },
+            revision: snapshot.revision,
+            sessions: new Map(),
+            retainedSessionCleanups: new Map(),
+            sessionDeletions: new Map(),
+            initializingSessions: new Set(),
+            sessionInitializations: new Map(),
+            sessionImports: new Map(),
+            tombstones: new Map(snapshot.tombstones.map((entry) => [entry.sessionId, entry])),
+            tombstoneCleanups: new Map(),
+            activeRuns: new Map(),
+            delegatedRunAdmissionOwners: new Set(),
+            pendingPermissions: new Map(),
+            publications: new Map(),
+            scopeQueue: Promise.resolve(),
+            lifecycle: 'active',
+            fenceInProgress: false,
+            fenceAdditionalErrors: [],
+            detachedCleanups: new Set(),
+        };
+        const loadedSessions = [];
+        try {
+            for (const metadata of snapshot.sessions) {
+                if (state.tombstones.has(metadata.sessionId))
+                    continue;
+                const stored = await this.loadSessionRuntime(state, metadata, scopeId, scope);
+                state.sessions.set(metadata.sessionId, stored);
+                loadedSessions.push(stored);
+                scopeChanged = (await this.repairLoadedSession(state.storageKey, stored, state, scopeId, scope)) || scopeChanged;
+                await this.reversions.drainReversionReleases(state, stored, scopeId, scope, false);
+                if (stored.projectionRevision < 0)
+                    throw new Error('Invalid projection revision.');
+            }
+            for (const stored of state.sessions.values()) {
+                let ancestorId = stored.session.parentSessionId;
+                const visited = new Set([stored.session.sessionId]);
+                while (ancestorId) {
+                    if (visited.has(ancestorId)) {
+                        throw new FlexHarnessValidationError(`Live session "${stored.session.sessionId}" has a cyclic ancestor chain.`);
+                    }
+                    visited.add(ancestorId);
+                    if (state.tombstones.has(ancestorId)) {
+                        throw new FlexHarnessValidationError(`Live session "${stored.session.sessionId}" descends from tombstoned ancestor "${ancestorId}".`);
+                    }
+                    ancestorId = state.sessions.get(ancestorId)?.session.parentSessionId;
+                }
+            }
+            const tombstoneRoots = this.deletion.orderTombstoneRootsChildFirst(state, [...new Set([...state.tombstones.values()].map((tombstone) => tombstone.rootSessionId ?? tombstone.sessionId))]);
+            for (const rootSessionId of tombstoneRoots) {
+                if (this.deletion.descendantTombstoneRoots(state, rootSessionId).length > 0)
+                    continue;
+                try {
+                    const group = this.deletion.tombstoneGroup(state, rootSessionId);
+                    for (const tombstone of group) {
+                        await this.reversions.releaseDeletedSessionReversions(state, storageKey, tombstone, scopeId, scope);
+                        await this.deletion.cleanupSessionDomains(state, tombstone);
+                    }
+                    for (const tombstone of group)
+                        state.tombstones.delete(tombstone.sessionId);
+                    scopeChanged = true;
+                }
+                catch (error) {
+                    // A retained tombstone is retried by the next load or explicit delete call.
+                    if (state.lifecycle === 'fenced') {
+                        this.lifecycle.deferNamespaceDrain(state, error, { scopeId, scope });
+                        break;
+                    }
+                }
+            }
+            if (scopeChanged) {
+                const next = this.createScopeSnapshot(state, state.revision + 1);
+                await this.stores.scopes.save(storageKey, next, state.revision);
+                state.revision = next.revision;
+            }
+            return state;
+        }
+        catch (error) {
+            for (const rootSessionId of new Set([...state.tombstones.values()].map((tombstone) => tombstone.rootSessionId ?? tombstone.sessionId))) {
+                const key = JSON.stringify([storageKey, rootSessionId]);
+                this.lifecycle.orphanedTombstoneOwners.set(key, {
+                    state,
+                    rootSessionId,
+                    scopeId,
+                    scope,
+                });
+            }
+            const closeResults = await Promise.allSettled(loadedSessions.map((stored) => this.lifecycle.closeStoredSession(stored)));
+            const errors = [error];
+            for (let index = 0; index < closeResults.length; index++) {
+                const result = closeResults[index];
+                if (result.status === 'rejected') {
+                    if (!this.lifecycle.storedSessionCleanupCompleted(loadedSessions[index])) {
+                        this.lifecycle.orphanedStoredSessions.add(loadedSessions[index]);
+                    }
+                    errors.push(result.reason);
+                }
+            }
+            throw combineErrors(errors);
+        }
+    }
+    createUninitializedStoredSession(session, storageKey, compactorLifecycleController = new AbortController()) {
+        const unavailable = new Proxy({}, {
+            get() {
+                throw new Error('AgentSession is not initialized.');
+            },
+        });
+        return {
+            storageKey,
+            session,
+            messages: [],
+            stagedTerminals: [],
+            reversionSegments: [],
+            revertCursor: 0,
+            excludedRunIds: [],
+            pendingReversionReleases: [],
+            projectionSchemaVersion: 3,
+            projectionReconciliationRequired: false,
+            projectionRevision: 0,
+            projectionQueue: Promise.resolve(),
+            metrics: createSessionMetricsState(false),
+            rememberedPermissionKeys: new Set(),
+            permissionRevision: 0,
+            permissionQueue: Promise.resolve(),
+            eventStore: undefined,
+            agentSession: unavailable,
+            agentSessionAbortCompleted: true,
+            agentSessionCloseCompleted: true,
+            agentEventStoreReleased: true,
+            executionContextCloseCompleted: true,
+            jobStoreReleased: true,
+            compactorLifecycleController,
+            promptQueue: [],
+            outstandingPromptsById: new Map(),
+            terminalPromptQueueEntries: new Map(),
+            outstandingPromptBytes: 0,
+        };
+    }
+    async loadSessionRuntime(state, metadata, scopeId, scope, compactorLifecycleController = new AbortController(), newSession = false) {
+        const sessionId = metadata.sessionId;
+        const compactorContext = this.compaction.createCompactorContext(scopeId, scope, state.storageKey, sessionId);
+        const [projectionResult, permissionResult, eventStoreResult, jobStoreResult] = await Promise.allSettled([
+            this.stores.projections.load(state.storageKey, sessionId),
+            this.stores.permissions.load(state.storageKey, sessionId),
+            this.stores.agentEvents.getStore(state.storageKey, sessionId),
+            this.stores.jobs.getStore(state.storageKey, sessionId),
+        ]);
+        const acquisitionErrors = [projectionResult, permissionResult, eventStoreResult, jobStoreResult]
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (projectionResult.status === 'rejected'
+            || permissionResult.status === 'rejected'
+            || eventStoreResult.status === 'rejected'
+            || jobStoreResult.status === 'rejected') {
+            if (eventStoreResult.status === 'fulfilled') {
+                try {
+                    await this.lifecycle.releasePartialProviderSession('agentEvents', state.storageKey, sessionId);
+                }
+                catch (error) {
+                    acquisitionErrors.push(error);
+                }
+            }
+            if (jobStoreResult.status === 'fulfilled') {
+                try {
+                    await this.lifecycle.releasePartialProviderSession('jobs', state.storageKey, sessionId);
+                }
+                catch (error) {
+                    acquisitionErrors.push(error);
+                }
+            }
+            throw combineErrors(acquisitionErrors);
+        }
+        const projection = projectionResult.value;
+        const legacyProjection = projection?.schemaVersion === 2 ? projection : undefined;
+        const currentProjection = projection?.schemaVersion === 3 ? projection : undefined;
+        const reversionSegments = currentProjection
+            ? cloneSerializable(currentProjection.reversionSegments)
+            : (legacyProjection?.reversionSegments ?? []).map((segment) => ({
+                ...cloneSerializable(segment),
+                protocolVersion: 1,
+                provenance: segment.workspaceCaptured ? 'workspace' : 'transcript',
+                ...(segment.workspaceCaptured
+                    ? { disposition: segment.status === 'capturing' ? 'pending' : 'revertible' }
+                    : {}),
+            }));
+        const pendingReversion = currentProjection?.pendingReversion
+            ?? (legacyProjection?.pendingReversion?.kind === 'capture'
+                ? { ...legacyProjection.pendingReversion, protocolVersion: 1 }
+                : legacyProjection?.pendingReversion);
+        const pendingReversionReleases = currentProjection
+            ? cloneSerializable(currentProjection.pendingReversionReleases)
+            : (legacyProjection?.pendingReversionReleases ?? []).map((release) => ({
+                ...cloneSerializable(release),
+                protocolVersion: 1,
+            }));
+        const permission = permissionResult.value;
+        const eventStore = eventStoreResult.value;
+        const jobStore = jobStoreResult.value;
+        let executionContextHandle;
+        try {
+            if (this.executionContextProvider) {
+                executionContextHandle = await this.compaction.withCompactorContext(compactorContext, () => this.executionContextProvider.provideExecutionContext({
+                    scopeId,
+                    scope,
+                    storageKey: state.storageKey,
+                    sessionId,
+                    jobStore,
+                }));
+                if (executionContextHandle
+                    && (!executionContextHandle.context
+                        || (executionContextHandle.close !== undefined && typeof executionContextHandle.close !== 'function'))) {
+                    throw new FlexHarnessValidationError('Execution context provider returned an invalid handle.');
+                }
+            }
+            const stored = {
+                storageKey: state.storageKey,
+                compactorContext,
+                session: cloneSerializable(metadata),
+                messages: cloneSerializable(projection?.messages ?? []),
+                stagedTerminals: cloneSerializable(projection?.stagedTerminals ?? []),
+                reversionSegments,
+                revertCursor: currentProjection?.revertCursor ?? legacyProjection?.revertCursor ?? 0,
+                excludedRunIds: cloneSerializable(currentProjection?.excludedRunIds ?? legacyProjection?.excludedRunIds ?? []),
+                ...(pendingReversion === undefined
+                    ? {}
+                    : { pendingReversion: cloneSerializable(pendingReversion) }),
+                pendingReversionReleases,
+                projectionSchemaVersion: projection?.schemaVersion ?? 3,
+                projectionReconciliationRequired: false,
+                ...(projection
+                    ? { projectionBaseline: cloneSerializable(projection) }
+                    : {}),
+                projectionRevision: projection?.revision ?? 0,
+                projectionQueue: Promise.resolve(),
+                metrics: cloneSerializable(currentProjection?.metrics ?? createSessionMetricsState(newSession)),
+                rememberedPermissionKeys: new Set(permission?.rememberedPermissionKeys ?? []),
+                permissionRevision: permission?.revision ?? 0,
+                permissionQueue: Promise.resolve(),
+                eventStore,
+                agentSession: undefined,
+                agentSessionAbortCompleted: false,
+                agentSessionCloseCompleted: false,
+                agentEventStoreReleased: this.stores.agentEvents.releaseSession === undefined,
+                executionContextHandle,
+                executionContextCloseCompleted: executionContextHandle?.close === undefined,
+                jobStoreReleased: this.stores.jobs.releaseSession === undefined,
+                jobs: executionContextHandle?.context.jobs,
+                compactorLifecycleController,
+                promptQueue: [],
+                outstandingPromptsById: new Map(),
+                terminalPromptQueueEntries: new Map(),
+                outstandingPromptBytes: 0,
+            };
+            if (currentProjection?.metrics === undefined
+                || stored.metrics.pendingGenerationId !== undefined
+                || stored.metrics.pendingCompactionId !== undefined
+                || (metadata.origin !== undefined && stored.metrics.lifetimeUsageComplete)) {
+                await this.mutateProjection(state, stored, () => {
+                    if (stored.metrics.pendingGenerationId !== undefined || stored.metrics.pendingCompactionId !== undefined
+                        || metadata.origin !== undefined) {
+                        stored.metrics.lifetimeUsageComplete = false;
+                    }
+                    delete stored.metrics.pendingGenerationId;
+                    delete stored.metrics.pendingCompactionId;
+                });
+            }
+            const { contextCompactor, ...agentSessionPolicy } = this.agentSessionPolicy;
+            const executionContext = executionContextHandle?.context;
+            const jobContext = executionContext?.jobs;
+            const contextualExecutionContext = executionContext && jobContext?.subscribe
+                ? {
+                    ...executionContext,
+                    jobs: {
+                        start: jobContext.start.bind(jobContext),
+                        get: jobContext.get.bind(jobContext),
+                        list: jobContext.list.bind(jobContext),
+                        ...(jobContext.abort ? { abort: jobContext.abort.bind(jobContext) } : {}),
+                        subscribe: (listener) => jobContext.subscribe((event) => this.compaction.withCompactorContext(compactorContext, () => listener(event))),
+                    },
+                }
+                : executionContext;
+            const agentSessionOptions = {
+                ...agentSessionPolicy,
+                sessionId,
+                eventStore,
+                executionContext: contextualExecutionContext,
+                contextBuilder: ({ events }) => hydrateAgentMessages((this.agentSessionPolicy.contextBuilder ?? ((options) => plugins.buildModelMessages(options.events)))({
+                    events: this.reversions.filterReversionContextEvents(stored, events),
+                })),
+                ...(contextCompactor
+                    ? {
+                        contextCompactor: async (messages, events, options) => {
+                            const ambientContext = this.compaction.compactorInvocationContext.getStore();
+                            const invocationContext = ambientContext
+                                ? (this.compaction.deferredCompactorContexts.get(ambientContext) ?? ambientContext)
+                                : undefined;
+                            if (!ambientContext
+                                || !invocationContext
+                                || invocationContext.storageKey !== state.storageKey
+                                || invocationContext.sessionId !== sessionId) {
+                                throw new Error('Agent context compaction is missing its exact FlexHarness invocation context.');
+                            }
+                            const { modelHint, ...invocation } = invocationContext;
+                            const filteredEvents = this.reversions.filterReversionContextEvents(stored, events);
+                            const filteredMessages = hydrateAgentMessages((this.agentSessionPolicy.contextBuilder
+                                ?? ((contextOptions) => plugins.buildModelMessages(contextOptions.events)))({
+                                events: filteredEvents,
+                            }));
+                            const operation = createSessionMetricsOperation(plugins.crypto.randomUUID(), 'compaction');
+                            try {
+                                await this.mutateProjection(state, stored, () => {
+                                    if (stored.metrics.pendingCompactionId !== undefined || stored.metricsFailure !== undefined) {
+                                        throw new Error('Session metrics compaction ownership is unresolved.');
+                                    }
+                                    stored.metrics.pendingCompactionId = operation.id;
+                                });
+                            }
+                            catch (error) {
+                                // No compactor ran. Reconcile a known committed reservation without inventing spend.
+                                // Unknown outcomes remain fenced and are repaired conservatively on namespace reload.
+                                if (state.lifecycle !== 'fenced' && stored.metrics.pendingCompactionId === operation.id) {
+                                    try {
+                                        await this.mutateProjection(state, stored, () => {
+                                            delete stored.metrics.pendingCompactionId;
+                                        }, true);
+                                    }
+                                    catch (cleanupError) {
+                                        stored.metricsFailure ??= cleanupError;
+                                        state.lifecycle = 'fenced';
+                                        throw combineErrors([error, cleanupError]);
+                                    }
+                                }
+                                throw error;
+                            }
+                            stored.metricsCompaction = operation;
+                            try {
+                                return await contextCompactor(filteredMessages, filteredEvents, {
+                                    ...options,
+                                    ...invocation,
+                                    scope: invocation.scope,
+                                    ...this.compaction.compactionModel(state, sessionId, ambientContext, options.reason, modelHint),
+                                    abortSignal: options.abortSignal
+                                        ? AbortSignal.any([
+                                            options.abortSignal,
+                                            state.compactorLifecycleController.signal,
+                                            stored.compactorLifecycleController.signal,
+                                        ])
+                                        : AbortSignal.any([
+                                            state.compactorLifecycleController.signal,
+                                            stored.compactorLifecycleController.signal,
+                                        ]),
+                                });
+                            }
+                            finally {
+                                try {
+                                    await this.callbacks.settleMetricsOperation(state, stored, operation);
+                                }
+                                finally {
+                                    delete stored.metricsCompaction;
+                                }
+                            }
+                        },
+                    }
+                    : {}),
+                transactionOutcomeErrorProjector: () => 'The model operation failed.',
+                onToken: (delta) => this.callbacks.onTextDelta(state, sessionId, delta),
+                onReasoningStart: (id) => this.callbacks.onReasoningStart(state, sessionId, id),
+                onReasoningDelta: (id, delta) => this.callbacks.onReasoningDelta(state, sessionId, id, delta),
+                onReasoningEnd: (id, text) => this.callbacks.onReasoningEnd(state, sessionId, id, text),
+                onToolCallStart: (event) => this.callbacks.onToolStart(state, sessionId, event),
+                onToolCallUpdate: (event) => this.callbacks.onToolUpdate(state, sessionId, event),
+                onToolCallFinish: (event) => this.callbacks.onToolFinish(state, sessionId, event),
+                onRetry: (event) => this.callbacks.onRetry(state, sessionId, event),
+                onUsage: (event) => this.callbacks.onModelCallUsage(state, stored, event),
+            };
+            stored.agentSession = await this.compaction.withCompactorContext(compactorContext, () => plugins.AgentSession.create(agentSessionOptions));
+            return stored;
+        }
+        catch (error) {
+            const cleanupErrors = [];
+            let executionContextClosed = true;
+            if (executionContextHandle && typeof executionContextHandle.close === 'function') {
+                try {
+                    await executionContextHandle.close();
+                }
+                catch (closeError) {
+                    executionContextClosed = false;
+                    this.lifecycle.orphanedExecutionContexts.set(executionContextHandle, {
+                        storageKey: state.storageKey,
+                        sessionId,
+                    });
+                    cleanupErrors.push(closeError);
+                }
+            }
+            try {
+                await this.lifecycle.releasePartialProviderSession('agentEvents', state.storageKey, sessionId);
+            }
+            catch (releaseError) {
+                cleanupErrors.push(releaseError);
+            }
+            if (executionContextClosed) {
+                try {
+                    await this.lifecycle.releasePartialProviderSession('jobs', state.storageKey, sessionId);
+                }
+                catch (releaseError) {
+                    cleanupErrors.push(releaseError);
+                }
+            }
+            else {
+                this.lifecycle.retainPartialProviderSession('jobs', state.storageKey, sessionId);
+            }
+            throw cleanupErrors.length === 0 ? error : combineErrors([error, ...cleanupErrors]);
+        }
+    }
+    async repairLoadedSession(storageKey, stored, state, scopeId, scope) {
+        if (stored.session.origin !== undefined) {
+            this.assertImportedSessionState(stored);
+            return false;
+        }
+        const beforeProjection = JSON.stringify({
+            messages: stored.messages,
+            stagedTerminals: stored.stagedTerminals,
+            reversionSegments: stored.reversionSegments,
+            revertCursor: stored.revertCursor,
+            excludedRunIds: stored.excludedRunIds,
+            pendingReversion: stored.pendingReversion,
+            pendingReversionReleases: stored.pendingReversionReleases,
+        });
+        const beforeSession = JSON.stringify(stored.session);
+        if (!this.turnReversionProvider
+            && (stored.reversionSegments.some((segment) => segment.captureId)
+                || stored.pendingReversionReleases.length > 0
+                || stored.pendingReversion?.kind === 'capture')) {
+            throw new FlexHarnessValidationError('Capture-backed session recovery requires its turn reversion provider.');
+        }
+        const requiredProtocols = new Set([
+            ...stored.reversionSegments
+                .filter((segment) => segment.captureId !== undefined)
+                .map((segment) => segment.protocolVersion),
+            ...stored.pendingReversionReleases.map((release) => release.protocolVersion),
+            ...(stored.pendingReversion?.kind === 'capture'
+                ? [stored.pendingReversion.protocolVersion]
+                : []),
+        ]);
+        const providerProtocol = this.reversions.reversionProviderProtocolVersion();
+        if (requiredProtocols.size > 0 && (requiredProtocols.size !== 1
+            || !requiredProtocols.has(providerProtocol ?? 0))) {
+            throw new FlexHarnessValidationError(`Capture-backed session recovery requires protocolVersion ${[...requiredProtocols].join(', ')}.`);
+        }
+        if (stored.pendingReversion?.kind === 'capture' && stored.pendingReversionReleases.length > 0) {
+            if (!state || scopeId === undefined || scope === undefined) {
+                throw new FlexHarnessValidationError('Pending capture recovery is missing its scope context.');
+            }
+            await this.reversions.drainReversionReleases(state, stored, scopeId, scope, false);
+            this.assertStateAcceptingWork(state);
+        }
+        const outcomes = this.canonicalOutcomes(stored.agentSession.getEvents());
+        const firstHiddenCandidate = this.reversions.completedReversionCandidates(stored)[stored.revertCursor];
+        const reversionVisibilityBoundary = firstHiddenCandidate
+            ? stored.reversionSegments.findIndex((segment) => segment.runId === firstHiddenCandidate.runId)
+            : stored.reversionSegments.length;
+        const stages = new Map(stored.stagedTerminals.map((terminal) => [terminal.runId, terminal]));
+        const runIds = new Set([
+            ...stored.messages.map((message) => message.runId),
+            ...stored.stagedTerminals.map((terminal) => terminal.runId),
+        ]);
+        let latestTerminal;
+        for (const runId of runIds) {
+            const outcome = outcomes.get(runId);
+            const stage = stages.get(runId);
+            if (outcome === 'accepted' && stage?.status === 'completed') {
+                this.runs.replaceVisibleRun(stored, stage);
+                latestTerminal = stage;
+            }
+            else if (outcome !== 'accepted') {
+                const visible = stored.messages.filter((message) => message.runId === runId);
+                if (visible.length > 0 || stage) {
+                    const status = outcome === 'rejected' ? 'failed' : 'cancelled';
+                    const terminal = this.repairTerminal(stored.session.sessionId, runId, visible, stage, status);
+                    this.runs.replaceVisibleRun(stored, terminal);
+                    latestTerminal = terminal;
+                }
+            }
+            else {
+                const visibleSuccess = stored.messages.some((message) => message.runId === runId && message.status === 'completed');
+                if (visibleSuccess) {
+                    latestTerminal = this.repairTerminal(stored.session.sessionId, runId, stored.messages.filter((message) => message.runId === runId), undefined, 'completed');
+                }
+            }
+        }
+        stored.stagedTerminals = stored.stagedTerminals.filter((terminal) => !outcomes.has(terminal.runId));
+        if (stored.stagedTerminals.length > 0)
+            stored.stagedTerminals = [];
+        const activeEvents = stored.agentSession.getEvents();
+        const activeEventIds = new Set(activeEvents.map((event) => event.id));
+        for (let index = 0; index < stored.reversionSegments.length; index++) {
+            const segment = stored.reversionSegments[index];
+            if (segment.eventIds.length > 0 && !segment.eventIds.some((id) => activeEventIds.has(id))) {
+                segment.contextAvailable = false;
+            }
+            if (segment.status !== 'capturing') {
+                const outcome = outcomes.get(segment.runId);
+                if (outcome === 'accepted')
+                    segment.status = 'completed';
+                else if (outcome === 'rejected')
+                    segment.status = 'failed';
+                else if (outcome === 'interrupted' || segment.contextAvailable)
+                    segment.status = 'cancelled';
+            }
+        }
+        stored.revertCursor = stored.reversionSegments
+            .slice(0, reversionVisibilityBoundary)
+            .filter((segment) => segment.status === 'completed')
+            .length;
+        this.reversions.commitArchivedHiddenBranchState(stored);
+        this.reversions.pruneReversionState(stored, false, true);
+        if (stored.pendingReversion?.kind === 'apply') {
+            if (!state || scopeId === undefined || scope === undefined) {
+                throw new FlexHarnessValidationError('Pending reversion recovery is missing its scope context.');
+            }
+            await this.reversions.resumePendingApply(state, stored, scopeId, scope);
+        }
+        else if (stored.pendingReversion?.kind === 'capture') {
+            if (!this.turnReversionProvider || !state || scopeId === undefined || scope === undefined) {
+                throw new FlexHarnessValidationError('Pending capture recovery requires its reversion provider.');
+            }
+            await this.reversions.recoverPendingCapture(state, stored, scopeId, scope, outcomes);
+        }
+        if (latestTerminal) {
+            const completedAt = latestTerminal.assistantMessage.completedAt ?? new Date().toISOString();
+            stored.session.status = latestTerminal.status === 'completed' ? 'idle' : latestTerminal.status;
+            stored.session.activity = {
+                runId: latestTerminal.runId,
+                status: latestTerminal.status === 'completed' ? 'idle' : latestTerminal.status,
+                completedAt,
+                ...terminalActivityError(latestTerminal.assistantMessage),
+            };
+            stored.session.updatedAt = completedAt;
+        }
+        else if (['scheduled', 'running', 'waiting_permission'].includes(stored.session.status)) {
+            const timestamp = new Date().toISOString();
+            stored.session.status = 'cancelled';
+            stored.session.activity = {
+                ...(stored.session.activity.runId ? { runId: stored.session.activity.runId } : {}),
+                status: 'cancelled',
+                completedAt: timestamp,
+                error: repairCancellationMessage,
+            };
+            stored.session.updatedAt = timestamp;
+        }
+        const projectionChanged = beforeProjection !== JSON.stringify({
+            messages: stored.messages,
+            stagedTerminals: stored.stagedTerminals,
+            reversionSegments: stored.reversionSegments,
+            revertCursor: stored.revertCursor,
+            excludedRunIds: stored.excludedRunIds,
+            pendingReversion: stored.pendingReversion,
+            pendingReversionReleases: stored.pendingReversionReleases,
+        });
+        if (projectionChanged) {
+            const expected = stored.projectionRevision;
+            const snapshot = this.createProjectionSnapshot(stored, expected + 1);
+            await this.stores.projections.save(storageKey, stored.session.sessionId, snapshot, expected);
+            stored.projectionSchemaVersion = 3;
+            delete stored.projectionBaseline;
+            stored.projectionReconciliationRequired = false;
+            stored.projectionRevision = snapshot.revision;
+        }
+        return beforeSession !== JSON.stringify(stored.session);
+    }
+    repairTerminal(sessionId, runId, visible, stage, status) {
+        const timestamp = new Date().toISOString();
+        // A steered run projects its prompt first and its steers after it; its last assistant
+        // message is the one that was still answering.
+        const sourceUser = stage?.userMessage
+            ?? visible.find((message) => message.role === 'user' && message.steerId === undefined);
+        const sourceAssistant = stage?.assistantMessage
+            ?? [...visible].reverse().find((message) => message.role === 'assistant');
+        const userMessage = cloneSerializable(sourceUser ?? {
+            messageId: plugins.crypto.randomUUID(),
+            sessionId,
+            runId,
+            role: 'user',
+            status,
+            createdAt: timestamp,
+            parts: [],
+        });
+        const assistantMessage = cloneSerializable(sourceAssistant ?? {
+            messageId: plugins.crypto.randomUUID(),
+            sessionId,
+            runId,
+            role: 'assistant',
+            status,
+            createdAt: timestamp,
+            parts: [],
+        });
+        userMessage.status = status;
+        assistantMessage.status = status;
+        userMessage.completedAt ??= timestamp;
+        assistantMessage.completedAt ??= timestamp;
+        for (const part of assistantMessage.parts) {
+            if (part.type === 'reasoning' && part.status === 'running') {
+                part.status = status === 'completed' ? 'completed' : 'cancelled';
+                part.completedAt = assistantMessage.completedAt;
+            }
+            if (part.type === 'tool' && part.status === 'running') {
+                part.status = status === 'cancelled' ? 'cancelled' : 'failed';
+                part.error = status === 'cancelled' ? repairCancellationMessage : externalErrorFallback.message;
+                part.completedAt = assistantMessage.completedAt;
+            }
+        }
+        if (status !== 'completed') {
+            const message = status === 'cancelled' ? repairCancellationMessage : externalErrorFallback.message;
+            userMessage.error = message;
+            assistantMessage.error = message;
+            if (stage?.usage) {
+                assistantMessage.usage = cloneSerializable(stage.usage);
+            }
+            else {
+                delete assistantMessage.usage;
+            }
+        }
+        return {
+            runId,
+            status,
+            userMessage,
+            assistantMessage,
+            ...(status === 'completed' && stage?.model ? { model: stage.model } : {}),
+            ...(stage?.usage ? { usage: stage.usage } : {}),
+            ...(status === 'completed' && stage?.finishReason ? { finishReason: stage.finishReason } : {}),
+            ...(status === 'completed' && stage?.steps !== undefined ? { steps: stage.steps } : {}),
+        };
+    }
+    withScopeMutationOwnership(state, operation) {
+        const owned = state.scopeQueue.then(async () => {
+            this.assertStateAcceptingWork(state);
+            return operation();
+        });
+        state.scopeQueue = owned.then(() => undefined, () => undefined);
+        return owned;
+    }
+    mutateScope(state, mutation, allowDuringDrain = false) {
+        const operation = state.scopeQueue.then(() => {
+            if (!allowDuringDrain)
+                this.assertStateAcceptingWork(state);
+            return this.mutateScopeOwned(state, mutation);
+        });
+        state.scopeQueue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async mutateScopeOwned(state, mutation) {
+        const beforeRevision = state.revision;
+        const beforeSessions = new Map([...state.sessions].map(([id, stored]) => [id, {
+                stored,
+                metadata: cloneSerializable(stored.session),
+            }]));
+        const beforeTombstones = new Map([...state.tombstones].map(([id, value]) => [id, cloneSerializable(value)]));
+        const beforeRetainedCleanups = new Map(state.retainedSessionCleanups);
+        const beforeSnapshot = {
+            schemaVersion: 1,
+            revision: beforeRevision,
+            sessions: [...beforeSessions.values()]
+                .map((entry) => cloneSerializable(entry.metadata))
+                .sort((left, right) => left.sessionId.localeCompare(right.sessionId)),
+            tombstones: [...beforeTombstones.values()]
+                .map((value) => cloneSerializable(value))
+                .sort((left, right) => left.sessionId.localeCompare(right.sessionId)),
+        };
+        const restore = () => {
+            state.revision = beforeRevision;
+            state.sessions.clear();
+            for (const [id, entry] of beforeSessions) {
+                entry.stored.session = entry.metadata;
+                state.sessions.set(id, entry.stored);
+            }
+            state.tombstones.clear();
+            for (const [id, value] of beforeTombstones)
+                state.tombstones.set(id, value);
+            state.retainedSessionCleanups.clear();
+            for (const [id, retained] of beforeRetainedCleanups) {
+                state.retainedSessionCleanups.set(id, retained);
+            }
+        };
+        let result;
+        try {
+            result = mutation();
+        }
+        catch (error) {
+            restore();
+            throw error;
+        }
+        const snapshot = this.createScopeSnapshot(state, beforeRevision + 1);
+        try {
+            await this.stores.scopes.save(state.storageKey, snapshot, beforeRevision);
+            state.revision = snapshot.revision;
+            return result;
+        }
+        catch (error) {
+            if (error instanceof FlexHarnessStoreConflictError) {
+                restore();
+                throw error;
+            }
+            if (error instanceof FlexHarnessStoreCommitUncertainError) {
+                state.revision = snapshot.revision;
+                state.lifecycle = 'fenced';
+                throw error;
+            }
+            let current;
+            let reconciliationError;
+            try {
+                current = await this.stores.scopes.load(state.storageKey);
+            }
+            catch (loadError) {
+                reconciliationError = loadError;
+            }
+            if (current && JSON.stringify(current) === JSON.stringify(snapshot)) {
+                state.revision = snapshot.revision;
+                throw error;
+            }
+            if ((current === undefined && beforeRevision === 0)
+                || (current !== undefined && JSON.stringify(current) === JSON.stringify(beforeSnapshot))) {
+                restore();
+                throw error;
+            }
+            state.revision = snapshot.revision;
+            state.lifecycle = 'fenced';
+            throw reconciliationError === undefined
+                ? error
+                : combineErrors([error, reconciliationError]);
+        }
+    }
+    mutateProjection(state, stored, mutation, _allowDuringDrain = false) {
+        const operation = stored.projectionQueue.then(async () => {
+            const beforeRevision = stored.projectionRevision;
+            const beforeSchemaVersion = stored.projectionSchemaVersion;
+            const beforeReconciliationRequired = stored.projectionReconciliationRequired;
+            const beforeBaseline = stored.projectionBaseline === undefined
+                ? undefined
+                : cloneSerializable(stored.projectionBaseline);
+            const beforeMetrics = cloneSerializable(stored.metrics);
+            const beforeMessages = cloneSerializable(stored.messages);
+            const beforeStages = cloneSerializable(stored.stagedTerminals);
+            const beforeSegments = cloneSerializable(stored.reversionSegments);
+            const beforeCursor = stored.revertCursor;
+            const beforeExcludedRunIds = cloneSerializable(stored.excludedRunIds);
+            const beforePendingReversion = stored.pendingReversion === undefined
+                ? undefined
+                : cloneSerializable(stored.pendingReversion);
+            const beforePendingReversionReleases = cloneSerializable(stored.pendingReversionReleases);
+            const beforeSnapshot = beforeBaseline ?? {
+                schemaVersion: 3,
+                revision: beforeRevision,
+                metrics: cloneSerializable(beforeMetrics),
+                messages: cloneSerializable(beforeMessages),
+                stagedTerminals: cloneSerializable(beforeStages),
+                reversionSegments: cloneSerializable(beforeSegments),
+                revertCursor: beforeCursor,
+                excludedRunIds: cloneSerializable(beforeExcludedRunIds),
+                ...(beforePendingReversion === undefined
+                    ? {}
+                    : { pendingReversion: cloneSerializable(beforePendingReversion) }),
+                pendingReversionReleases: cloneSerializable(beforePendingReversionReleases),
+            };
+            const restore = () => {
+                stored.projectionSchemaVersion = beforeSchemaVersion;
+                stored.projectionReconciliationRequired = beforeReconciliationRequired;
+                if (beforeBaseline === undefined)
+                    delete stored.projectionBaseline;
+                else
+                    stored.projectionBaseline = beforeBaseline;
+                stored.projectionRevision = beforeRevision;
+                stored.metrics = beforeMetrics;
+                stored.messages = beforeMessages;
+                stored.stagedTerminals = beforeStages;
+                stored.reversionSegments = beforeSegments;
+                stored.revertCursor = beforeCursor;
+                stored.excludedRunIds = beforeExcludedRunIds;
+                if (beforePendingReversion === undefined)
+                    delete stored.pendingReversion;
+                else
+                    stored.pendingReversion = beforePendingReversion;
+                stored.pendingReversionReleases = beforePendingReversionReleases;
+            };
+            let result;
+            try {
+                result = mutation();
+            }
+            catch (error) {
+                restore();
+                throw error;
+            }
+            const snapshot = this.createProjectionSnapshot(stored, beforeRevision + 1);
+            try {
+                await this.stores.projections.save(state.storageKey, stored.session.sessionId, snapshot, beforeRevision);
+                stored.projectionSchemaVersion = 3;
+                delete stored.projectionBaseline;
+                stored.projectionReconciliationRequired = false;
+                stored.projectionRevision = snapshot.revision;
+                return result;
+            }
+            catch (error) {
+                if (error instanceof FlexHarnessStoreConflictError) {
+                    restore();
+                    throw error;
+                }
+                if (error instanceof FlexHarnessStoreCommitUncertainError) {
+                    stored.projectionSchemaVersion = 3;
+                    stored.projectionReconciliationRequired = true;
+                    stored.projectionRevision = snapshot.revision;
+                    state.lifecycle = 'fenced';
+                    throw error;
+                }
+                let current;
+                let reconciliationError;
+                try {
+                    current = await this.stores.projections.load(state.storageKey, stored.session.sessionId);
+                }
+                catch (loadError) {
+                    reconciliationError = loadError;
+                }
+                if (current && JSON.stringify(current) === JSON.stringify(snapshot)) {
+                    stored.projectionSchemaVersion = 3;
+                    delete stored.projectionBaseline;
+                    stored.projectionReconciliationRequired = false;
+                    stored.projectionRevision = snapshot.revision;
+                    throw error;
+                }
+                if ((current === undefined && beforeRevision === 0)
+                    || (current !== undefined && JSON.stringify(current) === JSON.stringify(beforeSnapshot))) {
+                    restore();
+                    throw error;
+                }
+                stored.projectionSchemaVersion = 3;
+                stored.projectionReconciliationRequired = true;
+                stored.projectionRevision = snapshot.revision;
+                state.lifecycle = 'fenced';
+                throw reconciliationError === undefined
+                    ? error
+                    : combineErrors([error, reconciliationError]);
+            }
+        });
+        stored.projectionQueue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    createScopeSnapshot(state, revision) {
+        return {
+            schemaVersion: 1,
+            revision,
+            sessions: [...state.sessions.values()]
+                .map((stored) => cloneSerializable(stored.session))
+                .sort((left, right) => left.sessionId.localeCompare(right.sessionId)),
+            tombstones: [...state.tombstones.values()]
+                .map((value) => cloneSerializable(value))
+                .sort((left, right) => left.sessionId.localeCompare(right.sessionId)),
+        };
+    }
+    createProjectionSnapshot(stored, revision) {
+        return {
+            schemaVersion: 3,
+            revision,
+            metrics: cloneSerializable(stored.metrics),
+            messages: cloneSerializable(stored.messages),
+            stagedTerminals: cloneSerializable(stored.stagedTerminals),
+            reversionSegments: cloneSerializable(stored.reversionSegments),
+            revertCursor: stored.revertCursor,
+            excludedRunIds: cloneSerializable(stored.excludedRunIds),
+            ...(stored.pendingReversion === undefined
+                ? {}
+                : { pendingReversion: cloneSerializable(stored.pendingReversion) }),
+            pendingReversionReleases: cloneSerializable(stored.pendingReversionReleases),
+        };
+    }
+    upgradeProjectionSnapshot(projection) {
+        if (projection.schemaVersion === 3)
+            return cloneSerializable(projection);
+        if (projection.schemaVersion === 1) {
+            return {
+                schemaVersion: 3,
+                revision: projection.revision,
+                messages: cloneSerializable(projection.messages),
+                stagedTerminals: cloneSerializable(projection.stagedTerminals),
+                reversionSegments: [],
+                revertCursor: 0,
+                excludedRunIds: [],
+                pendingReversionReleases: [],
+            };
+        }
+        return {
+            schemaVersion: 3,
+            revision: projection.revision,
+            messages: cloneSerializable(projection.messages),
+            stagedTerminals: cloneSerializable(projection.stagedTerminals),
+            reversionSegments: projection.reversionSegments.map((segment) => ({
+                ...cloneSerializable(segment),
+                protocolVersion: 1,
+                provenance: segment.workspaceCaptured ? 'workspace' : 'transcript',
+                ...(segment.workspaceCaptured
+                    ? { disposition: segment.status === 'capturing' ? 'pending' : 'revertible' }
+                    : {}),
+            })),
+            revertCursor: projection.revertCursor,
+            excludedRunIds: cloneSerializable(projection.excludedRunIds),
+            ...(projection.pendingReversion === undefined
+                ? {}
+                : {
+                    pendingReversion: projection.pendingReversion.kind === 'capture'
+                        ? { ...cloneSerializable(projection.pendingReversion), protocolVersion: 1 }
+                        : cloneSerializable(projection.pendingReversion),
+                }),
+            pendingReversionReleases: projection.pendingReversionReleases.map((release) => ({
+                ...cloneSerializable(release),
+                protocolVersion: 1,
+            })),
+        };
+    }
+    async reconcileProjectionFromStore(stored) {
+        if (!stored.projectionReconciliationRequired)
+            return;
+        const projection = await this.stores.projections.load(stored.storageKey, stored.session.sessionId);
+        if (!projection) {
+            throw new FlexHarnessValidationError('Uncertain projection persistence could not be reloaded.');
+        }
+        const current = this.upgradeProjectionSnapshot(projection);
+        stored.messages = current.messages;
+        stored.stagedTerminals = current.stagedTerminals;
+        stored.reversionSegments = current.reversionSegments;
+        stored.revertCursor = current.revertCursor;
+        stored.excludedRunIds = current.excludedRunIds;
+        if (current.pendingReversion === undefined)
+            delete stored.pendingReversion;
+        else
+            stored.pendingReversion = current.pendingReversion;
+        stored.pendingReversionReleases = current.pendingReversionReleases;
+        if (projection.schemaVersion === 3)
+            delete stored.projectionBaseline;
+        else
+            stored.projectionBaseline = cloneSerializable(projection);
+        stored.projectionSchemaVersion = projection.schemaVersion;
+        stored.projectionRevision = projection.revision;
+        stored.projectionReconciliationRequired = false;
+    }
+    sessionsAreDependencyRelated(state, leftSessionId, rightSessionId) {
+        return this.isSessionAncestor(state, leftSessionId, rightSessionId)
+            || this.isSessionAncestor(state, rightSessionId, leftSessionId);
+    }
+    isSessionAncestor(state, ancestorSessionId, descendantSessionId) {
+        const visited = new Set();
+        let currentId = descendantSessionId;
+        while (currentId) {
+            if (visited.has(currentId))
+                return false;
+            visited.add(currentId);
+            const parentSessionId = this.sessionParentSessionId(state, currentId);
+            if (parentSessionId === ancestorSessionId)
+                return true;
+            currentId = parentSessionId;
+        }
+        return false;
+    }
+    sessionAncestryDepth(state, sessionId) {
+        const visited = new Set();
+        let currentId = sessionId;
+        let depth = 0;
+        while (currentId) {
+            if (visited.has(currentId))
+                return depth;
+            visited.add(currentId);
+            const parentSessionId = this.sessionParentSessionId(state, currentId);
+            if (!parentSessionId)
+                return depth;
+            depth++;
+            currentId = parentSessionId;
+        }
+        return depth;
+    }
+    sessionParentSessionId(state, sessionId) {
+        return this.sessionMetadata(state, sessionId)?.parentSessionId
+            ?? state.tombstones.get(sessionId)?.parentSessionId;
+    }
+    sessionMetadata(state, sessionId) {
+        return state.sessions.get(sessionId)?.session
+            ?? state.retainedSessionCleanups.get(sessionId)?.stored.session;
+    }
+    appendUnexpectedErrors(target, error) {
+        if (error instanceof FlexHarnessRunError) {
+            for (const nested of error.errors)
+                this.appendUnexpectedErrors(target, nested);
+        }
+        else if (!isAbortError(error))
+            target.push(error);
+    }
+    async resolveState(scopeId) {
+        this.assertOpen();
+        validateIdentifier(scopeId, 'scopeId');
+        const admission = this.getScopeAdmission(scopeId);
+        if (admission.retiring)
+            throw this.createScopeRetirementError();
+        const generation = admission.generation;
+        admission.inFlightResolvers++;
+        try {
+            const scope = await this.scopeResolver.resolveScope(scopeId);
+            this.assertOpen();
+            if (admission.retiring || admission.generation !== generation)
+                throw this.createScopeRetirementError();
+            validateIdentifier(scope.storageKey, 'resolved storageKey');
+            if (this.lifecycle.storageDrains.has(scope.storageKey))
+                throw this.createScopeRetirementError();
+            let stateLoad = this.stateLoads.get(scope.storageKey);
+            if (!stateLoad) {
+                const orphanErrors = await this.lifecycle.closeOrphanedResources(scope.storageKey);
+                if (orphanErrors.length > 0)
+                    throw combineErrors(orphanErrors);
+                this.assertOpen();
+                if (admission.retiring
+                    || admission.generation !== generation
+                    || this.lifecycle.storageDrains.has(scope.storageKey))
+                    throw this.createScopeRetirementError();
+                stateLoad = this.stateLoads.get(scope.storageKey);
+                if (!stateLoad) {
+                    const compactorLifecycleController = new AbortController();
+                    this.lifecycle.storageCompactorLifecycleControllers.set(scope.storageKey, compactorLifecycleController);
+                    stateLoad = this.loadState(scope.storageKey, scopeId, scope.scope, compactorLifecycleController);
+                    this.stateLoads.set(scope.storageKey, stateLoad);
+                    void stateLoad.catch(() => {
+                        if (this.stateLoads.get(scope.storageKey) === stateLoad) {
+                            this.stateLoads.delete(scope.storageKey);
+                            if (this.lifecycle.storageCompactorLifecycleControllers.get(scope.storageKey)
+                                === compactorLifecycleController)
+                                this.lifecycle.storageCompactorLifecycleControllers.delete(scope.storageKey);
+                        }
+                    });
+                }
+            }
+            const state = await stateLoad;
+            this.assertOpen();
+            if (state.lifecycle === 'fenced') {
+                const drain = this.lifecycle.storageDrains.get(scope.storageKey) ?? this.lifecycle.drainStorage(scope.storageKey, stateLoad, this.trustInternalError(new FlexHarnessAbortError('The session namespace was fenced.')), { scopeId, scope: scope.scope });
+                if (this.commands.ambientSlashCommandOwner({ storageKey: scope.storageKey })) {
+                    throw this.createScopeRetirementError();
+                }
+                try {
+                    await drain;
+                }
+                catch {
+                    // Fenced cleanup ownership remains available to explicit retirement or disposal.
+                }
+                throw this.createScopeRetirementError();
+            }
+            if (admission.retiring
+                || admission.generation !== generation
+                || this.lifecycle.storageDrains.has(scope.storageKey)
+                || state.lifecycle !== 'active')
+                throw this.createScopeRetirementError();
+            return { scope, state };
+        }
+        finally {
+            admission.inFlightResolvers--;
+            this.pruneScopeAdmission(scopeId, admission);
+        }
+    }
+    getScopeAdmission(scopeId) {
+        let admission = this.scopeAdmissions.get(scopeId);
+        if (!admission) {
+            admission = { generation: 0, inFlightResolvers: 0, retiring: false };
+            this.scopeAdmissions.set(scopeId, admission);
+        }
+        return admission;
+    }
+    pruneScopeAdmission(scopeId, admission) {
+        if (!admission.retiring
+            && admission.inFlightResolvers === 0
+            && this.scopeAdmissions.get(scopeId) === admission)
+            this.scopeAdmissions.delete(scopeId);
+    }
+    createScopeRetirementError() {
+        return this.trustInternalError(new FlexHarnessAbortError(scopeRetirementMessage));
+    }
+    assertStateAcceptingWork(state) {
+        if (state.lifecycle !== 'active' || this.lifecycle.storageDrains.has(state.storageKey)) {
+            throw this.createScopeRetirementError();
+        }
+    }
+    requireSession(state, sessionId) {
+        validateIdentifier(sessionId, 'sessionId');
+        requireTransferIdentifier(sessionId, 'sessionId');
+        if (state.tombstones.has(sessionId))
+            throw new FlexHarnessNotFoundError('Session', sessionId);
+        if (state.initializingSessions.has(sessionId)) {
+            throw new FlexHarnessSessionBusyError(sessionId, 'is still being initialized');
+        }
+        const stored = state.sessions.get(sessionId);
+        if (!stored)
+            throw new FlexHarnessNotFoundError('Session', sessionId);
+        return stored;
+    }
+    visibleMessages(stored) {
+        const firstHiddenSegment = this.reversions.reversionGroups(stored)[stored.revertCursor]?.segments[0];
+        if (!firstHiddenSegment)
+            return stored.messages;
+        const boundary = stored.messages.findIndex((message) => message.runId === firstHiddenSegment.runId);
+        return boundary < 0 ? stored.messages : stored.messages.slice(0, boundary);
+    }
+    requireMutableSession(state, sessionId) {
+        const stored = this.requireSession(state, sessionId);
+        const pending = [...state.pendingPermissions.values()].some((entry) => !entry.settled && entry.request.sessionId === sessionId);
+        if (stored.outstandingPromptsById.size > 0 || pending) {
+            throw new FlexHarnessSessionBusyError(sessionId, 'cannot be changed while it has an outstanding prompt or pending permission');
+        }
+        return stored;
+    }
+    /** Refuses an operation that would change an imported session's history or model context. */
+    assertSessionWritable(stored) {
+        if (stored.session.origin !== undefined) {
+            throw this.trustInternalError(new FlexHarnessImportedSessionError(stored.session.sessionId));
+        }
+    }
+    /** An imported session never ran here, so it has no hidden stage and no reversion state. */
+    assertImportedSessionState(stored) {
+        if (stored.stagedTerminals.length > 0
+            || stored.reversionSegments.length > 0
+            || stored.excludedRunIds.length > 0
+            || stored.pendingReversion !== undefined
+            || stored.pendingReversionReleases.length > 0
+            || stored.messages.some((message) => message.status === 'streaming')) {
+            throw new FlexHarnessValidationError(`Imported session "${stored.session.sessionId}" has run state it cannot have.`);
+        }
+    }
+    requireMessage(stored, messageId) {
+        const message = this.visibleMessages(stored).find((entry) => entry.messageId === messageId);
+        if (!message)
+            throw new FlexHarnessNotFoundError('Message', messageId);
+        return message;
+    }
+    isTombstoned(run) {
+        return run.state.tombstones.has(run.sessionId) || run.state.sessions.get(run.sessionId) !== run.stored;
+    }
+    emitPartEvent(run, type, part) {
+        const { messageIndex, partIndex } = this.partEventCoordinates(run, part.partId);
+        this.emitEvent(run.scopeId, run.stored.session, {
+            type,
+            runId: run.runId,
+            messageId: run.assistantMessageId,
+            messageIndex,
+            partId: part.partId,
+            partIndex,
+            part: publicSnapshot(part),
+        });
+    }
+    emitPartDeltaEvent(run, part, delta, accounting) {
+        const { messageIndex, partIndex } = this.partEventCoordinates(run, part.partId);
+        this.emitEvent(run.scopeId, run.stored.session, {
+            type: 'part.delta',
+            runId: run.runId,
+            messageId: run.assistantMessageId,
+            messageIndex,
+            partId: part.partId,
+            partIndex,
+            partType: part.type,
+            delta,
+            ...accounting,
+        });
+    }
+    partEventCoordinates(run, partId) {
+        const messageIndex = run.stored.messages.findIndex((message) => message.messageId === run.assistantMessageId);
+        const partIndex = run.callbackParts.findIndex((entry) => entry.partId === partId);
+        if (messageIndex < 0
+            || run.stored.messages[messageIndex]?.messageId !== run.assistantMessageId
+            || partIndex < 0
+            || run.callbackParts[partIndex]?.partId !== partId)
+            throw new Error('Flex part event source coordinates are unavailable.');
+        return { messageIndex, partIndex };
+    }
+    emitEvent(scopeId, sourceSession, details) {
+        const generation = requireSessionGeneration(sourceSession);
+        const event = deepFreeze(cloneSerializable({
+            eventId: plugins.crypto.randomUUID(),
+            sequence: ++this.sequence,
+            timestamp: new Date().toISOString(),
+            scopeId,
+            ...details,
+            sessionId: sourceSession.sessionId,
+            ...generation,
+        }));
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Public listener failures are isolated from persistence and run ownership.
+            }
+        }
+    }
+    validateRuntimeEvent(event) {
+        try {
+            assertJsonSerializable(event, '$event');
+        }
+        catch {
+            throw new FlexHarnessValidationError('Runtime event must be JSON-serializable.');
+        }
+        if (!event || typeof event !== 'object' || Array.isArray(event)) {
+            throw new FlexHarnessValidationError('Runtime event must be a plain JSON object.');
+        }
+        validateIdentifier(event.type, 'runtime event type');
+        if (jsonBytes(event) > this.toolOutputLimits.maxBytes) {
+            throw new FlexHarnessValidationError('Runtime event exceeds the byte limit.');
+        }
+        const visit = (value, depth) => {
+            if (!value || typeof value !== 'object')
+                return;
+            if (depth > this.toolOutputLimits.maxDepth) {
+                throw new FlexHarnessValidationError('Runtime event exceeds the depth limit.');
+            }
+            for (const entry of Array.isArray(value) ? value : Object.values(value))
+                visit(entry, depth + 1);
+        };
+        visit(event, 0);
+    }
+    boundedIdentifier(value, name) {
+        validateIdentifier(value, name);
+        requireTransferIdentifier(value, name);
+        return value;
+    }
+    messageCursorNamespace(storageKey) {
+        return plugins.crypto.createHash('sha256').update(storageKey).digest('base64url');
+    }
+    createMessageCursor(namespace, sessionId, anchorMessageId) {
+        const cursor = Buffer.from(JSON.stringify({
+            version: 1,
+            namespace,
+            sessionId,
+            anchorMessageId,
+        })).toString('base64url');
+        if (Buffer.byteLength(cursor, 'utf8') > maxMessagePageCursorBytes) {
+            throw new FlexHarnessValidationError('Message page cursor exceeds its transfer limit.');
+        }
+        return cursor;
+    }
+    parseMessageCursor(cursor) {
+        let parsed;
+        try {
+            const decoded = Buffer.from(cursor, 'base64url');
+            if (decoded.toString('base64url') !== cursor)
+                throw new Error('non-canonical cursor');
+            parsed = JSON.parse(decoded.toString('utf8'));
+        }
+        catch {
+            throw new FlexHarnessValidationError('Message page cursor is invalid.');
+        }
+        if (!parsed
+            || typeof parsed !== 'object'
+            || Array.isArray(parsed)
+            || Object.keys(parsed).length !== 4
+            || parsed.version !== 1
+            || typeof parsed.namespace !== 'string'
+            || typeof parsed.sessionId !== 'string'
+            || typeof parsed.anchorMessageId !== 'string')
+            throw new FlexHarnessValidationError('Message page cursor is invalid.');
+        const result = parsed;
+        if (!result.namespace
+            || !result.sessionId
+            || !result.anchorMessageId
+            || Buffer.byteLength(result.namespace, 'utf8') > 128
+            || Buffer.byteLength(result.sessionId, 'utf8') > maxTransferIdentifierBytes
+            || Buffer.byteLength(result.anchorMessageId, 'utf8') > maxTransferIdentifierBytes)
+            throw new FlexHarnessValidationError('Message page cursor is invalid.');
+        return result;
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new FlexHarnessClosedError();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.core.js","sourceRoot":"","sources":["../ts/classes.flexharness.core.ts"],"names":[],"mappings":"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"}