@modelprofile.com/flexharness 3.5.0 → 3.7.0

package/ts/classes.flexharness.ts

@@ -10,11 +10,18 @@ import {
   FlexHarnessQueueFullError,
   FlexHarnessRunError,
   FlexHarnessSessionBusyError,
+  FlexHarnessSlashCommandReentryError,
+  FlexHarnessSlashCommandUnavailableError,
   FlexHarnessStoreConflictError,
   FlexHarnessStoreCommitUncertainError,
   FlexHarnessValidationError,
   errorToInfo,
 } from './errors.js';
+import {
+  FLEX_REVERSION_DEFAULT_LIMITS,
+  FLEX_REVERSION_MAXIMUM_LIMITS,
+  FLEX_REVERSION_REFERENCE_MAX_BYTES,
+} from './interfaces.js';
 import type {
   IFlexAgentContextInvocation,
   IFlexAgentSessionPolicy,
@@ -41,20 +48,31 @@ import type {
   IFlexPromptQueueLimits,
   IFlexPromptOptions,
   IFlexPromptResult,
-  IFlexProjectionSnapshot,
+  IFlexProjectionSnapshotCurrent,
+  IFlexReversionLimits,
+  IFlexReversionSegment,
+  IFlexPendingReversionRelease,
+  IFlexRedoSessionResult,
   IFlexResolvedModel,
   IFlexResolvedScope,
+  IFlexResourceToolProviderDescriptor,
   IFlexRunFinishedEvent,
   IFlexScheduledPromptAdmission,
   IFlexSchedulePromptOptions,
   IFlexScopeSnapshot,
   IFlexSession,
   IFlexSessionTombstone,
+  IFlexSlashCommandDescriptor,
+  IFlexSlashCommandExecutionOptions,
+  IFlexSlashCommandHandlerRegistration,
+  IFlexSlashCommandTemplateRegistration,
   IFlexSubagentDefinition,
   IFlexTerminalProjection,
   IFlexToolHandle,
   IFlexToolMessagePart,
+  IFlexToolProviderContext,
   IFlexUncertainToolExecution,
+  IFlexUndoSessionResult,
   IFlexUpdateSessionOptions,
   IFlexUsage,
   IJsonObject,
@@ -71,7 +89,12 @@ import type {
   TFlexPrompt,
   TFlexPromptPart,
   TFlexPromptQueueStatus,
+  TFlexSlashCommandExecutionResult,
+  TFlexSlashCommandRegistration,
+  TFlexPendingReversion,
+  TFlexProjectionSnapshot,
   TFlexToolExecutionReconciliation,
+  TJsonValue,
 } from './interfaces.js';
 import { InMemoryFlexHarnessStores } from './classes.stores.js';
 import {
@@ -86,6 +109,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 =
@@ -102,6 +133,14 @@ interface IStoredSessionState {
   session: IFlexSession;
   messages: IFlexMessage[];
   stagedTerminals: IFlexTerminalProjection[];
+  reversionSegments: IFlexReversionSegment[];
+  revertCursor: number;
+  excludedRunIds: string[];
+  pendingReversion?: TFlexPendingReversion;
+  pendingReversionReleases: IFlexPendingReversionRelease[];
+  projectionSchemaVersion: 1 | 2;
+  projectionBaseline?: TFlexProjectionSnapshot;
+  projectionReconciliationRequired: boolean;
   projectionRevision: number;
   projectionQueue: Promise<void>;
   rememberedPermissionKeys: Set<string>;
@@ -149,6 +188,13 @@ interface IOrphanedTombstoneCleanup {
   completion: Promise<void>;
 }
 
+interface IOrphanedTombstoneOwner<TScope> {
+  state: IStorageState;
+  rootSessionId: string;
+  scopeId: string;
+  scope: TScope;
+}
+
 interface IOrphanedExecutionContextOwner {
   storageKey: string;
   sessionId: string;
@@ -158,6 +204,7 @@ interface IStorageState {
   storageKey: string;
   compactorLifecycleController: AbortController;
   scopeIdHint: string;
+  scopeContext: { scopeId: string; scope: unknown };
   revision: number;
   sessions: Map<string, IStoredSessionState>;
   retainedSessionCleanups: Map<string, IRetainedSessionCleanup>;
@@ -259,6 +306,32 @@ 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 IRunResultProjection {
   text: string;
   steps: number;
@@ -337,8 +410,17 @@ const defaultMaxSubagentDepth = 1;
 const maximumMaxSubagentDepth = 8;
 const defaultMaxSubagentCallsPerRun = 32;
 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.',
@@ -436,6 +518,40 @@ function validateIdentifier(value: string, name: string): void {
   }
 }
 
+function sha256Hex(value: string): string {
+  return plugins.crypto.createHash('sha256').update(value, 'utf8').digest('hex');
+}
+
+function createFlexResourceIdentityDigest(
+  resourceId: string,
+  attachmentRevision: number,
+): string {
+  validateUtf8String(resourceId, 'resourceId', maxResourceIdBytes, true);
+  if (!Number.isSafeInteger(attachmentRevision) || attachmentRevision < 0) {
+    throw new FlexHarnessValidationError('attachmentRevision must be a non-negative safe integer.');
+  }
+  return sha256Hex(JSON.stringify([resourceId, attachmentRevision]));
+}
+
+export function createFlexResourceToolNamespace(
+  resourceId: string,
+  attachmentRevision: number,
+): string {
+  const digest = createFlexResourceIdentityDigest(resourceId, attachmentRevision);
+  return `resource_${digest.slice(0, 16)}`;
+}
+
+export function createFlexResourceToolName(namespace: string, toolName: string): string {
+  if (!/^resource_[a-f0-9]{16}$/u.test(namespace)) {
+    throw new FlexHarnessValidationError('Resource tool namespace is invalid.');
+  }
+  validateUtf8String(toolName, 'resource tool name', maxResourceToolNameBytes, true);
+  const stem = toolName
+    .replace(/[^A-Za-z0-9_-]/gu, '_')
+    .slice(0, resourceToolStemLength) || 'tool';
+  return `${namespace}__${stem}__${sha256Hex(toolName).slice(0, 12)}`;
+}
+
 function validateUtf8String(
   value: unknown,
   name: string,
@@ -519,6 +635,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,
@@ -793,6 +992,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,
@@ -830,6 +1054,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> {
@@ -859,14 +1104,18 @@ export class FlexHarness<TScope = unknown> {
   private readonly scopeResolver: IFlexHarnessOptions<TScope>['scopeResolver'];
   private readonly modelResolver: IFlexHarnessOptions<TScope>['modelResolver'];
   private readonly toolProvider: IFlexHarnessOptions<TScope>['toolProvider'];
+  private readonly resourceToolProviderResolver: IFlexHarnessOptions<TScope>['resourceToolProviderResolver'];
   private readonly executionContextProvider: IFlexHarnessOptions<TScope>['executionContextProvider'];
   private readonly stores: IFlexHarnessStores;
   private readonly agentSessionPolicy: IFlexAgentSessionPolicy<TScope>;
   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 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>>();
@@ -884,10 +1133,16 @@ 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 deferredCompactorContexts = new WeakMap<
     IFlexAgentContextInvocation<unknown>,
     IFlexAgentContextInvocation<unknown>
@@ -906,14 +1161,18 @@ export class FlexHarness<TScope = unknown> {
     this.scopeResolver = options.scopeResolver;
     this.modelResolver = options.modelResolver;
     this.toolProvider = options.toolProvider;
+    this.resourceToolProviderResolver = options.resourceToolProviderResolver;
     this.executionContextProvider = options.executionContextProvider;
     this.stores = options.stores ?? new InMemoryFlexHarnessStores();
     this.agentSessionPolicy = normalizeAgentSessionPolicy(options.agentSessionPolicy);
     this.toolOutputLimits = resolveJsonLimits(options.toolOutputLimits);
     this.callbackLimits = resolveCallbackLimits(options.callbackLimits);
     this.promptQueueLimits = resolvePromptQueueLimits(options.promptQueueLimits);
+    this.reversionLimits = resolveReversionLimits(options.reversionLimits);
+    this.turnReversionProvider = options.turnReversionProvider;
     this.externalErrorProjector = options.externalErrorProjector;
     this.subagents = normalizeSubagents(options.subagents);
+    this.slashCommands = normalizeSlashCommands(options.slashCommands);
     this.maxSubagentDepth = resolveBoundedPositiveInteger(
       options.maxSubagentDepth,
       'maxSubagentDepth',
@@ -931,6 +1190,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))
@@ -1124,7 +1384,14 @@ export class FlexHarness<TScope = unknown> {
   }
 
   public async deleteSession(scopeId: string, sessionId: string): Promise<void> {
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner?.scopeId === scopeId && invocationOwner.sessionId === sessionId) {
+      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+    }
     const { scope, state } = await this.resolveState(scopeId);
+    if (invocationOwner?.storageKey === state.storageKey) {
+      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(invocationOwner.sessionId));
+    }
     validateIdentifier(sessionId, 'sessionId');
     await state.scopeQueue;
     const deletionKey = state.tombstones.get(sessionId)?.rootSessionId ?? sessionId;
@@ -1199,6 +1466,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));
@@ -1213,7 +1495,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(
@@ -1240,7 +1525,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(
@@ -1270,20 +1555,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)
@@ -1315,100 +1601,628 @@ 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(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.workspaceCaptured)
+        ? '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.workspaceCaptured && 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(
+        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(
+        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);
-    return publicSnapshot([
-      ...[...stored.outstandingPromptsById.values()].map((entry) => this.projectPromptQueueEntry(entry)),
-      ...stored.terminalPromptQueueEntries.values(),
-    ].sort((left, right) => left.queueSequence - right.queueSequence));
+  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;
   }
 
-  public async cancelPrompt(
-    scopeId: string,
-    sessionId: string,
-    queueId: string,
-  ): Promise<boolean> {
-    validateIdentifier(queueId, 'queueId');
+  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>(
+    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 completion = Promise.resolve().then(() => {
+      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>(
+    state: IStorageState,
+    sessionId: string,
+    operation: (signal: AbortSignal) => Promise<TResult>,
+  ): Promise<TResult> {
+    const controller = new AbortController();
+    const completion = Promise.resolve().then(() => 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(
+      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(),
+    ].sort((left, right) => left.queueSequence - right.queueSequence));
+  }
+
+  public async cancelPrompt(
+    scopeId: string,
+    sessionId: string,
+    queueId: string,
+  ): Promise<boolean> {
+    validateIdentifier(queueId, 'queueId');
     requireTransferIdentifier(queueId, 'queueId');
     const { scope, state } = await this.resolveState(scopeId);
     const stored = this.requireSession(state, sessionId);
@@ -1576,15 +2390,505 @@ 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);
+    if (!this.agentSessionPolicy.contextCompactor) {
+      throw new FlexHarnessSlashCommandUnavailableError(
+        'compact',
+        'No context compactor is configured.',
+      );
+    }
+    this.requireSessionAvailableForSlashCommand(state, stored, 'compact');
+    await this.trackSlashCommandExecution(
+      state,
+      sessionId,
+      'operation',
+      undefined,
+      async (signal) => {
+        await this.commitRevertedBranch(state, stored, scopeId, scope.scope);
+        await this.compactStoredSession(scopeId, scope.scope, state, stored, signal);
+      },
+    );
+  }
+
+  private async compactStoredSession(
+    scopeId: string,
+    scope: TScope,
+    state: IStorageState,
+    stored: IStoredSessionState,
+    signal?: AbortSignal,
+  ): Promise<void> {
     try {
       await this.withCompactorContext(
-        this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
-        () => stored.agentSession.compact(),
+        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, 'compaction');
+      throw this.projectOperationError(
+        error,
+        'agentSession',
+        scopeId,
+        stored.session.sessionId,
+        'compaction',
+      );
+    }
+  }
+
+  public async undoSession(
+    scopeId: string,
+    sessionId: string,
+    signal?: AbortSignal,
+  ): Promise<IFlexUndoSessionResult> {
+    const result = await this.changeReversionCursor(scopeId, sessionId, 'undo', signal);
+    return Object.freeze({ revertedRunId: result });
+  }
+
+  public async redoSession(
+    scopeId: string,
+    sessionId: string,
+    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 candidates = this.completedReversionCandidates(stored);
+    const candidate = direction === 'undo'
+      ? candidates[stored.revertCursor - 1]
+      : candidates[stored.revertCursor];
+    if (!candidate) return undefined;
+    const candidateIndex = stored.reversionSegments.findIndex((segment) => segment.runId === candidate.runId);
+    const start = candidate === candidates[0] ? 0 : candidateIndex;
+    const next = candidates[direction === 'undo' ? stored.revertCursor : stored.revertCursor + 1];
+    const end = next
+      ? stored.reversionSegments.findIndex((segment) => segment.runId === next.runId)
+      : stored.reversionSegments.length;
+    return {
+      target: candidate,
+      segments: stored.reversionSegments.slice(start, end),
+      toCursor: stored.revertCursor + (direction === 'undo' ? -1 : 1),
+    };
+  }
+
+  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(
+      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 candidates = this.completedReversionCandidates(stored);
+          const target = candidates[direction === 'undo' ? pending.fromCursor - 1 : pending.fromCursor];
+          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.captureId !== undefined && 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)?.workspaceCaptured)
+      && !this.turnReversionProvider
+    ) {
+      throw new FlexHarnessValidationError(
+        'Pending workspace reversion recovery requires its turn reversion provider.',
+      );
+    }
+    const orderedRunIds = pending.direction === 'undo'
+      ? [...pending.segmentRunIds].reverse()
+      : [...pending.segmentRunIds];
+    for (const runId of orderedRunIds) {
+      if (pending.appliedRunIds.includes(runId)) continue;
+      if (signal?.aborted) {
+        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.workspaceCaptured) {
+        if (!this.turnReversionProvider || !segment.captureId || segment.workspaceReference === undefined) {
+          throw new FlexHarnessValidationError('Pending workspace reversion segment is incomplete.');
+        }
+        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) {
+              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);
+    }
+    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);
+      if (current.appliedRunIds.length === 0) {
+        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.');
+    const outcome = outcomes.get(pending.runId);
+    const reference = await this.resolveReversionCaptureReference(
+      state,
+      scopeId,
+      scope,
+      stored.session.sessionId,
+      pending.runId,
+      pending.captureId,
+      pending.state,
+    );
+    if (reference === 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';
+      segment.workspaceReference = cloneSerializable(reference);
+      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(
@@ -1596,21 +2900,51 @@ export class FlexHarness<TScope = unknown> {
       validateIdentifier(compactionEventId, 'compactionEventId');
       requireTransferIdentifier(compactionEventId, 'compactionEventId');
     }
-    const { state } = await this.resolveState(scopeId);
+    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 {
-      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,
-      });
+      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(
@@ -1683,6 +3017,10 @@ export class FlexHarness<TScope = unknown> {
   }
 
   public retireScope(scopeId: string): Promise<void> {
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner?.scopeId === scopeId) {
+      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(invocationOwner.sessionId));
+    }
     this.assertOpen();
     validateIdentifier(scopeId, 'scopeId');
     const existing = this.scopeRetirements.get(scopeId);
@@ -1702,6 +3040,12 @@ export class FlexHarness<TScope = unknown> {
 
   public async dispose(): Promise<void> {
     if (this.disposePromise) return this.disposePromise;
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner) {
+      throw this.trustInternalError(
+        new FlexHarnessSlashCommandReentryError(invocationOwner.sessionId),
+      );
+    }
     this.closed = true;
     let disposal!: Promise<void>;
     disposal = this.disposeInternal().catch((error) => {
@@ -1721,16 +3065,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 = {
@@ -1765,6 +3109,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.',
@@ -1833,6 +3191,7 @@ export class FlexHarness<TScope = unknown> {
       return {
         admission: Object.freeze({ queueId: queued.queueId, completion }),
         started,
+        queued,
       };
     } finally {
       for (const signal of admissionSignals) {
@@ -1961,6 +3320,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(
@@ -1974,6 +3334,29 @@ 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;
+          run.stored.reversionSegments.push({
+            runId: run.runId,
+            userMessageId: reservation.userMessage.messageId,
+            status: 'capturing',
+            contextAvailable: true,
+            eventIds: [],
+            workspaceCaptured: captureId !== undefined,
+            ...(captureId === undefined ? {} : { captureId }),
+          });
+          if (captureId) {
+            run.stored.pendingReversion = {
+              kind: 'capture',
+              runId: run.runId,
+              captureId,
+              state: 'preparing',
+            };
+          }
+        }
       });
       projectionReserved = true;
       run.reservedUserMessage = publicSnapshot(reservation.userMessage);
@@ -2194,6 +3577,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, () => {
@@ -2224,6 +3608,13 @@ export class FlexHarness<TScope = unknown> {
       }
       this.emitTerminalProjection(run, terminal);
       this.emitFinalRunEvent(run, terminal.assistantMessage, undefined, false);
+      await this.drainReversionReleases(
+        run.state,
+        run.stored,
+        run.scopeId,
+        run.scope as TScope,
+        false,
+      );
       return {
         runId: run.runId,
         sessionId: run.sessionId,
@@ -2264,6 +3655,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 {
@@ -2318,6 +3717,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;
   }
 
@@ -2327,6 +3733,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')) {
@@ -2353,16 +3760,18 @@ export class FlexHarness<TScope = unknown> {
         (value): IResolverOutcome<IFlexResolvedModel> => ({ source: 'model', success: true, value }),
         (error): IResolverOutcome<IFlexResolvedModel> => ({ source: 'model', success: false, error }),
       );
+    const toolProviderContext: Readonly<IFlexToolProviderContext<TScope>> = Object.freeze({
+      scopeId: run.scopeId,
+      scope: run.scope as TScope,
+      sessionId: run.sessionId,
+      runId: run.runId,
+      ...resolverRelationship,
+      signal,
+      requestPermission: (request: IFlexPermissionRequestInput) =>
+        this.requestPermission(run.state, run, request),
+    });
     const toolOutcome = Promise.resolve()
-      .then(() => this.toolProvider?.provideTools(Object.freeze({
-        scopeId: run.scopeId,
-        scope: run.scope as TScope,
-        sessionId: run.sessionId,
-        runId: run.runId,
-        ...resolverRelationship,
-        signal,
-        requestPermission: (request) => this.requestPermission(run.state, run, request),
-      })))
+      .then(() => this.provideRunToolHandle(run, toolProviderContext))
       .then(
         (value): IResolverOutcome<IFlexToolHandle | undefined> => ({ source: 'tools', success: true, value }),
         (error): IResolverOutcome<IFlexToolHandle | undefined> => ({ source: 'tools', success: false, error }),
@@ -2992,39 +4401,781 @@ 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 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,
+  ) {
+    return this.withReversionMaintenanceSignal((signal) =>
+      this.turnReversionProvider!.inspectCapture(Object.freeze({
+        scopeId,
+        scope,
+        storageKey,
+        sessionId,
+        runId,
+        captureId,
+        signal,
+      })));
+  }
+
+  private finalizeReversionCapture(
+    scopeId: string,
+    scope: TScope,
+    storageKey: string,
+    sessionId: string,
+    runId: string,
+    captureId: string,
+  ) {
+    return this.withReversionMaintenanceSignal((signal) =>
+      this.turnReversionProvider!.finalize(Object.freeze({
+        scopeId,
+        scope,
+        storageKey,
+        sessionId,
+        runId,
+        captureId,
+        signal,
+      })));
+  }
+
+  private async resolveReversionCaptureReference(
+    state: IStorageState,
+    scopeId: string,
+    scope: TScope,
+    sessionId: string,
+    runId: string,
+    captureId: string,
+    durableState: 'preparing' | 'prepared' | 'finalizing',
+  ): Promise<TJsonValue | 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 reference = inspection.reference;
+    if (inspection.status === 'prepared') {
+      try {
+        reference = 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' || finalInspection.reference === undefined) {
+          if (finalInspection.status === 'unknown') state.lifecycle = 'fenced';
+          throw this.projectOperationError(error, 'turnReversion', scopeId, sessionId, captureId);
+        }
+        reference = finalInspection.reference;
+      }
+    }
+    if (reference === undefined) {
+      state.lifecycle = 'fenced';
+      throw new FlexHarnessValidationError('Finalized reversion capture has no reference.');
+    }
+    return this.normalizeReversionReference(reference);
+  }
+
+  private normalizeReversionReference(reference: unknown): TJsonValue {
+    return normalizeJsonValue(reference, {
+      maxDepth: this.toolOutputLimits.maxDepth,
+      maxBytes: Math.min(
+        this.toolOutputLimits.maxBytes,
+        FLEX_REVERSION_REFERENCE_MAX_BYTES,
+      ),
+    });
+  }
+
+  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);
+    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.captureId) {
+      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;
+    }
+    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.');
+    }
+    const reference = await this.resolveReversionCaptureReference(
+      run.state,
+      run.scopeId,
+      run.scope as TScope,
+      run.sessionId,
+      run.runId,
+      captureId,
+      pending.state,
+    );
+    if (reference === 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;
+      segment.workspaceReference = reference;
+      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 hiddenReversionSegments(stored: IStoredSessionState): IFlexReversionSegment[] {
+    const candidates = this.completedReversionCandidates(stored);
+    const firstHidden = candidates[stored.revertCursor];
+    if (!firstHidden) return [];
+    const index = stored.reversionSegments.findIndex((segment) => segment.runId === firstHidden.runId);
+    if (index < 0) return [];
+    return stored.reversionSegments.slice(firstHidden === candidates[0] ? 0 : index);
+  }
+
+  private enqueueReversionRelease(
+    stored: IStoredSessionState,
+    segment: IFlexReversionSegment,
+  ): void {
+    if (!segment.workspaceCaptured) return;
+    if (segment.captureId === undefined || segment.workspaceReference === undefined) {
+      throw new FlexHarnessValidationError('Capture-backed segment has no releasable workspace reference.');
+    }
+    if (stored.pendingReversionReleases.some((release) => release.captureId === segment.captureId)) {
+      return;
+    }
+    if (stored.pendingReversionReleases.length >= this.reversionLimits.maxPendingReversionReleases) {
+      throw new FlexHarnessValidationError('Pending reversion release limit was reached.');
+    }
+    stored.pendingReversionReleases.push({
+      runId: segment.runId,
+      captureId: segment.captureId,
+      reference: cloneSerializable(segment.workspaceReference),
+    });
+  }
+
+  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.workspaceCaptured && 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];
+      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;
+    const loadedProjection = await this.stores.projections.load(storageKey, sessionId);
+    if (loadedProjection?.schemaVersion !== 2) return;
+    let projection: IFlexProjectionSnapshotCurrent = loadedProjection;
+    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.workspaceCaptured) {
+            if (!this.turnReversionProvider || !segment.captureId || segment.workspaceReference === undefined) {
+              throw new FlexHarnessValidationError(
+                'Pending workspace reversion deletion requires its turn reversion provider.',
+              );
+            }
+            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') {
+              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') throw error;
+              }
+            }
+          }
+          pending.appliedRunIds.push(runId);
+          const next = { ...projection, revision: projection.revision + 1 };
+          await this.stores.projections.save(storageKey, sessionId, next, projection.revision);
+          projection = next;
+        }
+        const { pendingReversion: _pendingReversion, ...completedProjection } = projection;
+        const completed: IFlexProjectionSnapshotCurrent = {
+          ...completedProjection,
+          revision: projection.revision + 1,
+          revertCursor: pending.toCursor,
+        };
+        await this.stores.projections.save(storageKey, sessionId, completed, projection.revision);
+        projection = completed;
+      }
+      const recoveredProjection = await this.stores.projections.load(storageKey, sessionId);
+      if (recoveredProjection?.schemaVersion !== 2) return;
+      projection = recoveredProjection;
+    }
+    const hasWorkspaceCaptures = projection.reversionSegments.some((segment) => segment.captureId)
+      || projection.pendingReversionReleases.length > 0
+      || projection.pendingReversion?.kind === 'capture';
+    if (!this.turnReversionProvider) {
+      if (hasWorkspaceCaptures) {
+        throw new FlexHarnessValidationError(
+          'Capture-backed session deletion requires its turn reversion provider.',
+        );
+      }
+      return;
+    }
+    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),
         });
       }
-      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,
+    const unresolvedCaptures = new Map<string, {
+      runId: string;
+      captureId: string;
+      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,
+        });
+      }
+    }
+    if (projection.pendingReversion?.kind === 'capture') {
+      unresolvedCaptures.set(projection.pendingReversion.captureId, {
+        runId: projection.pendingReversion.runId,
+        captureId: projection.pendingReversion.captureId,
+        durableState: projection.pendingReversion.state,
+      });
+    }
+    for (const capture of unresolvedCaptures.values()) {
+      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') {
+        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 reference = inspection.reference;
+      if (inspection.status === 'prepared') {
+        try {
+          reference = 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' || finalInspection.reference === undefined) {
+            throw this.projectOperationError(
+              error,
+              'turnReversion',
+              scopeId,
+              sessionId,
+              `release:${capture.captureId}`,
+            );
           }
-        : {}),
-    };
+          reference = finalInspection.reference;
+        }
+      }
+      if (reference === undefined) {
+        throw new FlexHarnessValidationError('Deleted session capture has no release reference.');
+      }
+      releases.set(capture.captureId, {
+        runId: capture.runId,
+        captureId: capture.captureId,
+        reference: this.normalizeReversionReference(reference),
+      });
+    }
+    if (stored) {
+      await this.mutateProjection(state, stored, () => {
+        for (const release of releases.values()) {
+          if (!stored.pendingReversionReleases.some((entry) => entry.captureId === release.captureId)) {
+            stored.pendingReversionReleases.push(cloneSerializable(release));
+          }
+        }
+      }, true);
+    } else {
+      const missing = [...releases.values()].filter((release) =>
+        !projection.pendingReversionReleases.some((entry) => entry.captureId === release.captureId));
+      if (missing.length > 0) {
+        const next: IFlexProjectionSnapshotCurrent = {
+          ...projection,
+          revision: projection.revision + 1,
+          pendingReversionReleases: [
+            ...projection.pendingReversionReleases,
+            ...missing.map((release) => cloneSerializable(release)),
+          ],
+        };
+        await this.stores.projections.save(storageKey, sessionId, next, projection.revision);
+        projection = next;
+      }
+    }
+    for (const release of releases.values()) {
+      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}`,
+        );
+      }
+    }
   }
 
   private async promoteCompletedTerminal(
@@ -3644,6 +5795,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'));
@@ -3684,6 +5842,161 @@ export class FlexHarness<TScope = unknown> {
     }
   }
 
+  private async provideRunToolHandle(
+    run: IActiveRun,
+    context: Readonly<IFlexToolProviderContext<TScope>>,
+  ): Promise<IFlexToolHandle | undefined> {
+    if (!this.resourceToolProviderResolver) return this.toolProvider?.provideTools(context);
+
+    const resolverContext = Object.freeze({
+      scopeId: context.scopeId,
+      scope: context.scope,
+      sessionId: context.sessionId,
+      runId: context.runId,
+      ...(context.parentSessionId === undefined ? {} : { parentSessionId: context.parentSessionId }),
+      ...(context.agent === undefined ? {} : { agent: context.agent }),
+      signal: context.signal,
+    });
+    const resolved = await this.resourceToolProviderResolver.resolveResourceToolProviders(resolverContext);
+    const descriptors = this.normalizeResourceToolProviderDescriptors(resolved);
+    const owned: Array<{ handle: IFlexToolHandle; closed: boolean }> = [];
+    const tools: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    const closeOwned = async (): Promise<void> => {
+      const errors: unknown[] = [];
+      for (const entry of [...owned].reverse()) {
+        if (entry.closed || !entry.handle.close) continue;
+        try {
+          await entry.handle.close();
+          entry.closed = true;
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      if (errors.length > 0) throw combineErrors(errors);
+    };
+    try {
+      context.signal.throwIfAborted();
+      const applicationHandle = this.normalizeToolHandle(
+        run,
+        await this.toolProvider?.provideTools(context),
+      );
+      if (applicationHandle) {
+        owned.push({ handle: applicationHandle, closed: false });
+        for (const [toolName, tool] of Object.entries(applicationHandle.tools)) {
+          tools[toolName] = tool;
+        }
+      }
+      for (const descriptor of descriptors) {
+        context.signal.throwIfAborted();
+        const namespace = createFlexResourceToolNamespace(
+          descriptor.resourceId,
+          descriptor.attachmentRevision,
+        );
+        const resourceIdentity = createFlexResourceIdentityDigest(
+          descriptor.resourceId,
+          descriptor.attachmentRevision,
+        );
+        const resourceContext = Object.freeze({
+          ...context,
+          requestPermission: (request: IFlexPermissionRequestInput) => context.requestPermission({
+            ...request,
+            kind: `resource.${resourceIdentity}.${request.kind}`,
+            ...(request.rememberKey === undefined
+              ? {}
+              : { rememberKey: `resource:${resourceIdentity}:${request.rememberKey}` }),
+            metadata: {
+              resourceId: descriptor.resourceId,
+              attachmentRevision: descriptor.attachmentRevision,
+              resourceIdentity,
+              toolNamespace: namespace,
+              ...(request.metadata === undefined ? {} : { providerMetadata: request.metadata }),
+            },
+          }),
+        });
+        const handle = this.normalizeToolHandle(
+          run,
+          await descriptor.provider.provideTools(resourceContext),
+        );
+        if (!handle) continue;
+        owned.push({ handle, closed: false });
+        for (const [toolName, tool] of Object.entries(handle.tools)) {
+          const exposedName = createFlexResourceToolName(namespace, toolName);
+          if (Object.prototype.hasOwnProperty.call(tools, exposedName)) {
+            throw new FlexHarnessValidationError(`Duplicate exposed tool "${exposedName}".`);
+          }
+          tools[exposedName] = tool;
+        }
+      }
+      if (owned.length === 0 && Object.keys(tools).length === 0) return undefined;
+      return {
+        tools: tools as TFlexAgentToolSet,
+        ...(owned.some((entry) => entry.handle.close) ? { close: closeOwned } : {}),
+      };
+    } catch (error) {
+      if (owned.some((entry) => entry.handle.close && !entry.closed)) {
+        try {
+          await this.closePartialToolHandle({ tools: {}, close: closeOwned }, run);
+        } catch (cleanupError) {
+          throw combineErrors([error, cleanupError]);
+        }
+      }
+      throw error;
+    }
+  }
+
+  private normalizeResourceToolProviderDescriptors(
+    descriptors: readonly IFlexResourceToolProviderDescriptor<TScope>[],
+  ): IFlexResourceToolProviderDescriptor<TScope>[] {
+    if (!Array.isArray(descriptors) || descriptors.length > maxResourceToolProviders) {
+      throw new FlexHarnessValidationError(
+        `Resource tool providers must be an array with at most ${maxResourceToolProviders} descriptors.`,
+      );
+    }
+    const resourceIds = new Set<string>();
+    const namespaces = new Set<string>();
+    return descriptors.map((descriptor, index) => {
+      if (
+        !descriptor
+        || typeof descriptor !== 'object'
+        || Array.isArray(descriptor)
+        || ![Object.prototype, null].includes(Object.getPrototypeOf(descriptor))
+      ) {
+        throw new FlexHarnessValidationError(`Resource tool provider descriptor ${index} is invalid.`);
+      }
+      const unsupported = Object.keys(descriptor).find(
+        (key) => !['resourceId', 'attachmentRevision', 'provider'].includes(key),
+      );
+      if (unsupported) {
+        throw new FlexHarnessValidationError(
+          `Resource tool provider descriptor ${index} does not support "${unsupported}".`,
+        );
+      }
+      const resourceId = descriptor.resourceId;
+      const attachmentRevision = descriptor.attachmentRevision;
+      const provider = descriptor.provider;
+      const provideTools = provider?.provideTools;
+      const namespace = createFlexResourceToolNamespace(resourceId, attachmentRevision);
+      if (resourceIds.has(resourceId)) {
+        throw new FlexHarnessValidationError(`Duplicate resourceId "${resourceId}".`);
+      }
+      if (namespaces.has(namespace)) {
+        throw new FlexHarnessValidationError(`Duplicate resource tool namespace "${namespace}".`);
+      }
+      if (!provider || typeof provideTools !== 'function') {
+        throw new FlexHarnessValidationError(`Resource tool provider descriptor ${index} has no tool provider.`);
+      }
+      resourceIds.add(resourceId);
+      namespaces.add(namespace);
+      return {
+        resourceId,
+        attachmentRevision,
+        provider: {
+          provideTools: (context) => provideTools.call(provider, context),
+        },
+      };
+    });
+  }
+
   private async closePartialToolHandle(handle: IFlexToolHandle, run: IActiveRun): Promise<void> {
     try {
       await handle.close?.();
@@ -3861,6 +6174,7 @@ export class FlexHarness<TScope = unknown> {
       storageKey,
       compactorLifecycleController,
       scopeIdHint: scopeId,
+      scopeContext: { scopeId, scope },
       revision: snapshot.revision,
       sessions: new Map(),
       retainedSessionCleanups: new Map(),
@@ -3885,7 +6199,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()) {
@@ -3916,6 +6237,13 @@ 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);
@@ -3931,6 +6259,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)),
       );
@@ -3963,6 +6301,12 @@ export class FlexHarness<TScope = unknown> {
       session,
       messages: [],
       stagedTerminals: [],
+      reversionSegments: [],
+      revertCursor: 0,
+      excludedRunIds: [],
+      pendingReversionReleases: [],
+      projectionSchemaVersion: 2,
+      projectionReconciliationRequired: false,
       projectionRevision: 0,
       projectionQueue: Promise.resolve(),
       rememberedPermissionKeys: new Set(),
@@ -4029,6 +6373,7 @@ export class FlexHarness<TScope = unknown> {
       throw combineErrors(acquisitionErrors);
     }
     const projection = projectionResult.value;
+    const projectionV2 = projection?.schemaVersion === 2 ? projection : undefined;
     const permission = permissionResult.value;
     const eventStore = eventStoreResult.value;
     const jobStore = jobStoreResult.value;
@@ -4059,6 +6404,20 @@ export class FlexHarness<TScope = unknown> {
         session: cloneSerializable(metadata),
         messages: cloneSerializable(projection?.messages ?? []),
         stagedTerminals: cloneSerializable(projection?.stagedTerminals ?? []),
+        reversionSegments: cloneSerializable(projectionV2?.reversionSegments ?? []),
+        revertCursor: projectionV2?.revertCursor ?? 0,
+        excludedRunIds: cloneSerializable(projectionV2?.excludedRunIds ?? []),
+        ...(projectionV2?.pendingReversion === undefined
+          ? {}
+          : { pendingReversion: cloneSerializable(projectionV2.pendingReversion) }),
+        pendingReversionReleases: cloneSerializable(
+          projectionV2?.pendingReversionReleases ?? [],
+        ),
+        projectionSchemaVersion: projection?.schemaVersion ?? 2,
+        projectionReconciliationRequired: false,
+        ...(projection?.schemaVersion === 1
+          ? { projectionBaseline: cloneSerializable(projection) }
+          : {}),
         projectionRevision: projection?.revision ?? 0,
         projectionQueue: Promise.resolve(),
         rememberedPermissionKeys: new Set(permission?.rememberedPermissionKeys ?? []),
@@ -4107,7 +6466,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
           ? {
@@ -4124,7 +6485,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,
@@ -4191,13 +6559,37 @@ 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 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),
@@ -4234,6 +6626,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;
@@ -4260,6 +6683,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;
@@ -4270,6 +6698,9 @@ export class FlexHarness<TScope = unknown> {
         snapshot,
         expected,
       );
+      stored.projectionSchemaVersion = 2;
+      delete stored.projectionBaseline;
+      stored.projectionReconciliationRequired = false;
       stored.projectionRevision = snapshot.revision;
     }
     return beforeSession !== JSON.stringify(stored.session);
@@ -4429,18 +6860,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: 2,
         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 {
@@ -4457,6 +6917,9 @@ export class FlexHarness<TScope = unknown> {
           snapshot,
           beforeRevision,
         );
+        stored.projectionSchemaVersion = 2;
+        delete stored.projectionBaseline;
+        stored.projectionReconciliationRequired = false;
         stored.projectionRevision = snapshot.revision;
         return result;
       } catch (error) {
@@ -4465,11 +6928,13 @@ export class FlexHarness<TScope = unknown> {
           throw error;
         }
         if (error instanceof FlexHarnessStoreCommitUncertainError) {
+          stored.projectionSchemaVersion = 2;
+          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(
@@ -4480,6 +6945,9 @@ export class FlexHarness<TScope = unknown> {
           reconciliationError = loadError;
         }
         if (current && JSON.stringify(current) === JSON.stringify(snapshot)) {
+          stored.projectionSchemaVersion = 2;
+          delete stored.projectionBaseline;
+          stored.projectionReconciliationRequired = false;
           stored.projectionRevision = snapshot.revision;
           throw error;
         }
@@ -4490,6 +6958,8 @@ export class FlexHarness<TScope = unknown> {
           restore();
           throw error;
         }
+        stored.projectionSchemaVersion = 2;
+        stored.projectionReconciliationRequired = true;
         stored.projectionRevision = snapshot.revision;
         state.lifecycle = 'fenced';
         throw reconciliationError === undefined
@@ -4598,15 +7068,54 @@ export class FlexHarness<TScope = unknown> {
   private createProjectionSnapshot(
     stored: IStoredSessionState,
     revision: number,
-  ): IFlexProjectionSnapshot {
+  ): IFlexProjectionSnapshotCurrent {
     return {
-      schemaVersion: 1,
+      schemaVersion: 2,
       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 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.');
+    }
+    stored.messages = cloneSerializable(projection.messages);
+    stored.stagedTerminals = cloneSerializable(projection.stagedTerminals);
+    if (projection.schemaVersion === 2) {
+      stored.reversionSegments = cloneSerializable(projection.reversionSegments);
+      stored.revertCursor = projection.revertCursor;
+      stored.excludedRunIds = cloneSerializable(projection.excludedRunIds);
+      if (projection.pendingReversion === undefined) delete stored.pendingReversion;
+      else stored.pendingReversion = cloneSerializable(projection.pendingReversion);
+      stored.pendingReversionReleases = cloneSerializable(projection.pendingReversionReleases);
+      delete stored.projectionBaseline;
+    } else {
+      stored.reversionSegments = [];
+      stored.revertCursor = 0;
+      stored.excludedRunIds = [];
+      delete stored.pendingReversion;
+      stored.pendingReversionReleases = [];
+      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),
@@ -4715,15 +7224,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,
         )
@@ -4796,6 +7309,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;
       }
@@ -4983,6 +7511,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,
@@ -5188,6 +7736,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(
@@ -5237,6 +7799,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),
     ]);
   }
 
@@ -5244,7 +7807,23 @@ export class FlexHarness<TScope = unknown> {
     const scope = await this.scopeResolver.resolveScope(scopeId);
     this.assertOpen();
     validateIdentifier(scope.storageKey, 'resolved storageKey');
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner?.storageKey === scope.storageKey) {
+      throw this.trustInternalError(
+        new FlexHarnessSlashCommandReentryError(invocationOwner.sessionId),
+      );
+    }
     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);
@@ -5386,6 +7965,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(
@@ -5430,6 +8024,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(
@@ -5439,7 +8048,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);
     }
@@ -5452,6 +8060,7 @@ export class FlexHarness<TScope = unknown> {
     this.listeners.clear();
     if (errors.length > 0) throw combineErrors(errors);
     this.compactorInvocationContext.disable();
+    this.slashCommandInvocationContext.disable();
     this.stateLoads.clear();
     this.scopeAdmissions.clear();
     this.scopeRetirements.clear();
@@ -5459,6 +8068,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);
@@ -5606,6 +8254,18 @@ 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 firstHiddenUnit = this.reversionUnit(stored, 'redo');
+    const firstHiddenSegment = firstHiddenUnit?.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) =>
@@ -5620,7 +8280,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;
   }