@modelprofile.com/flexharness 10.23.0 → 10.24.1

package/ts/classes.flexharness.slashcommands.ts

@@ -0,0 +1,705 @@
+import * as plugins from './plugins.js';
+import {
+  FlexHarnessAbortError,
+  FlexHarnessSessionBusyError,
+  FlexHarnessSlashCommandReentryError,
+  FlexHarnessSlashCommandUnavailableError,
+  FlexHarnessValidationError,
+} from './errors.js';
+import type {
+  IFlexPromptAdmission,
+  IFlexSlashCommandDescriptor,
+  IFlexSlashCommandExecutionOptions,
+  IFlexSlashCommandHandlerRegistration,
+  TFlexSlashCommandExecutionResult,
+} from './interfaces.js';
+import { normalizeJsonValue } from './utils.json.js';
+import { normalizeFlexPrompt } from './utils.prompt.js';
+import type { TRegisteredSlashCommand } from './utils.harnessoptions.js';
+import {
+  FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE,
+  expandSlashCommandTemplate,
+  isReservedSlashCommandName,
+  parseSlashCommand,
+  slashCommandTemplateHints,
+} from './utils.slashcommands.js';
+import { publicSnapshot } from './utils.transfer.js';
+import { validateSlashCommandExecutionOptions } from './utils.validation.js';
+import type {
+  IStoredSessionState,
+  IStorageState,
+  IActiveSlashCommandExecution,
+  IActiveSlashCommandListing,
+  ISlashCommandInvocationOwner,
+  ISlashCommandActivityOwner,
+} from './interfaces.flexharness.js';
+import {
+  slashCommandSessionUnavailableReason,
+  requireSessionGeneration,
+} from './utils.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+
+const importedSessionUnavailableReason = 'Session is an imported conversation and is read-only.';
+
+/** Slash command listing and execution, and the ownership of their activity. */
+export class FlexHarnessSlashCommands<TScope> {
+  public readonly activeSlashCommandExecutions = new Map<string, IActiveSlashCommandExecution>();
+  private readonly activeSlashCommandListings = new Set<IActiveSlashCommandListing>();
+  public readonly slashCommandInvocationContext = new plugins.AsyncLocalStorage<
+    ISlashCommandInvocationOwner
+  >();
+  public readonly slashCommandActivityContext = new plugins.AsyncLocalStorage<
+    ISlashCommandActivityOwner
+  >();
+
+  constructor(private readonly core: FlexHarnessCore<TScope>) {}
+
+  public async listSlashCommands(
+    scopeId: string,
+    sessionId: string,
+  ): Promise<IFlexSlashCommandDescriptor[]> {
+    const { scope, state } = await this.core.resolveState(scopeId);
+    return this.trackSlashCommandListing(scopeId, state, sessionId, async (signal) => {
+      await this.core.reversions.awaitReversionOperation(state.scopeQueue, signal);
+      signal.throwIfAborted();
+      this.core.assertStateAcceptingWork(state);
+      const stored = this.core.requireSession(state, sessionId);
+      const configuration = await this.core.configurations.resolveSessionConfiguration(
+        scopeId, scope.scope, state, stored, signal,
+      );
+      await this.core.reversions.reconcileContextAvailability(state, stored);
+      signal.throwIfAborted();
+      const sessionAvailable = this.isSessionAvailableForSlashCommand(state, stored);
+      const reversionIdleReason = await this.core.reversions.reversionUnavailableReason(
+        state,
+        stored,
+        false,
+        signal,
+      );
+      signal.throwIfAborted();
+      const descriptors = this.createSlashCommandDescriptors(
+        state,
+        stored,
+        sessionAvailable,
+        reversionIdleReason,
+        configuration.slashCommands,
+      );
+      if (stored.session.origin === undefined) return descriptors;
+      return publicSnapshot(descriptors.map((descriptor): IFlexSlashCommandDescriptor => ({
+        ...descriptor,
+        available: false,
+        unavailableReason: importedSessionUnavailableReason,
+      })));
+    });
+  }
+
+  private createSlashCommandDescriptors(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    sessionAvailable: boolean,
+    reversionIdleReason?: string,
+    slashCommands: ReadonlyMap<string, TRegisteredSlashCommand<TScope>> = this.core.slashCommands,
+  ): IFlexSlashCommandDescriptor[] {
+    const sessionAvailability = sessionAvailable
+      ? {}
+      : { available: false, unavailableReason: slashCommandSessionUnavailableReason };
+    const undoUnit = this.core.reversions.reversionUnit(stored, 'undo');
+    const redoUnit = this.core.reversions.reversionUnit(stored, 'redo');
+    const workspaceReversion = (unit: ReturnType<typeof this.core.reversions.reversionUnit>) =>
+      !unit
+      || !this.core.turnReversionProvider
+      || unit.segments.some((segment) => segment.provenance !== 'workspace')
+        ? 'unsupported' as const
+        : 'supported' as const;
+    const reversionAvailability = (unit: ReturnType<typeof this.core.reversions.reversionUnit>) => {
+      if (reversionIdleReason) return {
+        available: false,
+        unavailableReason: reversionIdleReason,
+      };
+      if (!unit) return { available: false, unavailableReason: 'No turn is available.' };
+      if (!unit.target.contextAvailable) return {
+        available: false,
+        unavailableReason: 'The turn is beyond the context archive horizon.',
+      };
+      if (unit.segments.some((segment) =>
+        segment.disposition === 'revertible' && segment.workspaceReference === undefined)) return {
+        available: false,
+        unavailableReason: 'The turn has no available workspace reversion capture.',
+      };
+      return { available: true };
+    };
+    const compactAvailable = Boolean(this.core.agentSessionPolicy.contextCompactor) && sessionAvailable;
+    const compactUnavailableReason = !this.core.agentSessionPolicy.contextCompactor
+      ? 'No context compactor is configured.'
+      : !sessionAvailable
+        ? slashCommandSessionUnavailableReason
+        : undefined;
+    const initPrompt = expandSlashCommandTemplate(FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE, '', []);
+    const initAvailability = this.slashCommandPromptAvailability(
+      state,
+      stored,
+      this.core.prompts.promptAdmissionByteSize(initPrompt, {}),
+    );
+    const descriptors: IFlexSlashCommandDescriptor[] = [
+      {
+        name: 'compact',
+        description: 'Compact the current session context.',
+        kind: 'builtin',
+        hints: [],
+        available: compactAvailable,
+        ...(compactUnavailableReason === undefined
+          ? {}
+          : { unavailableReason: compactUnavailableReason }),
+        workspaceReversion: 'not-applicable',
+      },
+      {
+        name: 'init',
+        description: 'Create or update AGENTS.md for the active workspace.',
+        kind: 'builtin',
+        hints: ['$ARGUMENTS'],
+        ...initAvailability,
+        workspaceReversion: 'not-applicable',
+      },
+      {
+        name: 'undo',
+        description: 'Undo the most recent session operation.',
+        kind: 'builtin',
+        hints: [],
+        ...reversionAvailability(undoUnit),
+        workspaceReversion: workspaceReversion(undoUnit),
+      },
+      {
+        name: 'redo',
+        description: 'Redo the most recently undone session operation.',
+        kind: 'builtin',
+        hints: [],
+        ...reversionAvailability(redoUnit),
+        workspaceReversion: workspaceReversion(redoUnit),
+      },
+    ];
+    for (const registration of slashCommands.values()) {
+      const template = typeof registration.template === 'string';
+      const availability = template
+        ? this.slashCommandPromptAvailability(
+            state,
+            stored,
+            this.core.prompts.promptAdmissionByteSize(
+              expandSlashCommandTemplate(registration.template!, '', []),
+              {},
+            ),
+          )
+        : { available: sessionAvailable, ...sessionAvailability };
+      descriptors.push({
+        name: registration.name,
+        description: registration.description ?? '',
+        kind: template ? 'template' : 'handler',
+        hints: template ? slashCommandTemplateHints(registration.template!) : [],
+        ...availability,
+        workspaceReversion: 'not-applicable',
+      });
+    }
+    return publicSnapshot(descriptors);
+  }
+
+  public async executeSlashCommand(
+    scopeId: string,
+    sessionId: string,
+    untouchedInput: string,
+    options: IFlexSlashCommandExecutionOptions = {},
+  ): Promise<TFlexSlashCommandExecutionResult> {
+    return this.executeSlashCommandInternal(scopeId, sessionId, untouchedInput, options, false);
+  }
+
+  public async executeSessionSlashCommand(
+    scopeId: string,
+    sessionId: string,
+    untouchedInput: string,
+    options: IFlexSlashCommandExecutionOptions = {},
+  ): Promise<TFlexSlashCommandExecutionResult> {
+    return this.executeSlashCommandInternal(scopeId, sessionId, untouchedInput, options, true);
+  }
+
+  private async executeSlashCommandInternal(
+    scopeId: string,
+    sessionId: string,
+    untouchedInput: string,
+    options: IFlexSlashCommandExecutionOptions,
+    sessionAware: boolean,
+  ): Promise<TFlexSlashCommandExecutionResult> {
+    const currentInvocation = this.slashCommandInvocationContext.getStore();
+    if (currentInvocation?.scopeId === scopeId && currentInvocation.sessionId === sessionId) {
+      throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+    }
+    const parsed = parseSlashCommand(untouchedInput);
+    if (parsed.type !== 'parsed') return parsed;
+    let registration = sessionAware ? undefined : this.core.slashCommands.get(parsed.name);
+    if (!sessionAware && !isReservedSlashCommandName(parsed.name) && !registration) {
+      return Object.freeze({
+        type: 'unknown',
+        input: parsed.input,
+        name: parsed.name,
+        rawArguments: parsed.rawArguments,
+        arguments: parsed.arguments,
+      });
+    }
+    const promptOptions = validateSlashCommandExecutionOptions(options);
+    const { scope, state } = await this.core.resolveState(scopeId);
+    await state.scopeQueue;
+    this.core.assertOpen();
+    this.core.assertStateAcceptingWork(state);
+    const stored = this.core.requireSession(state, sessionId);
+    this.core.assertSessionWritable(stored);
+    if (sessionAware) {
+      const configuration = await this.core.configurations.resolveSessionConfiguration(
+        scopeId, scope.scope, state, stored, options.signal,
+      );
+      this.core.assertStateAcceptingWork(state);
+      if (state.sessions.get(sessionId) !== stored) {
+        throw this.core.trustInternalError(new FlexHarnessAbortError(
+          'The session was deleted during slash command resolution.',
+        ));
+      }
+      registration = configuration.slashCommands.get(parsed.name);
+      if (!isReservedSlashCommandName(parsed.name) && !registration) {
+        return Object.freeze({
+          type: 'unknown',
+          input: parsed.input,
+          name: parsed.name,
+          rawArguments: parsed.rawArguments,
+          arguments: parsed.arguments,
+        });
+      }
+    } else if (stored.session.configurationRef !== undefined) {
+      throw new FlexHarnessValidationError(
+        'A bound session requires executeSessionSlashCommand().',
+      );
+    }
+    const sessionKey = this.slashCommandSessionKey(state.storageKey, sessionId);
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner?.sessionKey === sessionKey) {
+      throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+    }
+    if (this.activeSlashCommandExecutions.has(sessionKey)) {
+      throw new FlexHarnessSessionBusyError(
+        sessionId,
+        'already has an active slash command execution',
+      );
+    }
+    if (parsed.name === 'undo' || parsed.name === 'redo') {
+      if (parsed.arguments.length > 0) {
+        throw new FlexHarnessValidationError(`Slash command "/${parsed.name}" does not accept arguments.`);
+      }
+      await this.core.reversions.changeReversionCursorResolved(
+        scopeId,
+        sessionId,
+        parsed.name,
+        scope.scope,
+        state,
+        options.signal,
+      );
+      return Object.freeze({ type: 'operation', name: parsed.name });
+    }
+    if (parsed.name === 'compact') {
+      if (parsed.arguments.length > 0) {
+        throw new FlexHarnessValidationError('Slash command "/compact" does not accept arguments.');
+      }
+      const ignoredOption = (['system', 'maxSteps'] as const)
+        .find((key) => promptOptions[key] !== undefined);
+      if (ignoredOption) {
+        throw new FlexHarnessValidationError(
+          `Slash command "/compact" does not support the "${ignoredOption}" option.`,
+        );
+      }
+      if (!this.core.agentSessionPolicy.contextCompactor) {
+        throw new FlexHarnessSlashCommandUnavailableError(
+          parsed.name,
+          'No context compactor is configured.',
+        );
+      }
+      this.requireSessionAvailableForSlashCommand(state, stored, parsed.name);
+      return this.trackSlashCommandExecution(
+        scopeId,
+        state,
+        sessionId,
+        'operation',
+        options.signal,
+        async (signal) => {
+          await this.core.reversions.commitRevertedBranch(state, stored, scopeId, scope.scope);
+          await this.core.compaction.compactStoredSession(
+            scopeId,
+            scope.scope,
+            state,
+            stored,
+            promptOptions.modelHint,
+            signal,
+          );
+          return Object.freeze({ type: 'operation', name: parsed.name });
+        },
+      );
+    }
+    if (options.signal?.aborted) {
+      throw this.core.trustInternalError(new FlexHarnessAbortError('The slash command was aborted.'));
+    }
+      if (parsed.name === 'init' || typeof registration?.template === 'string') {
+      const template = parsed.name === 'init'
+        ? FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE
+        : registration!.template!;
+      const expanded = expandSlashCommandTemplate(template, parsed.rawArguments, parsed.arguments);
+      normalizeFlexPrompt(expanded);
+      this.requireSlashCommandPromptAvailable(
+        state,
+        stored,
+        parsed.name,
+        this.core.prompts.promptAdmissionByteSize(expanded, promptOptions),
+      );
+      return this.trackSlashCommandExecution(
+        scopeId,
+        state,
+        sessionId,
+        'prompt-admission',
+        options.signal,
+        async (signal) => {
+          const queued = await this.core.prompts.enqueuePromptInternal(
+            scopeId,
+            sessionId,
+            expanded,
+            promptOptions,
+            undefined,
+            undefined,
+            undefined,
+            signal,
+            true,
+          );
+          const cancellation = this.core.trustInternalError(
+            new FlexHarnessAbortError('The slash command prompt was aborted.'),
+          );
+          const cancel = () => {
+            const entry = queued.queued;
+            if (!entry) return;
+            this.core.prompts.cancelQueuedPrompt(
+              entry,
+              cancellation,
+              this.core.compaction.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId),
+            );
+          };
+          const cancellationSignals = options.signal && options.signal !== signal
+            ? [signal, options.signal]
+            : [signal];
+          for (const cancellationSignal of cancellationSignals) {
+            cancellationSignal.addEventListener('abort', cancel, { once: true });
+          }
+          if (cancellationSignals.some((cancellationSignal) => cancellationSignal.aborted)) cancel();
+          let admission: IFlexPromptAdmission;
+          try {
+            admission = await queued.started;
+            if (cancellationSignals.some((cancellationSignal) => cancellationSignal.aborted)) {
+              cancel();
+              throw cancellationSignals.find((cancellationSignal) => cancellationSignal.aborted)?.reason
+                ?? cancellation;
+            }
+          } catch (error) {
+            for (const cancellationSignal of cancellationSignals) {
+              cancellationSignal.removeEventListener('abort', cancel);
+            }
+            throw error;
+          }
+          void admission.completion.finally(() => {
+            for (const cancellationSignal of cancellationSignals) {
+              cancellationSignal.removeEventListener('abort', cancel);
+            }
+          }).catch(() => undefined);
+          return Object.freeze({ type: 'prompt-admission', name: parsed.name, admission });
+        },
+      );
+    }
+    this.requireSessionAvailableForSlashCommand(state, stored, parsed.name);
+    return this.executeSlashCommandHandler(
+      scopeId,
+      scope.scope,
+      state,
+      stored,
+      parsed.name,
+      parsed.rawArguments,
+      parsed.arguments,
+      registration!.handler!,
+      options.signal,
+    );
+  }
+
+  private isSessionAvailableForSlashCommand(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    allowPendingApply = false,
+  ): boolean {
+    return this.core.prompts.isSessionRuntimeIdle(state, stored)
+      && !this.activeSlashCommandExecutions.has(
+        this.slashCommandSessionKey(state.storageKey, stored.session.sessionId),
+      )
+      && (stored.pendingReversion === undefined
+        || (allowPendingApply && stored.pendingReversion.kind === 'apply'));
+  }
+
+  private slashCommandPromptUnavailableReason(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    byteSize: number,
+  ): string | undefined {
+    if (state.lifecycle !== 'active') return 'The session namespace is not accepting work.';
+    if (this.activeSlashCommandExecutions.has(
+      this.slashCommandSessionKey(state.storageKey, stored.session.sessionId),
+    )) return 'Session already has an active slash command execution.';
+    if (stored.pendingReversion) return 'Session has a pending reversion operation.';
+    if (stored.session.agent !== undefined) {
+      return 'Subagent sessions can only be prompted through the foreground delegate tool.';
+    }
+    if (stored.outstandingPromptsById.size >= this.core.promptQueueLimits.maxOutstandingPromptsPerSession) {
+      return 'Session has reached its outstanding prompt limit.';
+    }
+    if (stored.outstandingPromptBytes + byteSize > this.core.promptQueueLimits.maxOutstandingBytesPerSession) {
+      return 'Session has reached its outstanding prompt byte limit.';
+    }
+    if (this.core.prompts.pendingPromptAdmissions >= this.core.promptQueueLimits.maxPendingAdmissions) {
+      return 'FlexHarness has reached its pending prompt admission limit.';
+    }
+    if (this.core.prompts.pendingPromptAdmissionBytes + byteSize > this.core.promptQueueLimits.maxPendingAdmissionBytes) {
+      return 'FlexHarness has reached its pending prompt admission byte limit.';
+    }
+    return undefined;
+  }
+
+  private slashCommandPromptAvailability(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    byteSize: number,
+  ): { available: boolean; unavailableReason?: string } {
+    const unavailableReason = this.slashCommandPromptUnavailableReason(state, stored, byteSize);
+    return unavailableReason === undefined
+      ? { available: true }
+      : { available: false, unavailableReason };
+  }
+
+  private requireSlashCommandPromptAvailable(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    commandName: string,
+    byteSize: number,
+  ): void {
+    const reason = this.slashCommandPromptUnavailableReason(state, stored, byteSize);
+    if (reason) throw new FlexHarnessSlashCommandUnavailableError(commandName, reason);
+  }
+
+  public slashCommandSessionKey(storageKey: string, sessionId: string): string {
+    return JSON.stringify([storageKey, sessionId]);
+  }
+
+  public requireSessionAvailableForSlashCommand(
+    state: IStorageState,
+    stored: IStoredSessionState,
+    commandName: string,
+  ): void {
+    if (!this.isSessionAvailableForSlashCommand(state, stored)) {
+      throw new FlexHarnessSlashCommandUnavailableError(
+        commandName,
+        slashCommandSessionUnavailableReason,
+      );
+    }
+  }
+
+  public trackSlashCommandExecution<TResult>(
+    scopeId: string,
+    state: IStorageState,
+    sessionId: string,
+    kind: IActiveSlashCommandExecution['kind'],
+    externalSignal: AbortSignal | undefined,
+    operation: (signal: AbortSignal) => Promise<TResult>,
+  ): Promise<TResult> {
+    const sessionKey = this.slashCommandSessionKey(state.storageKey, sessionId);
+    if (this.activeSlashCommandExecutions.has(sessionKey)) {
+      throw new FlexHarnessSessionBusyError(
+        sessionId,
+        'already has an active slash command execution',
+      );
+    }
+    const controller = new AbortController();
+    const abortFromExternalSignal = () => {
+      if (!controller.signal.aborted) {
+        controller.abort(this.core.trustInternalError(
+          new FlexHarnessAbortError('The slash command was aborted.'),
+        ));
+      }
+    };
+    externalSignal?.addEventListener('abort', abortFromExternalSignal, { once: true });
+    if (externalSignal?.aborted) abortFromExternalSignal();
+    const activityOwner = Object.freeze({ scopeId, storageKey: state.storageKey, sessionId });
+    const completion = Promise.resolve().then(() => this.slashCommandActivityContext.run(activityOwner, () => {
+      if (controller.signal.aborted) throw controller.signal.reason;
+      return operation(controller.signal);
+    }));
+    const active: IActiveSlashCommandExecution = {
+      kind,
+      storageKey: state.storageKey,
+      sessionId,
+      controller,
+      completion,
+    };
+    this.activeSlashCommandExecutions.set(sessionKey, active);
+    return completion.finally(() => {
+      externalSignal?.removeEventListener('abort', abortFromExternalSignal);
+      if (this.activeSlashCommandExecutions.get(sessionKey) === active) {
+        this.activeSlashCommandExecutions.delete(sessionKey);
+      }
+    });
+  }
+
+  private trackSlashCommandListing<TResult>(
+    scopeId: string,
+    state: IStorageState,
+    sessionId: string,
+    operation: (signal: AbortSignal) => Promise<TResult>,
+  ): Promise<TResult> {
+    const controller = new AbortController();
+    const activityOwner = Object.freeze({ scopeId, storageKey: state.storageKey, sessionId });
+    const completion = Promise.resolve().then(() =>
+      this.slashCommandActivityContext.run(activityOwner, () => operation(controller.signal)));
+    const active: IActiveSlashCommandListing = {
+      storageKey: state.storageKey,
+      sessionId,
+      controller,
+      completion,
+    };
+    this.activeSlashCommandListings.add(active);
+    return completion.finally(() => {
+      this.activeSlashCommandListings.delete(active);
+    });
+  }
+
+  private async executeSlashCommandHandler(
+    scopeId: string,
+    scope: TScope,
+    state: IStorageState,
+    stored: IStoredSessionState,
+    commandName: string,
+    rawArguments: string,
+    arguments_: readonly string[],
+    handler: IFlexSlashCommandHandlerRegistration<TScope>['handler'],
+    externalSignal?: AbortSignal,
+  ): Promise<TFlexSlashCommandExecutionResult> {
+    const sessionKey = this.slashCommandSessionKey(state.storageKey, stored.session.sessionId);
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner?.sessionKey === sessionKey) {
+      throw this.core.trustInternalError(
+        new FlexHarnessSlashCommandReentryError(stored.session.sessionId),
+      );
+    }
+    if (this.activeSlashCommandExecutions.has(sessionKey)) {
+      throw new FlexHarnessSessionBusyError(
+        stored.session.sessionId,
+        'already has an active slash command execution',
+      );
+    }
+    const owner = Object.freeze({
+      scopeId,
+      storageKey: state.storageKey,
+      sessionId: stored.session.sessionId,
+      sessionKey,
+    });
+    return this.trackSlashCommandExecution(
+      scopeId,
+      state,
+      stored.session.sessionId,
+      'handler',
+      externalSignal,
+      (signal) => this.slashCommandInvocationContext.run(owner, async () => {
+        const context = Object.freeze({
+          scopeId,
+          scope,
+          storageKey: state.storageKey,
+          sessionId: stored.session.sessionId,
+          ...requireSessionGeneration(stored.session),
+          rawArguments,
+          arguments: arguments_,
+          signal,
+        });
+        try {
+          await this.core.reversions.commitRevertedBranch(state, stored, scopeId, scope);
+          const result = await handler(context);
+          return Object.freeze({
+            type: 'handler-result' as const,
+            name: commandName,
+            result: normalizeJsonValue(result === undefined ? null : result, this.core.toolOutputLimits),
+          });
+        } catch (error) {
+          throw this.core.projectOperationError(
+            error,
+            'slashCommand',
+            scopeId,
+            stored.session.sessionId,
+            `slash-command:${commandName}`,
+          );
+        }
+      }),
+    );
+  }
+
+  public async abortSlashCommandExecutions(
+    storageKey: string | undefined,
+    reason: FlexHarnessAbortError,
+    errors: unknown[],
+    sessionId?: string,
+  ): Promise<void> {
+    const active = [...this.activeSlashCommandExecutions.values()]
+      .filter((execution) =>
+        (storageKey === undefined || execution.storageKey === storageKey)
+        && (sessionId === undefined || execution.sessionId === sessionId));
+    for (const execution of active) {
+      if (!execution.controller.signal.aborted) execution.controller.abort(reason);
+    }
+    const awaited = active.filter((execution) => execution.kind !== 'prompt-admission');
+    const results = await Promise.allSettled(awaited.map((execution) => execution.completion));
+    for (let index = 0; index < results.length; index++) {
+      const result = results[index];
+      if (result.status === 'rejected' && awaited[index].kind === 'handler') {
+        this.core.appendUnexpectedErrors(errors, result.reason);
+      }
+    }
+  }
+
+  public abortSlashCommandListings(
+    storageKey: string | undefined,
+    reason: FlexHarnessAbortError,
+    sessionId?: string,
+  ): Promise<void> | undefined {
+    const active = [...this.activeSlashCommandListings]
+      .filter((listing) =>
+        (storageKey === undefined || listing.storageKey === storageKey)
+        && (sessionId === undefined || listing.sessionId === sessionId));
+    if (active.length === 0) return undefined;
+    for (const listing of active) {
+      if (!listing.controller.signal.aborted) listing.controller.abort(reason);
+    }
+    return Promise.allSettled(active.map((listing) => listing.completion)).then(() => undefined);
+  }
+
+  public ambientSlashCommandOwner(
+    criteria: { scopeId?: string; storageKey?: string; sessionId?: string } = {},
+  ): ISlashCommandInvocationOwner | ISlashCommandActivityOwner | undefined {
+    const matches = (owner: ISlashCommandInvocationOwner | ISlashCommandActivityOwner) => (
+      (criteria.scopeId === undefined || owner.scopeId === criteria.scopeId)
+      && (criteria.storageKey === undefined || owner.storageKey === criteria.storageKey)
+      && (criteria.sessionId === undefined || owner.sessionId === criteria.sessionId)
+    );
+    const invocationOwner = this.slashCommandInvocationContext.getStore();
+    if (invocationOwner && matches(invocationOwner)) return invocationOwner;
+    const activityOwner = this.slashCommandActivityContext.getStore();
+    return activityOwner && matches(activityOwner) ? activityOwner : undefined;
+  }
+
+  public assertNoAmbientSlashCommandTeardown(
+    criteria: { scopeId?: string; storageKey?: string; sessionId?: string } = {},
+  ): void {
+    const owner = this.ambientSlashCommandOwner(criteria);
+    if (owner) {
+      throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(owner.sessionId));
+    }
+  }
+}