@oh-my-pi/pi-agent-core 18.3.1 → 18.3.3

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [18.3.3] - 2026-09-27
+
+### Added
+
+- Added live steering support, allowing models to receive and act on user steering messages during an active stream.
+
+## [18.3.2] - 2026-09-25
+
+### Fixed
+
+- Fixed tool calls that put their payload in the intent field `i` (for example a file body in `write`) silently running with the leftover arguments; they now fail with an error telling the model to retry ([#13140](https://github.com/can1357/oh-my-pi/issues/13140), [#13141](https://github.com/can1357/oh-my-pi/pull/13141) by [@radkawar](https://github.com/radkawar))
+- Fixed the Anthropic compaction failure log omitting why no compaction block came back; it now names the stop reason ([#13300](https://github.com/can1357/oh-my-pi/pull/13300) by [@alphastorm](https://github.com/alphastorm))
+
 ## [18.3.1] - 2026-09-25
 
 ### Added

package/dist/types/agent-loop.d.ts

@@ -5,7 +5,7 @@
 import { type AssistantMessage, type Context, EventStream, type ToolResultMessage } from "@oh-my-pi/pi-ai";
 import { type Dialect } from "@oh-my-pi/pi-ai/dialect";
 import { type AgentRunCoverage, type AgentRunSummary } from "./run-collector.js";
-import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.js";
+import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, SteeringQueueState, StreamFn } from "./types.js";
 /** Stop-details marker for a provider error after assistant content/tool args already streamed. */
 export declare const STREAM_INTERRUPTED_AFTER_CONTENT_STOP_DETAIL = "stream_interrupted_after_content";
 /**
@@ -106,6 +106,13 @@ export interface NormalizeToolsOptions {
     pruneDescriptions?: boolean;
 }
 export declare function normalizeTools(tools: AgentContext["tools"], options: NormalizeToolsOptions): Context["tools"];
+/**
+ * Classify the first `count` steering messages for a tool-batch interrupt:
+ * any user-authored message wins, then agent-attributed user messages, else
+ * system steering (advisor cards, hidden directives). Shared by the agent's
+ * queue peek and the loop's live-taken steering.
+ */
+export declare function steeringQueueState(messages: readonly AgentMessage[], count?: number): SteeringQueueState;
 /** Resolve the human-readable reason an abort carried. A caller that aborts via
  *  `AbortController.abort(reason)` with a string or a non-`AbortError` `Error`
  *  (e.g. the coding agent's user-interrupt label) gets that text surfaced on the

package/dist/types/agent.d.ts

@@ -411,6 +411,14 @@ export declare class Agent {
     addBeforeQueuedMessageDequeueHook(hook: (signal?: AbortSignal) => Promise<void> | void): () => void;
     /** Register an independently removable hook that runs immediately before each model call. */
     addBeforeModelCallHook(hook: (signal?: AbortSignal) => Promise<void> | void): () => void;
+    /**
+     * Take back live-steered messages ahead of an abort (Esc restores them to the editor):
+     * the aborted run then neither records nor requeues them.
+     */
+    withdrawLiveSteering(): AgentMessage[];
+    /** Steering live steering took for the streaming response; the transcript records it once
+     *  that response (or its tool batch) ends, which is when the model switches to it. */
+    peekLiveSteeredMessages(): AgentMessage[];
     setProviderResponseInterceptor(fn: SimpleStreamOptions["onResponse"] | undefined): void;
     setRawSseEventInterceptor(fn: SimpleStreamOptions["onSseEvent"] | undefined): void;
     setAssistantMessageEventInterceptor(fn: ((message: AssistantMessage, event: AssistantMessageEvent) => void) | undefined): void;
@@ -476,6 +484,11 @@ export declare class Agent {
      *  single source of truth. Includes exclusively claimed originals while
      *  preparation is pending, so editor restoration can cancel their delivery. */
     peekSteeringQueue(): readonly AgentMessage[];
+    /** Dequeued messages not yet in the transcript, e.g. steering a provider
+     *  took into its in-flight response via live steering. Aborting the run
+     *  requeues them, so the session's empty-submit interrupt counts them as
+     *  pending input even though {@link peekSteeringQueue} no longer does. */
+    peekUndeliveredQueuedMessages(): AgentMessage[];
     /** Non-consuming view of the pending follow-up queue. See
      *  {@link peekSteeringQueue}. */
     peekFollowUpQueue(): readonly AgentMessage[];

package/dist/types/compaction/pruning.d.ts

@@ -82,6 +82,15 @@ export interface SupersedePruneConfig {
     /** Tool-result protection matchers (same contract as {@link PruneConfig.protectedTools}). */
     protectedTools: ProtectedToolMatcher[];
 }
+/**
+ * Generic age-based pruning floor. Below this, blanking a result to
+ * `[Output truncated - N tokens]` recovers nothing — the placeholder itself
+ * costs ~8 tokens, so a sub-floor result grows the context (and churns the
+ * prompt cache) instead of shrinking it. Superseded/useless results keep their
+ * own rules: useless already drops no-savings candidates, superseded prunes for
+ * correctness regardless of size.
+ */
+export declare const MIN_PRUNE_TOKENS = 50;
 /**
  * Prune superseded tool results (e.g. stale `read` outputs replaced by a newer
  * read of the same file) and, when `pruneUseless` is set, results their tool

package/dist/types/compaction/transcript-tokens.d.ts

@@ -37,6 +37,14 @@ export interface TranscriptUsageAnchor {
  * the session-entry walkers.
  */
 export declare function isTranscriptUsageAnchor(message: AgentMessage): message is AssistantMessage;
+/** Options for {@link findTranscriptUsageAnchor}. */
+export interface TranscriptUsageAnchorOptions {
+    /**
+     * Also treat usage reported at or before the newest `prunedAt` as stale,
+     * the same rule {@link findRequestUsageAnchor} applies to request contexts.
+     */
+    skipPrunedAnchors?: boolean;
+}
 /**
  * Newest assistant turn in `messages[fromIndex..]` whose usage can anchor the
  * transcript, or `undefined` when none qualifies (fresh context, or every
@@ -45,7 +53,7 @@ export declare function isTranscriptUsageAnchor(message: AgentMessage): message
  * `fromIndex` excludes turns whose usage is stale — anything a compaction
  * summarized away describes a prompt that is no longer sent.
  */
-export declare function findTranscriptUsageAnchor(messages: readonly AgentMessage[], fromIndex?: number): TranscriptUsageAnchor | undefined;
+export declare function findTranscriptUsageAnchor(messages: readonly AgentMessage[], fromIndex?: number, options?: TranscriptUsageAnchorOptions): TranscriptUsageAnchor | undefined;
 /**
  * Newest assistant turn in a provider request's `messages` whose usage still
  * describes the prefix it sits on, or `undefined` when none does.
@@ -67,6 +75,8 @@ export interface TranscriptTokenOptions {
      * accounting is governed separately by {@link countFromIndex}.
      */
     anchorFromIndex?: number;
+    /** Forwarded to {@link findTranscriptUsageAnchor}. */
+    skipPrunedAnchors?: boolean;
     /**
      * First message whose content is counted locally when no anchor is found.
      * Defaults to 0 (count the whole transcript), which is what a floor

package/dist/types/types.d.ts

@@ -240,6 +240,13 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * {@link getSteeringMessages}.
      */
     waitForSteeringMessages?: (signal?: AbortSignal) => Promise<void>;
+    /**
+     * Called when live steering dequeues messages via {@link getSteeringMessages}
+     * for the response being streamed. The loop records them in the transcript
+     * after that response (or its tool batch); an abort before then leaves them
+     * unrecorded for the host to requeue.
+     */
+    onLiveSteeringTaken?: (messages: AgentMessage[]) => void;
     /**
      * Peeks whether IRC messages should interrupt an interruptible waiting tool.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "18.3.1",
+	"version": "18.3.3",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -38,16 +38,16 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.3.1",
-		"@oh-my-pi/pi-catalog": "18.3.1",
-		"@oh-my-pi/pi-natives": "18.3.1",
-		"@oh-my-pi/pi-utils": "18.3.1",
-		"@oh-my-pi/pi-wire": "18.3.1",
-		"@oh-my-pi/snapcompact": "18.3.1",
+		"@oh-my-pi/pi-ai": "18.3.3",
+		"@oh-my-pi/pi-catalog": "18.3.3",
+		"@oh-my-pi/pi-natives": "18.3.3",
+		"@oh-my-pi/pi-utils": "18.3.3",
+		"@oh-my-pi/pi-wire": "18.3.3",
+		"@oh-my-pi/snapcompact": "18.3.3",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "18.3.1",
+		"@oh-my-pi/omptype": "18.3.3",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@types/bun": "^1.3.14"

package/src/agent-loop.ts

@@ -39,6 +39,7 @@ import {
 	getStreamingPartialJson,
 	kCursorExecResolved,
 } from "@oh-my-pi/pi-ai/utils/block-symbols";
+import { schemaDefinesProperty } from "@oh-my-pi/pi-ai/utils/schema/json-schema-validator";
 import { stamp } from "@oh-my-pi/pi-ai/utils/schema/stamps";
 import {
 	createHarmonyAuditEvent,
@@ -1022,6 +1023,13 @@ function resolveIntentMode(intent: AgentTool["intent"]): "require" | "optional"
 	return "require";
 }
 
+/**
+ * Longest `i` value accepted as an intent. The injected field is described as
+ * a "concise intent" (INTENT_FIELD_DESCRIPTION); anything past this is a tool
+ * payload the model put in the wrong field, not a label.
+ */
+const MAX_INTENT_LENGTH = 200;
+
 function extractIntent(args: Record<string, unknown>): { intent?: string; strippedArgs: Record<string, unknown> } {
 	const { [INTENT_FIELD]: intent, ...strippedArgs } = args;
 	if (typeof intent !== "string") {
@@ -1239,6 +1247,7 @@ async function runLoopBody(
 				config,
 				telemetry,
 				invokeAgentSpan,
+				[],
 			);
 			for (const result of executionResult.toolResults) {
 				currentContext.messages.push(result);
@@ -1611,6 +1620,7 @@ async function runLoopBody(
 						config,
 						telemetry,
 						invokeAgentSpan,
+						[...liveAccepted, ...liveDeferred],
 					);
 					toolResults.push(...executionResult.toolResults);
 
@@ -1792,6 +1802,27 @@ interface PreparedProviderCall {
 	liveSteering?: LiveSteeringChannel;
 }
 
+/**
+ * Classify the first `count` steering messages for a tool-batch interrupt:
+ * any user-authored message wins, then agent-attributed user messages, else
+ * system steering (advisor cards, hidden directives). Shared by the agent's
+ * queue peek and the loop's live-taken steering.
+ */
+export function steeringQueueState(messages: readonly AgentMessage[], count = messages.length): SteeringQueueState {
+	if (count === 0) return { queued: false };
+	let hasAgentSteering = false;
+	for (let i = 0; i < count; i++) {
+		const message = messages[i];
+		const role = "role" in message ? message.role : undefined;
+		const attribution = "attribution" in message ? message.attribution : undefined;
+		if (attribution === "user") return { queued: true, source: "user" };
+		if (role !== "user") continue;
+		if (attribution !== "agent") return { queued: true, source: "user" };
+		hasAgentSteering = true;
+	}
+	return { queued: true, source: hasAgentSteering ? "agent" : "system" };
+}
+
 /**
  * Offer queued steering to a provider that can deliver it into the response it
  * is streaming. Latency decides whether steering lands before the model commits
@@ -1810,7 +1841,11 @@ function openLiveSteering(
 	const bound = (signal: AbortSignal): AbortSignal => (loopSignal ? AbortSignal.any([signal, loopSignal]) : signal);
 	return new LiveSteeringChannel({
 		wait: signal => waitForSteeringMessages(bound(signal)),
-		take: signal => getSteeringMessages(bound(signal)),
+		take: async signal => {
+			const messages = await getSteeringMessages(bound(signal));
+			if (messages.length > 0) config.onLiveSteeringTaken?.(messages);
+			return messages;
+		},
 		toProvider: async (messages, signal) => {
 			const transformed = config.transformContext
 				? await config.transformContext(messages, bound(signal))
@@ -2830,6 +2865,19 @@ async function prepareToolCallDispatch(
 		if (intentTracing) {
 			const { intent, strippedArgs } = extractIntent(toolCall.arguments);
 			argsForExecution = strippedArgs;
+			// A payload in `i` would be stripped and the tool run with the leftover
+			// args. Unknown tools fall through to the not-found error; a tool that
+			// owns `i` as a real parameter has nowhere else to put the value.
+			if (
+				intent !== undefined &&
+				intent.length > MAX_INTENT_LENGTH &&
+				tool &&
+				!schemaDefinesProperty(toolWireSchema(tool), INTENT_FIELD)
+			) {
+				entry.args = strippedArgs;
+				entry.validationErrorMessage = `\`${INTENT_FIELD}\` is a short intent label (at most ${MAX_INTENT_LENGTH} chars); the value you sent is ${intent.length} chars. The tool was not run. Put that content in the tool's own parameters and retry with a brief \`${INTENT_FIELD}\`.`;
+				continue;
+			}
 			if (intent) {
 				toolCall.intent = intent;
 			} else if (typeof tool?.intent === "function") {
@@ -2981,6 +3029,9 @@ async function executeToolCalls(
 	config: AgentLoopConfig,
 	telemetry: AgentTelemetry | undefined,
 	invokeAgentSpan: Span | undefined,
+	// Steering the provider took off the queue during the response that emitted
+	// this batch; it injects at this batch's boundary like queued steering.
+	liveSteering: readonly AgentMessage[],
 ): Promise<{ toolResults: ToolResultMessage[]; additionalContext?: string }> {
 	const tools = currentContext.tools;
 	const {
@@ -3122,7 +3173,10 @@ async function executeToolCalls(
 		// injection boundary below; polling it here would strand or drop messages.
 		let steeringQueued = false;
 		let steeringSource: SteeringInterruptSource | undefined;
-		if (hasSteeringMessages) {
+		if (liveSteering.length > 0) {
+			steeringQueued = true;
+			steeringSource = steeringQueueState(liveSteering).source;
+		} else if (hasSteeringMessages) {
 			const queuedState = await hasSteeringMessages();
 			if (typeof queuedState === "boolean") {
 				steeringQueued = queuedState;
@@ -3469,6 +3523,9 @@ async function executeToolCalls(
 	const watchSteeringWhileRunning =
 		(softInterrupts || records.some(record => record.interruptible)) &&
 		(hasSteeringMessages !== undefined || hasAsidePeek);
+	// Live-taken steering is already pending: interrupt before any call starts
+	// so not-yet-started interruptible waits are skipped outright.
+	if (liveSteering.length > 0) await checkSteering();
 	const eventDrivenSteeringWatch =
 		watchSteeringWhileRunning && config.waitForSteeringMessages !== undefined && hasSteeringMessages !== undefined;
 	const steeringWatchAbortController = new AbortController();

package/src/agent.ts

@@ -34,6 +34,7 @@ import {
 	normalizeMessagesForProvider,
 	normalizeTools,
 	resolveOwnedDialectFromEnv,
+	steeringQueueState,
 	unpairedToolCallTail,
 } from "./agent-loop";
 import type { AppendOnlyContextManager } from "./append-only-context";
@@ -411,6 +412,14 @@ export class Agent {
 	#steeringQueue: AgentMessage[] = [];
 	#followUpQueue: AgentMessage[] = [];
 	#queuedMessageClaims: Partial<Record<QueuedMessageQueue, QueuedMessageClaim>> = {};
+	/**
+	 * Steering live steering took for the in-flight response (`onLiveSteeringTaken`) that the
+	 * transcript has not recorded yet, whether or not the provider accepted it. Kept apart from
+	 * {@link #queuedMessageDeliveries}: the loop drops it on abort instead of recording it, so queue
+	 * replacement must not drop it too; the run's end requeues whatever it did not record, and
+	 * {@link withdrawLiveSteering} takes it back ahead of an abort.
+	 */
+	#liveSteered: { message: AgentMessage; controller: AbortController | undefined }[] = [];
 	/** Dequeued originals remain recoverable until their transcript events arrive. */
 	#queuedMessageDeliveries = new Set<{
 		queue: QueuedMessageQueue;
@@ -992,8 +1001,14 @@ export class Agent {
 	}
 
 	#restoreUndeliveredQueuedMessages(controller: AbortController): void {
-		if (this.#queuedMessageDeliveries.size === 0) return;
+		if (this.#queuedMessageDeliveries.size === 0 && this.#liveSteered.length === 0) return;
 		const restored: Record<QueuedMessageQueue, AgentMessage[]> = { steering: [], followUp: [] };
+		// Live steering was taken before anything the run still holds undelivered.
+		this.#liveSteered = this.#liveSteered.filter(entry => {
+			if (entry.controller !== controller) return true;
+			restored.steering.push(entry.message);
+			return false;
+		});
 		for (const delivery of this.#queuedMessageDeliveries) {
 			if (delivery.controller !== controller) continue;
 			this.#queuedMessageDeliveries.delete(delivery);
@@ -1008,6 +1023,40 @@ export class Agent {
 		if (restored.followUp.length > 0) this.#followUpQueue = [...restored.followUp, ...this.#followUpQueue];
 	}
 
+	/** Move steering live steering took out of the queue-delivery records into {@link #liveSteered}. */
+	#adoptLiveSteering(taken: readonly AgentMessage[]): void {
+		for (const delivery of this.#queuedMessageDeliveries) {
+			const pending = delivery.messages.slice(delivery.next);
+			const kept = pending.filter(message => !taken.includes(message));
+			if (kept.length === pending.length) continue;
+			for (const message of pending) {
+				if (taken.includes(message)) this.#liveSteered.push({ message, controller: delivery.controller });
+			}
+			if (kept.length === 0) {
+				this.#queuedMessageDeliveries.delete(delivery);
+			} else {
+				delivery.messages = kept;
+				delivery.next = 0;
+			}
+		}
+	}
+
+	/**
+	 * Take back live-steered messages ahead of an abort (Esc restores them to the editor):
+	 * the aborted run then neither records nor requeues them.
+	 */
+	withdrawLiveSteering(): AgentMessage[] {
+		const messages = this.peekLiveSteeredMessages();
+		this.#liveSteered = [];
+		return messages;
+	}
+
+	/** Steering live steering took for the streaming response; the transcript records it once
+	 *  that response (or its tool batch) ends, which is when the model switches to it. */
+	peekLiveSteeredMessages(): AgentMessage[] {
+		return this.#liveSteered.map(entry => entry.message);
+	}
+
 	setProviderResponseInterceptor(fn: SimpleStreamOptions["onResponse"] | undefined): void {
 		this.#onResponse = fn;
 	}
@@ -1147,6 +1196,11 @@ export class Agent {
 
 	appendMessage(m: AgentMessage) {
 		this.#state.messages.push(m);
+		const live = this.#liveSteered.findIndex(entry => entry.message === m);
+		if (live >= 0) {
+			this.#liveSteered.splice(live, 1);
+			return;
+		}
 		for (const delivery of this.#queuedMessageDeliveries) {
 			if (delivery.messages[delivery.next] !== m) continue;
 			if (++delivery.next === delivery.messages.length) this.#queuedMessageDeliveries.delete(delivery);
@@ -1202,6 +1256,7 @@ export class Agent {
 	clearAllQueues() {
 		this.#steeringQueue = [];
 		this.#followUpQueue = [];
+		this.#liveSteered = [];
 		this.#cancelQueuedMessagePreparation("steering");
 		this.#cancelQueuedMessagePreparation("followUp");
 		this.#notifySteeringWaiters();
@@ -1227,6 +1282,18 @@ export class Agent {
 		return claim ? [...claim.messages, ...this.#steeringQueue] : this.#steeringQueue;
 	}
 
+	/** Dequeued messages not yet in the transcript, e.g. steering a provider
+	 *  took into its in-flight response via live steering. Aborting the run
+	 *  requeues them, so the session's empty-submit interrupt counts them as
+	 *  pending input even though {@link peekSteeringQueue} no longer does. */
+	peekUndeliveredQueuedMessages(): AgentMessage[] {
+		const messages = this.peekLiveSteeredMessages();
+		for (const delivery of this.#queuedMessageDeliveries) {
+			for (let i = delivery.next; i < delivery.messages.length; i++) messages.push(delivery.messages[i]);
+		}
+		return messages;
+	}
+
 	/** Non-consuming view of the pending follow-up queue. See
 	 *  {@link peekSteeringQueue}. */
 	peekFollowUpQueue(): readonly AgentMessage[] {
@@ -1702,28 +1769,15 @@ export class Agent {
 				}
 				return this.#dequeueSteeringMessagesAfterHooks(signal ?? loopSignal);
 			},
-			hasSteeringMessages: () => {
-				if (this.#steeringQueue.length === 0) {
-					return { queued: false };
-				}
-				const messageCount = this.#steeringMode === "one-at-a-time" ? 1 : this.#steeringQueue.length;
-				let hasAgentSteering = false;
-				for (let i = 0; i < messageCount; i++) {
-					const message = this.#steeringQueue[i];
-					const role = "role" in message ? message.role : undefined;
-					const attribution = "attribution" in message ? message.attribution : undefined;
-					if (attribution === "user") {
-						return { queued: true, source: "user" };
-					}
-					if (role !== "user") continue;
-					if (attribution !== "agent") {
-						return { queued: true, source: "user" };
-					}
-					hasAgentSteering = true;
-				}
-				return { queued: true, source: hasAgentSteering ? "agent" : "system" };
-			},
+			hasSteeringMessages: () =>
+				steeringQueueState(
+					this.#steeringQueue,
+					this.#steeringMode === "one-at-a-time"
+						? Math.min(1, this.#steeringQueue.length)
+						: this.#steeringQueue.length,
+				),
 			waitForSteeringMessages: signal => this.#waitForSteeringMessages(signal),
+			onLiveSteeringTaken: messages => this.#adoptLiveSteering(messages),
 			hasIrcInterrupts: this.hasIrcInterrupts,
 			hasBackgroundCompletions: this.hasBackgroundCompletions,
 			getFollowUpMessages: signal => this.#dequeueFollowUpMessagesAfterHooks(signal ?? loopSignal),

package/src/compaction/anthropic.ts

@@ -255,7 +255,7 @@ export async function requestAnthropicNativeCompaction(
 		throw new Error(
 			response.stopDetails?.type === "compaction"
 				? "Anthropic compaction returned no signed summary"
-				: "Anthropic compaction response carried no compaction block",
+				: `Anthropic compaction response carried no compaction block (stop reason: ${response.stopDetails?.type ?? response.stopReason})`,
 		);
 	}
 	return {

package/src/compaction/pruning.ts

@@ -120,7 +120,7 @@ function createPrunedNotice(tokens: number): string {
  * own rules: useless already drops no-savings candidates, superseded prunes for
  * correctness regardless of size.
  */
-const MIN_PRUNE_TOKENS = 50;
+export const MIN_PRUNE_TOKENS = 50;
 
 function getToolResultMessage(entry: SessionEntry): ToolResultMessage | undefined {
 	if (entry.type !== "message") return undefined;

package/src/compaction/transcript-tokens.ts

@@ -47,6 +47,31 @@ export function isTranscriptUsageAnchor(message: AgentMessage): message is Assis
 	return assistant.usage !== undefined && hasContextTokenUsage(assistant.usage);
 }
 
+/**
+ * Newest `prunedAt` in `messages`, or `-Infinity` when nothing was pruned.
+ *
+ * A pruned tool result was rewritten in place, so every usage report made at
+ * or before this time still counts the removed bytes.
+ */
+function newestPrunedAt(messages: readonly AgentMessage[]): number {
+	let rewriteAt = Number.NEGATIVE_INFINITY;
+	for (const message of messages) {
+		if (message.role === "toolResult" && message.prunedAt !== undefined) {
+			rewriteAt = Math.max(rewriteAt, message.prunedAt);
+		}
+	}
+	return rewriteAt;
+}
+
+/** Options for {@link findTranscriptUsageAnchor}. */
+export interface TranscriptUsageAnchorOptions {
+	/**
+	 * Also treat usage reported at or before the newest `prunedAt` as stale,
+	 * the same rule {@link findRequestUsageAnchor} applies to request contexts.
+	 */
+	skipPrunedAnchors?: boolean;
+}
+
 /**
  * Newest assistant turn in `messages[fromIndex..]` whose usage can anchor the
  * transcript, or `undefined` when none qualifies (fresh context, or every
@@ -58,10 +83,12 @@ export function isTranscriptUsageAnchor(message: AgentMessage): message is Assis
 export function findTranscriptUsageAnchor(
 	messages: readonly AgentMessage[],
 	fromIndex = 0,
+	options?: TranscriptUsageAnchorOptions,
 ): TranscriptUsageAnchor | undefined {
+	const rewriteAt = options?.skipPrunedAnchors === true ? newestPrunedAt(messages) : Number.NEGATIVE_INFINITY;
 	for (let index = messages.length - 1; index >= fromIndex; index--) {
 		const message = messages[index];
-		if (!isTranscriptUsageAnchor(message)) continue;
+		if (!isTranscriptUsageAnchor(message) || message.timestamp <= rewriteAt) continue;
 		return { index, message, tokens: calculateContextTokens(message.usage) };
 	}
 	return undefined;
@@ -105,6 +132,8 @@ export interface TranscriptTokenOptions {
 	 * accounting is governed separately by {@link countFromIndex}.
 	 */
 	anchorFromIndex?: number;
+	/** Forwarded to {@link findTranscriptUsageAnchor}. */
+	skipPrunedAnchors?: boolean;
 	/**
 	 * First message whose content is counted locally when no anchor is found.
 	 * Defaults to 0 (count the whole transcript), which is what a floor
@@ -132,7 +161,9 @@ export function estimateTranscriptTokens(
 ): number {
 	const estimateOptions: MessageCountOptions | undefined =
 		options?.excludeEncryptedReasoning === true ? { excludeEncryptedReasoning: true } : undefined;
-	const anchor = findTranscriptUsageAnchor(messages, options?.anchorFromIndex ?? 0);
+	const anchor = findTranscriptUsageAnchor(messages, options?.anchorFromIndex ?? 0, {
+		skipPrunedAnchors: options?.skipPrunedAnchors,
+	});
 	let total = anchor?.tokens ?? 0;
 	for (let index = anchor ? anchor.index + 1 : (options?.countFromIndex ?? 0); index < messages.length; index++) {
 		total += tokenizer.countMessage(messages[index], estimateOptions);

package/src/types.ts

@@ -298,6 +298,14 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	 */
 	waitForSteeringMessages?: (signal?: AbortSignal) => Promise<void>;
 
+	/**
+	 * Called when live steering dequeues messages via {@link getSteeringMessages}
+	 * for the response being streamed. The loop records them in the transcript
+	 * after that response (or its tool batch); an abort before then leaves them
+	 * unrecorded for the host to requeue.
+	 */
+	onLiveSteeringTaken?: (messages: AgentMessage[]) => void;
+
 	/**
 	 * Peeks whether IRC messages should interrupt an interruptible waiting tool.
 	 *