@modelprofile.com/flexharness 9.9.1 → 10.0.0

package/ts/errors.ts

@@ -44,6 +44,30 @@ export class FlexHarnessSessionBusyError extends FlexHarnessError {
   }
 }
 
+export type TFlexSteerRejection = 'not-running' | 'duplicate';
+
+/**
+ * The run refused a steer. `not-running`: the prompt has no run that takes input, because it
+ * has not started or its run is ending; the steer belongs to the next turn. `duplicate`: the run
+ * already accepted a steer with this id.
+ */
+export class FlexHarnessSteerRejectedError extends FlexHarnessError {
+  public readonly reason: TFlexSteerRejection;
+  public readonly steerId: string;
+
+  constructor(reason: TFlexSteerRejection, steerId: string) {
+    super(
+      reason === 'duplicate' ? 'FLEX_STEER_DUPLICATE' : 'FLEX_STEER_NOT_RUNNING',
+      reason === 'duplicate'
+        ? `Steer "${steerId}" was already accepted.`
+        : `Steer "${steerId}" has no running turn to join.`,
+    );
+    this.name = 'FlexHarnessSteerRejectedError';
+    this.reason = reason;
+    this.steerId = steerId;
+  }
+}
+
 /** An operation would change the history or model context of an imported, read-only session. */
 export class FlexHarnessImportedSessionError extends FlexHarnessError {
   public readonly sessionId: string;

package/ts/interfaces.ts

@@ -141,6 +141,8 @@ export interface IFlexMessage {
   error?: string;
   /** The model limit that failed this run, next to its error. */
   limit?: TFlexModelLimit;
+  /** On a user message that steered its running run: the caller's steer identity. */
+  steerId?: string;
 }
 
 export interface IFlexSessionActivity {
@@ -436,17 +438,46 @@ export interface IFlexPromptQueueEntry {
   startedAt?: string;
   finishedAt?: string;
   error?: IFlexErrorInfo;
+  /**
+   * On a finished entry: whether its prompt, the steers its run took in and what its model
+   * produced stay in the model context of later turns. True for a completed run and a run
+   * stopped after its model produced output; false for a failed run, a run stopped before any
+   * model output and a prompt that never ran. Send the prompt again to have it answered.
+   */
+  keptInContext?: boolean;
+  /**
+   * On a finished entry whose run left steers unapplied: the steers it accepted that the model
+   * context of later turns does not hold, in the order they arrived. The caller decides what
+   * becomes of them.
+   */
+  unappliedSteerIds?: string[];
 }
 
 export interface IFlexPromptResult {
   runId: string;
   sessionId: string;
   userMessage: IFlexMessage;
+  /** The run's last assistant message; a steered run completed earlier ones as it took steers in. */
   assistantMessage: IFlexMessage;
   model: IFlexModelIdentity;
   usage: IFlexUsage;
   finishReason: string;
   steps: number;
+  /** Steers the run accepted but never took in, in the order they arrived. */
+  unappliedSteerIds: string[];
+}
+
+/** A message for the running run of a session, taken in at the run's next step boundary. */
+export interface IFlexSteerInput {
+  /** Caller-chosen identity, unique among the steers of the run. */
+  steerId: string;
+  prompt: TFlexPrompt;
+}
+
+export interface IFlexSteerAdmission {
+  steerId: string;
+  queueId: string;
+  runId: string;
 }
 
 export interface IFlexPromptQueueAdmission {
@@ -1276,6 +1307,7 @@ export type TFlexAgentContextCompactor<TScope = unknown> = (
 export interface IFlexAgentSessionPolicy<TScope = unknown> {
   contextBuilder?: plugins.TAgentContextBuilder;
   contextCompactor?: TFlexAgentContextCompactor<TScope>;
+  contextCompactionBytes?: plugins.IAgentSessionOptions['contextCompactionBytes'];
   eventRetention?: TFlexAgentSessionOptions['eventRetention'];
   changeListenerTimeoutMs?: number;
   maxPendingSessionChanges?: number;
@@ -1455,6 +1487,36 @@ export interface IFlexRunFinishedEvent extends IFlexEventBase {
   readonly status: 'completed' | 'failed' | 'cancelled';
   readonly message: IFlexMessage;
   readonly error?: IFlexErrorInfo;
+  /**
+   * Whether the run's prompt, the steers it took in and what its model produced stay in the
+   * model context of later turns. True for a completed run and a run stopped after its model
+   * produced output; false for a failed run and a run stopped before any model output, whose
+   * prompt the caller sends again to have it answered.
+   */
+  readonly keptInContext: boolean;
+  /**
+   * Steers the run accepted that the model context of later turns does not hold, in the order
+   * they arrived: the ones it never took in, and, when the run is not kept in context, every
+   * steer it accepted.
+   */
+  readonly unappliedSteerIds: readonly string[];
+}
+
+/** The running run accepted a steer; it is taken in at the run's next step boundary. */
+export interface IFlexSteerAcceptedEvent extends IFlexEventBase {
+  readonly type: 'prompt.steer.accepted';
+  readonly queueId: string;
+  readonly runId: string;
+  readonly steerId: string;
+}
+
+/** The run took a steer in as the user message `messageId`, before its next model call. */
+export interface IFlexSteerAppliedEvent extends IFlexEventBase {
+  readonly type: 'prompt.steer.applied';
+  readonly queueId: string;
+  readonly runId: string;
+  readonly steerId: string;
+  readonly messageId: string;
 }
 
 /** The run waits `delayMs` before retrying a rate-limited or unavailable model call. */
@@ -1513,6 +1575,8 @@ export type TFlexHarnessEvent =
   | IFlexRunRetryingEvent
   | TFlexModelUsageEvent
   | IFlexPromptQueueEvent
+  | IFlexSteerAcceptedEvent
+  | IFlexSteerAppliedEvent
   | IFlexSessionHistoryChangedEvent;
 
 export type TFlexHarnessEventListener = (event: TFlexHarnessEvent) => void;

package/ts/plugins.ts

@@ -9,12 +9,15 @@ export { AsyncLocalStorage, crypto, fs, path };
 // @push.rocks scope
 import {
   AgentEventStoreConflictError,
+  AgentPendingInputQueue,
+  AgentPendingInputRejectedError,
   AgentSession,
   buildModelMessages,
   ToolJobStoreConflictError,
   createAgentEvent,
   filterModelVisibleAgentEvents,
   getAgentGenerationTransactions,
+  isGenerationInModelContext,
   modelMessagesToAgentEvents,
   tool,
   validateAgentEventArchiveV2,
@@ -24,12 +27,15 @@ import {
 
 export {
   AgentEventStoreConflictError,
+  AgentPendingInputQueue,
+  AgentPendingInputRejectedError,
   AgentSession,
   buildModelMessages,
   ToolJobStoreConflictError,
   createAgentEvent,
   filterModelVisibleAgentEvents,
   getAgentGenerationTransactions,
+  isGenerationInModelContext,
   modelMessagesToAgentEvents,
   tool,
   validateAgentEventArchiveV2,
@@ -37,6 +43,7 @@ export {
   z,
 };
 export type {
+  IAgentAppliedInput,
   IAgentEventArchiveV2,
   IAgentContextCompactionOptions,
   IAgentEventSnapshotV2,

package/ts/readme.md

@@ -403,26 +403,29 @@ Normal Flex session cleanup always waits in-flight local project operations, the
 
 `InMemoryFlexProjectManagementStore` is the standalone in-memory implementation. `InMemoryFlexHarnessStores` and `JsonFileFlexHarnessStores` include `projectManagement` as a required bundle member. `assertFlexProjectManagementSnapshot()` validates live records, `assertFlexProjectManagementTombstone()` validates tombstones, and `assertFlexProjectManagementRecord()` validates the union. `createEmptyFlexProjectManagementSnapshot(sessionGenerationId, sessionGenerationSequence)` returns a revision-0 live state for the supplied current generation.
 
-## Foreground Subagents
+## Subagents
 
-`subagents` enables a harness-owned built-in tool named `delegate`. It is available only when at least one definition exists and the current session depth is below `maxSubagentDepth`. An application or resource `toolProvider` must not return its own `delegate` tool while the built-in is enabled for that run. The built-in is foreground-only: the parent tool call does not complete until the child prompt reaches a terminal outcome.
+`subagents` enables the harness-owned `delegate` and `delegate_result` tools when at least one definition exists and the session depth is below `maxSubagentDepth`. A tool provider cannot replace either enabled built-in. Delegation is asynchronous by default: `delegate` returns `{ taskId, status: 'running', runId }` after durable child admission, so the parent can continue independent work. `delegate_result({ taskId, waitMs? })` reads live status and, once settled, bounded final text and model identity; its optional wait is limited to 240 seconds and observes parent cancellation. Set `foreground: true` to await the final answer in `delegate` itself. Children remain owned by the parent turn: Stop cancels its exact child runs, and the parent joins them before releasing authority and finalizing. A child result arriving while inference is still active enters the parent's next model context as untrusted task data.
 
 The model calls it with this exact input shape:
 
+When upgrading from 9.x, callers that require the previous synchronous delegate result must pass `foreground: true`. Tool providers must also leave the newly reserved `delegate_result` name available when subagents are enabled.
+
 ```typescript
 interface IDelegateInput {
   description: string;
   prompt: string;
   subagentType: string;
   taskId?: string;
+  foreground?: boolean;
 }
 ```
 
 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()` remains limited to `sessionId`, `sessionGenerationId`, and `title`. Child sessions reject direct `prompt()`, `startPrompt()`, `enqueuePrompt()`, and `schedulePrompt()` calls and run only through the foreground `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()` remains limited to `sessionId`, `sessionGenerationId`, and `title`. 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`.
 
-The parent tool part receives `childSessionId` in a cumulative `part.updated` event as soon as the child is acquired. If child model resolution completes, a later cumulative update adds `model`; failures before model resolution leave it absent. The terminal tool part retains every value that became available. A successful delegate call always has model identity and returns bounded JSON:
+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:
 
 ```typescript
 {
@@ -525,7 +528,7 @@ Attachment payloads are never copied into public audit messages or events. Publi
 }
 ```
 
-When the turn succeeds, the original string remains only in canonical private Agent events so a later model turn can receive the attachment again. Failed, cancelled, resolver-failed, cleanup-failed, and persistence-failed turns do not add it to future context.
+The original string remains only in canonical private Agent events, so a later model turn can receive the attachment again. A turn that succeeded stays in future context, and so does a turn stopped through `abort()` or `cancelPrompt()` once its model produced output: its prompt, the steers it took in and what the model produced before the stop, with every tool call that has no recorded result closed by an error result saying its effect is unknown. A turn stopped before any model output leaves no trace, so its prompt can be sent again without appearing twice; its `run.finished` event and finished queue entry carry `keptInContext: false`. Failed, resolver-failed, cleanup-failed, and persistence-failed turns, and turns a process restart interrupted, do not add anything to future context.
 
 The main session methods are:
 
@@ -572,6 +575,7 @@ await harness.cancelScheduledPrompt(scopeId, sessionId, scheduled.scheduleKey);
 await harness.getPromptQueueEntry(scopeId, sessionId, queued.queueId);
 await harness.listPromptQueueEntries(scopeId, sessionId);
 await harness.cancelPrompt(scopeId, sessionId, queued.queueId);
+await harness.steerPrompt(scopeId, sessionId, admission.queueId, { steerId, prompt });
 await harness.abort(scopeId, sessionId);
 await harness.listPendingPermissions(scopeId, sessionId);
 await harness.respondToPermission(scopeId, sessionId, permissionId, 'once');
@@ -616,6 +620,24 @@ 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.
 
+### Steering a Running Turn
+
+`steerPrompt()` hands a message to the running run of a prompt instead of queueing it behind that run:
+
+```typescript
+const admission = await harness.startPrompt(scopeId, sessionId, 'Plan the release.');
+await harness.steerPrompt(scopeId, sessionId, admission.queueId, {
+  steerId: 'steer-1',
+  prompt: 'Keep the database migration out of it.',
+});
+const result = await admission.completion;
+console.log(result.unappliedSteerIds); // [] once the run took the steer in
+```
+
+The run takes a steer in at its next step boundary: after the tool results of its current model step are recorded and before its next model call. A running tool call or a pending permission is never interrupted; the steer waits for the boundary that follows it. A steer taken in is a user message of the run (`steerId` set) that the model sees in its next call and every later turn. If the run had already answered, the assistant message that answered is completed and the run answers on in a new assistant message after the steer; a steer taken in before the run answered anything is placed before its still empty assistant message. `IFlexPromptResult.userMessage` stays the prompt and `assistantMessage` is the run's last assistant message. Undo and redo treat the run's messages as one turn.
+
+`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 subagent sessions are not steerable. 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.
+
 ## Slash Commands
 
 `parseSlashCommand()` is the public strict pure parser. It accepts at most 768 KiB, returns `not-command` for input not starting with `/`, `malformed` for invalid slash syntax, and `parsed` with the exact input, lowercase command name, separator-stripped raw argument text, and OpenCode-compatible quoted tokenization. Command names match `[a-z][a-z0-9-]{0,63}`. Single and double quotes group tokens and are stripped; escapes are not interpreted.
@@ -668,7 +690,7 @@ At most 128 custom commands may be registered. Every registration must be a plai
 
 `/undo` and `/redo`, plus `undoSession()` and `redoSession()`, move a durable history cursor. The direct methods return `{ revertedRunId }` and `{ restoredRunId }`; the slash forms return `{ type: 'operation', name: 'undo' | 'redo' }`. Each committed cursor move emits one `session.history.changed` event with `direction`, `runId`, and the selected session identity. A committed branch emits the same event with `direction: 'branch'` and no `runId`, so controllers should refresh the complete selected session. Capture finalization, cleanup, and metadata-only changes do not emit this event.
 
-A completed root-session turn defines an operation-group boundary. Failed and cancelled turns after it belong to that group; leading failed or cancelled turns belong to the first completed group. No completed boundary means there is nothing to undo. Undo applies selected segments in reverse order and redo applies them in forward order. Without `turnReversionProvider`, only transcript and future model context move. Hidden messages disappear from `getMessages()`, message pages, exact message lookup, and future model context. Starting a new prompt, template, handler, or compaction from an undone position commits a branch: hidden messages and segments are removed durably and cannot be redone. Successful event archival also commits hidden redo history; a missing compaction or failed archive leaves it intact.
+A completed root-session turn defines an operation-group boundary. Failed and cancelled turns after it belong to that group; leading failed or cancelled turns belong to the first completed group. No completed boundary means there is nothing to undo. Undo applies selected segments in reverse order and redo applies them in forward order. Without `turnReversionProvider`, only transcript and future model context move. Hidden messages disappear from `getMessages()`, message pages, exact message lookup, and future model context. Starting a new prompt, template, handler, or compaction from an undone position commits a branch: hidden messages and segments are removed durably and cannot be redone. Successful event archival also commits hidden redo history; a missing compaction or failed archive leaves it intact. Automatic budget compaction archives covered events after generation finalization and advances the same undo horizon; set `contextCompactionBytes: false` to disable that automatic policy.
 
 Two horizons bound undo. Retention pruning removes the oldest complete visible units when `reversionLimits` is exceeded. Explicit event archival marks covered turns context-unavailable and prunes complete prefixes that can no longer be rebuilt; FlexHarness never crosses that archive horizon. Manual compaction without archival retains the original events and remains undoable. Schema-1 projection history and sessions migrated from `2.x` have no reversion segments, so historical turns are not retroactively undoable; newly written turns are tracked normally.
 
@@ -771,7 +793,7 @@ The protocol is durable and inspectable:
 
 1. FlexHarness persists a `preparing` capture intent before calling `prepare()`, before model or tool execution. The provider must establish exclusive capture ownership for that `storageKey` and retain it until `release()` succeeds.
 2. `inspectCapture()` returns `missing`, `prepared`, `finalized`, or `unknown`. A finalized V1 result includes `reference`; a finalized V2 result includes the complete tagged `outcome`. `missing` is safe only while the durable state is still `preparing`; a missing prepared or finalizing capture, an `unknown` result, or an inspection failure fences the namespace.
-3. `finalize()` closes the capture and returns its JSON-safe V1 reference or complete V2 outcome. FlexHarness may call it during normal finalization or recovery after `inspectCapture()` reports `prepared`. Failed and cancelled root turns are captured too. A root capture spans foreground subagent effects, although child transcript records remain separate.
+3. `finalize()` closes the capture and returns its JSON-safe V1 reference or complete V2 outcome. FlexHarness may call it during normal finalization or recovery after `inspectCapture()` reports `prepared`. Failed and cancelled root turns are captured too. A root capture spans its admitted subagent effects, including asynchronous children joined before finalization, although child transcript records remain separate. A failed parent cancels its outstanding children before joining them.
 4. Before undo or redo, FlexHarness persists an apply write-ahead record. `inspectApply()` must report the exact durable outcome for the supplied `operationId`: `not-applied` means no effect occurred, `applied` means the complete effect occurred, and `unknown` means the provider cannot prove either result. FlexHarness calls `apply()` only for `not-applied`; after an apply error it inspects again, and an `unknown` result or inspection failure fences the namespace. Progress is persisted after each segment, and the transcript cursor moves only after the complete unit succeeds. Known zero-progress failures leave the cursor unchanged and can be retried; partial progress retains the write-ahead record and resumes after restart. Caller cancellation is honored until the first workspace segment makes progress; recovery then continues with fresh bounded maintenance signals until the unit and cursor commit. Providers must treat `operationId` idempotently.
 5. `release()` relinquishes the capture after no-change or nonrevertible V2 finalization, branch commitment, retention or archive pruning, session deletion, or other durable removal. It must be idempotent: an unacknowledged release remains persisted and is retried before FlexHarness discards the reference.
 
@@ -941,6 +963,7 @@ A `contextCompactor` states which model to compact with from the model the compa
 | `reason` | Compaction | Model members |
 | --- | --- | --- |
 | `context-overflow` | A run's context overflowed, including a delegated run's | `resolvedModel`: the `IFlexResolvedModel` the model resolver returned for that run, frozen; a delegated run's overflow carries the delegated run's own model |
+| `context-budget` | Settled history exceeds `contextCompactionBytes` before a generation's first inference (256 KiB by default with a compactor) | `resolvedModel`: the exact model resolved for that run, including its delegated model |
 | `manual` | `/compact` or `compactSession()` | `modelHint`: the `modelHint` of the `/compact` execution options or of `compactSession(scopeId, sessionId, { modelHint })`, when one was passed |
 | `retention` | Event retention | none |
 
@@ -983,6 +1006,14 @@ const unsubscribe = harness.subscribe((event) => {
       break;
     case 'run.finished':
       markRunFinished(event.runId, event.status);
+      // A run that did not stay in context needs its prompt sent again, followed by its unapplied steers.
+      resendAsNextTurn(event.keptInContext ? [] : [event.runId], event.unappliedSteerIds);
+      break;
+    case 'prompt.steer.accepted':
+      markSteerPending(event.steerId);
+      break;
+    case 'prompt.steer.applied':
+      markSteerApplied(event.steerId, event.messageId);
       break;
     case 'session.history.changed':
       refreshSelectedSession(event.sessionId);
@@ -999,7 +1030,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`. 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 emits exactly one `part.completed` event before the corresponding `run.finished` event. Every `part.started`, `part.delta`, `part.updated`, and `part.completed` 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`, 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 emits exactly one `part.completed` event before the corresponding `run.finished` event. Every `part.started`, `part.delta`, `part.updated`, and `part.completed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences.
 
 `part.started`, `part.updated`, and `part.completed` are snapshot events with a complete immutable `part`. A newly streamed text part emits `part.started` with empty text before its first delta; reasoning parts also start empty. `part.delta` is a separate delta-only event: it has no cumulative `part`, and carries `partType`, the required exact source `delta`, and `baseTextUtf8Bytes`/`textUtf8Bytes` for the cumulative text before and after that delta. The counters remain correct when a UTF-16 surrogate pair is split across callbacks. Exact deltas are never truncated, including a single delta above the 96 KiB message-transfer text limit. `part.updated` remains a cumulative replacement snapshot for running tool output or metadata, not a text delta. `session.history.changed` carries `direction: 'undo' | 'redo' | 'branch'`; `runId` is present for undo and redo. Events contain public IDs, exact delta payloads, and public snapshots only; they do not expose prompt payloads, the resolved scope object, storage key, model object, provider options, or raw storage key.
 

package/ts/utils.harnessoptions.ts

@@ -380,6 +380,7 @@ export function normalizeAgentSessionPolicy<TScope>(
   return {
     ...(policy.contextBuilder === undefined ? {} : { contextBuilder: policy.contextBuilder }),
     ...(policy.contextCompactor === undefined ? {} : { contextCompactor: policy.contextCompactor }),
+    ...(policy.contextCompactionBytes === undefined ? {} : { contextCompactionBytes: policy.contextCompactionBytes }),
     ...(policy.eventRetention === undefined ? {} : { eventRetention: policy.eventRetention }),
     ...(policy.changeListenerTimeoutMs === undefined
       ? {}

package/ts/utils.json.ts

@@ -720,6 +720,7 @@ function validateMessage(value: unknown, path: string): IValidatedMessageIdentit
       'usage',
       'error',
       'limit',
+      'steerId',
     ],
     path,
   );
@@ -736,6 +737,12 @@ function validateMessage(value: unknown, path: string): IValidatedMessageIdentit
   requireOptionalString(message.completedAt, `${path}.completedAt`);
   requireOptionalString(message.error, `${path}.error`);
   requireOptionalModelLimit(message.limit, `${path}.limit`);
+  if (message.steerId !== undefined) {
+    requireString(message.steerId, `${path}.steerId`);
+    if (message.role !== 'user') {
+      throw new FlexHarnessStoreFormatError(`${path}.steerId is only valid on a user message.`);
+    }
+  }
   if (message.model !== undefined) validateModel(message.model, `${path}.model`);
   if (message.usage !== undefined) validateUsage(message.usage, `${path}.usage`);
   if (!Array.isArray(message.parts)) {

package/ts/utils.transfer.ts

@@ -172,6 +172,7 @@ export function createBoundedTransferMessage(message: IFlexMessage): IFlexMessag
   requireTransferIdentifier(projected.messageId, 'messageId');
   requireTransferIdentifier(projected.sessionId, 'sessionId');
   requireTransferIdentifier(projected.runId, 'runId');
+  if (projected.steerId !== undefined) requireTransferIdentifier(projected.steerId, 'steerId');
   projected.createdAt = truncateUtf8(projected.createdAt, 128);
   if (projected.completedAt !== undefined) projected.completedAt = truncateUtf8(projected.completedAt, 128);
   if (projected.error !== undefined) projected.error = truncateUtf8(projected.error, maxTransferMetadataBytes);

package/ts_kvm/classes.browserkvm.ts

@@ -256,9 +256,9 @@ export class BrowserKvm implements IKvmDriver {
       return;
     }
 
-    await usernameElement.click({ clickCount: 3 });
+    await usernameElement.click({ count: 3 });
     await usernameElement.type(this.options.username);
-    await passwordElement.click({ clickCount: 3 });
+    await passwordElement.click({ count: 3 });
     await passwordElement.type(this.options.password);
     await passwordElement.press('Enter');
 

package/ts_kvm/plugins.ts

@@ -4,7 +4,7 @@ import * as crypto from 'node:crypto';
 export { crypto };
 
 // third party scope
-import puppeteer from 'puppeteer';
+import * as puppeteer from 'puppeteer';
 
 export { puppeteer };