@modelprofile.com/flexharness 3.6.0 → 3.8.0

package/ts/classes.flexharness.ts

@@ -10,14 +10,26 @@ import {
   FlexHarnessQueueFullError,
   FlexHarnessRunError,
   FlexHarnessSessionBusyError,
+  FlexHarnessSlashCommandReentryError,
+  FlexHarnessSlashCommandUnavailableError,
   FlexHarnessStoreConflictError,
   FlexHarnessStoreCommitUncertainError,
   FlexHarnessValidationError,
   errorToInfo,
 } from './errors.js';
+import {
+  FLEX_REVERSION_MAX_AFFECTED_WORKSPACES,
+  FLEX_REVERSION_DEFAULT_LIMITS,
+  FLEX_REVERSION_MAXIMUM_LIMITS,
+  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 type {
   IFlexAgentContextInvocation,
   IFlexAgentSessionPolicy,
+  IFlexAffectedWorkspace,
   IFlexAttachmentMessagePart,
   IFlexBackgroundExecution,
   IFlexCallbackLimits,
@@ -41,7 +53,11 @@ import type {
   IFlexPromptQueueLimits,
   IFlexPromptOptions,
   IFlexPromptResult,
-  IFlexProjectionSnapshot,
+  IFlexProjectionSnapshotCurrent,
+  IFlexReversionLimits,
+  IFlexReversionSegment,
+  IFlexPendingReversionRelease,
+  IFlexRedoSessionResult,
   IFlexResolvedModel,
   IFlexResolvedScope,
   IFlexResourceToolProviderDescriptor,
@@ -50,13 +66,20 @@ import type {
   IFlexSchedulePromptOptions,
   IFlexScopeSnapshot,
   IFlexSession,
+  IFlexSessionReversionGroup,
+  IFlexSessionReversionInfo,
   IFlexSessionTombstone,
+  IFlexSlashCommandDescriptor,
+  IFlexSlashCommandExecutionOptions,
+  IFlexSlashCommandHandlerRegistration,
+  IFlexSlashCommandTemplateRegistration,
   IFlexSubagentDefinition,
   IFlexTerminalProjection,
   IFlexToolHandle,
   IFlexToolMessagePart,
   IFlexToolProviderContext,
   IFlexUncertainToolExecution,
+  IFlexUndoSessionResult,
   IFlexUpdateSessionOptions,
   IFlexUsage,
   IJsonObject,
@@ -73,7 +96,15 @@ import type {
   TFlexPrompt,
   TFlexPromptPart,
   TFlexPromptQueueStatus,
+  TFlexSlashCommandExecutionResult,
+  TFlexSlashCommandRegistration,
+  TFlexPendingReversion,
+  TFlexProjectionSnapshot,
+  TFlexReversionPolicy,
+  TFlexSessionReversionGroupKind,
+  TFlexTurnReversionFinalizedOutcome,
   TFlexToolExecutionReconciliation,
+  TJsonValue,
 } from './interfaces.js';
 import { InMemoryFlexHarnessStores } from './classes.stores.js';
 import {
@@ -88,6 +119,14 @@ import {
   normalizeFlexPrompt,
   type INormalizedFlexPrompt,
 } from './utils.prompt.js';
+import {
+  FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE,
+  FLEX_SLASH_COMMAND_MAX_INPUT_BYTES,
+  expandSlashCommandTemplate,
+  isValidSlashCommandName,
+  parseSlashCommand,
+  slashCommandTemplateHints,
+} from './utils.slashcommands.js';
 
 type TCanonicalOutcome = 'accepted' | 'rejected' | 'interrupted';
 type TRunPhase =
@@ -104,6 +143,14 @@ interface IStoredSessionState {
   session: IFlexSession;
   messages: IFlexMessage[];
   stagedTerminals: IFlexTerminalProjection[];
+  reversionSegments: IFlexReversionSegment[];
+  revertCursor: number;
+  excludedRunIds: string[];
+  pendingReversion?: TFlexPendingReversion;
+  pendingReversionReleases: IFlexPendingReversionRelease[];
+  projectionSchemaVersion: 1 | 2 | 3;
+  projectionBaseline?: TFlexProjectionSnapshot;
+  projectionReconciliationRequired: boolean;
   projectionRevision: number;
   projectionQueue: Promise<void>;
   rememberedPermissionKeys: Set<string>;
@@ -131,6 +178,18 @@ interface IRetainedSessionCleanup {
   domainsCompleted: boolean;
 }
 
+interface IReversionGroup {
+  target: IFlexReversionSegment;
+  segments: IFlexReversionSegment[];
+  kind: TFlexSessionReversionGroupKind;
+  affectedWorkspaces: IFlexAffectedWorkspace[];
+  affectedWorkspacesTruncated: boolean;
+}
+
+type TNormalizedCaptureInspection =
+  | { status: 'missing' | 'prepared' | 'unknown' }
+  | { status: 'finalized'; outcome: TFlexTurnReversionFinalizedOutcome };
+
 interface IDetachedCleanup {
   cleanup: () => Promise<void> | void;
   projectError: (error: unknown) => Error;
@@ -151,6 +210,13 @@ interface IOrphanedTombstoneCleanup {
   completion: Promise<void>;
 }
 
+interface IOrphanedTombstoneOwner<TScope> {
+  state: IStorageState;
+  rootSessionId: string;
+  scopeId: string;
+  scope: TScope;
+}
+
 interface IOrphanedExecutionContextOwner {
   storageKey: string;
   sessionId: string;
@@ -160,6 +226,7 @@ interface IStorageState {
   storageKey: string;
   compactorLifecycleController: AbortController;
   scopeIdHint: string;
+  scopeContext: { scopeId: string; scope: unknown };
   revision: number;
   sessions: Map<string, IStoredSessionState>;
   retainedSessionCleanups: Map<string, IRetainedSessionCleanup>;
@@ -261,6 +328,38 @@ interface IScopeAdmissionState {
   retiring: boolean;
 }
 
+type TRegisteredSlashCommand<TScope> =
+  | Readonly<IFlexSlashCommandTemplateRegistration>
+  | Readonly<IFlexSlashCommandHandlerRegistration<TScope>>;
+
+interface IActiveSlashCommandExecution {
+  kind: 'handler' | 'operation' | 'prompt-admission';
+  storageKey: string;
+  sessionId: string;
+  controller: AbortController;
+  completion: Promise<unknown>;
+}
+
+interface IActiveSlashCommandListing {
+  storageKey: string;
+  sessionId: string;
+  controller: AbortController;
+  completion: Promise<unknown>;
+}
+
+interface ISlashCommandInvocationOwner {
+  scopeId: string;
+  storageKey: string;
+  sessionId: string;
+  sessionKey: string;
+}
+
+interface ISlashCommandActivityOwner {
+  scopeId: string;
+  storageKey: string;
+  sessionId: string;
+}
+
 interface IRunResultProjection {
   text: string;
   steps: number;
@@ -342,9 +441,14 @@ const maximumMaxSubagentCallsPerRun = 128;
 const maxResourceToolProviders = 128;
 const maxResourceIdBytes = 512;
 const maxResourceToolNameBytes = 512;
+const maxSlashCommandRegistrations = 128;
+const maxSlashCommandDescriptionBytes = 2048;
+const maxSlashCommandTemplateBytes = FLEX_SLASH_COMMAND_MAX_INPUT_BYTES;
 const resourceToolStemLength = 16;
 const repairCancellationMessage = 'The process stopped before this run completed.';
 const scopeRetirementMessage = 'The scope is being retired.';
+const slashCommandSessionUnavailableReason = 'Session must be idle with no queued prompts.';
+const reservedSlashCommandNames = new Set(['compact', 'undo', 'redo', 'init']);
 const externalErrorFallback: IFlexErrorInfo = Object.freeze({
   name: 'FlexHarnessExternalError',
   message: 'The model operation failed.',
@@ -559,6 +663,89 @@ function normalizeSubagents(
   return Object.freeze(normalized);
 }
 
+function normalizeSlashCommands<TScope>(
+  registrations: readonly TFlexSlashCommandRegistration<TScope>[] | undefined,
+): ReadonlyMap<string, TRegisteredSlashCommand<TScope>> {
+  if (registrations === undefined) return new Map();
+  if (!Array.isArray(registrations) || registrations.length > maxSlashCommandRegistrations) {
+    throw new FlexHarnessValidationError(
+      `slashCommands must be an array with at most ${maxSlashCommandRegistrations} registrations.`,
+    );
+  }
+  const normalized = new Map<string, TRegisteredSlashCommand<TScope>>();
+  for (let index = 0; index < registrations.length; index++) {
+    const registration = registrations[index];
+    if (
+      !registration
+      || typeof registration !== 'object'
+      || Array.isArray(registration)
+      || ![Object.prototype, null].includes(Object.getPrototypeOf(registration))
+    ) {
+      throw new FlexHarnessValidationError(`slashCommands[${index}] must be a plain object.`);
+    }
+    const keys = Object.keys(registration);
+    const hasTemplate = Object.prototype.hasOwnProperty.call(registration, 'template');
+    const hasHandler = Object.prototype.hasOwnProperty.call(registration, 'handler');
+    const supported = hasTemplate
+      ? ['name', 'description', 'template']
+      : ['name', 'description', 'handler'];
+    const unsupported = keys.find((key) => !supported.includes(key));
+    if (unsupported || hasTemplate === hasHandler) {
+      throw new FlexHarnessValidationError(
+        `slashCommands[${index}] must define exactly one of template or handler.`,
+      );
+    }
+    if (typeof registration.name !== 'string' || !isValidSlashCommandName(registration.name)) {
+      throw new FlexHarnessValidationError(`slashCommands[${index}].name is invalid.`);
+    }
+    if (reservedSlashCommandNames.has(registration.name)) {
+      throw new FlexHarnessValidationError(
+        `Slash command "${registration.name}" is reserved.`,
+      );
+    }
+    if (normalized.has(registration.name)) {
+      throw new FlexHarnessValidationError(`Duplicate slash command "${registration.name}".`);
+    }
+    if (registration.description !== undefined) {
+      validateUtf8String(
+        registration.description,
+        `slashCommands[${index}].description`,
+        maxSlashCommandDescriptionBytes,
+        true,
+      );
+    }
+    if (hasTemplate) {
+      const template = registration.template;
+      validateUtf8String(
+        template,
+        `slashCommands[${index}].template`,
+        maxSlashCommandTemplateBytes,
+        true,
+      );
+      normalized.set(registration.name, Object.freeze({
+        name: registration.name,
+        ...(registration.description === undefined
+          ? {}
+          : { description: registration.description }),
+        template,
+      }));
+    } else {
+      const handler = registration.handler;
+      if (typeof handler !== 'function') {
+        throw new FlexHarnessValidationError(`slashCommands[${index}].handler must be a function.`);
+      }
+      normalized.set(registration.name, Object.freeze({
+        name: registration.name,
+        ...(registration.description === undefined
+          ? {}
+          : { description: registration.description }),
+        handler,
+      }));
+    }
+  }
+  return Object.freeze(normalized);
+}
+
 function resolveBoundedPositiveInteger(
   value: number | undefined,
   name: string,
@@ -833,6 +1020,31 @@ function validatePromptOptions(options: IFlexPromptOptions, scheduled: boolean):
   }
 }
 
+function validateSlashCommandExecutionOptions(
+  options: IFlexSlashCommandExecutionOptions,
+): IFlexPromptOptions {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new FlexHarnessValidationError('Slash command execution options must be a plain object.');
+  }
+  const unsupported = Object.keys(options)
+    .find((key) => !['modelHint', 'system', 'maxSteps', 'signal'].includes(key));
+  if (unsupported) {
+    throw new FlexHarnessValidationError(
+      `Slash command execution options do not support "${unsupported}".`,
+    );
+  }
+  if (options.signal !== undefined && !(options.signal instanceof AbortSignal)) {
+    throw new FlexHarnessValidationError('Slash command signal must be an AbortSignal.');
+  }
+  const promptOptions: IFlexPromptOptions = {
+    ...(options.modelHint === undefined ? {} : { modelHint: options.modelHint }),
+    ...(options.system === undefined ? {} : { system: options.system }),
+    ...(options.maxSteps === undefined ? {} : { maxSteps: options.maxSteps }),
+  };
+  validatePromptOptions(promptOptions, false);
+  return promptOptions;
+}
+
 function resolveCallbackLimits(limits: IFlexCallbackLimits = {}): Required<IFlexCallbackLimits> {
   const resolved = {
     maxEvents: limits.maxEvents ?? DEFAULT_CALLBACK_LIMITS.maxEvents,
@@ -870,6 +1082,27 @@ function resolvePromptQueueLimits(
   return resolved;
 }
 
+function resolveReversionLimits(
+  limits: IFlexReversionLimits = {},
+): Required<IFlexReversionLimits> {
+  const resolved = {
+    maxCompletedTurns: limits.maxCompletedTurns ?? FLEX_REVERSION_DEFAULT_LIMITS.maxCompletedTurns,
+    maxSegments: limits.maxSegments ?? FLEX_REVERSION_DEFAULT_LIMITS.maxSegments,
+    maxExcludedRunIds: limits.maxExcludedRunIds ?? FLEX_REVERSION_DEFAULT_LIMITS.maxExcludedRunIds,
+    maxPendingReversionReleases: limits.maxPendingReversionReleases
+      ?? FLEX_REVERSION_DEFAULT_LIMITS.maxPendingReversionReleases,
+  };
+  for (const [name, value] of Object.entries(resolved)) {
+    const maximum = FLEX_REVERSION_MAXIMUM_LIMITS[name as keyof IFlexReversionLimits];
+    if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
+      throw new FlexHarnessValidationError(
+        `reversionLimits.${name} must be an integer from 1 through ${maximum}.`,
+      );
+    }
+  }
+  return resolved;
+}
+
 function normalizeAgentSessionPolicy<TScope>(
   policy: IFlexAgentSessionPolicy<TScope> = {},
 ): IFlexAgentSessionPolicy<TScope> {
@@ -906,8 +1139,12 @@ export class FlexHarness<TScope = unknown> {
   private readonly toolOutputLimits: Required<NonNullable<IFlexHarnessOptions<TScope>['toolOutputLimits']>>;
   private readonly callbackLimits: Required<IFlexCallbackLimits>;
   private readonly promptQueueLimits: Required<IFlexPromptQueueLimits>;
+  private readonly reversionLimits: Required<IFlexReversionLimits>;
+  private readonly turnReversionProvider: IFlexHarnessOptions<TScope>['turnReversionProvider'];
+  private readonly reversionPolicy: TFlexReversionPolicy;
   private readonly externalErrorProjector?: TFlexExternalErrorProjector;
   private readonly subagents: ReadonlyMap<string, Readonly<IFlexSubagentDefinition>>;
+  private readonly slashCommands: ReadonlyMap<string, TRegisteredSlashCommand<TScope>>;
   private readonly maxSubagentDepth: number;
   private readonly maxSubagentCallsPerRun: number;
   private readonly stateLoads = new Map<string, Promise<IStorageState>>();
@@ -925,10 +1162,19 @@ export class FlexHarness<TScope = unknown> {
   >();
   private readonly orphanedProviderReleases = new Map<string, IOrphanedProviderRelease>();
   private readonly orphanedTombstoneCleanups = new Map<string, IOrphanedTombstoneCleanup>();
+  private readonly orphanedTombstoneOwners = new Map<string, IOrphanedTombstoneOwner<TScope>>();
   private readonly pendingPromptAdmissionOwners = new Set<IPendingPromptAdmission>();
+  private readonly activeSlashCommandExecutions = new Map<string, IActiveSlashCommandExecution>();
+  private readonly activeSlashCommandListings = new Set<IActiveSlashCommandListing>();
   private readonly compactorInvocationContext = new plugins.AsyncLocalStorage<
     IFlexAgentContextInvocation<TScope>
   >();
+  private readonly slashCommandInvocationContext = new plugins.AsyncLocalStorage<
+    ISlashCommandInvocationOwner
+  >();
+  private readonly slashCommandActivityContext = new plugins.AsyncLocalStorage<
+    ISlashCommandActivityOwner
+  >();
   private readonly deferredCompactorContexts = new WeakMap<
     IFlexAgentContextInvocation<unknown>,
     IFlexAgentContextInvocation<unknown>
@@ -954,8 +1200,29 @@ export class FlexHarness<TScope = unknown> {
     this.toolOutputLimits = resolveJsonLimits(options.toolOutputLimits);
     this.callbackLimits = resolveCallbackLimits(options.callbackLimits);
     this.promptQueueLimits = resolvePromptQueueLimits(options.promptQueueLimits);
+    this.reversionLimits = resolveReversionLimits(options.reversionLimits);
+    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.slashCommands = normalizeSlashCommands(options.slashCommands);
     this.maxSubagentDepth = resolveBoundedPositiveInteger(
       options.maxSubagentDepth,
       'maxSubagentDepth',
@@ -973,6 +1240,7 @@ export class FlexHarness<TScope = unknown> {
   public async listSessions(scopeId: string): Promise<IFlexSession[]> {
     const { state } = await this.resolveState(scopeId);
     await state.scopeQueue;
+    this.assertOpen();
     this.assertStateAcceptingWork(state);
     return publicSnapshot([...state.sessions.values()]
       .filter((stored) => !state.initializingSessions.has(stored.session.sessionId))
@@ -1139,6 +1407,41 @@ export class FlexHarness<TScope = unknown> {
     return publicSnapshot(this.requireSession(state, sessionId).session);
   }
 
+  public async getSessionReversionInfo(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexSessionReversionInfo> {
+    const { state } = await this.resolveState(scopeId);
+    const stored = this.requireSession(state, sessionId);
+    await stored.projectionQueue;
+    this.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: ReturnType<typeof this.reversionUnit>) => 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): IFlexSessionReversionGroup => ({
+        runId: group.target.runId,
+        kind: group.kind,
+        visibility: index < stored.revertCursor ? 'visible' : 'hidden',
+        affectedWorkspaces: cloneSerializable(group.affectedWorkspaces),
+        affectedWorkspacesTruncated: group.affectedWorkspacesTruncated,
+      })),
+    });
+  }
+
   public async updateSession(
     scopeId: string,
     sessionId: string,
@@ -1166,7 +1469,9 @@ export class FlexHarness<TScope = unknown> {
   }
 
   public async deleteSession(scopeId: string, sessionId: string): Promise<void> {
+    this.assertNoAmbientSlashCommandTeardown({ scopeId, sessionId });
     const { scope, state } = await this.resolveState(scopeId);
+    this.assertNoAmbientSlashCommandTeardown({ storageKey: state.storageKey });
     validateIdentifier(sessionId, 'sessionId');
     await state.scopeQueue;
     const deletionKey = state.tombstones.get(sessionId)?.rootSessionId ?? sessionId;
@@ -1241,6 +1546,21 @@ export class FlexHarness<TScope = unknown> {
       }
     });
     const reason = this.trustInternalError(new FlexHarnessAbortError('The session subtree was deleted.'));
+    const slashCommandErrors: unknown[] = [];
+    for (const deleted of deletedSessions) {
+      const listingSettlement = this.abortSlashCommandListings(
+        state.storageKey,
+        reason,
+        deleted.sessionId,
+      );
+      if (listingSettlement) await listingSettlement;
+      await this.abortSlashCommandExecutions(
+        state.storageKey,
+        reason,
+        slashCommandErrors,
+        deleted.sessionId,
+      );
+    }
     const childFirstDeletedSessions = [...deletedSessions].sort((left, right) =>
       (right.depth ?? 0) - (left.depth ?? 0)
       || left.sessionId.localeCompare(right.sessionId));
@@ -1255,7 +1575,10 @@ export class FlexHarness<TScope = unknown> {
       }
     }
     try {
-      const orphanErrors = await this.closeOrphanedResources(state.storageKey);
+      const orphanErrors = [
+        ...slashCommandErrors,
+        ...await this.closeOrphanedResources(state.storageKey),
+      ];
       if (orphanErrors.length > 0) throw combineErrors(orphanErrors);
       for (const descendantRoot of descendantRoots) {
         await this.finishTombstoneCleanup(
@@ -1282,7 +1605,7 @@ export class FlexHarness<TScope = unknown> {
     const stored = this.requireSession(state, sessionId);
     await stored.projectionQueue;
     this.assertStateAcceptingWork(state);
-    return publicSnapshot(stored.messages);
+    return publicSnapshot(this.visibleMessages(stored));
   }
 
   public async listMessagePage(
@@ -1312,20 +1635,21 @@ export class FlexHarness<TScope = unknown> {
     await stored.projectionQueue;
     this.assertStateAcceptingWork(state);
     const namespace = this.messageCursorNamespace(state.storageKey);
-    let end = stored.messages.length;
+    const visibleMessages = this.visibleMessages(stored);
+    let end = visibleMessages.length;
     if (options.before !== undefined) {
       const cursor = this.parseMessageCursor(options.before);
       if (cursor.namespace !== namespace || cursor.sessionId !== sessionId) {
         throw new FlexHarnessValidationError('Message page cursor is invalid.');
       }
-      const anchor = stored.messages.findIndex((message) => message.messageId === cursor.anchorMessageId);
+      const anchor = visibleMessages.findIndex((message) => message.messageId === cursor.anchorMessageId);
       if (anchor < 0) throw new FlexHarnessValidationError('Message page cursor is stale.');
       end = anchor;
     }
     let start = end;
     let messages: IFlexMessage[] = [];
     for (let index = end - 1; index >= 0 && messages.length < limit; index--) {
-      const candidate = createBoundedTransferMessage(stored.messages[index]);
+      const candidate = createBoundedTransferMessage(visibleMessages[index]);
       const candidateMessages = [candidate, ...messages];
       const nextCursor = index > 0
         ? this.createMessageCursor(namespace, sessionId, candidate.messageId)
@@ -1357,88 +1681,624 @@ export class FlexHarness<TScope = unknown> {
     return publicSnapshot(createBoundedTransferMessage(this.requireMessage(stored, messageId)));
   }
 
-  public async prompt(
-    scopeId: string,
-    sessionId: string,
-    prompt: TFlexPrompt,
-    options: IFlexPromptOptions = {},
-  ): Promise<IFlexPromptResult> {
-    const admission = await this.startPrompt(scopeId, sessionId, prompt, options);
-    return admission.completion;
-  }
-
-  public async startPrompt(
+  public async listSlashCommands(
     scopeId: string,
     sessionId: string,
-    prompt: TFlexPrompt,
-    options: IFlexPromptOptions = {},
-  ): Promise<IFlexPromptAdmission> {
-    validatePromptOptions(options, false);
-    const queued = await this.enqueuePromptInternal(scopeId, sessionId, prompt, options);
-    return queued.started;
+  ): Promise<IFlexSlashCommandDescriptor[]> {
+    const { state } = await this.resolveState(scopeId);
+    return this.trackSlashCommandListing(scopeId, state, sessionId, async (signal) => {
+      await this.awaitReversionOperation(state.scopeQueue, signal);
+      signal.throwIfAborted();
+      this.assertStateAcceptingWork(state);
+      const stored = this.requireSession(state, sessionId);
+      await this.reconcileContextAvailability(state, stored);
+      signal.throwIfAborted();
+      const sessionAvailable = this.isSessionAvailableForSlashCommand(state, stored);
+      const reversionIdleReason = await this.reversionUnavailableReason(
+        state,
+        stored,
+        false,
+        signal,
+      );
+      signal.throwIfAborted();
+      return this.createSlashCommandDescriptors(
+        state,
+        stored,
+        sessionAvailable,
+        reversionIdleReason,
+      );
+    });
   }
 
-  public async enqueuePrompt(
-    scopeId: string,
-    sessionId: string,
-    prompt: TFlexPrompt,
-    options: IFlexPromptOptions = {},
-  ): Promise<IFlexPromptQueueAdmission> {
-    validatePromptOptions(options, false);
-    const queued = await this.enqueuePromptInternal(scopeId, sessionId, prompt, options);
-    return queued.admission;
+  private createSlashCommandDescriptors(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    sessionAvailable: boolean,
+    reversionIdleReason?: string,
+  ): IFlexSlashCommandDescriptor[] {
+    const sessionAvailability = sessionAvailable
+      ? {}
+      : { available: false, unavailableReason: slashCommandSessionUnavailableReason };
+    const undoUnit = this.reversionUnit(stored, 'undo');
+    const redoUnit = this.reversionUnit(stored, 'redo');
+    const workspaceReversion = (unit: ReturnType<typeof this.reversionUnit>) =>
+      !unit
+      || !this.turnReversionProvider
+      || unit.segments.some((segment) => segment.provenance !== 'workspace')
+        ? 'unsupported' as const
+        : 'supported' as const;
+    const reversionAvailability = (unit: ReturnType<typeof this.reversionUnit>) => {
+      if (reversionIdleReason) return {
+        available: false,
+        unavailableReason: reversionIdleReason,
+      };
+      if (!unit) return { available: false, unavailableReason: 'No turn is available.' };
+      if (!unit.target.contextAvailable) return {
+        available: false,
+        unavailableReason: 'The turn is beyond the context archive horizon.',
+      };
+      if (unit.segments.some((segment) =>
+        segment.disposition === 'revertible' && segment.workspaceReference === undefined)) return {
+        available: false,
+        unavailableReason: 'The turn has no available workspace reversion capture.',
+      };
+      return { available: true };
+    };
+    const compactAvailable = Boolean(this.agentSessionPolicy.contextCompactor) && sessionAvailable;
+    const compactUnavailableReason = !this.agentSessionPolicy.contextCompactor
+      ? 'No context compactor is configured.'
+      : !sessionAvailable
+        ? slashCommandSessionUnavailableReason
+        : undefined;
+    const initPrompt = expandSlashCommandTemplate(FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE, '', []);
+    const initAvailability = this.slashCommandPromptAvailability(
+      state,
+      stored,
+      this.promptAdmissionByteSize(initPrompt, {}),
+    );
+    const descriptors: IFlexSlashCommandDescriptor[] = [
+      {
+        name: 'compact',
+        description: 'Compact the current session context.',
+        kind: 'builtin',
+        hints: [],
+        available: compactAvailable,
+        ...(compactUnavailableReason === undefined
+          ? {}
+          : { unavailableReason: compactUnavailableReason }),
+        workspaceReversion: 'not-applicable',
+      },
+      {
+        name: 'init',
+        description: 'Create or update AGENTS.md for the active workspace.',
+        kind: 'builtin',
+        hints: ['$ARGUMENTS'],
+        ...initAvailability,
+        workspaceReversion: 'not-applicable',
+      },
+      {
+        name: 'undo',
+        description: 'Undo the most recent session operation.',
+        kind: 'builtin',
+        hints: [],
+        ...reversionAvailability(undoUnit),
+        workspaceReversion: workspaceReversion(undoUnit),
+      },
+      {
+        name: 'redo',
+        description: 'Redo the most recently undone session operation.',
+        kind: 'builtin',
+        hints: [],
+        ...reversionAvailability(redoUnit),
+        workspaceReversion: workspaceReversion(redoUnit),
+      },
+    ];
+    for (const registration of this.slashCommands.values()) {
+      const template = typeof registration.template === 'string';
+      const availability = template
+        ? this.slashCommandPromptAvailability(
+            state,
+            stored,
+            this.promptAdmissionByteSize(
+              expandSlashCommandTemplate(registration.template!, '', []),
+              {},
+            ),
+          )
+        : { available: sessionAvailable, ...sessionAvailability };
+      descriptors.push({
+        name: registration.name,
+        description: registration.description ?? '',
+        kind: template ? 'template' : 'handler',
+        hints: template ? slashCommandTemplateHints(registration.template!) : [],
+        ...availability,
+        workspaceReversion: 'not-applicable',
+      });
+    }
+    return publicSnapshot(descriptors);
   }
 
-  public async schedulePrompt(
+  public async executeSlashCommand(
     scopeId: string,
     sessionId: string,
-    scheduleKey: string,
-    prompt: TFlexPrompt,
-    options: IFlexSchedulePromptOptions = {},
-  ): Promise<IFlexScheduledPromptAdmission> {
-    validateIdentifier(scheduleKey, 'scheduleKey');
-    requireTransferIdentifier(scheduleKey, 'scheduleKey');
-    validatePromptOptions(options, true);
-    const debounceMs = options.debounceMs ?? 50;
-    if (!Number.isSafeInteger(debounceMs) || debounceMs < 0 || debounceMs > maxScheduleDebounceMs) {
-      throw new FlexHarnessValidationError(
-        `debounceMs must be an integer from 0 through ${maxScheduleDebounceMs}.`,
+    untouchedInput: string,
+    options: IFlexSlashCommandExecutionOptions = {},
+  ): Promise<TFlexSlashCommandExecutionResult> {
+    const currentInvocation = this.slashCommandInvocationContext.getStore();
+    if (currentInvocation?.scopeId === scopeId && currentInvocation.sessionId === sessionId) {
+      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+    }
+    const parsed = parseSlashCommand(untouchedInput);
+    if (parsed.type !== 'parsed') return parsed;
+    const registration = this.slashCommands.get(parsed.name);
+    if (!reservedSlashCommandNames.has(parsed.name) && !registration) {
+      return Object.freeze({
+        type: 'unknown',
+        input: parsed.input,
+        name: parsed.name,
+        rawArguments: parsed.rawArguments,
+        arguments: parsed.arguments,
+      });
+    }
+    const promptOptions = validateSlashCommandExecutionOptions(options);
+    const { scope, state } = await this.resolveState(scopeId);
+    await state.scopeQueue;
+    this.assertOpen();
+    this.assertStateAcceptingWork(state);
+    const stored = this.requireSession(state, sessionId);
+    const sessionKey = this.slashCommandSessionKey(state.storageKey, sessionId);
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner?.sessionKey === sessionKey) {
+      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+    }
+    if (this.activeSlashCommandExecutions.has(sessionKey)) {
+      throw new FlexHarnessSessionBusyError(
+        sessionId,
+        'already has an active slash command execution',
       );
     }
-    const queued = await this.enqueuePromptInternal(
+    if (parsed.name === 'undo' || parsed.name === 'redo') {
+      if (parsed.arguments.length > 0) {
+        throw new FlexHarnessValidationError(`Slash command "/${parsed.name}" does not accept arguments.`);
+      }
+      await this.changeReversionCursorResolved(
+        scopeId,
+        sessionId,
+        parsed.name,
+        scope.scope,
+        state,
+        options.signal,
+      );
+      return Object.freeze({ type: 'operation', name: parsed.name });
+    }
+    if (parsed.name === 'compact') {
+      if (parsed.arguments.length > 0) {
+        throw new FlexHarnessValidationError('Slash command "/compact" does not accept arguments.');
+      }
+      if (!this.agentSessionPolicy.contextCompactor) {
+        throw new FlexHarnessSlashCommandUnavailableError(
+          parsed.name,
+          'No context compactor is configured.',
+        );
+      }
+      this.requireSessionAvailableForSlashCommand(state, stored, parsed.name);
+      return this.trackSlashCommandExecution(
+        scopeId,
+        state,
+        sessionId,
+        'operation',
+        options.signal,
+        async (signal) => {
+          await this.commitRevertedBranch(state, stored, scopeId, scope.scope);
+          await this.compactStoredSession(scopeId, scope.scope, state, stored, signal);
+          return Object.freeze({ type: 'operation', name: parsed.name });
+        },
+      );
+    }
+    if (options.signal?.aborted) {
+      throw this.trustInternalError(new FlexHarnessAbortError('The slash command was aborted.'));
+    }
+      if (parsed.name === 'init' || typeof registration?.template === 'string') {
+      const template = parsed.name === 'init'
+        ? FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE
+        : registration!.template!;
+      const expanded = expandSlashCommandTemplate(template, parsed.rawArguments, parsed.arguments);
+      normalizeFlexPrompt(expanded);
+      this.requireSlashCommandPromptAvailable(
+        state,
+        stored,
+        parsed.name,
+        this.promptAdmissionByteSize(expanded, promptOptions),
+      );
+      return this.trackSlashCommandExecution(
+        scopeId,
+        state,
+        sessionId,
+        'prompt-admission',
+        options.signal,
+        async (signal) => {
+          const queued = await this.enqueuePromptInternal(
+            scopeId,
+            sessionId,
+            expanded,
+            promptOptions,
+            undefined,
+            undefined,
+            false,
+            signal,
+            true,
+          );
+          const cancellation = this.trustInternalError(
+            new FlexHarnessAbortError('The slash command prompt was aborted.'),
+          );
+          const cancel = () => {
+            const entry = queued.queued;
+            if (!entry) return;
+            this.cancelQueuedPrompt(
+              entry,
+              cancellation,
+              this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
+            );
+          };
+          const cancellationSignals = options.signal && options.signal !== signal
+            ? [signal, options.signal]
+            : [signal];
+          for (const cancellationSignal of cancellationSignals) {
+            cancellationSignal.addEventListener('abort', cancel, { once: true });
+          }
+          if (cancellationSignals.some((cancellationSignal) => cancellationSignal.aborted)) cancel();
+          let admission: IFlexPromptAdmission;
+          try {
+            admission = await queued.started;
+            if (cancellationSignals.some((cancellationSignal) => cancellationSignal.aborted)) {
+              cancel();
+              throw cancellationSignals.find((cancellationSignal) => cancellationSignal.aborted)?.reason
+                ?? cancellation;
+            }
+          } catch (error) {
+            for (const cancellationSignal of cancellationSignals) {
+              cancellationSignal.removeEventListener('abort', cancel);
+            }
+            throw error;
+          }
+          void admission.completion.finally(() => {
+            for (const cancellationSignal of cancellationSignals) {
+              cancellationSignal.removeEventListener('abort', cancel);
+            }
+          }).catch(() => undefined);
+          return Object.freeze({ type: 'prompt-admission', name: parsed.name, admission });
+        },
+      );
+    }
+    this.requireSessionAvailableForSlashCommand(state, stored, parsed.name);
+    return this.executeSlashCommandHandler(
       scopeId,
-      sessionId,
-      prompt,
-      options,
-      scheduleKey,
-      debounceMs,
+      scope.scope,
+      state,
+      stored,
+      parsed.name,
+      parsed.rawArguments,
+      parsed.arguments,
+      registration!.handler!,
+      options.signal,
     );
-    const admission = await queued.started;
-    return Object.freeze({ ...admission, scheduleKey });
   }
 
-  public async getPromptQueueEntry(
-    scopeId: string,
-    sessionId: string,
-    queueId: string,
-  ): Promise<IFlexPromptQueueEntry> {
-    validateIdentifier(queueId, 'queueId');
-    requireTransferIdentifier(queueId, 'queueId');
-    const { state } = await this.resolveState(scopeId);
-    this.assertStateAcceptingWork(state);
-    const stored = this.requireSession(state, sessionId);
-    const entry = this.promptQueueEntry(stored, queueId);
-    if (!entry) throw new FlexHarnessNotFoundError('Prompt queue entry', queueId);
-    return publicSnapshot(entry);
+  private isSessionAvailableForSlashCommand(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    allowPendingApply = false,
+  ): boolean {
+    return this.isSessionRuntimeIdle(state, stored)
+      && !this.activeSlashCommandExecutions.has(
+        this.slashCommandSessionKey(state.storageKey, stored.session.sessionId),
+      )
+      && (stored.pendingReversion === undefined
+        || (allowPendingApply && stored.pendingReversion.kind === 'apply'));
   }
 
-  public async listPromptQueueEntries(
-    scopeId: string,
-    sessionId: string,
-  ): Promise<IFlexPromptQueueEntry[]> {
-    const { state } = await this.resolveState(scopeId);
-    this.assertStateAcceptingWork(state);
-    const stored = this.requireSession(state, sessionId);
+  private slashCommandPromptUnavailableReason(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    byteSize: number,
+  ): string | undefined {
+    if (state.lifecycle !== 'active') return 'The session namespace is not accepting work.';
+    if (this.activeSlashCommandExecutions.has(
+      this.slashCommandSessionKey(state.storageKey, stored.session.sessionId),
+    )) return 'Session already has an active slash command execution.';
+    if (stored.pendingReversion) return 'Session has a pending reversion operation.';
+    if (stored.session.agent !== undefined) {
+      return 'Subagent sessions can only be prompted through the foreground task tool.';
+    }
+    if (stored.outstandingPromptsById.size >= this.promptQueueLimits.maxOutstandingPromptsPerSession) {
+      return 'Session has reached its outstanding prompt limit.';
+    }
+    if (stored.outstandingPromptBytes + byteSize > this.promptQueueLimits.maxOutstandingBytesPerSession) {
+      return 'Session has reached its outstanding prompt byte limit.';
+    }
+    if (this.pendingPromptAdmissions >= this.promptQueueLimits.maxPendingAdmissions) {
+      return 'FlexHarness has reached its pending prompt admission limit.';
+    }
+    if (this.pendingPromptAdmissionBytes + byteSize > this.promptQueueLimits.maxPendingAdmissionBytes) {
+      return 'FlexHarness has reached its pending prompt admission byte limit.';
+    }
+    return undefined;
+  }
+
+  private slashCommandPromptAvailability(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    byteSize: number,
+  ): { available: boolean; unavailableReason?: string } {
+    const unavailableReason = this.slashCommandPromptUnavailableReason(state, stored, byteSize);
+    return unavailableReason === undefined
+      ? { available: true }
+      : { available: false, unavailableReason };
+  }
+
+  private requireSlashCommandPromptAvailable(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    commandName: string,
+    byteSize: number,
+  ): void {
+    const reason = this.slashCommandPromptUnavailableReason(state, stored, byteSize);
+    if (reason) throw new FlexHarnessSlashCommandUnavailableError(commandName, reason);
+  }
+
+  private promptAdmissionByteSize(
+    prompt: TFlexPrompt,
+    options: IFlexPromptOptions,
+    scheduleKey?: string,
+    debounceMs?: number,
+  ): number {
+    return jsonBytes({
+      prompt: normalizeFlexPrompt(prompt),
+      options: cloneSerializable(options),
+      scheduleKey,
+      debounceMs,
+    });
+  }
+
+  private isSessionRuntimeIdle(state: IStorageState, stored: IStoredSessionState): boolean {
+    return stored.session.status === 'idle'
+      && !state.activeRuns.has(stored.session.sessionId)
+      && stored.outstandingPromptsById.size === 0;
+  }
+
+  private slashCommandSessionKey(storageKey: string, sessionId: string): string {
+    return JSON.stringify([storageKey, sessionId]);
+  }
+
+  private requireSessionAvailableForSlashCommand(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    commandName: string,
+  ): void {
+    if (!this.isSessionAvailableForSlashCommand(state, stored)) {
+      throw new FlexHarnessSlashCommandUnavailableError(
+        commandName,
+        slashCommandSessionUnavailableReason,
+      );
+    }
+  }
+
+  private trackSlashCommandExecution<TResult>(
+    scopeId: string,
+    state: IStorageState,
+    sessionId: string,
+    kind: IActiveSlashCommandExecution['kind'],
+    externalSignal: AbortSignal | undefined,
+    operation: (signal: AbortSignal) => Promise<TResult>,
+  ): Promise<TResult> {
+    const sessionKey = this.slashCommandSessionKey(state.storageKey, sessionId);
+    if (this.activeSlashCommandExecutions.has(sessionKey)) {
+      throw new FlexHarnessSessionBusyError(
+        sessionId,
+        'already has an active slash command execution',
+      );
+    }
+    const controller = new AbortController();
+    const abortFromExternalSignal = () => {
+      if (!controller.signal.aborted) {
+        controller.abort(this.trustInternalError(
+          new FlexHarnessAbortError('The slash command was aborted.'),
+        ));
+      }
+    };
+    externalSignal?.addEventListener('abort', abortFromExternalSignal, { once: true });
+    if (externalSignal?.aborted) abortFromExternalSignal();
+    const activityOwner = Object.freeze({ scopeId, storageKey: state.storageKey, sessionId });
+    const completion = Promise.resolve().then(() => this.slashCommandActivityContext.run(activityOwner, () => {
+      if (controller.signal.aborted) throw controller.signal.reason;
+      return operation(controller.signal);
+    }));
+    const active: IActiveSlashCommandExecution = {
+      kind,
+      storageKey: state.storageKey,
+      sessionId,
+      controller,
+      completion,
+    };
+    this.activeSlashCommandExecutions.set(sessionKey, active);
+    return completion.finally(() => {
+      externalSignal?.removeEventListener('abort', abortFromExternalSignal);
+      if (this.activeSlashCommandExecutions.get(sessionKey) === active) {
+        this.activeSlashCommandExecutions.delete(sessionKey);
+      }
+    });
+  }
+
+  private trackSlashCommandListing<TResult>(
+    scopeId: string,
+    state: IStorageState,
+    sessionId: string,
+    operation: (signal: AbortSignal) => Promise<TResult>,
+  ): Promise<TResult> {
+    const controller = new AbortController();
+    const activityOwner = Object.freeze({ scopeId, storageKey: state.storageKey, sessionId });
+    const completion = Promise.resolve().then(() =>
+      this.slashCommandActivityContext.run(activityOwner, () => operation(controller.signal)));
+    const active: IActiveSlashCommandListing = {
+      storageKey: state.storageKey,
+      sessionId,
+      controller,
+      completion,
+    };
+    this.activeSlashCommandListings.add(active);
+    return completion.finally(() => {
+      this.activeSlashCommandListings.delete(active);
+    });
+  }
+
+  private async executeSlashCommandHandler(
+    scopeId: string,
+    scope: TScope,
+    state: IStorageState,
+    stored: IStoredSessionState,
+    commandName: string,
+    rawArguments: string,
+    arguments_: readonly string[],
+    handler: IFlexSlashCommandHandlerRegistration<TScope>['handler'],
+    externalSignal?: AbortSignal,
+  ): Promise<TFlexSlashCommandExecutionResult> {
+    const sessionKey = this.slashCommandSessionKey(state.storageKey, stored.session.sessionId);
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner?.sessionKey === sessionKey) {
+      throw this.trustInternalError(
+        new FlexHarnessSlashCommandReentryError(stored.session.sessionId),
+      );
+    }
+    if (this.activeSlashCommandExecutions.has(sessionKey)) {
+      throw new FlexHarnessSessionBusyError(
+        stored.session.sessionId,
+        'already has an active slash command execution',
+      );
+    }
+    const owner = Object.freeze({
+      scopeId,
+      storageKey: state.storageKey,
+      sessionId: stored.session.sessionId,
+      sessionKey,
+    });
+    return this.trackSlashCommandExecution(
+      scopeId,
+      state,
+      stored.session.sessionId,
+      'handler',
+      externalSignal,
+      (signal) => this.slashCommandInvocationContext.run(owner, async () => {
+        const context = Object.freeze({
+          scopeId,
+          scope,
+          storageKey: state.storageKey,
+          sessionId: stored.session.sessionId,
+          rawArguments,
+          arguments: arguments_,
+          signal,
+        });
+        try {
+          await this.commitRevertedBranch(state, stored, scopeId, scope);
+          const result = await handler(context);
+          return Object.freeze({
+            type: 'handler-result' as const,
+            name: commandName,
+            result: normalizeJsonValue(result === undefined ? null : result, this.toolOutputLimits),
+          });
+        } catch (error) {
+          throw this.projectOperationError(
+            error,
+            'slashCommand',
+            scopeId,
+            stored.session.sessionId,
+            `slash-command:${commandName}`,
+          );
+        }
+      }),
+    );
+  }
+
+  public async prompt(
+    scopeId: string,
+    sessionId: string,
+    prompt: TFlexPrompt,
+    options: IFlexPromptOptions = {},
+  ): Promise<IFlexPromptResult> {
+    const admission = await this.startPrompt(scopeId, sessionId, prompt, options);
+    return admission.completion;
+  }
+
+  public async startPrompt(
+    scopeId: string,
+    sessionId: string,
+    prompt: TFlexPrompt,
+    options: IFlexPromptOptions = {},
+  ): Promise<IFlexPromptAdmission> {
+    validatePromptOptions(options, false);
+    const queued = await this.enqueuePromptInternal(scopeId, sessionId, prompt, options);
+    return queued.started;
+  }
+
+  public async enqueuePrompt(
+    scopeId: string,
+    sessionId: string,
+    prompt: TFlexPrompt,
+    options: IFlexPromptOptions = {},
+  ): Promise<IFlexPromptQueueAdmission> {
+    validatePromptOptions(options, false);
+    const queued = await this.enqueuePromptInternal(scopeId, sessionId, prompt, options);
+    return queued.admission;
+  }
+
+  public async schedulePrompt(
+    scopeId: string,
+    sessionId: string,
+    scheduleKey: string,
+    prompt: TFlexPrompt,
+    options: IFlexSchedulePromptOptions = {},
+  ): Promise<IFlexScheduledPromptAdmission> {
+    validateIdentifier(scheduleKey, 'scheduleKey');
+    requireTransferIdentifier(scheduleKey, 'scheduleKey');
+    validatePromptOptions(options, true);
+    const debounceMs = options.debounceMs ?? 50;
+    if (!Number.isSafeInteger(debounceMs) || debounceMs < 0 || debounceMs > maxScheduleDebounceMs) {
+      throw new FlexHarnessValidationError(
+        `debounceMs must be an integer from 0 through ${maxScheduleDebounceMs}.`,
+      );
+    }
+    const queued = await this.enqueuePromptInternal(
+      scopeId,
+      sessionId,
+      prompt,
+      options,
+      scheduleKey,
+      debounceMs,
+    );
+    const admission = await queued.started;
+    return Object.freeze({ ...admission, scheduleKey });
+  }
+
+  public async getPromptQueueEntry(
+    scopeId: string,
+    sessionId: string,
+    queueId: string,
+  ): Promise<IFlexPromptQueueEntry> {
+    validateIdentifier(queueId, 'queueId');
+    requireTransferIdentifier(queueId, 'queueId');
+    const { state } = await this.resolveState(scopeId);
+    this.assertStateAcceptingWork(state);
+    const stored = this.requireSession(state, sessionId);
+    const entry = this.promptQueueEntry(stored, queueId);
+    if (!entry) throw new FlexHarnessNotFoundError('Prompt queue entry', queueId);
+    return publicSnapshot(entry);
+  }
+
+  public async listPromptQueueEntries(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexPromptQueueEntry[]> {
+    const { state } = await this.resolveState(scopeId);
+    this.assertStateAcceptingWork(state);
+    const stored = this.requireSession(state, sessionId);
     return publicSnapshot([
       ...[...stored.outstandingPromptsById.values()].map((entry) => this.projectPromptQueueEntry(entry)),
       ...stored.terminalPromptQueueEntries.values(),
@@ -1618,90 +2478,692 @@ export class FlexHarness<TScope = unknown> {
   public async compactSession(scopeId: string, sessionId: string): Promise<void> {
     const { scope, state } = await this.resolveState(scopeId);
     const stored = this.requireSession(state, sessionId);
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner?.sessionKey === this.slashCommandSessionKey(state.storageKey, sessionId)) {
+      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+    }
     this.assertStateAcceptingWork(state);
-    try {
-      await this.withCompactorContext(
-        this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
-        () => stored.agentSession.compact(),
+    if (!this.agentSessionPolicy.contextCompactor) {
+      throw new FlexHarnessSlashCommandUnavailableError(
+        'compact',
+        'No context compactor is configured.',
       );
-    } catch (error) {
-      throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'compaction');
     }
+    this.requireSessionAvailableForSlashCommand(state, stored, 'compact');
+    await this.trackSlashCommandExecution(
+      scopeId,
+      state,
+      sessionId,
+      'operation',
+      undefined,
+      async (signal) => {
+        await this.commitRevertedBranch(state, stored, scopeId, scope.scope);
+        await this.compactStoredSession(scopeId, scope.scope, state, stored, signal);
+      },
+    );
   }
 
-  public async archiveSessionEvents(
+  private async compactStoredSession(
     scopeId: string,
-    sessionId: string,
-    compactionEventId?: string,
-  ): Promise<IFlexEventArchiveMetadata | undefined> {
-    if (compactionEventId !== undefined) {
-      validateIdentifier(compactionEventId, 'compactionEventId');
-      requireTransferIdentifier(compactionEventId, 'compactionEventId');
-    }
-    const { state } = await this.resolveState(scopeId);
-    const stored = this.requireSession(state, sessionId);
-    this.assertStateAcceptingWork(state);
+    scope: TScope,
+    state: IStorageState,
+    stored: IStoredSessionState,
+    signal?: AbortSignal,
+  ): Promise<void> {
     try {
-      const archive = await stored.agentSession.archiveCompactedEvents(compactionEventId);
-      if (!archive) return undefined;
-      return publicSnapshot({
-        archiveId: this.boundedIdentifier(archive.archiveId, 'archiveId'),
-        sessionId: this.boundedIdentifier(archive.sessionId, 'sessionId'),
-        createdAt: new Date(archive.createdAt).toISOString(),
-        eventCount: archive.events.length,
-      });
+      await this.withCompactorContext(
+        this.createCompactorContext(
+          scopeId,
+          scope,
+          state.storageKey,
+          stored.session.sessionId,
+        ),
+        () => stored.agentSession.compact(signal === undefined ? {} : { abort: signal }),
+      );
     } catch (error) {
-      throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'archive');
+      throw this.projectOperationError(
+        error,
+        'agentSession',
+        scopeId,
+        stored.session.sessionId,
+        'compaction',
+      );
     }
   }
 
-  public async listBackgroundExecutions(
+  public async undoSession(
     scopeId: string,
     sessionId: string,
-  ): Promise<IFlexBackgroundExecution[]> {
-    const { state } = await this.resolveState(scopeId);
-    const stored = this.requireSession(state, sessionId);
-    this.assertStateAcceptingWork(state);
-    if (!stored.jobs) return [];
-    try {
-      const jobs = await stored.jobs.list();
-      return publicSnapshot(jobs
-        .sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))
-        .slice(0, maxBackgroundExecutions)
-        .map((job) => this.projectBackgroundExecution(job)));
-    } catch (error) {
-      throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'background-list');
-    }
+    signal?: AbortSignal,
+  ): Promise<IFlexUndoSessionResult> {
+    const result = await this.changeReversionCursor(scopeId, sessionId, 'undo', signal);
+    return Object.freeze({ revertedRunId: result });
   }
 
-  public async getBackgroundExecution(
+  public async redoSession(
     scopeId: string,
     sessionId: string,
-    executionId: string,
-  ): Promise<IFlexBackgroundExecution> {
-    validateIdentifier(executionId, 'executionId');
-    requireTransferIdentifier(executionId, 'executionId');
-    const { state } = await this.resolveState(scopeId);
-    const stored = this.requireSession(state, sessionId);
-    this.assertStateAcceptingWork(state);
-    try {
-      return publicSnapshot(this.projectBackgroundExecution(
-        await stored.agentSession.getBackgroundExecution(executionId),
-      ));
-    } catch (error) {
-      throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'background-get');
+    signal?: AbortSignal,
+  ): Promise<IFlexRedoSessionResult> {
+    const result = await this.changeReversionCursor(scopeId, sessionId, 'redo', signal);
+    return Object.freeze({ restoredRunId: result });
+  }
+
+  private reversionUnit(
+    stored: IStoredSessionState,
+    direction: 'undo' | 'redo',
+  ): { target: IFlexReversionSegment; segments: IFlexReversionSegment[]; toCursor: number } | undefined {
+    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,
+    };
   }
 
-  public async abortBackgroundExecution(
-    scopeId: string,
-    sessionId: string,
-    executionId: string,
-  ): Promise<void> {
-    validateIdentifier(executionId, 'executionId');
-    requireTransferIdentifier(executionId, 'executionId');
-    const { scope, state } = await this.resolveState(scopeId);
-    const stored = this.requireSession(state, sessionId);
+  private reversionGroups(stored: IStoredSessionState): IReversionGroup[] {
+    const groups: IReversionGroup[] = [];
+    let leading: IFlexReversionSegment[] = [];
+    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<string, IFlexAffectedWorkspace>();
+      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.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;
+  }
+
+  private async requireReversionIdle(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    sessionId: string,
+    allowPendingApply = false,
+    operationSignal?: AbortSignal,
+  ): Promise<void> {
+    const reason = await this.reversionUnavailableReason(
+      state,
+      stored,
+      allowPendingApply,
+      operationSignal,
+    );
+    if (reason) throw new FlexHarnessSessionBusyError(sessionId, reason.toLowerCase().replace(/\.$/u, ''));
+  }
+
+  private async reversionUnavailableReason(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    allowPendingApply = false,
+    operationSignal?: AbortSignal,
+  ): Promise<string | undefined> {
+    if (stored.pendingReversion && !(allowPendingApply && stored.pendingReversion.kind === 'apply')) {
+      return 'Session has a pending reversion operation.';
+    }
+    if (!this.isSessionRuntimeIdle(state, stored)) {
+      return slashCommandSessionUnavailableReason;
+    }
+    const activeOperation = this.activeSlashCommandExecutions.get(
+      this.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;
+  }
+
+  private async awaitReversionOperation<TResult>(
+    operation: Promise<TResult>,
+    signal?: AbortSignal,
+  ): Promise<TResult> {
+    if (!signal) return operation;
+    void operation.catch(() => undefined);
+    let rejectForAbort!: () => void;
+    const aborted = new Promise<never>((_resolve, reject) => {
+      rejectForAbort = () => reject(
+        signal.reason ?? this.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);
+    }
+  }
+
+  private async changeReversionCursor(
+    scopeId: string,
+    sessionId: string,
+    direction: 'undo' | 'redo',
+    signal?: AbortSignal,
+  ): Promise<string> {
+    const { scope, state } = await this.resolveState(scopeId);
+    return this.changeReversionCursorResolved(
+      scopeId,
+      sessionId,
+      direction,
+      scope.scope,
+      state,
+      signal,
+    );
+  }
+
+  private async changeReversionCursorResolved(
+    scopeId: string,
+    sessionId: string,
+    direction: 'undo' | 'redo',
+    scope: TScope,
+    state: IStorageState,
+    signal?: AbortSignal,
+  ): Promise<string> {
+    const stored = this.requireSession(state, sessionId);
+    this.assertStateAcceptingWork(state);
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner?.sessionKey === this.slashCommandSessionKey(state.storageKey, sessionId)) {
+      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+    }
+    return this.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.');
+          await this.resumePendingApply(state, stored, scopeId, scope, operationSignal);
+          this.emitEvent(scopeId, sessionId, {
+            type: 'session.history.changed',
+            direction,
+            runId: target.runId,
+          });
+          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.turnReversionProvider && unit.segments.some((segment) =>
+          segment.disposition === 'revertible' && segment.workspaceReference === undefined)) {
+          throw new FlexHarnessSlashCommandUnavailableError(
+            direction,
+            'The turn has no available workspace reversion capture.',
+          );
+        }
+        const operationId = this.reversionId(
+          'apply',
+          state.storageKey,
+          sessionId,
+          JSON.stringify([direction, stored.revertCursor, unit.toCursor, unit.target.runId]),
+        );
+        await this.mutateProjection(state, stored, () => {
+          stored.pendingReversion = {
+            kind: 'apply',
+            operationId,
+            direction,
+            fromCursor: stored.revertCursor,
+            toCursor: unit.toCursor,
+            segmentRunIds: unit.segments.map((segment) => segment.runId),
+            appliedRunIds: [],
+          };
+        }, true);
+        await this.resumePendingApply(
+          state,
+          stored,
+          scopeId,
+          scope,
+          operationSignal,
+        );
+        this.emitEvent(scopeId, sessionId, {
+          type: 'session.history.changed',
+          direction,
+          runId: unit.target.runId,
+        });
+        return unit.target.runId;
+      },
+    );
+  }
+
+  private async reconcileContextAvailability(
+    state: IStorageState,
+    stored: IStoredSessionState,
+  ): Promise<boolean> {
+    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.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 as IFlexAgentContextInvocation<TScope> | undefined;
+    if (context) {
+      await this.drainReversionReleases(state, stored, context.scopeId, context.scope, false);
+    }
+    return branchCommitted;
+  }
+
+  private async resumePendingApply(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    scopeId: string,
+    scope: TScope,
+    signal?: AbortSignal,
+  ): Promise<void> {
+    const pending = stored.pendingReversion;
+    if (pending?.kind !== 'apply') return;
+    const segmentMap = new Map(stored.reversionSegments.map((segment) => [segment.runId, segment]));
+    if (
+      pending.segmentRunIds.some((runId) =>
+        segmentMap.get(runId)?.disposition === 'revertible')
+      && !this.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.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: AbortSignal) => Object.freeze({
+          scopeId,
+          scope,
+          storageKey: state.storageKey,
+          sessionId: stored.session.sessionId,
+          runId,
+          captureId,
+          reference: cloneSerializable(reference),
+          operationId: childOperationId,
+          direction: pending.direction,
+          signal: contextSignal,
+        });
+        let inspection;
+        try {
+          inspection = await this.withReversionMaintenanceSignal((inspectionSignal) =>
+            this.turnReversionProvider!.inspectApply(createContext(inspectionSignal)));
+        } catch (inspectionError) {
+          state.lifecycle = 'fenced';
+          throw this.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.turnReversionProvider.apply(createContext(signal));
+            } else {
+              await this.withReversionMaintenanceSignal((maintenanceSignal) =>
+                this.turnReversionProvider!.apply(createContext(maintenanceSignal)));
+            }
+          } catch (error) {
+            try {
+              inspection = await this.withReversionMaintenanceSignal((inspectionSignal) =>
+                this.turnReversionProvider!.inspectApply(createContext(inspectionSignal)));
+            } catch (inspectionError) {
+              state.lifecycle = 'fenced';
+              throw this.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.projectOperationError(
+                error,
+                'turnReversion',
+                scopeId,
+                stored.session.sessionId,
+                childOperationId,
+              );
+            }
+          }
+        }
+      }
+      await this.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.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);
+  }
+
+  private async persistKnownNotApplied(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    operationId: string,
+    runId: string,
+  ): Promise<void> {
+    await this.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);
+  }
+
+  private async recoverPendingCapture(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    scopeId: string,
+    scope: TScope,
+    outcomes: Map<string, TCanonicalOutcome>,
+  ): Promise<void> {
+    const pending = stored.pendingReversion;
+    if (pending?.kind !== 'capture' || !this.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.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,
+      pending.runId,
+      pending.captureId,
+      pending.state === 'prepared' ? 'finalizing' : pending.state,
+    );
+    if (finalizedOutcome === undefined) {
+      await this.mutateProjection(state, stored, () => {
+        stored.reversionSegments = stored.reversionSegments.filter(
+          (entry) => entry.runId !== pending.runId,
+        );
+        delete stored.pendingReversion;
+      }, true);
+      return;
+    }
+    await this.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);
+  }
+
+  public async archiveSessionEvents(
+    scopeId: string,
+    sessionId: string,
+    compactionEventId?: string,
+  ): Promise<IFlexEventArchiveMetadata | undefined> {
+    if (compactionEventId !== undefined) {
+      validateIdentifier(compactionEventId, 'compactionEventId');
+      requireTransferIdentifier(compactionEventId, 'compactionEventId');
+    }
+    const { scope, state } = await this.resolveState(scopeId);
+    const stored = this.requireSession(state, sessionId);
+    this.assertStateAcceptingWork(state);
+    this.requireSessionAvailableForSlashCommand(state, stored, 'archive');
+    const compaction = compactionEventId === undefined
+      ? [...stored.agentSession.getEvents()].reverse().find((event) =>
+          event.type === 'context-compaction')
+      : stored.agentSession.getEvents().find((event) =>
+          event.type === 'context-compaction' && event.id === compactionEventId);
+    if (!compaction || compaction.type !== 'context-compaction') return undefined;
+    let archive;
+    try {
+      archive = await stored.agentSession.archiveCompactedEvents(compaction.id);
+    } catch (error) {
+      throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'archive');
+    }
+    if (!archive) return undefined;
+    let branchCommitted = false;
+    try {
+      const archivedIds = new Set(archive.events.map((event) => event.id));
+      await this.mutateProjection(state, stored, () => {
+        branchCommitted = this.commitRevertedBranchState(stored);
+        for (const segment of stored.reversionSegments) {
+          if (segment.eventIds.some((eventId) => archivedIds.has(eventId))) {
+            segment.contextAvailable = false;
+          }
+        }
+        this.pruneReversionState(stored);
+      }, true);
+    } catch (error) {
+      throw this.projectOperationError(error, 'persistence', scopeId, sessionId, 'archive-horizon');
+    }
+    if (branchCommitted) {
+      this.emitEvent(scopeId, sessionId, {
+        type: 'session.history.changed',
+        direction: 'branch',
+      });
+    }
+    await this.drainReversionReleases(state, stored, scopeId, scope.scope, false);
+    return publicSnapshot({
+      archiveId: this.boundedIdentifier(archive.archiveId, 'archiveId'),
+      sessionId: this.boundedIdentifier(archive.sessionId, 'sessionId'),
+      createdAt: new Date(archive.createdAt).toISOString(),
+      eventCount: archive.events.length,
+    });
+  }
+
+  public async listBackgroundExecutions(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexBackgroundExecution[]> {
+    const { state } = await this.resolveState(scopeId);
+    const stored = this.requireSession(state, sessionId);
+    this.assertStateAcceptingWork(state);
+    if (!stored.jobs) return [];
+    try {
+      const jobs = await stored.jobs.list();
+      return publicSnapshot(jobs
+        .sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))
+        .slice(0, maxBackgroundExecutions)
+        .map((job) => this.projectBackgroundExecution(job)));
+    } catch (error) {
+      throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'background-list');
+    }
+  }
+
+  public async getBackgroundExecution(
+    scopeId: string,
+    sessionId: string,
+    executionId: string,
+  ): Promise<IFlexBackgroundExecution> {
+    validateIdentifier(executionId, 'executionId');
+    requireTransferIdentifier(executionId, 'executionId');
+    const { state } = await this.resolveState(scopeId);
+    const stored = this.requireSession(state, sessionId);
+    this.assertStateAcceptingWork(state);
+    try {
+      return publicSnapshot(this.projectBackgroundExecution(
+        await stored.agentSession.getBackgroundExecution(executionId),
+      ));
+    } catch (error) {
+      throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'background-get');
+    }
+  }
+
+  public async abortBackgroundExecution(
+    scopeId: string,
+    sessionId: string,
+    executionId: string,
+  ): Promise<void> {
+    validateIdentifier(executionId, 'executionId');
+    requireTransferIdentifier(executionId, 'executionId');
+    const { scope, state } = await this.resolveState(scopeId);
+    const stored = this.requireSession(state, sessionId);
     this.assertStateAcceptingWork(state);
     try {
       await this.withCompactorContext(
@@ -1725,6 +3187,7 @@ export class FlexHarness<TScope = unknown> {
   }
 
   public retireScope(scopeId: string): Promise<void> {
+    this.assertNoAmbientSlashCommandTeardown({ scopeId });
     this.assertOpen();
     validateIdentifier(scopeId, 'scopeId');
     const existing = this.scopeRetirements.get(scopeId);
@@ -1743,6 +3206,7 @@ export class FlexHarness<TScope = unknown> {
   }
 
   public async dispose(): Promise<void> {
+    this.assertNoAmbientSlashCommandTeardown();
     if (this.disposePromise) return this.disposePromise;
     this.closed = true;
     let disposal!: Promise<void>;
@@ -1763,16 +3227,16 @@ export class FlexHarness<TScope = unknown> {
     debounceMs?: number,
     subagentAdmission = false,
     admissionSignal?: AbortSignal,
-  ): Promise<{ admission: IFlexPromptQueueAdmission; started: Promise<IFlexPromptAdmission> }> {
+    slashCommandAdmission = false,
+  ): Promise<{
+    admission: IFlexPromptQueueAdmission;
+    started: Promise<IFlexPromptAdmission>;
+    queued?: IQueuedPrompt;
+  }> {
     this.assertOpen();
     const normalizedPrompt = normalizeFlexPrompt(prompt);
     const normalizedOptions = cloneSerializable(options);
-    const byteSize = jsonBytes({
-      prompt: normalizedPrompt,
-      options: normalizedOptions,
-      scheduleKey,
-      debounceMs,
-    });
+    const byteSize = this.promptAdmissionByteSize(prompt, options, scheduleKey, debounceMs);
     const releasePendingAdmission = this.reservePendingPromptAdmission(byteSize);
     let resolveSettled!: () => void;
     const pendingOwner: IPendingPromptAdmission = {
@@ -1807,6 +3271,20 @@ export class FlexHarness<TScope = unknown> {
       }
       this.assertStateAcceptingWork(state);
       const stored = this.requireSession(state, sessionId);
+      const sessionKey = this.slashCommandSessionKey(state.storageKey, sessionId);
+      const invocationOwner = this.slashCommandInvocationContext.getStore();
+      if (invocationOwner?.sessionKey === sessionKey) {
+        throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+      }
+      if (!slashCommandAdmission && this.activeSlashCommandExecutions.has(sessionKey)) {
+        throw new FlexHarnessSessionBusyError(
+          sessionId,
+          'already has an active slash command execution',
+        );
+      }
+      if (stored.pendingReversion) {
+        throw new FlexHarnessSessionBusyError(sessionId, 'has a pending reversion operation');
+      }
       if (stored.session.agent !== undefined && !subagentAdmission) {
         throw new FlexHarnessValidationError(
           'Subagent sessions can only be prompted through the foreground task tool.',
@@ -1875,6 +3353,7 @@ export class FlexHarness<TScope = unknown> {
       return {
         admission: Object.freeze({ queueId: queued.queueId, completion }),
         started,
+        queued,
       };
     } finally {
       for (const signal of admissionSignals) {
@@ -2003,6 +3482,7 @@ export class FlexHarness<TScope = unknown> {
     const options = queued.options!;
     let projectionReserved = false;
     try {
+      await this.commitRevertedBranch(run.state, run.stored, run.scopeId, run.scope as TScope);
       run.transaction = await this.withRunCompactorContext(
         run,
         () => run.stored.agentSession.beginGeneration(
@@ -2016,6 +3496,34 @@ export class FlexHarness<TScope = unknown> {
       const reservation = this.createReservation(run, prompt);
       await this.mutateProjection(run.state, run.stored, () => {
         run.stored.messages.push(reservation.userMessage, reservation.assistantMessage);
+        if (run.stored.session.agent === undefined) {
+          this.pruneReversionState(run.stored, true);
+          const captureId = this.turnReversionProvider
+            ? this.reversionId('capture', run.state.storageKey, run.sessionId, run.runId)
+            : undefined;
+          const protocolVersion = this.reversionProviderProtocolVersion() ?? 1;
+          run.stored.reversionSegments.push({
+            runId: run.runId,
+            userMessageId: reservation.userMessage.messageId,
+            status: 'capturing',
+            contextAvailable: true,
+            eventIds: [],
+            workspaceCaptured: captureId !== undefined,
+            protocolVersion,
+            provenance: captureId === undefined ? 'transcript' : 'workspace',
+            ...(captureId === undefined ? {} : { disposition: 'pending' }),
+            ...(captureId === undefined ? {} : { captureId }),
+          });
+          if (captureId) {
+            run.stored.pendingReversion = {
+              kind: 'capture',
+              runId: run.runId,
+              captureId,
+              state: 'preparing',
+              protocolVersion,
+            };
+          }
+        }
       });
       projectionReserved = true;
       run.reservedUserMessage = publicSnapshot(reservation.userMessage);
@@ -2236,6 +3744,7 @@ export class FlexHarness<TScope = unknown> {
       if (run.controller.signal.aborted) throw run.controller.signal.reason;
       const result = normalizeRunResult(rawResult);
       if (!run.modelResolution) throw new FlexHarnessValidationError('Generation completed without a resolved model.');
+      await this.finalizeRunReversion(run, 'completed');
       const terminal = this.buildTerminal(run, 'completed', result);
       try {
         await this.mutateProjection(run.state, run.stored, () => {
@@ -2266,9 +3775,16 @@ export class FlexHarness<TScope = unknown> {
       }
       this.emitTerminalProjection(run, terminal);
       this.emitFinalRunEvent(run, terminal.assistantMessage, undefined, false);
-      return {
-        runId: run.runId,
-        sessionId: run.sessionId,
+      await this.drainReversionReleases(
+        run.state,
+        run.stored,
+        run.scopeId,
+        run.scope as TScope,
+        false,
+      );
+      return {
+        runId: run.runId,
+        sessionId: run.sessionId,
         userMessage: publicSnapshot(terminal.userMessage),
         assistantMessage: publicSnapshot(terminal.assistantMessage),
         model: publicSnapshot(terminal.model!),
@@ -2306,6 +3822,14 @@ export class FlexHarness<TScope = unknown> {
       ? run.ownerCancellation!
       : this.projectExternalError(run, error, generated ? 'persistence' : 'agentSession');
     const errors: unknown[] = [safeError];
+    try {
+      await this.finalizeRunReversion(run, cancelled ? 'cancelled' : 'failed');
+    } catch (reversionError) {
+      errors.push(reversionError);
+      const combined = combineErrors(errors);
+      await this.fenceNamespace(run.state, run, combined);
+      throw combined;
+    }
     if (generated && !this.isTombstoned(run)) {
       const failedStage = this.buildTerminal(run, cancelled ? 'cancelled' : 'failed', undefined, safeError);
       try {
@@ -2360,6 +3884,13 @@ export class FlexHarness<TScope = unknown> {
       this.emitTerminalProjection(run, terminal);
       this.emitFinalRunEvent(run, terminal.assistantMessage, terminalError, publicStatus === 'cancelled');
     }
+    await this.drainReversionReleases(
+      run.state,
+      run.stored,
+      run.scopeId,
+      run.scope as TScope,
+      false,
+    );
     throw errors.length > 1 ? combineErrors(errors) : terminalError;
   }
 
@@ -2369,6 +3900,7 @@ export class FlexHarness<TScope = unknown> {
     signal: AbortSignal,
   ): Promise<plugins.IAgentGenerationLease> {
     signal.throwIfAborted();
+    await this.prepareRunReversion(run, signal);
     run.phase = 'running';
     const queued = run.stored.outstandingPromptsById.get(run.queueId);
     if (queued && (queued.status === 'starting' || queued.status === 'scheduled')) {
@@ -3036,39 +4568,1047 @@ export class FlexHarness<TScope = unknown> {
           : 'Tool execution ended without a terminal event.';
       }
     }
-    userMessage.status = status;
-    userMessage.completedAt = timestamp;
-    assistantMessage.status = status;
-    assistantMessage.completedAt = timestamp;
-    if (run.modelResolution) assistantMessage.model = cloneSerializable(run.modelResolution.identity);
-    if (status === 'completed' && result) {
-      if (!assistantMessage.parts.some((part) => part.type === 'text')) {
-        assistantMessage.parts.push({
-          partId: plugins.crypto.randomUUID(),
-          type: 'text',
-          text: truncateUtf8(result.text, this.callbackLimits.maxOutputBytes),
+    userMessage.status = status;
+    userMessage.completedAt = timestamp;
+    assistantMessage.status = status;
+    assistantMessage.completedAt = timestamp;
+    if (run.modelResolution) assistantMessage.model = cloneSerializable(run.modelResolution.identity);
+    if (status === 'completed' && result) {
+      if (!assistantMessage.parts.some((part) => part.type === 'text')) {
+        assistantMessage.parts.push({
+          partId: plugins.crypto.randomUUID(),
+          type: 'text',
+          text: truncateUtf8(result.text, this.callbackLimits.maxOutputBytes),
+        });
+      }
+      assistantMessage.usage = cloneSerializable(result.usage);
+    } else {
+      const message = truncateUtf8(error?.message ?? externalErrorFallback.message, maxTransferMetadataBytes);
+      userMessage.error = message;
+      assistantMessage.error = message;
+    }
+    return {
+      runId: run.runId,
+      status,
+      userMessage,
+      assistantMessage,
+      ...(run.modelResolution ? { model: cloneSerializable(run.modelResolution.identity) } : {}),
+      ...(status === 'completed' && result
+        ? {
+            usage: cloneSerializable(result.usage),
+            finishReason: result.finishReason,
+            steps: result.steps,
+          }
+        : {}),
+    };
+  }
+
+  private reversionId(
+    kind: 'capture' | 'apply',
+    storageKey: string,
+    sessionId: string,
+    value: string,
+  ): string {
+    return `${kind}_${sha256Hex(JSON.stringify([storageKey, sessionId, value]))}`;
+  }
+
+  private reversionProviderProtocolVersion(): 1 | 2 | undefined {
+    if (!this.turnReversionProvider) return undefined;
+    return 'protocolVersion' in this.turnReversionProvider ? 2 : 1;
+  }
+
+  private reversionCaptureContext(
+    run: IActiveRun,
+    captureId: string,
+    signal: AbortSignal,
+  ) {
+    return Object.freeze({
+      scopeId: run.scopeId,
+      scope: run.scope as TScope,
+      storageKey: run.state.storageKey,
+      sessionId: run.sessionId,
+      runId: run.runId,
+      captureId,
+      signal,
+    });
+  }
+
+  private async withReversionMaintenanceSignal<TResult>(
+    operation: (signal: AbortSignal) => Promise<TResult> | TResult,
+  ): Promise<TResult> {
+    const controller = new AbortController();
+    const timeoutMs = this.agentSessionPolicy.generationLeaseCleanupTimeoutMs ?? 30_000;
+    const timeoutError = new Error(`Turn reversion maintenance timed out after ${timeoutMs}ms.`);
+    let rejectTimeout!: (error: Error) => void;
+    const timeout = new Promise<never>((_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);
+    }
+  }
+
+  private inspectReversionCapture(
+    scopeId: string,
+    scope: TScope,
+    storageKey: string,
+    sessionId: string,
+    runId: string,
+    captureId: string,
+  ): Promise<TNormalizedCaptureInspection> {
+    return this.withReversionMaintenanceSignal(async (signal) => {
+      const provider = this.turnReversionProvider!;
+      const inspection = await provider.inspectCapture(Object.freeze({
+        scopeId,
+        scope,
+        storageKey,
+        sessionId,
+        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: [],
+        },
+      };
+    });
+  }
+
+  private finalizeReversionCapture(
+    scopeId: string,
+    scope: TScope,
+    storageKey: string,
+    sessionId: string,
+    runId: string,
+    captureId: string,
+  ): Promise<TFlexTurnReversionFinalizedOutcome> {
+    return this.withReversionMaintenanceSignal(async (signal) => {
+      const result = await this.turnReversionProvider!.finalize(Object.freeze({
+        scopeId,
+        scope,
+        storageKey,
+        sessionId,
+        runId,
+        captureId,
+        signal,
+      }));
+      return this.reversionProviderProtocolVersion() === 2
+        ? this.normalizeReversionOutcome(result)
+        : {
+            disposition: 'revertible',
+            reference: this.normalizeReversionReference(result),
+            affectedWorkspaces: [],
+          };
+    });
+  }
+
+  private async resolveReversionCaptureOutcome(
+    state: IStorageState,
+    scopeId: string,
+    scope: TScope,
+    sessionId: string,
+    runId: string,
+    captureId: string,
+    durableState: 'preparing' | 'prepared' | 'finalizing',
+  ): Promise<TFlexTurnReversionFinalizedOutcome | undefined> {
+    let inspection;
+    try {
+      inspection = await this.inspectReversionCapture(
+        scopeId,
+        scope,
+        state.storageKey,
+        sessionId,
+        runId,
+        captureId,
+      );
+    } catch (error) {
+      state.lifecycle = 'fenced';
+      throw this.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,
+          runId,
+          captureId,
+        );
+      } catch (error) {
+        const finalInspection = await this.inspectReversionCapture(
+          scopeId,
+          scope,
+          state.storageKey,
+          sessionId,
+          runId,
+          captureId,
+        );
+        if (finalInspection.status !== 'finalized') {
+          if (finalInspection.status === 'unknown') state.lifecycle = 'fenced';
+          throw this.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;
+  }
+
+  private normalizeReversionReference(reference: unknown): TJsonValue {
+    return normalizeJsonValue(reference, {
+      maxDepth: this.toolOutputLimits.maxDepth,
+      maxBytes: Math.min(
+        this.toolOutputLimits.maxBytes,
+        FLEX_REVERSION_REFERENCE_MAX_BYTES,
+      ),
+    });
+  }
+
+  private normalizeReversionOutcome(value: unknown): TFlexTurnReversionFinalizedOutcome {
+    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 as Record<string, unknown>;
+    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 }),
+    };
+  }
+
+  private normalizeAffectedWorkspaces(value: unknown): IFlexAffectedWorkspace[] {
+    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<string>();
+    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 as Record<string, unknown>;
+      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 };
+    });
+  }
+
+  private async prepareRunReversion(run: IActiveRun, signal: AbortSignal): Promise<void> {
+    if (run.stored.session.agent !== undefined || !this.turnReversionProvider) return;
+    const segment = run.stored.reversionSegments.find((entry) => entry.runId === run.runId);
+    const captureId = segment?.captureId;
+    if (!segment || !captureId) {
+      throw this.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.projectExternalError(
+        run,
+        new Error(`Root generation requires reversion protocolVersion ${segment.protocolVersion}.`),
+        'turnReversion',
+      );
+    }
+    try {
+      await this.turnReversionProvider.prepare(context);
+    } catch (error) {
+      let inspection;
+      try {
+        inspection = await this.inspectReversionCapture(
+          run.scopeId,
+          run.scope as TScope,
+          run.state.storageKey,
+          run.sessionId,
+          run.runId,
+          captureId,
+        );
+      } catch (inspectionError) {
+        run.state.lifecycle = 'fenced';
+        throw this.projectExternalError(run, inspectionError, 'turnReversion');
+      }
+      if (inspection.status !== 'prepared' && inspection.status !== 'finalized') {
+        if (inspection.status === 'unknown') run.state.lifecycle = 'fenced';
+        throw this.projectExternalError(run, error, 'turnReversion');
+      }
+    }
+    await this.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);
+  }
+
+  private async finalizeRunReversion(
+    run: IActiveRun,
+    status: 'completed' | 'failed' | 'cancelled',
+  ): Promise<void> {
+    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.turnReversionProvider || segment.provenance === 'transcript') {
+      await this.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.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.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 as TScope,
+      run.sessionId,
+      run.runId,
+      captureId,
+      pending.state === 'prepared' ? 'finalizing' : pending.state,
+    );
+    if (outcome === undefined) {
+      await this.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.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);
+  }
+
+  private applyFinalizedReversionOutcome(
+    stored: IStoredSessionState,
+    segment: IFlexReversionSegment,
+    outcome: TFlexTurnReversionFinalizedOutcome,
+  ): void {
+    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;
+  }
+
+  private hiddenReversionSegments(stored: IStoredSessionState): IFlexReversionSegment[] {
+    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);
+  }
+
+  private enqueueReversionRelease(
+    stored: IStoredSessionState,
+    segment: IFlexReversionSegment,
+  ): void {
+    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,
+    });
+  }
+
+  private enqueueReversionReleaseReference(
+    stored: IStoredSessionState,
+    release: IFlexPendingReversionRelease,
+  ): void {
+    if (stored.pendingReversionReleases.some((entry) => entry.captureId === release.captureId)) {
+      return;
+    }
+    if (stored.pendingReversionReleases.length >= this.reversionLimits.maxPendingReversionReleases) {
+      throw new FlexHarnessValidationError('Pending reversion release limit was reached.');
+    }
+    stored.pendingReversionReleases.push(cloneSerializable(release));
+  }
+
+  private pruneReversionState(
+    stored: IStoredSessionState,
+    reserveSegment = false,
+    dropNonUndoablePrefix = false,
+  ): void {
+    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.reversionLimits.maxCompletedTurns
+        || stored.reversionSegments.length + (reserveSegment ? 1 : 0)
+          > this.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.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.reversionLimits.maxExcludedRunIds) {
+      throw new FlexHarnessValidationError('Excluded reversion run limit was reached.');
+    }
+  }
+
+  private async commitRevertedBranch(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    scopeId: string,
+    scope: TScope,
+  ): Promise<void> {
+    if (stored.pendingReversionReleases.length > 0) {
+      await this.drainReversionReleases(state, stored, scopeId, scope, false);
+      this.assertStateAcceptingWork(state);
+    }
+    if (this.hiddenReversionSegments(stored).length === 0) {
+      return;
+    }
+    await this.mutateProjection(state, stored, () => this.commitRevertedBranchState(stored), true);
+    this.emitEvent(scopeId, stored.session.sessionId, {
+      type: 'session.history.changed',
+      direction: 'branch',
+    });
+    await this.drainReversionReleases(state, stored, scopeId, scope, false);
+  }
+
+  private commitRevertedBranchState(stored: IStoredSessionState): boolean {
+    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;
+  }
+
+  private commitArchivedHiddenBranchState(stored: IStoredSessionState): boolean {
+    const hidden = this.hiddenReversionSegments(stored);
+    return hidden.some((segment) => !segment.contextAvailable)
+      ? this.commitRevertedBranchState(stored)
+      : false;
+  }
+
+  private filterReversionContextEvents(
+    stored: IStoredSessionState,
+    events: readonly plugins.TAgentEvent[],
+  ): plugins.TAgentEvent[] {
+    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<string>();
+    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));
+  }
+
+  private async drainReversionReleases(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    scopeId: string,
+    scope: TScope,
+    throwOnFailure: boolean,
+  ): Promise<void> {
+    await this.reconcileProjectionFromStore(stored);
+    if (!this.turnReversionProvider) {
+      if (stored.pendingReversionReleases.length > 0) {
+        throw new FlexHarnessValidationError(
+          'Pending workspace capture releases require their turn reversion provider.',
+        );
+      }
+      return;
+    }
+    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.turnReversionProvider!.release(Object.freeze({
+            scopeId,
+            scope,
+            storageKey: state.storageKey,
+            sessionId: stored.session.sessionId,
+            runId: release.runId,
+            captureId: release.captureId,
+            reference: cloneSerializable(release.reference),
+            signal,
+          })));
+      } catch (error) {
+        if (throwOnFailure) {
+          throw this.projectOperationError(
+            error,
+            'turnReversion',
+            scopeId,
+            stored.session.sessionId,
+            `release:${release.captureId}`,
+          );
+        }
+        return;
+      }
+      try {
+        await this.mutateProjection(state, stored, () => {
+          if (stored.pendingReversionReleases[0]?.captureId === release.captureId) {
+            stored.pendingReversionReleases.shift();
+          }
+        }, true);
+      } catch (error) {
+        if (!throwOnFailure && state.lifecycle === 'fenced') {
+          this.deferReversionReleaseDrain(state, stored, scopeId, scope);
+        }
+        if (throwOnFailure) throw error;
+        return;
+      }
+      if (stored.projectionReconciliationRequired) return;
+    }
+  }
+
+  private async releaseDeletedSessionReversions(
+    state: IStorageState,
+    storageKey: string,
+    sessionId: string,
+    scopeId: string,
+    scope: TScope,
+    stored?: IStoredSessionState,
+  ): Promise<void> {
+    if (stored) await stored.projectionQueue;
+    let durableProjection = await this.stores.projections.load(storageKey, sessionId);
+    if (!durableProjection) return;
+    let projection = this.upgradeProjectionSnapshot(durableProjection);
+    const persistDirect = async (next: IFlexProjectionSnapshotCurrent): Promise<void> => {
+      const before = durableProjection;
+      try {
+        await this.stores.projections.save(storageKey, sessionId, next, projection.revision);
+        durableProjection = next;
+        projection = next;
+      } catch (error) {
+        let current: TFlexProjectionSnapshot | undefined;
+        let reconciliationError: unknown;
+        try {
+          current = await this.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.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: AbortSignal) => Object.freeze({
+              scopeId,
+              scope,
+              storageKey,
+              sessionId,
+              runId,
+              captureId,
+              reference: cloneSerializable(reference),
+              operationId,
+              direction: pending.direction,
+              signal,
+            });
+            let inspection = await this.withReversionMaintenanceSignal((signal) =>
+              this.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.turnReversionProvider!.apply(createContext(signal)));
+              } catch (error) {
+                inspection = await this.withReversionMaintenanceSignal((signal) =>
+                  this.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: IFlexProjectionSnapshotCurrent = {
+          ...completedProjection,
+          revision: projection.revision + 1,
+          revertCursor: pending.toCursor,
+        };
+        await persistDirect(completed);
+      }
+      const recoveredProjection = await this.stores.projections.load(storageKey, sessionId);
+      if (!recoveredProjection) return;
+      durableProjection = recoveredProjection;
+      projection = this.upgradeProjectionSnapshot(recoveredProjection);
+    }
+    const releases = new Map<string, IFlexPendingReversionRelease>();
+    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<string, {
+      runId: string;
+      captureId: string;
+      protocolVersion: 1 | 2;
+      durableState?: 'preparing' | 'prepared' | 'finalizing';
+    }>();
+    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,
         });
       }
-      assistantMessage.usage = cloneSerializable(result.usage);
-    } else {
-      const message = truncateUtf8(error?.message ?? externalErrorFallback.message, maxTransferMetadataBytes);
-      userMessage.error = message;
-      assistantMessage.error = message;
     }
-    return {
-      runId: run.runId,
-      status,
-      userMessage,
-      assistantMessage,
-      ...(run.modelResolution ? { model: cloneSerializable(run.modelResolution.identity) } : {}),
-      ...(status === 'completed' && result
-        ? {
-            usage: cloneSerializable(result.usage),
-            finishReason: result.finishReason,
-            steps: result.steps,
+    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.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.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,
+          capture.runId,
+          capture.captureId,
+        );
+      } catch (error) {
+        throw this.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,
+            capture.runId,
+            capture.captureId,
+          );
+        } catch (error) {
+          const finalInspection = await this.inspectReversionCapture(
+            scopeId,
+            scope,
+            storageKey,
+            sessionId,
+            capture.runId,
+            capture.captureId,
+          );
+          if (finalInspection.status !== 'finalized') {
+            if (finalInspection.status === 'unknown') state.lifecycle = 'fenced';
+            throw this.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.turnReversionProvider) {
+      throw new FlexHarnessValidationError(
+        'Capture-backed session deletion requires its turn reversion provider.',
+      );
+    }
+    if (stored) {
+      await this.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.turnReversionProvider!.release(Object.freeze({
+              scopeId,
+              scope,
+              storageKey,
+              sessionId,
+              runId: release.runId,
+              captureId: release.captureId,
+              reference: cloneSerializable(release.reference),
+              signal,
+            })));
+        } catch (error) {
+          throw this.projectOperationError(
+            error,
+            'turnReversion',
+            scopeId,
+            sessionId,
+            `release:${release.captureId}`,
+          );
+        }
+        await persistDirect({
+          ...projection,
+          revision: projection.revision + 1,
+          pendingReversionReleases: projection.pendingReversionReleases.slice(1),
+        });
+      }
+    }
   }
 
   private async promoteCompletedTerminal(
@@ -3688,6 +6228,13 @@ export class FlexHarness<TScope = unknown> {
         await this.mutateProjection(run.state, run.stored, () => {
           run.stored.messages = run.stored.messages.filter((message) => message.runId !== run.runId);
           run.stored.stagedTerminals = run.stored.stagedTerminals.filter((entry) => entry.runId !== run.runId);
+          run.stored.reversionSegments = run.stored.reversionSegments.filter(
+            (segment) => segment.runId !== run.runId,
+          );
+          if (
+            run.stored.pendingReversion?.kind === 'capture'
+            && run.stored.pendingReversion.runId === run.runId
+          ) delete run.stored.pendingReversion;
         }, true);
       } catch (error) {
         errors.push(this.projectExternalError(run, error, 'persistence'));
@@ -4060,6 +6607,7 @@ export class FlexHarness<TScope = unknown> {
       storageKey,
       compactorLifecycleController,
       scopeIdHint: scopeId,
+      scopeContext: { scopeId, scope },
       revision: snapshot.revision,
       sessions: new Map(),
       retainedSessionCleanups: new Map(),
@@ -4084,7 +6632,14 @@ export class FlexHarness<TScope = unknown> {
         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)) || scopeChanged;
+        scopeChanged = (await this.repairLoadedSession(
+          state.storageKey,
+          stored,
+          state,
+          scopeId,
+          scope,
+        )) || scopeChanged;
+        await this.drainReversionReleases(state, stored, scopeId, scope, false);
         if (stored.projectionRevision < 0) throw new Error('Invalid projection revision.');
       }
       for (const stored of state.sessions.values()) {
@@ -4115,12 +6670,23 @@ export class FlexHarness<TScope = unknown> {
         try {
           const group = this.tombstoneGroup(state, rootSessionId);
           for (const tombstone of group) {
+            await this.releaseDeletedSessionReversions(
+              state,
+              storageKey,
+              tombstone.sessionId,
+              scopeId,
+              scope,
+            );
             await this.cleanupSessionDomains(storageKey, tombstone.sessionId);
           }
           for (const tombstone of group) state.tombstones.delete(tombstone.sessionId);
           scopeChanged = true;
-        } catch {
+        } catch (error) {
           // A retained tombstone is retried by the next load or explicit delete call.
+          if (state.lifecycle === 'fenced') {
+            this.deferNamespaceDrain(state, error, { scopeId, scope });
+            break;
+          }
         }
       }
       if (scopeChanged) {
@@ -4130,6 +6696,16 @@ export class FlexHarness<TScope = unknown> {
       }
       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.orphanedTombstoneOwners.set(key, {
+          state,
+          rootSessionId,
+          scopeId,
+          scope,
+        });
+      }
       const closeResults = await Promise.allSettled(
         loadedSessions.map((stored) => this.closeStoredSession(stored)),
       );
@@ -4162,6 +6738,12 @@ export class FlexHarness<TScope = unknown> {
       session,
       messages: [],
       stagedTerminals: [],
+      reversionSegments: [],
+      revertCursor: 0,
+      excludedRunIds: [],
+      pendingReversionReleases: [],
+      projectionSchemaVersion: 3,
+      projectionReconciliationRequired: false,
       projectionRevision: 0,
       projectionQueue: Promise.resolve(),
       rememberedPermissionKeys: new Set(),
@@ -4228,6 +6810,28 @@ export class FlexHarness<TScope = unknown> {
       throw combineErrors(acquisitionErrors);
     }
     const projection = projectionResult.value;
+    const legacyProjection = projection?.schemaVersion === 2 ? projection : undefined;
+    const currentProjection = projection?.schemaVersion === 3 ? projection : undefined;
+    const reversionSegments: IFlexReversionSegment[] = currentProjection
+      ? cloneSerializable(currentProjection.reversionSegments)
+      : (legacyProjection?.reversionSegments ?? []).map((segment): IFlexReversionSegment => ({
+          ...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 as const }
+        : legacyProjection?.pendingReversion);
+    const pendingReversionReleases: IFlexPendingReversionRelease[] = currentProjection
+      ? cloneSerializable(currentProjection.pendingReversionReleases)
+      : (legacyProjection?.pendingReversionReleases ?? []).map((release) => ({
+          ...cloneSerializable(release),
+          protocolVersion: 1,
+        }));
     const permission = permissionResult.value;
     const eventStore = eventStoreResult.value;
     const jobStore = jobStoreResult.value;
@@ -4258,6 +6862,20 @@ export class FlexHarness<TScope = unknown> {
         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 && projection.schemaVersion !== 3
+          ? { projectionBaseline: cloneSerializable(projection) }
+          : {}),
         projectionRevision: projection?.revision ?? 0,
         projectionQueue: Promise.resolve(),
         rememberedPermissionKeys: new Set(permission?.rememberedPermissionKeys ?? []),
@@ -4306,7 +6924,9 @@ export class FlexHarness<TScope = unknown> {
         eventStore,
         executionContext: contextualExecutionContext,
         contextBuilder: ({ events }) => hydrateAgentMessages(
-          (this.agentSessionPolicy.contextBuilder ?? ((options) => plugins.buildModelMessages(options.events)))({ events }),
+          (this.agentSessionPolicy.contextBuilder ?? ((options) => plugins.buildModelMessages(options.events)))({
+            events: this.filterReversionContextEvents(stored, events),
+          }),
         ),
         ...(contextCompactor
           ? {
@@ -4323,7 +6943,14 @@ export class FlexHarness<TScope = unknown> {
                 ) {
                   throw new Error('Agent context compaction is missing its exact FlexHarness invocation context.');
                 }
-                return contextCompactor(messages, events, {
+                const filteredEvents = this.filterReversionContextEvents(stored, events);
+                const filteredMessages = hydrateAgentMessages(
+                  (this.agentSessionPolicy.contextBuilder
+                    ?? ((contextOptions) => plugins.buildModelMessages(contextOptions.events)))({
+                    events: filteredEvents,
+                  }),
+                );
+                return contextCompactor(filteredMessages, filteredEvents, {
                   ...options,
                   ...invocationContext,
                   scope: invocationContext.scope as TScope,
@@ -4390,13 +7017,62 @@ export class FlexHarness<TScope = unknown> {
   private async repairLoadedSession(
     storageKey: string,
     stored: IStoredSessionState,
+    state?: IStorageState,
+    scopeId?: string,
+    scope?: TScope,
   ): Promise<boolean> {
     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<number>([
+      ...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.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.drainReversionReleases(state, stored, scopeId, scope, false);
+      this.assertStateAcceptingWork(state);
+    }
     const outcomes = this.canonicalOutcomes(stored.agentSession.getEvents());
+    const firstHiddenCandidate = this.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),
@@ -4433,6 +7109,37 @@ export class FlexHarness<TScope = unknown> {
     }
     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.commitArchivedHiddenBranchState(stored);
+    this.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.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.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;
@@ -4459,6 +7166,11 @@ export class FlexHarness<TScope = unknown> {
     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;
@@ -4469,6 +7181,9 @@ export class FlexHarness<TScope = unknown> {
         snapshot,
         expected,
       );
+      stored.projectionSchemaVersion = 3;
+      delete stored.projectionBaseline;
+      stored.projectionReconciliationRequired = false;
       stored.projectionRevision = snapshot.revision;
     }
     return beforeSession !== JSON.stringify(stored.session);
@@ -4628,18 +7343,47 @@ export class FlexHarness<TScope = unknown> {
   ): Promise<TValue> {
     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 beforeMessages = cloneSerializable(stored.messages);
       const beforeStages = cloneSerializable(stored.stagedTerminals);
-      const beforeSnapshot: IFlexProjectionSnapshot = {
-        schemaVersion: 1,
+      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: TFlexProjectionSnapshot = beforeBaseline ?? {
+        schemaVersion: 3,
         revision: beforeRevision,
         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.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: TValue;
       try {
@@ -4656,6 +7400,9 @@ export class FlexHarness<TScope = unknown> {
           snapshot,
           beforeRevision,
         );
+        stored.projectionSchemaVersion = 3;
+        delete stored.projectionBaseline;
+        stored.projectionReconciliationRequired = false;
         stored.projectionRevision = snapshot.revision;
         return result;
       } catch (error) {
@@ -4664,11 +7411,13 @@ export class FlexHarness<TScope = unknown> {
           throw error;
         }
         if (error instanceof FlexHarnessStoreCommitUncertainError) {
+          stored.projectionSchemaVersion = 3;
+          stored.projectionReconciliationRequired = true;
           stored.projectionRevision = snapshot.revision;
           state.lifecycle = 'fenced';
           throw error;
         }
-        let current: IFlexProjectionSnapshot | undefined;
+        let current: TFlexProjectionSnapshot | undefined;
         let reconciliationError: unknown;
         try {
           current = await this.stores.projections.load(
@@ -4679,6 +7428,9 @@ export class FlexHarness<TScope = unknown> {
           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;
         }
@@ -4689,6 +7441,8 @@ export class FlexHarness<TScope = unknown> {
           restore();
           throw error;
         }
+        stored.projectionSchemaVersion = 3;
+        stored.projectionReconciliationRequired = true;
         stored.projectionRevision = snapshot.revision;
         state.lifecycle = 'fenced';
         throw reconciliationError === undefined
@@ -4797,15 +7551,92 @@ export class FlexHarness<TScope = unknown> {
   private createProjectionSnapshot(
     stored: IStoredSessionState,
     revision: number,
-  ): IFlexProjectionSnapshot {
+  ): IFlexProjectionSnapshotCurrent {
     return {
-      schemaVersion: 1,
+      schemaVersion: 3,
       revision,
       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),
+    };
+  }
+
+  private upgradeProjectionSnapshot(
+    projection: TFlexProjectionSnapshot,
+  ): IFlexProjectionSnapshotCurrent {
+    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' as const : 'transcript' as const,
+        ...(segment.workspaceCaptured
+          ? { disposition: segment.status === 'capturing' ? 'pending' as const : 'revertible' as const }
+          : {}),
+      })),
+      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,
+      })),
     };
   }
 
+  private async reconcileProjectionFromStore(stored: IStoredSessionState): Promise<void> {
+    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;
+  }
+
   private async cleanupSessionDomains(storageKey: string, sessionId: string): Promise<void> {
     const results = await Promise.allSettled([
       this.stores.agentEvents.deleteSession(storageKey, sessionId),
@@ -4914,15 +7745,19 @@ export class FlexHarness<TScope = unknown> {
     }
     const group = this.tombstoneGroup(state, rootSessionId);
     if (group.length === 0) return;
+    const exactInvocation = invocation ?? {
+      scopeId: state.scopeContext.scopeId,
+      scope: state.scopeContext.scope as TScope,
+    };
     const groupIds = new Set(group.map((tombstone) => tombstone.sessionId));
     const reason = this.trustInternalError(new FlexHarnessAbortError('The session subtree was deleted.'));
     const contextFor = (
       sessionId: string,
       retained?: IRetainedSessionCleanup,
-    ): IFlexAgentContextInvocation<TScope> | undefined => invocation
+    ): IFlexAgentContextInvocation<TScope> | undefined => exactInvocation
       ? this.createCompactorContext(
-          invocation.scopeId,
-          invocation.scope,
+          exactInvocation.scopeId,
+          exactInvocation.scope,
           state.storageKey,
           sessionId,
         )
@@ -4995,6 +7830,21 @@ export class FlexHarness<TScope = unknown> {
         if (this.hasOrphanedSessionResources(state.storageKey, sessionId)) {
           throw new Error(`Session "${sessionId}" still has runtime cleanup ownership.`);
         }
+        const releaseContext = exactInvocation ?? retained?.stored.compactorContext as
+          IFlexAgentContextInvocation<TScope> | undefined;
+        if (!releaseContext) {
+          throw new FlexHarnessValidationError(
+            'Tombstone cleanup requires its exact scope context before deleting projection data.',
+          );
+        }
+        await this.releaseDeletedSessionReversions(
+          state,
+          state.storageKey,
+          sessionId,
+          releaseContext.scopeId,
+          releaseContext.scope,
+          retained?.stored,
+        );
         await this.cleanupSessionDomains(state.storageKey, sessionId);
         if (retained) retained.domainsCompleted = true;
       }
@@ -5182,6 +8032,26 @@ export class FlexHarness<TScope = unknown> {
     void drain.catch(() => undefined);
   }
 
+  private deferReversionReleaseDrain(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    scopeId: string,
+    scope: TScope,
+  ): void {
+    state.lifecycle = 'fenced';
+    const reason = this.trustInternalError(new FlexHarnessAbortError('The session namespace was fenced.'));
+    this.abortCompactorLifecycle(stored, reason);
+    const stateLoad = this.stateLoads.get(state.storageKey);
+    if (!stateLoad) return;
+    const drain = this.drainStorage(
+      state.storageKey,
+      stateLoad,
+      reason,
+      { scopeId, scope },
+    );
+    void drain.catch(() => undefined);
+  }
+
   private sessionsAreDependencyRelated(
     state: IStorageState,
     leftSessionId: string,
@@ -5387,6 +8257,20 @@ export class FlexHarness<TScope = unknown> {
 
   private async closeOrphanedResourcesInternal(storageKey?: string): Promise<unknown[]> {
     const errors: unknown[] = [];
+    for (const [key, owner] of [...this.orphanedTombstoneOwners]) {
+      if (storageKey !== undefined && owner.state.storageKey !== storageKey) continue;
+      try {
+        await this.finishTombstoneCleanup(
+          owner.state,
+          owner.rootSessionId,
+          owner.scopeId,
+          { scopeId: owner.scopeId, scope: owner.scope },
+        );
+        this.orphanedTombstoneOwners.delete(key);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
     const tombstoneCleanups = [...this.orphanedTombstoneCleanups.values()]
       .filter((retained) => storageKey === undefined || retained.storageKey === storageKey);
     const tombstoneResults = await Promise.allSettled(
@@ -5436,6 +8320,7 @@ export class FlexHarness<TScope = unknown> {
       ...[...this.orphanedExecutionContexts.values()].map((owner) => owner.storageKey),
       ...[...this.orphanedProviderReleases.values()].map((retained) => retained.storageKey),
       ...[...this.orphanedTombstoneCleanups.values()].map((retained) => retained.storageKey),
+      ...[...this.orphanedTombstoneOwners.values()].map((owner) => owner.state.storageKey),
     ]);
   }
 
@@ -5443,7 +8328,18 @@ export class FlexHarness<TScope = unknown> {
     const scope = await this.scopeResolver.resolveScope(scopeId);
     this.assertOpen();
     validateIdentifier(scope.storageKey, 'resolved storageKey');
+    this.assertNoAmbientSlashCommandTeardown({ storageKey: scope.storageKey });
     const errors: unknown[] = [];
+    const listingSettlement = this.abortSlashCommandListings(
+      scope.storageKey,
+      this.trustInternalError(new FlexHarnessAbortError(scopeRetirementMessage)),
+    );
+    if (listingSettlement) await listingSettlement;
+    await this.abortSlashCommandExecutions(
+      scope.storageKey,
+      this.trustInternalError(new FlexHarnessAbortError(scopeRetirementMessage)),
+      errors,
+    );
     const stateLoad = this.stateLoads.get(scope.storageKey);
     if (!stateLoad) {
       const drain = this.storageDrains.get(scope.storageKey);
@@ -5515,8 +8411,11 @@ export class FlexHarness<TScope = unknown> {
       return;
     }
     if (state.lifecycle !== 'fenced') state.lifecycle = 'retiring';
-    const detachedCleanupAttempts = this.beginDetachedCleanupSettlement(state);
     const errors: unknown[] = [];
+    const listingSettlement = this.abortSlashCommandListings(storageKey, reason);
+    if (listingSettlement) await listingSettlement;
+    await this.abortSlashCommandExecutions(storageKey, reason, errors);
+    const detachedCleanupAttempts = this.beginDetachedCleanupSettlement(state);
     const contextFor = (sessionId: string) => invocation
       ? this.createCompactorContext(invocation.scopeId, invocation.scope, storageKey, sessionId)
       : undefined;
@@ -5585,6 +8484,21 @@ export class FlexHarness<TScope = unknown> {
           'lifecycle-close',
         ));
       }
+      const releaseContext = invocation ?? stored.compactorContext as
+        IFlexAgentContextInvocation<TScope> | undefined;
+      if (releaseContext) {
+        try {
+          await this.drainReversionReleases(
+            state,
+            stored,
+            releaseContext.scopeId,
+            releaseContext.scope,
+            true,
+          );
+        } catch (error) {
+          errors.push(error);
+        }
+      }
       this.purgeStoredPromptQueue(stored);
     }
     const roots = this.orderTombstoneRootsChildFirst(
@@ -5629,6 +8543,21 @@ export class FlexHarness<TScope = unknown> {
       if (!pending.controller.signal.aborted) pending.controller.abort(pendingAdmissionReason);
     }
     await Promise.all(pendingAdmissions.map((pending) => pending.settled));
+    const errors: unknown[] = [];
+    const listingSettlement = this.abortSlashCommandListings(
+      undefined,
+      this.trustInternalError(new FlexHarnessAbortError(
+        'The slash command listing was aborted because FlexHarness was disposed.',
+      )),
+    );
+    if (listingSettlement) await listingSettlement;
+    await this.abortSlashCommandExecutions(
+      undefined,
+      this.trustInternalError(new FlexHarnessAbortError(
+        'The slash command was aborted because FlexHarness was disposed.',
+      )),
+      errors,
+    );
     const loads = [...this.stateLoads.entries()];
     const results = await Promise.allSettled(loads.map(([storageKey, stateLoad]) =>
       this.drainStorage(
@@ -5638,7 +8567,6 @@ export class FlexHarness<TScope = unknown> {
           'The run was aborted because FlexHarness was disposed.',
         )),
       )));
-    const errors: unknown[] = [];
     for (const result of results) {
       if (result.status === 'rejected') this.appendUnexpectedErrors(errors, result.reason);
     }
@@ -5651,6 +8579,8 @@ export class FlexHarness<TScope = unknown> {
     this.listeners.clear();
     if (errors.length > 0) throw combineErrors(errors);
     this.compactorInvocationContext.disable();
+    this.slashCommandInvocationContext.disable();
+    this.slashCommandActivityContext.disable();
     this.stateLoads.clear();
     this.scopeAdmissions.clear();
     this.scopeRetirements.clear();
@@ -5658,6 +8588,45 @@ export class FlexHarness<TScope = unknown> {
     this.storageCompactorLifecycleControllers.clear();
   }
 
+  private async abortSlashCommandExecutions(
+    storageKey: string | undefined,
+    reason: FlexHarnessAbortError,
+    errors: unknown[],
+    sessionId?: string,
+  ): Promise<void> {
+    const active = [...this.activeSlashCommandExecutions.values()]
+      .filter((execution) =>
+        (storageKey === undefined || execution.storageKey === storageKey)
+        && (sessionId === undefined || execution.sessionId === sessionId));
+    for (const execution of active) {
+      if (!execution.controller.signal.aborted) execution.controller.abort(reason);
+    }
+    const awaited = active.filter((execution) => execution.kind !== 'prompt-admission');
+    const results = await Promise.allSettled(awaited.map((execution) => execution.completion));
+    for (let index = 0; index < results.length; index++) {
+      const result = results[index];
+      if (result.status === 'rejected' && awaited[index].kind === 'handler') {
+        this.appendUnexpectedErrors(errors, result.reason);
+      }
+    }
+  }
+
+  private abortSlashCommandListings(
+    storageKey: string | undefined,
+    reason: FlexHarnessAbortError,
+    sessionId?: string,
+  ): Promise<void> | undefined {
+    const active = [...this.activeSlashCommandListings]
+      .filter((listing) =>
+        (storageKey === undefined || listing.storageKey === storageKey)
+        && (sessionId === undefined || listing.sessionId === sessionId));
+    if (active.length === 0) return undefined;
+    for (const listing of active) {
+      if (!listing.controller.signal.aborted) listing.controller.abort(reason);
+    }
+    return Promise.allSettled(active.map((listing) => listing.completion)).then(() => undefined);
+  }
+
   private appendUnexpectedErrors(target: unknown[], error: unknown): void {
     if (error instanceof FlexHarnessRunError) {
       for (const nested of error.errors) this.appendUnexpectedErrors(target, nested);
@@ -5722,6 +8691,23 @@ export class FlexHarness<TScope = unknown> {
       }
       const state = await stateLoad;
       this.assertOpen();
+      if (state.lifecycle === 'fenced') {
+        const drain = this.storageDrains.get(scope.storageKey) ?? this.drainStorage(
+          scope.storageKey,
+          stateLoad,
+          this.trustInternalError(new FlexHarnessAbortError('The session namespace was fenced.')),
+          { scopeId, scope: scope.scope },
+        );
+        if (this.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
@@ -5756,6 +8742,29 @@ export class FlexHarness<TScope = unknown> {
     return this.trustInternalError(new FlexHarnessAbortError(scopeRetirementMessage));
   }
 
+  private ambientSlashCommandOwner(
+    criteria: { scopeId?: string; storageKey?: string; sessionId?: string } = {},
+  ): ISlashCommandInvocationOwner | ISlashCommandActivityOwner | undefined {
+    const matches = (owner: ISlashCommandInvocationOwner | ISlashCommandActivityOwner) => (
+      (criteria.scopeId === undefined || owner.scopeId === criteria.scopeId)
+      && (criteria.storageKey === undefined || owner.storageKey === criteria.storageKey)
+      && (criteria.sessionId === undefined || owner.sessionId === criteria.sessionId)
+    );
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner && matches(invocationOwner)) return invocationOwner;
+    const activityOwner = this.slashCommandActivityContext.getStore();
+    return activityOwner && matches(activityOwner) ? activityOwner : undefined;
+  }
+
+  private assertNoAmbientSlashCommandTeardown(
+    criteria: { scopeId?: string; storageKey?: string; sessionId?: string } = {},
+  ): void {
+    const owner = this.ambientSlashCommandOwner(criteria);
+    if (owner) {
+      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(owner.sessionId));
+    }
+  }
+
   private assertStateAcceptingWork(state: IStorageState): void {
     if (state.lifecycle !== 'active' || this.storageDrains.has(state.storageKey)) {
       throw this.createScopeRetirementError();
@@ -5805,6 +8814,17 @@ export class FlexHarness<TScope = unknown> {
     return stored;
   }
 
+  private completedReversionCandidates(stored: IStoredSessionState): IFlexReversionSegment[] {
+    return stored.reversionSegments.filter((segment) => segment.status === 'completed');
+  }
+
+  private visibleMessages(stored: IStoredSessionState): IFlexMessage[] {
+    const firstHiddenSegment = this.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);
+  }
+
   private requireMutableSession(state: IStorageState, sessionId: string): IStoredSessionState {
     const stored = this.requireSession(state, sessionId);
     const pending = [...state.pendingPermissions.values()].some((entry) =>
@@ -5819,7 +8839,7 @@ export class FlexHarness<TScope = unknown> {
   }
 
   private requireMessage(stored: IStoredSessionState, messageId: string): IFlexMessage {
-    const message = stored.messages.find((entry) => entry.messageId === messageId);
+    const message = this.visibleMessages(stored).find((entry) => entry.messageId === messageId);
     if (!message) throw new FlexHarnessNotFoundError('Message', messageId);
     return message;
   }