@modelprofile.com/flexharness 14.0.0 → 16.0.0

package/ts/classes.flexharness.runs.ts

@@ -16,7 +16,8 @@ import {
   type IFlexMessage,
   type IFlexPermissionRequestInput,
   type IFlexPromptOptions,
-  type IFlexPromptResult,
+  type IFlexContinuePromptResult,
+  type TFlexAgentPrompt,
   type IFlexResolvedModel,
   type IFlexRunFinishedEvent,
   type IFlexSession,
@@ -94,9 +95,7 @@ export class FlexHarnessRuns<TScope> {
     for (const steer of steers) {
       steering.input.add({
         inputId: steer.steerId,
-        content: cloneSerializable(steer.prompt.modelMessage.content) as Parameters<
-          plugins.IAgentSession['beginGeneration']
-        >[0],
+        content: cloneSerializable(steer.prompt.modelMessage.content) as TFlexAgentPrompt,
       });
       steering.accepted.set(steer.steerId, { prompt: steer.prompt, byteSize: steer.byteSize });
     }
@@ -123,7 +122,7 @@ export class FlexHarnessRuns<TScope> {
       sessionId: queued.sessionId,
       queueId: queued.queueId,
       runId: queued.runId!,
-      userMessageId: plugins.crypto.randomUUID(),
+      ...(queued.continuation ? { continuation: true as const } : { userMessageId: plugins.crypto.randomUUID() }),
       assistantMessageId: plugins.crypto.randomUUID(),
       controller: new AbortController(),
       ...(queued.scheduleKey === undefined
@@ -162,7 +161,7 @@ export class FlexHarnessRuns<TScope> {
   public async executeRun(
     run: IActiveRun,
     generation: Promise<plugins.IAgentGenerateResult>,
-  ): Promise<IFlexPromptResult> {
+  ): Promise<IFlexContinuePromptResult> {
     let generated = false;
     try {
       // The transactional generation settles only after its model calls are reported, so
@@ -186,7 +185,7 @@ export class FlexHarnessRuns<TScope> {
       if (!run.modelResolution) throw new FlexHarnessValidationError('Generation completed without a resolved model.');
       const closeReversion = await this.core.reversions.prepareRunReversionClose(run, 'completed');
       await this.core.admission.closeRunDelegatedRunAdmission(run);
-      const terminal = this.buildTerminal(run, 'completed', result);
+      let terminal = this.buildTerminal(run, 'completed', result);
       try {
         // The reversion segment closes in the save that stages the terminal.
         await this.core.mutateProjection(run.state, run.stored, () => {
@@ -209,6 +208,7 @@ export class FlexHarnessRuns<TScope> {
         throw projected;
       }
       run.steering.keptInContext = true;
+      terminal = this.withKeptInContext(terminal, true);
       this.core.reversions.refreshAutomaticArchiveHorizon(run.stored);
       run.phase = 'promoting';
       const closePublication = this.core.openPublication(run.state, run.sessionId);
@@ -235,7 +235,7 @@ export class FlexHarnessRuns<TScope> {
       return {
         runId: run.runId,
         sessionId: run.sessionId,
-        userMessage: publicSnapshot(terminal.userMessage),
+        ...(terminal.userMessage ? { userMessage: publicSnapshot(terminal.userMessage) } : {}),
         assistantMessage: publicSnapshot(terminal.assistantMessage),
         model: publicSnapshot(terminal.model!),
         usage: publicSnapshot(terminal.usage!),
@@ -351,7 +351,10 @@ export class FlexHarnessRuns<TScope> {
     const terminalError = publicStatus === 'cancelled'
       ? run.ownerCancellation ?? this.core.trustInternalError(new FlexHarnessAbortError())
       : safeError;
-    const terminal = this.buildTerminal(run, publicStatus, undefined, terminalError);
+    const terminal = this.withKeptInContext(
+      this.buildTerminal(run, publicStatus, undefined, terminalError),
+      run.steering.keptInContext === true,
+    );
     if (!this.core.isTombstoned(run)) {
       const closePublication = this.core.openPublication(run.state, run.sessionId);
       try {
@@ -564,6 +567,21 @@ export class FlexHarnessRuns<TScope> {
       } catch (error) {
         throw this.core.projectExternalError(run, error, 'toolProvider');
       }
+      const contextCompaction = run.stored.session.contextCompaction ?? this.core.agentSessionPolicy.contextCompaction;
+      if (run.metricsOperation) {
+        run.metricsOperation.contextCompaction = {
+          ...(model!.contextWindow === undefined ? {} : { contextWindow: model!.contextWindow }),
+          point: this.core.agentSessionPolicy.contextCompactor
+            ? plugins.resolveAgentContextCompactionPoint({
+                ...(model!.contextWindow === undefined ? {} : { contextWindow: model!.contextWindow }),
+                ...(model!.contextCompactionDefaultTokens === undefined
+                  ? {}
+                  : { contextCompactionDefaultTokens: model!.contextCompactionDefaultTokens }),
+                ...(contextCompaction === undefined ? {} : { setting: contextCompaction }),
+              })
+            : { off: 'no-compactor' },
+        };
+      }
       let closed = false;
       let closePromise: Promise<void> | undefined;
       const close = toolHandle?.close
@@ -596,6 +614,11 @@ export class FlexHarnessRuns<TScope> {
         ...(model!.cache === undefined ? {} : { cache: model!.cache }),
         ...(options.maxSteps ?? model!.maxSteps ? { maxSteps: options.maxSteps ?? model!.maxSteps } : {}),
         ...(run.cacheWarm ? { maxOutputTokens: this.core.cacheWarmOptions.maxOutputTokens } : {}),
+        ...(model!.contextWindow === undefined ? {} : { contextWindow: model!.contextWindow }),
+        ...(model!.contextCompactionDefaultTokens === undefined
+          ? {}
+          : { contextCompactionDefaultTokens: model!.contextCompactionDefaultTokens }),
+        ...(contextCompaction === undefined ? {} : { contextCompaction }),
         ...(close ? { close } : {}),
       };
     } catch (error) {
@@ -705,17 +728,19 @@ export class FlexHarnessRuns<TScope> {
 
   public createReservation(
     run: IActiveRun,
-    prompt: INormalizedFlexPrompt,
-  ): { userMessage: IFlexMessage; assistantMessage: IFlexMessage } {
+    prompt: INormalizedFlexPrompt | undefined,
+    promptId?: string,
+  ): { userMessage?: IFlexMessage; assistantMessage: IFlexMessage } {
     const timestamp = new Date().toISOString();
-    const userMessage: IFlexMessage = {
-      messageId: run.userMessageId,
+    const userMessage: IFlexMessage | undefined = prompt === undefined ? undefined : {
+      messageId: run.userMessageId!,
       sessionId: run.sessionId,
       runId: run.runId,
       role: 'user',
       status: 'streaming',
       createdAt: timestamp,
       parts: this.userMessageParts(prompt),
+      ...(promptId === undefined ? {} : { promptId }),
       ...(run.cacheWarm ? { cacheWarm: true as const } : {}),
     };
     const assistantMessage: IFlexMessage = {
@@ -728,7 +753,7 @@ export class FlexHarnessRuns<TScope> {
       parts: [],
       ...(run.cacheWarm ? { cacheWarm: true as const } : {}),
     };
-    return { userMessage, assistantMessage };
+    return { ...(userMessage ? { userMessage } : {}), assistantMessage };
   }
 
   private userMessageParts(prompt: INormalizedFlexPrompt): TFlexMessagePart[] {
@@ -889,11 +914,11 @@ export class FlexHarnessRuns<TScope> {
     error?: Error,
   ): IFlexTerminalProjection {
     const timestamp = new Date().toISOString();
-    const userMessage: IFlexMessage = cloneSerializable(
+    const userMessage = run.continuation ? undefined : cloneSerializable(
       run.reservedUserMessage
       ?? run.stored.messages.find((message) => message.messageId === run.userMessageId)
       ?? {
-        messageId: run.userMessageId,
+        messageId: run.userMessageId!,
         sessionId: run.sessionId,
         runId: run.runId,
         role: 'user',
@@ -931,11 +956,13 @@ export class FlexHarnessRuns<TScope> {
       }
     }
     if (run.cacheWarm) {
-      userMessage.cacheWarm = true;
+      if (userMessage) userMessage.cacheWarm = true;
       assistantMessage.cacheWarm = true;
     }
-    userMessage.status = status;
-    userMessage.completedAt = timestamp;
+    if (userMessage) {
+      userMessage.status = status;
+      userMessage.completedAt = timestamp;
+    }
     assistantMessage.status = status;
     assistantMessage.completedAt = timestamp;
     if (run.modelResolution) assistantMessage.model = cloneSerializable(run.modelResolution.identity);
@@ -958,6 +985,7 @@ export class FlexHarnessRuns<TScope> {
       // A failed turn fails its prompt too. A stopped turn is no fault of its prompt, so the prompt
       // stays an ordinary user message and only the answer it stopped carries the stop.
       for (const failedMessage of status === 'cancelled' ? [assistantMessage] : [userMessage, assistantMessage]) {
+        if (!failedMessage) continue;
         failedMessage.error = message;
         if (limit) failedMessage.limit = cloneSerializable(limit);
         if (rejectedPermissionId) failedMessage.rejectedPermissionId = rejectedPermissionId;
@@ -966,7 +994,7 @@ export class FlexHarnessRuns<TScope> {
     return {
       runId: run.runId,
       status,
-      userMessage,
+      ...(userMessage ? { userMessage } : {}),
       assistantMessage,
       ...(run.modelResolution ? { model: cloneSerializable(run.modelResolution.identity) } : {}),
       ...(status === 'completed' && result
@@ -1029,6 +1057,16 @@ export class FlexHarnessRuns<TScope> {
     }, true);
   }
 
+  /**
+   * The terminal with its prompt's `keptInContext`: whether the run's result kept the prompt and
+   * the steers it took in in the model context. `replaceVisibleRun()` writes it onto the steers.
+   */
+  public withKeptInContext(terminal: IFlexTerminalProjection, keptInContext: boolean): IFlexTerminalProjection {
+    return terminal.userMessage
+      ? { ...terminal, userMessage: { ...terminal.userMessage, keptInContext } }
+      : terminal;
+  }
+
   private replaceStagedTerminal(stored: IStoredSessionState, terminal: IFlexTerminalProjection): void {
     stored.stagedTerminals = stored.stagedTerminals.filter((entry) => entry.runId !== terminal.runId);
     stored.stagedTerminals.push(cloneSerializable(terminal));
@@ -1042,20 +1080,29 @@ export class FlexHarnessRuns<TScope> {
    */
   public replaceVisibleRun(stored: IStoredSessionState, terminal: IFlexTerminalProjection): void {
     const replacements = new Map([
-      [terminal.userMessage.messageId, terminal.userMessage],
+      ...(terminal.userMessage ? [[terminal.userMessage.messageId, terminal.userMessage] as const] : []),
       [terminal.assistantMessage.messageId, terminal.assistantMessage],
     ]);
     const placed = new Set<string>();
+    const keptInContext = terminal.userMessage?.keptInContext
+      ?? (terminal.status === 'completed'
+        || plugins.isGenerationInModelContext(stored.agentSession.getEvents(), terminal.runId));
     stored.messages = stored.messages.map((message) => {
       const replacement = message.runId === terminal.runId
         ? replacements.get(message.messageId)
         : undefined;
-      if (!replacement) return message;
+      if (!replacement) {
+        // The steers the run took in share its prompt's outcome.
+        return keptInContext !== undefined && message.runId === terminal.runId && message.role === 'user'
+          && message.keptInContext !== keptInContext
+          ? { ...cloneSerializable(message), keptInContext }
+          : message;
+      }
       placed.add(replacement.messageId);
       return cloneSerializable(replacement);
     });
     const firstIndex = stored.messages.findIndex((message) => message.runId === terminal.runId);
-    if (!placed.has(terminal.userMessage.messageId)) {
+    if (terminal.userMessage && !placed.has(terminal.userMessage.messageId)) {
       stored.messages.splice(
         firstIndex < 0 ? stored.messages.length : firstIndex,
         0,
@@ -1089,7 +1136,14 @@ export class FlexHarnessRuns<TScope> {
         this.core.emitPartEvent(run, 'part.completed', part);
       }
     }
-    for (const message of [terminal.userMessage, terminal.assistantMessage]) {
+    const retentionKnown = terminal.userMessage
+      ? terminal.userMessage.keptInContext !== undefined
+      : run.steering.keptInContext !== undefined;
+    const steerMessages = retentionKnown
+      ? run.stored.messages.filter((message) => message.runId === run.runId && message.steerId !== undefined)
+      : [];
+    for (const message of [terminal.userMessage, ...steerMessages, terminal.assistantMessage]) {
+      if (!message) continue;
       this.core.emitEvent(run.scopeId, run.stored.session, {
         type: 'message.updated',
         runId: run.runId,

package/ts/classes.flexharness.sessions.ts

@@ -11,6 +11,7 @@ import {
   type IFlexMessage,
   type IFlexMessagePage,
   type IFlexMessagePageOptions,
+  type IFlexMessageReadOptions,
   type IFlexSession,
   type IFlexSessionView,
   type IFlexSessionMetrics,
@@ -29,6 +30,7 @@ import {
   requireTransferIdentifier,
 } from './utils.transfer.js';
 import {
+  validateContextCompactionSetting,
   validateIdentifier,
   validateSessionGenerationId,
   validateSessionConfigurationRef,
@@ -51,6 +53,19 @@ import type { FlexHarnessCore } from './classes.flexharness.core.js';
 const maxSessionViewPasses = 64;
 
 /** Sessions and their messages: listing, creation, updates, views and message pages. */
+/** Validates transcript read options and states whether undone messages are included. */
+function readIncludeUndone(options: IFlexMessageReadOptions, name: string): boolean {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new FlexHarnessValidationError(`${name} must be a plain object.`);
+  }
+  const unsupported = Object.keys(options).find((key) => key !== 'includeUndone');
+  if (unsupported) throw new FlexHarnessValidationError(`${name} do not support "${unsupported}".`);
+  if (options.includeUndone !== undefined && typeof options.includeUndone !== 'boolean') {
+    throw new FlexHarnessValidationError('includeUndone must be a boolean.');
+  }
+  return options.includeUndone === true;
+}
+
 export class FlexHarnessSessions<TScope> {
   constructor(private readonly core: FlexHarnessCore<TScope>) {}
 
@@ -73,7 +88,7 @@ export class FlexHarnessSessions<TScope> {
       throw new FlexHarnessValidationError('createSession options must be a plain object.');
     }
     const unsupported = Object.keys(options).find(
-      (key) => !['sessionId', 'sessionGenerationId', 'configurationRef', 'title'].includes(key),
+      (key) => !['sessionId', 'sessionGenerationId', 'configurationRef', 'title', 'contextCompaction'].includes(key),
     );
     if (unsupported) throw new FlexHarnessValidationError(`createSession does not support "${unsupported}".`);
     const requestedSessionGenerationId = options.sessionGenerationId;
@@ -81,6 +96,12 @@ export class FlexHarnessSessions<TScope> {
       validateSessionGenerationId(requestedSessionGenerationId);
     }
     if (options.configurationRef !== undefined) validateSessionConfigurationRef(options.configurationRef);
+    if (options.contextCompaction !== undefined) {
+      validateContextCompactionSetting(
+        options.contextCompaction,
+        this.core.agentSessionPolicy.contextCompactor !== undefined,
+      );
+    }
     const resolved = await this.core.resolveState(scopeId);
     const sessionId = options.sessionId ?? plugins.crypto.randomUUID();
     validateIdentifier(sessionId, 'sessionId');
@@ -131,6 +152,9 @@ export class FlexHarnessSessions<TScope> {
           sessionGenerationSequence: resolved.state.revision + 1,
           ...(options.configurationRef === undefined ? {} : { configurationRef: options.configurationRef }),
           ...(options.title ? { title: options.title } : {}),
+          ...(options.contextCompaction === undefined
+            ? {}
+            : { contextCompaction: cloneSerializable(options.contextCompaction) }),
           createdAt: timestamp,
           updatedAt: timestamp,
           status: 'idle',
@@ -257,7 +281,7 @@ export class FlexHarnessSessions<TScope> {
     sessionId: string,
     options: IFlexUpdateSessionOptions,
   ): Promise<IFlexSession> {
-    validateUpdateSessionOptions(options);
+    validateUpdateSessionOptions(options, this.core.agentSessionPolicy.contextCompactor !== undefined);
     const { state } = await this.core.resolveState(scopeId);
     let result!: IFlexSession;
     await this.core.mutateScope(state, () => {
@@ -269,6 +293,10 @@ export class FlexHarnessSessions<TScope> {
         if (options.title === null) delete stored.session.title;
         else stored.session.title = options.title!;
       }
+      if (Object.prototype.hasOwnProperty.call(options, 'contextCompaction')) {
+        if (options.contextCompaction === null) delete stored.session.contextCompaction;
+        else stored.session.contextCompaction = cloneSerializable(options.contextCompaction!);
+      }
       if (options.archived === true) stored.session.archivedAt ??= timestamp;
       else if (options.archived === false) delete stored.session.archivedAt;
       stored.session.updatedAt = timestamp;
@@ -278,7 +306,12 @@ export class FlexHarnessSessions<TScope> {
     return result;
   }
 
-  public async getSessionView(scopeId: string, sessionId: string): Promise<IFlexSessionView> {
+  public async getSessionView(
+    scopeId: string,
+    sessionId: string,
+    options: IFlexMessageReadOptions = {},
+  ): Promise<IFlexSessionView> {
+    const includeUndone = readIncludeUndone(options, 'Session view options');
     const { state } = await this.core.resolveState(scopeId);
     let stored = this.core.requireSession(state, sessionId);
     for (let pass = 0; ; pass++) {
@@ -301,7 +334,7 @@ export class FlexHarnessSessions<TScope> {
       ) break;
     }
     const run = state.activeRuns.get(sessionId);
-    const messages = this.core.visibleMessages(stored).map((message) => (
+    const messages = this.core.transcriptMessages(stored, includeUndone).map((message) => (
       run && run.stored === stored && message.messageId === run.assistantMessageId
         && message.status === 'streaming'
         ? { ...message, parts: run.callbackParts }
@@ -318,12 +351,17 @@ export class FlexHarnessSessions<TScope> {
     });
   }
 
-  public async getMessages(scopeId: string, sessionId: string): Promise<IFlexMessage[]> {
+  public async getMessages(
+    scopeId: string,
+    sessionId: string,
+    options: IFlexMessageReadOptions = {},
+  ): Promise<IFlexMessage[]> {
+    const includeUndone = readIncludeUndone(options, 'Message read options');
     const { state } = await this.core.resolveState(scopeId);
     const stored = this.core.requireSession(state, sessionId);
     await stored.projectionQueue;
     this.core.assertStateAcceptingWork(state);
-    return publicSnapshot(this.core.visibleMessages(stored));
+    return publicSnapshot(this.core.transcriptMessages(stored, includeUndone));
   }
 
   public async listMessagePage(
@@ -334,8 +372,13 @@ export class FlexHarnessSessions<TScope> {
     if (!options || typeof options !== 'object' || Array.isArray(options)) {
       throw new FlexHarnessValidationError('Message page options must be a plain object.');
     }
-    const unsupported = Object.keys(options).find((key) => key !== 'limit' && key !== 'before');
+    const unsupported = Object.keys(options)
+      .find((key) => key !== 'limit' && key !== 'before' && key !== 'includeUndone');
     if (unsupported) throw new FlexHarnessValidationError(`Message page options do not support "${unsupported}".`);
+    if (options.includeUndone !== undefined && typeof options.includeUndone !== 'boolean') {
+      throw new FlexHarnessValidationError('includeUndone must be a boolean.');
+    }
+    const includeUndone = options.includeUndone === true;
     const limit = options.limit ?? maxMessagePageSize;
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > maxMessagePageSize) {
       throw new FlexHarnessValidationError(`Message page limit must be an integer from 1 through ${maxMessagePageSize}.`);
@@ -353,7 +396,7 @@ export class FlexHarnessSessions<TScope> {
     await stored.projectionQueue;
     this.core.assertStateAcceptingWork(state);
     const namespace = this.core.messageCursorNamespace(state.storageKey);
-    const visibleMessages = this.core.visibleMessages(stored);
+    const visibleMessages = this.core.transcriptMessages(stored, includeUndone);
     let end = visibleMessages.length;
     if (options.before !== undefined) {
       const cursor = this.core.parseMessageCursor(options.before);
@@ -394,14 +437,16 @@ export class FlexHarnessSessions<TScope> {
     scopeId: string,
     sessionId: string,
     messageId: string,
+    options: IFlexMessageReadOptions = {},
   ): Promise<IFlexMessage> {
+    const includeUndone = readIncludeUndone(options, 'Message read options');
     validateIdentifier(messageId, 'messageId');
     requireTransferIdentifier(messageId, 'messageId');
     const { state } = await this.core.resolveState(scopeId);
     const stored = this.core.requireSession(state, sessionId);
     await stored.projectionQueue;
     this.core.assertStateAcceptingWork(state);
-    return publicSnapshot(createBoundedTransferMessage(this.core.requireMessage(stored, messageId)));
+    return publicSnapshot(createBoundedTransferMessage(this.core.requireMessage(stored, messageId, includeUndone)));
   }
 
   public async pushRuntimeEvent(

package/ts/classes.flexharness.subagents.ts

@@ -13,6 +13,7 @@ import type {
   IFlexSteerAdmission,
   IFlexSteerInput,
   IFlexPromptAdmission,
+  IFlexContinuePromptResult,
   IFlexPromptOptions,
   IFlexSession,
   IFlexSubagentDefinition,
@@ -378,7 +379,7 @@ export class FlexHarnessSubagents<TScope> {
     let child: IStoredSessionState | undefined;
     let childCreated = false;
     let queued: Awaited<ReturnType<typeof this.core.prompts.enqueuePromptInternal>> | undefined;
-    let admission: IFlexPromptAdmission | undefined;
+    let admission: IFlexPromptAdmission<IFlexContinuePromptResult> | undefined;
     const abortChild = () => {
       const reason = delegatedCancellation(run.controller.signal.reason)
         ?? this.core.trustInternalError(new FlexHarnessAbortError('The parent run was aborted.'));

package/ts/classes.flexharness.ts

@@ -4,6 +4,8 @@ import type {
   IFlexCacheWarmInput,
   IFlexCacheWarmState,
   IFlexCompactSessionOptions,
+  IFlexContinuePromptOptions,
+  IFlexContinuePromptResult,
   IFlexCreateProjectTaskInput,
   IFlexCreateSessionOptions,
   IFlexDeleteSessionGenerationCohortInput,
@@ -15,6 +17,7 @@ import type {
   IFlexMessage,
   IFlexMessagePage,
   IFlexMessagePageOptions,
+  IFlexMessageReadOptions,
   IFlexPermissionRequest,
   IFlexProjectGoalResult,
   IFlexSteerAdmission,
@@ -246,12 +249,20 @@ export class FlexHarness<TScope = unknown> {
    * with the instance's event sequence they include. It waits until no queued projection or scope
    * write and no change that emits events for the session is in progress.
    */
-  public getSessionView(scopeId: string, sessionId: string): Promise<IFlexSessionView> {
-    return this.core.sessions.getSessionView(scopeId, sessionId);
+  public getSessionView(
+    scopeId: string,
+    sessionId: string,
+    options?: IFlexMessageReadOptions,
+  ): Promise<IFlexSessionView> {
+    return this.core.sessions.getSessionView(scopeId, sessionId, options);
   }
 
-  public getMessages(scopeId: string, sessionId: string): Promise<IFlexMessage[]> {
-    return this.core.sessions.getMessages(scopeId, sessionId);
+  public getMessages(
+    scopeId: string,
+    sessionId: string,
+    options?: IFlexMessageReadOptions,
+  ): Promise<IFlexMessage[]> {
+    return this.core.sessions.getMessages(scopeId, sessionId, options);
   }
 
   public listMessagePage(
@@ -266,8 +277,9 @@ export class FlexHarness<TScope = unknown> {
     scopeId: string,
     sessionId: string,
     messageId: string,
+    options?: IFlexMessageReadOptions,
   ): Promise<IFlexMessage> {
-    return this.core.sessions.getMessage(scopeId, sessionId, messageId);
+    return this.core.sessions.getMessage(scopeId, sessionId, messageId, options);
   }
 
   public listSlashCommands(
@@ -310,6 +322,14 @@ export class FlexHarness<TScope = unknown> {
     return this.core.prompts.prompt(scopeId, sessionId, prompt, options);
   }
 
+  public continuePrompt(
+    scopeId: string,
+    sessionId: string,
+    options: IFlexContinuePromptOptions = {},
+  ): Promise<IFlexPromptQueueAdmission<IFlexContinuePromptResult>> {
+    return this.core.prompts.continuePrompt(scopeId, sessionId, options);
+  }
+
   public startPrompt(
     scopeId: string,
     sessionId: string,

package/ts/errors.ts

@@ -68,6 +68,21 @@ export class FlexHarnessSteerRejectedError extends FlexHarnessError {
   }
 }
 
+/**
+ * A prompt names a `promptId` that an outstanding prompt of the same session, queued or running,
+ * already holds. A finished prompt's id is free again: its user message in the transcript shows
+ * that it ran.
+ */
+export class FlexHarnessDuplicatePromptError extends FlexHarnessError {
+  public readonly promptId: string;
+
+  constructor(promptId: string) {
+    super('FLEX_PROMPT_DUPLICATE', `Prompt "${promptId}" is already outstanding in this session.`);
+    this.name = 'FlexHarnessDuplicatePromptError';
+    this.promptId = promptId;
+  }
+}
+
 /** An operation would change the history or model context of an imported, read-only session. */
 export class FlexHarnessImportedSessionError extends FlexHarnessError {
   public readonly sessionId: string;

package/ts/index.ts

@@ -3,6 +3,12 @@ export * from './classes.stores.js';
 export { FlexToolCatalog } from './classes.toolcatalog.js';
 export * from './errors.js';
 export * from './interfaces.js';
+export {
+  AGENT_CONTEXT_COMPACTION_CEILING_PERCENT,
+  getAgentContextCompactionCeiling,
+  resolveAgentContextCompactionPoint,
+} from './plugins.js';
+export type { IAgentContextCompactionInput, TAgentContextCompactionPoint } from './plugins.js';
 export {
   createFlexToolPermissionRequester,
   type IFlexToolPermissionRequesterOptions,

package/ts/interfaces.flexharness.ts

@@ -15,7 +15,7 @@ import type {
   IFlexPromptAdmission,
   IFlexPromptQueueEntry,
   IFlexPromptOptions,
-  IFlexPromptResult,
+  IFlexContinuePromptResult,
   IFlexReversionSegment,
   IFlexPendingReversionRelease,
   IFlexResolvedModel,
@@ -88,7 +88,7 @@ export interface IStoredSessionState {
   permissionRevision: number;
   permissionQueue: Promise<void>;
   eventStore: plugins.IAgentEventStore;
-  agentSession: plugins.IAgentSession;
+  agentSession: plugins.IAgentContinuationSession;
   agentSessionAbortCompleted: boolean;
   agentSessionCloseCompleted: boolean;
   agentEventStoreReleased: boolean;
@@ -226,7 +226,8 @@ export interface IActiveRun {
   sessionId: string;
   queueId: string;
   runId: string;
-  userMessageId: string;
+  userMessageId?: string;
+  continuation?: true;
   assistantMessageId: string;
   controller: AbortController;
   transaction?: plugins.IAgentGenerationHandle;
@@ -292,7 +293,7 @@ export interface IActiveRun {
   permissionPolicy?: IFlexResolvedSessionConfiguration<unknown>['permissionPolicy'];
   delegatedRunAdmissionOwner?: IDelegatedRunAdmissionOwner;
   delegatedRunAdmissionClose?: Promise<void>;
-  completion: Promise<IFlexPromptResult>;
+  completion: Promise<IFlexContinuePromptResult>;
   steering: IRunSteering;
   /** Stops the run's generation for its owner, so what the model produced stays in context. */
   stop: AbortController;
@@ -412,7 +413,10 @@ export interface IQueuedPrompt {
   debounceMs?: number;
   /** A cache-warm prompt of the session's cache keeper; see `keepCacheWarm()`. */
   cacheWarm?: true;
+  /** The prompt's `promptId`; kept after its payload is released. */
+  promptId?: string;
   startedAt?: string;
+  continuation?: true;
   prompt?: INormalizedFlexPrompt;
   options?: IFlexPromptOptions;
   delegationSeed?: IDelegatedRunAdmissionSeed;
@@ -424,11 +428,11 @@ export interface IQueuedPrompt {
   steering?: IRunSteering;
   /** The steers admitted with the prompt, in their given order. */
   admittedSteerIds?: readonly string[];
-  completion: Promise<IFlexPromptResult>;
-  resolveCompletion: (result: IFlexPromptResult) => void;
+  completion: Promise<IFlexContinuePromptResult>;
+  resolveCompletion: (result: IFlexContinuePromptResult) => void;
   rejectCompletion: (error: unknown) => void;
-  started: Promise<IFlexPromptAdmission>;
-  resolveStarted: (admission: IFlexPromptAdmission) => void;
+  started: Promise<IFlexPromptAdmission<IFlexContinuePromptResult>>;
+  resolveStarted: (admission: IFlexPromptAdmission<IFlexContinuePromptResult>) => void;
   rejectStarted: (error: unknown) => void;
 }