@modelprofile.com/flexharness 10.24.0 → 10.24.1

package/ts/classes.flexharness.runs.ts

@@ -0,0 +1,1204 @@
+import * as plugins from './plugins.js';
+import {
+  FlexHarnessAbortError,
+  FlexHarnessExternalError,
+  FlexHarnessNotFoundError,
+  FlexHarnessRunError,
+  FlexHarnessStepLimitError,
+  FlexHarnessValidationError,
+  errorToInfo,
+} from './errors.js';
+import {
+  FLEX_PROJECT_MANAGEMENT_LIMITS,
+  FLEX_RESULT_METHOD,
+  type IFlexAgentContextInvocation,
+  type IFlexMessage,
+  type IFlexPermissionRequestInput,
+  type IFlexPromptOptions,
+  type IFlexPromptResult,
+  type IFlexResolvedModel,
+  type IFlexRunFinishedEvent,
+  type IFlexSession,
+  type IFlexTerminalProjection,
+  type IFlexToolHandle,
+  type IFlexToolProviderContext,
+  type TFlexAgentToolSet,
+  type TFlexMessagePart,
+} from './interfaces.js';
+import { FlexToolCatalog, assertNoCatalogCollisions } from './classes.toolcatalog.js';
+import { FlexCodeSandbox } from './classes.codesandbox.js';
+import { cloneSerializable } from './utils.json.js';
+import type { INormalizedFlexPrompt } from './utils.prompt.js';
+import {
+  describeAttachment,
+  maxTransferMetadataBytes,
+  normalizeResolvedModel,
+  normalizeRunResult,
+  publicSnapshot,
+  truncateUtf8,
+  type IRunResultProjection,
+} from './utils.transfer.js';
+import { wrapToolSet } from './utils.tooloutput.js';
+import { validateUtf8String } from './utils.validation.js';
+import type {
+  TCanonicalOutcome,
+  IStoredSessionState,
+  IStorageState,
+  IActiveRun,
+  IRunSteering,
+  IRunSteeringOutcome,
+  IQueuedPrompt,
+  IResolverOutcome,
+} from './interfaces.flexharness.js';
+import {
+  externalErrorFallback,
+  requireSessionGeneration,
+  combineErrors,
+  terminalActivityError,
+} from './utils.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+
+/** The run execution engine: generations, terminal outcomes, steering and cancellation. */
+export class FlexHarnessRuns<TScope> {
+  constructor(private readonly core: FlexHarnessCore<TScope>) {}
+
+  public async abort(scopeId: string, sessionId: string): Promise<boolean> {
+    const { scope, state } = await this.core.resolveState(scopeId);
+    const run = state.activeRuns.get(sessionId);
+    if (!run || run.phase === 'finalizing' || run.phase === 'promoting') return false;
+    this.cancelRun(
+      run,
+      this.core.trustInternalError(new FlexHarnessAbortError()),
+      this.core.compaction.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
+    );
+    return true;
+  }
+
+  public createActiveRun(queued: IQueuedPrompt): IActiveRun {
+    const steering: IRunSteering = {
+      input: new plugins.AgentPendingInputQueue(),
+      stored: queued.stored,
+      accepted: new Map(),
+      applied: new Set(),
+    };
+    queued.steering = steering;
+    return {
+      steering,
+      stop: new AbortController(),
+      subagents: this.core.subagents,
+      state: queued.state,
+      stored: queued.stored,
+      originCompactorContext: this.core.compaction.createCompactorContext(
+        queued.scopeId,
+        queued.scope as TScope,
+        queued.state.storageKey,
+        queued.sessionId,
+      ),
+      scopeId: queued.scopeId,
+      scope: queued.scope,
+      sessionId: queued.sessionId,
+      queueId: queued.queueId,
+      runId: queued.runId!,
+      userMessageId: plugins.crypto.randomUUID(),
+      assistantMessageId: plugins.crypto.randomUUID(),
+      controller: new AbortController(),
+      ...(queued.scheduleKey === undefined
+        ? {}
+        : { scheduleKey: queued.scheduleKey, debounceMs: queued.debounceMs }),
+      callbackEventCount: 0,
+      callbackOutputBytes: 0,
+      callbackParts: [],
+      partTextUtf8Bytes: new Map(),
+      callbacksClosed: false,
+      finishedEventEmitted: false,
+      usage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+      },
+      reasoningPartIds: new Map(),
+      toolPartIds: new Map(),
+      trustedToolExecutionErrors: new Map(),
+      unconfirmedToolCalls: new Map(),
+      readCalls: new Map(),
+      deduplicatedToolCalls: new Map(),
+      subagentCallCount: 0,
+      subagentSessionIds: new Set(),
+      backgroundSubagents: new Set(),
+      pendingPermissionIds: new Set(),
+      phase: 'admitting',
+      completion: queued.completion,
+    };
+  }
+
+  public async executeRun(
+    run: IActiveRun,
+    generation: Promise<plugins.IAgentGenerateResult>,
+  ): Promise<IFlexPromptResult> {
+    let generated = false;
+    try {
+      // The transactional generation settles only after its model calls are reported, so
+      // `run.usage` is complete once it settles, also for a cancelled run.
+      let rawResult: plugins.IAgentGenerateResult;
+      try {
+        rawResult = await generation;
+        generated = true;
+      } finally {
+        await this.core.callbacks.settleMetricsOperation(run.state, run.stored, run.metricsOperation!);
+      }
+      if (rawResult.terminationReason === 'step-limit') {
+        throw this.core.trustInternalError(new FlexHarnessStepLimitError(rawResult.steps));
+      }
+      // Background tools do not block inference, but the owning turn joins its admitted children
+      // before releasing its authority or committing its terminal projection.
+      await Promise.all([...run.backgroundSubagents]);
+      if (run.callbackError) throw run.callbackError;
+      if (run.controller.signal.aborted) throw run.controller.signal.reason;
+      const result = normalizeRunResult(rawResult);
+      if (!run.modelResolution) throw new FlexHarnessValidationError('Generation completed without a resolved model.');
+      await this.core.reversions.finalizeRunReversion(run, 'completed');
+      await this.core.admission.closeRunDelegatedRunAdmission(run);
+      const terminal = this.buildTerminal(run, 'completed', result);
+      try {
+        await this.core.mutateProjection(run.state, run.stored, () => {
+          this.replaceStagedTerminal(run.stored, terminal);
+        }, true);
+      } catch (error) {
+        throw this.core.projectExternalError(run, error, 'persistence');
+      }
+      if (run.controller.signal.aborted) throw run.controller.signal.reason;
+      run.phase = 'finalizing';
+      try {
+        await this.core.compaction.withRunCompactorContext(
+          run,
+          () => run.stored.agentSession.finalizeGeneration(run.transaction!, 'accepted'),
+        );
+      } catch (error) {
+        const projected = this.core.projectExternalError(run, error, 'agentSession');
+        await this.core.lifecycle.fenceNamespace(run.state, run, projected);
+        throw projected;
+      }
+      run.steering.keptInContext = true;
+      this.core.reversions.refreshAutomaticArchiveHorizon(run.stored);
+      run.phase = 'promoting';
+      const closePublication = this.core.openPublication(run.state, run.sessionId);
+      try {
+        try {
+          await this.promoteCompletedTerminal(run, terminal);
+        } catch (error) {
+          const projected = this.core.projectExternalError(run, error, 'persistence');
+          await this.core.lifecycle.fenceNamespace(run.state, run, projected);
+          throw projected;
+        }
+        this.emitTerminalProjection(run, terminal);
+        this.emitFinalRunEvent(run, terminal.assistantMessage, undefined, false);
+      } finally {
+        closePublication();
+      }
+      await this.core.reversions.drainReversionReleases(
+        run.state,
+        run.stored,
+        run.scopeId,
+        run.scope as TScope,
+        false,
+      );
+      return {
+        runId: run.runId,
+        sessionId: run.sessionId,
+        userMessage: publicSnapshot(terminal.userMessage),
+        assistantMessage: publicSnapshot(terminal.assistantMessage),
+        model: publicSnapshot(terminal.model!),
+        usage: publicSnapshot(terminal.usage!),
+        finishReason: terminal.finishReason!,
+        steps: terminal.steps!,
+        unappliedSteerIds: [...this.closeRunSteering(run.steering).unappliedSteerIds],
+      };
+    } catch (error) {
+      // A failed parent must cancel its admitted children before joining them. Otherwise a
+      // child waiting for permission or model I/O can keep a failed parent alive indefinitely.
+      if (run.backgroundSubagents.size > 0 && !run.controller.signal.aborted) run.controller.abort(error);
+      await Promise.allSettled([...run.backgroundSubagents]);
+      try {
+        if (run.state.lifecycle === 'fenced') {
+          await this.core.lifecycle.fenceNamespace(run.state, run, error);
+          throw error;
+        }
+        if (run.state.lifecycle === 'retired') throw error;
+        return await this.finishFailedRun(run, error, generated);
+      } catch (finalError) {
+        this.emitUnpublishedRunFinish(run, finalError, generated);
+        throw finalError;
+      }
+    } finally {
+      run.callbacksClosed = true;
+      this.core.permissions.rejectRunPermissions(
+        run.state,
+        run,
+        run.ownerCancellation ?? new FlexHarnessAbortError('The run ended before permission was resolved.'),
+      );
+      if (run.state.activeRuns.get(run.sessionId) === run) run.state.activeRuns.delete(run.sessionId);
+    }
+  }
+
+  private async finishFailedRun(
+    run: IActiveRun,
+    error: unknown,
+    generated: boolean,
+  ): Promise<never> {
+    run.callbacksClosed = true;
+    run.phase = 'closing';
+    const cancelled = run.ownerCancellation !== undefined && run.internalFailure === undefined;
+    const safeError = cancelled
+      ? run.ownerCancellation!
+      : this.core.projectExternalError(run, error, generated ? 'persistence' : 'agentSession');
+    const errors: unknown[] = [safeError];
+    let reversionFailed = false;
+    try {
+      await this.core.reversions.finalizeRunReversion(run, cancelled ? 'cancelled' : 'failed');
+    } catch (reversionError) {
+      errors.push(reversionError);
+      reversionFailed = true;
+    }
+    try {
+      await this.core.admission.closeRunDelegatedRunAdmission(run);
+    } catch (closeError) {
+      if (!errors.includes(closeError)) errors.push(closeError);
+    }
+    if (reversionFailed) {
+      const combined = combineErrors(errors);
+      await this.core.lifecycle.fenceNamespace(run.state, run, combined);
+      throw combined;
+    }
+    if (generated && !this.core.isTombstoned(run)) {
+      const failedStage = this.buildTerminal(run, cancelled ? 'cancelled' : 'failed', undefined, safeError);
+      try {
+        await this.core.mutateProjection(run.state, run.stored, () => {
+          this.replaceStagedTerminal(run.stored, failedStage);
+        }, true);
+      } catch (stageError) {
+        errors.push(this.core.projectExternalError(run, stageError, 'persistence'));
+      }
+    }
+
+    run.phase = 'finalizing';
+    const desiredOutcome: TCanonicalOutcome = cancelled || !generated ? 'interrupted' : 'rejected';
+    try {
+      await this.core.compaction.withRunCompactorContext(
+        run,
+        () => run.stored.agentSession.finalizeGeneration(
+          run.transaction!,
+          desiredOutcome,
+          { stopped: desiredOutcome === 'interrupted' && cancelled },
+        ),
+      );
+    } catch (finalizationError) {
+      errors.push(this.core.projectExternalError(run, finalizationError, 'agentSession'));
+    }
+    let outcome: TCanonicalOutcome | undefined;
+    try {
+      const snapshot = await run.stored.eventStore.load(run.stored.session.sessionId);
+      const events = snapshot?.events ?? [];
+      outcome = this.core.canonicalOutcomes(events).get(run.runId);
+      // A generation without a durable outcome is interrupted by the next load, which leaves it
+      // out of the model context.
+      run.steering.keptInContext = outcome !== undefined
+        && plugins.isGenerationInModelContext(events, run.runId);
+      this.core.reversions.refreshAutomaticArchiveHorizon(run.stored);
+    } catch (outcomeError) {
+      errors.push(this.core.projectExternalError(run, outcomeError, 'persistence'));
+    }
+    if (!outcome) {
+      const combined = combineErrors(errors);
+      await this.core.lifecycle.fenceNamespace(run.state, run, combined);
+      throw combined;
+    }
+    if (outcome === 'accepted') {
+      const combined = combineErrors(errors);
+      await this.core.lifecycle.fenceNamespace(run.state, run, combined);
+      throw combined;
+    }
+    const publicStatus = outcome === 'rejected' || !cancelled ? 'failed' : 'cancelled';
+    const terminalError = publicStatus === 'cancelled'
+      ? run.ownerCancellation ?? this.core.trustInternalError(new FlexHarnessAbortError())
+      : safeError;
+    const terminal = this.buildTerminal(run, publicStatus, undefined, terminalError);
+    if (!this.core.isTombstoned(run)) {
+      const closePublication = this.core.openPublication(run.state, run.sessionId);
+      try {
+        try {
+          await this.publishFailedTerminal(run, terminal);
+        } catch (persistenceError) {
+          errors.push(this.core.projectExternalError(run, persistenceError, 'persistence'));
+          const combined = combineErrors(errors);
+          await this.core.lifecycle.fenceNamespace(run.state, run, combined);
+          throw combined;
+        }
+        this.emitTerminalProjection(run, terminal);
+        this.emitFinalRunEvent(run, terminal.assistantMessage, terminalError, publicStatus === 'cancelled');
+      } finally {
+        closePublication();
+      }
+    }
+    await this.core.reversions.drainReversionReleases(
+      run.state,
+      run.stored,
+      run.scopeId,
+      run.scope as TScope,
+      false,
+    );
+    throw errors.length > 1 ? combineErrors(errors) : terminalError;
+  }
+
+  public async prepareGeneration(
+    run: IActiveRun,
+    options: IFlexPromptOptions,
+    signal: AbortSignal,
+  ): Promise<plugins.IAgentGenerationLease> {
+    signal.throwIfAborted();
+    const configuration = await this.core.configurations.resolveSessionConfiguration(
+      run.scopeId,
+      run.scope as TScope,
+      run.state,
+      run.stored,
+      signal,
+    );
+    run.subagents = configuration.subagents;
+    run.allowedTools = configuration.allowedTools;
+    run.permissionPolicy = configuration.permissionPolicy as IActiveRun['permissionPolicy'];
+    const agent = run.stored.session.agent;
+    if (agent !== undefined) {
+      const definition = configuration.subagents.get(agent);
+      if (!definition) throw new FlexHarnessValidationError(`Subagent "${agent}" is disabled.`);
+      run.agentAllowedTools = definition.allowedTools;
+    }
+    await this.core.reversions.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.core.prompts.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.core.modelResolver.resolveModel(Object.freeze({
+        scopeId: run.scopeId,
+        scope: run.scope as TScope,
+        sessionId: run.sessionId,
+        ...requireSessionGeneration(run.stored.session),
+        runId: run.runId,
+        ...(options.modelHint ? { modelHint: options.modelHint } : {}),
+        ...resolverRelationship,
+        signal,
+      })))
+      .then(
+        (value): IResolverOutcome<IFlexResolvedModel> => ({ source: 'model', success: true, value }),
+        (error): IResolverOutcome<IFlexResolvedModel> => ({ source: 'model', success: false, error }),
+      );
+    const toolProviderContext: Readonly<IFlexToolProviderContext<TScope>> = Object.freeze({
+      scopeId: run.scopeId,
+      scope: run.scope as TScope,
+      sessionId: run.sessionId,
+      ...requireSessionGeneration(run.stored.session),
+      runId: run.runId,
+      ...resolverRelationship,
+      signal,
+      requestPermission: async (request: IFlexPermissionRequestInput) => {
+        // A call that started early asks once the model's response confirmed it.
+        const confirmed = request.toolCallId === undefined
+          ? undefined
+          : run.unconfirmedToolCalls.get(request.toolCallId);
+        if (confirmed) await confirmed;
+        return this.core.permissions.requestPermission(run.state, run, request);
+      },
+    });
+    const toolOutcome = Promise.resolve()
+      .then(() => this.core.providers.provideRunToolHandle(run, toolProviderContext))
+      .then(
+        (value): IResolverOutcome<IFlexToolHandle | undefined> => ({ source: 'tools', success: true, value }),
+        (error): IResolverOutcome<IFlexToolHandle | undefined> => ({ source: 'tools', success: false, error }),
+      );
+    let resolveAbort!: (outcome: IResolverOutcome<never>) => void;
+    const abortOutcome = new Promise<IResolverOutcome<never>>((resolve) => {
+      resolveAbort = resolve;
+    });
+    const onAbort = () => resolveAbort({
+      source: 'abort',
+      success: false,
+      error: signal.reason ?? new FlexHarnessAbortError(),
+    });
+    signal.addEventListener('abort', onAbort, { once: true });
+    if (signal.aborted) onAbort();
+    let model: IFlexResolvedModel | undefined;
+    let toolHandle: IFlexToolHandle | undefined;
+    try {
+      const first = await Promise.race([modelOutcome, toolOutcome, abortOutcome]);
+      if (!first.success) {
+        const failure = first.source === 'abort'
+          ? first.error
+          : this.core.projectExternalError(run, first.error, first.source === 'model' ? 'modelResolver' : 'toolProvider');
+        if (first.source !== 'abort') this.abortRunInternally(run, failure);
+        if (first.source !== 'tools') this.core.providers.observeDetachedToolProvider(toolOutcome, run);
+        throw failure;
+      }
+      try {
+        if (first.source === 'model') model = normalizeResolvedModel(first.value as IFlexResolvedModel);
+        else toolHandle = this.core.providers.normalizeToolHandle(run, first.value as IFlexToolHandle | undefined);
+      } catch (error) {
+        const projected = first.source === 'model'
+          ? this.core.projectExternalError(run, error, 'modelResolver')
+          : this.core.projectExternalError(run, error, 'toolProvider');
+        this.abortRunInternally(run, projected);
+        if (first.source === 'model') this.core.providers.observeDetachedToolProvider(toolOutcome, run);
+        throw projected;
+      }
+      const second = await Promise.race([
+        first.source === 'model' ? toolOutcome : modelOutcome,
+        abortOutcome,
+      ]);
+      if (!second.success) {
+        const failure = second.source === 'abort'
+          ? second.error
+          : this.core.projectExternalError(run, second.error, second.source === 'model' ? 'modelResolver' : 'toolProvider');
+        if (second.source !== 'abort') this.abortRunInternally(run, failure);
+        if (!toolHandle && first.source === 'model' && second.source === 'abort') {
+          this.core.providers.observeDetachedToolProvider(toolOutcome, run);
+        }
+        throw failure;
+      }
+      try {
+        if (second.source === 'model') model = normalizeResolvedModel(second.value as IFlexResolvedModel);
+        else toolHandle = this.core.providers.normalizeToolHandle(run, second.value as IFlexToolHandle | undefined);
+      } catch (error) {
+        const projected = second.source === 'model'
+          ? this.core.projectExternalError(run, error, 'modelResolver')
+          : this.core.projectExternalError(run, error, 'toolProvider');
+        this.abortRunInternally(run, projected);
+        throw projected;
+      }
+      signal.throwIfAborted();
+      run.modelResolution = model!;
+      run.toolProviderContext = toolProviderContext as Readonly<IFlexToolProviderContext<unknown>>;
+      run.isReadOnlyHostCall = toolHandle?.isReadOnlyToolCall;
+      let catalog: FlexToolCatalog<unknown> | undefined;
+      if (toolHandle?.catalog) {
+        try {
+          catalog = await FlexToolCatalog.create(toolHandle.catalog, this.core.toolCatalogOptions, {
+            results: this.core.stores.results !== undefined,
+          });
+          if (catalog.codeMode) run.codeSandbox = await FlexCodeSandbox.load();
+        } catch (error) {
+          throw this.core.projectExternalError(run, error, 'toolProvider');
+        }
+        signal.throwIfAborted();
+      }
+      let tools: TFlexAgentToolSet | undefined;
+      try {
+        const providedTools = toolHandle?.tools;
+        const combinedTools: Record<string, unknown> = { ...(providedTools ?? {}) };
+        Object.assign(combinedTools, this.createBuiltInTools(run));
+        if (catalog) assertNoCatalogCollisions(catalog, combinedTools);
+        const globalNames = run.allowedTools === undefined ? undefined : new Set(run.allowedTools);
+        const agentNames = run.agentAllowedTools === undefined ? undefined : new Set(run.agentAllowedTools);
+        const admitted = (name: string): boolean =>
+          (globalNames === undefined || globalNames.has(name))
+          && (agentNames === undefined || agentNames.has(name));
+        const admittedTools = globalNames === undefined && agentNames === undefined
+          ? combinedTools
+          : Object.fromEntries(Object.entries(combinedTools).filter(([name]) => admitted(name)));
+        const admittedCatalog = catalog && (globalNames === undefined && agentNames === undefined
+          ? catalog
+          : catalog.restrict(catalog.methods.filter((name) => name === FLEX_RESULT_METHOD || admitted(name))));
+        if (admittedCatalog && admittedCatalog.methods.length > 0) {
+          run.toolCatalog = admittedCatalog;
+          Object.assign(admittedTools, this.core.toolDispatch.createCatalogTools(run, admittedCatalog));
+        }
+        tools = Object.keys(admittedTools).length > 0
+          ? this.core.toolDispatch.trackToolCalls(run, wrapToolSet(
+              admittedTools as TFlexAgentToolSet,
+              this.core.toolOutputLimits,
+              (toolError) => this.core.projectExternalError(run, toolError, 'toolExecution'),
+              (output) => this.core.results.budgetOutput(run, output),
+            ))
+          : undefined;
+      } catch (error) {
+        throw this.core.projectExternalError(run, error, 'toolProvider');
+      }
+      let closed = false;
+      let closePromise: Promise<void> | undefined;
+      const close = toolHandle?.close
+        ? async () => {
+            if (closed) return;
+            // Inference has ended before its tool lease closes. Fence follow-up admission
+            // synchronously, even when external cleanup has not settled yet.
+            run.steering.input.close();
+            closePromise ??= Promise.resolve()
+              .then(() => toolHandle!.close!())
+              .then(() => {
+                closed = true;
+              })
+              .catch((cleanupError) => {
+                closePromise = undefined;
+                throw this.core.projectExternalError(run, cleanupError, 'toolCleanup');
+              });
+            await closePromise;
+          }
+        : undefined;
+      return {
+        model: model!.model,
+        ...(options.system ?? model!.system ? { system: options.system ?? model!.system } : {}),
+        ...(tools ? {
+          tools,
+          isReadOnlyToolCall: ({ toolName, input }: { toolName: string; input: unknown }) =>
+            this.core.toolDispatch.isReadOnlyToolCall(run, toolName, input),
+        } : {}),
+        ...(model!.providerOptions ? { providerOptions: model!.providerOptions } : {}),
+        ...(model!.cache === undefined ? {} : { cache: model!.cache }),
+        ...(options.maxSteps ?? model!.maxSteps ? { maxSteps: options.maxSteps ?? model!.maxSteps } : {}),
+        ...(close ? { close } : {}),
+      };
+    } catch (error) {
+      if (toolHandle) {
+        try {
+          await this.core.providers.closePartialToolHandle(toolHandle, run);
+        } catch (cleanupError) {
+          throw combineErrors([error, cleanupError]);
+        }
+      }
+      throw error;
+    } finally {
+      signal.removeEventListener('abort', onAbort);
+    }
+  }
+
+  public enabledBuiltInToolNames(run: IActiveRun): Set<string> {
+    const names = new Set<string>();
+    if (run.subagents.size > 0 && (run.stored.session.depth ?? 0) < this.core.maxSubagentDepth) {
+      names.add('delegate');
+      names.add('delegate_result');
+      names.add('delegate_send');
+    }
+    if (this.core.builtInTools.renameSession) names.add('rename_session');
+    const projectManagement = this.core.builtInTools.projectManagement;
+    if (projectManagement?.task) names.add('task');
+    if (projectManagement?.goal) names.add('goal');
+    if (projectManagement?.scratchpad) names.add('scratchpad');
+    return names;
+  }
+
+  public 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 (run.subagents.size > 0 && (run.stored.session.depth ?? 0) < this.core.maxSubagentDepth) {
+      tools.delegate = this.core.subagentTasks.createSubagentTool(run);
+      tools.delegate_result = this.core.subagentTasks.createSubagentResultTool(run);
+      tools.delegate_send = this.core.subagentTasks.createSubagentSendTool(run);
+    }
+    if (this.core.builtInTools.renameSession) tools.rename_session = this.createRenameSessionTool(run);
+    const projectManagement = this.core.builtInTools.projectManagement;
+    if (projectManagement?.task) tools.task = this.core.projects.createProjectTaskTool(run);
+    if (projectManagement?.goal) tools.goal = this.core.projects.createProjectGoalTool(run);
+    if (projectManagement?.scratchpad) tools.scratchpad = this.core.projects.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.core.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.core.emitEvent(run.scopeId, session, {
+          type: 'session.updated',
+          session,
+        });
+        return { session };
+      },
+    });
+  }
+
+  public abortExactRun(
+    state: IStorageState,
+    sessionId: string,
+    runId: string,
+    reason: unknown,
+  ): boolean {
+    const active = state.activeRuns.get(sessionId);
+    if (!active || active.runId !== runId || active.phase === 'finalizing' || active.phase === 'promoting') {
+      return false;
+    }
+    const cancellation = reason instanceof FlexHarnessAbortError
+      ? reason
+      : this.core.trustInternalError(new FlexHarnessAbortError('The parent run was aborted.'));
+    this.cancelRun(active, cancellation);
+    return true;
+  }
+
+  public createReservation(
+    run: IActiveRun,
+    prompt: INormalizedFlexPrompt,
+  ): { userMessage: IFlexMessage; assistantMessage: IFlexMessage } {
+    const timestamp = new Date().toISOString();
+    const userMessage: IFlexMessage = {
+      messageId: run.userMessageId,
+      sessionId: run.sessionId,
+      runId: run.runId,
+      role: 'user',
+      status: 'streaming',
+      createdAt: timestamp,
+      parts: this.userMessageParts(prompt),
+    };
+    const assistantMessage: IFlexMessage = {
+      messageId: run.assistantMessageId,
+      sessionId: run.sessionId,
+      runId: run.runId,
+      role: 'assistant',
+      status: 'streaming',
+      createdAt: timestamp,
+      parts: [],
+    };
+    return { userMessage, assistantMessage };
+  }
+
+  private userMessageParts(prompt: INormalizedFlexPrompt): TFlexMessagePart[] {
+    return prompt.parts.map((part) => {
+      if (part.type === 'text') {
+        return { partId: plugins.crypto.randomUUID(), type: 'text' as const, text: part.text };
+      }
+      return {
+        partId: plugins.crypto.randomUUID(),
+        type: 'attachment' as const,
+        attachmentType: part.type,
+        ...describeAttachment(part),
+      };
+    });
+  }
+
+  /**
+   * Ends steering intake once the run's generation has settled and fixes what became of its
+   * steers. A run that stays in the model context reports the steers its generation did not
+   * record; a run that does not, because it failed, was stopped before any model output or its
+   * outcome could not be established, reports every steer it accepted, since the model context
+   * of later turns holds none of them. The bytes of the steers not taken in are released.
+   */
+  public closeRunSteering(steering: IRunSteering): IRunSteeringOutcome {
+    if (steering.outcome) return steering.outcome;
+    steering.input.close();
+    const keptInContext = steering.keptInContext === true;
+    const unappliedSteerIds: string[] = [];
+    let heldBytes = 0;
+    for (const [steerId, entry] of steering.accepted) {
+      const applied = steering.applied.has(steerId);
+      if (!applied) heldBytes += entry.byteSize;
+      if (!keptInContext || !applied) unappliedSteerIds.push(steerId);
+    }
+    steering.stored.outstandingPromptBytes = Math.max(0, steering.stored.outstandingPromptBytes - heldBytes);
+    steering.outcome = Object.freeze({
+      keptInContext,
+      unappliedSteerIds: Object.freeze(unappliedSteerIds),
+    });
+    return steering.outcome;
+  }
+
+  /**
+   * Projects a steer the run's generation took in as a user message of the run. The assistant
+   * message that answered before it is completed and the run answers on in a new one; a steer
+   * taken in before the run answered anything is placed before its still empty assistant message.
+   */
+  public async applyRunSteer(run: IActiveRun, applied: plugins.IAgentAppliedInput): Promise<void> {
+    const steering = run.steering;
+    const accepted = steering.accepted.get(applied.inputId);
+    if (
+      !accepted
+      || applied.generationId !== run.runId
+      || steering.applied.has(applied.inputId)
+      || steering.outcome !== undefined
+    ) {
+      throw new Error(`Steer "${applied.inputId}" was taken in without being accepted by its run.`);
+    }
+    // The generation recorded the steer durably: it is in the model context whenever the run is.
+    steering.applied.add(applied.inputId);
+    steering.stored.outstandingPromptBytes = Math.max(
+      0,
+      steering.stored.outstandingPromptBytes - accepted.byteSize,
+    );
+    const timestamp = new Date().toISOString();
+    const steerMessage: IFlexMessage = {
+      messageId: plugins.crypto.randomUUID(),
+      sessionId: run.sessionId,
+      runId: run.runId,
+      role: 'user',
+      status: 'completed',
+      createdAt: timestamp,
+      completedAt: timestamp,
+      steerId: applied.inputId,
+      parts: this.userMessageParts(accepted.prompt),
+    };
+    const answered = run.callbackParts.length > 0;
+    const answeredAssistantId = run.assistantMessageId;
+    let completedAssistant: IFlexMessage | undefined;
+    const nextAssistant: IFlexMessage | undefined = answered
+      ? {
+          messageId: plugins.crypto.randomUUID(),
+          sessionId: run.sessionId,
+          runId: run.runId,
+          role: 'assistant',
+          status: 'streaming',
+          createdAt: timestamp,
+          parts: [],
+        }
+      : undefined;
+    const closePublication = this.core.openPublication(run.state, run.sessionId);
+    try {
+      await this.core.mutateProjection(run.state, run.stored, () => {
+        const index = run.stored.messages.findIndex((message) => message.messageId === answeredAssistantId);
+        if (index < 0) throw new Error('The steered run has no projected assistant message.');
+        if (!nextAssistant) {
+          run.stored.messages.splice(index, 0, cloneSerializable(steerMessage));
+          return;
+        }
+        completedAssistant = {
+          ...cloneSerializable(run.stored.messages[index]),
+          status: 'completed',
+          completedAt: timestamp,
+          parts: cloneSerializable(run.callbackParts),
+          ...(run.modelResolution ? { model: cloneSerializable(run.modelResolution.identity) } : {}),
+        };
+        run.stored.messages.splice(
+          index,
+          1,
+          cloneSerializable(completedAssistant),
+          cloneSerializable(steerMessage),
+          cloneSerializable(nextAssistant),
+        );
+      });
+      if (completedAssistant && nextAssistant) {
+        run.assistantMessageId = nextAssistant.messageId;
+        run.reservedAssistantMessage = publicSnapshot(nextAssistant);
+        run.callbackParts = [];
+        run.reasoningPartIds.clear();
+        this.core.emitEvent(run.scopeId, run.stored.session, {
+          type: 'message.updated',
+          runId: run.runId,
+          messageId: completedAssistant.messageId,
+          message: publicSnapshot(completedAssistant),
+        });
+      }
+      this.core.emitEvent(run.scopeId, run.stored.session, {
+        type: 'message.created',
+        runId: run.runId,
+        messageId: steerMessage.messageId,
+        message: publicSnapshot(steerMessage),
+      });
+      if (nextAssistant) {
+        this.core.emitEvent(run.scopeId, run.stored.session, {
+          type: 'message.created',
+          runId: run.runId,
+          messageId: nextAssistant.messageId,
+          message: publicSnapshot(nextAssistant),
+        });
+      }
+      this.core.emitEvent(run.scopeId, run.stored.session, {
+        type: 'prompt.steer.applied',
+        queueId: run.queueId,
+        runId: run.runId,
+        steerId: applied.inputId,
+        messageId: steerMessage.messageId,
+      });
+    } finally {
+      closePublication();
+    }
+  }
+
+  private buildTerminal(
+    run: IActiveRun,
+    status: 'completed' | 'failed' | 'cancelled',
+    result?: IRunResultProjection,
+    error?: Error,
+  ): IFlexTerminalProjection {
+    const timestamp = new Date().toISOString();
+    const userMessage: IFlexMessage = cloneSerializable(
+      run.reservedUserMessage
+      ?? run.stored.messages.find((message) => message.messageId === run.userMessageId)
+      ?? {
+        messageId: run.userMessageId,
+        sessionId: run.sessionId,
+        runId: run.runId,
+        role: 'user',
+        status: 'streaming',
+        createdAt: timestamp,
+        parts: [],
+      } satisfies IFlexMessage,
+    );
+    const assistantMessage: IFlexMessage = cloneSerializable(
+      run.reservedAssistantMessage
+      ?? run.stored.messages.find((message) => message.messageId === run.assistantMessageId)
+      ?? {
+        messageId: run.assistantMessageId,
+        sessionId: run.sessionId,
+        runId: run.runId,
+        role: 'assistant',
+        status: 'streaming',
+        createdAt: timestamp,
+        parts: [],
+      } satisfies IFlexMessage,
+    );
+    assistantMessage.parts = cloneSerializable(run.callbackParts);
+    const terminalParts = assistantMessage.parts;
+    for (const part of terminalParts) {
+      if (part.type === 'reasoning' && part.status === 'running') {
+        part.status = status === 'completed' ? 'completed' : 'cancelled';
+        part.completedAt = timestamp;
+      } else if (part.type === 'tool' && part.status === 'running') {
+        part.status = status === 'cancelled' ? 'cancelled' : 'failed';
+        delete part.output;
+        part.error = status === 'cancelled'
+          ? 'Tool execution was cancelled.'
+          : 'Tool execution ended without a terminal event.';
+        part.completedAt = timestamp;
+      }
+    }
+    userMessage.status = status;
+    userMessage.completedAt = timestamp;
+    assistantMessage.status = status;
+    assistantMessage.completedAt = timestamp;
+    if (run.modelResolution) assistantMessage.model = cloneSerializable(run.modelResolution.identity);
+    if (status === 'completed' && result) {
+      if (!assistantMessage.parts.some((part) => part.type === 'text')) {
+        assistantMessage.parts.push({
+          partId: plugins.crypto.randomUUID(),
+          type: 'text',
+          text: truncateUtf8(result.text, this.core.callbackLimits.maxOutputBytes),
+        });
+      }
+      assistantMessage.usage = cloneSerializable(result.usage);
+    } else {
+      assistantMessage.usage = cloneSerializable(run.usage);
+      const message = truncateUtf8(error?.message ?? externalErrorFallback.message, maxTransferMetadataBytes);
+      const limit = error instanceof FlexHarnessExternalError ? error.limit : undefined;
+      for (const failedMessage of [userMessage, assistantMessage]) {
+        failedMessage.error = message;
+        if (limit) failedMessage.limit = cloneSerializable(limit);
+      }
+    }
+    return {
+      runId: run.runId,
+      status,
+      userMessage,
+      assistantMessage,
+      ...(run.modelResolution ? { model: cloneSerializable(run.modelResolution.identity) } : {}),
+      ...(status === 'completed' && result
+        ? {
+            usage: cloneSerializable(result.usage),
+            finishReason: result.finishReason,
+            steps: result.steps,
+          }
+        : { usage: cloneSerializable(run.usage) }),
+    };
+  }
+
+  private async promoteCompletedTerminal(
+    run: IActiveRun,
+    terminal: IFlexTerminalProjection,
+  ): Promise<void> {
+    await this.core.mutateProjection(run.state, run.stored, () => {
+      this.replaceVisibleRun(run.stored, terminal);
+      run.stored.stagedTerminals = run.stored.stagedTerminals.filter((entry) => entry.runId !== run.runId);
+    }, true);
+    if (!this.core.isTombstoned(run)) {
+      await this.core.mutateScope(run.state, () => {
+        if (run.state.sessions.get(run.sessionId) !== run.stored) return;
+        const timestamp = terminal.assistantMessage.completedAt!;
+        run.stored.session.status = 'idle';
+        run.stored.session.activity = {
+          runId: run.runId,
+          status: 'idle',
+          startedAt: run.stored.session.activity.startedAt,
+          completedAt: timestamp,
+        };
+        run.stored.session.updatedAt = timestamp;
+      }, true);
+    }
+  }
+
+  private async publishFailedTerminal(
+    run: IActiveRun,
+    terminal: IFlexTerminalProjection,
+  ): Promise<void> {
+    await this.core.mutateProjection(run.state, run.stored, () => {
+      this.replaceVisibleRun(run.stored, terminal);
+      run.stored.stagedTerminals = run.stored.stagedTerminals.filter((entry) => entry.runId !== run.runId);
+    }, true);
+    await this.core.mutateScope(run.state, () => {
+      if (run.state.sessions.get(run.sessionId) !== run.stored) return;
+      const timestamp = terminal.assistantMessage.completedAt!;
+      const activityStatus = terminal.status === 'completed' ? 'idle' : terminal.status;
+      run.stored.session.status = activityStatus;
+      run.stored.session.activity = {
+        runId: run.runId,
+        status: activityStatus,
+        startedAt: run.stored.session.activity.startedAt,
+        completedAt: timestamp,
+        ...terminalActivityError(terminal.assistantMessage),
+      };
+      run.stored.session.updatedAt = timestamp;
+    }, true);
+  }
+
+  private replaceStagedTerminal(stored: IStoredSessionState, terminal: IFlexTerminalProjection): void {
+    stored.stagedTerminals = stored.stagedTerminals.filter((entry) => entry.runId !== terminal.runId);
+    stored.stagedTerminals.push(cloneSerializable(terminal));
+  }
+
+  /**
+   * Puts a run's terminal messages in place of their projected versions: its prompt, and its last
+   * assistant message. The steers a run took in, and the assistant messages it completed before
+   * them, stay where they are. A terminal message that is not projected yet is added: the prompt
+   * before the run's other messages, the assistant message after them.
+   */
+  public replaceVisibleRun(stored: IStoredSessionState, terminal: IFlexTerminalProjection): void {
+    const replacements = new Map([
+      [terminal.userMessage.messageId, terminal.userMessage],
+      [terminal.assistantMessage.messageId, terminal.assistantMessage],
+    ]);
+    const placed = new Set<string>();
+    stored.messages = stored.messages.map((message) => {
+      const replacement = message.runId === terminal.runId
+        ? replacements.get(message.messageId)
+        : undefined;
+      if (!replacement) return message;
+      placed.add(replacement.messageId);
+      return cloneSerializable(replacement);
+    });
+    const firstIndex = stored.messages.findIndex((message) => message.runId === terminal.runId);
+    if (!placed.has(terminal.userMessage.messageId)) {
+      stored.messages.splice(
+        firstIndex < 0 ? stored.messages.length : firstIndex,
+        0,
+        cloneSerializable(terminal.userMessage),
+      );
+    }
+    if (!placed.has(terminal.assistantMessage.messageId)) {
+      const lastIndex = stored.messages.reduce(
+        (last, message, index) => message.runId === terminal.runId ? index : last,
+        -1,
+      );
+      stored.messages.splice(
+        lastIndex < 0 ? stored.messages.length : lastIndex + 1,
+        0,
+        cloneSerializable(terminal.assistantMessage),
+      );
+    }
+  }
+
+  private emitTerminalProjection(run: IActiveRun, terminal: IFlexTerminalProjection): void {
+    for (const part of terminal.assistantMessage.parts) {
+      const callbackPart = run.callbackParts.find((entry) => entry.partId === part.partId);
+      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.core.emitPartEvent(run, 'part.completed', part);
+      }
+    }
+    for (const message of [terminal.userMessage, terminal.assistantMessage]) {
+      this.core.emitEvent(run.scopeId, run.stored.session, {
+        type: 'message.updated',
+        runId: run.runId,
+        messageId: message.messageId,
+        message: publicSnapshot(message),
+      });
+    }
+  }
+
+  /**
+   * Ends a run that fails without publishing a terminal projection, because its namespace was
+   * fenced or retired or its durable outcome could not be established: listeners still receive
+   * its terminal message events and its one `run.finished`. Nothing here is persisted; the next
+   * load of the namespace repairs the stored projection from the canonical outcome.
+   */
+  private emitUnpublishedRunFinish(run: IActiveRun, error: unknown, generated: boolean): void {
+    if (run.finishedEventEmitted || run.state.tombstones.has(run.sessionId)) return;
+    const cancelled = run.ownerCancellation !== undefined && run.internalFailure === undefined;
+    const terminalError = cancelled
+      ? run.ownerCancellation!
+      : error instanceof FlexHarnessRunError
+        ? error
+        : this.core.projectExternalError(run, error, generated ? 'persistence' : 'agentSession');
+    const terminal = this.buildTerminal(run, cancelled ? 'cancelled' : 'failed', undefined, terminalError);
+    this.emitTerminalProjection(run, terminal);
+    this.emitFinalRunEvent(run, terminal.assistantMessage, terminalError, cancelled);
+  }
+
+  private emitFinalRunEvent(
+    run: IActiveRun,
+    message: IFlexMessage,
+    error: unknown,
+    cancelled: boolean,
+  ): void {
+    const status: IFlexRunFinishedEvent['status'] = error
+      ? cancelled ? 'cancelled' : 'failed'
+      : 'completed';
+    run.finishedEventEmitted = true;
+    const steering = this.closeRunSteering(run.steering);
+    this.core.emitEvent(run.scopeId, run.stored.session, {
+      type: 'run.finished',
+      runId: run.runId,
+      messageId: run.assistantMessageId,
+      status,
+      message: publicSnapshot(message),
+      ...(error === undefined ? {} : { error: errorToInfo(error) }),
+      keptInContext: steering.keptInContext,
+      unappliedSteerIds: [...steering.unappliedSteerIds],
+    });
+  }
+
+  public cancelRun(
+    run: IActiveRun,
+    reason: FlexHarnessAbortError,
+    context?: IFlexAgentContextInvocation<TScope>,
+  ): void {
+    const invocationContext = context ?? this.core.compaction.createRunCompactorContext(run);
+    // A stopped run takes no further steers; the ones it has not taken in are reported unapplied.
+    run.steering.input.close();
+    if (run.internalFailure === undefined && run.ownerCancellation === undefined) {
+      run.ownerCancellation = reason;
+      run.deferredCompactorContext = invocationContext;
+      this.core.compaction.deferredCompactorContexts.set(run.originCompactorContext, invocationContext);
+    }
+    this.core.compaction.withCompactorContext(
+      (run.deferredCompactorContext ?? invocationContext) as IFlexAgentContextInvocation<TScope>,
+      () => {
+        this.core.permissions.rejectRunPermissions(run.state, run, reason);
+        // The owner stops the generation: what its model produced stays in the model context.
+        if (run.ownerCancellation === reason && !run.stop.signal.aborted) run.stop.abort(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);
+        }
+      },
+    );
+  }
+
+  public abortRunInternally(
+    run: IActiveRun,
+    error: unknown,
+    context?: IFlexAgentContextInvocation<TScope>,
+  ): void {
+    const invocationContext = context ?? this.core.compaction.createRunCompactorContext(run);
+    run.steering.input.close();
+    if (run.internalFailure === undefined) {
+      run.internalFailure = error ?? new Error('Internal FlexHarness run failure.');
+      run.deferredCompactorContext = invocationContext;
+      this.core.compaction.deferredCompactorContexts.set(run.originCompactorContext, invocationContext);
+    }
+    this.core.compaction.withCompactorContext(
+      (run.deferredCompactorContext ?? invocationContext) as IFlexAgentContextInvocation<TScope>,
+      () => {
+        if (!run.controller.signal.aborted) run.controller.abort(run.internalFailure);
+        run.stored.agentSession.abortCurrentGeneration(run.internalFailure);
+      },
+    );
+  }
+
+  public async rollbackAdmission(
+    run: IActiveRun,
+    projectionReserved: boolean,
+    originalError: Error,
+  ): Promise<unknown[]> {
+    const errors: unknown[] = [];
+    if (run.transaction) {
+      try {
+        await this.core.compaction.withRunCompactorContext(
+          run,
+          () => run.stored.agentSession.finalizeGeneration(run.transaction!, 'interrupted'),
+        );
+      } catch (error) {
+        errors.push(this.core.projectExternalError(run, error, 'agentSession'));
+      }
+      try {
+        const outcome = (await this.core.durableCanonicalOutcomes(run.stored)).get(run.runId);
+        if (outcome !== 'interrupted') {
+          errors.push(this.core.projectExternalError(
+            run,
+            new Error('Prompt admission interruption is not durably established.'),
+            'persistence',
+          ));
+        }
+      } catch (error) {
+        errors.push(this.core.projectExternalError(run, error, 'persistence'));
+      }
+    }
+    if (projectionReserved || run.stored.metrics.pendingGenerationId === run.runId) {
+      try {
+        await this.core.mutateProjection(run.state, run.stored, () => {
+          if (run.stored.metrics.pendingGenerationId === run.runId) {
+            delete run.stored.metrics.pendingGenerationId;
+          }
+          run.stored.messages = run.stored.messages.filter((message) => message.runId !== run.runId);
+          run.stored.stagedTerminals = run.stored.stagedTerminals.filter((entry) => entry.runId !== run.runId);
+          run.stored.reversionSegments = run.stored.reversionSegments.filter(
+            (segment) => segment.runId !== run.runId,
+          );
+          if (
+            run.stored.pendingReversion?.kind === 'capture'
+            && run.stored.pendingReversion.runId === run.runId
+          ) delete run.stored.pendingReversion;
+        }, true);
+      } catch (error) {
+        errors.push(this.core.projectExternalError(run, error, 'persistence'));
+      }
+    }
+    if (run.state.sessions.get(run.sessionId) === run.stored && run.stored.session.activity.runId === run.runId) {
+      try {
+        await this.core.mutateScope(run.state, () => {
+          run.stored.session.status = 'idle';
+          run.stored.session.activity = { status: 'idle' };
+          run.stored.session.updatedAt = new Date().toISOString();
+        }, true);
+      } catch (error) {
+        errors.push(this.core.projectExternalError(run, error, 'persistence'));
+      }
+    }
+    if (errors.length > 0) await this.core.lifecycle.fenceNamespace(run.state, run, combineErrors([originalError, ...errors]));
+    return errors;
+  }
+}