@oh-my-pi/pi-agent-core 18.6.0 → 18.6.3

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [18.6.3] - 2026-10-06
+
+### Breaking Changes
+
+- `Agent.withdrawUndeliveredQueuedMessages()` replaces `withdrawLiveSteering()` and returns `{ steering, followUp }`: it also takes back queued input already dequeued for the next model call, which the aborted run then neither records nor reports in `agent_end` ([#14179](https://github.com/can1357/oh-my-pi/pull/14179) by [@andrebrait](https://github.com/andrebrait))
+
+### Added
+
+- Added `Agent.setOnModelCallSystemPrompt`, called with the exact system prompt each model call is built from ([#14338](https://github.com/can1357/oh-my-pi/pull/14338) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Changed
+
+- `SessionInitEntry.systemPrompt` holds the system prompt blocks as sent; session files written earlier keep one joined string ([#14338](https://github.com/can1357/oh-my-pi/pull/14338) by [@will-bogusz](https://github.com/will-bogusz))
+- Image token estimates now use the catalog's `imageTokens()` formula with its OpenAI Responses wire rule; values are unchanged ([#14286](https://github.com/can1357/oh-my-pi/pull/14286) by [@will-bogusz](https://github.com/will-bogusz)).
+
+### Fixed
+
+- Fixed the context count and auto-compaction trigger pricing every snapcompact archive frame at Opus's high-res rate, which overcounted Codex and Gemini sessions and could re-trigger compaction right after compacting ([#14291](https://github.com/can1357/oh-my-pi/pull/14291) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed native (OpenAI) compaction being refused as over the context window in sessions with many screenshots. Images were counted as about 1,200 tokens when deciding to compact but 12,000 when checking whether the compaction request fits; both checks now estimate images from their actual dimensions, and a request is no longer refused when only the image estimate pushes it over the window ([#14260](https://github.com/can1357/oh-my-pi/pull/14260) by [@H4vC](https://github.com/H4vC)).
+- Fixed OpenAI and Codex Remote Compaction V2 dropping your recent messages instead of keeping them next to the compaction summary ([#14247](https://github.com/can1357/oh-my-pi/pull/14247) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed the failed V2 remote compaction warning claiming a V1 fallback on Codex, where V1 does not run ([#14245](https://github.com/can1357/oh-my-pi/pull/14245) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed Anthropic native compaction being rejected with `Invalid signature in thinking block` (or silently dropping the summarized thinking) on models with preserved thinking ([#14251](https://github.com/can1357/oh-my-pi/pull/14251) by [@will-bogusz](https://github.com/will-bogusz))
+
+## [18.6.1] - 2026-10-04
+
+### Fixed
+
+- Fixed native OpenAI context compaction for sessions containing many screenshots, preventing image-size estimates from incorrectly causing compaction requests to be rejected.
+
 ## [18.6.0] - 2026-10-03
 
 ### Fixed

package/dist/types/agent.d.ts

@@ -390,8 +390,8 @@ export declare class Agent {
     get state(): AgentState;
     /**
      * Tokenizer for the active model. The instance is replaced whenever the
-     * active model's encoding changes (see {@link setModel}), so callers must
-     * not cache it across model switches.
+     * active model's encoding or snapcompact frame pricing changes (see
+     * {@link setModel}), so callers must not cache it across model switches.
      */
     get tokenizer(): Tokenizer;
     get appendOnlyContext(): AppendOnlyContextManager | undefined;
@@ -422,10 +422,15 @@ export declare class Agent {
     /** 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.
+     * Take back dequeued input the transcript has not recorded yet, ahead of an abort (Esc restores
+     * it to the editor): steering live steering took for the in-flight response, then each batch
+     * dequeued for the next model call, oldest first. The aborted run then neither records it (or
+     * the context prepared for it) nor requeues it.
      */
-    withdrawLiveSteering(): AgentMessage[];
+    withdrawUndeliveredQueuedMessages(): {
+        steering: AgentMessage[];
+        followUp: 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[];
@@ -434,6 +439,8 @@ export declare class Agent {
     setAssistantMessageEventInterceptor(fn: ((message: AssistantMessage, event: AssistantMessageEvent) => void) | undefined): void;
     setOnBeforeYield(fn: (() => Promise<void> | void) | undefined): void;
     setOnTurnEnd(fn: ((messages: AgentMessage[], signal?: AbortSignal, context?: AgentTurnEndContext) => Promise<void> | void) | undefined): void;
+    /** Called with the exact system prompt each model call is built from, after before-model-call hooks. */
+    setOnModelCallSystemPrompt(fn: ((systemPrompt: string[]) => void) | undefined): void;
     /**
      * Install or replace the host pre-model-call gate; pass `undefined` to
      * remove it. Gates are sampled when a run starts: installing the first

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

@@ -1,11 +1,12 @@
 /**
  * Anthropic on-demand compaction (`compact-2026-09-04` beta).
  *
- * The request sends only the prefix to summarize, with the live conversation's
- * system prompt, tools and thinking settings. The returned signed block
- * replaces that prefix; the retained tail is replayed from session entries.
+ * The request sends only the prefix to summarize, as the live conversation
+ * sent it: same system prompt, tools, history bytes and thinking settings.
+ * The returned signed block replaces that prefix; the retained tail is
+ * replayed from session entries.
  */
-import type { AnthropicCompactionPayload, ApiKey, Effort, Message, Model, SimpleStreamOptions, Tool, Usage } from "@oh-my-pi/pi-ai";
+import type { AnthropicCompactionFiles, AnthropicCompactionPayload, ApiKey, Context, Effort, Model, SimpleStreamOptions, Usage } from "@oh-my-pi/pi-ai";
 import { type InstrumentedChatSpanOptions } from "../telemetry.js";
 import type { AgentMessage } from "../types.js";
 export declare const ANTHROPIC_COMPACTION_PRESERVE_KEY = "anthropicCompaction";
@@ -17,8 +18,12 @@ export interface AnthropicCompactionPreserveData {
     signature?: string;
     /** Legacy threshold block state; replay-only. */
     encryptedContent?: string;
-    /** Harness file metadata (`<files>` section) replayed after the native block. */
+    /** Harness file metadata (`<files>` section) replayed after the retained tail. */
     filesText?: string;
+    /** Earlier summaries' file metadata replayed inside the retained tail. */
+    retainedFiles?: AnthropicCompactionFiles[];
+    /** The retained tail replays unchanged (see `AnthropicCompactionPayload.exactTail`). */
+    exactTail?: true;
     /** Model that wrote the summary. */
     model?: string;
     /** Prompt tokens the compaction request processed, for display. */
@@ -51,10 +56,11 @@ export declare function findAnthropicCompactionCut(messages: readonly (AgentMess
 /** Instructions replace the API default; the request contains only summarized messages. */
 export declare function buildAnthropicCompactionInstructions(basePrompt: string, customInstructions: string | undefined, extraContext: string | undefined): string;
 export interface AnthropicNativeCompactionRequest {
-    systemPrompt: string[];
-    messages: Message[];
-    tools?: Tool[];
+    /** The summarized prefix as the live turn would send it. */
+    context: Context;
     instructions: string;
+    /** Replayed file metadata due before this time ends the request (see `AnthropicCompactionRequest.filesDueBefore`). */
+    filesDueBefore?: number;
     maxTokens: number;
     reasoning?: Effort;
 }

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

@@ -26,6 +26,8 @@ export interface CompactionV2Usage {
 export interface CompactionV2Request {
     body: OpenAICodexCompactionBody;
     input: unknown[];
+    /** Serialized user-written turns to keep next to the compaction item; defaults to `input`. */
+    retainedUserItems: unknown[];
     retainedMessageBudget: number;
     sessionId?: string;
     promptCacheKey?: string;
@@ -56,12 +58,14 @@ export declare function buildCompactionV2Request(model: Model, input: unknown[],
     sessionId?: string;
     promptCacheKey?: string;
     retainedMessageBudget?: number;
+    retainedUserItems?: unknown[];
 }): CompactionV2Request;
 /** Wrap a body built by the normal Codex serializer for V2 compaction transport. */
 export declare function buildCompactionV2RequestFromBody(model: Model, body: OpenAICodexCompactionBody, options?: {
     sessionId?: string;
     promptCacheKey?: string;
     retainedMessageBudget?: number;
+    retainedUserItems?: unknown[];
 }): CompactionV2Request;
 /** Request V2 compaction over the normal OpenAI Responses streaming endpoint. */
 export declare function requestCompactionV2Streaming(model: Model, apiKey: string, request: CompactionV2Request, signal?: AbortSignal, options?: {
@@ -72,7 +76,7 @@ export declare function requestCompactionV2Streaming(model: Model, apiKey: strin
     codexCompaction?: CodexCompactionContext;
     preferWebsockets?: boolean;
 }): Promise<CompactionV2Response>;
-/** Build Codex-style V2 replacement history from prompt input plus compaction output. */
+/** Build Codex-style V2 replacement history from retention candidates plus compaction output. */
 export declare function buildCompactionV2ReplacementHistory(input: unknown[], compactionItem: Record<string, unknown>, retainedMessageBudget?: number): {
     replacementHistory: Array<Record<string, unknown>>;
     retainedImageCount: number;

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

@@ -177,6 +177,20 @@ export interface SummaryOptions {
     initiatorOverride?: MessageAttribution;
     metadata?: Record<string, unknown>;
     convertToLlm?: ConvertToLlm;
+    /**
+     * The provider context a live turn sends for `summarized` + `retained`, cut to
+     * `summarized`. Anthropic on-demand compaction sends it so retained signed
+     * thinking keeps its prefix; without it the request uses `remoteSystemPrompt`,
+     * `tools` and `convertToLlm`.
+     */
+    buildProviderContext?: (summarized: AgentMessage[], retained: AgentMessage[], signal?: AbortSignal) => Promise<Context>;
+    /**
+     * Whether a message is a turn the user wrote. Remote Compaction V2 keeps these
+     * next to the compaction item. Defaults to `role === "user"`; hosts whose
+     * user-initiated turns also arrive as custom messages (e.g. skill invocations)
+     * widen it.
+     */
+    isUserAuthored?: (message: AgentMessage) => boolean;
     /**
      * Optional telemetry handle. When provided, every LLM call emitted during
      * compaction is wrapped in an OTEL chat span tagged with

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

@@ -88,8 +88,8 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
 }
 export interface SessionInitEntry extends SessionEntryBase {
     type: "session_init";
-    /** Full system prompt sent to the model */
-    systemPrompt: string;
+    /** System prompt blocks exactly as sent to the model; files written before blocks were kept store one joined string. */
+    systemPrompt: string[] | string;
     /** Initial task/user message */
     task: string;
     /** Tools available to the agent */

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

@@ -28,19 +28,31 @@ export declare const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompac
  */
 export declare const REMOTE_COMPACTION_TIMEOUT_MS = 300000;
 export declare const CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE: string;
+/**
+ * Tokens of stored Responses replacement history. Retained `input_image` parts
+ * count at their image estimate rather than as base64 text; everything else,
+ * opaque compaction state included, counts as serialized.
+ */
+export declare function countResponsesHistoryTokens(items: unknown[], tokenizer: Tokenizer): number;
 export interface TrimRemoteCompactionInputResult {
     input: Array<Record<string, unknown>>;
     rewrittenOutputs: number;
     estimatedTokensBefore: number;
     estimatedTokensAfter: number;
-    /** Whether `input` fits the model window; false means it must not be sent. */
+    /**
+     * Whether `input` may be sent; false means it must not be. True when the
+     * full estimate fits, or when only the image estimate pushes it over (image
+     * pricing is a guess; the provider's own accounting decides).
+     */
     fits: boolean;
 }
 /**
  * Preserve the full native transcript unless trailing tool outputs alone push a
  * remote compaction request beyond the model window. Replacing only those
  * outputs keeps call/result pairing and all earlier assistant/reasoning history,
- * matching Codex's recovery path for oversized tool turns.
+ * matching Codex's recovery path for oversized tool turns. A request whose text
+ * fits but whose image estimate does not is still sendable: refusing it on an
+ * image guess would skip native compaction the provider would have accepted.
  */
 export declare function trimRemoteCompactionInputToContextWindow(input: Array<Record<string, unknown>>, tokenizer: Tokenizer, contextWindow: number | null | undefined, instructions: string, tools?: unknown[]): TrimRemoteCompactionInputResult;
 /**

package/dist/types/image-tokens.d.ts

@@ -0,0 +1,29 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { type ImageSize } from "@oh-my-pi/pi-catalog/compat/image-tokenization";
+/**
+ * Dimension-based image token estimates shared by the local context counter
+ * ({@link Tokenizer.countMessage}) and the native remote-compaction fit probe.
+ * Both sides must price the same image the same way: when they disagreed
+ * (1.2k flat locally vs a 12k flat worst case remotely) an image-heavy session
+ * stayed under the local compaction trigger yet was refused as over-window by
+ * the remote probe.
+ *
+ * Follows the catalog's image rule for the OpenAI Responses wire (GPT-5.5's
+ * 32px patches, a per-detail pixel limit and patch budget, x1.2 multiplier),
+ * which is also a close upper estimate for other providers once omp has
+ * downscaled the image (≤1568px by default).
+ */
+/** OpenAI image `detail` values; `undefined` means the provider default (`auto`). */
+export type ImageDetail = ImageContent["detail"];
+export type { ImageSize };
+/**
+ * Estimated input tokens for one image. Unknown dimensions (undecodable data,
+ * remote URLs, provider file ids) charge the detail level's full patch budget.
+ */
+export declare function estimateImageTokens(size: ImageSize | null | undefined, detail?: ImageDetail): number;
+/** Pixel size read from the header of base64-encoded image data, or null. */
+export declare function base64ImageSize(base64: string): ImageSize | null;
+/** Pixel size of a `data:<mime>;base64,` URL, or null for any other URL. */
+export declare function dataUrlImageSize(url: string): ImageSize | null;
+/** {@link estimateImageTokens} for an in-memory image block. */
+export declare function estimateImageContentTokens(image: Pick<ImageContent, "data" | "detail">): number;

package/dist/types/tokenizer.d.ts

@@ -1,5 +1,6 @@
 import type { Model } from "@oh-my-pi/pi-ai";
 import * as natives from "@oh-my-pi/pi-natives";
+import * as snapcompact from "@oh-my-pi/snapcompact";
 import type { AgentMessage } from "./types.js";
 /** Maps the catalog-resolved tokenizer family to its native implementation. */
 export declare function tokenizerEncodingForModel(model: Pick<Model, "tokenizer"> | null | undefined): natives.Encoding | null;
@@ -42,14 +43,15 @@ export interface TokenBudgetCheck {
  * Model-aware local token counter. Immutable: the catalog-resolved encoding
  * is fixed at construction, so a cached count can never straddle two
  * encodings. An `Agent` owns one for its active model (swapping the instance
- * when the model's encoding changes); one-shot flows construct their own for
- * the model that will be billed. Known tokenizer families use exact native
- * counts; unknown models keep the fast byte estimate (or o200k when
- * `PI_TOKENIZER_ACCURATE=1`).
+ * when the model's encoding or snapcompact frame pricing changes); one-shot
+ * flows construct their own for the model that will be billed. Known
+ * tokenizer families use exact native counts; unknown models keep the fast
+ * byte estimate (or o200k when `PI_TOKENIZER_ACCURATE=1`).
  */
 export declare class Tokenizer {
     #private;
-    constructor(model?: Pick<Model, "tokenizer"> | null);
+    readonly frameBillingKey: string;
+    constructor(model?: (Pick<Model, "tokenizer"> & snapcompact.ShapeTarget) | null);
     get encoding(): natives.Encoding | null;
     countTokens(text: string | string[], mode?: TokenCountMode): number;
     /**
@@ -70,7 +72,8 @@ export declare class Tokenizer {
      * Settled historical messages are counted once and reused until an owner
      * (prune/shake/strip-images) calls `invalidateMessageCache`; streaming
      * assistants bypass the memo entirely (see the message-cache settle-gate
-     * invariant). Image blocks charge a fixed per-image estimate.
+     * invariant). Image blocks charge {@link estimateImageContentTokens}, the
+     * same dimension-based estimate the native remote-compaction probe applies.
      */
     countMessage(message: AgentMessage, options?: MessageCountOptions): number;
     /** Sum of {@link countMessage} over `messages`. */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "18.6.0",
+	"version": "18.6.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.6.0",
-		"@oh-my-pi/pi-catalog": "18.6.0",
-		"@oh-my-pi/pi-natives": "18.6.0",
-		"@oh-my-pi/pi-utils": "18.6.0",
-		"@oh-my-pi/pi-wire": "18.6.0",
-		"@oh-my-pi/snapcompact": "18.6.0",
+		"@oh-my-pi/pi-ai": "18.6.3",
+		"@oh-my-pi/pi-catalog": "18.6.3",
+		"@oh-my-pi/pi-natives": "18.6.3",
+		"@oh-my-pi/pi-utils": "18.6.3",
+		"@oh-my-pi/pi-wire": "18.6.3",
+		"@oh-my-pi/snapcompact": "18.6.3",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "18.6.0",
+		"@oh-my-pi/omptype": "18.6.3",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@types/bun": "^1.3.14"

package/src/agent.ts

@@ -26,6 +26,7 @@ import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
 import type { HarmonyAuditEvent } from "@oh-my-pi/pi-ai/utils/harmony-leak";
 import { getBundledModel } from "@oh-my-pi/pi-catalog/models";
 import { logger } from "@oh-my-pi/pi-utils";
+import * as snapcompact from "@oh-my-pi/snapcompact";
 import {
 	abortReasonText,
 	agentLoop,
@@ -386,6 +387,13 @@ interface CursorToolResultEntry {
 
 type QueuedMessageQueue = "steering" | "followUp";
 
+interface LiveSteeredEntry {
+	message: AgentMessage;
+	controller: AbortController | undefined;
+	/** Context preparation committed for the batch, carried by its last adopted entry. Never requeued. */
+	additional?: readonly AgentMessage[];
+}
+
 interface QueuedMessageClaim {
 	messages: AgentMessage[];
 	controller: AbortController;
@@ -420,16 +428,20 @@ export class Agent {
 	 * 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.
+	 * {@link withdrawUndeliveredQueuedMessages} takes it back ahead of an abort.
 	 */
-	#liveSteered: { message: AgentMessage; controller: AbortController | undefined }[] = [];
-	/** Dequeued originals remain recoverable until their transcript events arrive. */
+	#liveSteered: LiveSteeredEntry[] = [];
+	/** Dequeued originals remain recoverable until their transcript events arrive. `additional` is
+	 *  the context preparation appended after them, which the transcript records with them. */
 	#queuedMessageDeliveries = new Set<{
 		queue: QueuedMessageQueue;
 		controller: AbortController | undefined;
 		messages: AgentMessage[];
 		next: number;
+		additional: readonly AgentMessage[];
 	}>();
+	/** Messages {@link withdrawUndeliveredQueuedMessages} took back, keyed to the run that must not record them. */
+	#withdrawnMessages = new WeakMap<AgentMessage, AbortController>();
 	#steeringWaiters = new Set<() => void>();
 	#queuedMessageGrouping?: (previous: AgentMessage, next: AgentMessage) => boolean;
 
@@ -484,6 +496,7 @@ export class Agent {
 	#onHarmonyLeak?: (event: HarmonyAuditEvent) => void | Promise<void>;
 	#onBeforeYield?: () => Promise<void> | void;
 	#onTurnEnd?: (messages: AgentMessage[], signal?: AbortSignal, context?: AgentTurnEndContext) => Promise<void> | void;
+	#onModelCallSystemPrompt?: (systemPrompt: string[]) => void;
 	#beforeModelCall?: AgentBeforeModelCall;
 	#additionalBeforeModelCalls = new Set<AgentBeforeModelCall>();
 	#asideMessageProvider?: () => AsideMessage[] | Promise<AsideMessage[]>;
@@ -831,19 +844,22 @@ export class Agent {
 
 	/**
 	 * Tokenizer for the active model. The instance is replaced whenever the
-	 * active model's encoding changes (see {@link setModel}), so callers must
-	 * not cache it across model switches.
+	 * active model's encoding or snapcompact frame pricing changes (see
+	 * {@link setModel}), so callers must not cache it across model switches.
 	 */
 	get tokenizer(): Tokenizer {
 		return this.#tokenizer;
 	}
 
 	/**
-	 * Swap the tokenizer only when the encoding actually changes, so the warm
-	 * per-message memo survives same-encoding model switches.
+	 * Swap the tokenizer only when the encoding or frame pricing actually
+	 * changes, so the warm per-message memo survives same-pricing model switches.
 	 */
 	#syncTokenizer(model: Model | null | undefined): void {
-		if (tokenizerEncodingForModel(model) !== this.#tokenizer.encoding) {
+		if (
+			tokenizerEncodingForModel(model) !== this.#tokenizer.encoding ||
+			snapcompact.frameBillingKey(snapcompact.frameBilling(model ?? undefined)) !== this.#tokenizer.frameBillingKey
+		) {
 			this.#tokenizer = new Tokenizer(model);
 		}
 	}
@@ -967,7 +983,7 @@ export class Agent {
 		if (messages.length === 0) return messages;
 		const runController = this.#abortController;
 		if (!prepare) {
-			this.#queuedMessageDeliveries.add({ queue, controller: runController, messages, next: 0 });
+			this.#queuedMessageDeliveries.add({ queue, controller: runController, messages, next: 0, additional: [] });
 			return messages;
 		}
 
@@ -986,7 +1002,13 @@ export class Agent {
 				throw new DOMException("Queued message preparation cancelled", "AbortError");
 			}
 			delete this.#queuedMessageClaims[queue];
-			this.#queuedMessageDeliveries.add({ queue, controller: runController, messages, next: 0 });
+			this.#queuedMessageDeliveries.add({
+				queue,
+				controller: runController,
+				messages,
+				next: 0,
+				additional: additional ?? [],
+			});
 			return additional?.length ? [...messages, ...additional] : messages;
 		} catch (error) {
 			if (signal.aborted) throw error;
@@ -1048,10 +1070,15 @@ export class Agent {
 			const pending = delivery.messages.slice(delivery.next);
 			const kept = pending.filter(message => !taken.includes(message));
 			if (kept.length === pending.length) continue;
+			let last: LiveSteeredEntry | undefined;
 			for (const message of pending) {
-				if (taken.includes(message)) this.#liveSteered.push({ message, controller: delivery.controller });
+				if (!taken.includes(message)) continue;
+				last = { message, controller: delivery.controller };
+				this.#liveSteered.push(last);
 			}
 			if (kept.length === 0) {
+				// The delivery record goes away; keep its context withdrawable with the adopted batch.
+				if (last && delivery.additional.length > 0) last.additional = delivery.additional;
 				this.#queuedMessageDeliveries.delete(delivery);
 			} else {
 				delivery.messages = kept;
@@ -1061,13 +1088,29 @@ export class Agent {
 	}
 
 	/**
-	 * Take back live-steered messages ahead of an abort (Esc restores them to the editor):
-	 * the aborted run then neither records nor requeues them.
+	 * Take back dequeued input the transcript has not recorded yet, ahead of an abort (Esc restores
+	 * it to the editor): steering live steering took for the in-flight response, then each batch
+	 * dequeued for the next model call, oldest first. The aborted run then neither records it (or
+	 * the context prepared for it) nor requeues it.
 	 */
-	withdrawLiveSteering(): AgentMessage[] {
-		const messages = this.peekLiveSteeredMessages();
+	withdrawUndeliveredQueuedMessages(): { steering: AgentMessage[]; followUp: AgentMessage[] } {
+		const withdrawn: Record<QueuedMessageQueue, AgentMessage[]> = { steering: [], followUp: [] };
+		const suppress = (message: AgentMessage, controller: AbortController | undefined) => {
+			if (controller) this.#withdrawnMessages.set(message, controller);
+		};
+		for (const { message, controller, additional } of this.#liveSteered) {
+			withdrawn.steering.push(message);
+			suppress(message, controller);
+			for (const context of additional ?? []) suppress(context, controller);
+		}
 		this.#liveSteered = [];
-		return messages;
+		for (const delivery of this.#queuedMessageDeliveries) {
+			const pending = delivery.messages.slice(delivery.next);
+			withdrawn[delivery.queue].push(...pending);
+			for (const message of [...pending, ...delivery.additional]) suppress(message, delivery.controller);
+		}
+		this.#queuedMessageDeliveries.clear();
+		return withdrawn;
 	}
 
 	/** Steering live steering took for the streaming response; the transcript records it once
@@ -1101,6 +1144,11 @@ export class Agent {
 		this.#onTurnEnd = fn;
 	}
 
+	/** Called with the exact system prompt each model call is built from, after before-model-call hooks. */
+	setOnModelCallSystemPrompt(fn: ((systemPrompt: string[]) => void) | undefined): void {
+		this.#onModelCallSystemPrompt = fn;
+	}
+
 	/**
 	 * Install or replace the host pre-model-call gate; pass `undefined` to
 	 * remove it. Gates are sampled when a run starts: installing the first
@@ -1800,6 +1848,7 @@ export class Agent {
 					await Bun.sleep(0);
 				}
 				context.systemPrompt = this.#state.systemPrompt;
+				this.#onModelCallSystemPrompt?.(context.systemPrompt);
 				context.tools = this.#toolsForModel(this.#state.model ?? model);
 			},
 			beforeModelCall:
@@ -1879,8 +1928,19 @@ export class Agent {
 				? agentLoop(messages, context, config, loopSignal, this.streamFn)
 				: agentLoopContinue(context, config, loopSignal, this.streamFn);
 
-			for await (const event of stream) {
+			for await (let event of stream) {
 				if (this.#abortController !== loopAbortController) return;
+				// Withdrawn input the loop already holds for this run never reaches the transcript.
+				if (
+					(event.type === "message_start" || event.type === "message_end") &&
+					this.#withdrawnMessages.get(event.message) === loopAbortController
+				) {
+					continue;
+				}
+				if (event.type === "agent_end") {
+					const messages = event.messages.filter(m => this.#withdrawnMessages.get(m) !== loopAbortController);
+					if (messages.length < event.messages.length) event = { ...event, messages };
+				}
 				if (event.type === "turn_start") turnOpen = true;
 				if (event.type === "turn_end") turnOpen = false;
 				// Update internal state based on events

package/src/compaction/anthropic.ts

@@ -1,22 +1,24 @@
 /**
  * Anthropic on-demand compaction (`compact-2026-09-04` beta).
  *
- * The request sends only the prefix to summarize, with the live conversation's
- * system prompt, tools and thinking settings. The returned signed block
- * replaces that prefix; the retained tail is replayed from session entries.
+ * The request sends only the prefix to summarize, as the live conversation
+ * sent it: same system prompt, tools, history bytes and thinking settings.
+ * The returned signed block replaces that prefix; the retained tail is
+ * replayed from session entries.
  */
 
 import type {
+	AnthropicCompactionFiles,
 	AnthropicCompactionPayload,
 	ApiKey,
+	Context,
 	Effort,
-	Message,
 	Model,
 	SimpleStreamOptions,
-	Tool,
 	Usage,
 } from "@oh-my-pi/pi-ai";
 import * as AIError from "@oh-my-pi/pi-ai/error";
+import { resolveAnthropicCompactionEffort } from "@oh-my-pi/pi-ai/providers/anthropic";
 import { supportsAnthropicCompaction } from "@oh-my-pi/pi-ai/providers/anthropic-compaction";
 import { isRecord, prompt } from "@oh-my-pi/pi-utils";
 import { type InstrumentedChatSpanOptions, instrumentedCompleteSimple } from "../telemetry";
@@ -33,8 +35,12 @@ export interface AnthropicCompactionPreserveData {
 	signature?: string;
 	/** Legacy threshold block state; replay-only. */
 	encryptedContent?: string;
-	/** Harness file metadata (`<files>` section) replayed after the native block. */
+	/** Harness file metadata (`<files>` section) replayed after the retained tail. */
 	filesText?: string;
+	/** Earlier summaries' file metadata replayed inside the retained tail. */
+	retainedFiles?: AnthropicCompactionFiles[];
+	/** The retained tail replays unchanged (see `AnthropicCompactionPayload.exactTail`). */
+	exactTail?: true;
 	/** Model that wrote the summary. */
 	model?: string;
 	/** Prompt tokens the compaction request processed, for display. */
@@ -76,6 +82,15 @@ export function getPreservedAnthropicCompactionData(
 		...(typeof candidate.filesText === "string" && candidate.filesText.length > 0
 			? { filesText: candidate.filesText }
 			: {}),
+		...(Array.isArray(candidate.retainedFiles) && candidate.retainedFiles.length > 0
+			? {
+					retainedFiles: candidate.retainedFiles.filter(
+						(files): files is AnthropicCompactionFiles =>
+							isRecord(files) && typeof files.text === "string" && typeof files.after === "number",
+					),
+				}
+			: {}),
+		...(candidate.exactTail === true ? { exactTail: true as const } : {}),
 		...(typeof candidate.model === "string" ? { model: candidate.model } : {}),
 		...(typeof candidate.usedTokens === "number" ? { usedTokens: candidate.usedTokens } : {}),
 	};
@@ -109,6 +124,8 @@ export function getAnthropicCompactionPayload(
 		...(preserved.signature ? { signature: preserved.signature } : {}),
 		...(preserved.encryptedContent ? { encryptedContent: preserved.encryptedContent } : {}),
 		...(preserved.filesText ? { filesText: preserved.filesText } : {}),
+		...(preserved.retainedFiles?.length ? { retainedFiles: preserved.retainedFiles } : {}),
+		...(preserved.exactTail ? { exactTail: true as const } : {}),
 	};
 }
 
@@ -167,10 +184,11 @@ export function buildAnthropicCompactionInstructions(
 }
 
 export interface AnthropicNativeCompactionRequest {
-	systemPrompt: string[];
-	messages: Message[];
-	tools?: Tool[];
+	/** The summarized prefix as the live turn would send it. */
+	context: Context;
 	instructions: string;
+	/** Replayed file metadata due before this time ends the request (see `AnthropicCompactionRequest.filesDueBefore`). */
+	filesDueBefore?: number;
 	maxTokens: number;
 	reasoning?: Effort;
 }
@@ -214,12 +232,12 @@ export async function requestAnthropicNativeCompaction(
 ): Promise<AnthropicNativeCompactionResponse> {
 	const response = await instrumentedCompleteSimple(
 		model,
-		{ systemPrompt: request.systemPrompt, messages: request.messages, tools: request.tools },
+		request.context,
 		{
 			apiKey,
 			signal,
 			maxTokens: request.maxTokens,
-			reasoning: request.reasoning,
+			reasoning: resolveAnthropicCompactionEffort(model, request.context.messages, request.reasoning),
 			initiatorOverride: options.initiatorOverride,
 			metadata: options.metadata,
 			fetch: options.fetch,
@@ -227,7 +245,7 @@ export async function requestAnthropicNativeCompaction(
 			promptCacheKey: options.promptCacheKey,
 			providerSessionState: options.providerSessionState,
 			maxInFlightRequests: options.maxInFlightRequests,
-			anthropicCompaction: { instructions: request.instructions },
+			anthropicCompaction: { instructions: request.instructions, filesDueBefore: request.filesDueBefore },
 		},
 		{
 			telemetry: options.telemetry,