@modelprofile.com/flexharness 13.2.0 → 13.2.1

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

@@ -642,18 +642,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';

package/ts/classes.flexharness.runs.ts

@@ -965,7 +965,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 +975,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 +989,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 +1002,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/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 {

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.