@modelprofile.com/flexharness 13.2.0 → 13.3.0

package/ts/classes.flexharness.core.ts

@@ -969,32 +969,42 @@ export class FlexHarnessCore<TScope> {
       ...stored.messages.map((message) => message.runId),
       ...stored.stagedTerminals.map((terminal) => terminal.runId),
     ]);
+    // The session's state is the latest real turn's: a cache-warm turn's terminal never sets it.
     let latestTerminal: IFlexTerminalProjection | undefined;
     for (const runId of runIds) {
       const outcome = outcomes.get(runId);
       const stage = stages.get(runId);
       if (outcome === 'accepted' && stage?.status === 'completed') {
         this.runs.replaceVisibleRun(stored, stage);
-        latestTerminal = stage;
+        if (!stage.userMessage.cacheWarm) latestTerminal = stage;
       } else if (outcome !== 'accepted') {
         const visible = stored.messages.filter((message) => message.runId === runId);
-        if (visible.length > 0 || stage) {
+        // A run that failed or was stopped keeps its terminal and its error: the staged one, or the
+        // one it published. Only a run that never reached its terminal is repaired as interrupted.
+        const ended = stage && stage.status !== 'completed'
+          ? stage
+          : stage ? undefined : this.publishedTerminal(runId, visible);
+        if (ended) {
+          if (ended === stage) this.runs.replaceVisibleRun(stored, stage);
+          if (!ended.userMessage.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);
           this.runs.replaceVisibleRun(stored, terminal);
-          latestTerminal = terminal;
+          if (!terminal.userMessage.cacheWarm) latestTerminal = terminal;
         }
       } else {
         const visibleSuccess = stored.messages.some((message) =>
           message.runId === runId && message.status === 'completed');
         if (visibleSuccess) {
-          latestTerminal = this.repairTerminal(
+          const terminal = this.repairTerminal(
             stored.session.sessionId,
             runId,
             stored.messages.filter((message) => message.runId === runId),
             undefined,
             'completed',
           );
+          if (!terminal.userMessage.cacheWarm) latestTerminal = terminal;
         }
       }
     }
@@ -1033,17 +1043,22 @@ export class FlexHarnessCore<TScope> {
       }
       await this.reversions.recoverPendingCapture(state, stored, scopeId, scope, outcomes);
     }
+    // FlexHarness 13.2.0 marked a warm turn's activity with `cacheWarm`; no activity carries it now.
+    delete (stored.session.activity as { cacheWarm?: true }).cacheWarm;
     if (latestTerminal) {
       const completedAt = latestTerminal.assistantMessage.completedAt ?? new Date().toISOString();
+      const startedAt = stored.session.activity.runId === latestTerminal.runId
+        ? stored.session.activity.startedAt
+        : undefined;
       stored.session.status = latestTerminal.status === 'completed' ? 'idle' : latestTerminal.status;
       stored.session.activity = {
         runId: latestTerminal.runId,
         status: latestTerminal.status === 'completed' ? 'idle' : latestTerminal.status,
+        ...(startedAt === undefined ? {} : { startedAt }),
         completedAt,
         ...terminalActivityError(latestTerminal.assistantMessage),
-        ...(latestTerminal.userMessage.cacheWarm ? { cacheWarm: true as const } : {}),
       };
-      if (!latestTerminal.userMessage.cacheWarm) stored.session.updatedAt = completedAt;
+      stored.session.updatedAt = completedAt;
     } else if (['scheduled', 'running', 'waiting_permission'].includes(stored.session.status)) {
       const timestamp = new Date().toISOString();
       stored.session.status = 'cancelled';
@@ -1083,6 +1098,30 @@ export class FlexHarnessCore<TScope> {
     return beforeSession !== JSON.stringify(stored.session);
   }
 
+  /**
+   * The failed or cancelled terminal a run published, read from its projected messages. A run
+   * still running has its prompt or its last assistant message streaming; it has none.
+   */
+  private publishedTerminal(
+    runId: string,
+    visible: IFlexMessage[],
+  ): IFlexTerminalProjection | undefined {
+    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;
+    const status = assistantMessage.status;
+    if (status !== 'failed' && status !== 'cancelled') return undefined;
+    return {
+      runId,
+      status,
+      userMessage,
+      assistantMessage,
+      ...(assistantMessage.model ? { model: assistantMessage.model } : {}),
+      ...(assistantMessage.usage ? { usage: assistantMessage.usage } : {}),
+    };
+  }
+
   private repairTerminal(
     sessionId: string,
     runId: string,

package/ts/classes.flexharness.prompts.ts

@@ -12,6 +12,7 @@ import {
 } from './errors.js';
 import type {
   IFlexAgentContextInvocation,
+  IFlexEnqueuePromptOptions,
   IFlexSteerAdmission,
   IFlexSteerInput,
   IFlexPromptAdmission,
@@ -35,6 +36,7 @@ import type {
   IDelegatedRunAdmissionSeed,
   IQueuedPrompt,
   IPendingPromptAdmission,
+  IAdmittedSteer,
 } from './interfaces.flexharness.js';
 import { combineErrors, isAbortError } from './utils.flexharness.js';
 import { sessionPreview } from './utils.sessionpreview.js';
@@ -91,7 +93,7 @@ export class FlexHarnessPromptQueue<TScope> {
     scopeId: string,
     sessionId: string,
     prompt: TFlexPrompt,
-    options: IFlexPromptOptions = {},
+    options: IFlexEnqueuePromptOptions = {},
   ): Promise<IFlexPromptResult> {
     const admission = await this.startPrompt(scopeId, sessionId, prompt, options);
     return admission.completion;
@@ -101,10 +103,13 @@ export class FlexHarnessPromptQueue<TScope> {
     scopeId: string,
     sessionId: string,
     prompt: TFlexPrompt,
-    options: IFlexPromptOptions = {},
+    options: IFlexEnqueuePromptOptions = {},
   ): Promise<IFlexPromptAdmission> {
-    validatePromptOptions(options, false);
-    const queued = await this.enqueuePromptInternal(scopeId, sessionId, prompt, options);
+    const admitted = this.splitEnqueueOptions(options);
+    const queued = await this.enqueuePromptInternal(
+      scopeId, sessionId, prompt, admitted.options,
+      undefined, undefined, undefined, undefined, false, false, admitted.steers,
+    );
     return queued.started;
   }
 
@@ -112,13 +117,47 @@ export class FlexHarnessPromptQueue<TScope> {
     scopeId: string,
     sessionId: string,
     prompt: TFlexPrompt,
-    options: IFlexPromptOptions = {},
+    options: IFlexEnqueuePromptOptions = {},
   ): Promise<IFlexPromptQueueAdmission> {
-    validatePromptOptions(options, false);
-    const queued = await this.enqueuePromptInternal(scopeId, sessionId, prompt, options);
+    const admitted = this.splitEnqueueOptions(options);
+    const queued = await this.enqueuePromptInternal(
+      scopeId, sessionId, prompt, admitted.options,
+      undefined, undefined, undefined, undefined, false, false, admitted.steers,
+    );
     return queued.admission;
   }
 
+  /** Validates the options of a prompt and the steers that join its run, in their given order. */
+  private splitEnqueueOptions(
+    options: IFlexEnqueuePromptOptions,
+  ): { options: IFlexPromptOptions; steers: IAdmittedSteer[] } {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+      throw new FlexHarnessValidationError('Prompt options must be a plain object.');
+    }
+    const { steers, ...promptOptions } = options;
+    validatePromptOptions(promptOptions, false);
+    if (steers === undefined) return { options: promptOptions, steers: [] };
+    if (!Array.isArray(steers)) throw new FlexHarnessValidationError('steers must be an array.');
+    const steerIds = new Set<string>();
+    const admitted = steers.map((steer): IAdmittedSteer => {
+      if (!steer || typeof steer !== 'object' || Array.isArray(steer)) {
+        throw new FlexHarnessValidationError('Each steer must be a plain object.');
+      }
+      validateIdentifier(steer.steerId, 'steerId');
+      requireTransferIdentifier(steer.steerId, 'steerId');
+      if (steerIds.has(steer.steerId)) {
+        throw new FlexHarnessValidationError(`Steer "${steer.steerId}" is given more than once.`);
+      }
+      steerIds.add(steer.steerId);
+      return {
+        steerId: steer.steerId,
+        prompt: normalizeFlexPrompt(steer.prompt, this.core.attachmentReferenceProtocols),
+        byteSize: this.promptAdmissionByteSize(steer.prompt, {}),
+      };
+    });
+    return { options: promptOptions, steers: admitted };
+  }
+
   public async schedulePrompt(
     scopeId: string,
     sessionId: string,
@@ -326,6 +365,7 @@ export class FlexHarnessPromptQueue<TScope> {
     admissionSignal?: AbortSignal,
     slashCommandAdmission = false,
     cacheWarm = false,
+    steers: readonly IAdmittedSteer[] = [],
   ): Promise<{
     admission: IFlexPromptQueueAdmission;
     started: Promise<IFlexPromptAdmission>;
@@ -335,7 +375,8 @@ export class FlexHarnessPromptQueue<TScope> {
     const normalizedPrompt = normalizeFlexPrompt(prompt, this.core.attachmentReferenceProtocols);
     const normalizedOptions = cloneSerializable(options);
     const byteSize = this.promptAdmissionByteSize(prompt, options, scheduleKey, debounceMs);
-    const releasePendingAdmission = this.reservePendingPromptAdmission(byteSize);
+    const steerBytes = steers.reduce((sum, steer) => sum + steer.byteSize, 0);
+    const releasePendingAdmission = this.reservePendingPromptAdmission(byteSize + steerBytes);
     let resolveSettled!: () => void;
     const pendingOwner: IPendingPromptAdmission = {
       controller: new AbortController(),
@@ -400,8 +441,11 @@ export class FlexHarnessPromptQueue<TScope> {
           `Session "${sessionId}" has reached its outstanding prompt limit.`,
         );
       }
+      if (steers.length > this.core.promptQueueLimits.maxOutstandingPromptsPerSession) {
+        throw new FlexHarnessQueueFullError(`Session "${sessionId}" has reached its pending steer limit.`);
+      }
       if (
-        stored.outstandingPromptBytes + byteSize
+        stored.outstandingPromptBytes + byteSize + steerBytes
         > this.core.promptQueueLimits.maxOutstandingBytesPerSession
       ) {
         throw new FlexHarnessQueueFullError(
@@ -452,9 +496,14 @@ export class FlexHarnessPromptQueue<TScope> {
         resolveStarted,
         rejectStarted,
       };
+      if (steers.length > 0) {
+        // The steers are the run's from admission on: a prompt that never runs reports them unapplied.
+        queued.steering = this.core.runs.createRunSteering(stored, steers);
+        queued.admittedSteerIds = steers.map((steer) => steer.steerId);
+      }
       stored.promptQueue.push(queued);
       stored.outstandingPromptsById.set(queued.queueId, queued);
-      stored.outstandingPromptBytes += byteSize;
+      stored.outstandingPromptBytes += byteSize + steerBytes;
       if (!cacheWarm) this.core.cacheWarm.onActivity(state.storageKey, sessionId);
       this.emitPromptQueueEvent(queued, 'prompt.queued');
       this.schedulePromptQueueDrain(state, stored);
@@ -642,18 +691,18 @@ export class FlexHarnessPromptQueue<TScope> {
           if (run.state.tombstones.has(run.sessionId) || run.state.sessions.get(run.sessionId) !== run.stored) {
             throw new FlexHarnessAbortError('The session was deleted during prompt admission.');
           }
+          // A cache-warm turn leaves the session's status, activity, updatedAt and preview as the
+          // last real turn left them; the active run alone keeps the session busy.
+          if (run.cacheWarm) return;
           run.stored.session.status = run.scheduleKey ? 'scheduled' : 'running';
           run.stored.session.activity = {
             runId: run.runId,
             status: run.scheduleKey ? 'scheduled' : 'running',
             startedAt: reservation.userMessage.createdAt,
-            ...(run.cacheWarm ? { cacheWarm: true as const } : {}),
           };
-          if (!run.cacheWarm) {
-            run.stored.session.updatedAt = reservation.userMessage.createdAt;
-            const preview = run.stored.session.preview ?? sessionPreview(run.stored.messages);
-            if (preview !== undefined) run.stored.session.preview = preview;
-          }
+          run.stored.session.updatedAt = reservation.userMessage.createdAt;
+          const preview = run.stored.session.preview ?? sessionPreview(run.stored.messages);
+          if (preview !== undefined) run.stored.session.preview = preview;
         });
       } catch (error) {
         if (containsStoreCommitUncertainty(error)) run.state.lifecycle = 'fenced';
@@ -712,6 +761,14 @@ export class FlexHarnessPromptQueue<TScope> {
     queued.status = run.scheduleKey ? 'scheduled' : 'starting';
     this.core.cacheWarm.onRunStarted(run, queued);
     this.emitPromptQueueEvent(queued, 'prompt.started');
+    for (const steerId of queued.admittedSteerIds ?? []) {
+      this.core.emitEvent(run.scopeId, run.stored.session, {
+        type: 'prompt.steer.accepted',
+        queueId: run.queueId,
+        runId: run.runId,
+        steerId,
+      });
+    }
     queued.resolveStarted(Object.freeze({
       queueId: queued.queueId,
       runId: run.runId,

package/ts/classes.flexharness.runs.ts

@@ -46,6 +46,7 @@ import type {
   IStoredSessionState,
   IStorageState,
   IActiveRun,
+  IAdmittedSteer,
   IRunSteering,
   IRunSteeringOutcome,
   IQueuedPrompt,
@@ -76,13 +77,34 @@ export class FlexHarnessRuns<TScope> {
     return true;
   }
 
-  public createActiveRun(queued: IQueuedPrompt): IActiveRun {
+  /**
+   * The steering of a run, holding `steers` as accepted and waiting for its first step boundary.
+   * The caller already counted their bytes against the session.
+   */
+  public createRunSteering(
+    stored: IStoredSessionState,
+    steers: readonly IAdmittedSteer[] = [],
+  ): IRunSteering {
     const steering: IRunSteering = {
       input: new plugins.AgentPendingInputQueue(),
-      stored: queued.stored,
+      stored,
       accepted: new Map(),
       applied: new Set(),
     };
+    for (const steer of steers) {
+      steering.input.add({
+        inputId: steer.steerId,
+        content: cloneSerializable(steer.prompt.modelMessage.content) as Parameters<
+          plugins.IAgentSession['beginGeneration']
+        >[0],
+      });
+      steering.accepted.set(steer.steerId, { prompt: steer.prompt, byteSize: steer.byteSize });
+    }
+    return steering;
+  }
+
+  public createActiveRun(queued: IQueuedPrompt): IActiveRun {
+    const steering = queued.steering ?? this.createRunSteering(queued.stored);
     queued.steering = steering;
     return {
       steering,
@@ -965,7 +987,7 @@ export class FlexHarnessRuns<TScope> {
       this.replaceVisibleRun(run.stored, terminal);
       run.stored.stagedTerminals = run.stored.stagedTerminals.filter((entry) => entry.runId !== run.runId);
     }, true);
-    if (!this.core.isTombstoned(run)) {
+    if (!this.core.isTombstoned(run) && !run.cacheWarm) {
       await this.core.mutateScope(run.state, () => {
         if (run.state.sessions.get(run.sessionId) !== run.stored) return;
         const timestamp = terminal.assistantMessage.completedAt!;
@@ -975,9 +997,8 @@ export class FlexHarnessRuns<TScope> {
           status: 'idle',
           startedAt: run.stored.session.activity.startedAt,
           completedAt: timestamp,
-          ...(run.cacheWarm ? { cacheWarm: true as const } : {}),
         };
-        if (!run.cacheWarm) run.stored.session.updatedAt = timestamp;
+        run.stored.session.updatedAt = timestamp;
       }, true);
     }
   }
@@ -990,6 +1011,8 @@ export class FlexHarnessRuns<TScope> {
       this.replaceVisibleRun(run.stored, terminal);
       run.stored.stagedTerminals = run.stored.stagedTerminals.filter((entry) => entry.runId !== run.runId);
     }, true);
+    // A failed cache-warm turn reports through `cache.warm.stopped`; the session keeps its state.
+    if (run.cacheWarm) return;
     await this.core.mutateScope(run.state, () => {
       if (run.state.sessions.get(run.sessionId) !== run.stored) return;
       const timestamp = terminal.assistantMessage.completedAt!;
@@ -1001,9 +1024,8 @@ export class FlexHarnessRuns<TScope> {
         startedAt: run.stored.session.activity.startedAt,
         completedAt: timestamp,
         ...terminalActivityError(terminal.assistantMessage),
-        ...(run.cacheWarm ? { cacheWarm: true as const } : {}),
       };
-      if (!run.cacheWarm) run.stored.session.updatedAt = timestamp;
+      run.stored.session.updatedAt = timestamp;
     }, true);
   }
 

package/ts/classes.flexharness.ts

@@ -8,6 +8,7 @@ import type {
   IFlexCreateSessionOptions,
   IFlexDeleteSessionGenerationCohortInput,
   IFlexDeleteSessionGenerationCohortResult,
+  IFlexEnqueuePromptOptions,
   IFlexEventArchiveMetadata,
   IFlexHarnessOptions,
   IFlexImportedRun,
@@ -25,7 +26,6 @@ import type {
   IFlexPromptAdmission,
   IFlexPromptQueueAdmission,
   IFlexPromptQueueEntry,
-  IFlexPromptOptions,
   IFlexPromptResult,
   IFlexRedoSessionResult,
   IFlexScheduledPromptAdmission,
@@ -305,7 +305,7 @@ export class FlexHarness<TScope = unknown> {
     scopeId: string,
     sessionId: string,
     prompt: TFlexPrompt,
-    options?: IFlexPromptOptions,
+    options?: IFlexEnqueuePromptOptions,
   ): Promise<IFlexPromptResult> {
     return this.core.prompts.prompt(scopeId, sessionId, prompt, options);
   }
@@ -314,7 +314,7 @@ export class FlexHarness<TScope = unknown> {
     scopeId: string,
     sessionId: string,
     prompt: TFlexPrompt,
-    options?: IFlexPromptOptions,
+    options?: IFlexEnqueuePromptOptions,
   ): Promise<IFlexPromptAdmission> {
     return this.core.prompts.startPrompt(scopeId, sessionId, prompt, options);
   }
@@ -323,7 +323,7 @@ export class FlexHarness<TScope = unknown> {
     scopeId: string,
     sessionId: string,
     prompt: TFlexPrompt,
-    options?: IFlexPromptOptions,
+    options?: IFlexEnqueuePromptOptions,
   ): Promise<IFlexPromptQueueAdmission> {
     return this.core.prompts.enqueuePrompt(scopeId, sessionId, prompt, options);
   }

package/ts/interfaces.flexharness.ts

@@ -337,6 +337,13 @@ export interface IRunSteering {
   outcome?: IRunSteeringOutcome;
 }
 
+/** A steer admitted together with the prompt whose run takes it in before its first model call. */
+export interface IAdmittedSteer {
+  readonly steerId: string;
+  readonly prompt: INormalizedFlexPrompt;
+  readonly byteSize: number;
+}
+
 export interface IRunSteeringOutcome {
   /** Whether the run's prompt, the steers it took in and what its model produced stay in context. */
   readonly keptInContext: boolean;
@@ -410,8 +417,13 @@ export interface IQueuedPrompt {
   options?: IFlexPromptOptions;
   delegationSeed?: IDelegatedRunAdmissionSeed;
   byteSize: number;
-  /** The steering of the run the prompt started, once it started one. */
+  /**
+   * The steering of the run the prompt started, once it started one. A prompt admitted with steers
+   * has it from admission on, holding those steers and their bytes.
+   */
   steering?: IRunSteering;
+  /** The steers admitted with the prompt, in their given order. */
+  admittedSteerIds?: readonly string[];
   completion: Promise<IFlexPromptResult>;
   resolveCompletion: (result: IFlexPromptResult) => void;
   rejectCompletion: (error: unknown) => void;

package/ts/interfaces.ts

@@ -239,8 +239,6 @@ export interface IFlexSessionActivity {
   limit?: TFlexModelLimit;
   /** The permission whose rejection stopped the last run, next to its error. */
   rejectedPermissionId?: string;
-  /** The run is or was a cache-warm turn; see {@link IFlexMessage.cacheWarm}. */
-  cacheWarm?: true;
 }
 
 export interface IFlexSession {
@@ -590,6 +588,19 @@ export interface IFlexSchedulePromptOptions extends IFlexPromptOptions {
   debounceMs?: number;
 }
 
+/**
+ * Options of a prompt that starts a run now or queues it. `steers` are further user messages that
+ * join the prompt's run in the order given: the run accepts them when it starts and its generation
+ * takes them in before its first model call, each as a user message of its own carrying its
+ * `steerId`. They count against the session's outstanding prompt limits from admission on, and
+ * report like every other steer of the run: `prompt.steer.applied` names each message, and
+ * `unappliedSteerIds` names the ones the model context of later turns does not hold, also when the
+ * prompt is cancelled before its run started.
+ */
+export interface IFlexEnqueuePromptOptions extends IFlexPromptOptions {
+  steers?: readonly IFlexSteerInput[];
+}
+
 export interface IFlexScheduledPromptAdmission extends IFlexPromptAdmission {
   scheduleKey: string;
 }

package/ts/readme.md

@@ -730,6 +730,8 @@ The run takes a steer in at its next step boundary: after the tool results of it
 
 `steerPrompt()` resolves with `{ steerId, queueId, runId }` once the run accepted the steer and `prompt.steer.accepted` was emitted; `prompt.steer.applied` carries the `messageId` of the user message the steer became. Every accepted steer ends in exactly one of two ways: it is in the model context of later turns, or it is listed in `unappliedSteerIds`, in arrival order, on `IFlexPromptResult` and `run.finished`, and on the finished queue entry when that list is not empty. A steer is listed when the run did not take it in before it ended, because its last model step was already running or because it was stopped or failed, and also when the run itself does not stay in context. `keptInContext` on `run.finished` and on the finished queue entry says whether it does: it is `false` for a failed run and for a run stopped before any model output, and such a run lists every steer it accepted, including the ones it took in and reported with `prompt.steer.applied`. Send its prompt and its unapplied steers again to have them answered. The run stops taking steers atomically when its generation ends or `abort()`/`cancelPrompt()` stops it. A steer for a prompt without a running run, or whose run is ending, is refused with `FlexHarnessSteerRejectedError` reason `not-running`; the caller sends it as the next turn instead. Reusing a `steerId` within a run is refused with reason `duplicate`, an unknown `queueId` throws `FlexHarnessNotFoundError`, and child sessions reject this general API (their exact parent run uses `sendSubagentInput()` or `delegate_send` instead). A run holds at most `maxOutstandingPromptsPerSession` pending steers, and their bytes count against the session's outstanding prompt byte limit until the run takes them in or ends, so `startPrompt()` and `enqueuePrompt()` are refused with `FlexHarnessQueueFullError` while pending steers fill it. They are process-local like queue entries: a process restart ends the run and drops its pending steers, while steers it took in are durable parts of the turn.
 
+A prompt can bring further user messages into its run: `startPrompt()`, `enqueuePrompt()` and `prompt()` take `steers`, a list of `{ steerId, prompt }`, in their options. The run accepts them when it starts, emitting `prompt.steer.accepted` for each in the given order right after `prompt.started`, and takes them in before its first model call, so the model sees the prompt and its steers as consecutive user messages of their own in one call, each with its own `steerId`, `messageId` and attachments. From then on they report like every other steer of the run. They count against the session's outstanding prompt limits from admission on. The whole prompt is refused with `FlexHarnessValidationError` when a `steerId` repeats, and with `FlexHarnessQueueFullError` when it brings more steers than `maxOutstandingPromptsPerSession` or its steers' bytes exceed the outstanding byte limit. A prompt cancelled before its run started lists them in `unappliedSteerIds` on its finished queue entry and `prompt.finished`, with `keptInContext: false`. A caller holding several waiting messages for a session delivers them in one turn this way, without merging them into one message.
+
 ### Keeping the Prompt Cache Warm
 
 A provider's prompt cache expires when nothing reads it for its TTL, and the next turn then writes the whole prefix again. `keepCacheWarm()` keeps a root session's cache warm until a deadline:
@@ -1157,7 +1159,7 @@ const unsubscribe = harness.subscribe((event) => {
 unsubscribe();
 ```
 
-Events are discriminated, deeply immutable values with one global sequence within each `FlexHarness` instance. Every `IFlexEventBase` carries the exact source `sessionGenerationId` and `sessionGenerationSequence`; `session.deleted` retains the deleted generation after live metadata is removed. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. Every accepted steer emits `prompt.steer.accepted`, and `prompt.steer.applied`, after the `message.*` events of its user message, once the run took it in; `run.finished` lists it in `unappliedSteerIds` unless it is in the model context of later turns. Durable promotion additionally emits `prompt.started`, and actual model preparation emits `prompt.running`; cancellation or failure can omit either intermediate event. Existing durable run/message terminal events precede `prompt.finished`. Every callback-backed streamed text part that stays in its message emits exactly one `part.completed` event before the corresponding `run.finished` event: once the model step that streamed it is committed, so its text is final and saved, or with the run's terminal projection when that step did not commit. Text a later model step streams starts a new part. When a model call fails and is retried, the text and reasoning parts it streamed are not in the session: `part.removed` takes each of them out of its message, last part first, and the retry streams its own parts. Its `partIndex` is the part's position before it left; the parts after it move up by one. A removed part has no further events, and `part.removed` does not count against `callbackLimits`. The tool parts of calls the failed model call executed stay. Every `part.started`, `part.delta`, `part.updated`, `part.completed`, and `part.removed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences.
+Events are discriminated, deeply immutable values with one global sequence within each `FlexHarness` instance. Every `IFlexEventBase` carries the exact source `sessionGenerationId` and `sessionGenerationSequence`; `session.deleted` retains the deleted generation after live metadata is removed. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. Every accepted steer emits `prompt.steer.accepted` (a steer admitted with its prompt when the run starts, and not at all when the prompt is cancelled or fails before), and `prompt.steer.applied`, after the `message.*` events of its user message, once the run took it in; `run.finished` lists it in `unappliedSteerIds` unless it is in the model context of later turns. Durable promotion additionally emits `prompt.started`, and actual model preparation emits `prompt.running`; cancellation or failure can omit either intermediate event. Existing durable run/message terminal events precede `prompt.finished`. Every callback-backed streamed text part that stays in its message emits exactly one `part.completed` event before the corresponding `run.finished` event: once the model step that streamed it is committed, so its text is final and saved, or with the run's terminal projection when that step did not commit. Text a later model step streams starts a new part. When a model call fails and is retried, the text and reasoning parts it streamed are not in the session: `part.removed` takes each of them out of its message, last part first, and the retry streams its own parts. Its `partIndex` is the part's position before it left; the parts after it move up by one. A removed part has no further events, and `part.removed` does not count against `callbackLimits`. The tool parts of calls the failed model call executed stay. Every `part.started`, `part.delta`, `part.updated`, `part.completed`, and `part.removed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences.
 
 `getSessionView(scopeId, sessionId)` reads a session's metadata, visible messages and pending permission requests in one step, together with the instance's event `sequence` they include. The messages include what a running turn has streamed so far, so a consumer that applies every event of the instance with a greater `sequence` follows the session exactly from the view on; events up to `sequence` are already in it. The read waits while a queued write or a change that emits events for the session is in progress; a session that keeps changing through 64 consecutive waits is refused with `FlexHarnessSessionBusyError`, and the read can be repeated. Session metadata is current: status changes such as `waiting_permission` emit no event. A permission request its run leaves unanswered leaves `pendingPermissions` without an event of its own; the run's `run.finished` follows.
 

package/ts/utils.json.ts

@@ -578,6 +578,8 @@ function validateSession(value: unknown, path: string): IValidatedSessionIdentit
   requireOptionalString(activity.error, `${path}.activity.error`);
   requireOptionalModelLimit(activity.limit, `${path}.activity.limit`);
   requireOptionalString(activity.rejectedPermissionId, `${path}.activity.rejectedPermissionId`);
+  // FlexHarness 13.2.0 stored a warm turn's activity with `cacheWarm`; session repair on load
+  // removes it and restores the latest real turn's activity.
   if (activity.cacheWarm !== undefined && activity.cacheWarm !== true) {
     throw new FlexHarnessStoreFormatError(`${path}.activity.cacheWarm must be true when present.`);
   }

package/ts_chat_harness/functions.mapping.ts

@@ -215,9 +215,7 @@ export function flexPermissionToHarness(
   };
 }
 
-/** A cache-warm turn is idle time to the user: its activity shows as idle. */
 export function flexSessionToHarnessStatus(session: IFlexSession): plugins.IHarnessStatus {
-  if (session.activity.cacheWarm) return { type: 'idle' };
   switch (session.activity.status) {
     case 'running':
     case 'scheduled':
@@ -249,7 +247,7 @@ export function flexSessionToHarnessMeta(session: IFlexSession): plugins.IHarnes
     title: session.title ?? session.sessionId,
     ...(epoch(session.createdAt) === undefined ? {} : { createdAt: epoch(session.createdAt) }),
     ...(epoch(session.updatedAt) === undefined ? {} : { updatedAt: epoch(session.updatedAt) }),
-    state: session.activity.cacheWarm ? 'normal' : sessionCardStates[session.activity.status],
+    state: sessionCardStates[session.activity.status],
   };
 }
 

package/ts_chat_harness/readme.md

@@ -78,7 +78,7 @@ The host forwards every event of the harness instance, of every session, in orde
 - Permission rows stay in the transcript once answered, showing the decision. A request its run leaves unanswered, because the run was stopped or failed, is removed when the run finishes.
 - FlexHarness emits no event for project state. After a run, or after a project tool's row completes, read `getProjectState()` and pass it to `applyProjectState()` for the task list and the scratchpad.
 - `questions` is always empty: FlexHarness has no question requests.
-- A cache-warm turn (see the FlexHarness readme, Keeping the Prompt Cache Warm) has no rows and leaves the status idle, the session card normal and `activeQueueId` unset, so a steer never joins it. Its usage still counts in `usage`: it is spent.
+- A cache-warm turn (see the FlexHarness readme, Keeping the Prompt Cache Warm) has no rows and leaves the status and the session card as the last real turn left them and `activeQueueId` unset, so a steer never joins it. Its usage still counts in `usage`: it is spent.
 - Messages the session has not taken in yet (a queued prompt, a steer) carry no text in FlexHarness events. The host that sent them shows them as pending rows.
 - An attachment row needs a name, a media type and a size. The public projection keeps no payload and states these only when the prompt did, so an attachment without all three, such as a remote URL of unknown size, has no row.