@modelprofile.com/flexharness 3.7.0 → 4.0.0

package/ts/classes.flexharness.ts

@@ -18,16 +18,23 @@ import {
   errorToInfo,
 } from './errors.js';
 import {
+  FLEX_PROJECT_MANAGEMENT_LIMITS,
+  FLEX_REVERSION_MAX_AFFECTED_WORKSPACES,
   FLEX_REVERSION_DEFAULT_LIMITS,
   FLEX_REVERSION_MAXIMUM_LIMITS,
+  FLEX_REVERSION_REASON_CODE_MAX_BYTES,
   FLEX_REVERSION_REFERENCE_MAX_BYTES,
+  FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES,
+  FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES,
 } from './interfaces.js';
 import type {
   IFlexAgentContextInvocation,
   IFlexAgentSessionPolicy,
+  IFlexAffectedWorkspace,
   IFlexAttachmentMessagePart,
   IFlexBackgroundExecution,
   IFlexCallbackLimits,
+  IFlexCreateProjectTaskInput,
   IFlexCreateSessionOptions,
   IFlexErrorInfo,
   IFlexEventArchiveMetadata,
@@ -42,6 +49,15 @@ import type {
   IFlexPermissionRequest,
   IFlexPermissionRequestInput,
   IFlexPermissionSnapshot,
+  IFlexProjectGoalResult,
+  IFlexProjectManagementSnapshot,
+  IFlexProjectManagementTombstone,
+  IFlexProjectManagementWriteContext,
+  IFlexProjectScratchpadResult,
+  IFlexProjectStateResult,
+  IFlexProjectTask,
+  IFlexProjectTaskResult,
+  IFlexProjectTasksResult,
   IFlexPromptAdmission,
   IFlexPromptQueueAdmission,
   IFlexPromptQueueEntry,
@@ -61,6 +77,8 @@ import type {
   IFlexSchedulePromptOptions,
   IFlexScopeSnapshot,
   IFlexSession,
+  IFlexSessionReversionGroup,
+  IFlexSessionReversionInfo,
   IFlexSessionTombstone,
   IFlexSlashCommandDescriptor,
   IFlexSlashCommandExecutionOptions,
@@ -74,6 +92,7 @@ import type {
   IFlexUncertainToolExecution,
   IFlexUndoSessionResult,
   IFlexUpdateSessionOptions,
+  IFlexUpdateProjectTaskInput,
   IFlexUsage,
   IJsonObject,
   TFlexAgentRunResult,
@@ -86,6 +105,8 @@ import type {
   TFlexHarnessEventListener,
   TFlexMessagePart,
   TFlexPermissionDecision,
+  TFlexProjectTaskPriority,
+  TFlexProjectTaskStatus,
   TFlexPrompt,
   TFlexPromptPart,
   TFlexPromptQueueStatus,
@@ -93,6 +114,9 @@ import type {
   TFlexSlashCommandRegistration,
   TFlexPendingReversion,
   TFlexProjectionSnapshot,
+  TFlexReversionPolicy,
+  TFlexSessionReversionGroupKind,
+  TFlexTurnReversionFinalizedOutcome,
   TFlexToolExecutionReconciliation,
   TJsonValue,
 } from './interfaces.js';
@@ -104,6 +128,11 @@ import {
   normalizeJsonValue,
   resolveJsonLimits,
 } from './utils.json.js';
+import {
+  assertFlexProjectManagementRecord,
+  assertFlexProjectManagementSnapshot,
+  createEmptyFlexProjectManagementSnapshot,
+} from './utils.projectmanagement.js';
 import {
   hydrateAgentMessages,
   normalizeFlexPrompt,
@@ -138,7 +167,7 @@ interface IStoredSessionState {
   excludedRunIds: string[];
   pendingReversion?: TFlexPendingReversion;
   pendingReversionReleases: IFlexPendingReversionRelease[];
-  projectionSchemaVersion: 1 | 2;
+  projectionSchemaVersion: 1 | 2 | 3;
   projectionBaseline?: TFlexProjectionSnapshot;
   projectionReconciliationRequired: boolean;
   projectionRevision: number;
@@ -168,6 +197,18 @@ interface IRetainedSessionCleanup {
   domainsCompleted: boolean;
 }
 
+interface IReversionGroup {
+  target: IFlexReversionSegment;
+  segments: IFlexReversionSegment[];
+  kind: TFlexSessionReversionGroupKind;
+  affectedWorkspaces: IFlexAffectedWorkspace[];
+  affectedWorkspacesTruncated: boolean;
+}
+
+type TNormalizedCaptureInspection =
+  | { status: 'missing' | 'prepared' | 'unknown' }
+  | { status: 'finalized'; outcome: TFlexTurnReversionFinalizedOutcome };
+
 interface IDetachedCleanup {
   cleanup: () => Promise<void> | void;
   projectError: (error: unknown) => Error;
@@ -332,6 +373,12 @@ interface ISlashCommandInvocationOwner {
   sessionKey: string;
 }
 
+interface ISlashCommandActivityOwner {
+  scopeId: string;
+  storageKey: string;
+  sessionId: string;
+}
+
 interface IRunResultProjection {
   text: string;
   steps: number;
@@ -369,6 +416,47 @@ interface IFlexSubagentAcquisition {
   created: boolean;
 }
 
+interface INormalizedProjectManagementTools {
+  readonly task: boolean;
+  readonly goal: boolean;
+  readonly scratchpad: boolean;
+}
+
+interface INormalizedBuiltInTools {
+  readonly renameSession: boolean;
+  readonly projectManagement?: INormalizedProjectManagementTools;
+}
+
+type TProjectTaskToolInput =
+  | { action: 'list' }
+  | {
+      action: 'create';
+      id?: string;
+      content: string;
+      status?: TFlexProjectTaskStatus;
+      priority?: TFlexProjectTaskPriority;
+    }
+  | {
+      action: 'update';
+      id: string;
+      content?: string;
+      status?: TFlexProjectTaskStatus;
+      priority?: TFlexProjectTaskPriority;
+    }
+  | { action: 'delete'; id: string }
+  | { action: 'clear' };
+
+type TProjectGoalToolInput =
+  | { action: 'get' }
+  | { action: 'set'; goal: string }
+  | { action: 'clear' };
+
+type TProjectScratchpadToolInput =
+  | { action: 'get' }
+  | { action: 'set'; content: string }
+  | { action: 'append'; content: string }
+  | { action: 'clear' };
+
 type TEventDetails = Record<string, unknown> & {
   type: TFlexHarnessEvent['type'];
 };
@@ -416,6 +504,7 @@ const maxResourceToolNameBytes = 512;
 const maxSlashCommandRegistrations = 128;
 const maxSlashCommandDescriptionBytes = 2048;
 const maxSlashCommandTemplateBytes = FLEX_SLASH_COMMAND_MAX_INPUT_BYTES;
+const maxProjectManagementTombstoneConflicts = 8;
 const resourceToolStemLength = 16;
 const repairCancellationMessage = 'The process stopped before this run completed.';
 const scopeRetirementMessage = 'The scope is being retired.';
@@ -427,6 +516,43 @@ const externalErrorFallback: IFlexErrorInfo = Object.freeze({
   code: 'FLEX_EXTERNAL_ERROR',
 });
 
+function createSessionGenerationId(): string {
+  return `generation_${plugins.crypto.randomUUID()}`;
+}
+
+function deriveLegacySessionGenerationId(
+  storageKey: string,
+  sessionId: string,
+  createdAt: string,
+): string {
+  const digest = plugins.crypto.createHash('sha256').update(JSON.stringify([
+    'flexharness-legacy-session-generation-v1',
+    storageKey,
+    sessionId,
+    createdAt,
+  ])).digest('hex');
+  return `legacy_${digest}`;
+}
+
+function requireSessionGeneration(
+  session: Pick<
+    IFlexSession | IFlexSessionTombstone,
+    'sessionGenerationId' | 'sessionGenerationSequence'
+  >,
+): { sessionGenerationId: string; sessionGenerationSequence: number } {
+  if (
+    !session.sessionGenerationId
+    || !Number.isSafeInteger(session.sessionGenerationSequence)
+    || Number(session.sessionGenerationSequence) < 1
+  ) {
+    throw new FlexHarnessValidationError('Session generation metadata is missing.');
+  }
+  return {
+    sessionGenerationId: session.sessionGenerationId,
+    sessionGenerationSequence: session.sessionGenerationSequence as number,
+  };
+}
+
 function isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {
   return Boolean(
     value
@@ -635,6 +761,58 @@ function normalizeSubagents(
   return Object.freeze(normalized);
 }
 
+function normalizeBuiltInTools(
+  options: IFlexHarnessOptions<unknown>['builtInTools'],
+): INormalizedBuiltInTools {
+  if (options === undefined) return Object.freeze({ renameSession: false });
+  if (
+    !options
+    || typeof options !== 'object'
+    || Array.isArray(options)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(options))
+  ) {
+    throw new FlexHarnessValidationError('builtInTools must be a plain object.');
+  }
+  const unsupported = Object.keys(options)
+    .find((key) => !['renameSession', 'projectManagement'].includes(key));
+  if (unsupported) throw new FlexHarnessValidationError(`builtInTools does not support "${unsupported}".`);
+  if (options.renameSession !== undefined && typeof options.renameSession !== 'boolean') {
+    throw new FlexHarnessValidationError('builtInTools.renameSession must be a boolean.');
+  }
+  const projectManagement = options.projectManagement;
+  if (projectManagement === undefined) {
+    return Object.freeze({ renameSession: options.renameSession ?? false });
+  }
+  if (
+    !projectManagement
+    || typeof projectManagement !== 'object'
+    || Array.isArray(projectManagement)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(projectManagement))
+  ) {
+    throw new FlexHarnessValidationError('builtInTools.projectManagement must be a plain object.');
+  }
+  const unsupportedProjectOption = Object.keys(projectManagement)
+    .find((key) => !['task', 'goal', 'scratchpad'].includes(key));
+  if (unsupportedProjectOption) {
+    throw new FlexHarnessValidationError(
+      `builtInTools.projectManagement does not support "${unsupportedProjectOption}".`,
+    );
+  }
+  for (const key of ['task', 'goal', 'scratchpad'] as const) {
+    if (projectManagement[key] !== undefined && typeof projectManagement[key] !== 'boolean') {
+      throw new FlexHarnessValidationError(`builtInTools.projectManagement.${key} must be a boolean.`);
+    }
+  }
+  return Object.freeze({
+    renameSession: options.renameSession ?? false,
+    projectManagement: Object.freeze({
+      task: projectManagement.task ?? true,
+      goal: projectManagement.goal ?? true,
+      scratchpad: projectManagement.scratchpad ?? true,
+    }),
+  });
+}
+
 function normalizeSlashCommands<TScope>(
   registrations: readonly TFlexSlashCommandRegistration<TScope>[] | undefined,
 ): ReadonlyMap<string, TRegisteredSlashCommand<TScope>> {
@@ -969,13 +1147,81 @@ function validateUpdateSessionOptions(options: IFlexUpdateSessionOptions): void
   const unsupportedKey = keys.find((key) => key !== 'title' && key !== 'archived');
   if (unsupportedKey) throw new FlexHarnessValidationError(`updateSession does not support "${unsupportedKey}".`);
   if (Object.prototype.hasOwnProperty.call(options, 'title') && options.title !== null) {
-    validateIdentifier(options.title!, 'title');
+    validateUtf8String(
+      options.title,
+      'title',
+      FLEX_PROJECT_MANAGEMENT_LIMITS.maxTitleBytes,
+      true,
+    );
   }
   if (Object.prototype.hasOwnProperty.call(options, 'archived') && typeof options.archived !== 'boolean') {
     throw new FlexHarnessValidationError('archived must be a boolean.');
   }
 }
 
+function validateProjectTaskStatus(value: unknown): asserts value is TFlexProjectTaskStatus {
+  if (!['pending', 'in_progress', 'completed', 'cancelled'].includes(String(value))) {
+    throw new FlexHarnessValidationError('Project task status is invalid.');
+  }
+}
+
+function validateProjectTaskPriority(value: unknown): asserts value is TFlexProjectTaskPriority {
+  if (!['high', 'medium', 'low'].includes(String(value))) {
+    throw new FlexHarnessValidationError('Project task priority is invalid.');
+  }
+}
+
+function validateProjectTaskId(value: unknown): asserts value is string {
+  validateUtf8String(
+    value,
+    'project task id',
+    FLEX_PROJECT_MANAGEMENT_LIMITS.maxTaskIdBytes,
+    true,
+  );
+}
+
+function validateProjectTaskContent(value: unknown): asserts value is string {
+  validateUtf8String(
+    value,
+    'project task content',
+    FLEX_PROJECT_MANAGEMENT_LIMITS.maxTaskContentBytes,
+    true,
+  );
+}
+
+function validateCreateProjectTaskInput(input: IFlexCreateProjectTaskInput): void {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new FlexHarnessValidationError('Project task create input must be a plain object.');
+  }
+  const unsupported = Object.keys(input)
+    .find((key) => !['id', 'content', 'status', 'priority'].includes(key));
+  if (unsupported) {
+    throw new FlexHarnessValidationError(`Project task create input does not support "${unsupported}".`);
+  }
+  validateProjectTaskId(input.id);
+  validateProjectTaskContent(input.content);
+  if (input.status !== undefined) validateProjectTaskStatus(input.status);
+  if (input.priority !== undefined) validateProjectTaskPriority(input.priority);
+}
+
+function validateUpdateProjectTaskInput(input: IFlexUpdateProjectTaskInput): void {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new FlexHarnessValidationError('Project task update input must be a plain object.');
+  }
+  const keys = Object.keys(input);
+  const unsupported = keys.find((key) => !['id', 'content', 'status', 'priority'].includes(key));
+  if (unsupported) {
+    throw new FlexHarnessValidationError(`Project task update input does not support "${unsupported}".`);
+  }
+  if (!keys.some((key) => key !== 'id')) {
+    throw new FlexHarnessValidationError('Project task update requires a changed field.');
+  }
+  validateProjectTaskId(input.id);
+  if (input.content !== undefined) validateProjectTaskContent(input.content);
+  if (input.status !== undefined) validateProjectTaskStatus(input.status);
+  if (input.priority !== undefined) validateProjectTaskPriority(input.priority);
+}
+
 function validatePromptOptions(options: IFlexPromptOptions, scheduled: boolean): void {
   if (!options || typeof options !== 'object' || Array.isArray(options)) {
     throw new FlexHarnessValidationError('Prompt options must be a plain object.');
@@ -1100,6 +1346,22 @@ function normalizeAgentSessionPolicy<TScope>(
   };
 }
 
+function requireHarnessStores(stores: IFlexHarnessStores): IFlexHarnessStores {
+  const projectManagement = stores?.projectManagement;
+  if (
+    !projectManagement
+    || typeof projectManagement.load !== 'function'
+    || typeof projectManagement.save !== 'function'
+    || typeof projectManagement.tombstoneSession !== 'function'
+    || typeof projectManagement.purgeNamespace !== 'function'
+  ) {
+    throw new FlexHarnessValidationError(
+      'stores.projectManagement requires load/save/tombstoneSession/purgeNamespace methods.',
+    );
+  }
+  return stores;
+}
+
 export class FlexHarness<TScope = unknown> {
   private readonly scopeResolver: IFlexHarnessOptions<TScope>['scopeResolver'];
   private readonly modelResolver: IFlexHarnessOptions<TScope>['modelResolver'];
@@ -1113,8 +1375,10 @@ export class FlexHarness<TScope = unknown> {
   private readonly promptQueueLimits: Required<IFlexPromptQueueLimits>;
   private readonly reversionLimits: Required<IFlexReversionLimits>;
   private readonly turnReversionProvider: IFlexHarnessOptions<TScope>['turnReversionProvider'];
+  private readonly reversionPolicy: TFlexReversionPolicy;
   private readonly externalErrorProjector?: TFlexExternalErrorProjector;
   private readonly subagents: ReadonlyMap<string, Readonly<IFlexSubagentDefinition>>;
+  private readonly builtInTools: INormalizedBuiltInTools;
   private readonly slashCommands: ReadonlyMap<string, TRegisteredSlashCommand<TScope>>;
   private readonly maxSubagentDepth: number;
   private readonly maxSubagentCallsPerRun: number;
@@ -1135,6 +1399,7 @@ export class FlexHarness<TScope = unknown> {
   private readonly orphanedTombstoneCleanups = new Map<string, IOrphanedTombstoneCleanup>();
   private readonly orphanedTombstoneOwners = new Map<string, IOrphanedTombstoneOwner<TScope>>();
   private readonly pendingPromptAdmissionOwners = new Set<IPendingPromptAdmission>();
+  private readonly projectManagementQueues = new Map<string, Promise<void>>();
   private readonly activeSlashCommandExecutions = new Map<string, IActiveSlashCommandExecution>();
   private readonly activeSlashCommandListings = new Set<IActiveSlashCommandListing>();
   private readonly compactorInvocationContext = new plugins.AsyncLocalStorage<
@@ -1143,6 +1408,9 @@ export class FlexHarness<TScope = unknown> {
   private readonly slashCommandInvocationContext = new plugins.AsyncLocalStorage<
     ISlashCommandInvocationOwner
   >();
+  private readonly slashCommandActivityContext = new plugins.AsyncLocalStorage<
+    ISlashCommandActivityOwner
+  >();
   private readonly deferredCompactorContexts = new WeakMap<
     IFlexAgentContextInvocation<unknown>,
     IFlexAgentContextInvocation<unknown>
@@ -1163,15 +1431,34 @@ export class FlexHarness<TScope = unknown> {
     this.toolProvider = options.toolProvider;
     this.resourceToolProviderResolver = options.resourceToolProviderResolver;
     this.executionContextProvider = options.executionContextProvider;
-    this.stores = options.stores ?? new InMemoryFlexHarnessStores();
+    this.stores = requireHarnessStores(options.stores ?? new InMemoryFlexHarnessStores());
     this.agentSessionPolicy = normalizeAgentSessionPolicy(options.agentSessionPolicy);
     this.toolOutputLimits = resolveJsonLimits(options.toolOutputLimits);
     this.callbackLimits = resolveCallbackLimits(options.callbackLimits);
     this.promptQueueLimits = resolvePromptQueueLimits(options.promptQueueLimits);
     this.reversionLimits = resolveReversionLimits(options.reversionLimits);
     this.turnReversionProvider = options.turnReversionProvider;
+    this.reversionPolicy = options.reversionPolicy ?? 'transcript-optional';
+    if (!['transcript-optional', 'workspace-required'].includes(this.reversionPolicy)) {
+      throw new FlexHarnessValidationError(
+        'reversionPolicy must be "transcript-optional" or "workspace-required".',
+      );
+    }
+    const protocolVersion = this.turnReversionProvider
+      && 'protocolVersion' in this.turnReversionProvider
+      ? this.turnReversionProvider.protocolVersion
+      : 1;
+    if (protocolVersion !== 1 && protocolVersion !== 2) {
+      throw new FlexHarnessValidationError('Turn reversion provider protocolVersion is invalid.');
+    }
+    if (this.reversionPolicy === 'workspace-required' && protocolVersion !== 2) {
+      throw new FlexHarnessValidationError(
+        'workspace-required reversion policy requires a protocolVersion 2 turn reversion provider.',
+      );
+    }
     this.externalErrorProjector = options.externalErrorProjector;
     this.subagents = normalizeSubagents(options.subagents);
+    this.builtInTools = normalizeBuiltInTools(options.builtInTools);
     this.slashCommands = normalizeSlashCommands(options.slashCommands);
     this.maxSubagentDepth = resolveBoundedPositiveInteger(
       options.maxSubagentDepth,
@@ -1211,7 +1498,14 @@ export class FlexHarness<TScope = unknown> {
     const sessionId = options.sessionId ?? plugins.crypto.randomUUID();
     validateIdentifier(sessionId, 'sessionId');
     requireTransferIdentifier(sessionId, 'sessionId');
-    if (options.title !== undefined) validateIdentifier(options.title, 'title');
+    if (options.title !== undefined) {
+      validateUtf8String(
+        options.title,
+        'title',
+        FLEX_PROJECT_MANAGEMENT_LIMITS.maxTitleBytes,
+        true,
+      );
+    }
     await resolved.state.scopeQueue;
     if (
       resolved.state.sessions.has(sessionId)
@@ -1246,6 +1540,8 @@ export class FlexHarness<TScope = unknown> {
         metadata = {
           scopeId,
           sessionId,
+          sessionGenerationId: createSessionGenerationId(),
+          sessionGenerationSequence: resolved.state.revision + 1,
           ...(options.title ? { title: options.title } : {}),
           createdAt: timestamp,
           updatedAt: timestamp,
@@ -1291,6 +1587,7 @@ export class FlexHarness<TScope = unknown> {
       if (!scopeReserved) throw projectedError;
       const tombstone: IFlexSessionTombstone = {
         sessionId,
+        ...requireSessionGeneration(metadata),
         deletedAt: new Date().toISOString(),
         rootSessionId: sessionId,
         depth: 0,
@@ -1357,6 +1654,41 @@ export class FlexHarness<TScope = unknown> {
     return publicSnapshot(this.requireSession(state, sessionId).session);
   }
 
+  public async getSessionReversionInfo(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexSessionReversionInfo> {
+    const { state } = await this.resolveState(scopeId);
+    const stored = this.requireSession(state, sessionId);
+    await stored.projectionQueue;
+    this.assertStateAcceptingWork(state);
+    await this.reconcileContextAvailability(state, stored);
+    const unavailableReason = await this.reversionUnavailableReason(state, stored);
+    const groups = this.reversionGroups(stored);
+    const undo = this.reversionUnit(stored, 'undo');
+    const redo = this.reversionUnit(stored, 'redo');
+    const isAvailable = (unit: ReturnType<typeof this.reversionUnit>) => Boolean(
+      !unavailableReason
+      && unit
+      && unit.target.contextAvailable
+      && !unit.segments.some((segment) =>
+        segment.provenance === 'workspace'
+        && segment.disposition === 'revertible'
+        && segment.workspaceReference === undefined),
+    );
+    return publicSnapshot({
+      undoAvailable: isAvailable(undo),
+      redoAvailable: isAvailable(redo),
+      groups: groups.map((group, index): IFlexSessionReversionGroup => ({
+        runId: group.target.runId,
+        kind: group.kind,
+        visibility: index < stored.revertCursor ? 'visible' : 'hidden',
+        affectedWorkspaces: cloneSerializable(group.affectedWorkspaces),
+        affectedWorkspacesTruncated: group.affectedWorkspacesTruncated,
+      })),
+    });
+  }
+
   public async updateSession(
     scopeId: string,
     sessionId: string,
@@ -1383,15 +1715,185 @@ export class FlexHarness<TScope = unknown> {
     return result;
   }
 
+  public async getProjectState(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexProjectStateResult> {
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    const snapshot = await this.readProjectManagementState(state, stored);
+    return this.projectStateResult(snapshot);
+  }
+
+  public async listProjectTasks(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexProjectTasksResult> {
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    const snapshot = await this.readProjectManagementState(state, stored);
+    return this.projectTasksResult(snapshot, snapshot.tasks);
+  }
+
+  public async createProjectTask(
+    scopeId: string,
+    sessionId: string,
+    input: IFlexCreateProjectTaskInput,
+  ): Promise<IFlexProjectTaskResult> {
+    validateCreateProjectTaskInput(input);
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    return this.createProjectTaskInState(
+      state,
+      stored,
+      input,
+      Object.freeze({ actor: 'application' }),
+    );
+  }
+
+  public async updateProjectTask(
+    scopeId: string,
+    sessionId: string,
+    input: IFlexUpdateProjectTaskInput,
+  ): Promise<IFlexProjectTaskResult> {
+    validateUpdateProjectTaskInput(input);
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    return this.updateProjectTaskInState(
+      state,
+      stored,
+      input,
+      Object.freeze({ actor: 'application' }),
+    );
+  }
+
+  public async deleteProjectTask(
+    scopeId: string,
+    sessionId: string,
+    taskId: string,
+  ): Promise<IFlexProjectTaskResult> {
+    validateProjectTaskId(taskId);
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    return this.deleteProjectTaskInState(
+      state,
+      stored,
+      taskId,
+      Object.freeze({ actor: 'application' }),
+    );
+  }
+
+  public async clearProjectTasks(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexProjectTasksResult> {
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    return this.clearProjectTasksInState(
+      state,
+      stored,
+      Object.freeze({ actor: 'application' }),
+    );
+  }
+
+  public async getProjectGoal(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexProjectGoalResult> {
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    const snapshot = await this.readProjectManagementState(state, stored);
+    return this.projectGoalResult(snapshot);
+  }
+
+  public async setProjectGoal(
+    scopeId: string,
+    sessionId: string,
+    goal: string,
+  ): Promise<IFlexProjectGoalResult> {
+    validateUtf8String(
+      goal,
+      'project goal',
+      FLEX_PROJECT_MANAGEMENT_LIMITS.maxGoalBytes,
+      true,
+    );
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    return this.setProjectGoalInState(
+      state,
+      stored,
+      goal,
+      Object.freeze({ actor: 'application' }),
+    );
+  }
+
+  public async clearProjectGoal(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexProjectGoalResult> {
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    return this.clearProjectGoalInState(
+      state,
+      stored,
+      Object.freeze({ actor: 'application' }),
+    );
+  }
+
+  public async getProjectScratchpad(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexProjectScratchpadResult> {
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    const snapshot = await this.readProjectManagementState(state, stored);
+    return this.projectScratchpadResult(snapshot);
+  }
+
+  public async setProjectScratchpad(
+    scopeId: string,
+    sessionId: string,
+    content: string,
+  ): Promise<IFlexProjectScratchpadResult> {
+    validateUtf8String(
+      content,
+      'project scratchpad',
+      FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes,
+    );
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    return this.setProjectScratchpadInState(
+      state,
+      stored,
+      content,
+      Object.freeze({ actor: 'application' }),
+    );
+  }
+
+  public async appendProjectScratchpad(
+    scopeId: string,
+    sessionId: string,
+    content: string,
+  ): Promise<IFlexProjectScratchpadResult> {
+    validateUtf8String(
+      content,
+      'project scratchpad append',
+      FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes,
+    );
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    return this.appendProjectScratchpadInState(
+      state,
+      stored,
+      content,
+      Object.freeze({ actor: 'application' }),
+    );
+  }
+
+  public async clearProjectScratchpad(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexProjectScratchpadResult> {
+    const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId);
+    return this.clearProjectScratchpadInState(
+      state,
+      stored,
+      Object.freeze({ actor: 'application' }),
+    );
+  }
+
   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));
-    }
+    this.assertNoAmbientSlashCommandTeardown({ scopeId, sessionId });
     const { scope, state } = await this.resolveState(scopeId);
-    if (invocationOwner?.storageKey === state.storageKey) {
-      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(invocationOwner.sessionId));
-    }
+    this.assertNoAmbientSlashCommandTeardown({ storageKey: state.storageKey });
     validateIdentifier(sessionId, 'sessionId');
     await state.scopeQueue;
     const deletionKey = state.tombstones.get(sessionId)?.rootSessionId ?? sessionId;
@@ -1456,6 +1958,7 @@ export class FlexHarness<TScope = unknown> {
         });
         state.tombstones.set(entrySessionId, {
           sessionId: entrySessionId,
+          ...requireSessionGeneration(entry.session),
           deletedAt,
           rootSessionId: sessionId,
           depth: (entry.session.depth ?? rootDepth) - rootDepth,
@@ -1606,7 +2109,7 @@ export class FlexHarness<TScope = unknown> {
     sessionId: string,
   ): Promise<IFlexSlashCommandDescriptor[]> {
     const { state } = await this.resolveState(scopeId);
-    return this.trackSlashCommandListing(state, sessionId, async (signal) => {
+    return this.trackSlashCommandListing(scopeId, state, sessionId, async (signal) => {
       await this.awaitReversionOperation(state.scopeQueue, signal);
       signal.throwIfAborted();
       this.assertStateAcceptingWork(state);
@@ -1644,7 +2147,7 @@ export class FlexHarness<TScope = unknown> {
     const workspaceReversion = (unit: ReturnType<typeof this.reversionUnit>) =>
       !unit
       || !this.turnReversionProvider
-      || unit.segments.some((segment) => !segment.workspaceCaptured)
+      || unit.segments.some((segment) => segment.provenance !== 'workspace')
         ? 'unsupported' as const
         : 'supported' as const;
     const reversionAvailability = (unit: ReturnType<typeof this.reversionUnit>) => {
@@ -1658,7 +2161,7 @@ export class FlexHarness<TScope = unknown> {
         unavailableReason: 'The turn is beyond the context archive horizon.',
       };
       if (unit.segments.some((segment) =>
-        segment.workspaceCaptured && segment.workspaceReference === undefined)) return {
+        segment.disposition === 'revertible' && segment.workspaceReference === undefined)) return {
         available: false,
         unavailableReason: 'The turn has no available workspace reversion capture.',
       };
@@ -1802,6 +2305,7 @@ export class FlexHarness<TScope = unknown> {
       }
       this.requireSessionAvailableForSlashCommand(state, stored, parsed.name);
       return this.trackSlashCommandExecution(
+        scopeId,
         state,
         sessionId,
         'operation',
@@ -1829,6 +2333,7 @@ export class FlexHarness<TScope = unknown> {
         this.promptAdmissionByteSize(expanded, promptOptions),
       );
       return this.trackSlashCommandExecution(
+        scopeId,
         state,
         sessionId,
         'prompt-admission',
@@ -1925,7 +2430,7 @@ export class FlexHarness<TScope = unknown> {
     )) 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.';
+      return 'Subagent sessions can only be prompted through the foreground delegate tool.';
     }
     if (stored.outstandingPromptsById.size >= this.promptQueueLimits.maxOutstandingPromptsPerSession) {
       return 'Session has reached its outstanding prompt limit.';
@@ -2001,6 +2506,7 @@ export class FlexHarness<TScope = unknown> {
   }
 
   private trackSlashCommandExecution<TResult>(
+    scopeId: string,
     state: IStorageState,
     sessionId: string,
     kind: IActiveSlashCommandExecution['kind'],
@@ -2024,10 +2530,11 @@ export class FlexHarness<TScope = unknown> {
     };
     externalSignal?.addEventListener('abort', abortFromExternalSignal, { once: true });
     if (externalSignal?.aborted) abortFromExternalSignal();
-    const completion = Promise.resolve().then(() => {
+    const activityOwner = Object.freeze({ scopeId, storageKey: state.storageKey, sessionId });
+    const completion = Promise.resolve().then(() => this.slashCommandActivityContext.run(activityOwner, () => {
       if (controller.signal.aborted) throw controller.signal.reason;
       return operation(controller.signal);
-    });
+    }));
     const active: IActiveSlashCommandExecution = {
       kind,
       storageKey: state.storageKey,
@@ -2045,12 +2552,15 @@ export class FlexHarness<TScope = unknown> {
   }
 
   private trackSlashCommandListing<TResult>(
+    scopeId: string,
     state: IStorageState,
     sessionId: string,
     operation: (signal: AbortSignal) => Promise<TResult>,
   ): Promise<TResult> {
     const controller = new AbortController();
-    const completion = Promise.resolve().then(() => operation(controller.signal));
+    const activityOwner = Object.freeze({ scopeId, storageKey: state.storageKey, sessionId });
+    const completion = Promise.resolve().then(() =>
+      this.slashCommandActivityContext.run(activityOwner, () => operation(controller.signal)));
     const active: IActiveSlashCommandListing = {
       storageKey: state.storageKey,
       sessionId,
@@ -2094,6 +2604,7 @@ export class FlexHarness<TScope = unknown> {
       sessionKey,
     });
     return this.trackSlashCommandExecution(
+      scopeId,
       state,
       stored.session.sessionId,
       'handler',
@@ -2403,6 +2914,7 @@ export class FlexHarness<TScope = unknown> {
     }
     this.requireSessionAvailableForSlashCommand(state, stored, 'compact');
     await this.trackSlashCommandExecution(
+      scopeId,
       state,
       sessionId,
       'operation',
@@ -2464,24 +2976,77 @@ export class FlexHarness<TScope = unknown> {
     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;
+    const groups = this.reversionGroups(stored);
+    if (direction === 'undo') {
+      let start = stored.revertCursor - 1;
+      while (start >= 0 && groups[start]?.kind === 'no-change') start--;
+      const candidate = groups[start];
+      if (!candidate || candidate.kind !== 'candidate') return undefined;
+      return {
+        target: candidate.target,
+        segments: groups.slice(start, stored.revertCursor).flatMap((group) => group.segments),
+        toCursor: start,
+      };
+    }
+    const candidate = groups[stored.revertCursor];
+    if (!candidate || candidate.kind !== 'candidate') return undefined;
+    let end = stored.revertCursor + 1;
+    while (groups[end]?.kind === 'no-change') end++;
     return {
-      target: candidate,
-      segments: stored.reversionSegments.slice(start, end),
-      toCursor: stored.revertCursor + (direction === 'undo' ? -1 : 1),
+      target: candidate.target,
+      segments: groups.slice(stored.revertCursor, end).flatMap((group) => group.segments),
+      toCursor: end,
     };
   }
 
+  private reversionGroups(stored: IStoredSessionState): IReversionGroup[] {
+    const groups: IReversionGroup[] = [];
+    let leading: IFlexReversionSegment[] = [];
+    for (const segment of stored.reversionSegments) {
+      if (segment.status === 'completed') {
+        const segments = groups.length === 0 ? [...leading, segment] : [segment];
+        leading = [];
+        groups.push({
+          target: segment,
+          segments,
+          kind: 'candidate',
+          affectedWorkspaces: [],
+          affectedWorkspacesTruncated: false,
+        });
+      } else if (groups.length > 0) {
+        groups[groups.length - 1].segments.push(segment);
+      } else {
+        leading.push(segment);
+      }
+    }
+    for (const group of groups) {
+      const affected = new Map<string, IFlexAffectedWorkspace>();
+      for (const workspace of group.segments.flatMap((segment) =>
+        segment.affectedWorkspaces ?? [])) {
+        if (affected.has(workspace.id)) continue;
+        if (affected.size < FLEX_REVERSION_MAX_AFFECTED_WORKSPACES) {
+          affected.set(workspace.id, cloneSerializable(workspace));
+        } else {
+          group.affectedWorkspacesTruncated = true;
+        }
+      }
+      group.affectedWorkspaces = [...affected.values()];
+      if (this.reversionPolicy === 'transcript-optional') continue;
+      if (group.segments.some((segment) =>
+        segment.status === 'capturing'
+        || segment.disposition === 'pending'
+        || (segment.protocolVersion === 1 && segment.provenance === 'transcript')
+        || segment.disposition === 'nonrevertible')) {
+        group.kind = 'barrier';
+      } else if (group.segments.some((segment) => segment.disposition === 'revertible')) {
+        group.kind = 'candidate';
+      } else {
+        group.kind = 'no-change';
+      }
+    }
+    return groups;
+  }
+
   private async requireReversionIdle(
     state: IStorageState,
     stored: IStoredSessionState,
@@ -2587,6 +3152,7 @@ export class FlexHarness<TScope = unknown> {
       throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
     }
     return this.trackSlashCommandExecution(
+      scopeId,
       state,
       sessionId,
       'operation',
@@ -2609,8 +3175,9 @@ export class FlexHarness<TScope = unknown> {
           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];
+          const target = pending.segmentRunIds
+            .map((runId) => stored.reversionSegments.find((segment) => segment.runId === runId))
+            .find((segment) => segment?.status === 'completed');
           if (!target) throw new FlexHarnessValidationError('Pending reversion has no target candidate.');
           await this.resumePendingApply(state, stored, scopeId, scope, operationSignal);
           this.emitEvent(scopeId, sessionId, {
@@ -2634,7 +3201,7 @@ export class FlexHarness<TScope = unknown> {
           );
         }
         if (this.turnReversionProvider && unit.segments.some((segment) =>
-          segment.captureId !== undefined && segment.workspaceReference === undefined)) {
+          segment.disposition === 'revertible' && segment.workspaceReference === undefined)) {
           throw new FlexHarnessSlashCommandUnavailableError(
             direction,
             'The turn has no available workspace reversion capture.',
@@ -2713,7 +3280,8 @@ export class FlexHarness<TScope = unknown> {
     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)
+      pending.segmentRunIds.some((runId) =>
+        segmentMap.get(runId)?.disposition === 'revertible')
       && !this.turnReversionProvider
     ) {
       throw new FlexHarnessValidationError(
@@ -2723,18 +3291,25 @@ export class FlexHarness<TScope = unknown> {
     const orderedRunIds = pending.direction === 'undo'
       ? [...pending.segmentRunIds].reverse()
       : [...pending.segmentRunIds];
+    let workspaceProgress = pending.appliedRunIds.some((runId) =>
+      segmentMap.get(runId)?.disposition === 'revertible');
     for (const runId of orderedRunIds) {
       if (pending.appliedRunIds.includes(runId)) continue;
-      if (signal?.aborted) {
+      if (signal?.aborted && !workspaceProgress) {
         await this.persistKnownNotApplied(state, stored, pending.operationId, runId);
         throw signal.reason;
       }
       const segment = segmentMap.get(runId);
       if (!segment) throw new FlexHarnessValidationError('Pending reversion references a missing segment.');
-      if (segment.workspaceCaptured) {
+      if (segment.disposition === 'revertible') {
         if (!this.turnReversionProvider || !segment.captureId || segment.workspaceReference === undefined) {
           throw new FlexHarnessValidationError('Pending workspace reversion segment is incomplete.');
         }
+        if (this.reversionProviderProtocolVersion() !== segment.protocolVersion) {
+          throw new FlexHarnessValidationError(
+            `Pending workspace reversion requires protocolVersion ${segment.protocolVersion}.`,
+          );
+        }
         const captureId = segment.captureId;
         const reference = segment.workspaceReference;
         const childOperationId = `${pending.operationId}:${sha256Hex(runId).slice(0, 16)}`;
@@ -2770,7 +3345,7 @@ export class FlexHarness<TScope = unknown> {
         }
         if (inspection.status === 'not-applied') {
           try {
-            if (signal) {
+            if (signal && !workspaceProgress) {
               await this.turnReversionProvider.apply(createContext(signal));
             } else {
               await this.withReversionMaintenanceSignal((maintenanceSignal) =>
@@ -2811,6 +3386,7 @@ export class FlexHarness<TScope = unknown> {
         }
         if (!current.appliedRunIds.includes(runId)) current.appliedRunIds.push(runId);
       }, true);
+      if (segment.disposition === 'revertible') workspaceProgress = true;
     }
     await this.mutateProjection(state, stored, () => {
       const current = stored.pendingReversion;
@@ -2834,7 +3410,10 @@ export class FlexHarness<TScope = unknown> {
         throw new FlexHarnessValidationError('Pending reversion changed while recording failed apply.');
       }
       current.appliedRunIds = current.appliedRunIds.filter((entry) => entry !== runId);
-      if (current.appliedRunIds.length === 0) {
+      const hasWorkspaceProgress = current.appliedRunIds.some((appliedRunId) =>
+        stored.reversionSegments.some((segment) =>
+          segment.runId === appliedRunId && segment.disposition === 'revertible'));
+      if (!hasWorkspaceProgress) {
         stored.revertCursor = current.fromCursor;
         delete stored.pendingReversion;
       }
@@ -2852,17 +3431,31 @@ export class FlexHarness<TScope = unknown> {
     if (pending?.kind !== 'capture' || !this.turnReversionProvider) return;
     const segment = stored.reversionSegments.find((entry) => entry.runId === pending.runId);
     if (!segment) throw new FlexHarnessValidationError('Pending capture references a missing segment.');
+    if (this.reversionProviderProtocolVersion() !== pending.protocolVersion) {
+      throw new FlexHarnessValidationError(
+        `Pending capture recovery requires protocolVersion ${pending.protocolVersion}.`,
+      );
+    }
     const outcome = outcomes.get(pending.runId);
-    const reference = await this.resolveReversionCaptureReference(
+    if (pending.state === 'prepared') {
+      await this.mutateProjection(state, stored, () => {
+        const current = stored.pendingReversion;
+        if (current?.kind !== 'capture' || current.captureId !== pending.captureId) {
+          throw new FlexHarnessValidationError('Pending capture changed before finalization.');
+        }
+        current.state = 'finalizing';
+      }, true);
+    }
+    const finalizedOutcome = await this.resolveReversionCaptureOutcome(
       state,
       scopeId,
       scope,
       stored.session.sessionId,
       pending.runId,
       pending.captureId,
-      pending.state,
+      pending.state === 'prepared' ? 'finalizing' : pending.state,
     );
-    if (reference === undefined) {
+    if (finalizedOutcome === undefined) {
       await this.mutateProjection(state, stored, () => {
         stored.reversionSegments = stored.reversionSegments.filter(
           (entry) => entry.runId !== pending.runId,
@@ -2877,7 +3470,7 @@ export class FlexHarness<TScope = unknown> {
         : outcome === 'rejected'
           ? 'failed'
         : 'cancelled';
-      segment.workspaceReference = cloneSerializable(reference);
+      this.applyFinalizedReversionOutcome(stored, segment, finalizedOutcome);
       segment.eventIds = stored.agentSession.getEvents()
         .filter((event) => event.generationId === pending.runId)
         .map((event) => event.id);
@@ -3017,10 +3610,7 @@ 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.assertNoAmbientSlashCommandTeardown({ scopeId });
     this.assertOpen();
     validateIdentifier(scopeId, 'scopeId');
     const existing = this.scopeRetirements.get(scopeId);
@@ -3039,13 +3629,8 @@ export class FlexHarness<TScope = unknown> {
   }
 
   public async dispose(): Promise<void> {
+    this.assertNoAmbientSlashCommandTeardown();
     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) => {
@@ -3125,7 +3710,7 @@ export class FlexHarness<TScope = unknown> {
       }
       if (stored.session.agent !== undefined && !subagentAdmission) {
         throw new FlexHarnessValidationError(
-          'Subagent sessions can only be prompted through the foreground task tool.',
+          'Subagent sessions can only be prompted through the foreground delegate tool.',
         );
       }
       if (stored.outstandingPromptsById.size >= this.promptQueueLimits.maxOutstandingPromptsPerSession) {
@@ -3339,6 +3924,7 @@ export class FlexHarness<TScope = unknown> {
           const captureId = this.turnReversionProvider
             ? this.reversionId('capture', run.state.storageKey, run.sessionId, run.runId)
             : undefined;
+          const protocolVersion = this.reversionProviderProtocolVersion() ?? 1;
           run.stored.reversionSegments.push({
             runId: run.runId,
             userMessageId: reservation.userMessage.messageId,
@@ -3346,6 +3932,9 @@ export class FlexHarness<TScope = unknown> {
             contextAvailable: true,
             eventIds: [],
             workspaceCaptured: captureId !== undefined,
+            protocolVersion,
+            provenance: captureId === undefined ? 'transcript' : 'workspace',
+            ...(captureId === undefined ? {} : { disposition: 'pending' }),
             ...(captureId === undefined ? {} : { captureId }),
           });
           if (captureId) {
@@ -3354,6 +3943,7 @@ export class FlexHarness<TScope = unknown> {
               runId: run.runId,
               captureId,
               state: 'preparing',
+              protocolVersion,
             };
           }
         }
@@ -3727,32 +4317,438 @@ export class FlexHarness<TScope = unknown> {
     throw errors.length > 1 ? combineErrors(errors) : terminalError;
   }
 
-  private async prepareGeneration(
-    run: IActiveRun,
-    options: IFlexPromptOptions,
-    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')) {
-      queued.status = 'running';
-      this.emitPromptQueueEvent(queued, 'prompt.running');
+  private requireProjectManagementTools(): INormalizedProjectManagementTools {
+    const projectManagement = this.builtInTools.projectManagement;
+    if (!projectManagement) {
+      throw new FlexHarnessValidationError('Project management is not configured for this FlexHarness.');
     }
-    const resolverRelationship = {
-      ...(run.stored.session.parentSessionId === undefined
-        ? {}
-        : { parentSessionId: run.stored.session.parentSessionId }),
-      ...(run.stored.session.agent === undefined ? {} : { agent: run.stored.session.agent }),
-    };
-    const modelOutcome = Promise.resolve()
-      .then(() => this.modelResolver.resolveModel(Object.freeze({
-        scopeId: run.scopeId,
-        scope: run.scope as TScope,
-        sessionId: run.sessionId,
-        runId: run.runId,
-        ...(options.modelHint ? { modelHint: options.modelHint } : {}),
+    return projectManagement;
+  }
+
+  private projectManagementKey(storageKey: string, sessionId: string): string {
+    return JSON.stringify([storageKey, sessionId]);
+  }
+
+  private queueProjectManagementOperation<TResult>(
+    storageKey: string,
+    sessionId: string,
+    operation: () => Promise<TResult>,
+  ): Promise<TResult> {
+    const key = this.projectManagementKey(storageKey, sessionId);
+    const previous = this.projectManagementQueues.get(key) ?? Promise.resolve();
+    const result = previous.then(operation);
+    const barrier = result.then(() => undefined, () => undefined);
+    this.projectManagementQueues.set(key, barrier);
+    void barrier.then(() => {
+      if (this.projectManagementQueues.get(key) === barrier) {
+        this.projectManagementQueues.delete(key);
+      }
+    });
+    return result;
+  }
+
+  private async awaitProjectManagementOperations(
+    storageKey: string,
+    sessionIds: Iterable<string>,
+  ): Promise<void> {
+    const barriers = [...new Set(sessionIds)]
+      .map((sessionId) => this.projectManagementQueues.get(
+        this.projectManagementKey(storageKey, sessionId),
+      ))
+      .filter((barrier): barrier is Promise<void> => barrier !== undefined);
+    await Promise.all(barriers);
+  }
+
+  private async resolveProjectManagementSession(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<{ state: IStorageState; stored: IStoredSessionState }> {
+    this.requireProjectManagementTools();
+    const { state } = await this.resolveState(scopeId);
+    await state.scopeQueue;
+    this.assertOpen();
+    this.assertStateAcceptingWork(state);
+    return { state, stored: this.requireSession(state, sessionId) };
+  }
+
+  private assertProjectManagementSession(
+    state: IStorageState,
+    stored: IStoredSessionState,
+  ): void {
+    this.assertOpen();
+    this.assertStateAcceptingWork(state);
+    if (
+      state.sessions.get(stored.session.sessionId) !== stored
+      || state.tombstones.has(stored.session.sessionId)
+    ) {
+      throw new FlexHarnessNotFoundError('Session', stored.session.sessionId);
+    }
+  }
+
+  private async loadProjectManagementState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+  ): Promise<IFlexProjectManagementSnapshot> {
+    const store = this.stores.projectManagement;
+    const generation = requireSessionGeneration(stored.session);
+    const record = await store.load(state.storageKey, stored.session.sessionId);
+    if (record === undefined) {
+      return createEmptyFlexProjectManagementSnapshot(
+        generation.sessionGenerationId,
+        generation.sessionGenerationSequence,
+      );
+    }
+    assertFlexProjectManagementRecord(record);
+    if (record.sessionGenerationId === generation.sessionGenerationId) {
+      if (record.sessionGenerationSequence !== generation.sessionGenerationSequence) {
+        throw new FlexHarnessStoreConflictError(
+          this.projectManagementKey(state.storageKey, stored.session.sessionId),
+          0,
+          record.revision,
+        );
+      }
+      if (!('deletedAt' in record)) return cloneSerializable(record);
+      throw new FlexHarnessNotFoundError('Project management state', stored.session.sessionId);
+    }
+    if (
+      'deletedAt' in record
+      && record.sessionGenerationSequence < generation.sessionGenerationSequence
+    ) {
+      return createEmptyFlexProjectManagementSnapshot(
+        generation.sessionGenerationId,
+        generation.sessionGenerationSequence,
+      );
+    }
+    throw new FlexHarnessStoreConflictError(
+      this.projectManagementKey(state.storageKey, stored.session.sessionId),
+      0,
+      record.revision,
+    );
+  }
+
+  private readProjectManagementState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+  ): Promise<IFlexProjectManagementSnapshot> {
+    return this.queueProjectManagementOperation(
+      state.storageKey,
+      stored.session.sessionId,
+      async () => {
+        this.assertProjectManagementSession(state, stored);
+        const snapshot = await this.loadProjectManagementState(state, stored);
+        this.assertProjectManagementSession(state, stored);
+        return publicSnapshot(snapshot);
+      },
+    );
+  }
+
+  private mutateProjectManagementState<TResult>(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    writeContext: IFlexProjectManagementWriteContext,
+    mutation: (
+      snapshot: IFlexProjectManagementSnapshot,
+    ) => { changed: boolean; value: TResult },
+  ): Promise<{ snapshot: IFlexProjectManagementSnapshot; value: TResult }> {
+    return this.queueProjectManagementOperation(
+      state.storageKey,
+      stored.session.sessionId,
+      async () => {
+        this.assertProjectManagementSession(state, stored);
+        const snapshot = await this.loadProjectManagementState(state, stored);
+        this.assertProjectManagementSession(state, stored);
+        const expectedRevision = snapshot.revision;
+        const result = mutation(snapshot);
+        if (result.changed) {
+          snapshot.revision = expectedRevision + 1;
+          assertFlexProjectManagementSnapshot(snapshot);
+          this.assertProjectManagementSession(state, stored);
+          await this.stores.projectManagement.save(
+            state.storageKey,
+            stored.session.sessionId,
+            cloneSerializable(snapshot),
+            expectedRevision,
+            Object.freeze(cloneSerializable(writeContext)),
+          );
+        }
+        return {
+          snapshot: publicSnapshot(snapshot),
+          value: result.value === undefined ? result.value : publicSnapshot(result.value),
+        };
+      },
+    );
+  }
+
+  private projectStateResult(snapshot: IFlexProjectManagementSnapshot): IFlexProjectStateResult {
+    return publicSnapshot({ revision: snapshot.revision, state: snapshot });
+  }
+
+  private projectTaskResult(
+    snapshot: IFlexProjectManagementSnapshot,
+    task: IFlexProjectTask,
+  ): IFlexProjectTaskResult {
+    return publicSnapshot({ revision: snapshot.revision, task, state: snapshot });
+  }
+
+  private projectTasksResult(
+    snapshot: IFlexProjectManagementSnapshot,
+    tasks: IFlexProjectTask[],
+  ): IFlexProjectTasksResult {
+    return publicSnapshot({ revision: snapshot.revision, tasks, state: snapshot });
+  }
+
+  private projectGoalResult(snapshot: IFlexProjectManagementSnapshot): IFlexProjectGoalResult {
+    return publicSnapshot({
+      revision: snapshot.revision,
+      goal: snapshot.goal ?? null,
+      state: snapshot,
+    });
+  }
+
+  private projectScratchpadResult(
+    snapshot: IFlexProjectManagementSnapshot,
+  ): IFlexProjectScratchpadResult {
+    return publicSnapshot({
+      revision: snapshot.revision,
+      scratchpad: snapshot.scratchpad,
+      state: snapshot,
+    });
+  }
+
+  private async createProjectTaskInState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    input: IFlexCreateProjectTaskInput,
+    writeContext: IFlexProjectManagementWriteContext,
+  ): Promise<IFlexProjectTaskResult> {
+    const status = input.status ?? 'pending';
+    const priority = input.priority ?? 'medium';
+    const result = await this.mutateProjectManagementState(
+      state,
+      stored,
+      writeContext,
+      (snapshot) => {
+        const existing = snapshot.tasks.find((task) => task.id === input.id);
+        if (existing) {
+          if (
+            existing.content === input.content
+            && existing.status === status
+            && existing.priority === priority
+          ) return { changed: false, value: existing };
+          throw new FlexHarnessValidationError(
+            `Project task "${input.id}" already exists with different creation data.`,
+          );
+        }
+        if (snapshot.tasks.length >= FLEX_PROJECT_MANAGEMENT_LIMITS.maxTasks) {
+          throw new FlexHarnessValidationError('Project task count has reached its limit.');
+        }
+        const timestamp = new Date().toISOString();
+        const task: IFlexProjectTask = {
+          id: input.id,
+          content: input.content,
+          status,
+          priority,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+        };
+        snapshot.tasks.push(task);
+        return { changed: true, value: task };
+      },
+    );
+    return this.projectTaskResult(result.snapshot, result.value);
+  }
+
+  private async updateProjectTaskInState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    input: IFlexUpdateProjectTaskInput,
+    writeContext: IFlexProjectManagementWriteContext,
+  ): Promise<IFlexProjectTaskResult> {
+    const result = await this.mutateProjectManagementState(
+      state,
+      stored,
+      writeContext,
+      (snapshot) => {
+        const task = snapshot.tasks.find((entry) => entry.id === input.id);
+        if (!task) throw new FlexHarnessNotFoundError('Project task', input.id);
+        const changed = (input.content !== undefined && input.content !== task.content)
+          || (input.status !== undefined && input.status !== task.status)
+          || (input.priority !== undefined && input.priority !== task.priority);
+        if (!changed) return { changed: false, value: task };
+        if (input.content !== undefined) task.content = input.content;
+        if (input.status !== undefined) task.status = input.status;
+        if (input.priority !== undefined) task.priority = input.priority;
+        task.updatedAt = new Date().toISOString();
+        return { changed: true, value: task };
+      },
+    );
+    return this.projectTaskResult(result.snapshot, result.value);
+  }
+
+  private async deleteProjectTaskInState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    taskId: string,
+    writeContext: IFlexProjectManagementWriteContext,
+  ): Promise<IFlexProjectTaskResult> {
+    const result = await this.mutateProjectManagementState(
+      state,
+      stored,
+      writeContext,
+      (snapshot) => {
+        const index = snapshot.tasks.findIndex((task) => task.id === taskId);
+        if (index < 0) throw new FlexHarnessNotFoundError('Project task', taskId);
+        const [task] = snapshot.tasks.splice(index, 1);
+        return { changed: true, value: task };
+      },
+    );
+    return this.projectTaskResult(result.snapshot, result.value);
+  }
+
+  private async clearProjectTasksInState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    writeContext: IFlexProjectManagementWriteContext,
+  ): Promise<IFlexProjectTasksResult> {
+    const result = await this.mutateProjectManagementState(
+      state,
+      stored,
+      writeContext,
+      (snapshot) => {
+        const tasks = snapshot.tasks;
+        if (tasks.length === 0) return { changed: false, value: [] as IFlexProjectTask[] };
+        snapshot.tasks = [];
+        return { changed: true, value: tasks };
+      },
+    );
+    return this.projectTasksResult(result.snapshot, result.value);
+  }
+
+  private async setProjectGoalInState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    goal: string,
+    writeContext: IFlexProjectManagementWriteContext,
+  ): Promise<IFlexProjectGoalResult> {
+    const result = await this.mutateProjectManagementState(
+      state,
+      stored,
+      writeContext,
+      (snapshot) => {
+        if (snapshot.goal === goal) return { changed: false, value: undefined };
+        snapshot.goal = goal;
+        return { changed: true, value: undefined };
+      },
+    );
+    return this.projectGoalResult(result.snapshot);
+  }
+
+  private async clearProjectGoalInState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    writeContext: IFlexProjectManagementWriteContext,
+  ): Promise<IFlexProjectGoalResult> {
+    const result = await this.mutateProjectManagementState(
+      state,
+      stored,
+      writeContext,
+      (snapshot) => {
+        if (snapshot.goal === undefined) return { changed: false, value: undefined };
+        delete snapshot.goal;
+        return { changed: true, value: undefined };
+      },
+    );
+    return this.projectGoalResult(result.snapshot);
+  }
+
+  private async setProjectScratchpadInState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    content: string,
+    writeContext: IFlexProjectManagementWriteContext,
+  ): Promise<IFlexProjectScratchpadResult> {
+    const result = await this.mutateProjectManagementState(
+      state,
+      stored,
+      writeContext,
+      (snapshot) => {
+        if (snapshot.scratchpad === content) return { changed: false, value: undefined };
+        snapshot.scratchpad = content;
+        return { changed: true, value: undefined };
+      },
+    );
+    return this.projectScratchpadResult(result.snapshot);
+  }
+
+  private async appendProjectScratchpadInState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    content: string,
+    writeContext: IFlexProjectManagementWriteContext,
+  ): Promise<IFlexProjectScratchpadResult> {
+    const result = await this.mutateProjectManagementState(
+      state,
+      stored,
+      writeContext,
+      (snapshot) => {
+        if (content.length === 0) return { changed: false, value: undefined };
+        const appended = `${snapshot.scratchpad}${content}`;
+        validateUtf8String(
+          appended,
+          'project scratchpad',
+          FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes,
+        );
+        snapshot.scratchpad = appended;
+        return { changed: true, value: undefined };
+      },
+    );
+    return this.projectScratchpadResult(result.snapshot);
+  }
+
+  private async clearProjectScratchpadInState(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    writeContext: IFlexProjectManagementWriteContext,
+  ): Promise<IFlexProjectScratchpadResult> {
+    const result = await this.mutateProjectManagementState(
+      state,
+      stored,
+      writeContext,
+      (snapshot) => {
+        if (snapshot.scratchpad.length === 0) return { changed: false, value: undefined };
+        snapshot.scratchpad = '';
+        return { changed: true, value: undefined };
+      },
+    );
+    return this.projectScratchpadResult(result.snapshot);
+  }
+
+  private async prepareGeneration(
+    run: IActiveRun,
+    options: IFlexPromptOptions,
+    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')) {
+      queued.status = 'running';
+      this.emitPromptQueueEvent(queued, 'prompt.running');
+    }
+    const resolverRelationship = {
+      ...(run.stored.session.parentSessionId === undefined
+        ? {}
+        : { parentSessionId: run.stored.session.parentSessionId }),
+      ...(run.stored.session.agent === undefined ? {} : { agent: run.stored.session.agent }),
+    };
+    const modelOutcome = Promise.resolve()
+      .then(() => this.modelResolver.resolveModel(Object.freeze({
+        scopeId: run.scopeId,
+        scope: run.scope as TScope,
+        sessionId: run.sessionId,
+        runId: run.runId,
+        ...(options.modelHint ? { modelHint: options.modelHint } : {}),
         ...resolverRelationship,
         signal,
       })))
@@ -3839,17 +4835,8 @@ export class FlexHarness<TScope = unknown> {
       let tools: TFlexAgentToolSet | undefined;
       try {
         const providedTools = toolHandle?.tools;
-        if (
-          this.subagents.size > 0
-          && providedTools
-          && Object.prototype.hasOwnProperty.call(providedTools, 'task')
-        ) {
-          throw new FlexHarnessValidationError('The application tool provider cannot define reserved tool "task".');
-        }
         const combinedTools: Record<string, unknown> = { ...(providedTools ?? {}) };
-        if (this.subagents.size > 0 && (run.stored.session.depth ?? 0) < this.maxSubagentDepth) {
-          combinedTools.task = this.createSubagentTool(run);
-        }
+        Object.assign(combinedTools, this.createBuiltInTools(run));
         tools = Object.keys(combinedTools).length > 0
           ? wrapToolSet(
               combinedTools as TFlexAgentToolSet,
@@ -3900,6 +4887,283 @@ export class FlexHarness<TScope = unknown> {
     }
   }
 
+  private enabledBuiltInToolNames(run: IActiveRun): Set<string> {
+    const names = new Set<string>();
+    if (this.subagents.size > 0 && (run.stored.session.depth ?? 0) < this.maxSubagentDepth) {
+      names.add('delegate');
+    }
+    if (this.builtInTools.renameSession) names.add('rename_session');
+    const projectManagement = this.builtInTools.projectManagement;
+    if (projectManagement?.task) names.add('task');
+    if (projectManagement?.goal) names.add('goal');
+    if (projectManagement?.scratchpad) names.add('scratchpad');
+    return names;
+  }
+
+  private assertNoBuiltInToolCollisions(run: IActiveRun, tools: TFlexAgentToolSet): void {
+    const reserved = this.enabledBuiltInToolNames(run);
+    const collision = Object.keys(tools).find((name) => reserved.has(name));
+    if (collision) {
+      throw new FlexHarnessValidationError(
+        `Tool provider cannot define enabled built-in tool "${collision}".`,
+      );
+    }
+  }
+
+  private createBuiltInTools(run: IActiveRun): Record<string, unknown> {
+    const tools: Record<string, unknown> = {};
+    if (this.subagents.size > 0 && (run.stored.session.depth ?? 0) < this.maxSubagentDepth) {
+      tools.delegate = this.createSubagentTool(run);
+    }
+    if (this.builtInTools.renameSession) tools.rename_session = this.createRenameSessionTool(run);
+    const projectManagement = this.builtInTools.projectManagement;
+    if (projectManagement?.task) tools.task = this.createProjectTaskTool(run);
+    if (projectManagement?.goal) tools.goal = this.createProjectGoalTool(run);
+    if (projectManagement?.scratchpad) tools.scratchpad = this.createProjectScratchpadTool(run);
+    return tools;
+  }
+
+  private createRenameSessionTool(run: IActiveRun): unknown {
+    return plugins.tool({
+      description: 'Set the current FlexHarness session title.',
+      inputSchema: plugins.z.object({
+        title: plugins.z.string().min(1).max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxTitleBytes),
+      }).strict(),
+      execute: async ({ title }: { title: string }) => {
+        validateUtf8String(
+          title,
+          'title',
+          FLEX_PROJECT_MANAGEMENT_LIMITS.maxTitleBytes,
+          true,
+        );
+        let session!: IFlexSession;
+        await this.mutateScope(run.state, () => {
+          if (run.state.sessions.get(run.sessionId) !== run.stored) {
+            throw new FlexHarnessNotFoundError('Session', run.sessionId);
+          }
+          run.stored.session.title = title;
+          run.stored.session.updatedAt = new Date().toISOString();
+          session = publicSnapshot(run.stored.session);
+        });
+        this.emitEvent(run.scopeId, run.sessionId, {
+          type: 'session.updated',
+          session,
+        });
+        return { session };
+      },
+    });
+  }
+
+  private createProjectTaskTool(run: IActiveRun): unknown {
+    const status = plugins.z.enum(['pending', 'in_progress', 'completed', 'cancelled']);
+    const priority = plugins.z.enum(['high', 'medium', 'low']);
+    const id = plugins.z.string().min(1).max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxTaskIdBytes);
+    const content = plugins.z.string().min(1).max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxTaskContentBytes);
+    return plugins.tool({
+      description: 'List, create, update, delete, or clear session-local project tasks.',
+      inputSchema: plugins.z.discriminatedUnion('action', [
+        plugins.z.object({ action: plugins.z.literal('list') }).strict(),
+        plugins.z.object({
+          action: plugins.z.literal('create'),
+          id: id.optional(),
+          content,
+          status: status.optional(),
+          priority: priority.optional(),
+        }).strict(),
+        plugins.z.object({
+          action: plugins.z.literal('update'),
+          id,
+          content: content.optional(),
+          status: status.optional(),
+          priority: priority.optional(),
+        }).strict().refine(
+          (input) => input.content !== undefined
+            || input.status !== undefined
+            || input.priority !== undefined,
+          { message: 'Task update requires content, status, or priority.' },
+        ),
+        plugins.z.object({ action: plugins.z.literal('delete'), id }).strict(),
+        plugins.z.object({ action: plugins.z.literal('clear') }).strict(),
+      ]),
+      execute: (
+        input: TProjectTaskToolInput,
+        options?: { toolCallId?: string },
+      ) => this.executeProjectTaskTool(run, input, options?.toolCallId),
+    });
+  }
+
+  private createProjectGoalTool(run: IActiveRun): unknown {
+    return plugins.tool({
+      description: 'Get, set, or clear the session-local project goal.',
+      inputSchema: plugins.z.discriminatedUnion('action', [
+        plugins.z.object({ action: plugins.z.literal('get') }).strict(),
+        plugins.z.object({
+          action: plugins.z.literal('set'),
+          goal: plugins.z.string().min(1).max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxGoalBytes),
+        }).strict(),
+        plugins.z.object({ action: plugins.z.literal('clear') }).strict(),
+      ]),
+      execute: (
+        input: TProjectGoalToolInput,
+        options?: { toolCallId?: string },
+      ) => this.executeProjectGoalTool(run, input, options?.toolCallId),
+    });
+  }
+
+  private createProjectScratchpadTool(run: IActiveRun): unknown {
+    const content = plugins.z.string().max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes);
+    return plugins.tool({
+      description: 'Get, set, append to, or clear the session-local project scratchpad.',
+      inputSchema: plugins.z.discriminatedUnion('action', [
+        plugins.z.object({ action: plugins.z.literal('get') }).strict(),
+        plugins.z.object({ action: plugins.z.literal('set'), content }).strict(),
+        plugins.z.object({ action: plugins.z.literal('append'), content }).strict(),
+        plugins.z.object({ action: plugins.z.literal('clear') }).strict(),
+      ]),
+      execute: (
+        input: TProjectScratchpadToolInput,
+        options?: { toolCallId?: string },
+      ) => this.executeProjectScratchpadTool(run, input, options?.toolCallId),
+    });
+  }
+
+  private projectManagementAgentWriteContext(
+    run: IActiveRun,
+    toolCallId: string | undefined,
+  ): IFlexProjectManagementWriteContext {
+    return Object.freeze({
+      actor: 'agent' as const,
+      runId: run.runId,
+      ...(run.stored.session.agent === undefined ? {} : { agent: run.stored.session.agent }),
+      ...(toolCallId === undefined ? {} : { toolCallId }),
+    });
+  }
+
+  private async executeProjectTaskTool(
+    run: IActiveRun,
+    input: TProjectTaskToolInput,
+    toolCallId: string | undefined,
+  ): Promise<IFlexProjectStateResult | IFlexProjectTaskResult | IFlexProjectTasksResult> {
+    this.assertProjectManagementSession(run.state, run.stored);
+    if (input.action === 'list') {
+      const snapshot = await this.readProjectManagementState(run.state, run.stored);
+      return this.projectTasksResult(snapshot, snapshot.tasks);
+    }
+    const writeContext = this.projectManagementAgentWriteContext(run, toolCallId);
+    if (input.action === 'create') {
+      const id = input.id ?? (() => {
+        validateUtf8String(
+          toolCallId,
+          'task toolCallId',
+          maxTransferIdentifierBytes,
+          true,
+        );
+        return this.createProjectTaskId(
+          run.state.storageKey,
+          run.sessionId,
+          run.runId,
+          toolCallId,
+        );
+      })();
+      const createInput: IFlexCreateProjectTaskInput = {
+        id,
+        content: input.content,
+        ...(input.status === undefined ? {} : { status: input.status }),
+        ...(input.priority === undefined ? {} : { priority: input.priority }),
+      };
+      validateCreateProjectTaskInput(createInput);
+      return this.createProjectTaskInState(run.state, run.stored, createInput, writeContext);
+    }
+    if (input.action === 'update') {
+      const updateInput: IFlexUpdateProjectTaskInput = {
+        id: input.id,
+        ...(input.content === undefined ? {} : { content: input.content }),
+        ...(input.status === undefined ? {} : { status: input.status }),
+        ...(input.priority === undefined ? {} : { priority: input.priority }),
+      };
+      validateUpdateProjectTaskInput(updateInput);
+      return this.updateProjectTaskInState(run.state, run.stored, updateInput, writeContext);
+    }
+    if (input.action === 'delete') {
+      validateProjectTaskId(input.id);
+      return this.deleteProjectTaskInState(run.state, run.stored, input.id, writeContext);
+    }
+    return this.clearProjectTasksInState(run.state, run.stored, writeContext);
+  }
+
+  private async executeProjectGoalTool(
+    run: IActiveRun,
+    input: TProjectGoalToolInput,
+    toolCallId: string | undefined,
+  ): Promise<IFlexProjectGoalResult> {
+    this.assertProjectManagementSession(run.state, run.stored);
+    if (input.action === 'get') {
+      return this.projectGoalResult(await this.readProjectManagementState(run.state, run.stored));
+    }
+    const writeContext = this.projectManagementAgentWriteContext(run, toolCallId);
+    if (input.action === 'set') {
+      validateUtf8String(
+        input.goal,
+        'project goal',
+        FLEX_PROJECT_MANAGEMENT_LIMITS.maxGoalBytes,
+        true,
+      );
+      return this.setProjectGoalInState(run.state, run.stored, input.goal, writeContext);
+    }
+    return this.clearProjectGoalInState(run.state, run.stored, writeContext);
+  }
+
+  private async executeProjectScratchpadTool(
+    run: IActiveRun,
+    input: TProjectScratchpadToolInput,
+    toolCallId: string | undefined,
+  ): Promise<IFlexProjectScratchpadResult> {
+    this.assertProjectManagementSession(run.state, run.stored);
+    if (input.action === 'get') {
+      return this.projectScratchpadResult(
+        await this.readProjectManagementState(run.state, run.stored),
+      );
+    }
+    const writeContext = this.projectManagementAgentWriteContext(run, toolCallId);
+    if (input.action === 'set') {
+      validateUtf8String(
+        input.content,
+        'project scratchpad',
+        FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes,
+      );
+      return this.setProjectScratchpadInState(run.state, run.stored, input.content, writeContext);
+    }
+    if (input.action === 'append') {
+      validateUtf8String(
+        input.content,
+        'project scratchpad append',
+        FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes,
+      );
+      return this.appendProjectScratchpadInState(
+        run.state,
+        run.stored,
+        input.content,
+        writeContext,
+      );
+    }
+    return this.clearProjectScratchpadInState(run.state, run.stored, writeContext);
+  }
+
+  private createProjectTaskId(
+    storageKey: string,
+    sessionId: string,
+    runId: string,
+    toolCallId: string,
+  ): string {
+    return `task_${sha256Hex(JSON.stringify([
+      'flexharness-project-task-v1',
+      storageKey,
+      sessionId,
+      runId,
+      toolCallId,
+    ]))}`;
+  }
+
   private createSubagentTool(run: IActiveRun): unknown {
     const available = [...this.subagents.values()]
       .map((definition) => `- ${definition.name}: ${definition.description}`)
@@ -3930,16 +5194,16 @@ export class FlexHarness<TScope = unknown> {
     }
     validateUtf8String(
       input.description,
-      'task description',
+      'delegate description',
       maxSubagentTaskDescriptionBytes,
       true,
     );
-    validateUtf8String(input.prompt, 'task prompt', maxSubagentPromptBytes, true);
+    validateUtf8String(input.prompt, 'delegate prompt', maxSubagentPromptBytes, true);
     validateUtf8String(input.subagentType, 'subagentType', maxSubagentNameBytes, true);
     if (input.taskId !== undefined) {
       validateUtf8String(input.taskId, 'taskId', maxSubagentTaskIdBytes, true);
     }
-    validateUtf8String(toolCallId, 'task toolCallId', maxTransferIdentifierBytes, true);
+    validateUtf8String(toolCallId, 'delegate toolCallId', maxTransferIdentifierBytes, true);
     const definition = this.subagents.get(input.subagentType);
     if (!definition || (run.stored.session.depth ?? 0) >= this.maxSubagentDepth) {
       throw new FlexHarnessValidationError(`Subagent "${input.subagentType}" is not available.`);
@@ -4163,6 +5427,8 @@ export class FlexHarness<TScope = unknown> {
         metadata = {
           scopeId: run.scopeId,
           sessionId,
+          sessionGenerationId: createSessionGenerationId(),
+          sessionGenerationSequence: state.revision + 1,
           title: `Subagent: ${definition.name}`,
           createdAt: timestamp,
           updatedAt: timestamp,
@@ -4236,6 +5502,7 @@ export class FlexHarness<TScope = unknown> {
           state.sessions.delete(sessionId);
           state.tombstones.set(sessionId, {
             sessionId,
+            ...requireSessionGeneration(metadata!),
             deletedAt: new Date().toISOString(),
             rootSessionId: sessionId,
             depth: 0,
@@ -4291,12 +5558,12 @@ export class FlexHarness<TScope = unknown> {
     const partId = run.toolPartIds.get(toolCallId);
     const part = run.callbackParts.find((entry) => entry.partId === partId && entry.type === 'tool');
     if (!part || part.type !== 'tool' || part.status !== 'running') {
-      throw new FlexHarnessValidationError(`Running task part "${toolCallId}" is unavailable.`);
+      throw new FlexHarnessValidationError(`Running delegate part "${toolCallId}" is unavailable.`);
     }
     const bytes = Buffer.byteLength(childSessionId, 'utf8')
       + (model === undefined ? 0 : jsonBytes(model));
     if (!this.reserveCallbackCapacity(run, 1, bytes, 0)) {
-      throw run.callbackError ?? new FlexHarnessCallbackOverflowError('Task metadata exceeded callback limits.');
+      throw run.callbackError ?? new FlexHarnessCallbackOverflowError('Delegate metadata exceeded callback limits.');
     }
     part.childSessionId = childSessionId;
     if (model !== undefined) part.model = cloneSerializable(model);
@@ -4445,6 +5712,11 @@ export class FlexHarness<TScope = unknown> {
     return `${kind}_${sha256Hex(JSON.stringify([storageKey, sessionId, value]))}`;
   }
 
+  private reversionProviderProtocolVersion(): 1 | 2 | undefined {
+    if (!this.turnReversionProvider) return undefined;
+    return 'protocolVersion' in this.turnReversionProvider ? 2 : 1;
+  }
+
   private reversionCaptureContext(
     run: IActiveRun,
     captureId: string,
@@ -4491,9 +5763,10 @@ export class FlexHarness<TScope = unknown> {
     sessionId: string,
     runId: string,
     captureId: string,
-  ) {
-    return this.withReversionMaintenanceSignal((signal) =>
-      this.turnReversionProvider!.inspectCapture(Object.freeze({
+  ): Promise<TNormalizedCaptureInspection> {
+    return this.withReversionMaintenanceSignal(async (signal) => {
+      const provider = this.turnReversionProvider!;
+      const inspection = await provider.inspectCapture(Object.freeze({
         scopeId,
         scope,
         storageKey,
@@ -4501,7 +5774,29 @@ export class FlexHarness<TScope = unknown> {
         runId,
         captureId,
         signal,
-      })));
+      }));
+      if (inspection.status !== 'finalized') return { status: inspection.status };
+      if (this.reversionProviderProtocolVersion() === 2) {
+        if (!('outcome' in inspection)) {
+          throw new FlexHarnessValidationError('Protocol-2 finalized inspection has no outcome.');
+        }
+        return {
+          status: 'finalized',
+          outcome: this.normalizeReversionOutcome(inspection.outcome),
+        };
+      }
+      if (!('reference' in inspection) || inspection.reference === undefined) {
+        throw new FlexHarnessValidationError('Protocol-1 finalized inspection has no reference.');
+      }
+      return {
+        status: 'finalized',
+        outcome: {
+          disposition: 'revertible',
+          reference: this.normalizeReversionReference(inspection.reference),
+          affectedWorkspaces: [],
+        },
+      };
+    });
   }
 
   private finalizeReversionCapture(
@@ -4511,9 +5806,9 @@ export class FlexHarness<TScope = unknown> {
     sessionId: string,
     runId: string,
     captureId: string,
-  ) {
-    return this.withReversionMaintenanceSignal((signal) =>
-      this.turnReversionProvider!.finalize(Object.freeze({
+  ): Promise<TFlexTurnReversionFinalizedOutcome> {
+    return this.withReversionMaintenanceSignal(async (signal) => {
+      const result = await this.turnReversionProvider!.finalize(Object.freeze({
         scopeId,
         scope,
         storageKey,
@@ -4521,10 +5816,18 @@ export class FlexHarness<TScope = unknown> {
         runId,
         captureId,
         signal,
-      })));
+      }));
+      return this.reversionProviderProtocolVersion() === 2
+        ? this.normalizeReversionOutcome(result)
+        : {
+            disposition: 'revertible',
+            reference: this.normalizeReversionReference(result),
+            affectedWorkspaces: [],
+          };
+    });
   }
 
-  private async resolveReversionCaptureReference(
+  private async resolveReversionCaptureOutcome(
     state: IStorageState,
     scopeId: string,
     scope: TScope,
@@ -4532,7 +5835,7 @@ export class FlexHarness<TScope = unknown> {
     runId: string,
     captureId: string,
     durableState: 'preparing' | 'prepared' | 'finalizing',
-  ): Promise<TJsonValue | undefined> {
+  ): Promise<TFlexTurnReversionFinalizedOutcome | undefined> {
     let inspection;
     try {
       inspection = await this.inspectReversionCapture(
@@ -4556,10 +5859,10 @@ export class FlexHarness<TScope = unknown> {
       state.lifecycle = 'fenced';
       throw new FlexHarnessValidationError('Prepared reversion capture is missing.');
     }
-    let reference = inspection.reference;
+    let outcome = inspection.status === 'finalized' ? inspection.outcome : undefined;
     if (inspection.status === 'prepared') {
       try {
-        reference = await this.finalizeReversionCapture(
+        outcome = await this.finalizeReversionCapture(
           scopeId,
           scope,
           state.storageKey,
@@ -4576,27 +5879,123 @@ export class FlexHarness<TScope = unknown> {
           runId,
           captureId,
         );
-        if (finalInspection.status !== 'finalized' || finalInspection.reference === undefined) {
+        if (finalInspection.status !== 'finalized') {
           if (finalInspection.status === 'unknown') state.lifecycle = 'fenced';
           throw this.projectOperationError(error, 'turnReversion', scopeId, sessionId, captureId);
         }
-        reference = finalInspection.reference;
+        outcome = finalInspection.outcome;
+      }
+    }
+    if (outcome === undefined) {
+      state.lifecycle = 'fenced';
+      throw new FlexHarnessValidationError('Finalized reversion capture has no outcome.');
+    }
+    return outcome;
+  }
+
+  private normalizeReversionReference(reference: unknown): TJsonValue {
+    return normalizeJsonValue(reference, {
+      maxDepth: this.toolOutputLimits.maxDepth,
+      maxBytes: Math.min(
+        this.toolOutputLimits.maxBytes,
+        FLEX_REVERSION_REFERENCE_MAX_BYTES,
+      ),
+    });
+  }
+
+  private normalizeReversionOutcome(value: unknown): TFlexTurnReversionFinalizedOutcome {
+    if (
+      !value
+      || typeof value !== 'object'
+      || Array.isArray(value)
+      || (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+    ) throw new FlexHarnessValidationError('Turn reversion finalized outcome must be a plain object.');
+    const outcome = value as Record<string, unknown>;
+    const disposition = outcome.disposition;
+    if (!['revertible', 'no-change', 'nonrevertible'].includes(String(disposition))) {
+      throw new FlexHarnessValidationError('Turn reversion finalized outcome disposition is invalid.');
+    }
+    const allowedKeys = disposition === 'nonrevertible'
+      ? ['disposition', 'reference', 'reasonCode', 'affectedWorkspaces']
+      : ['disposition', 'reference', 'affectedWorkspaces'];
+    const unsupported = Object.keys(outcome).find((key) => !allowedKeys.includes(key));
+    if (unsupported) {
+      throw new FlexHarnessValidationError(
+        `Turn reversion finalized outcome does not support "${unsupported}".`,
+      );
+    }
+    if (!Object.prototype.hasOwnProperty.call(outcome, 'reference')) {
+      throw new FlexHarnessValidationError('Turn reversion finalized outcome requires a reference.');
+    }
+    const reference = this.normalizeReversionReference(outcome.reference);
+    const affectedWorkspaces = outcome.affectedWorkspaces === undefined
+      ? undefined
+      : this.normalizeAffectedWorkspaces(outcome.affectedWorkspaces);
+    if (disposition === 'revertible') {
+      if (affectedWorkspaces === undefined) {
+        throw new FlexHarnessValidationError('Revertible outcome requires affectedWorkspaces.');
       }
+      return { disposition, reference, affectedWorkspaces };
     }
-    if (reference === undefined) {
-      state.lifecycle = 'fenced';
-      throw new FlexHarnessValidationError('Finalized reversion capture has no reference.');
+    if (disposition === 'no-change') {
+      if (affectedWorkspaces && affectedWorkspaces.length > 0) {
+        throw new FlexHarnessValidationError('No-change outcome cannot affect a workspace.');
+      }
+      return {
+        disposition,
+        reference,
+        ...(affectedWorkspaces === undefined ? {} : { affectedWorkspaces: [] }),
+      };
     }
-    return this.normalizeReversionReference(reference);
+    if (
+      typeof outcome.reasonCode !== 'string'
+      || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(outcome.reasonCode)
+      || Buffer.byteLength(outcome.reasonCode, 'utf8') > FLEX_REVERSION_REASON_CODE_MAX_BYTES
+    ) throw new FlexHarnessValidationError('Nonrevertible outcome reasonCode is invalid.');
+    return {
+      disposition: 'nonrevertible',
+      reference,
+      reasonCode: outcome.reasonCode,
+      ...(affectedWorkspaces === undefined ? {} : { affectedWorkspaces }),
+    };
   }
 
-  private normalizeReversionReference(reference: unknown): TJsonValue {
-    return normalizeJsonValue(reference, {
-      maxDepth: this.toolOutputLimits.maxDepth,
-      maxBytes: Math.min(
-        this.toolOutputLimits.maxBytes,
-        FLEX_REVERSION_REFERENCE_MAX_BYTES,
-      ),
+  private normalizeAffectedWorkspaces(value: unknown): IFlexAffectedWorkspace[] {
+    if (!Array.isArray(value) || value.length > FLEX_REVERSION_MAX_AFFECTED_WORKSPACES) {
+      throw new FlexHarnessValidationError(
+        `affectedWorkspaces must contain at most ${FLEX_REVERSION_MAX_AFFECTED_WORKSPACES} entries.`,
+      );
+    }
+    const ids = new Set<string>();
+    return value.map((entry, index) => {
+      if (
+        !entry
+        || typeof entry !== 'object'
+        || Array.isArray(entry)
+        || (Object.getPrototypeOf(entry) !== Object.prototype && Object.getPrototypeOf(entry) !== null)
+      ) throw new FlexHarnessValidationError(`affectedWorkspaces[${index}] must be a plain object.`);
+      const descriptor = entry as Record<string, unknown>;
+      const unsupported = Object.keys(descriptor).find((key) => !['id', 'label'].includes(key));
+      if (unsupported) {
+        throw new FlexHarnessValidationError(
+          `affectedWorkspaces[${index}] does not support "${unsupported}".`,
+        );
+      }
+      if (
+        typeof descriptor.id !== 'string'
+        || !descriptor.id.trim()
+        || Buffer.byteLength(descriptor.id, 'utf8') > FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES
+      ) throw new FlexHarnessValidationError(`affectedWorkspaces[${index}].id is invalid.`);
+      if (
+        typeof descriptor.label !== 'string'
+        || !descriptor.label.trim()
+        || Buffer.byteLength(descriptor.label, 'utf8') > FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES
+      ) throw new FlexHarnessValidationError(`affectedWorkspaces[${index}].label is invalid.`);
+      if (ids.has(descriptor.id)) {
+        throw new FlexHarnessValidationError(`affectedWorkspaces contains duplicate id "${descriptor.id}".`);
+      }
+      ids.add(descriptor.id);
+      return { id: descriptor.id, label: descriptor.label };
     });
   }
 
@@ -4612,6 +6011,13 @@ export class FlexHarness<TScope = unknown> {
       );
     }
     const context = this.reversionCaptureContext(run, captureId, signal);
+    if (this.reversionProviderProtocolVersion() !== segment.protocolVersion) {
+      throw this.projectExternalError(
+        run,
+        new Error(`Root generation requires reversion protocolVersion ${segment.protocolVersion}.`),
+        'turnReversion',
+      );
+    }
     try {
       await this.turnReversionProvider.prepare(context);
     } catch (error) {
@@ -4653,7 +6059,7 @@ export class FlexHarness<TScope = unknown> {
     const eventIds = run.stored.agentSession.getEvents()
       .filter((event) => event.generationId === run.runId)
       .map((event) => event.id);
-    if (!this.turnReversionProvider || !segment.captureId) {
+    if (!this.turnReversionProvider || segment.provenance === 'transcript') {
       await this.mutateProjection(run.state, run.stored, () => {
         const wasCompleted = segment.status === 'completed';
         segment.status = status;
@@ -4665,6 +6071,9 @@ export class FlexHarness<TScope = unknown> {
       }, true);
       return;
     }
+    if (!segment.captureId) {
+      throw new FlexHarnessValidationError('Workspace reversion segment has no capture ownership.');
+    }
     const captureId = segment.captureId;
     if (segment.workspaceReference !== undefined) {
       await this.mutateProjection(run.state, run.stored, () => {
@@ -4681,16 +6090,30 @@ export class FlexHarness<TScope = unknown> {
     if (pending?.kind !== 'capture' || pending.runId !== run.runId) {
       throw new FlexHarnessValidationError('Reversion capture intent changed before finalization.');
     }
-    const reference = await this.resolveReversionCaptureReference(
+    if (this.reversionProviderProtocolVersion() !== pending.protocolVersion) {
+      throw new FlexHarnessValidationError(
+        `Reversion capture finalization requires protocolVersion ${pending.protocolVersion}.`,
+      );
+    }
+    if (pending.state === 'prepared') {
+      await this.mutateProjection(run.state, run.stored, () => {
+        const current = run.stored.pendingReversion;
+        if (current?.kind !== 'capture' || current.captureId !== captureId) {
+          throw new FlexHarnessValidationError('Reversion capture changed before finalization.');
+        }
+        current.state = 'finalizing';
+      }, true);
+    }
+    const outcome = await this.resolveReversionCaptureOutcome(
       run.state,
       run.scopeId,
       run.scope as TScope,
       run.sessionId,
       run.runId,
       captureId,
-      pending.state,
+      pending.state === 'prepared' ? 'finalizing' : pending.state,
     );
-    if (reference === undefined) {
+    if (outcome === undefined) {
       await this.mutateProjection(run.state, run.stored, () => {
         run.stored.reversionSegments = run.stored.reversionSegments.filter(
           (entry) => entry.runId !== run.runId,
@@ -4707,7 +6130,7 @@ export class FlexHarness<TScope = unknown> {
       const wasCompleted = segment.status === 'completed';
       segment.status = status;
       segment.eventIds = eventIds;
-      segment.workspaceReference = reference;
+      this.applyFinalizedReversionOutcome(run.stored, segment, outcome);
       if (!wasCompleted && status === 'completed') run.stored.revertCursor++;
       else if (wasCompleted && status !== 'completed') run.stored.revertCursor--;
       delete run.stored.pendingReversion;
@@ -4715,34 +6138,73 @@ export class FlexHarness<TScope = unknown> {
     }, true);
   }
 
+  private applyFinalizedReversionOutcome(
+    stored: IStoredSessionState,
+    segment: IFlexReversionSegment,
+    outcome: TFlexTurnReversionFinalizedOutcome,
+  ): void {
+    const captureId = segment.captureId;
+    if (!captureId) {
+      throw new FlexHarnessValidationError('Finalized workspace outcome has no capture ownership.');
+    }
+    segment.disposition = outcome.disposition;
+    delete segment.affectedWorkspaces;
+    delete segment.reasonCode;
+    if (segment.protocolVersion === 2) {
+      if (outcome.affectedWorkspaces !== undefined) {
+        segment.affectedWorkspaces = cloneSerializable([...outcome.affectedWorkspaces]);
+      }
+      if (outcome.disposition === 'nonrevertible') segment.reasonCode = outcome.reasonCode;
+    }
+    if (outcome.disposition === 'revertible') {
+      segment.workspaceReference = cloneSerializable(outcome.reference);
+      return;
+    }
+    this.enqueueReversionReleaseReference(stored, {
+      runId: segment.runId,
+      captureId,
+      reference: cloneSerializable(outcome.reference),
+      protocolVersion: segment.protocolVersion,
+    });
+    delete segment.captureId;
+    delete segment.workspaceReference;
+  }
+
   private hiddenReversionSegments(stored: IStoredSessionState): IFlexReversionSegment[] {
-    const candidates = this.completedReversionCandidates(stored);
-    const firstHidden = candidates[stored.revertCursor];
+    const firstHidden = this.reversionGroups(stored)[stored.revertCursor]?.segments[0];
     if (!firstHidden) return [];
     const index = stored.reversionSegments.findIndex((segment) => segment.runId === firstHidden.runId);
     if (index < 0) return [];
-    return stored.reversionSegments.slice(firstHidden === candidates[0] ? 0 : index);
+    return stored.reversionSegments.slice(index);
   }
 
   private enqueueReversionRelease(
     stored: IStoredSessionState,
     segment: IFlexReversionSegment,
   ): void {
-    if (!segment.workspaceCaptured) return;
+    if (segment.disposition !== 'revertible') 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)) {
+    this.enqueueReversionReleaseReference(stored, {
+      runId: segment.runId,
+      captureId: segment.captureId,
+      reference: cloneSerializable(segment.workspaceReference),
+      protocolVersion: segment.protocolVersion,
+    });
+  }
+
+  private enqueueReversionReleaseReference(
+    stored: IStoredSessionState,
+    release: IFlexPendingReversionRelease,
+  ): void {
+    if (stored.pendingReversionReleases.some((entry) => entry.captureId === release.captureId)) {
       return;
     }
     if (stored.pendingReversionReleases.length >= this.reversionLimits.maxPendingReversionReleases) {
       throw new FlexHarnessValidationError('Pending reversion release limit was reached.');
     }
-    stored.pendingReversionReleases.push({
-      runId: segment.runId,
-      captureId: segment.captureId,
-      reference: cloneSerializable(segment.workspaceReference),
-    });
+    stored.pendingReversionReleases.push(cloneSerializable(release));
   }
 
   private pruneReversionState(
@@ -4784,7 +6246,8 @@ export class FlexHarness<TScope = unknown> {
       }
       if (end <= 0) break;
       const prefix = stored.reversionSegments.slice(0, end);
-      if (prefix.some((segment) => segment.workspaceCaptured && segment.workspaceReference === undefined)) break;
+      if (prefix.some((segment) =>
+        segment.disposition === 'revertible' && segment.workspaceReference === undefined)) break;
       for (const segment of prefix) this.enqueueReversionRelease(stored, segment);
       stored.reversionSegments.splice(0, end);
       stored.revertCursor = Math.max(
@@ -4897,6 +6360,11 @@ export class FlexHarness<TScope = unknown> {
     }
     while (stored.pendingReversionReleases.length > 0) {
       const release = stored.pendingReversionReleases[0];
+      if (this.reversionProviderProtocolVersion() !== release.protocolVersion) {
+        throw new FlexHarnessValidationError(
+          `Pending workspace release requires protocolVersion ${release.protocolVersion}.`,
+        );
+      }
       try {
         await this.withReversionMaintenanceSignal((signal) =>
           this.turnReversionProvider!.release(Object.freeze({
@@ -4947,9 +6415,33 @@ export class FlexHarness<TScope = unknown> {
     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;
+    let durableProjection = await this.stores.projections.load(storageKey, sessionId);
+    if (!durableProjection) return;
+    let projection = this.upgradeProjectionSnapshot(durableProjection);
+    const persistDirect = async (next: IFlexProjectionSnapshotCurrent): Promise<void> => {
+      const before = durableProjection;
+      try {
+        await this.stores.projections.save(storageKey, sessionId, next, projection.revision);
+        durableProjection = next;
+        projection = next;
+      } catch (error) {
+        let current: TFlexProjectionSnapshot | undefined;
+        let reconciliationError: unknown;
+        try {
+          current = await this.stores.projections.load(storageKey, sessionId);
+        } catch (loadError) {
+          reconciliationError = loadError;
+        }
+        if (current && JSON.stringify(current) === JSON.stringify(next)) {
+          durableProjection = current;
+          projection = next;
+          return;
+        }
+        if (current && before && JSON.stringify(current) === JSON.stringify(before)) throw error;
+        state.lifecycle = 'fenced';
+        throw reconciliationError === undefined ? error : combineErrors([error, reconciliationError]);
+      }
+    };
     if (projection.pendingReversion?.kind === 'apply') {
       if (stored) {
         await this.resumePendingApply(state, stored, scopeId, scope);
@@ -4961,12 +6453,17 @@ export class FlexHarness<TScope = unknown> {
         for (const runId of orderedRunIds) {
           if (pending.appliedRunIds.includes(runId)) continue;
           const segment = projection.reversionSegments.find((entry) => entry.runId === runId)!;
-          if (segment.workspaceCaptured) {
+          if (segment.disposition === 'revertible') {
             if (!this.turnReversionProvider || !segment.captureId || segment.workspaceReference === undefined) {
               throw new FlexHarnessValidationError(
                 'Pending workspace reversion deletion requires its turn reversion provider.',
               );
             }
+            if (this.reversionProviderProtocolVersion() !== segment.protocolVersion) {
+              throw new FlexHarnessValidationError(
+                `Pending workspace reversion deletion requires protocolVersion ${segment.protocolVersion}.`,
+              );
+            }
             const captureId = segment.captureId;
             const reference = segment.workspaceReference;
             const operationId = `${pending.operationId}:${sha256Hex(runId).slice(0, 16)}`;
@@ -4985,6 +6482,7 @@ export class FlexHarness<TScope = unknown> {
             let inspection = await this.withReversionMaintenanceSignal((signal) =>
               this.turnReversionProvider!.inspectApply(createContext(signal)));
             if (inspection.status === 'unknown') {
+              state.lifecycle = 'fenced';
               throw new FlexHarnessValidationError('Workspace reversion apply outcome is unknown.');
             }
             if (inspection.status === 'not-applied') {
@@ -4994,14 +6492,15 @@ export class FlexHarness<TScope = unknown> {
               } catch (error) {
                 inspection = await this.withReversionMaintenanceSignal((signal) =>
                   this.turnReversionProvider!.inspectApply(createContext(signal)));
-                if (inspection.status !== 'applied') throw error;
+                if (inspection.status !== 'applied') {
+                  if (inspection.status === 'unknown') state.lifecycle = 'fenced';
+                  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;
+          await persistDirect({ ...projection, revision: projection.revision + 1 });
         }
         const { pendingReversion: _pendingReversion, ...completedProjection } = projection;
         const completed: IFlexProjectionSnapshotCurrent = {
@@ -5009,23 +6508,12 @@ export class FlexHarness<TScope = unknown> {
           revision: projection.revision + 1,
           revertCursor: pending.toCursor,
         };
-        await this.stores.projections.save(storageKey, sessionId, completed, projection.revision);
-        projection = completed;
+        await persistDirect(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;
+      if (!recoveredProjection) return;
+      durableProjection = recoveredProjection;
+      projection = this.upgradeProjectionSnapshot(recoveredProjection);
     }
     const releases = new Map<string, IFlexPendingReversionRelease>();
     for (const release of projection.pendingReversionReleases) {
@@ -5037,12 +6525,14 @@ export class FlexHarness<TScope = unknown> {
           runId: segment.runId,
           captureId: segment.captureId,
           reference: cloneSerializable(segment.workspaceReference),
+          protocolVersion: segment.protocolVersion,
         });
       }
     }
     const unresolvedCaptures = new Map<string, {
       runId: string;
       captureId: string;
+      protocolVersion: 1 | 2;
       durableState?: 'preparing' | 'prepared' | 'finalizing';
     }>();
     for (const segment of projection.reversionSegments) {
@@ -5050,6 +6540,7 @@ export class FlexHarness<TScope = unknown> {
         unresolvedCaptures.set(segment.captureId, {
           runId: segment.runId,
           captureId: segment.captureId,
+          protocolVersion: segment.protocolVersion,
         });
       }
     }
@@ -5057,10 +6548,36 @@ export class FlexHarness<TScope = unknown> {
       unresolvedCaptures.set(projection.pendingReversion.captureId, {
         runId: projection.pendingReversion.runId,
         captureId: projection.pendingReversion.captureId,
+        protocolVersion: projection.pendingReversion.protocolVersion,
         durableState: projection.pendingReversion.state,
       });
     }
+    if (unresolvedCaptures.size > 0 && !this.turnReversionProvider) {
+      throw new FlexHarnessValidationError(
+        'Capture-backed session deletion requires its turn reversion provider.',
+      );
+    }
     for (const capture of unresolvedCaptures.values()) {
+      if (this.reversionProviderProtocolVersion() !== capture.protocolVersion) {
+        throw new FlexHarnessValidationError(
+          `Deleted session capture requires protocolVersion ${capture.protocolVersion}.`,
+        );
+      }
+      if (capture.durableState === 'prepared') {
+        if (stored) {
+          await this.mutateProjection(state, stored, () => {
+            const pending = stored.pendingReversion;
+            if (pending?.kind !== 'capture' || pending.captureId !== capture.captureId) {
+              throw new FlexHarnessValidationError('Deleted session capture changed before finalization.');
+            }
+            pending.state = 'finalizing';
+          }, true);
+        } else if (projection.pendingReversion?.kind === 'capture') {
+          projection.pendingReversion.state = 'finalizing';
+          await persistDirect({ ...projection, revision: projection.revision + 1 });
+        }
+        capture.durableState = 'finalizing';
+      }
       let inspection;
       try {
         inspection = await this.inspectReversionCapture(
@@ -5081,6 +6598,7 @@ export class FlexHarness<TScope = unknown> {
         );
       }
       if (inspection.status === 'unknown') {
+        state.lifecycle = 'fenced';
         throw new FlexHarnessValidationError('Deleted session capture outcome is unknown.');
       }
       if (inspection.status === 'missing') {
@@ -5088,10 +6606,10 @@ export class FlexHarness<TScope = unknown> {
         state.lifecycle = 'fenced';
         throw new FlexHarnessValidationError('Prepared deleted-session capture is missing.');
       }
-      let reference = inspection.reference;
+      let outcome = inspection.status === 'finalized' ? inspection.outcome : undefined;
       if (inspection.status === 'prepared') {
         try {
-          reference = await this.finalizeReversionCapture(
+          outcome = await this.finalizeReversionCapture(
             scopeId,
             scope,
             storageKey,
@@ -5108,7 +6626,8 @@ export class FlexHarness<TScope = unknown> {
             capture.runId,
             capture.captureId,
           );
-          if (finalInspection.status !== 'finalized' || finalInspection.reference === undefined) {
+          if (finalInspection.status !== 'finalized') {
+            if (finalInspection.status === 'unknown') state.lifecycle = 'fenced';
             throw this.projectOperationError(
               error,
               'turnReversion',
@@ -5117,63 +6636,77 @@ export class FlexHarness<TScope = unknown> {
               `release:${capture.captureId}`,
             );
           }
-          reference = finalInspection.reference;
+          outcome = finalInspection.outcome;
         }
       }
-      if (reference === undefined) {
+      if (outcome === 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),
+        reference: cloneSerializable(outcome.reference),
+        protocolVersion: capture.protocolVersion,
       });
     }
+    if (releases.size === 0) return;
+    if (!this.turnReversionProvider) {
+      throw new FlexHarnessValidationError(
+        'Capture-backed session deletion requires its turn reversion provider.',
+      );
+    }
     if (stored) {
       await this.mutateProjection(state, stored, () => {
-        for (const release of releases.values()) {
-          if (!stored.pendingReversionReleases.some((entry) => entry.captureId === release.captureId)) {
-            stored.pendingReversionReleases.push(cloneSerializable(release));
-          }
-        }
+        stored.reversionSegments = [];
+        stored.revertCursor = 0;
+        delete stored.pendingReversion;
+        stored.pendingReversionReleases = [...releases.values()].map((release) =>
+          cloneSerializable(release));
       }, true);
+      await this.drainReversionReleases(state, stored, scopeId, scope, true);
     } else {
-      const 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({
+      const { pendingReversion: _pendingReversion, ...withoutPending } = projection;
+      await persistDirect({
+        ...withoutPending,
+        revision: projection.revision + 1,
+        reversionSegments: [],
+        revertCursor: 0,
+        pendingReversionReleases: [...releases.values()].map((release) =>
+          cloneSerializable(release)),
+      });
+      while (projection.pendingReversionReleases.length > 0) {
+        const release = projection.pendingReversionReleases[0];
+        if (this.reversionProviderProtocolVersion() !== release.protocolVersion) {
+          throw new FlexHarnessValidationError(
+            `Deleted session release requires protocolVersion ${release.protocolVersion}.`,
+          );
+        }
+        try {
+          await this.withReversionMaintenanceSignal((signal) =>
+            this.turnReversionProvider!.release(Object.freeze({
+              scopeId,
+              scope,
+              storageKey,
+              sessionId,
+              runId: release.runId,
+              captureId: release.captureId,
+              reference: cloneSerializable(release.reference),
+              signal,
+            })));
+        } catch (error) {
+          throw this.projectOperationError(
+            error,
+            'turnReversion',
             scopeId,
-            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}`,
-        );
+            `release:${release.captureId}`,
+          );
+        }
+        await persistDirect({
+          ...projection,
+          revision: projection.revision + 1,
+          pendingReversionReleases: projection.pendingReversionReleases.slice(1),
+        });
       }
     }
   }
@@ -5831,6 +7364,7 @@ export class FlexHarness<TScope = unknown> {
         throw new FlexHarnessValidationError('Tool handle close must be a function.');
       }
       const tools = handle.tools;
+      this.assertNoBuiltInToolCollisions(run, tools);
       const closeHandle = close;
       return {
         tools,
@@ -6170,6 +7704,28 @@ export class FlexHarness<TScope = unknown> {
       sessions: [],
       tombstones: [],
     } satisfies IFlexScopeSnapshot);
+    let scopeChanged = false;
+    const repairedGenerationSequence = snapshot.revision + 1;
+    for (const session of snapshot.sessions) {
+      if (session.sessionGenerationId !== undefined) continue;
+      session.sessionGenerationId = deriveLegacySessionGenerationId(
+        storageKey,
+        session.sessionId,
+        session.createdAt,
+      );
+      session.sessionGenerationSequence = repairedGenerationSequence;
+      scopeChanged = true;
+    }
+    for (const tombstone of snapshot.tombstones) {
+      if (tombstone.sessionGenerationId !== undefined) continue;
+      tombstone.sessionGenerationId = deriveLegacySessionGenerationId(
+        storageKey,
+        tombstone.sessionId,
+        tombstone.deletedAt,
+      );
+      tombstone.sessionGenerationSequence = repairedGenerationSequence;
+      scopeChanged = true;
+    }
     const state: IStorageState = {
       storageKey,
       compactorLifecycleController,
@@ -6192,7 +7748,6 @@ export class FlexHarness<TScope = unknown> {
       detachedCleanups: new Set(),
     };
     const loadedSessions: IStoredSessionState[] = [];
-    let scopeChanged = false;
     try {
       for (const metadata of snapshot.sessions) {
         if (state.tombstones.has(metadata.sessionId)) continue;
@@ -6244,12 +7799,16 @@ export class FlexHarness<TScope = unknown> {
               scopeId,
               scope,
             );
-            await this.cleanupSessionDomains(storageKey, tombstone.sessionId);
+            await this.cleanupSessionDomains(storageKey, tombstone);
           }
           for (const tombstone of group) state.tombstones.delete(tombstone.sessionId);
           scopeChanged = true;
-        } catch {
+        } catch (error) {
           // A retained tombstone is retried by the next load or explicit delete call.
+          if (state.lifecycle === 'fenced') {
+            this.deferNamespaceDrain(state, error, { scopeId, scope });
+            break;
+          }
         }
       }
       if (scopeChanged) {
@@ -6305,7 +7864,7 @@ export class FlexHarness<TScope = unknown> {
       revertCursor: 0,
       excludedRunIds: [],
       pendingReversionReleases: [],
-      projectionSchemaVersion: 2,
+      projectionSchemaVersion: 3,
       projectionReconciliationRequired: false,
       projectionRevision: 0,
       projectionQueue: Promise.resolve(),
@@ -6373,7 +7932,28 @@ export class FlexHarness<TScope = unknown> {
       throw combineErrors(acquisitionErrors);
     }
     const projection = projectionResult.value;
-    const projectionV2 = projection?.schemaVersion === 2 ? projection : undefined;
+    const legacyProjection = projection?.schemaVersion === 2 ? projection : undefined;
+    const currentProjection = projection?.schemaVersion === 3 ? projection : undefined;
+    const reversionSegments: IFlexReversionSegment[] = currentProjection
+      ? cloneSerializable(currentProjection.reversionSegments)
+      : (legacyProjection?.reversionSegments ?? []).map((segment): IFlexReversionSegment => ({
+          ...cloneSerializable(segment),
+          protocolVersion: 1,
+          provenance: segment.workspaceCaptured ? 'workspace' : 'transcript',
+          ...(segment.workspaceCaptured
+            ? { disposition: segment.status === 'capturing' ? 'pending' : 'revertible' }
+            : {}),
+        }));
+    const pendingReversion = currentProjection?.pendingReversion
+      ?? (legacyProjection?.pendingReversion?.kind === 'capture'
+        ? { ...legacyProjection.pendingReversion, protocolVersion: 1 as const }
+        : legacyProjection?.pendingReversion);
+    const pendingReversionReleases: IFlexPendingReversionRelease[] = currentProjection
+      ? cloneSerializable(currentProjection.pendingReversionReleases)
+      : (legacyProjection?.pendingReversionReleases ?? []).map((release) => ({
+          ...cloneSerializable(release),
+          protocolVersion: 1,
+        }));
     const permission = permissionResult.value;
     const eventStore = eventStoreResult.value;
     const jobStore = jobStoreResult.value;
@@ -6404,18 +7984,18 @@ 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 ?? [],
+        reversionSegments,
+        revertCursor: currentProjection?.revertCursor ?? legacyProjection?.revertCursor ?? 0,
+        excludedRunIds: cloneSerializable(
+          currentProjection?.excludedRunIds ?? legacyProjection?.excludedRunIds ?? [],
         ),
-        projectionSchemaVersion: projection?.schemaVersion ?? 2,
+        ...(pendingReversion === undefined
+          ? {}
+          : { pendingReversion: cloneSerializable(pendingReversion) }),
+        pendingReversionReleases,
+        projectionSchemaVersion: projection?.schemaVersion ?? 3,
         projectionReconciliationRequired: false,
-        ...(projection?.schemaVersion === 1
+        ...(projection && projection.schemaVersion !== 3
           ? { projectionBaseline: cloneSerializable(projection) }
           : {}),
         projectionRevision: projection?.revision ?? 0,
@@ -6585,6 +8165,31 @@ export class FlexHarness<TScope = unknown> {
         'Capture-backed session recovery requires its turn reversion provider.',
       );
     }
+    const requiredProtocols = new Set<number>([
+      ...stored.reversionSegments
+        .filter((segment) => segment.captureId !== undefined)
+        .map((segment) => segment.protocolVersion),
+      ...stored.pendingReversionReleases.map((release) => release.protocolVersion),
+      ...(stored.pendingReversion?.kind === 'capture'
+        ? [stored.pendingReversion.protocolVersion]
+        : []),
+    ]);
+    const providerProtocol = this.reversionProviderProtocolVersion();
+    if (requiredProtocols.size > 0 && (
+      requiredProtocols.size !== 1
+      || !requiredProtocols.has(providerProtocol ?? 0)
+    )) {
+      throw new FlexHarnessValidationError(
+        `Capture-backed session recovery requires protocolVersion ${[...requiredProtocols].join(', ')}.`,
+      );
+    }
+    if (stored.pendingReversion?.kind === 'capture' && stored.pendingReversionReleases.length > 0) {
+      if (!state || scopeId === undefined || scope === undefined) {
+        throw new FlexHarnessValidationError('Pending capture recovery is missing its scope context.');
+      }
+      await this.drainReversionReleases(state, stored, scopeId, scope, false);
+      this.assertStateAcceptingWork(state);
+    }
     const outcomes = this.canonicalOutcomes(stored.agentSession.getEvents());
     const firstHiddenCandidate = this.completedReversionCandidates(stored)[stored.revertCursor];
     const reversionVisibilityBoundary = firstHiddenCandidate
@@ -6698,7 +8303,7 @@ export class FlexHarness<TScope = unknown> {
         snapshot,
         expected,
       );
-      stored.projectionSchemaVersion = 2;
+      stored.projectionSchemaVersion = 3;
       delete stored.projectionBaseline;
       stored.projectionReconciliationRequired = false;
       stored.projectionRevision = snapshot.revision;
@@ -6875,7 +8480,7 @@ export class FlexHarness<TScope = unknown> {
         : cloneSerializable(stored.pendingReversion);
       const beforePendingReversionReleases = cloneSerializable(stored.pendingReversionReleases);
       const beforeSnapshot: TFlexProjectionSnapshot = beforeBaseline ?? {
-        schemaVersion: 2,
+        schemaVersion: 3,
         revision: beforeRevision,
         messages: cloneSerializable(beforeMessages),
         stagedTerminals: cloneSerializable(beforeStages),
@@ -6917,7 +8522,7 @@ export class FlexHarness<TScope = unknown> {
           snapshot,
           beforeRevision,
         );
-        stored.projectionSchemaVersion = 2;
+        stored.projectionSchemaVersion = 3;
         delete stored.projectionBaseline;
         stored.projectionReconciliationRequired = false;
         stored.projectionRevision = snapshot.revision;
@@ -6928,7 +8533,7 @@ export class FlexHarness<TScope = unknown> {
           throw error;
         }
         if (error instanceof FlexHarnessStoreCommitUncertainError) {
-          stored.projectionSchemaVersion = 2;
+          stored.projectionSchemaVersion = 3;
           stored.projectionReconciliationRequired = true;
           stored.projectionRevision = snapshot.revision;
           state.lifecycle = 'fenced';
@@ -6945,7 +8550,7 @@ export class FlexHarness<TScope = unknown> {
           reconciliationError = loadError;
         }
         if (current && JSON.stringify(current) === JSON.stringify(snapshot)) {
-          stored.projectionSchemaVersion = 2;
+          stored.projectionSchemaVersion = 3;
           delete stored.projectionBaseline;
           stored.projectionReconciliationRequired = false;
           stored.projectionRevision = snapshot.revision;
@@ -6958,7 +8563,7 @@ export class FlexHarness<TScope = unknown> {
           restore();
           throw error;
         }
-        stored.projectionSchemaVersion = 2;
+        stored.projectionSchemaVersion = 3;
         stored.projectionReconciliationRequired = true;
         stored.projectionRevision = snapshot.revision;
         state.lifecycle = 'fenced';
@@ -7070,7 +8675,7 @@ export class FlexHarness<TScope = unknown> {
     revision: number,
   ): IFlexProjectionSnapshotCurrent {
     return {
-      schemaVersion: 2,
+      schemaVersion: 3,
       revision,
       messages: cloneSerializable(stored.messages),
       stagedTerminals: cloneSerializable(stored.stagedTerminals),
@@ -7084,6 +8689,51 @@ export class FlexHarness<TScope = unknown> {
     };
   }
 
+  private upgradeProjectionSnapshot(
+    projection: TFlexProjectionSnapshot,
+  ): IFlexProjectionSnapshotCurrent {
+    if (projection.schemaVersion === 3) return cloneSerializable(projection);
+    if (projection.schemaVersion === 1) {
+      return {
+        schemaVersion: 3,
+        revision: projection.revision,
+        messages: cloneSerializable(projection.messages),
+        stagedTerminals: cloneSerializable(projection.stagedTerminals),
+        reversionSegments: [],
+        revertCursor: 0,
+        excludedRunIds: [],
+        pendingReversionReleases: [],
+      };
+    }
+    return {
+      schemaVersion: 3,
+      revision: projection.revision,
+      messages: cloneSerializable(projection.messages),
+      stagedTerminals: cloneSerializable(projection.stagedTerminals),
+      reversionSegments: projection.reversionSegments.map((segment) => ({
+        ...cloneSerializable(segment),
+        protocolVersion: 1,
+        provenance: segment.workspaceCaptured ? 'workspace' as const : 'transcript' as const,
+        ...(segment.workspaceCaptured
+          ? { disposition: segment.status === 'capturing' ? 'pending' as const : 'revertible' as const }
+          : {}),
+      })),
+      revertCursor: projection.revertCursor,
+      excludedRunIds: cloneSerializable(projection.excludedRunIds),
+      ...(projection.pendingReversion === undefined
+        ? {}
+        : {
+            pendingReversion: projection.pendingReversion.kind === 'capture'
+              ? { ...cloneSerializable(projection.pendingReversion), protocolVersion: 1 }
+              : cloneSerializable(projection.pendingReversion),
+          }),
+      pendingReversionReleases: projection.pendingReversionReleases.map((release) => ({
+        ...cloneSerializable(release),
+        protocolVersion: 1,
+      })),
+    };
+  }
+
   private async reconcileProjectionFromStore(stored: IStoredSessionState): Promise<void> {
     if (!stored.projectionReconciliationRequired) return;
     const projection = await this.stores.projections.load(
@@ -7093,35 +8743,42 @@ export class FlexHarness<TScope = unknown> {
     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);
-    }
+    const current = this.upgradeProjectionSnapshot(projection);
+    stored.messages = current.messages;
+    stored.stagedTerminals = current.stagedTerminals;
+    stored.reversionSegments = current.reversionSegments;
+    stored.revertCursor = current.revertCursor;
+    stored.excludedRunIds = current.excludedRunIds;
+    if (current.pendingReversion === undefined) delete stored.pendingReversion;
+    else stored.pendingReversion = current.pendingReversion;
+    stored.pendingReversionReleases = current.pendingReversionReleases;
+    if (projection.schemaVersion === 3) delete stored.projectionBaseline;
+    else stored.projectionBaseline = cloneSerializable(projection);
     stored.projectionSchemaVersion = projection.schemaVersion;
     stored.projectionRevision = projection.revision;
     stored.projectionReconciliationRequired = false;
   }
 
-  private async cleanupSessionDomains(storageKey: string, sessionId: string): Promise<void> {
+  private async cleanupSessionDomains(
+    storageKey: string,
+    tombstone: IFlexSessionTombstone,
+  ): Promise<void> {
+    const sessionId = tombstone.sessionId;
+    const projectManagementCleanup = async (): Promise<void> => {
+      await this.projectManagementQueues.get(
+        this.projectManagementKey(storageKey, sessionId),
+      );
+      await this.tombstoneProjectManagementSession(
+        storageKey,
+        tombstone,
+      );
+    };
     const results = await Promise.allSettled([
       this.stores.agentEvents.deleteSession(storageKey, sessionId),
       this.stores.jobs.deleteSession(storageKey, sessionId),
       this.stores.projections.deleteSession(storageKey, sessionId),
       this.stores.permissions.deleteSession(storageKey, sessionId),
+      projectManagementCleanup(),
     ]);
     const errors = results
       .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
@@ -7129,6 +8786,66 @@ export class FlexHarness<TScope = unknown> {
     if (errors.length > 0) throw combineErrors(errors);
   }
 
+  private async tombstoneProjectManagementSession(
+    storageKey: string,
+    sessionTombstone: IFlexSessionTombstone,
+  ): Promise<void> {
+    const store = this.stores.projectManagement;
+    const sessionId = sessionTombstone.sessionId;
+    const generation = requireSessionGeneration(sessionTombstone);
+    let lastConflict: FlexHarnessStoreConflictError | undefined;
+    for (let attempt = 0; attempt <= maxProjectManagementTombstoneConflicts; attempt++) {
+      const current = await store.load(storageKey, sessionId);
+      if (current !== undefined) {
+        assertFlexProjectManagementRecord(current);
+        if (current.sessionGenerationId === generation.sessionGenerationId) {
+          if (current.sessionGenerationSequence !== generation.sessionGenerationSequence) {
+            throw new FlexHarnessStoreConflictError(
+              this.projectManagementKey(storageKey, sessionId),
+              0,
+              current.revision,
+            );
+          }
+          if ('deletedAt' in current) return;
+        } else if (
+          !('deletedAt' in current)
+          || current.sessionGenerationSequence >= generation.sessionGenerationSequence
+        ) {
+          throw new FlexHarnessStoreConflictError(
+            this.projectManagementKey(storageKey, sessionId),
+            0,
+            current.revision,
+          );
+        }
+      }
+      if (attempt === maxProjectManagementTombstoneConflicts) break;
+      const expectedRevision = current === undefined
+        || current.sessionGenerationId !== generation.sessionGenerationId
+        ? 0
+        : current.revision;
+      const tombstone: IFlexProjectManagementTombstone = {
+        schemaVersion: 1,
+        revision: expectedRevision + 1,
+        ...generation,
+        deletedAt: sessionTombstone.deletedAt,
+      };
+      try {
+        await store.tombstoneSession(
+          storageKey,
+          sessionId,
+          tombstone,
+          expectedRevision,
+        );
+      } catch (error) {
+        if (!(error instanceof FlexHarnessStoreConflictError)) throw error;
+        lastConflict = error;
+      }
+    }
+    throw lastConflict ?? new FlexHarnessValidationError(
+      `Project management tombstone for session "${sessionId}" could not be durably confirmed.`,
+    );
+  }
+
   private collectSessionSubtree(
     state: IStorageState,
     rootSessionId: string,
@@ -7324,7 +9041,7 @@ export class FlexHarness<TScope = unknown> {
           releaseContext.scope,
           retained?.stored,
         );
-        await this.cleanupSessionDomains(state.storageKey, sessionId);
+        await this.cleanupSessionDomains(state.storageKey, tombstone);
         if (retained) retained.domainsCompleted = true;
       }
     }
@@ -7404,6 +9121,13 @@ export class FlexHarness<TScope = unknown> {
       await Promise.allSettled([...state.sessionInitializations.values()]);
       cleanupErrors.push(...await this.closeOrphanedResources(state.storageKey));
       await state.scopeQueue;
+      await this.awaitProjectManagementOperations(
+        state.storageKey,
+        [
+          ...state.sessions.keys(),
+          ...state.retainedSessionCleanups.keys(),
+        ],
+      );
       const currentTombstoneRoot = state.tombstones.get(currentRun.sessionId)?.rootSessionId
         ?? currentRun.sessionId;
       const currentTombstoneCleanup = state.tombstoneCleanups.get(currentTombstoneRoot);
@@ -7807,12 +9531,7 @@ 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),
-      );
-    }
+    this.assertNoAmbientSlashCommandTeardown({ storageKey: scope.storageKey });
     const errors: unknown[] = [];
     const listingSettlement = this.abortSlashCommandListings(
       scope.storageKey,
@@ -7895,8 +9614,11 @@ export class FlexHarness<TScope = unknown> {
       return;
     }
     if (state.lifecycle !== 'fenced') state.lifecycle = 'retiring';
-    const detachedCleanupAttempts = this.beginDetachedCleanupSettlement(state);
     const errors: unknown[] = [];
+    const listingSettlement = this.abortSlashCommandListings(storageKey, reason);
+    if (listingSettlement) await listingSettlement;
+    await this.abortSlashCommandExecutions(storageKey, reason, errors);
+    const detachedCleanupAttempts = this.beginDetachedCleanupSettlement(state);
     const contextFor = (sessionId: string) => invocation
       ? this.createCompactorContext(invocation.scopeId, invocation.scope, storageKey, sessionId)
       : undefined;
@@ -7939,6 +9661,13 @@ export class FlexHarness<TScope = unknown> {
     await Promise.allSettled([...state.sessionInitializations.values()]);
     errors.push(...await this.closeOrphanedResources(state.storageKey));
     await state.scopeQueue;
+    await this.awaitProjectManagementOperations(
+      state.storageKey,
+      [
+        ...state.sessions.keys(),
+        ...state.retainedSessionCleanups.keys(),
+      ],
+    );
     await Promise.all([...state.sessions.values()].flatMap((stored) => [
       stored.projectionQueue,
       stored.permissionQueue,
@@ -8061,6 +9790,7 @@ export class FlexHarness<TScope = unknown> {
     if (errors.length > 0) throw combineErrors(errors);
     this.compactorInvocationContext.disable();
     this.slashCommandInvocationContext.disable();
+    this.slashCommandActivityContext.disable();
     this.stateLoads.clear();
     this.scopeAdmissions.clear();
     this.scopeRetirements.clear();
@@ -8171,6 +9901,23 @@ export class FlexHarness<TScope = unknown> {
       }
       const state = await stateLoad;
       this.assertOpen();
+      if (state.lifecycle === 'fenced') {
+        const drain = this.storageDrains.get(scope.storageKey) ?? this.drainStorage(
+          scope.storageKey,
+          stateLoad,
+          this.trustInternalError(new FlexHarnessAbortError('The session namespace was fenced.')),
+          { scopeId, scope: scope.scope },
+        );
+        if (this.ambientSlashCommandOwner({ storageKey: scope.storageKey })) {
+          throw this.createScopeRetirementError();
+        }
+        try {
+          await drain;
+        } catch {
+          // Fenced cleanup ownership remains available to explicit retirement or disposal.
+        }
+        throw this.createScopeRetirementError();
+      }
       if (
         admission.retiring
         || admission.generation !== generation
@@ -8205,6 +9952,29 @@ export class FlexHarness<TScope = unknown> {
     return this.trustInternalError(new FlexHarnessAbortError(scopeRetirementMessage));
   }
 
+  private ambientSlashCommandOwner(
+    criteria: { scopeId?: string; storageKey?: string; sessionId?: string } = {},
+  ): ISlashCommandInvocationOwner | ISlashCommandActivityOwner | undefined {
+    const matches = (owner: ISlashCommandInvocationOwner | ISlashCommandActivityOwner) => (
+      (criteria.scopeId === undefined || owner.scopeId === criteria.scopeId)
+      && (criteria.storageKey === undefined || owner.storageKey === criteria.storageKey)
+      && (criteria.sessionId === undefined || owner.sessionId === criteria.sessionId)
+    );
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner && matches(invocationOwner)) return invocationOwner;
+    const activityOwner = this.slashCommandActivityContext.getStore();
+    return activityOwner && matches(activityOwner) ? activityOwner : undefined;
+  }
+
+  private assertNoAmbientSlashCommandTeardown(
+    criteria: { scopeId?: string; storageKey?: string; sessionId?: string } = {},
+  ): void {
+    const owner = this.ambientSlashCommandOwner(criteria);
+    if (owner) {
+      throw this.trustInternalError(new FlexHarnessSlashCommandReentryError(owner.sessionId));
+    }
+  }
+
   private assertStateAcceptingWork(state: IStorageState): void {
     if (state.lifecycle !== 'active' || this.storageDrains.has(state.storageKey)) {
       throw this.createScopeRetirementError();
@@ -8259,8 +10029,7 @@ export class FlexHarness<TScope = unknown> {
   }
 
   private visibleMessages(stored: IStoredSessionState): IFlexMessage[] {
-    const firstHiddenUnit = this.reversionUnit(stored, 'redo');
-    const firstHiddenSegment = firstHiddenUnit?.segments[0];
+    const firstHiddenSegment = this.reversionGroups(stored)[stored.revertCursor]?.segments[0];
     if (!firstHiddenSegment) return stored.messages;
     const boundary = stored.messages.findIndex((message) => message.runId === firstHiddenSegment.runId);
     return boundary < 0 ? stored.messages : stored.messages.slice(0, boundary);