@linxiraos/pi-agent-core 1.1.23 → 1.1.24

package/CHANGELOG.md

@@ -2,11 +2,9 @@
 
 ## [Unreleased]
 
-## [1.1.23] - 2026-10-01
+## [1.1.24] - 2026-10-03
 
-## [1.1.22] - 2026-09-30
-
-- 随 1.1.22 版本线:CLI bin 命名(zeta-c)相关的用量文案与文档对齐。
+- 上游 v18.4.11 集成：goal 命令与 Zeta goal/vibe mode 共存（GoalRuntime 共享）；跨面 token 对双端清扫（统一 `__zeta_worker_*`）。
 
 ## [14.9.5] - 2026-05-12
 

package/README.md

@@ -251,6 +251,10 @@ agent.followUp({
 Steering messages are checked after each tool call by default. Set `interruptMode` to `"wait"` to defer
 steering until the current turn completes.
 
+Hosts can use `setQueuedMessageGrouping((previous, next) => boolean)` to keep adjacent companion
+records and their prompt together in `one-at-a-time` mode. Without a grouping predicate, records
+remain separate. `replaceQueue("steering" | "followUp", messages)` replaces only the selected queue.
+
 ## Custom Message Types
 
 Extend `AgentMessage` via declaration merging:

package/THIRD-PARTY-NOTICES.txt

@@ -1,7 +1,7 @@
-OMP THIRD-PARTY NOTICES
+ZETA THIRD-PARTY NOTICES
 =======================
 
-This generated, self-contained aggregate accompanies OMP release artifacts.
+This generated, self-contained aggregate accompanies Zeta release artifacts.
 It does not replace package-level license files. First-party licensing grants
 no rights in third-party code, fonts, data, or marks identified below.
 
@@ -1046,7 +1046,7 @@ These packages participate only in generation/web build tooling and are not ship
 
 SCOPED NON-PERMISSIVE PACKAGES
 ------------------------------
-The exact @img/sharp-libvips-* 1.2.4 all-target family is LGPL-3.0-or-later. It is not distributed in OMP npm bundles or standalone assets: @huggingface/transformers is always external, installed into a user-side versioned runtime on demand, and sharp is stubbed for speech/text. The dynamically loaded native library remains replaceable. Corresponding source is available from https://github.com/lovell/sharp-libvips.git and upstream libvips sources.
+The exact @img/sharp-libvips-* 1.2.4 all-target family is LGPL-3.0-or-later. It is not distributed in Zeta npm bundles or standalone assets: @huggingface/transformers is always external, installed into a user-side versioned runtime on demand, and sharp is stubbed for speech/text. The dynamically loaded native library remains replaceable. Corresponding source is available from https://github.com/lovell/sharp-libvips.git and upstream libvips sources.
 
 lightningcss 1.32.0 and its exact target leaves are MPL-2.0 build-only dependencies. MPL is not globally allowed and these packages are absent from runtime artifacts.
 

package/dist/types/agent.d.ts

@@ -411,6 +411,12 @@ export declare class Agent {
      */
     buildSideRequestContext(llmMessages: Message[], systemPrompt?: string[]): Promise<Context>;
     subscribe(fn: (e: AgentEvent) => void): () => void;
+    /** Register a listener notified after any steering/follow-up queue mutator
+     *  (enqueue, dequeue-on-delivery, clear, restore) runs. Internal-only signal —
+     *  the queue itself has no concept of display filtering — so listeners
+     *  recompute their own snapshot from `peekSteeringQueue()`/`peekFollowUpQueue()`
+     *  (or a higher-level view) on notification. */
+    onQueueChange(listener: () => void): () => void;
     /** Register an independently removable hook that runs before queued messages are consumed. */
     addBeforeQueuedMessageDequeueHook(hook: (signal?: AbortSignal) => Promise<void> | void): () => void;
     /** Register an independently removable hook that runs immediately before each model call. */
@@ -461,6 +467,23 @@ export declare class Agent {
     setTools(t: AgentTool<any>[]): void;
     replaceMessages(ms: AgentMessage[]): void;
     replaceQueues(steering: AgentMessage[], followUp: AgentMessage[]): void;
+    /**
+     * Replace one pending queue without changing the other queue.
+     *
+     * The caller's snapshot comes from {@link peekSteeringQueue} /
+     * {@link peekFollowUpQueue}, which prepend the live claimed batch. Installing
+     * it while that claim is still live would commit a removed message anyway and
+     * deliver the surviving claimed prefix twice, so the claim and its pending
+     * delivery are dropped here exactly as {@link replaceQueues} does.
+     */
+    replaceQueue(queue: "steering" | "followUp", messages: readonly AgentMessage[]): void;
+    /**
+     * Install `followUp` as the pending follow-up queue (same claim handling as
+     * {@link replaceQueue}) and append `promoted` to the steering queue, then notify
+     * queue listeners once. A live steering claim is left alone. Listeners never
+     * observe the moved messages in both queues or in neither.
+     */
+    moveFollowUpsToSteering(followUp: readonly AgentMessage[], promoted: readonly AgentMessage[]): void;
     appendMessage(m: AgentMessage): void;
     popMessage(): AgentMessage | undefined;
     /**
@@ -499,6 +522,12 @@ export declare class Agent {
     /** Nonblocking snapshot of the latest results, including provisional payloads while transforms are pending. */
     getPendingToolResults(): readonly ToolResultMessage[];
     get isAborting(): boolean;
+    /**
+     * Join adjacent queued records into one delivery unit in one-at-a-time mode.
+     * The predicate must be synchronous and side-effect-free. By default each
+     * record is independent; all mode, queue inspection, and removal stay unchanged.
+     */
+    setQueuedMessageGrouping(predicate: ((previous: AgentMessage, next: AgentMessage) => boolean) | undefined): void;
     /**
      * Remove and return the last steering message from the queue (LIFO).
      * Used by dequeue keybinding.

package/dist/types/compaction/azure-openai-endpoint.d.ts

@@ -0,0 +1,5 @@
+import type { Model } from "@linxiraos/pi-ai";
+/** Azure OpenAI base URL for compaction requests: env override, resource name, then the model's baseUrl. */
+export declare function resolveAzureOpenAiBaseUrl(model: Model): string;
+/** Append `api-version` unless the endpoint already carries one. */
+export declare function appendAzureApiVersion(endpoint: string): string;

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

@@ -0,0 +1,18 @@
+import type { FetchImpl, Model } from "@linxiraos/pi-ai/types";
+export interface BedrockCompactionRequest {
+    model: Model;
+    apiKey: string;
+    fetch: FetchImpl;
+}
+/**
+ * Shape a native compaction request for Amazon Bedrock's OpenAI routes
+ * (`isBedrockOpenAIUrl`) the way stream dispatch shapes a normal Bedrock turn:
+ * configured headers, transport fetch (proxy, CA, User-Agent, request
+ * recording), then the provider's model and request hooks. The bundled
+ * `bedrock-mantle` provider's hook fills in `{region}` and picks bearer or
+ * SigV4 auth; without it compaction targets an unresolved host.
+ *
+ * Only Bedrock requests come through here; other providers' compaction
+ * requests keep their own transport.
+ */
+export declare function prepareBedrockCompactionRequest(model: Model, apiKey: string, fetch: FetchImpl | undefined, signal: AbortSignal | undefined): Promise<BedrockCompactionRequest>;

package/dist/types/compaction/compaction-v2-streaming.d.ts

@@ -6,7 +6,7 @@
  * compaction output item, then install retained real user messages plus that
  * compaction item as replacement history.
  */
-import type { CodexCompactionContext, FetchImpl, Model, ProviderSessionState } from "@linxiraos/pi-ai";
+import type { Api, CodexCompactionContext, FetchImpl, Model, ProviderSessionState } from "@linxiraos/pi-ai";
 import { type OpenAICodexCompactionBody } from "@linxiraos/pi-ai/providers/openai-codex-responses";
 /** Retained-message budget Codex uses after streamed V2 compaction. */
 export declare const V2_RETAINED_MESSAGE_TOKEN_BUDGET = 64000;
@@ -42,6 +42,8 @@ export interface CompactionV2Response {
 export declare function getCompactionV2Endpoint(model: Model): string | undefined;
 /** Check whether a model can use streaming V2 compaction. */
 export declare function shouldUseCompactionV2Streaming(model: Model): model is Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">;
+/** APIs that speak the OpenAI Responses compaction protocol (V1 `/responses/compact` and V2 streaming). */
+export declare function isOpenAiRemoteCompactionApi(api: Api | undefined): boolean;
 /** Clamp the retained-message budget to Codex's known-safe 64K ceiling. */
 export declare function resolveCompactionV2RetainedMessageBudget(value: number | undefined): number;
 /** Build a V2 streaming compaction request from Responses-native history. */

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

@@ -14,7 +14,7 @@
  *   summarization endpoints that accept `{ systemPrompt, prompt }` and reply
  *   with `{ summary, shortSummary? }`.
  */
-import type { Api, CodexCompactionContext, FetchImpl, Message, Model, ProviderSessionState } from "@linxiraos/pi-ai/types";
+import type { CodexCompactionContext, FetchImpl, Message, Model, ProviderSessionState } from "@linxiraos/pi-ai/types";
 import { Tokenizer } from "../tokenizer.js";
 export * from "./compaction-v2-streaming.js";
 export declare const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
@@ -83,7 +83,6 @@ export interface RemoteCompactionResponse {
     summary: string;
     shortSummary?: string;
 }
-export declare function isOpenAiRemoteCompactionApi(api: Api | undefined): boolean;
 export declare function shouldUseOpenAiRemoteCompaction(model: Model): boolean;
 export declare function getPreservedOpenAiRemoteCompactionData(preserveData: Record<string, unknown> | undefined): OpenAiRemoteCompactionPreserveData | undefined;
 export declare function withOpenAiRemoteCompactionPreserveData(preserveData: Record<string, unknown> | undefined, remoteCompaction: OpenAiRemoteCompactionPreserveData | undefined): Record<string, unknown> | undefined;
@@ -110,10 +109,10 @@ export declare function requestOpenAiRemoteCompaction(model: Model, apiKey: stri
 /**
  * Generic remote-compaction POST. Two wire shapes are auto-selected by
  * endpoint suffix so a single `compaction.remoteEndpoint` setting can point at
- * either a purpose-built omp summarizer (`{systemPrompt, prompt}` → `{summary}`)
+ * either a purpose-built zeta summarizer (`{systemPrompt, prompt}` → `{summary}`)
  * or any OpenAI-compatible chat-completions server (`/chat/completions`,
  * `/v1/chat/completions`, …) as reported for llama.cpp / vLLM / etc. in
- * issue #4630: without this, the omp payload was rejected with
+ * issue #4630: without this, the zeta payload was rejected with
  * HTTP 400 `"'messages' is required"`, compaction silently fell back to
  * local summarization, and context grew unbounded.
  *

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

@@ -43,6 +43,12 @@ export declare const DEFAULT_PRUNE_CONFIG: PruneConfig;
 export interface PruneResult {
     prunedCount: number;
     tokensSaved: number;
+    /**
+     * Restore every result this pass blanked. Pruning mutates entries in place,
+     * so a caller whose persistence of the pruned history fails calls this to keep
+     * memory matching what is durable.
+     */
+    undo(): void;
 }
 /** Exact placeholder written over a superseded tool result. */
 export declare const SUPERSEDED_NOTICE = "[Superseded by a newer read of this file]";

package/dist/types/compaction/tool-protection.d.ts

@@ -7,6 +7,8 @@ export interface ProtectedToolContext {
 }
 export type ProtectedToolMatcher = string | ((context: ProtectedToolContext) => boolean);
 export declare function collectToolCallsById(entries: readonly SessionEntry[]): Map<string, AgentToolCall>;
+/** Return the tool-result message carried by a session entry, if any. */
+export declare function getToolResultMessage(entry: SessionEntry): ToolResultMessage | undefined;
 /**
  * Extract the `path` argument from a paired `read` tool call, when the result
  * is a `read` result carrying a string path. Returns `undefined` otherwise.

package/dist/types/types.d.ts

@@ -808,6 +808,13 @@ export interface AfterToolCallResult {
     isError?: boolean;
     /** If provided, replaces the contextually-useless flag carried with the tool result. */
     useless?: boolean;
+    /**
+     * Trusted post-tool instructions for the next provider request. Delivered
+     * outside the tool result, after all calls in the batch settle. Unlike
+     * `BeforeToolCallResult.additionalContext`, this is retained for error
+     * results because the callback receives the finalized outcome.
+     */
+    additionalContext?: string;
 }
 /** Context passed to `beforeToolCall`. */
 export interface BeforeToolCallContext {
@@ -1000,7 +1007,7 @@ export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any
      * before ordinary dispatch commits its result.
      */
     speculation?: ToolSpeculationPolicy;
-    /** If true, argument validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM. */
+    /** If true, schema validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM. Malformed argument JSON still returns the parse error. */
     lenientArgValidation?: boolean;
     /**
      * Whether the agent loop may abort this tool mid-execution — or skip it

package/package.json

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

package/src/agent-loop.ts

@@ -2907,13 +2907,14 @@ async function prepareToolCallDispatch(
 				}
 				return validateToolArguments(tool, { ...toolCall, arguments: args });
 			} catch (validationError) {
-				if (tool?.lenientArgValidation) {
+				// Lenience covers schema mismatches; a parse failure has no args to hand over.
+				const parseFailed = "__parseError" in args;
+				if (tool?.lenientArgValidation && !parseFailed) {
 					const fallback = { ...args };
-					delete fallback.__parseError;
 					delete fallback.__rawJson;
 					return fallback;
 				}
-				entry.args = "__parseError" in args ? { __parseError: args.__parseError } : args;
+				entry.args = parseFailed ? { __parseError: args.__parseError } : args;
 				entry.validationErrorMessage =
 					validationError instanceof Error ? validationError.message : String(validationError);
 				return undefined;
@@ -3470,6 +3471,9 @@ async function executeToolCalls(
 						});
 						result = coerced.result;
 						isError = coerced.malformed || (after.isError ?? isError);
+						if (isNonBlankContext(after.additionalContext)) {
+							record.reportedContext.push(after.additionalContext);
+						}
 					}
 				} catch (e) {
 					caughtError = e;

package/src/agent.ts

@@ -406,6 +406,7 @@ export class Agent {
 	};
 	#tokenizer = new Tokenizer(this.#state.model);
 	#listeners = new Set<(e: AgentEvent) => void>();
+	#queueListeners = new Set<() => void>();
 	#abortController?: AbortController;
 	#convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
 	#transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
@@ -430,6 +431,7 @@ export class Agent {
 		next: number;
 	}>();
 	#steeringWaiters = new Set<() => void>();
+	#queuedMessageGrouping?: (previous: AgentMessage, next: AgentMessage) => boolean;
 
 	#steeringMode: "all" | "one-at-a-time";
 	#followUpMode: "all" | "one-at-a-time";
@@ -914,6 +916,16 @@ export class Agent {
 		return () => this.#listeners.delete(fn);
 	}
 
+	/** Register a listener notified after any steering/follow-up queue mutator
+	 *  (enqueue, dequeue-on-delivery, clear, restore) runs. Internal-only signal —
+	 *  the queue itself has no concept of display filtering — so listeners
+	 *  recompute their own snapshot from `peekSteeringQueue()`/`peekFollowUpQueue()`
+	 *  (or a higher-level view) on notification. */
+	onQueueChange(listener: () => void): () => void {
+		this.#queueListeners.add(listener);
+		return () => this.#queueListeners.delete(listener);
+	}
+
 	/** Register an independently removable hook that runs before queued messages are consumed. */
 	addBeforeQueuedMessageDequeueHook(hook: (signal?: AbortSignal) => Promise<void> | void): () => void {
 		const registration = (signal?: AbortSignal) => hook(signal);
@@ -1001,6 +1013,7 @@ export class Agent {
 			} else {
 				this.#followUpQueue = [...claim.messages, ...this.#followUpQueue];
 			}
+			this.#emitQueueChanged();
 		}
 		claim.controller.abort();
 	}
@@ -1026,6 +1039,7 @@ export class Agent {
 			this.#notifySteeringWaiters();
 		}
 		if (restored.followUp.length > 0) this.#followUpQueue = [...restored.followUp, ...this.#followUpQueue];
+		if (restored.steering.length > 0 || restored.followUp.length > 0) this.#emitQueueChanged();
 	}
 
 	/** Move steering live steering took out of the queue-delivery records into {@link #liveSteered}. */
@@ -1191,12 +1205,65 @@ export class Agent {
 		this.#state.messages = ms.slice();
 	}
 
+	/** Signal that the steering/follow-up queue contents may have changed. Every
+	 *  queue mutator below calls this once after mutating, so external layers
+	 *  (AgentSession's `queue_update` coalescing) have a single seam to observe
+	 *  enqueue, dequeue-on-delivery, clear, and restore without emits scattered
+	 *  across every call site that queues or dequeues a message. */
+	#emitQueueChanged(): void {
+		for (const listener of this.#queueListeners) {
+			try {
+				listener();
+			} catch (err) {
+				logger.warn("Agent queue listener threw", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+		}
+	}
+
 	replaceQueues(steering: AgentMessage[], followUp: AgentMessage[]) {
 		this.#steeringQueue = steering.slice();
 		this.#followUpQueue = followUp.slice();
 		this.#cancelQueuedMessagePreparation("steering");
 		this.#cancelQueuedMessagePreparation("followUp");
 		this.#notifySteeringWaiters();
+		this.#emitQueueChanged();
+	}
+
+	/**
+	 * Replace one pending queue without changing the other queue.
+	 *
+	 * The caller's snapshot comes from {@link peekSteeringQueue} /
+	 * {@link peekFollowUpQueue}, which prepend the live claimed batch. Installing
+	 * it while that claim is still live would commit a removed message anyway and
+	 * deliver the surviving claimed prefix twice, so the claim and its pending
+	 * delivery are dropped here exactly as {@link replaceQueues} does.
+	 */
+	replaceQueue(queue: "steering" | "followUp", messages: readonly AgentMessage[]): void {
+		if (queue === "steering") {
+			this.#steeringQueue = messages.slice();
+			this.#cancelQueuedMessagePreparation("steering");
+			this.#notifySteeringWaiters();
+		} else {
+			this.#followUpQueue = messages.slice();
+			this.#cancelQueuedMessagePreparation("followUp");
+		}
+		this.#emitQueueChanged();
+	}
+
+	/**
+	 * Install `followUp` as the pending follow-up queue (same claim handling as
+	 * {@link replaceQueue}) and append `promoted` to the steering queue, then notify
+	 * queue listeners once. A live steering claim is left alone. Listeners never
+	 * observe the moved messages in both queues or in neither.
+	 */
+	moveFollowUpsToSteering(followUp: readonly AgentMessage[], promoted: readonly AgentMessage[]): void {
+		this.#followUpQueue = followUp.slice();
+		this.#cancelQueuedMessagePreparation("followUp");
+		this.#steeringQueue.push(...promoted);
+		this.#notifySteeringWaiters();
+		this.#emitQueueChanged();
 	}
 
 	appendMessage(m: AgentMessage) {
@@ -1228,6 +1295,7 @@ export class Agent {
 	steer(m: AgentMessage) {
 		this.#steeringQueue.push(m);
 		this.#notifySteeringWaiters();
+		this.#emitQueueChanged();
 	}
 
 	/**
@@ -1236,17 +1304,20 @@ export class Agent {
 	 */
 	followUp(m: AgentMessage) {
 		this.#followUpQueue.push(m);
+		this.#emitQueueChanged();
 	}
 
 	clearSteeringQueue() {
 		this.#steeringQueue = [];
 		this.#cancelQueuedMessagePreparation("steering");
 		this.#notifySteeringWaiters();
+		this.#emitQueueChanged();
 	}
 
 	clearFollowUpQueue() {
 		this.#followUpQueue = [];
 		this.#cancelQueuedMessagePreparation("followUp");
+		this.#emitQueueChanged();
 	}
 
 	/**
@@ -1266,6 +1337,7 @@ export class Agent {
 		this.#cancelQueuedMessagePreparation("followUp");
 		this.#notifySteeringWaiters();
 		this.clearDeferredToolDirectives();
+		this.#emitQueueChanged();
 	}
 
 	hasQueuedMessages(): boolean {
@@ -1317,32 +1389,34 @@ export class Agent {
 		return this.#abortController?.signal.aborted === true && this.#state.isStreaming;
 	}
 
+	/**
+	 * Join adjacent queued records into one delivery unit in one-at-a-time mode.
+	 * The predicate must be synchronous and side-effect-free. By default each
+	 * record is independent; all mode, queue inspection, and removal stay unchanged.
+	 */
+	setQueuedMessageGrouping(predicate: ((previous: AgentMessage, next: AgentMessage) => boolean) | undefined): void {
+		this.#queuedMessageGrouping = predicate;
+	}
+
+	#dequeueMessages(queue: readonly AgentMessage[], mode: "all" | "one-at-a-time"): AgentMessage[] {
+		if (mode === "all") return queue.slice();
+		let count = Math.min(1, queue.length);
+		while (count < queue.length && this.#queuedMessageGrouping?.(queue[count - 1], queue[count])) count++;
+		return queue.slice(0, count);
+	}
+
 	#dequeueSteeringMessages(): AgentMessage[] {
-		if (this.#steeringMode === "one-at-a-time") {
-			if (this.#steeringQueue.length > 0) {
-				const first = this.#steeringQueue[0];
-				this.#steeringQueue = this.#steeringQueue.slice(1);
-				return [first];
-			}
-			return [];
-		}
-		const steering = this.#steeringQueue.slice();
-		this.#steeringQueue = [];
-		return steering;
+		const messages = this.#dequeueMessages(this.#steeringQueue, this.#steeringMode);
+		this.#steeringQueue = this.#steeringQueue.slice(messages.length);
+		if (messages.length > 0) this.#emitQueueChanged();
+		return messages;
 	}
 
 	#dequeueFollowUpMessages(): AgentMessage[] {
-		if (this.#followUpMode === "one-at-a-time") {
-			if (this.#followUpQueue.length > 0) {
-				const first = this.#followUpQueue[0];
-				this.#followUpQueue = this.#followUpQueue.slice(1);
-				return [first];
-			}
-			return [];
-		}
-		const followUp = this.#followUpQueue.slice();
-		this.#followUpQueue = [];
-		return followUp;
+		const messages = this.#dequeueMessages(this.#followUpQueue, this.#followUpMode);
+		this.#followUpQueue = this.#followUpQueue.slice(messages.length);
+		if (messages.length > 0) this.#emitQueueChanged();
+		return messages;
 	}
 
 	/**
@@ -1351,7 +1425,9 @@ export class Agent {
 	 */
 	popLastSteer(): AgentMessage | undefined {
 		if (this.#steeringQueue.length === 0) this.#cancelQueuedMessagePreparation("steering", true);
-		return this.#steeringQueue.pop();
+		const popped = this.#steeringQueue.pop();
+		if (popped !== undefined) this.#emitQueueChanged();
+		return popped;
 	}
 
 	/**
@@ -1360,7 +1436,9 @@ export class Agent {
 	 */
 	popLastFollowUp(): AgentMessage | undefined {
 		if (this.#followUpQueue.length === 0) this.#cancelQueuedMessagePreparation("followUp", true);
-		return this.#followUpQueue.pop();
+		const popped = this.#followUpQueue.pop();
+		if (popped !== undefined) this.#emitQueueChanged();
+		return popped;
 	}
 
 	clearMessages() {

package/src/compaction/azure-openai-endpoint.ts

@@ -0,0 +1,25 @@
+import type { Model } from "@linxiraos/pi-ai";
+import { $env } from "@linxiraos/pi-utils";
+
+const DEFAULT_AZURE_API_VERSION = "v1";
+
+/** Azure OpenAI base URL for compaction requests: env override, resource name, then the model's baseUrl. */
+export function resolveAzureOpenAiBaseUrl(model: Model): string {
+	const baseUrl = $env.AZURE_OPENAI_BASE_URL?.trim() || undefined;
+	const resourceName = $env.AZURE_OPENAI_RESOURCE_NAME;
+	const resolvedBaseUrl =
+		baseUrl ?? (resourceName ? `https://${resourceName}.openai.azure.com/openai/v1` : undefined) ?? model.baseUrl;
+	if (!resolvedBaseUrl) {
+		throw new Error(
+			"Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or configure model.baseUrl.",
+		);
+	}
+	return resolvedBaseUrl.replace(/\/+$/, "");
+}
+
+/** Append `api-version` unless the endpoint already carries one. */
+export function appendAzureApiVersion(endpoint: string): string {
+	if (/[?&]api-version=/.test(endpoint)) return endpoint;
+	const separator = endpoint.includes("?") ? "&" : "?";
+	return `${endpoint}${separator}api-version=${encodeURIComponent($env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION)}`;
+}

package/src/compaction/bedrock.ts

@@ -0,0 +1,48 @@
+import { getProviderDefinition } from "@linxiraos/pi-ai/registry";
+import type { FetchImpl, Model } from "@linxiraos/pi-ai/types";
+import { transportFetch } from "@linxiraos/pi-ai/utils/transport-fetch";
+import { untilAborted } from "@linxiraos/pi-utils";
+
+export interface BedrockCompactionRequest {
+	model: Model;
+	apiKey: string;
+	fetch: FetchImpl;
+}
+
+/**
+ * Shape a native compaction request for Amazon Bedrock's OpenAI routes
+ * (`isBedrockOpenAIUrl`) the way stream dispatch shapes a normal Bedrock turn:
+ * configured headers, transport fetch (proxy, CA, User-Agent, request
+ * recording), then the provider's model and request hooks. The bundled
+ * `bedrock-mantle` provider's hook fills in `{region}` and picks bearer or
+ * SigV4 auth; without it compaction targets an unresolved host.
+ *
+ * Only Bedrock requests come through here; other providers' compaction
+ * requests keep their own transport.
+ */
+export async function prepareBedrockCompactionRequest(
+	model: Model,
+	apiKey: string,
+	fetch: FetchImpl | undefined,
+	signal: AbortSignal | undefined,
+): Promise<BedrockCompactionRequest> {
+	let resolvedModel = model;
+	const resolveHeaders = model.resolveHeaders;
+	if (resolveHeaders) {
+		const headers = await untilAborted(signal, () => resolveHeaders(signal));
+		signal?.throwIfAborted();
+		resolvedModel = { ...model, resolveHeaders: undefined, headers: headers ? { ...headers } : undefined };
+	}
+	const baseFetch = transportFetch(resolvedModel, fetch);
+	const provider = getProviderDefinition(resolvedModel.provider);
+	const providerModel = provider?.prepareModel?.(resolvedModel) ?? resolvedModel;
+	const prepared = provider?.prepareRequest?.(providerModel, { apiKey, fetch: baseFetch, signal }) ?? {
+		model: providerModel,
+		options: { apiKey, fetch: baseFetch },
+	};
+	return {
+		model: { ...prepared.model, headers: { ...prepared.model.headers, ...prepared.options.headers } },
+		apiKey: prepared.options.apiKey || apiKey,
+		fetch: prepared.options.fetch ?? baseFetch,
+	};
+}

package/src/compaction/compaction-v2-streaming.ts

@@ -24,6 +24,7 @@ import {
 	resolveOpenAIRequestSetup,
 } from "@linxiraos/pi-ai/providers/openai-shared";
 import { captureOpenAIHttpError } from "@linxiraos/pi-ai/utils/openai-http";
+import { isBedrockOpenAIUrl } from "@linxiraos/pi-catalog/hosts";
 import {
 	applyCodexResidencyHeader,
 	CODEX_BASE_URL,
@@ -32,7 +33,9 @@ import {
 	OPENAI_HEADER_VALUES,
 	OPENAI_HEADERS,
 } from "@linxiraos/pi-catalog/wire/codex";
-import { $env, isUnexpectedSocketCloseMessage, logger, stringifyJson } from "@linxiraos/pi-utils";
+import { $env, isUnexpectedSocketCloseMessage, logger, ptree, stringifyJson } from "@linxiraos/pi-utils";
+import { appendAzureApiVersion, resolveAzureOpenAiBaseUrl } from "./azure-openai-endpoint";
+import { prepareBedrockCompactionRequest } from "./bedrock";
 
 // ============================================================================
 // Types & Configuration
@@ -47,7 +50,6 @@ export const V2_COMPACTION_MAX_RETRIES = 2;
 /** Timeout for V2 streaming compaction (5 minutes, same as V1). */
 export const V2_COMPACTION_TIMEOUT_MS = 300_000;
 
-const DEFAULT_AZURE_API_VERSION = "v1";
 const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
 const COMPACTION_TRIGGER_ITEM = { type: "compaction_trigger" } as const;
 // OpenAI image metering depends on detail and dimensions; charge the common
@@ -96,7 +98,7 @@ export interface CompactionV2Response {
 /** Resolve the streaming Responses endpoint for a V2-capable model. */
 export function getCompactionV2Endpoint(model: Model): string | undefined {
 	if (model.remoteCompaction?.enabled === false) return undefined;
-	if (!isOpenAiV2CompatibleModel(model)) return undefined;
+	if (!isOpenAiRemoteCompactionApi(compactionV2Api(model))) return undefined;
 
 	const configuredEndpoint = model.remoteCompaction?.v2Endpoint ?? model.remoteCompaction?.streamingEndpoint;
 	if (configuredEndpoint && configuredEndpoint.length > 0) return configuredEndpoint;
@@ -115,7 +117,15 @@ export function getCompactionV2Endpoint(model: Model): string | undefined {
 export function shouldUseCompactionV2Streaming(
 	model: Model,
 ): model is Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses"> {
-	if (model.remoteCompaction?.v2StreamingEnabled !== true) return false;
+	const v2StreamingEnabled = model.remoteCompaction?.v2StreamingEnabled;
+	if (v2StreamingEnabled === false) return false;
+	// Amazon Bedrock's OpenAI routes accept `compaction_trigger` without an opt-in.
+	if (
+		v2StreamingEnabled !== true &&
+		!(compactionV2Api(model) === "openai-responses" && isBedrockOpenAIUrl(model.baseUrl))
+	) {
+		return false;
+	}
 	return getCompactionV2Endpoint(model) !== undefined;
 }
 
@@ -123,8 +133,8 @@ function compactionV2Api(model: Model): Api | undefined {
 	return model.remoteCompaction?.api ?? model.api;
 }
 
-function isOpenAiV2CompatibleModel(model: Model): boolean {
-	const api = compactionV2Api(model);
+/** APIs that speak the OpenAI Responses compaction protocol (V1 `/responses/compact` and V2 streaming). */
+export function isOpenAiRemoteCompactionApi(api: Api | undefined): boolean {
 	return api === "openai-responses" || api === "azure-openai-responses" || api === "openai-codex-responses";
 }
 
@@ -152,25 +162,6 @@ function resolveOpenAiCodexResponsesEndpoint(baseUrl: string | undefined): strin
 	return `${normalizedBase}/codex/responses`;
 }
 
-function resolveAzureOpenAiBaseUrl(model: Model): string {
-	const baseUrl = $env.AZURE_OPENAI_BASE_URL?.trim() || undefined;
-	const resourceName = $env.AZURE_OPENAI_RESOURCE_NAME;
-	const resolvedBaseUrl =
-		baseUrl ?? (resourceName ? `https://${resourceName}.openai.azure.com/openai/v1` : undefined) ?? model.baseUrl;
-	if (!resolvedBaseUrl) {
-		throw new Error(
-			"Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or configure model.baseUrl.",
-		);
-	}
-	return resolvedBaseUrl.replace(/\/+$/, "");
-}
-
-function appendAzureApiVersion(endpoint: string): string {
-	if (/[?&]api-version=/.test(endpoint)) return endpoint;
-	const separator = endpoint.includes("?") ? "&" : "?";
-	return `${endpoint}${separator}api-version=${encodeURIComponent($env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION)}`;
-}
-
 function resolveCompactionV2Model(model: Model): string {
 	const requestModel = model.remoteCompaction?.model ?? model.requestModelId ?? model.id;
 	if (compactionV2Api(model) !== "azure-openai-responses") return requestModel;
@@ -248,13 +239,6 @@ export function buildCompactionV2RequestFromBody(
 // Streaming Request Handler
 // ============================================================================
 
-/** Race the caller's signal against the V2 request timeout. */
-function withRequestTimeout(signal: AbortSignal | undefined, timeoutMs: number): AbortSignal | undefined {
-	if (timeoutMs <= 0) return signal;
-	const timeout = AbortSignal.timeout(timeoutMs);
-	return signal ? AbortSignal.any([signal, timeout]) : timeout;
-}
-
 /** Request V2 compaction over the normal OpenAI Responses streaming endpoint. */
 export async function requestCompactionV2Streaming(
 	model: Model,
@@ -270,12 +254,19 @@ export async function requestCompactionV2Streaming(
 		preferWebsockets?: boolean;
 	},
 ): Promise<CompactionV2Response> {
+	let fetchImpl: FetchImpl = options?.fetch ?? globalThis.fetch;
+	if (isBedrockOpenAIUrl(model.baseUrl)) {
+		({
+			model,
+			apiKey,
+			fetch: fetchImpl,
+		} = await prepareBedrockCompactionRequest(model, apiKey, options?.fetch, signal));
+	}
 	const endpoint = getCompactionV2Endpoint(model);
 	if (!endpoint) {
 		throw new Error(`Model ${model.id} does not support V2 streaming compaction`);
 	}
 
-	const fetchImpl = options?.fetch ?? globalThis.fetch;
 	const retryWait = options?.retryWait ?? ((delayMs: number) => Bun.sleep(delayMs));
 	const isCodexResponses = compactionV2Api(model) === "openai-codex-responses" || model.provider === "openai-codex";
 	const codexMetadata =
@@ -293,7 +284,7 @@ export async function requestCompactionV2Streaming(
 	let lastError: Error | undefined;
 
 	for (let attempt = 0; attempt <= V2_COMPACTION_MAX_RETRIES; attempt++) {
-		const timeoutSignal = withRequestTimeout(signal, options?.timeoutMs ?? V2_COMPACTION_TIMEOUT_MS);
+		const timeoutSignal = ptree.combineSignals(signal, options?.timeoutMs ?? V2_COMPACTION_TIMEOUT_MS);
 		try {
 			return await attemptCompactionV2Streaming(endpoint, apiKey, model, request, fetchImpl, timeoutSignal, {
 				codexMetadata,

package/src/compaction/openai.ts

@@ -28,7 +28,6 @@ import {
 } from "@linxiraos/pi-ai/providers/openai-shared";
 import { transformMessages } from "@linxiraos/pi-ai/providers/transform-messages";
 import type {
-	Api,
 	AssistantMessage,
 	CodexCompactionContext,
 	FetchImpl,
@@ -37,12 +36,14 @@ import type {
 	ProviderSessionState,
 } from "@linxiraos/pi-ai/types";
 import {
+	dropMalformedOpenAIResponsesToolCalls,
 	getOpenAIResponsesHistoryItems,
 	getOpenAIResponsesHistoryPayload,
 	normalizeResponsesToolCallId,
 	stripOpenAIResponsesOutputOnlyStatusesForReplay,
 } from "@linxiraos/pi-ai/utils";
 import { captureOpenAIHttpError } from "@linxiraos/pi-ai/utils/openai-http";
+import { isBedrockOpenAIUrl } from "@linxiraos/pi-catalog/hosts";
 import {
 	applyCodexResidencyHeader,
 	CODEX_BASE_URL,
@@ -51,8 +52,11 @@ import {
 	OPENAI_HEADER_VALUES,
 	OPENAI_HEADERS,
 } from "@linxiraos/pi-catalog/wire/codex";
-import { $env, isRecord, logger, prompt, stringifyJson, structuredCloneJSON } from "@linxiraos/pi-utils";
+import { $env, isRecord, logger, prompt, ptree, stringifyJson, structuredCloneJSON } from "@linxiraos/pi-utils";
 import { Tokenizer } from "../tokenizer";
+import { appendAzureApiVersion, resolveAzureOpenAiBaseUrl } from "./azure-openai-endpoint";
+import { prepareBedrockCompactionRequest } from "./bedrock";
+import { isOpenAiRemoteCompactionApi } from "./compaction-v2-streaming";
 import contextWindowTruncatedOutputPrompt from "./prompts/context-window-truncated-output.md" with { type: "text" };
 
 export * from "./compaction-v2-streaming";
@@ -73,8 +77,6 @@ export const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
  */
 export const REMOTE_COMPACTION_TIMEOUT_MS = 300_000;
 
-const DEFAULT_AZURE_API_VERSION = "v1";
-
 export const CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE = prompt.render(contextWindowTruncatedOutputPrompt);
 
 const REMOTE_COMPACTION_REQUEST_OVERHEAD_TOKENS = 256;
@@ -262,13 +264,6 @@ export function assertRemoteCompactionInputFits(trimmed: TrimRemoteCompactionInp
 	);
 }
 
-/** Race the caller's signal against the request timeout; `timeoutMs <= 0` disables the watchdog. */
-function withRequestTimeout(signal: AbortSignal | undefined, timeoutMs: number): AbortSignal | undefined {
-	if (timeoutMs <= 0) return signal;
-	const timeout = AbortSignal.timeout(timeoutMs);
-	return signal ? AbortSignal.any([signal, timeout]) : timeout;
-}
-
 export type OpenAiRemoteCompactionItem = {
 	type: "compaction" | "compaction_summary";
 	encrypted_content?: string;
@@ -309,10 +304,6 @@ export interface RemoteCompactionResponse {
 // OpenAI provider gating + endpoint resolution
 // ============================================================================
 
-export function isOpenAiRemoteCompactionApi(api: Api | undefined): boolean {
-	return api === "openai-responses" || api === "azure-openai-responses" || api === "openai-codex-responses";
-}
-
 export function shouldUseOpenAiRemoteCompaction(model: Model): boolean {
 	if (model.remoteCompaction?.enabled === false) return false;
 	const compactionApi = model.remoteCompaction?.api ?? model.api;
@@ -323,6 +314,8 @@ export function shouldUseOpenAiRemoteCompaction(model: Model): boolean {
 		return (model.remoteCompaction?.endpoint?.trim().length ?? 0) > 0;
 	}
 	if (model.provider === "openai") return true;
+	// Amazon Bedrock's OpenAI routes serve `/responses/compact` without an opt-in.
+	if (compactionApi === "openai-responses" && isBedrockOpenAIUrl(model.baseUrl)) return true;
 	if (model.remoteCompaction?.enabled !== true) return false;
 	return isOpenAiRemoteCompactionApi(compactionApi);
 }
@@ -353,25 +346,6 @@ function resolveAzureOpenAiCompactEndpoint(model: Model, configuredEndpoint: str
 	return appendAzureApiVersion(endpoint);
 }
 
-function resolveAzureOpenAiBaseUrl(model: Model): string {
-	const baseUrl = $env.AZURE_OPENAI_BASE_URL?.trim() || undefined;
-	const resourceName = $env.AZURE_OPENAI_RESOURCE_NAME;
-	const resolvedBaseUrl =
-		baseUrl ?? (resourceName ? `https://${resourceName}.openai.azure.com/openai/v1` : undefined) ?? model.baseUrl;
-	if (!resolvedBaseUrl) {
-		throw new Error(
-			"Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or configure model.baseUrl.",
-		);
-	}
-	return resolvedBaseUrl.replace(/\/+$/, "");
-}
-
-function appendAzureApiVersion(endpoint: string): string {
-	if (/[?&]api-version=/.test(endpoint)) return endpoint;
-	const separator = endpoint.includes("?") ? "&" : "?";
-	return `${endpoint}${separator}api-version=${encodeURIComponent($env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION)}`;
-}
-
 function resolveOpenAiCompactModel(model: Model): string {
 	const requestModel = model.remoteCompaction?.model ?? model.requestModelId ?? model.id;
 	const compactionApi = model.remoteCompaction?.api ?? model.api;
@@ -564,7 +538,10 @@ export function buildOpenAiNativeHistory(
 						}
 					}
 				}
-				const historyItems = adaptComputerHistoryForCompaction(rawHistoryItems, model.supportsComputerUse === true);
+				const historyItems = adaptComputerHistoryForCompaction(
+					dropMalformedOpenAIResponsesToolCalls(rawHistoryItems),
+					model.supportsComputerUse === true,
+				);
 				input.push(...historyItems);
 				addOpenAiCallIds(historyItems, knownCallIds, customCallIds, computerCallIds);
 				msgIndex++;
@@ -616,7 +593,7 @@ export function buildOpenAiNativeHistory(
 					}
 				}
 				const historyItems = adaptComputerHistoryForCompaction(
-					providerPayload.items,
+					dropMalformedOpenAIResponsesToolCalls(providerPayload.items),
 					model.supportsComputerUse === true,
 				);
 				if (providerPayload.dt) {
@@ -805,6 +782,10 @@ export async function requestOpenAiRemoteCompaction(
 		codexCompaction?: CodexCompactionContext;
 	},
 ): Promise<OpenAiRemoteCompactionResponse> {
+	let fetchImpl: FetchImpl = opts?.fetch ?? fetch;
+	if (isBedrockOpenAIUrl(model.baseUrl)) {
+		({ model, apiKey, fetch: fetchImpl } = await prepareBedrockCompactionRequest(model, apiKey, opts?.fetch, signal));
+	}
 	const endpoint = resolveOpenAiCompactEndpoint(model);
 	const requestModel = resolveOpenAiCompactModel(model);
 	const trimmed = trimRemoteCompactionInputToContextWindow(
@@ -889,11 +870,11 @@ export async function requestOpenAiRemoteCompaction(
 		}
 	}
 
-	const response = await (opts?.fetch ?? fetch)(endpoint, {
+	const response = await fetchImpl(endpoint, {
 		method: "POST",
 		headers,
 		body: stringifyJson(request),
-		signal: withRequestTimeout(signal, opts?.timeoutMs ?? REMOTE_COMPACTION_TIMEOUT_MS),
+		signal: ptree.combineSignals(signal, opts?.timeoutMs ?? REMOTE_COMPACTION_TIMEOUT_MS),
 	});
 
 	if (!response.ok) {
@@ -945,10 +926,10 @@ export async function requestOpenAiRemoteCompaction(
 /**
  * Generic remote-compaction POST. Two wire shapes are auto-selected by
  * endpoint suffix so a single `compaction.remoteEndpoint` setting can point at
- * either a purpose-built omp summarizer (`{systemPrompt, prompt}` → `{summary}`)
+ * either a purpose-built zeta summarizer (`{systemPrompt, prompt}` → `{summary}`)
  * or any OpenAI-compatible chat-completions server (`/chat/completions`,
  * `/v1/chat/completions`, …) as reported for llama.cpp / vLLM / etc. in
- * issue #4630: without this, the omp payload was rejected with
+ * issue #4630: without this, the zeta payload was rejected with
  * HTTP 400 `"'messages' is required"`, compaction silently fell back to
  * local summarization, and context grew unbounded.
  *
@@ -992,7 +973,7 @@ export async function requestRemoteCompaction(
 		method: "POST",
 		headers,
 		body: stringifyJson(body),
-		signal: withRequestTimeout(signal, opts?.timeoutMs ?? REMOTE_COMPACTION_TIMEOUT_MS),
+		signal: ptree.combineSignals(signal, opts?.timeoutMs ?? REMOTE_COMPACTION_TIMEOUT_MS),
 	});
 
 	if (!response.ok) {

package/src/compaction/pruning.ts

@@ -9,6 +9,7 @@ import type { SessionEntry, SessionMessageEntry } from "./entries";
 import { invalidateMessageCache } from "./message-cache";
 import {
 	collectToolCallsById,
+	getToolResultMessage,
 	isProtectedToolResult,
 	isSkillReadToolResult,
 	type ProtectedToolMatcher,
@@ -61,6 +62,34 @@ export const DEFAULT_PRUNE_CONFIG: PruneConfig = {
 export interface PruneResult {
 	prunedCount: number;
 	tokensSaved: number;
+	/**
+	 * Restore every result this pass blanked. Pruning mutates entries in place,
+	 * so a caller whose persistence of the pruned history fails calls this to keep
+	 * memory matching what is durable.
+	 */
+	undo(): void;
+}
+
+const NOTHING_PRUNED: PruneResult = { prunedCount: 0, tokensSaved: 0, undo: () => {} };
+
+/** Blank `message` to `notice`, returning the step that restores it. */
+function blankToolResult(message: ToolResultMessage, notice: string, prunedAt: number): () => void {
+	const { content, prunedAt: previousPrunedAt } = message;
+	message.content = [{ type: "text", text: notice }];
+	message.prunedAt = prunedAt;
+	invalidateMessageCache(message as AgentMessage);
+	return () => {
+		message.content = content;
+		message.prunedAt = previousPrunedAt;
+		invalidateMessageCache(message as AgentMessage);
+	};
+}
+
+/** Combine per-message restore steps into one {@link PruneResult.undo}. */
+function undoAll(steps: Array<() => void>): () => void {
+	return () => {
+		for (const step of steps) step();
+	};
 }
 
 /** Exact placeholder written over a superseded tool result. */
@@ -122,13 +151,6 @@ function createPrunedNotice(tokens: number): string {
  */
 export const MIN_PRUNE_TOKENS = 50;
 
-function getToolResultMessage(entry: SessionEntry): ToolResultMessage | undefined {
-	if (entry.type !== "message") return undefined;
-	const message = entry.message as AgentMessage;
-	if (message.role !== "toolResult") return undefined;
-	return message as ToolResultMessage;
-}
-
 function estimatePrunedSavings(tokens: number, notice: string): number {
 	const noticeTokens = Math.ceil(notice.length / 4);
 	return Math.max(0, tokens - noticeTokens);
@@ -263,7 +285,7 @@ export function pruneSupersededToolResults(
 		candidates.push(...collectUselessResults(entries, tokenizer, toolCallsById, config.protectedTools, exclude));
 		candidates.sort((a, b) => a.index - b.index);
 	}
-	if (candidates.length === 0) return { prunedCount: 0, tokensSaved: 0 };
+	if (candidates.length === 0) return NOTHING_PRUNED;
 
 	const now = config.now ?? Date.now();
 	let lastMessageTimestamp: number | undefined;
@@ -296,17 +318,15 @@ export function pruneSupersededToolResults(
 			candidate => candidate.index >= boundaryIndex && suffixTokens[candidate.index] <= suffixTokenLimit,
 		);
 	}
-	if (toPrune.length === 0) return { prunedCount: 0, tokensSaved: 0 };
+	if (toPrune.length === 0) return NOTHING_PRUNED;
 
 	const prunedAt = Date.now();
 	let tokensSaved = 0;
-	for (const candidate of toPrune) {
-		candidate.message.content = [{ type: "text", text: candidate.notice }];
-		candidate.message.prunedAt = prunedAt;
-		invalidateMessageCache(candidate.message as AgentMessage);
+	const steps = toPrune.map(candidate => {
 		tokensSaved += estimatePrunedSavings(candidate.tokens, candidate.notice);
-	}
-	return { prunedCount: toPrune.length, tokensSaved };
+		return blankToolResult(candidate.message, candidate.notice, prunedAt);
+	});
+	return { prunedCount: toPrune.length, tokensSaved, undo: undoAll(steps) };
 }
 
 export function pruneToolOutputs(
@@ -316,7 +336,6 @@ export function pruneToolOutputs(
 ): PruneResult {
 	let accumulatedTokens = 0;
 	let tokensSaved = 0;
-	let prunedCount = 0;
 
 	const candidates: Array<{ entry: SessionMessageEntry; tokens: number; superseded: boolean; useless: boolean }> = [];
 	const toolCallsById = collectToolCallsById(entries);
@@ -400,24 +419,20 @@ export function pruneToolOutputs(
 	}
 
 	if (tokensSaved < config.minimumSavings || candidates.length === 0) {
-		return { prunedCount: 0, tokensSaved: 0 };
+		return NOTHING_PRUNED;
 	}
 
 	const prunedAt = Date.now();
-	for (const candidate of candidates) {
-		const message = candidate.entry.message as ToolResultMessage;
+	const steps = candidates.map(candidate => {
 		const notice = candidate.superseded
 			? SUPERSEDED_NOTICE
 			: candidate.useless
 				? USELESS_NOTICE
 				: createPrunedNotice(candidate.tokens);
-		message.content = [{ type: "text", text: notice }];
-		message.prunedAt = prunedAt;
-		invalidateMessageCache(message as AgentMessage);
-		prunedCount++;
-	}
+		return blankToolResult(candidate.entry.message as ToolResultMessage, notice, prunedAt);
+	});
 
-	return { prunedCount, tokensSaved };
+	return { prunedCount: candidates.length, tokensSaved, undo: undoAll(steps) };
 }
 
 /**

package/src/compaction/shake.ts

@@ -18,6 +18,7 @@ import type { CustomMessageEntry, SessionEntry, SessionMessageEntry } from "./en
 import { invalidateMessageCache } from "./message-cache";
 import {
 	collectToolCallsById,
+	getToolResultMessage,
 	isArtifactRecoveryToolResult,
 	isProtectedToolResult,
 	isSkillReadToolResult,
@@ -109,13 +110,6 @@ export type ShakeRegion = ToolResultShakeRegion | BlockShakeRegion;
 const OPENING_XML = /^<([a-z_-]+)(?:\s+[^>]*)?>$/;
 const CLOSING_XML = /^<\/([a-z_-]+)>$/;
 
-function getToolResultMessage(entry: SessionEntry): ToolResultMessage | undefined {
-	if (entry.type !== "message") return undefined;
-	const message = entry.message as AgentMessage;
-	if (message.role !== "toolResult") return undefined;
-	return message as ToolResultMessage;
-}
-
 function toolResultText(
 	message: ToolResultMessage,
 	tokenizer: Tokenizer,

package/src/compaction/tool-protection.ts

@@ -1,5 +1,5 @@
 import type { ToolResultMessage } from "@linxiraos/pi-ai";
-import type { AgentToolCall } from "../types";
+import type { AgentMessage, AgentToolCall } from "../types";
 import type { SessionEntry } from "./entries";
 
 export interface ProtectedToolContext {
@@ -24,6 +24,14 @@ export function collectToolCallsById(entries: readonly SessionEntry[]): Map<stri
 	return toolCalls;
 }
 
+/** Return the tool-result message carried by a session entry, if any. */
+export function getToolResultMessage(entry: SessionEntry): ToolResultMessage | undefined {
+	if (entry.type !== "message") return undefined;
+	const message = entry.message as AgentMessage;
+	if (message.role !== "toolResult") return undefined;
+	return message as ToolResultMessage;
+}
+
 /**
  * Extract the `path` argument from a paired `read` tool call, when the result
  * is a `read` result carrying a string path. Returns `undefined` otherwise.

package/src/proxy.ts

@@ -21,6 +21,7 @@ import {
 	setStreamingPartialJson,
 } from "@linxiraos/pi-ai/utils/block-symbols";
 import { parseStreamingJson, parseStreamingJsonThrottled, readSseJson } from "@linxiraos/pi-utils";
+import { parseToolCallArguments } from "@linxiraos/pi-ai/utils/tool-call-arguments";
 
 // Event stream adapter for proxy SSE events
 export class ProxyMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
@@ -378,7 +379,7 @@ function processProxyEvent(
 				// throttle may have skipped trailing deltas, so the last
 				// parsed arguments can lag the accumulated buffer.
 				const acc = partialJsonByIndex.get(proxyEvent.contentIndex);
-				if (acc !== undefined && acc.length > 0) content.arguments = parseStreamingJson(acc) || {};
+				if (acc !== undefined && acc.length > 0) content.arguments = parseToolCallArguments(acc) || {};
 				partialJsonByIndex.delete(proxyEvent.contentIndex);
 				parsedLenByIndex.delete(proxyEvent.contentIndex);
 				clearStreamingPartialJson(content);
@@ -427,6 +428,6 @@ function finalizeBufferedArguments(partial: AssistantMessage, partialJsonByIndex
 	for (const [index, acc] of partialJsonByIndex) {
 		if (acc.length === 0) continue;
 		const content = partial.content[index];
-		if (content?.type === "toolCall") content.arguments = parseStreamingJson(acc) || {};
+		if (content?.type === "toolCall") content.arguments = parseToolCallArguments(acc) || {};
 	}
 }

package/src/speculative-execution.ts

@@ -714,12 +714,12 @@ export class SpeculativeOperationCoordinator {
 		try {
 			validatedArgs = validateToolArguments(tool, toolCall);
 		} catch {
-			if (!tool.lenientArgValidation) {
+			// Lenience covers schema mismatches; a parse failure has no args to hand over.
+			if (!tool.lenientArgValidation || "__parseError" in toolCall.arguments) {
 				this.ineligible(toolCall, "tool arguments are not valid", source, parentToolCallId);
 				return undefined;
 			}
-			validatedArgs = { ...(toolCall.arguments as Record<string, unknown>) };
-			delete validatedArgs.__parseError;
+			validatedArgs = { ...toolCall.arguments };
 			delete validatedArgs.__rawJson;
 		}
 		let executionArgs: Record<string, unknown>;

package/src/telemetry.ts

@@ -722,7 +722,7 @@ export function startChatSpan(
 		model,
 		parent: options.parent,
 		stepNumber: options.stepNumber,
-		attributes: buildChatRequestAttributes(options.stepNumber, options.request, model.provider),
+		attributes: buildChatRequestAttributes(options.stepNumber, options.request, model),
 	});
 	if (span) {
 		telemetry?.collector.beginChat(span, {
@@ -756,7 +756,7 @@ export interface ChatRequestSnapshot {
 	readonly messages?: readonly Message[];
 }
 
-function buildChatRequestAttributes(stepNumber: number, request: ChatRequestSnapshot, provider: string): Attributes {
+function buildChatRequestAttributes(stepNumber: number, request: ChatRequestSnapshot, model: Model): Attributes {
 	const attrs: Attributes = {
 		[OmpGenAIAttr.AgentStepNumber]: stepNumber,
 		[GenAIAttr.OutputType]: "text",
@@ -772,7 +772,8 @@ function buildChatRequestAttributes(stepNumber: number, request: ChatRequestSnap
 	if (request.stopSequences && request.stopSequences.length > 0) {
 		attrs[GenAIAttr.RequestStopSequences] = [...request.stopSequences];
 	}
-	if (request.serviceTier && shouldSendServiceTier(request.serviceTier, provider)) {
+	// Record the tier only when it reaches the wire for this model (Codex drops unadvertised tiers).
+	if (request.serviceTier && shouldSendServiceTier(request.serviceTier, model)) {
 		attrs[OpenAIAttr.RequestServiceTier] = request.serviceTier;
 	}
 	if (request.reasoningEffort) attrs[OmpGenAIAttr.RequestReasoningEffort] = request.reasoningEffort;

package/src/types.ts

@@ -906,6 +906,13 @@ export interface AfterToolCallResult {
 	isError?: boolean;
 	/** If provided, replaces the contextually-useless flag carried with the tool result. */
 	useless?: boolean;
+	/**
+	 * Trusted post-tool instructions for the next provider request. Delivered
+	 * outside the tool result, after all calls in the batch settle. Unlike
+	 * `BeforeToolCallResult.additionalContext`, this is retained for error
+	 * results because the callback receives the finalized outcome.
+	 */
+	additionalContext?: string;
 }
 
 /** Context passed to `beforeToolCall`. */
@@ -1136,7 +1143,7 @@ export interface AgentTool<
 	 * before ordinary dispatch commits its result.
 	 */
 	speculation?: ToolSpeculationPolicy;
-	/** If true, argument validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM. */
+	/** If true, schema validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM. Malformed argument JSON still returns the parse error. */
 	lenientArgValidation?: boolean;
 	/**
 	 * Whether the agent loop may abort this tool mid-execution — or skip it