@modelprofile.com/flexharness 15.0.0 → 16.0.0

package/readme.md

@@ -498,7 +498,7 @@ Sending requires the exact active parent run, its currently delegated direct chi
 
 Before creating or resuming a child, FlexHarness requests permission on the parent run with `kind: 'subagent.start'`, the parent `toolCallId`, and separately bounded harness-owned agent/task metadata. Its metadata includes `childSessionId`, the exact ID reserved for this call: FlexHarness derives it deterministically when `taskId` is omitted and copies the supplied candidate when `taskId` is present. A resume also retains that candidate as `taskId`. This block is not truncated by `toolOutputLimits`. The reserved ID binds permission handling before child creation but does not prove that the child exists or is owned: applications must treat the later delegated admission context as authoritative. The controller answers through the normal permission APIs. This request has no `rememberKey`, so `always` is invalid; controllers use `once` or `reject`.
 
-Each new invocation creates a durable child `IFlexSession` with immutable `parentSessionId`, origin `parentRunId`, origin `parentToolCallId`, `agent`, and `depth`. New public roots persist `depth: 0`; legacy schema-1 roots may omit it. These fields are harness-owned; public `createSession()` accepts `sessionId`, `sessionGenerationId`, `configurationRef`, and `title`. A child inherits its parent's `configurationRef` and cannot resume under a different reference. Child sessions reject direct `prompt()`, `startPrompt()`, `enqueuePrompt()`, and `schedulePrompt()` calls and run only through the `delegate` tool. The model and tool resolver contexts receive optional immutable `parentSessionId` and `agent` values so integrations can apply agent-specific model and tool policy. Child prompts use the definition's `modelHint`, `system`, and `maxSteps`.
+Each new invocation creates a durable child `IFlexSession` with immutable `parentSessionId`, origin `parentRunId`, origin `parentToolCallId`, `agent`, and `depth`. New public roots persist `depth: 0`; legacy schema-1 roots may omit it. These fields are harness-owned; public `createSession()` accepts `sessionId`, `sessionGenerationId`, `configurationRef`, and `title`. A child inherits its parent's `configurationRef` and cannot resume under a different reference. Child sessions reject direct `continuePrompt()`, `prompt()`, `startPrompt()`, `enqueuePrompt()`, and `schedulePrompt()` calls and run only through the `delegate` tool. The model and tool resolver contexts receive optional immutable `parentSessionId` and `agent` values so integrations can apply agent-specific model and tool policy. Child prompts use the definition's `modelHint`, `system`, and `maxSteps`.
 
 The parent tool part receives `childSessionId` as soon as the child is acquired, so a host can offer an authorized live transcript. A foreground call also adds the resolved child model to its part and returns bounded JSON:
 
@@ -717,6 +717,55 @@ The reservation save is the admission point. A save failure produces no start ev
 
 `abort()` returns `true` only while cancellation is still accepted. Terminal persistence is the run's commit point; once it starts, `abort()` returns `false` and the already-fixed terminal outcome completes while the session remains busy.
 
+### Continuing Without New Input
+
+Use `continuePrompt()` after a failed or stopped run whose input remains in context
+(`keptInContext: true`), when the conversation still needs an answer:
+
+```typescript
+const continuation = await harness.continuePrompt(scopeId, sessionId, {
+  modelHint: 'available-model',
+});
+console.log(continuation.queueId);
+const result = await continuation.completion;
+console.log(result.assistantMessage.parts);
+```
+
+The signature is `continuePrompt(scopeId: string, sessionId: string,
+options?: IFlexContinuePromptOptions): Promise<IFlexPromptQueueAdmission<IFlexContinuePromptResult>>`.
+It accepts `modelHint`, `system`, `maxSteps` and initial `steers`, plus optional
+`scheduleKey` and `debounceMs` for the same scheduling behavior as `schedulePrompt()`.
+`debounceMs` requires a schedule key and defaults to 50 ms when scheduled. There is
+no `prompt` or `promptId`: continuation creates a new run and an assistant message
+without appending or modifying a user message. Its result has the prompt result's
+fields except `userMessage`. Explicit steers still become user messages normally.
+
+Admission returns `{ queueId, completion }` once queued, like `enqueuePrompt()`.
+The entry and its `prompt.*` events carry `continuation: true`. Inspect its `runId`
+after `prompt.started`, or read it through `getPromptQueueEntry()`. Use the same
+`cancelPrompt()`, `cancelScheduledPrompt()`, `abort()` and `steerPrompt()` methods.
+Queue bounds and FIFO order, permissions, resource cleanup, compaction, usage
+accounting and provider limits follow the ordinary run path.
+
+At the front of the FIFO, the harness validates the visible transcript and model
+context with undone and excluded runs filtered out, before committing an undone
+branch or reserving a generation or audit message. A refusal preserves redo history.
+Empty context, an already answered turn, and an unsuccessful input that did not stay
+in context refuse with `FlexHarnessValidationError` through `completion`. A retained
+failure whose model context ends in partial assistant text with no tool call is also
+refused; `keptInContext: true` alone does not guarantee it can be continued. An earlier
+queued answer can therefore invalidate a waiting continuation. Cancellation before
+execution leaves the retained input available for another continuation. Continuing never replays
+previous tool calls; unknown external effects still require reconciliation.
+
+Existing projections and Agent event stores remain readable without migration.
+Assistant-only runs require two optional fields in the existing schema-3 projection:
+a staged terminal omits `userMessage`, and its reversion segment omits
+`userMessageId`. Requiring either would invent a user message. Generation claims
+use existing events without a new `user-message` event. Older strict projection
+readers cannot open a session containing these continuation records; do not mix
+versions or downgrade those sessions.
+
 ### Steering a Running Turn
 
 `steerPrompt()` hands a message to the running run of a prompt instead of queueing it behind that run:
@@ -1010,7 +1059,7 @@ if (started.status === 'started') {
 
 **Read-only.** An imported session never runs, and nothing writes model context for it: it has no Agent events and no tool jobs. Every operation that would change its history or model context throws `FlexHarnessImportedSessionError` (code `FLEX_SESSION_READ_ONLY`):
 
-- `prompt`, `startPrompt`, `enqueuePrompt` and `schedulePrompt`;
+- `prompt`, `startPrompt`, `enqueuePrompt`, `schedulePrompt` and `continuePrompt`;
 - `executeSlashCommand` and `compactSession`;
 - `undoSession` and `redoSession`;
 - `pushRuntimeEvent`, `reconcileToolExecution` and `archiveSessionEvents`;

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '15.0.0',
+  version: '16.0.0',
   description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 }

package/ts/classes.flexharness.cachewarm.ts

@@ -8,7 +8,7 @@ import {
 import type {
   IFlexCacheWarmInput,
   IFlexCacheWarmState,
-  IFlexPromptResult,
+  IFlexContinuePromptResult,
   IFlexSession,
 } from './interfaces.js';
 import type {
@@ -236,7 +236,7 @@ export class FlexHarnessCacheWarm<TScope> {
     queued: IQueuedPrompt,
     status: 'completed' | 'failed' | 'cancelled',
     error?: unknown,
-    result?: IFlexPromptResult,
+    result?: IFlexContinuePromptResult,
   ): void {
     const entry = this.entries.get(this.key(queued.state.storageKey, queued.sessionId));
     if (queued.cacheWarm && status === 'completed' && result) {

package/ts/classes.flexharness.core.ts

@@ -542,7 +542,7 @@ export class FlexHarnessCore<TScope> {
     storageKey: string,
     compactorLifecycleController = new AbortController(),
   ): IStoredSessionState {
-    const unavailable = new Proxy({} as plugins.IAgentSession, {
+    const unavailable = new Proxy({} as plugins.IAgentContinuationSession, {
       get() {
         throw new Error('AgentSession is not initialized.');
       },
@@ -699,7 +699,7 @@ export class FlexHarnessCore<TScope> {
         permissionRevision: permission?.revision ?? 0,
         permissionQueue: Promise.resolve(),
         eventStore,
-        agentSession: undefined as unknown as plugins.IAgentSession,
+        agentSession: undefined as unknown as plugins.IAgentContinuationSession,
         agentSessionAbortCompleted: false,
         agentSessionCloseCompleted: false,
         agentEventStoreReleased: this.stores.agentEvents.releaseSession === undefined,
@@ -979,7 +979,7 @@ export class FlexHarnessCore<TScope> {
       const stage = stages.get(runId);
       if (outcome === 'accepted' && stage?.status === 'completed') {
         this.runs.replaceVisibleRun(stored, this.runs.withKeptInContext(stage, true));
-        if (!stage.userMessage.cacheWarm) latestTerminal = stage;
+        if (!stage.assistantMessage.cacheWarm) latestTerminal = stage;
       } else if (outcome !== 'accepted') {
         const visible = stored.messages.filter((message) => message.runId === runId);
         // A run that failed or was stopped keeps its terminal and its error: the staged one, or the
@@ -994,7 +994,7 @@ export class FlexHarnessCore<TScope> {
               plugins.isGenerationInModelContext(agentEvents, runId),
             ));
           }
-          if (!ended.userMessage.cacheWarm) latestTerminal = ended;
+          if (!ended.assistantMessage.cacheWarm) latestTerminal = ended;
         } else if (visible.length > 0 || stage) {
           const status = outcome === 'rejected' ? 'failed' : 'cancelled';
           const terminal = this.runs.withKeptInContext(
@@ -1002,7 +1002,7 @@ export class FlexHarnessCore<TScope> {
             plugins.isGenerationInModelContext(agentEvents, runId),
           );
           this.runs.replaceVisibleRun(stored, terminal);
-          if (!terminal.userMessage.cacheWarm) latestTerminal = terminal;
+          if (!terminal.assistantMessage.cacheWarm) latestTerminal = terminal;
         }
       } else {
         const visibleSuccess = stored.messages.some((message) =>
@@ -1015,7 +1015,7 @@ export class FlexHarnessCore<TScope> {
             undefined,
             'completed',
           );
-          if (!terminal.userMessage.cacheWarm) latestTerminal = terminal;
+          if (!terminal.assistantMessage.cacheWarm) latestTerminal = terminal;
         }
       }
     }
@@ -1120,13 +1120,13 @@ export class FlexHarnessCore<TScope> {
     if (visible.some((message) => message.status === 'streaming')) return undefined;
     const userMessage = visible.find((message) => message.role === 'user' && message.steerId === undefined);
     const assistantMessage = [...visible].reverse().find((message) => message.role === 'assistant');
-    if (!userMessage || !assistantMessage) return undefined;
+    if (!assistantMessage) return undefined;
     const status = assistantMessage.status;
     if (status !== 'failed' && status !== 'cancelled') return undefined;
     return {
       runId,
       status,
-      userMessage,
+      ...(userMessage ? { userMessage } : {}),
       assistantMessage,
       ...(assistantMessage.model ? { model: assistantMessage.model } : {}),
       ...(assistantMessage.usage ? { usage: assistantMessage.usage } : {}),
@@ -1147,15 +1147,7 @@ export class FlexHarnessCore<TScope> {
       ?? visible.find((message) => message.role === 'user' && message.steerId === undefined);
     const sourceAssistant = stage?.assistantMessage
       ?? [...visible].reverse().find((message) => message.role === 'assistant');
-    const userMessage: IFlexMessage = cloneSerializable(sourceUser ?? {
-      messageId: plugins.crypto.randomUUID(),
-      sessionId,
-      runId,
-      role: 'user',
-      status,
-      createdAt: timestamp,
-      parts: [],
-    });
+    const userMessage = sourceUser ? cloneSerializable(sourceUser) : undefined;
     const assistantMessage: IFlexMessage = cloneSerializable(sourceAssistant ?? {
       messageId: plugins.crypto.randomUUID(),
       sessionId,
@@ -1165,9 +1157,9 @@ export class FlexHarnessCore<TScope> {
       createdAt: timestamp,
       parts: [],
     });
-    userMessage.status = status;
+    if (userMessage) userMessage.status = status;
     assistantMessage.status = status;
-    userMessage.completedAt ??= timestamp;
+    if (userMessage) userMessage.completedAt ??= timestamp;
     assistantMessage.completedAt ??= timestamp;
     for (const part of assistantMessage.parts) {
       if (part.type === 'reasoning' && part.status === 'running') {
@@ -1183,7 +1175,7 @@ export class FlexHarnessCore<TScope> {
     if (status !== 'completed') {
       const message = status === 'cancelled' ? repairCancellationMessage : externalErrorFallback.message;
       // As for a run that ends live: a failed run marks its prompt too, a cancelled one only its answer.
-      if (status === 'failed') userMessage.error = message;
+      if (status === 'failed' && userMessage) userMessage.error = message;
       assistantMessage.error = message;
       if (stage?.usage) {
         assistantMessage.usage = cloneSerializable(stage.usage);
@@ -1194,7 +1186,7 @@ export class FlexHarnessCore<TScope> {
     return {
       runId,
       status,
-      userMessage,
+      ...(userMessage ? { userMessage } : {}),
       assistantMessage,
       ...(status === 'completed' && stage?.model ? { model: stage.model } : {}),
       ...(stage?.usage ? { usage: stage.usage } : {}),

package/ts/classes.flexharness.prompts.ts

@@ -13,6 +13,8 @@ import {
 } from './errors.js';
 import type {
   IFlexAgentContextInvocation,
+  IFlexContinuePromptOptions,
+  IFlexContinuePromptResult,
   IFlexEnqueuePromptOptions,
   IFlexSteerAdmission,
   IFlexSteerInput,
@@ -24,6 +26,7 @@ import type {
   IFlexScheduledPromptAdmission,
   IFlexSchedulePromptOptions,
   TFlexPrompt,
+  TFlexAgentPrompt,
 } from './interfaces.js';
 import { cloneSerializable } from './utils.json.js';
 import { normalizeFlexPrompt, type INormalizedFlexPrompt } from './utils.prompt.js';
@@ -71,13 +74,15 @@ export class FlexHarnessPromptQueue<TScope> {
   constructor(private readonly core: FlexHarnessCore<TScope>) {}
 
   public promptAdmissionByteSize(
-    prompt: TFlexPrompt,
+    prompt: TFlexPrompt | undefined,
     options: IFlexPromptOptions,
     scheduleKey?: string,
     debounceMs?: number,
   ): number {
     return jsonBytes({
-      prompt: normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols),
+      ...(prompt === undefined
+        ? {}
+        : { prompt: normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols) }),
       options: cloneSerializable(options),
       scheduleKey,
       debounceMs,
@@ -100,12 +105,52 @@ export class FlexHarnessPromptQueue<TScope> {
     return admission.completion;
   }
 
+  public async continuePrompt(
+    scopeId: string,
+    sessionId: string,
+    options: IFlexContinuePromptOptions = {},
+  ): Promise<IFlexPromptQueueAdmission<IFlexContinuePromptResult>> {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+      throw new FlexHarnessValidationError('Continuation options must be a plain object.');
+    }
+    const { scheduleKey, debounceMs, ...enqueueOptions } = options;
+    if ('promptId' in enqueueOptions) {
+      throw new FlexHarnessValidationError('A continuation has no new prompt to identify.');
+    }
+    const admitted = this.splitEnqueueOptions(enqueueOptions);
+    if (scheduleKey === undefined && debounceMs !== undefined) {
+      throw new FlexHarnessValidationError('debounceMs requires scheduleKey.');
+    }
+    if (scheduleKey !== undefined) {
+      validateIdentifier(scheduleKey, 'scheduleKey');
+      requireTransferIdentifier(scheduleKey, 'scheduleKey');
+      this.validateScheduleDebounce(debounceMs ?? 50);
+    }
+    const queued = await this.enqueuePromptInternal(
+      scopeId, sessionId, undefined, admitted.options,
+      scheduleKey, scheduleKey === undefined ? undefined : debounceMs ?? 50,
+      undefined, undefined, false, false, admitted.steers,
+    );
+    return queued.admission;
+  }
+
+  private validateScheduleDebounce(debounceMs: number): void {
+    if (!Number.isSafeInteger(debounceMs) || debounceMs < 0 || debounceMs > maxScheduleDebounceMs) {
+      throw new FlexHarnessValidationError(
+        `debounceMs must be an integer from 0 through ${maxScheduleDebounceMs}.`,
+      );
+    }
+  }
+
   public async startPrompt(
     scopeId: string,
     sessionId: string,
     prompt: TFlexPrompt,
     options: IFlexEnqueuePromptOptions = {},
   ): Promise<IFlexPromptAdmission> {
+    if (prompt === undefined) {
+      throw new FlexHarnessValidationError('prompt must be a string or a non-empty array of parts.');
+    }
     const admitted = this.splitEnqueueOptions(options);
     const queued = await this.enqueuePromptInternal(
       scopeId, sessionId, prompt, admitted.options,
@@ -120,6 +165,9 @@ export class FlexHarnessPromptQueue<TScope> {
     prompt: TFlexPrompt,
     options: IFlexEnqueuePromptOptions = {},
   ): Promise<IFlexPromptQueueAdmission> {
+    if (prompt === undefined) {
+      throw new FlexHarnessValidationError('prompt must be a string or a non-empty array of parts.');
+    }
     const admitted = this.splitEnqueueOptions(options);
     const queued = await this.enqueuePromptInternal(
       scopeId, sessionId, prompt, admitted.options,
@@ -166,15 +214,14 @@ export class FlexHarnessPromptQueue<TScope> {
     prompt: TFlexPrompt,
     options: IFlexSchedulePromptOptions = {},
   ): Promise<IFlexScheduledPromptAdmission> {
+    if (prompt === undefined) {
+      throw new FlexHarnessValidationError('prompt must be a string or a non-empty array of parts.');
+    }
     validateIdentifier(scheduleKey, 'scheduleKey');
     requireTransferIdentifier(scheduleKey, 'scheduleKey');
     validatePromptOptions(options, true);
     const debounceMs = options.debounceMs ?? 50;
-    if (!Number.isSafeInteger(debounceMs) || debounceMs < 0 || debounceMs > maxScheduleDebounceMs) {
-      throw new FlexHarnessValidationError(
-        `debounceMs must be an integer from 0 through ${maxScheduleDebounceMs}.`,
-      );
-    }
+    this.validateScheduleDebounce(debounceMs);
     const queued = await this.enqueuePromptInternal(
       scopeId,
       sessionId,
@@ -331,9 +378,7 @@ export class FlexHarnessPromptQueue<TScope> {
     try {
       steering.input.add({
         inputId: steer.steerId,
-        content: cloneSerializable(prompt.modelMessage.content) as Parameters<
-          plugins.IAgentSession['beginGeneration']
-        >[0],
+        content: cloneSerializable(prompt.modelMessage.content) as TFlexAgentPrompt,
       });
     } catch (error) {
       if (error instanceof plugins.AgentPendingInputRejectedError) {
@@ -355,10 +400,10 @@ export class FlexHarnessPromptQueue<TScope> {
     return { steerId: steer.steerId, queueId: run.queueId, runId: run.runId };
   }
 
-  public async enqueuePromptInternal(
+  public async enqueuePromptInternal<TPrompt extends TFlexPrompt | undefined>(
     scopeId: string,
     sessionId: string,
-    prompt: TFlexPrompt,
+    prompt: TPrompt,
     options: IFlexPromptOptions,
     scheduleKey?: string,
     debounceMs?: number,
@@ -368,13 +413,15 @@ export class FlexHarnessPromptQueue<TScope> {
     cacheWarm = false,
     steers: readonly IAdmittedSteer[] = [],
   ): Promise<{
-    admission: IFlexPromptQueueAdmission;
-    started: Promise<IFlexPromptAdmission>;
+    admission: IFlexPromptQueueAdmission<TPrompt extends undefined ? IFlexContinuePromptResult : IFlexPromptResult>;
+    started: Promise<IFlexPromptAdmission<TPrompt extends undefined ? IFlexContinuePromptResult : IFlexPromptResult>>;
     queued?: IQueuedPrompt;
   }> {
     this.core.assertOpen();
     if (options.promptId !== undefined) requireTransferIdentifier(options.promptId, 'promptId');
-    const normalizedPrompt = normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols);
+    const normalizedPrompt = prompt === undefined
+      ? undefined
+      : normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols);
     const normalizedOptions = cloneSerializable(options);
     const byteSize = this.promptAdmissionByteSize(prompt, options, scheduleKey, debounceMs);
     const steerBytes = steers.reduce((sum, steer) => sum + steer.byteSize, 0);
@@ -467,16 +514,16 @@ export class FlexHarnessPromptQueue<TScope> {
       ) {
         throw new FlexHarnessDuplicatePromptError(options.promptId);
       }
-      let resolveCompletion!: (result: IFlexPromptResult) => void;
+      let resolveCompletion!: (result: IFlexContinuePromptResult) => void;
       let rejectCompletion!: (error: unknown) => void;
-      const completion = new Promise<IFlexPromptResult>((resolve, reject) => {
+      const completion = new Promise<IFlexContinuePromptResult>((resolve, reject) => {
         resolveCompletion = resolve;
         rejectCompletion = reject;
       });
       void completion.catch(() => undefined);
-      let resolveStarted!: (admission: IFlexPromptAdmission) => void;
+      let resolveStarted!: (admission: IFlexPromptAdmission<IFlexContinuePromptResult>) => void;
       let rejectStarted!: (error: unknown) => void;
-      const started = new Promise<IFlexPromptAdmission>((resolve, reject) => {
+      const started = new Promise<IFlexPromptAdmission<IFlexContinuePromptResult>>((resolve, reject) => {
         resolveStarted = resolve;
         rejectStarted = reject;
       });
@@ -494,7 +541,7 @@ export class FlexHarnessPromptQueue<TScope> {
         ...(scheduleKey === undefined ? {} : { scheduleKey, debounceMs }),
         ...(cacheWarm ? { cacheWarm: true as const } : {}),
         ...(options.promptId === undefined ? {} : { promptId: options.promptId }),
-        prompt: normalizedPrompt,
+        ...(normalizedPrompt === undefined ? { continuation: true as const } : { prompt: normalizedPrompt }),
         options: normalizedOptions,
         ...(delegationSeed === undefined ? {} : { delegationSeed }),
         byteSize,
@@ -517,8 +564,13 @@ export class FlexHarnessPromptQueue<TScope> {
       this.emitPromptQueueEvent(queued, 'prompt.queued');
       this.schedulePromptQueueDrain(state, stored);
       return {
-        admission: Object.freeze({ queueId: queued.queueId, completion }),
-        started,
+        // The input determines whether the completed run has a user message.
+        admission: Object.freeze({ queueId: queued.queueId, completion }) as IFlexPromptQueueAdmission<
+          TPrompt extends undefined ? IFlexContinuePromptResult : IFlexPromptResult
+        >,
+        started: started as Promise<IFlexPromptAdmission<
+          TPrompt extends undefined ? IFlexContinuePromptResult : IFlexPromptResult
+        >>,
         queued,
       };
     } finally {
@@ -625,8 +677,28 @@ export class FlexHarnessPromptQueue<TScope> {
     }
   }
 
+  /** Check the actual model context at the FIFO boundary, before any durable run claim. */
+  private assertContinuableContext(stored: IStoredSessionState): void {
+    const visibleEvents = this.core.reversions.filterReversionContextEvents(stored, stored.agentSession.getEvents());
+    const retainedRunIds = new Set(plugins.filterModelVisibleAgentEvents(visibleEvents)
+      .map((event) => event.generationId));
+    const lastTurnMessage = [...this.core.visibleMessages(stored)].reverse().find((message) =>
+      !message.cacheWarm && (message.status === 'completed'
+        || message.keptInContext === true || retainedRunIds.has(message.runId)));
+    // A summary or runtime update can look like a user message even after a completed answer.
+    const answered = !lastTurnMessage || (lastTurnMessage.role === 'assistant'
+      && lastTurnMessage.status === 'completed');
+    const last = answered ? undefined : stored.agentSession.getModelMessages().at(-1);
+    if (last?.role === 'user' || last?.role === 'tool') return;
+    if (last?.role === 'assistant' && Array.isArray(last.content)
+      && last.content.some((part) => part.type === 'tool-call')) return;
+    throw this.core.trustInternalError(new FlexHarnessValidationError(
+      'The conversation has no unanswered turn to continue.',
+    ));
+  }
+
   private async promoteQueuedPrompt(queued: IQueuedPrompt, run: IActiveRun): Promise<void> {
-    const prompt = queued.prompt!;
+    const prompt = queued.prompt;
     const options = queued.options!;
     let projectionReserved = false;
     // Open from the reservation until its messages are announced or rolled back.
@@ -636,18 +708,18 @@ export class FlexHarnessPromptQueue<TScope> {
         this.assertPromptPromotion(queued, run);
         await this.core.admission.acquireDelegatedRunAdmission(queued, run);
         this.assertPromptPromotion(queued, run);
+        if (queued.continuation) this.assertContinuableContext(run.stored);
         await this.core.reversions.commitRevertedBranch(run.state, run.stored, run.scopeId, run.scope as TScope);
         this.assertPromptPromotion(queued, run);
-        const generationPrompt = cloneSerializable(prompt.modelMessage.content) as Parameters<
-          plugins.IAgentSession['beginGeneration']
-        >[0];
+        const generationPrompt = prompt === undefined
+          ? undefined
+          : cloneSerializable(prompt.modelMessage.content) as TFlexAgentPrompt;
         this.assertPromptPromotion(queued, run);
         run.transaction = await this.core.compaction.withRunCompactorContext(
           run,
-          () => run.stored.agentSession.beginGeneration(
-            generationPrompt,
-            { generationId: run.runId },
-          ),
+          () => generationPrompt === undefined
+            ? run.stored.agentSession.beginContinuation({ generationId: run.runId })
+            : run.stored.agentSession.beginGeneration(generationPrompt, { generationId: run.runId }),
         );
         this.assertPromptPromotion(queued, run);
         const reservation = this.core.runs.createReservation(run, prompt, queued.promptId);
@@ -658,7 +730,8 @@ export class FlexHarnessPromptQueue<TScope> {
             throw new Error('Session metrics already owns a generation.');
           }
           run.stored.metrics.pendingGenerationId = run.runId;
-          run.stored.messages.push(reservation.userMessage, reservation.assistantMessage);
+          if (reservation.userMessage) run.stored.messages.push(reservation.userMessage);
+          run.stored.messages.push(reservation.assistantMessage);
           // A cache-warm turn is no turn of the user's: it gets no reversion segment of its own.
           if (run.stored.session.agent === undefined && !run.cacheWarm) {
             this.core.reversions.pruneReversionState(run.stored, true);
@@ -668,7 +741,7 @@ export class FlexHarnessPromptQueue<TScope> {
             const protocolVersion = this.core.reversions.reversionProviderProtocolVersion() ?? 1;
             run.stored.reversionSegments.push({
               runId: run.runId,
-              userMessageId: reservation.userMessage.messageId,
+              ...(reservation.userMessage ? { userMessageId: reservation.userMessage.messageId } : {}),
               status: 'capturing',
               contextAvailable: true,
               eventIds: [],
@@ -690,7 +763,7 @@ export class FlexHarnessPromptQueue<TScope> {
           }
         });
         projectionReserved = true;
-        run.reservedUserMessage = publicSnapshot(reservation.userMessage);
+        if (reservation.userMessage) run.reservedUserMessage = publicSnapshot(reservation.userMessage);
         run.reservedAssistantMessage = publicSnapshot(reservation.assistantMessage);
         this.assertPromptPromotion(queued, run);
         await this.core.mutateScope(run.state, () => {
@@ -707,9 +780,9 @@ export class FlexHarnessPromptQueue<TScope> {
           run.stored.session.activity = {
             runId: run.runId,
             status: run.scheduleKey ? 'scheduled' : 'running',
-            startedAt: reservation.userMessage.createdAt,
+            startedAt: reservation.assistantMessage.createdAt,
           };
-          run.stored.session.updatedAt = reservation.userMessage.createdAt;
+          run.stored.session.updatedAt = reservation.assistantMessage.createdAt;
           const preview = run.stored.session.preview ?? sessionPreview(run.stored.messages);
           if (preview !== undefined) run.stored.session.preview = preview;
         });
@@ -751,11 +824,12 @@ export class FlexHarnessPromptQueue<TScope> {
       this.core.emitEvent(run.scopeId, run.stored.session, {
         type: runType,
         runId: run.runId,
-        messageId: run.userMessageId,
+        messageId: run.userMessageId ?? run.assistantMessageId,
         session: publicSnapshot(run.stored.session),
         ...(run.cacheWarm ? { cacheWarm: true } : {}),
       });
-      for (const message of [run.reservedUserMessage!, run.reservedAssistantMessage!]) {
+      for (const message of [run.reservedUserMessage, run.reservedAssistantMessage!]) {
+        if (!message) continue;
         this.core.emitEvent(run.scopeId, run.stored.session, {
           type: 'message.created',
           runId: run.runId,
@@ -828,6 +902,7 @@ export class FlexHarnessPromptQueue<TScope> {
       queuedAt: queued.queuedAt,
       ...(queued.runId ? { runId: queued.runId } : {}),
       ...(queued.promptId === undefined ? {} : { promptId: queued.promptId }),
+      ...(queued.continuation ? { continuation: true as const } : {}),
       ...(queued.scheduleKey ? { scheduleKey: queued.scheduleKey } : {}),
       ...(queued.cacheWarm ? { cacheWarm: true } : {}),
       ...(queued.startedAt ? { startedAt: queued.startedAt } : {}),
@@ -861,7 +936,7 @@ export class FlexHarnessPromptQueue<TScope> {
     queued: IQueuedPrompt,
     status: 'completed' | 'failed' | 'cancelled',
     error?: unknown,
-    result?: IFlexPromptResult,
+    result?: IFlexContinuePromptResult,
   ): void {
     const stored = queued.stored;
     if (stored.outstandingPromptsById.get(queued.queueId) !== queued) return;