@modelprofile.com/flexharness 10.24.0 → 10.24.1

package/dist_ts/classes.flexharness.reversions.js

@@ -0,0 +1,1306 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessSessionBusyError, FlexHarnessSlashCommandReentryError, FlexHarnessSlashCommandUnavailableError, FlexHarnessValidationError, } from './errors.js';
+import { FLEX_REVERSION_MAX_AFFECTED_WORKSPACES, FLEX_REVERSION_REASON_CODE_MAX_BYTES, FLEX_REVERSION_REFERENCE_MAX_BYTES, FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES, FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES, } from './interfaces.js';
+import { cloneSerializable, normalizeJsonValue } from './utils.json.js';
+import { publicSnapshot } from './utils.transfer.js';
+import { slashCommandSessionUnavailableReason, requireSessionGeneration, sha256Hex, combineErrors, } from './utils.flexharness.js';
+/** Turn reversion: capture, undo and redo, and the release of reversion state. */
+export class FlexHarnessReversions {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    async getSessionReversionInfo(scopeId, sessionId) {
+        const { state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        await stored.projectionQueue;
+        this.core.assertStateAcceptingWork(state);
+        await this.reconcileContextAvailability(state, stored);
+        const unavailableReason = await this.reversionUnavailableReason(state, stored);
+        const groups = this.reversionGroups(stored);
+        const undo = this.reversionUnit(stored, 'undo');
+        const redo = this.reversionUnit(stored, 'redo');
+        const isAvailable = (unit) => Boolean(!unavailableReason
+            && unit
+            && unit.target.contextAvailable
+            && !unit.segments.some((segment) => segment.provenance === 'workspace'
+                && segment.disposition === 'revertible'
+                && segment.workspaceReference === undefined));
+        return publicSnapshot({
+            undoAvailable: isAvailable(undo),
+            redoAvailable: isAvailable(redo),
+            groups: groups.map((group, index) => ({
+                runId: group.target.runId,
+                kind: group.kind,
+                visibility: index < stored.revertCursor ? 'visible' : 'hidden',
+                affectedWorkspaces: cloneSerializable(group.affectedWorkspaces),
+                affectedWorkspacesTruncated: group.affectedWorkspacesTruncated,
+            })),
+        });
+    }
+    async undoSession(scopeId, sessionId, signal) {
+        const result = await this.changeReversionCursor(scopeId, sessionId, 'undo', signal);
+        return Object.freeze({ revertedRunId: result });
+    }
+    async redoSession(scopeId, sessionId, signal) {
+        const result = await this.changeReversionCursor(scopeId, sessionId, 'redo', signal);
+        return Object.freeze({ restoredRunId: result });
+    }
+    reversionUnit(stored, direction) {
+        const groups = this.reversionGroups(stored);
+        if (direction === 'undo') {
+            let start = stored.revertCursor - 1;
+            while (start >= 0 && groups[start]?.kind === 'no-change')
+                start--;
+            const candidate = groups[start];
+            if (!candidate || candidate.kind !== 'candidate')
+                return undefined;
+            return {
+                target: candidate.target,
+                segments: groups.slice(start, stored.revertCursor).flatMap((group) => group.segments),
+                toCursor: start,
+            };
+        }
+        const candidate = groups[stored.revertCursor];
+        if (!candidate || candidate.kind !== 'candidate')
+            return undefined;
+        let end = stored.revertCursor + 1;
+        while (groups[end]?.kind === 'no-change')
+            end++;
+        return {
+            target: candidate.target,
+            segments: groups.slice(stored.revertCursor, end).flatMap((group) => group.segments),
+            toCursor: end,
+        };
+    }
+    reversionGroups(stored) {
+        const groups = [];
+        let leading = [];
+        for (const segment of stored.reversionSegments) {
+            if (segment.status === 'completed') {
+                const segments = groups.length === 0 ? [...leading, segment] : [segment];
+                leading = [];
+                groups.push({
+                    target: segment,
+                    segments,
+                    kind: 'candidate',
+                    affectedWorkspaces: [],
+                    affectedWorkspacesTruncated: false,
+                });
+            }
+            else if (groups.length > 0) {
+                groups[groups.length - 1].segments.push(segment);
+            }
+            else {
+                leading.push(segment);
+            }
+        }
+        for (const group of groups) {
+            const affected = new Map();
+            for (const workspace of group.segments.flatMap((segment) => segment.affectedWorkspaces ?? [])) {
+                if (affected.has(workspace.id))
+                    continue;
+                if (affected.size < FLEX_REVERSION_MAX_AFFECTED_WORKSPACES) {
+                    affected.set(workspace.id, cloneSerializable(workspace));
+                }
+                else {
+                    group.affectedWorkspacesTruncated = true;
+                }
+            }
+            group.affectedWorkspaces = [...affected.values()];
+            if (this.core.reversionPolicy === 'transcript-optional')
+                continue;
+            if (group.segments.some((segment) => segment.status === 'capturing'
+                || segment.disposition === 'pending'
+                || (segment.protocolVersion === 1 && segment.provenance === 'transcript')
+                || segment.disposition === 'nonrevertible')) {
+                group.kind = 'barrier';
+            }
+            else if (group.segments.some((segment) => segment.disposition === 'revertible')) {
+                group.kind = 'candidate';
+            }
+            else {
+                group.kind = 'no-change';
+            }
+        }
+        return groups;
+    }
+    async requireReversionIdle(state, stored, sessionId, allowPendingApply = false, operationSignal) {
+        const reason = await this.reversionUnavailableReason(state, stored, allowPendingApply, operationSignal);
+        if (reason)
+            throw new FlexHarnessSessionBusyError(sessionId, reason.toLowerCase().replace(/\.$/u, ''));
+    }
+    async reversionUnavailableReason(state, stored, allowPendingApply = false, operationSignal) {
+        if (stored.pendingReversion && !(allowPendingApply && stored.pendingReversion.kind === 'apply')) {
+            return 'Session has a pending reversion operation.';
+        }
+        if (!this.core.prompts.isSessionRuntimeIdle(state, stored)) {
+            return slashCommandSessionUnavailableReason;
+        }
+        const activeOperation = this.core.commands.activeSlashCommandExecutions.get(this.core.commands.slashCommandSessionKey(state.storageKey, stored.session.sessionId));
+        if (activeOperation && activeOperation.controller.signal !== operationSignal) {
+            return 'Session already has an active slash command execution.';
+        }
+        if ([...state.pendingPermissions.values()].some((pending) => !pending.settled && pending.request.sessionId === stored.session.sessionId)) {
+            return 'Session has a pending permission.';
+        }
+        if (stored.agentSession.listUncertainToolExecutions().length > 0) {
+            return 'Session has uncertain tool executions.';
+        }
+        if (stored.jobs) {
+            operationSignal?.throwIfAborted();
+            const jobs = Promise.resolve().then(() => stored.jobs.list());
+            if ((await this.awaitReversionOperation(jobs, operationSignal))
+                .some((job) => job.state === 'running')) {
+                return 'Session has running background jobs.';
+            }
+        }
+        return undefined;
+    }
+    async awaitReversionOperation(operation, signal) {
+        if (!signal)
+            return operation;
+        void operation.catch(() => undefined);
+        let rejectForAbort;
+        const aborted = new Promise((_resolve, reject) => {
+            rejectForAbort = () => reject(signal.reason ?? this.core.trustInternalError(new FlexHarnessAbortError('The slash command was aborted.')));
+            signal.addEventListener('abort', rejectForAbort, { once: true });
+            if (signal.aborted)
+                rejectForAbort();
+        });
+        try {
+            return await Promise.race([operation, aborted]);
+        }
+        finally {
+            signal.removeEventListener('abort', rejectForAbort);
+        }
+    }
+    async changeReversionCursor(scopeId, sessionId, direction, signal) {
+        const { scope, state } = await this.core.resolveState(scopeId);
+        return this.changeReversionCursorResolved(scopeId, sessionId, direction, scope.scope, state, signal);
+    }
+    async changeReversionCursorResolved(scopeId, sessionId, direction, scope, state, signal) {
+        const stored = this.core.requireSession(state, sessionId);
+        this.core.assertSessionWritable(stored);
+        this.core.assertStateAcceptingWork(state);
+        const invocationOwner = this.core.commands.slashCommandInvocationContext.getStore();
+        if (invocationOwner?.sessionKey === this.core.commands.slashCommandSessionKey(state.storageKey, sessionId)) {
+            throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+        }
+        return this.core.commands.trackSlashCommandExecution(scopeId, state, sessionId, 'operation', signal, async (operationSignal) => {
+            await stored.projectionQueue;
+            const resumable = stored.pendingReversion?.kind === 'apply'
+                && stored.pendingReversion.direction === direction;
+            await this.requireReversionIdle(state, stored, sessionId, resumable, operationSignal);
+            await this.reconcileContextAvailability(state, stored);
+            operationSignal.throwIfAborted();
+            const pending = stored.pendingReversion;
+            if (pending?.kind === 'apply') {
+                if (pending.direction !== direction) {
+                    throw new FlexHarnessSessionBusyError(sessionId, 'has a pending opposite reversion operation');
+                }
+                const target = pending.segmentRunIds
+                    .map((runId) => stored.reversionSegments.find((segment) => segment.runId === runId))
+                    .find((segment) => segment?.status === 'completed');
+                if (!target)
+                    throw new FlexHarnessValidationError('Pending reversion has no target candidate.');
+                const closePublication = this.core.openPublication(state, sessionId);
+                try {
+                    await this.resumePendingApply(state, stored, scopeId, scope, operationSignal);
+                    this.core.emitEvent(scopeId, stored.session, {
+                        type: 'session.history.changed',
+                        direction,
+                        runId: target.runId,
+                    });
+                }
+                finally {
+                    closePublication();
+                }
+                return target.runId;
+            }
+            const unit = this.reversionUnit(stored, direction);
+            if (!unit) {
+                throw new FlexHarnessSlashCommandUnavailableError(direction, direction === 'undo' ? 'No visible turn can be undone.' : 'No hidden turn can be redone.');
+            }
+            if (!unit.target.contextAvailable) {
+                throw new FlexHarnessSlashCommandUnavailableError(direction, 'The turn is beyond the context archive horizon.');
+            }
+            if (this.core.turnReversionProvider && unit.segments.some((segment) => segment.disposition === 'revertible' && segment.workspaceReference === undefined)) {
+                throw new FlexHarnessSlashCommandUnavailableError(direction, 'The turn has no available workspace reversion capture.');
+            }
+            await this.core.mutateProjection(state, stored, () => {
+                // The write-ahead record commits at exactly projectionRevision + 1, so the
+                // revision it replaces makes this apply's ID unique. Retries and recovery
+                // read the persisted ID instead of deriving it again.
+                const operationId = this.reversionId('apply', state.storageKey, sessionId, JSON.stringify([
+                    direction,
+                    stored.revertCursor,
+                    unit.toCursor,
+                    unit.target.runId,
+                    stored.projectionRevision,
+                ]));
+                stored.pendingReversion = {
+                    kind: 'apply',
+                    operationId,
+                    direction,
+                    fromCursor: stored.revertCursor,
+                    toCursor: unit.toCursor,
+                    segmentRunIds: unit.segments.map((segment) => segment.runId),
+                    appliedRunIds: [],
+                };
+            }, true);
+            const closePublication = this.core.openPublication(state, sessionId);
+            try {
+                await this.resumePendingApply(state, stored, scopeId, scope, operationSignal);
+                this.core.emitEvent(scopeId, stored.session, {
+                    type: 'session.history.changed',
+                    direction,
+                    runId: unit.target.runId,
+                });
+            }
+            finally {
+                closePublication();
+            }
+            return unit.target.runId;
+        });
+    }
+    async reconcileContextAvailability(state, stored) {
+        const activeEvents = new Set(stored.agentSession.getEvents().map((event) => event.id));
+        if (!stored.reversionSegments.some((segment) => segment.contextAvailable
+            && segment.eventIds.length > 0
+            && !segment.eventIds.some((eventId) => activeEvents.has(eventId))))
+            return false;
+        let branchCommitted = false;
+        await this.core.mutateProjection(state, stored, () => {
+            for (const segment of stored.reversionSegments) {
+                if (segment.contextAvailable
+                    && segment.eventIds.length > 0
+                    && !segment.eventIds.some((eventId) => activeEvents.has(eventId)))
+                    segment.contextAvailable = false;
+            }
+            branchCommitted = this.commitArchivedHiddenBranchState(stored);
+            this.pruneReversionState(stored, false, true);
+        }, true);
+        const context = stored.compactorContext;
+        if (context) {
+            await this.drainReversionReleases(state, stored, context.scopeId, context.scope, false);
+        }
+        return branchCommitted;
+    }
+    async resumePendingApply(state, stored, scopeId, scope, signal) {
+        const pending = stored.pendingReversion;
+        if (pending?.kind !== 'apply')
+            return;
+        const sessionGeneration = requireSessionGeneration(stored.session);
+        const segmentMap = new Map(stored.reversionSegments.map((segment) => [segment.runId, segment]));
+        if (pending.segmentRunIds.some((runId) => segmentMap.get(runId)?.disposition === 'revertible')
+            && !this.core.turnReversionProvider) {
+            throw new FlexHarnessValidationError('Pending workspace reversion recovery requires its turn reversion provider.');
+        }
+        const orderedRunIds = pending.direction === 'undo'
+            ? [...pending.segmentRunIds].reverse()
+            : [...pending.segmentRunIds];
+        let workspaceProgress = pending.appliedRunIds.some((runId) => segmentMap.get(runId)?.disposition === 'revertible');
+        for (const runId of orderedRunIds) {
+            if (pending.appliedRunIds.includes(runId))
+                continue;
+            if (signal?.aborted && !workspaceProgress) {
+                await this.persistKnownNotApplied(state, stored, pending.operationId, runId);
+                throw signal.reason;
+            }
+            const segment = segmentMap.get(runId);
+            if (!segment)
+                throw new FlexHarnessValidationError('Pending reversion references a missing segment.');
+            if (segment.disposition === 'revertible') {
+                if (!this.core.turnReversionProvider || !segment.captureId || segment.workspaceReference === undefined) {
+                    throw new FlexHarnessValidationError('Pending workspace reversion segment is incomplete.');
+                }
+                if (this.reversionProviderProtocolVersion() !== segment.protocolVersion) {
+                    throw new FlexHarnessValidationError(`Pending workspace reversion requires protocolVersion ${segment.protocolVersion}.`);
+                }
+                const captureId = segment.captureId;
+                const reference = segment.workspaceReference;
+                const childOperationId = `${pending.operationId}:${sha256Hex(runId).slice(0, 16)}`;
+                const createContext = (contextSignal) => Object.freeze({
+                    scopeId,
+                    scope,
+                    storageKey: state.storageKey,
+                    sessionId: stored.session.sessionId,
+                    ...sessionGeneration,
+                    runId,
+                    captureId,
+                    reference: cloneSerializable(reference),
+                    operationId: childOperationId,
+                    direction: pending.direction,
+                    signal: contextSignal,
+                });
+                let inspection;
+                try {
+                    inspection = await this.withReversionMaintenanceSignal((inspectionSignal) => this.core.turnReversionProvider.inspectApply(createContext(inspectionSignal)));
+                }
+                catch (inspectionError) {
+                    state.lifecycle = 'fenced';
+                    throw this.core.projectOperationError(inspectionError, 'turnReversion', scopeId, stored.session.sessionId, childOperationId);
+                }
+                if (inspection.status === 'unknown') {
+                    state.lifecycle = 'fenced';
+                    throw new FlexHarnessValidationError('Workspace reversion apply outcome is unknown.');
+                }
+                if (inspection.status === 'not-applied') {
+                    try {
+                        if (signal && !workspaceProgress) {
+                            await this.core.turnReversionProvider.apply(createContext(signal));
+                        }
+                        else {
+                            await this.withReversionMaintenanceSignal((maintenanceSignal) => this.core.turnReversionProvider.apply(createContext(maintenanceSignal)));
+                        }
+                    }
+                    catch (error) {
+                        try {
+                            inspection = await this.withReversionMaintenanceSignal((inspectionSignal) => this.core.turnReversionProvider.inspectApply(createContext(inspectionSignal)));
+                        }
+                        catch (inspectionError) {
+                            state.lifecycle = 'fenced';
+                            throw this.core.projectOperationError(inspectionError, 'turnReversion', scopeId, stored.session.sessionId, childOperationId);
+                        }
+                        if (inspection.status !== 'applied') {
+                            if (inspection.status === 'unknown')
+                                state.lifecycle = 'fenced';
+                            else
+                                await this.persistKnownNotApplied(state, stored, pending.operationId, runId);
+                            throw this.core.projectOperationError(error, 'turnReversion', scopeId, stored.session.sessionId, childOperationId);
+                        }
+                    }
+                }
+            }
+            await this.core.mutateProjection(state, stored, () => {
+                const current = stored.pendingReversion;
+                if (current?.kind !== 'apply' || current.operationId !== pending.operationId) {
+                    throw new FlexHarnessValidationError('Pending reversion changed while applying.');
+                }
+                if (!current.appliedRunIds.includes(runId))
+                    current.appliedRunIds.push(runId);
+            }, true);
+            if (segment.disposition === 'revertible')
+                workspaceProgress = true;
+        }
+        await this.core.mutateProjection(state, stored, () => {
+            const current = stored.pendingReversion;
+            if (current?.kind !== 'apply' || current.operationId !== pending.operationId) {
+                throw new FlexHarnessValidationError('Pending reversion changed before cursor commit.');
+            }
+            stored.revertCursor = current.toCursor;
+            delete stored.pendingReversion;
+        }, true);
+    }
+    async persistKnownNotApplied(state, stored, operationId, runId) {
+        await this.core.mutateProjection(state, stored, () => {
+            const current = stored.pendingReversion;
+            if (current?.kind !== 'apply' || current.operationId !== operationId) {
+                throw new FlexHarnessValidationError('Pending reversion changed while recording failed apply.');
+            }
+            current.appliedRunIds = current.appliedRunIds.filter((entry) => entry !== runId);
+            const hasWorkspaceProgress = current.appliedRunIds.some((appliedRunId) => stored.reversionSegments.some((segment) => segment.runId === appliedRunId && segment.disposition === 'revertible'));
+            if (!hasWorkspaceProgress) {
+                stored.revertCursor = current.fromCursor;
+                delete stored.pendingReversion;
+            }
+        }, true);
+    }
+    async recoverPendingCapture(state, stored, scopeId, scope, outcomes) {
+        const pending = stored.pendingReversion;
+        if (pending?.kind !== 'capture' || !this.core.turnReversionProvider)
+            return;
+        const segment = stored.reversionSegments.find((entry) => entry.runId === pending.runId);
+        if (!segment)
+            throw new FlexHarnessValidationError('Pending capture references a missing segment.');
+        if (this.reversionProviderProtocolVersion() !== pending.protocolVersion) {
+            throw new FlexHarnessValidationError(`Pending capture recovery requires protocolVersion ${pending.protocolVersion}.`);
+        }
+        const outcome = outcomes.get(pending.runId);
+        if (pending.state === 'prepared') {
+            await this.core.mutateProjection(state, stored, () => {
+                const current = stored.pendingReversion;
+                if (current?.kind !== 'capture' || current.captureId !== pending.captureId) {
+                    throw new FlexHarnessValidationError('Pending capture changed before finalization.');
+                }
+                current.state = 'finalizing';
+            }, true);
+        }
+        const finalizedOutcome = await this.resolveReversionCaptureOutcome(state, scopeId, scope, stored.session.sessionId, requireSessionGeneration(stored.session), pending.runId, pending.captureId, pending.state === 'prepared' ? 'finalizing' : pending.state);
+        if (finalizedOutcome === undefined) {
+            await this.core.mutateProjection(state, stored, () => {
+                stored.reversionSegments = stored.reversionSegments.filter((entry) => entry.runId !== pending.runId);
+                delete stored.pendingReversion;
+            }, true);
+            return;
+        }
+        await this.core.mutateProjection(state, stored, () => {
+            segment.status = outcome === 'accepted'
+                ? 'completed'
+                : outcome === 'rejected'
+                    ? 'failed'
+                    : 'cancelled';
+            this.applyFinalizedReversionOutcome(stored, segment, finalizedOutcome);
+            segment.eventIds = stored.agentSession.getEvents()
+                .filter((event) => event.generationId === pending.runId)
+                .map((event) => event.id);
+            if (segment.status === 'completed')
+                stored.revertCursor++;
+            if (outcome === undefined && !stored.excludedRunIds.includes(pending.runId)) {
+                stored.excludedRunIds.push(pending.runId);
+            }
+            delete stored.pendingReversion;
+            this.pruneReversionState(stored, false, true);
+        }, true);
+        await this.drainReversionReleases(state, stored, scopeId, scope, false);
+    }
+    reversionId(kind, storageKey, sessionId, value) {
+        return `${kind}_${sha256Hex(JSON.stringify([storageKey, sessionId, value]))}`;
+    }
+    reversionProviderProtocolVersion() {
+        if (!this.core.turnReversionProvider)
+            return undefined;
+        return 'protocolVersion' in this.core.turnReversionProvider ? 2 : 1;
+    }
+    reversionCaptureContext(run, captureId, signal) {
+        return Object.freeze({
+            scopeId: run.scopeId,
+            scope: run.scope,
+            storageKey: run.state.storageKey,
+            sessionId: run.sessionId,
+            ...requireSessionGeneration(run.stored.session),
+            runId: run.runId,
+            captureId,
+            signal,
+        });
+    }
+    async withReversionMaintenanceSignal(operation) {
+        const controller = new AbortController();
+        const timeoutMs = this.core.reversionMaintenanceTimeoutMs;
+        const timeoutError = new Error(`Turn reversion maintenance timed out after ${timeoutMs}ms.`);
+        let rejectTimeout;
+        const timeout = new Promise((_resolve, reject) => {
+            rejectTimeout = reject;
+        });
+        const timer = setTimeout(() => {
+            controller.abort(timeoutError);
+            rejectTimeout(timeoutError);
+        }, timeoutMs);
+        const completion = Promise.resolve().then(() => operation(controller.signal));
+        void completion.catch(() => undefined);
+        try {
+            return await Promise.race([completion, timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    inspectReversionCapture(scopeId, scope, storageKey, sessionId, sessionGeneration, runId, captureId) {
+        return this.withReversionMaintenanceSignal(async (signal) => {
+            const provider = this.core.turnReversionProvider;
+            const inspection = await provider.inspectCapture(Object.freeze({
+                scopeId,
+                scope,
+                storageKey,
+                sessionId,
+                ...sessionGeneration,
+                runId,
+                captureId,
+                signal,
+            }));
+            if (inspection.status !== 'finalized')
+                return { status: inspection.status };
+            if (this.reversionProviderProtocolVersion() === 2) {
+                if (!('outcome' in inspection)) {
+                    throw new FlexHarnessValidationError('Protocol-2 finalized inspection has no outcome.');
+                }
+                return {
+                    status: 'finalized',
+                    outcome: this.normalizeReversionOutcome(inspection.outcome),
+                };
+            }
+            if (!('reference' in inspection) || inspection.reference === undefined) {
+                throw new FlexHarnessValidationError('Protocol-1 finalized inspection has no reference.');
+            }
+            return {
+                status: 'finalized',
+                outcome: {
+                    disposition: 'revertible',
+                    reference: this.normalizeReversionReference(inspection.reference),
+                    affectedWorkspaces: [],
+                },
+            };
+        });
+    }
+    finalizeReversionCapture(scopeId, scope, storageKey, sessionId, sessionGeneration, runId, captureId) {
+        return this.withReversionMaintenanceSignal(async (signal) => {
+            const result = await this.core.turnReversionProvider.finalize(Object.freeze({
+                scopeId,
+                scope,
+                storageKey,
+                sessionId,
+                ...sessionGeneration,
+                runId,
+                captureId,
+                signal,
+            }));
+            return this.reversionProviderProtocolVersion() === 2
+                ? this.normalizeReversionOutcome(result)
+                : {
+                    disposition: 'revertible',
+                    reference: this.normalizeReversionReference(result),
+                    affectedWorkspaces: [],
+                };
+        });
+    }
+    async resolveReversionCaptureOutcome(state, scopeId, scope, sessionId, sessionGeneration, runId, captureId, durableState) {
+        let inspection;
+        try {
+            inspection = await this.inspectReversionCapture(scopeId, scope, state.storageKey, sessionId, sessionGeneration, runId, captureId);
+        }
+        catch (error) {
+            state.lifecycle = 'fenced';
+            throw this.core.projectOperationError(error, 'turnReversion', scopeId, sessionId, captureId);
+        }
+        if (inspection.status === 'unknown') {
+            state.lifecycle = 'fenced';
+            throw new FlexHarnessValidationError('Reversion capture outcome is unknown.');
+        }
+        if (inspection.status === 'missing') {
+            if (durableState === 'preparing')
+                return undefined;
+            state.lifecycle = 'fenced';
+            throw new FlexHarnessValidationError('Prepared reversion capture is missing.');
+        }
+        let outcome = inspection.status === 'finalized' ? inspection.outcome : undefined;
+        if (inspection.status === 'prepared') {
+            try {
+                outcome = await this.finalizeReversionCapture(scopeId, scope, state.storageKey, sessionId, sessionGeneration, runId, captureId);
+            }
+            catch (error) {
+                const finalInspection = await this.inspectReversionCapture(scopeId, scope, state.storageKey, sessionId, sessionGeneration, runId, captureId);
+                if (finalInspection.status !== 'finalized') {
+                    if (finalInspection.status === 'unknown')
+                        state.lifecycle = 'fenced';
+                    throw this.core.projectOperationError(error, 'turnReversion', scopeId, sessionId, captureId);
+                }
+                outcome = finalInspection.outcome;
+            }
+        }
+        if (outcome === undefined) {
+            state.lifecycle = 'fenced';
+            throw new FlexHarnessValidationError('Finalized reversion capture has no outcome.');
+        }
+        return outcome;
+    }
+    normalizeReversionReference(reference) {
+        return normalizeJsonValue(reference, {
+            maxDepth: this.core.toolOutputLimits.maxDepth,
+            maxBytes: Math.min(this.core.toolOutputLimits.maxBytes, FLEX_REVERSION_REFERENCE_MAX_BYTES),
+        });
+    }
+    normalizeReversionOutcome(value) {
+        if (!value
+            || typeof value !== 'object'
+            || Array.isArray(value)
+            || (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null))
+            throw new FlexHarnessValidationError('Turn reversion finalized outcome must be a plain object.');
+        const outcome = value;
+        const disposition = outcome.disposition;
+        if (!['revertible', 'no-change', 'nonrevertible'].includes(String(disposition))) {
+            throw new FlexHarnessValidationError('Turn reversion finalized outcome disposition is invalid.');
+        }
+        const allowedKeys = disposition === 'nonrevertible'
+            ? ['disposition', 'reference', 'reasonCode', 'affectedWorkspaces']
+            : ['disposition', 'reference', 'affectedWorkspaces'];
+        const unsupported = Object.keys(outcome).find((key) => !allowedKeys.includes(key));
+        if (unsupported) {
+            throw new FlexHarnessValidationError(`Turn reversion finalized outcome does not support "${unsupported}".`);
+        }
+        if (!Object.prototype.hasOwnProperty.call(outcome, 'reference')) {
+            throw new FlexHarnessValidationError('Turn reversion finalized outcome requires a reference.');
+        }
+        const reference = this.normalizeReversionReference(outcome.reference);
+        const affectedWorkspaces = outcome.affectedWorkspaces === undefined
+            ? undefined
+            : this.normalizeAffectedWorkspaces(outcome.affectedWorkspaces);
+        if (disposition === 'revertible') {
+            if (affectedWorkspaces === undefined) {
+                throw new FlexHarnessValidationError('Revertible outcome requires affectedWorkspaces.');
+            }
+            return { disposition, reference, affectedWorkspaces };
+        }
+        if (disposition === 'no-change') {
+            if (affectedWorkspaces && affectedWorkspaces.length > 0) {
+                throw new FlexHarnessValidationError('No-change outcome cannot affect a workspace.');
+            }
+            return {
+                disposition,
+                reference,
+                ...(affectedWorkspaces === undefined ? {} : { affectedWorkspaces: [] }),
+            };
+        }
+        if (typeof outcome.reasonCode !== 'string'
+            || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(outcome.reasonCode)
+            || Buffer.byteLength(outcome.reasonCode, 'utf8') > FLEX_REVERSION_REASON_CODE_MAX_BYTES)
+            throw new FlexHarnessValidationError('Nonrevertible outcome reasonCode is invalid.');
+        return {
+            disposition: 'nonrevertible',
+            reference,
+            reasonCode: outcome.reasonCode,
+            ...(affectedWorkspaces === undefined ? {} : { affectedWorkspaces }),
+        };
+    }
+    normalizeAffectedWorkspaces(value) {
+        if (!Array.isArray(value) || value.length > FLEX_REVERSION_MAX_AFFECTED_WORKSPACES) {
+            throw new FlexHarnessValidationError(`affectedWorkspaces must contain at most ${FLEX_REVERSION_MAX_AFFECTED_WORKSPACES} entries.`);
+        }
+        const ids = new Set();
+        return value.map((entry, index) => {
+            if (!entry
+                || typeof entry !== 'object'
+                || Array.isArray(entry)
+                || (Object.getPrototypeOf(entry) !== Object.prototype && Object.getPrototypeOf(entry) !== null))
+                throw new FlexHarnessValidationError(`affectedWorkspaces[${index}] must be a plain object.`);
+            const descriptor = entry;
+            const unsupported = Object.keys(descriptor).find((key) => !['id', 'label'].includes(key));
+            if (unsupported) {
+                throw new FlexHarnessValidationError(`affectedWorkspaces[${index}] does not support "${unsupported}".`);
+            }
+            if (typeof descriptor.id !== 'string'
+                || !descriptor.id.trim()
+                || Buffer.byteLength(descriptor.id, 'utf8') > FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES)
+                throw new FlexHarnessValidationError(`affectedWorkspaces[${index}].id is invalid.`);
+            if (typeof descriptor.label !== 'string'
+                || !descriptor.label.trim()
+                || Buffer.byteLength(descriptor.label, 'utf8') > FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES)
+                throw new FlexHarnessValidationError(`affectedWorkspaces[${index}].label is invalid.`);
+            if (ids.has(descriptor.id)) {
+                throw new FlexHarnessValidationError(`affectedWorkspaces contains duplicate id "${descriptor.id}".`);
+            }
+            ids.add(descriptor.id);
+            return { id: descriptor.id, label: descriptor.label };
+        });
+    }
+    async prepareRunReversion(run, signal) {
+        if (run.stored.session.agent !== undefined || !this.core.turnReversionProvider)
+            return;
+        const segment = run.stored.reversionSegments.find((entry) => entry.runId === run.runId);
+        const captureId = segment?.captureId;
+        if (!segment || !captureId) {
+            throw this.core.projectExternalError(run, new Error('Root generation is missing its durable reversion capture intent.'), 'turnReversion');
+        }
+        const context = this.reversionCaptureContext(run, captureId, signal);
+        if (this.reversionProviderProtocolVersion() !== segment.protocolVersion) {
+            throw this.core.projectExternalError(run, new Error(`Root generation requires reversion protocolVersion ${segment.protocolVersion}.`), 'turnReversion');
+        }
+        try {
+            await this.core.turnReversionProvider.prepare(context);
+        }
+        catch (error) {
+            let inspection;
+            try {
+                inspection = await this.inspectReversionCapture(run.scopeId, run.scope, run.state.storageKey, run.sessionId, requireSessionGeneration(run.stored.session), run.runId, captureId);
+            }
+            catch (inspectionError) {
+                run.state.lifecycle = 'fenced';
+                throw this.core.projectExternalError(run, inspectionError, 'turnReversion');
+            }
+            if (inspection.status !== 'prepared' && inspection.status !== 'finalized') {
+                if (inspection.status === 'unknown')
+                    run.state.lifecycle = 'fenced';
+                throw this.core.projectExternalError(run, error, 'turnReversion');
+            }
+        }
+        await this.core.mutateProjection(run.state, run.stored, () => {
+            const pending = run.stored.pendingReversion;
+            if (pending?.kind !== 'capture' || pending.runId !== run.runId) {
+                throw new FlexHarnessValidationError('Reversion capture intent changed during preparation.');
+            }
+            pending.state = 'prepared';
+        }, true);
+    }
+    async finalizeRunReversion(run, status) {
+        if (run.stored.session.agent !== undefined)
+            return;
+        const segment = run.stored.reversionSegments.find((entry) => entry.runId === run.runId);
+        if (!segment)
+            return;
+        const eventIds = run.stored.agentSession.getEvents()
+            .filter((event) => event.generationId === run.runId)
+            .map((event) => event.id);
+        if (!this.core.turnReversionProvider || segment.provenance === 'transcript') {
+            await this.core.mutateProjection(run.state, run.stored, () => {
+                const wasCompleted = segment.status === 'completed';
+                segment.status = status;
+                segment.eventIds = eventIds;
+                if (!wasCompleted && status === 'completed')
+                    run.stored.revertCursor++;
+                else if (wasCompleted && status !== 'completed')
+                    run.stored.revertCursor--;
+                delete run.stored.pendingReversion;
+                this.pruneReversionState(run.stored);
+            }, true);
+            return;
+        }
+        if (!segment.captureId) {
+            throw new FlexHarnessValidationError('Workspace reversion segment has no capture ownership.');
+        }
+        const captureId = segment.captureId;
+        if (segment.workspaceReference !== undefined) {
+            await this.core.mutateProjection(run.state, run.stored, () => {
+                const wasCompleted = segment.status === 'completed';
+                segment.status = status;
+                segment.eventIds = eventIds;
+                if (!wasCompleted && status === 'completed')
+                    run.stored.revertCursor++;
+                else if (wasCompleted && status !== 'completed')
+                    run.stored.revertCursor--;
+                delete run.stored.pendingReversion;
+            }, true);
+            return;
+        }
+        const pending = run.stored.pendingReversion;
+        if (pending?.kind !== 'capture' || pending.runId !== run.runId) {
+            throw new FlexHarnessValidationError('Reversion capture intent changed before finalization.');
+        }
+        if (this.reversionProviderProtocolVersion() !== pending.protocolVersion) {
+            throw new FlexHarnessValidationError(`Reversion capture finalization requires protocolVersion ${pending.protocolVersion}.`);
+        }
+        if (pending.state === 'prepared') {
+            await this.core.mutateProjection(run.state, run.stored, () => {
+                const current = run.stored.pendingReversion;
+                if (current?.kind !== 'capture' || current.captureId !== captureId) {
+                    throw new FlexHarnessValidationError('Reversion capture changed before finalization.');
+                }
+                current.state = 'finalizing';
+            }, true);
+        }
+        const outcome = await this.resolveReversionCaptureOutcome(run.state, run.scopeId, run.scope, run.sessionId, requireSessionGeneration(run.stored.session), run.runId, captureId, pending.state === 'prepared' ? 'finalizing' : pending.state);
+        if (outcome === undefined) {
+            await this.core.mutateProjection(run.state, run.stored, () => {
+                run.stored.reversionSegments = run.stored.reversionSegments.filter((entry) => entry.runId !== run.runId);
+                delete run.stored.pendingReversion;
+            }, true);
+            return;
+        }
+        await this.core.mutateProjection(run.state, run.stored, () => {
+            const current = run.stored.pendingReversion;
+            if (current?.kind !== 'capture' || current.runId !== run.runId) {
+                throw new FlexHarnessValidationError('Reversion capture intent changed before finalization.');
+            }
+            const wasCompleted = segment.status === 'completed';
+            segment.status = status;
+            segment.eventIds = eventIds;
+            this.applyFinalizedReversionOutcome(run.stored, segment, outcome);
+            if (!wasCompleted && status === 'completed')
+                run.stored.revertCursor++;
+            else if (wasCompleted && status !== 'completed')
+                run.stored.revertCursor--;
+            delete run.stored.pendingReversion;
+            this.pruneReversionState(run.stored);
+        }, true);
+    }
+    applyFinalizedReversionOutcome(stored, segment, outcome) {
+        const captureId = segment.captureId;
+        if (!captureId) {
+            throw new FlexHarnessValidationError('Finalized workspace outcome has no capture ownership.');
+        }
+        segment.disposition = outcome.disposition;
+        delete segment.affectedWorkspaces;
+        delete segment.reasonCode;
+        if (segment.protocolVersion === 2) {
+            if (outcome.affectedWorkspaces !== undefined) {
+                segment.affectedWorkspaces = cloneSerializable([...outcome.affectedWorkspaces]);
+            }
+            if (outcome.disposition === 'nonrevertible')
+                segment.reasonCode = outcome.reasonCode;
+        }
+        if (outcome.disposition === 'revertible') {
+            segment.workspaceReference = cloneSerializable(outcome.reference);
+            return;
+        }
+        this.enqueueReversionReleaseReference(stored, {
+            runId: segment.runId,
+            captureId,
+            reference: cloneSerializable(outcome.reference),
+            protocolVersion: segment.protocolVersion,
+        });
+        delete segment.captureId;
+        delete segment.workspaceReference;
+    }
+    hiddenReversionSegments(stored) {
+        const firstHidden = this.reversionGroups(stored)[stored.revertCursor]?.segments[0];
+        if (!firstHidden)
+            return [];
+        const index = stored.reversionSegments.findIndex((segment) => segment.runId === firstHidden.runId);
+        if (index < 0)
+            return [];
+        return stored.reversionSegments.slice(index);
+    }
+    enqueueReversionRelease(stored, segment) {
+        if (segment.disposition !== 'revertible')
+            return;
+        if (segment.captureId === undefined || segment.workspaceReference === undefined) {
+            throw new FlexHarnessValidationError('Capture-backed segment has no releasable workspace reference.');
+        }
+        this.enqueueReversionReleaseReference(stored, {
+            runId: segment.runId,
+            captureId: segment.captureId,
+            reference: cloneSerializable(segment.workspaceReference),
+            protocolVersion: segment.protocolVersion,
+        });
+    }
+    enqueueReversionReleaseReference(stored, release) {
+        if (stored.pendingReversionReleases.some((entry) => entry.captureId === release.captureId)) {
+            return;
+        }
+        if (stored.pendingReversionReleases.length >= this.core.reversionLimits.maxPendingReversionReleases) {
+            throw new FlexHarnessValidationError('Pending reversion release limit was reached.');
+        }
+        stored.pendingReversionReleases.push(cloneSerializable(release));
+    }
+    pruneReversionState(stored, reserveSegment = false, dropNonUndoablePrefix = false) {
+        if (stored.pendingReversion || stored.revertCursor !== this.completedReversionCandidates(stored).length) {
+            return;
+        }
+        while (stored.reversionSegments.length > 0) {
+            const candidates = this.completedReversionCandidates(stored);
+            const overLimit = candidates.length + (reserveSegment ? 1 : 0)
+                > this.core.reversionLimits.maxCompletedTurns
+                || stored.reversionSegments.length + (reserveSegment ? 1 : 0)
+                    > this.core.reversionLimits.maxSegments;
+            const firstCandidate = candidates[0];
+            const nextCandidate = candidates[1];
+            let end = 0;
+            if (!firstCandidate) {
+                if (dropNonUndoablePrefix)
+                    end = stored.reversionSegments.length;
+                else if (overLimit) {
+                    end = Math.max(1, stored.reversionSegments.length + (reserveSegment ? 1 : 0)
+                        - this.core.reversionLimits.maxSegments);
+                }
+                else
+                    break;
+            }
+            else if (!firstCandidate.contextAvailable) {
+                end = nextCandidate
+                    ? stored.reversionSegments.findIndex((segment) => segment.runId === nextCandidate.runId)
+                    : stored.reversionSegments.length;
+            }
+            else if (overLimit) {
+                end = nextCandidate
+                    ? stored.reversionSegments.findIndex((segment) => segment.runId === nextCandidate.runId)
+                    : stored.reversionSegments.length;
+            }
+            else {
+                break;
+            }
+            if (end <= 0)
+                break;
+            const prefix = stored.reversionSegments.slice(0, end);
+            if (prefix.some((segment) => segment.disposition === 'revertible' && segment.workspaceReference === undefined))
+                break;
+            for (const segment of prefix)
+                this.enqueueReversionRelease(stored, segment);
+            stored.reversionSegments.splice(0, end);
+            stored.revertCursor = Math.max(0, stored.revertCursor - prefix.filter((segment) => segment.status === 'completed').length);
+        }
+        if (stored.excludedRunIds.length > this.core.reversionLimits.maxExcludedRunIds) {
+            throw new FlexHarnessValidationError('Excluded reversion run limit was reached.');
+        }
+    }
+    async commitRevertedBranch(state, stored, scopeId, scope) {
+        if (stored.pendingReversionReleases.length > 0) {
+            await this.drainReversionReleases(state, stored, scopeId, scope, false);
+            this.core.assertStateAcceptingWork(state);
+        }
+        if (this.hiddenReversionSegments(stored).length === 0) {
+            return;
+        }
+        await this.core.mutateProjection(state, stored, () => this.commitRevertedBranchState(stored), true);
+        this.core.emitEvent(scopeId, stored.session, {
+            type: 'session.history.changed',
+            direction: 'branch',
+        });
+        await this.drainReversionReleases(state, stored, scopeId, scope, false);
+    }
+    commitRevertedBranchState(stored) {
+        const hidden = this.hiddenReversionSegments(stored);
+        if (hidden.length === 0)
+            return false;
+        const hiddenRunIds = new Set(hidden.map((segment) => segment.runId));
+        stored.messages = stored.messages.filter((message) => !hiddenRunIds.has(message.runId));
+        stored.stagedTerminals = stored.stagedTerminals.filter((terminal) => !hiddenRunIds.has(terminal.runId));
+        for (const segment of hidden) {
+            this.enqueueReversionRelease(stored, segment);
+            if (!stored.excludedRunIds.includes(segment.runId))
+                stored.excludedRunIds.push(segment.runId);
+        }
+        stored.reversionSegments = stored.reversionSegments.filter((segment) => !hiddenRunIds.has(segment.runId));
+        stored.revertCursor = this.completedReversionCandidates(stored).length;
+        this.pruneReversionState(stored);
+        return true;
+    }
+    commitArchivedHiddenBranchState(stored) {
+        const hidden = this.hiddenReversionSegments(stored);
+        return hidden.some((segment) => !segment.contextAvailable)
+            ? this.commitRevertedBranchState(stored)
+            : false;
+    }
+    refreshAutomaticArchiveHorizon(stored) {
+        const events = stored.agentSession.getEvents();
+        const activeIds = new Set(events.map((event) => event.id));
+        const archivedIds = new Set(events.flatMap((event) => event.type === 'context-compaction' && event.automatic
+            ? event.coveredEventIds.filter((id) => !activeIds.has(id)) : []));
+        if (archivedIds.size === 0)
+            return;
+        for (const segment of stored.reversionSegments) {
+            if (segment.eventIds.some((id) => archivedIds.has(id)))
+                segment.contextAvailable = false;
+        }
+        this.commitArchivedHiddenBranchState(stored);
+        this.pruneReversionState(stored, false, true);
+    }
+    filterReversionContextEvents(stored, events) {
+        const hiddenRunIds = new Set([
+            ...this.hiddenReversionSegments(stored).map((segment) => segment.runId),
+            ...stored.excludedRunIds,
+        ]);
+        const hiddenRawIds = new Set([
+            ...this.hiddenReversionSegments(stored).flatMap((segment) => segment.eventIds),
+            ...events.filter((event) => event.generationId && hiddenRunIds.has(event.generationId))
+                .map((event) => event.id),
+        ]);
+        const taintedCompactionIds = new Set();
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const event of events) {
+                if (event.type !== 'context-compaction' || taintedCompactionIds.has(event.id))
+                    continue;
+                if (event.coveredEventIds.some((id) => hiddenRawIds.has(id) || taintedCompactionIds.has(id))
+                    || event.archivedTransactions?.some((transaction) => hiddenRunIds.has(transaction.generationId))) {
+                    taintedCompactionIds.add(event.id);
+                    changed = true;
+                }
+            }
+        }
+        return events.filter((event) => !(event.generationId && hiddenRunIds.has(event.generationId))
+            && !taintedCompactionIds.has(event.id));
+    }
+    async drainReversionReleases(state, stored, scopeId, scope, throwOnFailure) {
+        await this.core.reconcileProjectionFromStore(stored);
+        if (!this.core.turnReversionProvider) {
+            if (stored.pendingReversionReleases.length > 0) {
+                throw new FlexHarnessValidationError('Pending workspace capture releases require their turn reversion provider.');
+            }
+            return;
+        }
+        const sessionGeneration = requireSessionGeneration(stored.session);
+        while (stored.pendingReversionReleases.length > 0) {
+            const release = stored.pendingReversionReleases[0];
+            if (this.reversionProviderProtocolVersion() !== release.protocolVersion) {
+                throw new FlexHarnessValidationError(`Pending workspace release requires protocolVersion ${release.protocolVersion}.`);
+            }
+            try {
+                await this.withReversionMaintenanceSignal((signal) => this.core.turnReversionProvider.release(Object.freeze({
+                    scopeId,
+                    scope,
+                    storageKey: state.storageKey,
+                    sessionId: stored.session.sessionId,
+                    ...sessionGeneration,
+                    runId: release.runId,
+                    captureId: release.captureId,
+                    reference: cloneSerializable(release.reference),
+                    signal,
+                })));
+            }
+            catch (error) {
+                if (throwOnFailure) {
+                    throw this.core.projectOperationError(error, 'turnReversion', scopeId, stored.session.sessionId, `release:${release.captureId}`);
+                }
+                return;
+            }
+            try {
+                await this.core.mutateProjection(state, stored, () => {
+                    if (stored.pendingReversionReleases[0]?.captureId === release.captureId) {
+                        stored.pendingReversionReleases.shift();
+                    }
+                }, true);
+            }
+            catch (error) {
+                if (!throwOnFailure && state.lifecycle === 'fenced') {
+                    this.core.lifecycle.deferReversionReleaseDrain(state, stored, scopeId, scope);
+                }
+                if (throwOnFailure)
+                    throw error;
+                return;
+            }
+            if (stored.projectionReconciliationRequired)
+                return;
+        }
+    }
+    async releaseDeletedSessionReversions(state, storageKey, tombstone, scopeId, scope, stored) {
+        const sessionId = tombstone.sessionId;
+        const sessionGeneration = requireSessionGeneration(stored?.session ?? tombstone);
+        if (stored)
+            await stored.projectionQueue;
+        let durableProjection = await this.core.stores.projections.load(storageKey, sessionId);
+        if (!durableProjection)
+            return;
+        let projection = this.core.upgradeProjectionSnapshot(durableProjection);
+        const persistDirect = async (next) => {
+            const before = durableProjection;
+            try {
+                await this.core.stores.projections.save(storageKey, sessionId, next, projection.revision);
+                durableProjection = next;
+                projection = next;
+            }
+            catch (error) {
+                let current;
+                let reconciliationError;
+                try {
+                    current = await this.core.stores.projections.load(storageKey, sessionId);
+                }
+                catch (loadError) {
+                    reconciliationError = loadError;
+                }
+                if (current && JSON.stringify(current) === JSON.stringify(next)) {
+                    durableProjection = current;
+                    projection = next;
+                    return;
+                }
+                if (current && before && JSON.stringify(current) === JSON.stringify(before))
+                    throw error;
+                state.lifecycle = 'fenced';
+                throw reconciliationError === undefined ? error : combineErrors([error, reconciliationError]);
+            }
+        };
+        if (projection.pendingReversion?.kind === 'apply') {
+            if (stored) {
+                await this.resumePendingApply(state, stored, scopeId, scope);
+            }
+            else {
+                const pending = projection.pendingReversion;
+                const orderedRunIds = pending.direction === 'undo'
+                    ? [...pending.segmentRunIds].reverse()
+                    : [...pending.segmentRunIds];
+                for (const runId of orderedRunIds) {
+                    if (pending.appliedRunIds.includes(runId))
+                        continue;
+                    const segment = projection.reversionSegments.find((entry) => entry.runId === runId);
+                    if (segment.disposition === 'revertible') {
+                        if (!this.core.turnReversionProvider || !segment.captureId || segment.workspaceReference === undefined) {
+                            throw new FlexHarnessValidationError('Pending workspace reversion deletion requires its turn reversion provider.');
+                        }
+                        if (this.reversionProviderProtocolVersion() !== segment.protocolVersion) {
+                            throw new FlexHarnessValidationError(`Pending workspace reversion deletion requires protocolVersion ${segment.protocolVersion}.`);
+                        }
+                        const captureId = segment.captureId;
+                        const reference = segment.workspaceReference;
+                        const operationId = `${pending.operationId}:${sha256Hex(runId).slice(0, 16)}`;
+                        const createContext = (signal) => Object.freeze({
+                            scopeId,
+                            scope,
+                            storageKey,
+                            sessionId,
+                            ...sessionGeneration,
+                            runId,
+                            captureId,
+                            reference: cloneSerializable(reference),
+                            operationId,
+                            direction: pending.direction,
+                            signal,
+                        });
+                        let inspection = await this.withReversionMaintenanceSignal((signal) => this.core.turnReversionProvider.inspectApply(createContext(signal)));
+                        if (inspection.status === 'unknown') {
+                            state.lifecycle = 'fenced';
+                            throw new FlexHarnessValidationError('Workspace reversion apply outcome is unknown.');
+                        }
+                        if (inspection.status === 'not-applied') {
+                            try {
+                                await this.withReversionMaintenanceSignal((signal) => this.core.turnReversionProvider.apply(createContext(signal)));
+                            }
+                            catch (error) {
+                                inspection = await this.withReversionMaintenanceSignal((signal) => this.core.turnReversionProvider.inspectApply(createContext(signal)));
+                                if (inspection.status !== 'applied') {
+                                    if (inspection.status === 'unknown')
+                                        state.lifecycle = 'fenced';
+                                    throw error;
+                                }
+                            }
+                        }
+                    }
+                    pending.appliedRunIds.push(runId);
+                    await persistDirect({ ...projection, revision: projection.revision + 1 });
+                }
+                const { pendingReversion: _pendingReversion, ...completedProjection } = projection;
+                const completed = {
+                    ...completedProjection,
+                    revision: projection.revision + 1,
+                    revertCursor: pending.toCursor,
+                };
+                await persistDirect(completed);
+            }
+            const recoveredProjection = await this.core.stores.projections.load(storageKey, sessionId);
+            if (!recoveredProjection)
+                return;
+            durableProjection = recoveredProjection;
+            projection = this.core.upgradeProjectionSnapshot(recoveredProjection);
+        }
+        const releases = new Map();
+        for (const release of projection.pendingReversionReleases) {
+            releases.set(release.captureId, cloneSerializable(release));
+        }
+        for (const segment of projection.reversionSegments) {
+            if (segment.captureId && segment.workspaceReference !== undefined) {
+                releases.set(segment.captureId, {
+                    runId: segment.runId,
+                    captureId: segment.captureId,
+                    reference: cloneSerializable(segment.workspaceReference),
+                    protocolVersion: segment.protocolVersion,
+                });
+            }
+        }
+        const unresolvedCaptures = new Map();
+        for (const segment of projection.reversionSegments) {
+            if (segment.captureId && !releases.has(segment.captureId)) {
+                unresolvedCaptures.set(segment.captureId, {
+                    runId: segment.runId,
+                    captureId: segment.captureId,
+                    protocolVersion: segment.protocolVersion,
+                });
+            }
+        }
+        if (projection.pendingReversion?.kind === 'capture') {
+            unresolvedCaptures.set(projection.pendingReversion.captureId, {
+                runId: projection.pendingReversion.runId,
+                captureId: projection.pendingReversion.captureId,
+                protocolVersion: projection.pendingReversion.protocolVersion,
+                durableState: projection.pendingReversion.state,
+            });
+        }
+        if (unresolvedCaptures.size > 0 && !this.core.turnReversionProvider) {
+            throw new FlexHarnessValidationError('Capture-backed session deletion requires its turn reversion provider.');
+        }
+        for (const capture of unresolvedCaptures.values()) {
+            if (this.reversionProviderProtocolVersion() !== capture.protocolVersion) {
+                throw new FlexHarnessValidationError(`Deleted session capture requires protocolVersion ${capture.protocolVersion}.`);
+            }
+            if (capture.durableState === 'prepared') {
+                if (stored) {
+                    await this.core.mutateProjection(state, stored, () => {
+                        const pending = stored.pendingReversion;
+                        if (pending?.kind !== 'capture' || pending.captureId !== capture.captureId) {
+                            throw new FlexHarnessValidationError('Deleted session capture changed before finalization.');
+                        }
+                        pending.state = 'finalizing';
+                    }, true);
+                }
+                else if (projection.pendingReversion?.kind === 'capture') {
+                    projection.pendingReversion.state = 'finalizing';
+                    await persistDirect({ ...projection, revision: projection.revision + 1 });
+                }
+                capture.durableState = 'finalizing';
+            }
+            let inspection;
+            try {
+                inspection = await this.inspectReversionCapture(scopeId, scope, storageKey, sessionId, sessionGeneration, capture.runId, capture.captureId);
+            }
+            catch (error) {
+                throw this.core.projectOperationError(error, 'turnReversion', scopeId, sessionId, `release:${capture.captureId}`);
+            }
+            if (inspection.status === 'unknown') {
+                state.lifecycle = 'fenced';
+                throw new FlexHarnessValidationError('Deleted session capture outcome is unknown.');
+            }
+            if (inspection.status === 'missing') {
+                if (capture.durableState === 'preparing')
+                    continue;
+                state.lifecycle = 'fenced';
+                throw new FlexHarnessValidationError('Prepared deleted-session capture is missing.');
+            }
+            let outcome = inspection.status === 'finalized' ? inspection.outcome : undefined;
+            if (inspection.status === 'prepared') {
+                try {
+                    outcome = await this.finalizeReversionCapture(scopeId, scope, storageKey, sessionId, sessionGeneration, capture.runId, capture.captureId);
+                }
+                catch (error) {
+                    const finalInspection = await this.inspectReversionCapture(scopeId, scope, storageKey, sessionId, sessionGeneration, capture.runId, capture.captureId);
+                    if (finalInspection.status !== 'finalized') {
+                        if (finalInspection.status === 'unknown')
+                            state.lifecycle = 'fenced';
+                        throw this.core.projectOperationError(error, 'turnReversion', scopeId, sessionId, `release:${capture.captureId}`);
+                    }
+                    outcome = finalInspection.outcome;
+                }
+            }
+            if (outcome === undefined) {
+                throw new FlexHarnessValidationError('Deleted session capture has no release reference.');
+            }
+            releases.set(capture.captureId, {
+                runId: capture.runId,
+                captureId: capture.captureId,
+                reference: cloneSerializable(outcome.reference),
+                protocolVersion: capture.protocolVersion,
+            });
+        }
+        if (releases.size === 0)
+            return;
+        if (!this.core.turnReversionProvider) {
+            throw new FlexHarnessValidationError('Capture-backed session deletion requires its turn reversion provider.');
+        }
+        if (stored) {
+            await this.core.mutateProjection(state, stored, () => {
+                stored.reversionSegments = [];
+                stored.revertCursor = 0;
+                delete stored.pendingReversion;
+                stored.pendingReversionReleases = [...releases.values()].map((release) => cloneSerializable(release));
+            }, true);
+            await this.drainReversionReleases(state, stored, scopeId, scope, true);
+        }
+        else {
+            const { pendingReversion: _pendingReversion, ...withoutPending } = projection;
+            await persistDirect({
+                ...withoutPending,
+                revision: projection.revision + 1,
+                reversionSegments: [],
+                revertCursor: 0,
+                pendingReversionReleases: [...releases.values()].map((release) => cloneSerializable(release)),
+            });
+            while (projection.pendingReversionReleases.length > 0) {
+                const release = projection.pendingReversionReleases[0];
+                if (this.reversionProviderProtocolVersion() !== release.protocolVersion) {
+                    throw new FlexHarnessValidationError(`Deleted session release requires protocolVersion ${release.protocolVersion}.`);
+                }
+                try {
+                    await this.withReversionMaintenanceSignal((signal) => this.core.turnReversionProvider.release(Object.freeze({
+                        scopeId,
+                        scope,
+                        storageKey,
+                        sessionId,
+                        ...sessionGeneration,
+                        runId: release.runId,
+                        captureId: release.captureId,
+                        reference: cloneSerializable(release.reference),
+                        signal,
+                    })));
+                }
+                catch (error) {
+                    throw this.core.projectOperationError(error, 'turnReversion', scopeId, sessionId, `release:${release.captureId}`);
+                }
+                await persistDirect({
+                    ...projection,
+                    revision: projection.revision + 1,
+                    pendingReversionReleases: projection.pendingReversionReleases.slice(1),
+                });
+            }
+        }
+    }
+    completedReversionCandidates(stored) {
+        return stored.reversionSegments.filter((segment) => segment.status === 'completed');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.reversions.js","sourceRoot":"","sources":["../ts/classes.flexharness.reversions.ts"],"names":[],"mappings":"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"}