@modelprofile.com/flexharness 3.2.0 → 3.4.0

package/ts/classes.flexharness.ts

@@ -16,6 +16,7 @@ import {
   errorToInfo,
 } from './errors.js';
 import type {
+  IFlexAgentContextInvocation,
   IFlexAgentSessionPolicy,
   IFlexAttachmentMessagePart,
   IFlexBackgroundExecution,
@@ -96,6 +97,7 @@ type TRunPhase =
 
 interface IStoredSessionState {
   storageKey: string;
+  compactorContext?: IFlexAgentContextInvocation<unknown>;
   session: IFlexSession;
   messages: IFlexMessage[];
   stagedTerminals: IFlexTerminalProjection[];
@@ -113,6 +115,7 @@ interface IStoredSessionState {
   executionContextCloseCompleted: boolean;
   jobStoreReleased: boolean;
   jobs?: NonNullable<plugins.IToolExecutionContext['jobs']>;
+  compactorLifecycleController: AbortController;
   promptQueue: IQueuedPrompt[];
   outstandingPromptsById: Map<string, IQueuedPrompt>;
   terminalPromptQueueEntries: Map<string, IFlexPromptQueueEntry>;
@@ -139,6 +142,12 @@ interface IOrphanedProviderRelease {
   release: () => Promise<void>;
 }
 
+interface IOrphanedTombstoneCleanup {
+  storageKey: string;
+  sessionId: string;
+  completion: Promise<void>;
+}
+
 interface IOrphanedExecutionContextOwner {
   storageKey: string;
   sessionId: string;
@@ -146,6 +155,7 @@ interface IOrphanedExecutionContextOwner {
 
 interface IStorageState {
   storageKey: string;
+  compactorLifecycleController: AbortController;
   scopeIdHint: string;
   revision: number;
   sessions: Map<string, IStoredSessionState>;
@@ -167,6 +177,8 @@ interface IStorageState {
 interface IActiveRun {
   state: IStorageState;
   stored: IStoredSessionState;
+  originCompactorContext: IFlexAgentContextInvocation<unknown>;
+  deferredCompactorContext?: IFlexAgentContextInvocation<unknown>;
   scopeId: string;
   scope: unknown;
   sessionId: string;
@@ -694,7 +706,9 @@ function resolvePromptQueueLimits(
   return resolved;
 }
 
-function normalizeAgentSessionPolicy(policy: IFlexAgentSessionPolicy = {}): IFlexAgentSessionPolicy {
+function normalizeAgentSessionPolicy<TScope>(
+  policy: IFlexAgentSessionPolicy<TScope> = {},
+): IFlexAgentSessionPolicy<TScope> {
   return {
     ...(policy.contextBuilder === undefined ? {} : { contextBuilder: policy.contextBuilder }),
     ...(policy.contextCompactor === undefined ? {} : { contextCompactor: policy.contextCompactor }),
@@ -723,7 +737,7 @@ export class FlexHarness<TScope = unknown> {
   private readonly toolProvider: IFlexHarnessOptions<TScope>['toolProvider'];
   private readonly executionContextProvider: IFlexHarnessOptions<TScope>['executionContextProvider'];
   private readonly stores: IFlexHarnessStores;
-  private readonly agentSessionPolicy: IFlexAgentSessionPolicy;
+  private readonly agentSessionPolicy: IFlexAgentSessionPolicy<TScope>;
   private readonly toolOutputLimits: Required<NonNullable<IFlexHarnessOptions<TScope>['toolOutputLimits']>>;
   private readonly callbackLimits: Required<IFlexCallbackLimits>;
   private readonly promptQueueLimits: Required<IFlexPromptQueueLimits>;
@@ -732,6 +746,7 @@ export class FlexHarness<TScope = unknown> {
   private readonly scopeAdmissions = new Map<string, IScopeAdmissionState>();
   private readonly scopeRetirements = new Map<string, Promise<void>>();
   private readonly storageDrains = new Map<string, Promise<void>>();
+  private readonly storageCompactorLifecycleControllers = new Map<string, AbortController>();
   private orphanedResourceQueue: Promise<void> = Promise.resolve();
   private readonly listeners = new Set<TFlexHarnessEventListener>();
   private readonly trustedInternalErrors = new WeakSet<object>();
@@ -741,7 +756,15 @@ export class FlexHarness<TScope = unknown> {
     IOrphanedExecutionContextOwner
   >();
   private readonly orphanedProviderReleases = new Map<string, IOrphanedProviderRelease>();
+  private readonly orphanedTombstoneCleanups = new Map<string, IOrphanedTombstoneCleanup>();
   private readonly pendingPromptAdmissionOwners = new Set<IPendingPromptAdmission>();
+  private readonly compactorInvocationContext = new plugins.AsyncLocalStorage<
+    IFlexAgentContextInvocation<TScope>
+  >();
+  private readonly deferredCompactorContexts = new WeakMap<
+    IFlexAgentContextInvocation<unknown>,
+    IFlexAgentContextInvocation<unknown>
+  >();
   private sequence = 0;
   private promptQueueSequence = 0;
   private pendingPromptAdmissions = 0;
@@ -876,7 +899,12 @@ export class FlexHarness<TScope = unknown> {
           resolved.state.tombstones.set(sessionId, tombstone);
         }, true);
         tombstoneCommitted = true;
-        await this.finishTombstoneCleanup(resolved.state, sessionId, scopeId);
+        await this.finishTombstoneCleanup(
+          resolved.state,
+          sessionId,
+          scopeId,
+          resolved.scope.scope,
+        );
         domainCleanupCompleted = true;
       } catch (cleanupError) {
         const projectedCleanup = this.projectOperationError(
@@ -898,6 +926,7 @@ export class FlexHarness<TScope = unknown> {
                 this.trustInternalError(new FlexHarnessAbortError(
                   'The session namespace was fenced after uncertain creation cleanup.',
                 )),
+                { scopeId, scope: resolved.scope.scope },
               );
             } catch {
               // The projected creation and cleanup errors remain safe for the caller.
@@ -932,7 +961,9 @@ export class FlexHarness<TScope = unknown> {
     const { state } = await this.resolveState(scopeId);
     let result!: IFlexSession;
     await this.mutateScope(state, () => {
-      const stored = this.requireMutableSession(state, sessionId);
+      const stored = Object.prototype.hasOwnProperty.call(options, 'archived')
+        ? this.requireMutableSession(state, sessionId)
+        : this.requireSession(state, sessionId);
       const timestamp = new Date().toISOString();
       if (Object.prototype.hasOwnProperty.call(options, 'title')) {
         if (options.title === null) delete stored.session.title;
@@ -948,12 +979,12 @@ export class FlexHarness<TScope = unknown> {
   }
 
   public async deleteSession(scopeId: string, sessionId: string): Promise<void> {
-    const { state } = await this.resolveState(scopeId);
+    const { scope, state } = await this.resolveState(scopeId);
     validateIdentifier(sessionId, 'sessionId');
     const existingDeletion = state.sessionDeletions.get(sessionId);
     if (existingDeletion) return existingDeletion;
     let deletion!: Promise<void>;
-    deletion = this.deleteSessionInternal(state, scopeId, sessionId).finally(() => {
+    deletion = this.deleteSessionInternal(state, scopeId, scope.scope, sessionId).finally(() => {
       if (state.sessionDeletions.get(sessionId) === deletion) {
         state.sessionDeletions.delete(sessionId);
       }
@@ -965,12 +996,13 @@ export class FlexHarness<TScope = unknown> {
   private async deleteSessionInternal(
     state: IStorageState,
     scopeId: string,
+    scope: TScope,
     sessionId: string,
   ): Promise<void> {
     const existingTombstone = state.tombstones.get(sessionId);
     if (existingTombstone) {
       try {
-        await this.finishTombstoneCleanup(state, sessionId, scopeId);
+        await this.finishTombstoneCleanup(state, sessionId, scopeId, scope);
       } catch (error) {
         throw this.projectOperationError(error, 'persistence', scopeId, sessionId, 'session-delete');
       }
@@ -993,7 +1025,7 @@ export class FlexHarness<TScope = unknown> {
       });
     });
     try {
-      await this.finishTombstoneCleanup(state, sessionId, scopeId);
+      await this.finishTombstoneCleanup(state, sessionId, scopeId, scope);
     } catch (error) {
       throw this.projectOperationError(error, 'persistence', scopeId, sessionId, 'session-delete');
     }
@@ -1175,7 +1207,7 @@ export class FlexHarness<TScope = unknown> {
   ): Promise<boolean> {
     validateIdentifier(queueId, 'queueId');
     requireTransferIdentifier(queueId, 'queueId');
-    const { state } = await this.resolveState(scopeId);
+    const { scope, state } = await this.resolveState(scopeId);
     const stored = this.requireSession(state, sessionId);
     const queued = stored.outstandingPromptsById.get(queueId);
     if (!queued) {
@@ -1185,6 +1217,7 @@ export class FlexHarness<TScope = unknown> {
     return this.cancelQueuedPrompt(
       queued,
       this.trustInternalError(new FlexHarnessAbortError('The queued prompt was cancelled.')),
+      this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
     );
   }
 
@@ -1194,20 +1227,28 @@ export class FlexHarness<TScope = unknown> {
     scheduleKey: string,
   ): Promise<boolean> {
     validateIdentifier(scheduleKey, 'scheduleKey');
-    const { state } = await this.resolveState(scopeId);
+    const { scope, state } = await this.resolveState(scopeId);
     const stored = this.requireSession(state, sessionId);
     const queued = [...stored.outstandingPromptsById.values()]
       .find((entry) => entry.scheduleKey === scheduleKey);
     if (!queued) return false;
     const cancellation = this.trustInternalError(new FlexHarnessAbortError('The scheduled run was cancelled.'));
-    return this.cancelQueuedPrompt(queued, cancellation);
+    return this.cancelQueuedPrompt(
+      queued,
+      cancellation,
+      this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
+    );
   }
 
   public async abort(scopeId: string, sessionId: string): Promise<boolean> {
-    const { state } = await this.resolveState(scopeId);
+    const { scope, state } = await this.resolveState(scopeId);
     const run = state.activeRuns.get(sessionId);
     if (!run || run.phase === 'finalizing' || run.phase === 'promoting') return false;
-    this.cancelRun(run, this.trustInternalError(new FlexHarnessAbortError()));
+    this.cancelRun(
+      run,
+      this.trustInternalError(new FlexHarnessAbortError()),
+      this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
+    );
     return true;
   }
 
@@ -1231,12 +1272,16 @@ export class FlexHarness<TScope = unknown> {
     decision: TFlexPermissionDecision,
   ): Promise<void> {
     validateIdentifier(permissionId, 'permissionId');
-    const { state } = await this.resolveState(scopeId);
+    const { scope, state } = await this.resolveState(scopeId);
     const pending = state.pendingPermissions.get(permissionId);
     if (!pending || pending.request.sessionId !== sessionId) {
       throw new FlexHarnessNotFoundError('Permission', permissionId);
     }
-    const response = pending.responseQueue.then(() => this.applyPermissionResponse(state, pending, decision));
+    const context = this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId);
+    const response = pending.responseQueue.then(() => this.withCompactorContext(
+      context,
+      () => this.applyPermissionResponse(state, pending, decision, context),
+    ));
     pending.responseQueue = response.then(() => undefined, () => undefined);
     return response;
   }
@@ -1273,7 +1318,7 @@ export class FlexHarness<TScope = unknown> {
     if (!reconciliation || typeof reconciliation !== 'object' || Array.isArray(reconciliation)) {
       throw new FlexHarnessValidationError('Tool execution reconciliation must be a plain object.');
     }
-    const { state } = await this.resolveState(scopeId);
+    const { scope, state } = await this.resolveState(scopeId);
     const stored = this.requireSession(state, sessionId);
     this.assertStateAcceptingWork(state);
     let canonical: plugins.TAgentToolExecutionReconciliationOptions;
@@ -1297,7 +1342,10 @@ export class FlexHarness<TScope = unknown> {
       throw new FlexHarnessValidationError('Unknown tool execution reconciliation.');
     }
     try {
-      await stored.agentSession.reconcileToolExecution(intentId, canonical);
+      await this.withCompactorContext(
+        this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
+        () => stored.agentSession.reconcileToolExecution(intentId, canonical),
+      );
     } catch (error) {
       throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'tool-reconciliation');
     }
@@ -1309,22 +1357,28 @@ export class FlexHarness<TScope = unknown> {
     event: IJsonObject & { type: string },
   ): Promise<void> {
     this.validateRuntimeEvent(event);
-    const { state } = await this.resolveState(scopeId);
+    const { scope, state } = await this.resolveState(scopeId);
     const stored = this.requireSession(state, sessionId);
     this.assertStateAcceptingWork(state);
     try {
-      await stored.agentSession.pushRuntimeEvent(cloneSerializable(event));
+      await this.withCompactorContext(
+        this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
+        () => stored.agentSession.pushRuntimeEvent(cloneSerializable(event)),
+      );
     } catch (error) {
       throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'runtime-event');
     }
   }
 
   public async compactSession(scopeId: string, sessionId: string): Promise<void> {
-    const { state } = await this.resolveState(scopeId);
+    const { scope, state } = await this.resolveState(scopeId);
     const stored = this.requireSession(state, sessionId);
     this.assertStateAcceptingWork(state);
     try {
-      await stored.agentSession.compact();
+      await this.withCompactorContext(
+        this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
+        () => stored.agentSession.compact(),
+      );
     } catch (error) {
       throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'compaction');
     }
@@ -1401,11 +1455,14 @@ export class FlexHarness<TScope = unknown> {
   ): Promise<void> {
     validateIdentifier(executionId, 'executionId');
     requireTransferIdentifier(executionId, 'executionId');
-    const { state } = await this.resolveState(scopeId);
+    const { scope, state } = await this.resolveState(scopeId);
     const stored = this.requireSession(state, sessionId);
     this.assertStateAcceptingWork(state);
     try {
-      await stored.agentSession.abortBackgroundExecution(executionId);
+      await this.withCompactorContext(
+        this.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
+        () => stored.agentSession.abortBackgroundExecution(executionId),
+      );
     } catch (error) {
       throw this.projectOperationError(error, 'agentSession', scopeId, sessionId, 'background-abort');
     }
@@ -1634,6 +1691,12 @@ export class FlexHarness<TScope = unknown> {
     return {
       state: queued.state,
       stored: queued.stored,
+      originCompactorContext: this.createCompactorContext(
+        queued.scopeId,
+        queued.scope as TScope,
+        queued.state.storageKey,
+        queued.sessionId,
+      ),
       scopeId: queued.scopeId,
       scope: queued.scope,
       sessionId: queued.sessionId,
@@ -1674,11 +1737,14 @@ export class FlexHarness<TScope = unknown> {
     const options = queued.options!;
     let projectionReserved = false;
     try {
-      run.transaction = await run.stored.agentSession.beginGeneration(
-        cloneSerializable(prompt.modelMessage.content) as Parameters<
-          plugins.IAgentSession['beginGeneration']
-        >[0],
-        { generationId: run.runId },
+      run.transaction = await this.withRunCompactorContext(
+        run,
+        () => run.stored.agentSession.beginGeneration(
+          cloneSerializable(prompt.modelMessage.content) as Parameters<
+            plugins.IAgentSession['beginGeneration']
+          >[0],
+          { generationId: run.runId },
+        ),
       );
       this.assertPromptPromotion(queued, run);
       const reservation = this.createReservation(run, prompt);
@@ -1757,13 +1823,13 @@ export class FlexHarness<TScope = unknown> {
       prepare: (context: { generationId: string; abortSignal: AbortSignal }) =>
         this.prepareGeneration(run, options, context.abortSignal),
     };
-    const generation = run.scheduleKey
+    const generation = this.withRunCompactorContext(run, () => run.scheduleKey
       ? run.stored.agentSession.scheduleGenerate({
           key: run.scheduleKey,
           debounceMs: run.debounceMs,
           ...generateOptions,
         })
-      : run.stored.agentSession.generate(generateOptions);
+      : run.stored.agentSession.generate(generateOptions));
     const execution = this.executeRun(run, generation).then(
       (result) => this.finishQueuedPrompt(queued, 'completed', undefined, result),
       (error) => this.finishQueuedPrompt(
@@ -1851,7 +1917,11 @@ export class FlexHarness<TScope = unknown> {
     }
   }
 
-  private cancelQueuedPrompt(queued: IQueuedPrompt, reason: FlexHarnessAbortError): boolean {
+  private cancelQueuedPrompt(
+    queued: IQueuedPrompt,
+    reason: FlexHarnessAbortError,
+    context?: IFlexAgentContextInvocation<TScope>,
+  ): boolean {
     if (queued.stored.outstandingPromptsById.get(queued.queueId) !== queued) return false;
     if (queued.status === 'queued') {
       this.finishQueuedPrompt(queued, 'cancelled', reason);
@@ -1861,7 +1931,7 @@ export class FlexHarness<TScope = unknown> {
     const run = queued.state.activeRuns.get(queued.sessionId);
     if (!run || run.queueId !== queued.queueId) return false;
     if (run.phase === 'finalizing' || run.phase === 'promoting') return false;
-    this.cancelRun(run, reason);
+    this.cancelRun(run, reason, context);
     return true;
   }
 
@@ -1869,10 +1939,15 @@ export class FlexHarness<TScope = unknown> {
     stored: IStoredSessionState,
     reason: FlexHarnessAbortError,
     excludedQueueId?: string,
+    context?: IFlexAgentContextInvocation<unknown>,
   ): void {
     for (const queued of [...stored.outstandingPromptsById.values()]) {
       if (queued.queueId === excludedQueueId) continue;
-      this.cancelQueuedPrompt(queued, reason);
+      this.cancelQueuedPrompt(
+        queued,
+        reason,
+        context as IFlexAgentContextInvocation<TScope> | undefined,
+      );
     }
   }
 
@@ -1906,7 +1981,10 @@ export class FlexHarness<TScope = unknown> {
       if (run.controller.signal.aborted) throw run.controller.signal.reason;
       run.phase = 'finalizing';
       try {
-        await run.stored.agentSession.finalizeGeneration(run.transaction!, 'accepted');
+        await this.withRunCompactorContext(
+          run,
+          () => run.stored.agentSession.finalizeGeneration(run.transaction!, 'accepted'),
+        );
       } catch (error) {
         const projected = this.projectExternalError(run, error, 'agentSession');
         await this.fenceNamespace(run.state, run, projected);
@@ -1976,7 +2054,10 @@ export class FlexHarness<TScope = unknown> {
     run.phase = 'finalizing';
     const desiredOutcome: TCanonicalOutcome = cancelled || !generated ? 'interrupted' : 'rejected';
     try {
-      await run.stored.agentSession.finalizeGeneration(run.transaction!, desiredOutcome);
+      await this.withRunCompactorContext(
+        run,
+        () => run.stored.agentSession.finalizeGeneration(run.transaction!, desiredOutcome),
+      );
     } catch (finalizationError) {
       errors.push(this.projectExternalError(run, finalizationError, 'agentSession'));
     }
@@ -2350,11 +2431,14 @@ export class FlexHarness<TScope = unknown> {
   private emitTerminalProjection(run: IActiveRun, terminal: IFlexTerminalProjection): void {
     for (const part of terminal.assistantMessage.parts) {
       const callbackPart = run.callbackParts.find((entry) => entry.partId === part.partId);
-      if (
-        (part.type === 'reasoning' || part.type === 'tool')
-        && callbackPart?.type === part.type
-        && callbackPart.status === 'running'
-      ) {
+      const shouldComplete = part.type === 'text'
+        ? callbackPart?.type === 'text'
+        : part.type === 'reasoning'
+          ? callbackPart?.type === 'reasoning' && callbackPart.status === 'running'
+          : part.type === 'tool'
+            ? callbackPart?.type === 'tool' && callbackPart.status === 'running'
+            : false;
+      if (shouldComplete) {
         this.emitPartEvent(run, 'part.completed', part);
       }
     }
@@ -2615,6 +2699,7 @@ export class FlexHarness<TScope = unknown> {
     state: IStorageState,
     pending: IPendingPermission,
     decision: TFlexPermissionDecision,
+    context: IFlexAgentContextInvocation<TScope>,
   ): Promise<void> {
     if (pending.settled) {
       throw new FlexHarnessPermissionStateError(`Permission "${pending.request.permissionId}" has already been resolved.`);
@@ -2712,7 +2797,7 @@ export class FlexHarness<TScope = unknown> {
       const rejection = this.trustInternalError(
         new FlexHarnessPermissionRejectedError(pending.request.permissionId),
       );
-      this.abortRunInternally(pending.run, rejection);
+      this.abortRunInternally(pending.run, rejection, context);
       pending.reject(rejection);
     } else {
       pending.resolve();
@@ -2816,19 +2901,50 @@ export class FlexHarness<TScope = unknown> {
     pending.reject(error);
   }
 
-  private cancelRun(run: IActiveRun, reason: FlexHarnessAbortError): void {
-    if (run.internalFailure === undefined) run.ownerCancellation ??= reason;
-    this.rejectRunPermissions(run.state, run, reason);
-    if (!run.controller.signal.aborted) run.controller.abort(reason);
-    if (run.phase === 'admitting') return;
-    if (run.scheduleKey) run.stored.agentSession.cancelScheduledGeneration(run.scheduleKey, reason);
-    else run.stored.agentSession.abortCurrentGeneration(reason);
+  private cancelRun(
+    run: IActiveRun,
+    reason: FlexHarnessAbortError,
+    context?: IFlexAgentContextInvocation<TScope>,
+  ): void {
+    const invocationContext = context ?? this.createRunCompactorContext(run);
+    if (run.internalFailure === undefined && run.ownerCancellation === undefined) {
+      run.ownerCancellation = reason;
+      run.deferredCompactorContext = invocationContext;
+      this.deferredCompactorContexts.set(run.originCompactorContext, invocationContext);
+    }
+    this.withCompactorContext(
+      (run.deferredCompactorContext ?? invocationContext) as IFlexAgentContextInvocation<TScope>,
+      () => {
+        this.rejectRunPermissions(run.state, run, reason);
+        if (!run.controller.signal.aborted) run.controller.abort(reason);
+        if (run.phase === 'admitting') return;
+        if (run.scheduleKey) {
+          run.stored.agentSession.cancelScheduledGeneration(run.scheduleKey, reason);
+        } else {
+          run.stored.agentSession.abortCurrentGeneration(reason);
+        }
+      },
+    );
   }
 
-  private abortRunInternally(run: IActiveRun, error: unknown): void {
-    run.internalFailure ??= error ?? new Error('Internal FlexHarness run failure.');
-    if (!run.controller.signal.aborted) run.controller.abort(run.internalFailure);
-    run.stored.agentSession.abortCurrentGeneration(run.internalFailure);
+  private abortRunInternally(
+    run: IActiveRun,
+    error: unknown,
+    context?: IFlexAgentContextInvocation<TScope>,
+  ): void {
+    const invocationContext = context ?? this.createRunCompactorContext(run);
+    if (run.internalFailure === undefined) {
+      run.internalFailure = error ?? new Error('Internal FlexHarness run failure.');
+      run.deferredCompactorContext = invocationContext;
+      this.deferredCompactorContexts.set(run.originCompactorContext, invocationContext);
+    }
+    this.withCompactorContext(
+      (run.deferredCompactorContext ?? invocationContext) as IFlexAgentContextInvocation<TScope>,
+      () => {
+        if (!run.controller.signal.aborted) run.controller.abort(run.internalFailure);
+        run.stored.agentSession.abortCurrentGeneration(run.internalFailure);
+      },
+    );
   }
 
   private async rollbackAdmission(
@@ -2839,7 +2955,10 @@ export class FlexHarness<TScope = unknown> {
     const errors: unknown[] = [];
     if (run.transaction) {
       try {
-        await run.stored.agentSession.finalizeGeneration(run.transaction, 'interrupted');
+        await this.withRunCompactorContext(
+          run,
+          () => run.stored.agentSession.finalizeGeneration(run.transaction!, 'interrupted'),
+        );
       } catch (error) {
         errors.push(this.projectExternalError(run, error, 'agentSession'));
       }
@@ -3066,6 +3185,7 @@ export class FlexHarness<TScope = unknown> {
     storageKey: string,
     scopeId: string,
     scope: TScope,
+    compactorLifecycleController: AbortController,
   ): Promise<IStorageState> {
     const snapshot = cloneSerializable(await this.stores.scopes.load(storageKey) ?? {
       schemaVersion: 1,
@@ -3075,6 +3195,7 @@ export class FlexHarness<TScope = unknown> {
     } satisfies IFlexScopeSnapshot);
     const state: IStorageState = {
       storageKey,
+      compactorLifecycleController,
       scopeIdHint: scopeId,
       revision: snapshot.revision,
       sessions: new Map(),
@@ -3162,6 +3283,7 @@ export class FlexHarness<TScope = unknown> {
       agentEventStoreReleased: true,
       executionContextCloseCompleted: true,
       jobStoreReleased: true,
+      compactorLifecycleController: new AbortController(),
       promptQueue: [],
       outstandingPromptsById: new Map(),
       terminalPromptQueueEntries: new Map(),
@@ -3176,6 +3298,12 @@ export class FlexHarness<TScope = unknown> {
     scope: TScope,
   ): Promise<IStoredSessionState> {
     const sessionId = metadata.sessionId;
+    const compactorContext = this.createCompactorContext(
+      scopeId,
+      scope,
+      state.storageKey,
+      sessionId,
+    );
     const [projectionResult, permissionResult, eventStoreResult, jobStoreResult] = await Promise.allSettled([
       this.stores.projections.load(state.storageKey, sessionId),
       this.stores.permissions.load(state.storageKey, sessionId),
@@ -3214,13 +3342,16 @@ export class FlexHarness<TScope = unknown> {
     let executionContextHandle: IFlexExecutionContextHandle | undefined;
     try {
       if (this.executionContextProvider) {
-        executionContextHandle = await this.executionContextProvider.provideExecutionContext({
-          scopeId,
-          scope,
-          storageKey: state.storageKey,
-          sessionId,
-          jobStore,
-        });
+        executionContextHandle = await this.withCompactorContext(
+          compactorContext,
+          () => this.executionContextProvider!.provideExecutionContext({
+            scopeId,
+            scope,
+            storageKey: state.storageKey,
+            sessionId,
+            jobStore,
+          }),
+        );
         if (
           executionContextHandle
           && (!executionContextHandle.context
@@ -3231,6 +3362,7 @@ export class FlexHarness<TScope = unknown> {
       }
       const stored: IStoredSessionState = {
         storageKey: state.storageKey,
+        compactorContext,
         session: cloneSerializable(metadata),
         messages: cloneSerializable(projection?.messages ?? []),
         stagedTerminals: cloneSerializable(projection?.stagedTerminals ?? []),
@@ -3248,21 +3380,75 @@ export class FlexHarness<TScope = unknown> {
         executionContextCloseCompleted: executionContextHandle?.close === undefined,
         jobStoreReleased: this.stores.jobs.releaseSession === undefined,
         jobs: executionContextHandle?.context.jobs,
+        compactorLifecycleController: new AbortController(),
         promptQueue: [],
         outstandingPromptsById: new Map(),
         terminalPromptQueueEntries: new Map(),
         outstandingPromptBytes: 0,
       };
+      const {
+        contextCompactor,
+        ...agentSessionPolicy
+      } = this.agentSessionPolicy;
+      const executionContext = executionContextHandle?.context;
+      const jobContext = executionContext?.jobs;
+      const contextualExecutionContext = executionContext && jobContext?.subscribe
+        ? {
+            ...executionContext,
+            jobs: {
+              start: jobContext.start.bind(jobContext),
+              get: jobContext.get.bind(jobContext),
+              list: jobContext.list.bind(jobContext),
+              ...(jobContext.abort ? { abort: jobContext.abort.bind(jobContext) } : {}),
+              subscribe: (listener: Parameters<NonNullable<typeof jobContext.subscribe>>[0]) =>
+                jobContext.subscribe!((event) =>
+                  this.withCompactorContext(compactorContext, () => listener(event))),
+            },
+          }
+        : executionContext;
       const agentSessionOptions: plugins.IAgentSessionOptions & {
         transactionOutcomeErrorProjector: (error: unknown) => string;
       } = {
-        ...this.agentSessionPolicy,
+        ...agentSessionPolicy,
         sessionId,
         eventStore,
-        executionContext: executionContextHandle?.context,
+        executionContext: contextualExecutionContext,
         contextBuilder: ({ events }) => hydrateAgentMessages(
           (this.agentSessionPolicy.contextBuilder ?? ((options) => plugins.buildModelMessages(options.events)))({ events }),
         ),
+        ...(contextCompactor
+          ? {
+              contextCompactor: async (messages, events, options) => {
+                const ambientContext = this.compactorInvocationContext.getStore();
+                const invocationContext = ambientContext
+                  ? (this.deferredCompactorContexts.get(ambientContext) ?? ambientContext) as
+                    IFlexAgentContextInvocation<TScope>
+                  : undefined;
+                if (
+                  !invocationContext
+                  || invocationContext.storageKey !== state.storageKey
+                  || invocationContext.sessionId !== sessionId
+                ) {
+                  throw new Error('Agent context compaction is missing its exact FlexHarness invocation context.');
+                }
+                return contextCompactor(messages, events, {
+                  ...options,
+                  ...invocationContext,
+                  scope: invocationContext.scope as TScope,
+                  abortSignal: options.abortSignal
+                    ? AbortSignal.any([
+                        options.abortSignal,
+                        state.compactorLifecycleController.signal,
+                        stored.compactorLifecycleController.signal,
+                      ])
+                    : AbortSignal.any([
+                        state.compactorLifecycleController.signal,
+                        stored.compactorLifecycleController.signal,
+                      ]),
+                });
+              },
+            }
+          : {}),
         transactionOutcomeErrorProjector: () => 'The model operation failed.',
         onToken: (delta) => this.onTextDelta(state, sessionId, delta),
         onReasoningStart: (id) => this.onReasoningStart(state, sessionId, id),
@@ -3271,7 +3457,10 @@ export class FlexHarness<TScope = unknown> {
         onToolCallStart: (event) => this.onToolStart(state, sessionId, event),
         onToolCallFinish: (event) => this.onToolFinish(state, sessionId, event),
       };
-      stored.agentSession = await plugins.AgentSession.create(agentSessionOptions);
+      stored.agentSession = await this.withCompactorContext(
+        compactorContext,
+        () => plugins.AgentSession.create(agentSessionOptions),
+      );
       return stored;
     } catch (error) {
       const cleanupErrors: unknown[] = [];
@@ -3742,11 +3931,12 @@ export class FlexHarness<TScope = unknown> {
     state: IStorageState,
     sessionId: string,
     scopeId: string,
+    scope?: TScope,
   ): Promise<void> {
     const existing = state.tombstoneCleanups.get(sessionId);
     if (existing) return existing;
     let cleanup!: Promise<void>;
-    cleanup = this.finishTombstoneCleanupInternal(state, sessionId, scopeId).finally(() => {
+    cleanup = this.finishTombstoneCleanupInternal(state, sessionId, scopeId, scope).finally(() => {
       if (state.tombstoneCleanups.get(sessionId) === cleanup) {
         state.tombstoneCleanups.delete(sessionId);
       }
@@ -3759,17 +3949,28 @@ export class FlexHarness<TScope = unknown> {
     state: IStorageState,
     sessionId: string,
     scopeId: string,
+    scope?: TScope,
   ): Promise<void> {
     const retained = state.retainedSessionCleanups.get(sessionId);
     if (retained) {
       const errors: unknown[] = [];
       const reason = this.trustInternalError(new FlexHarnessAbortError('The session was deleted.'));
-      this.cancelStoredPromptQueue(retained.stored, reason);
+      const invocation = scope === undefined
+        ? retained.stored.compactorContext
+        : this.createCompactorContext(scopeId, scope, state.storageKey, sessionId);
+      this.abortCompactorLifecycle(retained.stored, reason);
+      this.cancelStoredPromptQueue(retained.stored, reason, undefined, invocation);
       const run = state.activeRuns.get(sessionId);
-      if (run) this.cancelRun(run, reason);
+      if (run) this.cancelRun(run, reason, invocation as IFlexAgentContextInvocation<TScope>);
+      if (run) {
+        const settled = await Promise.allSettled([run.completion]);
+        if (settled[0].status === 'rejected') {
+          this.appendUnexpectedErrors(errors, settled[0].reason);
+        }
+      }
       if (!retained.stored.agentSessionAbortCompleted) {
         try {
-          await this.abortStoredSession(retained.stored, reason);
+          await this.abortStoredSession(retained.stored, reason, invocation);
         } catch (error) {
           errors.push(this.projectOperationError(
             error,
@@ -3780,20 +3981,16 @@ export class FlexHarness<TScope = unknown> {
           ));
         }
       }
-      if (run) {
-        const settled = await Promise.allSettled([run.completion]);
-        if (settled[0].status === 'rejected' && !isAbortError(settled[0].reason)) {
-          errors.push(settled[0].reason);
-        }
-      }
       if (retained.stored.promptQueueDrain) {
         const settled = await Promise.allSettled([retained.stored.promptQueueDrain]);
-        if (settled[0].status === 'rejected') errors.push(settled[0].reason);
+        if (settled[0].status === 'rejected') {
+          this.appendUnexpectedErrors(errors, settled[0].reason);
+        }
       }
       try {
-        await this.closeStoredSession(retained.stored);
+        await this.closeStoredSession(retained.stored, invocation);
       } catch (error) {
-        errors.push(this.projectOperationError(
+        this.appendUnexpectedErrors(errors, this.projectOperationError(
           error,
           'toolCleanup',
           scopeId,
@@ -3801,7 +3998,12 @@ export class FlexHarness<TScope = unknown> {
           'session-delete',
         ));
       }
-      if (errors.length > 0) throw combineErrors(errors);
+      if (errors.length > 0) {
+        if (state.lifecycle === 'retired' && !this.storedSessionCleanupCompleted(retained.stored)) {
+          this.orphanedStoredSessions.add(retained.stored);
+        }
+        throw combineErrors(errors);
+      }
       this.purgeStoredPromptQueue(retained.stored);
     }
     if (!retained?.domainsCompleted) {
@@ -3827,17 +4029,33 @@ export class FlexHarness<TScope = unknown> {
     state.lifecycle = 'fenced';
     const detachedCleanupAttempts = this.beginDetachedCleanupSettlement(state);
     const reason = this.trustInternalError(new FlexHarnessAbortError('The session namespace was fenced.'));
+    if (!state.compactorLifecycleController.signal.aborted) {
+      state.compactorLifecycleController.abort(reason);
+    }
     const cleanupErrors: unknown[] = [];
+    const ambientContext = this.compactorInvocationContext.getStore();
+    const invocation = ambientContext?.storageKey === state.storageKey
+      && ambientContext.sessionId === currentRun.sessionId
+      ? ambientContext
+      : this.effectiveRunCompactorContext(currentRun);
+    const contextFor = (sessionId: string) => this.createCompactorContext(
+      invocation.scopeId,
+      invocation.scope,
+      state.storageKey,
+      sessionId,
+    );
     try {
       for (const stored of state.sessions.values()) {
+        this.abortCompactorLifecycle(stored, reason);
         this.cancelStoredPromptQueue(
           stored,
           reason,
           stored === currentRun.stored ? currentRun.queueId : undefined,
+          contextFor(stored.session.sessionId),
         );
       }
       const otherRuns = [...state.activeRuns.values()].filter((run) => run !== currentRun);
-      for (const run of otherRuns) this.cancelRun(run, reason);
+      for (const run of otherRuns) this.cancelRun(run, reason, contextFor(run.sessionId));
       const runResults = await Promise.allSettled(otherRuns.map((run) => run.completion));
       for (const result of runResults) {
         if (result.status === 'rejected') this.appendUnexpectedErrors(cleanupErrors, result.reason);
@@ -3845,7 +4063,16 @@ export class FlexHarness<TScope = unknown> {
       await Promise.allSettled([...state.sessionInitializations.values()]);
       cleanupErrors.push(...await this.closeOrphanedResources(state.storageKey));
       await state.scopeQueue;
-      const tombstoneAttempts = [...state.tombstoneCleanups.entries()];
+      const currentTombstoneCleanup = state.tombstoneCleanups.get(currentRun.sessionId);
+      if (currentTombstoneCleanup) {
+        this.retainOrphanedTombstoneCleanup(
+          state.storageKey,
+          currentRun.sessionId,
+          currentTombstoneCleanup,
+        );
+      }
+      const tombstoneAttempts = [...state.tombstoneCleanups.entries()]
+        .filter(([sessionId]) => sessionId !== currentRun.sessionId);
       const tombstoneResults = await Promise.allSettled(
         tombstoneAttempts.map(([, cleanup]) => cleanup),
       );
@@ -3856,12 +4083,13 @@ export class FlexHarness<TScope = unknown> {
       const storedSessions = new Set([
         ...state.sessions.values(),
         ...[...state.retainedSessionCleanups]
-          .filter(([sessionId]) => !attemptedTombstones.has(sessionId))
+          .filter(([sessionId]) =>
+            sessionId !== currentRun.sessionId && !attemptedTombstones.has(sessionId))
           .map(([, retained]) => retained.stored),
       ]);
       for (const stored of storedSessions) {
         try {
-          await this.abortStoredSession(stored, reason);
+          await this.abortStoredSession(stored, reason, contextFor(stored.session.sessionId));
         } catch (error) {
           cleanupErrors.push(this.projectOperationError(
             error,
@@ -3872,7 +4100,7 @@ export class FlexHarness<TScope = unknown> {
           ));
         }
         try {
-          await this.closeStoredSession(stored);
+          await this.closeStoredSession(stored, contextFor(stored.session.sessionId));
         } catch (error) {
           if (!this.storedSessionCleanupCompleted(stored)) {
             cleanupErrors.push(this.projectOperationError(
@@ -3891,24 +4119,41 @@ export class FlexHarness<TScope = unknown> {
       if (cleanupErrors.length > 0) throw combineErrors([cause, ...cleanupErrors]);
       state.lifecycle = 'retired';
       state.sessions.clear();
+      const currentRetainedCleanup = state.retainedSessionCleanups.get(currentRun.sessionId);
       state.retainedSessionCleanups.clear();
+      if (currentRetainedCleanup) {
+        state.retainedSessionCleanups.set(currentRun.sessionId, currentRetainedCleanup);
+      }
       state.sessionDeletions.clear();
       state.tombstoneCleanups.clear();
+      if (currentTombstoneCleanup) {
+        state.tombstoneCleanups.set(currentRun.sessionId, currentTombstoneCleanup);
+      }
       state.activeRuns.clear();
       state.pendingPermissions.clear();
       state.initializingSessions.clear();
       state.sessionInitializations.clear();
       this.stateLoads.delete(state.storageKey);
+      if (
+        this.storageCompactorLifecycleControllers.get(state.storageKey)
+        === state.compactorLifecycleController
+      ) this.storageCompactorLifecycleControllers.delete(state.storageKey);
     } finally {
       state.fenceInProgress = false;
     }
   }
 
-  private async closeStoredSession(stored: IStoredSessionState): Promise<void> {
+  private async closeStoredSession(
+    stored: IStoredSessionState,
+    context: IFlexAgentContextInvocation<unknown> = stored.compactorContext!,
+  ): Promise<void> {
     const errors: unknown[] = [];
     if (!stored.agentSessionCloseCompleted) {
       try {
-        await stored.agentSession.close();
+        await this.withCompactorContext(
+          context,
+          () => stored.agentSession.close(),
+        );
         if (!stored.agentSession.closeCleanupCompleted) {
           throw new Error('AgentSession.close() resolved before cleanup ownership was released.');
         }
@@ -3958,9 +4203,13 @@ export class FlexHarness<TScope = unknown> {
   private async abortStoredSession(
     stored: IStoredSessionState,
     reason: FlexHarnessAbortError,
+    context: IFlexAgentContextInvocation<unknown> = stored.compactorContext!,
   ): Promise<void> {
     if (stored.agentSessionAbortCompleted) return;
-    await stored.agentSession.abortSession(reason, { abortBackgroundJobs: true });
+    await this.withCompactorContext(
+      context,
+      () => stored.agentSession.abortSession(reason, { abortBackgroundJobs: true }),
+    );
     stored.agentSessionAbortCompleted = true;
   }
 
@@ -4016,6 +4265,29 @@ export class FlexHarness<TScope = unknown> {
         retained.storageKey === storageKey && retained.sessionId === sessionId);
   }
 
+  private retainOrphanedTombstoneCleanup(
+    storageKey: string,
+    sessionId: string,
+    completion: Promise<void>,
+  ): void {
+    const key = JSON.stringify([storageKey, sessionId]);
+    if (this.orphanedTombstoneCleanups.has(key)) return;
+    const retained: IOrphanedTombstoneCleanup = { storageKey, sessionId, completion };
+    this.orphanedTombstoneCleanups.set(key, retained);
+    void completion.then(
+      () => {
+        if (this.orphanedTombstoneCleanups.get(key) === retained) {
+          this.orphanedTombstoneCleanups.delete(key);
+        }
+      },
+      () => {
+        if (this.orphanedTombstoneCleanups.get(key) === retained) {
+          this.orphanedTombstoneCleanups.delete(key);
+        }
+      },
+    );
+  }
+
   private closeOrphanedResources(storageKey?: string): Promise<unknown[]> {
     const operation = this.orphanedResourceQueue.then(() =>
       this.closeOrphanedResourcesInternal(storageKey));
@@ -4025,6 +4297,14 @@ export class FlexHarness<TScope = unknown> {
 
   private async closeOrphanedResourcesInternal(storageKey?: string): Promise<unknown[]> {
     const errors: unknown[] = [];
+    const tombstoneCleanups = [...this.orphanedTombstoneCleanups.values()]
+      .filter((retained) => storageKey === undefined || retained.storageKey === storageKey);
+    const tombstoneResults = await Promise.allSettled(
+      tombstoneCleanups.map((retained) => retained.completion),
+    );
+    for (const result of tombstoneResults) {
+      if (result.status === 'rejected') this.appendUnexpectedErrors(errors, result.reason);
+    }
     for (const stored of [...this.orphanedStoredSessions]) {
       if (storageKey !== undefined && stored.storageKey !== storageKey) continue;
       try {
@@ -4065,6 +4345,7 @@ export class FlexHarness<TScope = unknown> {
       ...[...this.orphanedStoredSessions].map((stored) => stored.storageKey),
       ...[...this.orphanedExecutionContexts.values()].map((owner) => owner.storageKey),
       ...[...this.orphanedProviderReleases.values()].map((retained) => retained.storageKey),
+      ...[...this.orphanedTombstoneCleanups.values()].map((retained) => retained.storageKey),
     ]);
   }
 
@@ -4087,7 +4368,12 @@ export class FlexHarness<TScope = unknown> {
       }
     } else {
       try {
-        await this.drainStorage(scope.storageKey, stateLoad, this.createScopeRetirementError());
+        await this.drainStorage(
+          scope.storageKey,
+          stateLoad,
+          this.createScopeRetirementError(),
+          { scopeId, scope: scope.scope },
+        );
       } catch (error) {
         this.appendUnexpectedErrors(errors, error);
       }
@@ -4099,15 +4385,25 @@ export class FlexHarness<TScope = unknown> {
     storageKey: string,
     stateLoad: Promise<IStorageState>,
     reason: FlexHarnessAbortError,
+    invocation?: { scopeId: string; scope: TScope },
   ): Promise<void> {
+    const compactorController = this.storageCompactorLifecycleControllers.get(storageKey);
+    if (compactorController && !compactorController.signal.aborted) {
+      compactorController.abort(reason);
+    }
     const existing = this.storageDrains.get(storageKey);
     if (existing) return existing;
     let completed = false;
     let drain!: Promise<void>;
-    drain = this.drainStorageInternal(storageKey, stateLoad, reason).then(() => {
+    drain = this.drainStorageInternal(storageKey, stateLoad, reason, invocation).then(() => {
       completed = true;
     }).finally(() => {
-      if (completed && this.stateLoads.get(storageKey) === stateLoad) this.stateLoads.delete(storageKey);
+      if (completed && this.stateLoads.get(storageKey) === stateLoad) {
+        this.stateLoads.delete(storageKey);
+        if (this.storageCompactorLifecycleControllers.get(storageKey) === compactorController) {
+          this.storageCompactorLifecycleControllers.delete(storageKey);
+        }
+      }
       if (this.storageDrains.get(storageKey) === drain) this.storageDrains.delete(storageKey);
     });
     this.storageDrains.set(storageKey, drain);
@@ -4118,6 +4414,7 @@ export class FlexHarness<TScope = unknown> {
     storageKey: string,
     stateLoad: Promise<IStorageState>,
     reason: FlexHarnessAbortError,
+    invocation?: { scopeId: string; scope: TScope },
   ): Promise<void> {
     let state: IStorageState;
     try {
@@ -4130,14 +4427,35 @@ export class FlexHarness<TScope = unknown> {
     if (state.lifecycle !== 'fenced') state.lifecycle = 'retiring';
     const detachedCleanupAttempts = this.beginDetachedCleanupSettlement(state);
     const errors: unknown[] = [];
-    for (const stored of state.sessions.values()) this.cancelStoredPromptQueue(stored, reason);
+    const contextFor = (sessionId: string) => invocation
+      ? this.createCompactorContext(invocation.scopeId, invocation.scope, storageKey, sessionId)
+      : undefined;
+    for (const stored of state.sessions.values()) {
+      this.abortCompactorLifecycle(stored, reason);
+      this.cancelStoredPromptQueue(
+        stored,
+        reason,
+        undefined,
+        contextFor(stored.session.sessionId),
+      );
+    }
     for (const run of state.activeRuns.values()) {
-      if (run.phase !== 'finalizing' && run.phase !== 'promoting') this.cancelRun(run, reason);
+      if (run.phase !== 'finalizing' && run.phase !== 'promoting') {
+        this.cancelRun(run, reason, contextFor(run.sessionId));
+      }
     }
     for (const pending of [...state.pendingPermissions.values()]) this.rejectPending(state, pending, reason);
+    const runResults = await Promise.allSettled([...state.activeRuns.values()].map((run) => run.completion));
+    for (const result of runResults) {
+      if (result.status === 'rejected') this.appendUnexpectedErrors(errors, result.reason);
+    }
     for (const stored of state.sessions.values()) {
       try {
-        await this.abortStoredSession(stored, reason);
+        await this.abortStoredSession(
+          stored,
+          reason,
+          contextFor(stored.session.sessionId),
+        );
       } catch (error) {
         errors.push(this.projectOperationError(
           error,
@@ -4148,10 +4466,6 @@ export class FlexHarness<TScope = unknown> {
         ));
       }
     }
-    const runResults = await Promise.allSettled([...state.activeRuns.values()].map((run) => run.completion));
-    for (const result of runResults) {
-      if (result.status === 'rejected') this.appendUnexpectedErrors(errors, result.reason);
-    }
     await Promise.allSettled([...state.sessionInitializations.values()]);
     errors.push(...await this.closeOrphanedResources(state.storageKey));
     await state.scopeQueue;
@@ -4171,7 +4485,7 @@ export class FlexHarness<TScope = unknown> {
     errors.push(...await this.settleDetachedCleanups(state, detachedCleanupAttempts));
     for (const stored of state.sessions.values()) {
       try {
-        await this.closeStoredSession(stored);
+        await this.closeStoredSession(stored, contextFor(stored.session.sessionId));
       } catch (error) {
         this.appendUnexpectedErrors(errors, this.projectOperationError(
           error,
@@ -4190,7 +4504,8 @@ export class FlexHarness<TScope = unknown> {
         await this.finishTombstoneCleanup(
           state,
           sessionId,
-          retained?.stored.session.scopeId ?? state.scopeIdHint,
+          invocation?.scopeId ?? retained?.stored.session.scopeId ?? state.scopeIdHint,
+          invocation?.scope,
         );
       } catch (error) {
         this.appendUnexpectedErrors(errors, error);
@@ -4238,10 +4553,12 @@ export class FlexHarness<TScope = unknown> {
     }
     this.listeners.clear();
     if (errors.length > 0) throw combineErrors(errors);
+    this.compactorInvocationContext.disable();
     this.stateLoads.clear();
     this.scopeAdmissions.clear();
     this.scopeRetirements.clear();
     this.storageDrains.clear();
+    this.storageCompactorLifecycleControllers.clear();
   }
 
   private appendUnexpectedErrors(target: unknown[], error: unknown): void {
@@ -4250,6 +4567,12 @@ export class FlexHarness<TScope = unknown> {
     } else if (!isAbortError(error)) target.push(error);
   }
 
+  private abortCompactorLifecycle(stored: IStoredSessionState, reason: FlexHarnessAbortError): void {
+    if (!stored.compactorLifecycleController.signal.aborted) {
+      stored.compactorLifecycleController.abort(reason);
+    }
+  }
+
   private async resolveState(
     scopeId: string,
   ): Promise<{ scope: IFlexResolvedScope<TScope>; state: IStorageState }> {
@@ -4277,10 +4600,26 @@ export class FlexHarness<TScope = unknown> {
         ) throw this.createScopeRetirementError();
         stateLoad = this.stateLoads.get(scope.storageKey);
         if (!stateLoad) {
-          stateLoad = this.loadState(scope.storageKey, scopeId, scope.scope);
+          const compactorLifecycleController = new AbortController();
+          this.storageCompactorLifecycleControllers.set(
+            scope.storageKey,
+            compactorLifecycleController,
+          );
+          stateLoad = this.loadState(
+            scope.storageKey,
+            scopeId,
+            scope.scope,
+            compactorLifecycleController,
+          );
           this.stateLoads.set(scope.storageKey, stateLoad);
           void stateLoad.catch(() => {
-            if (this.stateLoads.get(scope.storageKey) === stateLoad) this.stateLoads.delete(scope.storageKey);
+            if (this.stateLoads.get(scope.storageKey) === stateLoad) {
+              this.stateLoads.delete(scope.storageKey);
+              if (
+                this.storageCompactorLifecycleControllers.get(scope.storageKey)
+                === compactorLifecycleController
+              ) this.storageCompactorLifecycleControllers.delete(scope.storageKey);
+            }
           });
         }
       }
@@ -4326,6 +4665,37 @@ export class FlexHarness<TScope = unknown> {
     }
   }
 
+  private createCompactorContext(
+    scopeId: string,
+    scope: TScope,
+    storageKey: string,
+    sessionId: string,
+  ): IFlexAgentContextInvocation<TScope> {
+    return Object.freeze({ scopeId, scope, storageKey, sessionId });
+  }
+
+  private withCompactorContext<TResult>(
+    context: IFlexAgentContextInvocation<unknown>,
+    operation: () => TResult,
+  ): TResult {
+    return this.compactorInvocationContext.run(
+      context as IFlexAgentContextInvocation<TScope>,
+      operation,
+    );
+  }
+
+  private createRunCompactorContext(run: IActiveRun): IFlexAgentContextInvocation<TScope> {
+    return run.originCompactorContext as IFlexAgentContextInvocation<TScope>;
+  }
+
+  private effectiveRunCompactorContext(run: IActiveRun): IFlexAgentContextInvocation<TScope> {
+    return (run.deferredCompactorContext ?? run.originCompactorContext) as IFlexAgentContextInvocation<TScope>;
+  }
+
+  private withRunCompactorContext<TResult>(run: IActiveRun, operation: () => TResult): TResult {
+    return this.withCompactorContext(this.effectiveRunCompactorContext(run), operation);
+  }
+
   private requireSession(state: IStorageState, sessionId: string): IStoredSessionState {
     validateIdentifier(sessionId, 'sessionId');
     requireTransferIdentifier(sessionId, 'sessionId');