@modelprofile.com/flexharness 14.0.0 → 16.0.0

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,
@@ -728,8 +728,10 @@ export class FlexHarnessCore<TScope> {
           delete stored.metrics.pendingCompactionId;
         });
       }
+      // The compaction setting reaches each generation on its lease, with its model's window.
       const {
         contextCompactor,
+        contextCompaction: _contextCompaction,
         ...agentSessionPolicy
       } = this.agentSessionPolicy;
       const executionContext = executionContextHandle?.context;
@@ -959,7 +961,8 @@ export class FlexHarnessCore<TScope> {
       await this.reversions.drainReversionReleases(state, stored, scopeId, scope, false);
       this.assertStateAcceptingWork(state);
     }
-    const outcomes = this.canonicalOutcomes(stored.agentSession.getEvents());
+    const agentEvents = stored.agentSession.getEvents();
+    const outcomes = this.canonicalOutcomes(agentEvents);
     const firstHiddenCandidate = this.reversions.completedReversionCandidates(stored)[stored.revertCursor];
     const reversionVisibilityBoundary = firstHiddenCandidate
       ? stored.reversionSegments.findIndex((segment) => segment.runId === firstHiddenCandidate.runId)
@@ -975,8 +978,8 @@ export class FlexHarnessCore<TScope> {
       const outcome = outcomes.get(runId);
       const stage = stages.get(runId);
       if (outcome === 'accepted' && stage?.status === 'completed') {
-        this.runs.replaceVisibleRun(stored, stage);
-        if (!stage.userMessage.cacheWarm) latestTerminal = stage;
+        this.runs.replaceVisibleRun(stored, this.runs.withKeptInContext(stage, true));
+        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
@@ -985,13 +988,21 @@ export class FlexHarnessCore<TScope> {
           ? stage
           : stage ? undefined : this.publishedTerminal(runId, visible);
         if (ended) {
-          if (ended === stage) this.runs.replaceVisibleRun(stored, stage);
-          if (!ended.userMessage.cacheWarm) latestTerminal = ended;
+          if (ended === stage) {
+            this.runs.replaceVisibleRun(stored, this.runs.withKeptInContext(
+              stage,
+              plugins.isGenerationInModelContext(agentEvents, runId),
+            ));
+          }
+          if (!ended.assistantMessage.cacheWarm) latestTerminal = ended;
         } else if (visible.length > 0 || stage) {
           const status = outcome === 'rejected' ? 'failed' : 'cancelled';
-          const terminal = this.repairTerminal(stored.session.sessionId, runId, visible, stage, status);
+          const terminal = this.runs.withKeptInContext(
+            this.repairTerminal(stored.session.sessionId, runId, visible, stage, status),
+            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) =>
@@ -1004,7 +1015,7 @@ export class FlexHarnessCore<TScope> {
             undefined,
             'completed',
           );
-          if (!terminal.userMessage.cacheWarm) latestTerminal = terminal;
+          if (!terminal.assistantMessage.cacheWarm) latestTerminal = terminal;
         }
       }
     }
@@ -1109,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 } : {}),
@@ -1136,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,
@@ -1154,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') {
@@ -1172,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);
@@ -1183,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 } : {}),
@@ -1747,12 +1750,28 @@ export class FlexHarnessCore<TScope> {
   }
 
   public visibleMessages(stored: IStoredSessionState): IFlexMessage[] {
-    const firstHiddenSegment = this.reversions.reversionGroups(stored)[stored.revertCursor]?.segments[0];
-    if (!firstHiddenSegment) return stored.messages;
-    const boundary = stored.messages.findIndex((message) => message.runId === firstHiddenSegment.runId);
+    const boundary = this.undoneBoundary(stored);
     return boundary < 0 ? stored.messages : stored.messages.slice(0, boundary);
   }
 
+  /**
+   * The transcript: the visible messages, and with `includeUndone` the messages of undone turns
+   * after them, each marked `undone: true`.
+   */
+  public transcriptMessages(stored: IStoredSessionState, includeUndone: boolean): IFlexMessage[] {
+    if (!includeUndone) return this.visibleMessages(stored);
+    const boundary = this.undoneBoundary(stored);
+    if (boundary < 0) return stored.messages;
+    return stored.messages.map((message, index) => index < boundary ? message : { ...message, undone: true });
+  }
+
+  /** The index of the first message of an undone turn, or -1 when no turn is undone. */
+  private undoneBoundary(stored: IStoredSessionState): number {
+    const firstHiddenSegment = this.reversions.reversionGroups(stored)[stored.revertCursor]?.segments[0];
+    if (!firstHiddenSegment) return -1;
+    return stored.messages.findIndex((message) => message.runId === firstHiddenSegment.runId);
+  }
+
   public requireMutableSession(state: IStorageState, sessionId: string): IStoredSessionState {
     const stored = this.requireSession(state, sessionId);
     const pending = [...state.pendingPermissions.values()].some((entry) =>
@@ -1789,8 +1808,8 @@ export class FlexHarnessCore<TScope> {
     }
   }
 
-  public requireMessage(stored: IStoredSessionState, messageId: string): IFlexMessage {
-    const message = this.visibleMessages(stored).find((entry) => entry.messageId === messageId);
+  public requireMessage(stored: IStoredSessionState, messageId: string, includeUndone = false): IFlexMessage {
+    const message = this.transcriptMessages(stored, includeUndone).find((entry) => entry.messageId === messageId);
     if (!message) throw new FlexHarnessNotFoundError('Message', messageId);
     return message;
   }

package/ts/classes.flexharness.prompts.ts

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
 import {
   FlexHarnessAbortError,
+  FlexHarnessDuplicatePromptError,
   FlexHarnessNotFoundError,
   FlexHarnessQueueFullError,
   FlexHarnessSessionBusyError,
@@ -12,6 +13,8 @@ import {
 } from './errors.js';
 import type {
   IFlexAgentContextInvocation,
+  IFlexContinuePromptOptions,
+  IFlexContinuePromptResult,
   IFlexEnqueuePromptOptions,
   IFlexSteerAdmission,
   IFlexSteerInput,
@@ -23,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';
@@ -70,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,
@@ -99,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,
@@ -119,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,
@@ -165,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,
@@ -330,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) {
@@ -354,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,
@@ -367,12 +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();
-    const normalizedPrompt = normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols);
+    if (options.promptId !== undefined) requireTransferIdentifier(options.promptId, 'promptId');
+    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);
@@ -459,16 +508,22 @@ export class FlexHarnessPromptQueue<TScope> {
       ) {
         throw new FlexHarnessSessionBusyError(sessionId, `already has scheduled key "${scheduleKey}"`);
       }
-      let resolveCompletion!: (result: IFlexPromptResult) => void;
+      if (
+        options.promptId !== undefined
+        && [...stored.outstandingPromptsById.values()].some((entry) => entry.promptId === options.promptId)
+      ) {
+        throw new FlexHarnessDuplicatePromptError(options.promptId);
+      }
+      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;
       });
@@ -485,7 +540,8 @@ export class FlexHarnessPromptQueue<TScope> {
         queuedAt: new Date().toISOString(),
         ...(scheduleKey === undefined ? {} : { scheduleKey, debounceMs }),
         ...(cacheWarm ? { cacheWarm: true as const } : {}),
-        prompt: normalizedPrompt,
+        ...(options.promptId === undefined ? {} : { promptId: options.promptId }),
+        ...(normalizedPrompt === undefined ? { continuation: true as const } : { prompt: normalizedPrompt }),
         options: normalizedOptions,
         ...(delegationSeed === undefined ? {} : { delegationSeed }),
         byteSize,
@@ -508,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 {
@@ -616,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.
@@ -627,21 +708,21 @@ 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);
+        const reservation = this.core.runs.createReservation(run, prompt, queued.promptId);
         closeReservationPublication = this.core.openPublication(run.state, run.sessionId);
         run.metricsOperation = createSessionMetricsOperation(run.runId, 'generation');
         await this.core.mutateProjection(run.state, run.stored, () => {
@@ -649,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);
@@ -659,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: [],
@@ -681,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, () => {
@@ -698,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;
         });
@@ -742,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,
@@ -818,6 +901,8 @@ export class FlexHarnessPromptQueue<TScope> {
       status: queued.status,
       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 } : {}),
@@ -851,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;