one-code-extension 0.4.0 → 0.5.0

package/extensions/compaction/cut.ts

@@ -0,0 +1,157 @@
+/**
+ * Where a compaction cuts the conversation. Pure: no pi extension API.
+ *
+ * pi keeps the last ~20k tokens verbatim after its summary (`keepRecentTokens`).
+ * Claude Code keeps only the final assistant reply (findings §47), and
+ * so does One Code: the summary, that reply, then whatever came after it (the
+ * results of a tool call it made, on an overflow mid-turn). A short kept tail
+ * also keeps little signed thinking across the boundary (findings §46).
+ *
+ * pi's own cut is moved to the last assistant message that reaches the
+ * provider. When pi cut earlier (a keep window above 0), the messages between
+ * the two cuts join the doomed span. When pi cut later (with the window at 0,
+ * pi cuts at the last cut point, which can be a queued prompt or a harness
+ * notification that arrived after the reply), the reply and what follows it
+ * leave the doomed span, so the summary does not repeat what stays verbatim.
+ */
+
+import { latestCompaction } from "../lib/compaction-boundary.ts";
+
+/** The fields of a session entry the cut reads; pi's `SessionEntry` fits it. */
+export type CutEntry = {
+	id: string;
+	type: string;
+	message?: { role?: string; stopReason?: string; content?: unknown };
+	targetId?: string;
+	replacement?: { content: unknown } | null;
+	firstKeptEntryId?: string | null;
+};
+
+type Span<M> = { messagesToSummarize: M[]; turnPrefixMessages: M[]; isSplitTurn: boolean };
+type Preparation<M> = Span<M> & { firstKeptEntryId: string };
+
+/** What pi summarizes for a preparation: the messages before the cut, a split turn's prefix included. */
+export function doomedMessages<M>(preparation: Span<M>): M[] {
+	return preparation.isSplitTurn ? [...preparation.messagesToSummarize, ...preparation.turnPrefixMessages] : preparation.messagesToSummarize;
+}
+
+/**
+ * pi's preparation moved to Claude Code's cut, with the entry the kept tail
+ * starts at. pi's own when its cut already is the reply, no reply is still in
+ * context, or the messages to take off are not the doomed span's tail.
+ */
+export function claudeCodeCut<E extends CutEntry, M extends { role: string }, P extends Preparation<M>>(
+	entries: readonly E[],
+	preparation: P,
+	toMessages: (entry: E) => M[],
+): { preparation: P; firstKeptEntryId: string } {
+	const unchanged = { preparation, firstKeptEntryId: preparation.firstKeptEntryId };
+	const cut = lastReplyCut(entries, preparation.firstKeptEntryId);
+	if (!cut) return unchanged;
+	const moved = moveCut(preparation, spanMessages(cut.span, entries, toMessages), cut.later);
+	return moved ? { preparation: moved, firstKeptEntryId: cut.firstKeptEntryId } : unchanged;
+}
+
+/**
+ * The entry Claude Code's cut keeps from, and the entries between it and pi's
+ * cut: summarized too when the reply is `later` than pi's cut, kept when it is
+ * earlier. Undefined when pi's entry is not on the branch, no reply is still
+ * in context, or pi already cut at the reply.
+ *
+ * An assistant message that ended in an error or an abort never reaches the
+ * provider (pi-ai's `transformMessages` drops it), and one whose content (as
+ * a context edit leaves it) has no text or tool call is omitted or skipped by
+ * its converter, so none of them is a reply to keep. A reply an
+ * earlier compaction already summarized is out of reach.
+ */
+export function lastReplyCut<E extends CutEntry>(
+	entries: readonly E[],
+	piFirstKeptEntryId: string,
+): { firstKeptEntryId: string; span: E[]; later: boolean } | undefined {
+	const piIndex = entries.findIndex((entry) => entry.id === piFirstKeptEntryId);
+	if (piIndex < 0) return undefined;
+	const edits = contextEdits(entries);
+	const start = latestCompaction(entries)?.keptStart ?? 0;
+	let replyIndex = -1;
+	for (let i = entries.length - 1; i >= start; i--) {
+		const entry = entries[i];
+		const message = entry.message;
+		if (entry.type !== "message" || message?.role !== "assistant") continue;
+		if (message.stopReason === "error" || message.stopReason === "aborted") continue;
+		// The content the provider gets: a context edit's replacement, or none when it omits the message.
+		const content = edits.has(entry.id) ? edits.get(entry.id)?.content : message.content;
+		if (!sendsContent(content)) continue;
+		replyIndex = i;
+		break;
+	}
+	if (replyIndex < 0 || replyIndex === piIndex) return undefined;
+	const later = replyIndex > piIndex;
+	return {
+		firstKeptEntryId: entries[replyIndex].id,
+		span: later ? entries.slice(piIndex, replyIndex) : entries.slice(replyIndex, piIndex),
+		later,
+	};
+}
+
+/** Each edited entry's replacement (null when the edit omits it), the latest edit winning, as in pi's projection. */
+function contextEdits(entries: readonly CutEntry[]): Map<string, CutEntry["replacement"]> {
+	const edits = new Map<string, CutEntry["replacement"]>();
+	for (const entry of entries) if (entry.type === "context_edit" && entry.targetId) edits.set(entry.targetId, entry.replacement);
+	return edits;
+}
+
+/** Whether an assistant message carries text or a tool call (thinking alone is not a reply). */
+function sendsContent(content: unknown): boolean {
+	if (typeof content === "string") return content.trim().length > 0;
+	return (
+		Array.isArray(content) &&
+		content.some((block: { type?: string; text?: string }) => block?.type === "toolCall" || (block?.type === "text" && !!block.text?.trim()))
+	);
+}
+
+/**
+ * The context messages of entries in branch order, as pi projects them: an
+ * omitted entry contributes nothing, a replaced one its replacement content
+ * (`buildSessionProjection` in pi 0.87 and later; earlier pi has no edits), and
+ * an older compaction entry inside the span nothing (only the newest
+ * compaction's summary is context).
+ */
+export function spanMessages<E extends CutEntry, M extends { role: string }>(span: readonly E[], all: readonly E[], toMessages: (entry: E) => M[]): M[] {
+	const edits = contextEdits(all);
+	return span.flatMap((entry) => {
+		if (entry.type === "compaction" || entry.type === "context_edit") return [];
+		const messages = toMessages(entry);
+		if (!edits.has(entry.id)) return messages;
+		const replacement = edits.get(entry.id);
+		if (!replacement) return [];
+		return messages.map((message) => {
+			if (!["user", "assistant", "toolResult", "custom"].includes(message.role)) return message;
+			const content =
+				(message.role === "assistant" || message.role === "toolResult") && typeof replacement.content === "string"
+					? [{ type: "text", text: replacement.content }]
+					: replacement.content;
+			return { ...message, content };
+		});
+	});
+}
+
+/**
+ * pi's preparation with the doomed span moved to the new cut, the split turn's
+ * prefix folded in: `messages` appended when the reply is `later` than pi's
+ * cut, else taken off the span's end. Undefined when those are not the span's
+ * tail (role and timestamp, message by message) or would leave nothing to
+ * summarize: pi's cut stays.
+ */
+export function moveCut<P extends Span<unknown>>(preparation: P, messages: P["messagesToSummarize"], later: boolean): P | undefined {
+	const doomed = doomedMessages(preparation);
+	const moved = (messagesToSummarize: P["messagesToSummarize"]): P => ({ ...preparation, messagesToSummarize, turnPrefixMessages: [], isSplitTurn: false });
+	if (later) return moved([...doomed, ...messages]);
+	const keep = doomed.length - messages.length;
+	if (keep <= 0) return undefined;
+	const same = (a: unknown, b: unknown) => {
+		const [x, y] = [a as { role?: string; timestamp?: number } | null, b as { role?: string; timestamp?: number } | null];
+		return x?.role === y?.role && x?.timestamp === y?.timestamp;
+	};
+	if (messages.some((message, i) => !same(message, doomed[keep + i]))) return undefined;
+	return moved(doomed.slice(0, keep));
+}

package/extensions/compaction/index.ts

@@ -2,9 +2,9 @@
  * compaction extension — replaces pi's summarizer with Claude Code's.
  *
  * Hooks `session_before_compact` (manual /compact, threshold, and overflow
- * alike), reuses pi's already-computed cut point, and sends Claude Code's
- * compaction instruction; only the <summary> block of the reply survives as
- * context.
+ * alike), moves pi's cut point to the last assistant reply (`cut.ts`), and
+ * sends Claude Code's compaction instruction; only the <summary> block of the
+ * reply survives as context, followed by that reply.
  *
  * The call is built to hit the provider prompt cache, which is why Claude
  * Code compacts on the *session model* rather than something cheaper: it
@@ -41,20 +41,25 @@ import { completeSimple } from "@earendil-works/pi-ai/compat";
 import {
 	convertToLlm,
 	type ExtensionAPI,
-	type ExtensionContext,
 	type SessionBeforeCompactEvent,
+	type SessionEntry,
+	sessionEntryToContextMessages,
 } from "@earendil-works/pi-coding-agent";
 import {
 	type AnthropicModelCompat,
-	anthropicBetas,
 	clearThinkingApplies,
 	clearThinkingEnabled,
-	isAnthropicOAuth,
+	sessionRequestHeaders,
 	withClearThinking,
 } from "../context-management/index.ts";
+import { PRECOMPACT_INSTRUCTIONS_CHANNEL, type PreCompactInstructions } from "../hooks/compaction.ts";
 import { looksLikeAnthropicRequest } from "../lib/anthropic-payload.ts";
 import { forcedReasoningLevel } from "../lib/model-policy.ts";
+import { captureRequest, extendPayload, LAST_REQUEST_CHANNEL, LastExchange, lastCovered, type RequestCapture, replayOutputCap } from "../lib/request-replay.ts";
+import { withoutSystemMessages } from "../lib/side-call.ts";
+import { claudeCodeCut, type CutEntry, doomedMessages } from "./cut.ts";
 import { fitToBudget, replayFits, withoutUsage } from "./fit.ts";
+import { withoutThinking } from "./kept-thinking.ts";
 import { buildCompactionInstruction, COMPACTION_MAX_TOKENS, continuationSummary, extractSummary } from "./prompt.ts";
 
 /** Compaction reads a whole context window; give it more room than the classifier's 30s. */
@@ -71,6 +76,11 @@ export const STANDALONE_SYSTEM_PROMPT =
 type Preparation = Pick<SessionBeforeCompactEvent["preparation"], "messagesToSummarize" | "turnPrefixMessages" | "isSplitTurn" | "previousSummary">;
 
 export default function compactionExtension(pi: ExtensionAPI) {
+	const hookInstructions = new WeakMap<AbortSignal, string>();
+	pi.events.on(PRECOMPACT_INSTRUCTIONS_CHANNEL, (data) => {
+		const { signal, instructions } = data as PreCompactInstructions;
+		hookInstructions.set(signal, instructions);
+	});
 	/**
 	 * The exact message array the session last handed the provider, captured
 	 * from the `context` event AFTER every extension has mutated it — most
@@ -87,38 +97,83 @@ export default function compactionExtension(pi: ExtensionAPI) {
 	 * standalone path) diverges at message one, because those injected reminders
 	 * never become entries — so it cannot reproduce the cached prefix at all.
 	 *
-	 * We hold the reference, not a copy: `emitContext` hands each handler a fresh
-	 * structuredClone the session never mutates again, and compaction is the
-	 * last extension with a `context` handler, so this reference is exactly the
-	 * array the turn sent. Returning nothing keeps the handler a pure observer.
+	 * We hold the messages themselves, not copies: `emitContext` hands each
+	 * handler a fresh structuredClone the session never mutates again, and
+	 * compaction is the last extension with a `context` handler, so these are
+	 * exactly the messages the turn sent. Returning nothing keeps the handler a
+	 * pure observer.
+	 *
+	 * The system prompt is captured at the same moment. `ctx.getSystemPrompt()`
+	 * reflects the prompt a run forced through `before_agent_start` only while
+	 * that run lasts; pi drops the run's options when it settles, so read from an
+	 * idle `/compact` it is pi's default prompt and the replay misses the cache
+	 * (findings §27).
+	 */
+	let captured: { messages: AgentMessage[]; systemPrompt: string; model: string | undefined } | undefined;
+	pi.on("context", (event, ctx) => {
+		captured = { messages: event.messages, systemPrompt: ctx.getSystemPrompt(), model: modelKey(ctx.model) };
+	});
+
+	/**
+	 * The same request as pi put it on the wire, and the reply that answered it
+	 * (lib/request-replay.ts). This extension loads after every extension that
+	 * edits the payload (tool-search, context-management), so the body it sees
+	 * is final; it is published for the btw and recap side calls too.
 	 */
-	let capturedMessages: AgentMessage[] | undefined;
-	pi.on("context", (event) => {
-		capturedMessages = event.messages;
+	const exchange = new LastExchange<AgentMessage & { role: string }>();
+	const publish = (capture: ReturnType<typeof captureRequest>) => {
+		exchange.setCapture(capture);
+		pi.events.emit(LAST_REQUEST_CHANNEL, capture);
+	};
+	pi.on("before_provider_request", (event, ctx) => {
+		// The context this body was built from ends where a fork's own messages start.
+		const covers = captured ? lastCovered(captured.messages as { role: string; timestamp?: number }[]) : undefined;
+		publish(captureRequest(ctx.model as { api?: string; provider?: string; id?: string } | undefined, event.payload, covers, ctx.sessionManager.getSessionId()));
+	});
+	pi.on("message_end", (event) => {
+		exchange.noteMessage(event.message as AgentMessage & { role: string });
+	});
+	pi.on("session_start", () => {
+		captured = undefined;
+		publish(undefined);
 	});
+
 	// After a compaction the capture describes the pre-compaction request. A
 	// second /compact before any turn would otherwise re-summarize history the
 	// first one already folded away (and mis-scope the kept tail); the standalone
 	// reconstruction from entries serves until the next request recaptures.
 	pi.on("session_compact", () => {
-		capturedMessages = undefined;
+		captured = undefined;
+		publish(undefined);
 	});
 	// A /tree branch switch stays in the same process and fires no `context`
 	// event (navigateTree rebuilds the messages itself), so the capture would
 	// still describe the abandoned branch — and a /compact before the next turn
 	// summarized work the kept branch never did (review H1). Same remedy.
 	pi.on("session_tree", () => {
-		capturedMessages = undefined;
+		captured = undefined;
+		publish(undefined);
 	});
 
 	pi.on("session_before_compact", async (event, ctx) => {
+		const instructions = hookInstructions.get(event.signal);
+		hookInstructions.delete(event.signal);
+		if (instructions) event = { ...event, customInstructions: [event.customInstructions, instructions].filter(Boolean).join("\n\n") };
 		if (process.env.CC_COMPACTION === "0") return undefined;
 
 		const model = ctx.model;
 		if (!model) return undefined;
 		// Snapshot before the first await so the capture and pi's preparation
 		// describe the same request even if a context event lands meanwhile.
-		const captured = capturedMessages;
+		// A replay exists to read the session model's cache, and the prompt is built
+		// per model, so a capture made under another model (a `/model` switch with
+		// no turn since) is not replayed: the standalone shape serves.
+		const capture =
+			captured && captured.model === modelKey(model) ? { ...captured, messages: withoutSystemMessages(captured.messages) } : undefined;
+		const wire = exchange.forModel(model);
+		// Claude Code's cut: keep only the last assistant reply, and summarize
+		// exactly what lies before it (cut.ts).
+		const { preparation, firstKeptEntryId } = claudeCodeCut(event.branchEntries as (SessionEntry & CutEntry)[], event.preparation, sessionEntryToContextMessages);
 
 		try {
 			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
@@ -133,16 +188,24 @@ export default function compactionExtension(pi: ExtensionAPI) {
 			// Otherwise (no capture yet, an overflow, a nearly full window) the
 			// standalone shape summarizes the doomed span pi isolated. An overflow
 			// never replays, so its replay request is not even built.
-			const replay = captured && event.reason !== "overflow" ? replayRequest(pi, ctx, captured, event) : undefined;
-			const request =
-				replay && replayFits(event.reason, model, replay, maxTokens)
-					? replay
-					: standaloneRequest(
-							model,
-							event.preparation,
-							buildCompactionInstruction({ reason: event.reason, customInstructions: event.customInstructions }),
-							maxTokens,
-						);
+			const replay = capture && event.reason !== "overflow" ? replayRequest(pi, capture, event, preparation, wire?.reply, model.api) : undefined;
+			const replaying = replay !== undefined && replayFits(event.reason, model, replay, maxTokens);
+			const request = replaying
+				? replay
+				: standaloneRequest(
+						model,
+						preparation,
+						buildCompactionInstruction({ reason: event.reason, customInstructions: event.customInstructions }),
+						maxTokens,
+					);
+			// A replay goes out as the session's own last request body with the
+			// reply and the instruction appended, so it reads the cache that request
+			// wrote: rebuilt from `request`, the tools array (tool-search reshapes it
+			// on the wire) never matched on first-party Claude (measured on Sonnet 5:
+			// 0 read, 65k written). `request` still sizes the call (fit.ts), and
+			// pi-ai converts only the tail. No capture for this model, or too little
+			// room left under the captured cap: `request` as is.
+			const plan = replaying && wire ? wirePlan(wire, request, maxTokens) : undefined;
 
 			// When context-management (clear_thinking) is active for this session,
 			// the agent loop's cached message prefix has old thinking blocks cleared
@@ -159,17 +222,32 @@ export default function compactionExtension(pi: ExtensionAPI) {
 			// the Anthropic-shaped fields, and are gated to Anthropic anyway.
 			const cmModel = model as { api?: string; provider?: string; baseUrl?: string; compat?: AnthropicModelCompat };
 			const clearThinking = clearThinkingEnabled(process.env.CC_CLEAR_THINKING, cmModel);
-			const headers = clearThinking
-				? { ...auth.headers, "anthropic-beta": anthropicBetas(isAnthropicOAuth(), cmModel.compat) }
-				: auth.headers;
+			const headers = sessionRequestHeaders(cmModel, auth.headers);
+
+			// A replay sends the captured body (which already carries the
+			// clear_thinking edit) with the tail pi-ai just built appended.
+			// Otherwise the clear_thinking body edit, matching the session's
+			// requests (see the header note above), only on Anthropic requests
+			// that carry thinking, exactly as the context-management extension gates it.
+			let onPayload: ((payload: unknown) => unknown) | undefined;
+			if (plan) {
+				onPayload = (payload) => extendPayload(plan.capture, payload as Record<string, unknown>, plan.maxTokens);
+			} else if (clearThinking) {
+				onPayload = (payload) =>
+					looksLikeAnthropicRequest(payload) &&
+					clearThinkingApplies(payload as Record<string, unknown>, cmModel.compat?.forceAdaptiveThinking === true)
+						? withClearThinking(payload as Record<string, unknown>)
+						: payload;
+			}
 
 			const timeout = AbortSignal.timeout(COMPACTION_TIMEOUT_MS);
-			const result = await completeSimple(baseUrl ? ({ ...model, baseUrl } as Model<Api>) : model, request, {
+			const callContext: Context = plan ? { systemPrompt: "", messages: plan.tail, tools: [] } : request;
+			const result = await completeSimple(baseUrl ? ({ ...model, baseUrl } as Model<Api>) : model, callContext, {
 				apiKey: auth.apiKey,
 				headers,
 				env: auth.env,
 				signal: AbortSignal.any([event.signal, timeout]),
-				maxTokens,
+				maxTokens: plan?.maxTokens ?? maxTokens,
 				// The session id is the prompt-cache key / routing affinity on the
 				// providers that use one (openai-codex prompt_cache_key, session
 				// headers). Without it the replayed prefix cannot hit the session's
@@ -189,18 +267,13 @@ export default function compactionExtension(pi: ExtensionAPI) {
 				// unless the model cannot disable thinking, where an off-request
 				// would 400 (forcedReasoningLevel sends its lowest level instead).
 				reasoning: ctx.thinkingLevel === "off" ? forcedReasoningLevel(model) : ctx.thinkingLevel,
-				// The clear_thinking body edit, matching the session's requests (see
-				// the header note above). Only attached on Anthropic requests that
-				// carry thinking, exactly as the context-management extension gates it.
-				onPayload: clearThinking
-					? (payload: unknown) =>
-							looksLikeAnthropicRequest(payload) &&
-							clearThinkingApplies(payload as Record<string, unknown>, cmModel.compat?.forceAdaptiveThinking === true)
-								? withClearThinking(payload as Record<string, unknown>)
-								: payload
-					: undefined,
+				onPayload,
 			});
 
+			// A failed or capped stream can carry partial text. Never replace the
+			// conversation with that incomplete checkpoint; let pi retry its summary.
+			if (result.stopReason === "error" || result.stopReason === "aborted" || result.stopReason === "length") return undefined;
+
 			const text = result.content
 				.filter((block): block is { type: "text"; text: string } => block.type === "text")
 				.map((block) => block.text)
@@ -212,7 +285,7 @@ export default function compactionExtension(pi: ExtensionAPI) {
 				compaction: {
 					// Undefined in --no-session runs; the pointer line is dropped.
 					summary: continuationSummary(summary, ctx.sessionManager.getSessionFile()),
-					firstKeptEntryId: event.preparation.firstKeptEntryId,
+					firstKeptEntryId,
 					tokensBefore: event.preparation.tokensBefore,
 					usage: result.usage,
 				},
@@ -224,20 +297,50 @@ export default function compactionExtension(pi: ExtensionAPI) {
 	});
 }
 
+/** A model's identity for matching a capture to the current model. */
+function modelKey(model: { provider?: string; id?: string } | undefined): string | undefined {
+	return model ? `${model.provider}/${model.id}` : undefined;
+}
+
+/**
+ * A replay's wire form: the tail pi-ai converts (the reply, if any, and the
+ * instruction: the last messages of `request`) and the output cap left under
+ * the captured request's own, or undefined when too little room is left.
+ */
+function wirePlan(
+	wire: { capture: RequestCapture; reply: unknown },
+	request: Context,
+	maxTokens: number,
+): { capture: RequestCapture; tail: Message[]; maxTokens: number } | undefined {
+	const tail = request.messages.slice(-(wire.reply ? 2 : 1));
+	const cap = replayOutputCap(wire.capture, tail, maxTokens);
+	return cap === undefined ? undefined : { capture: wire.capture, tail, maxTokens: cap };
+}
+
 /**
  * The cache-aligned shape: the session's system prompt, the active tool
  * definitions in their active order — kept purely so the cached prefix (tools
  * come first) still matches; a mismatch costs cache hits, never correctness —
  * the captured request verbatim, and the instruction as one more user message.
  *
- * pi keeps the tail after the cut point verbatim (keepRecentTokens, ~20k
- * tokens); the captured request still carries that tail, so the instruction
- * names it (`keptTailOf`). Cutting the tail off the request instead was
+ * The kept tail (the last assistant reply and anything after it, `cut.ts`)
+ * stays verbatim after the summary; the captured request still carries it, so
+ * the instruction names it (`keptTailOf`). Cutting the tail off the request instead was
  * rejected: Anthropic checks cache hits only ~20 blocks back from the
  * breakpoint, so a request ending well before the last cached block misses
  * the cache the whole replay exists to hit.
  */
-function replayRequest(pi: ExtensionAPI, ctx: ExtensionContext, captured: AgentMessage[], event: SessionBeforeCompactEvent): Context {
+function replayRequest(
+	pi: ExtensionAPI,
+	captured: { messages: AgentMessage[]; systemPrompt: string },
+	event: SessionBeforeCompactEvent,
+	preparation: Preparation,
+	reply: AgentMessage | undefined,
+	api: string | undefined,
+): Context {
+	// The reply that answered the captured request is part of the conversation
+	// pi is compacting, and the last message the replayed body gains.
+	const conversation = reply ? [...captured.messages, reply] : captured.messages;
 	const byName = new Map(pi.getAllTools().map((tool) => [tool.name, tool]));
 	const tools = pi
 		.getActiveTools()
@@ -247,25 +350,38 @@ function replayRequest(pi: ExtensionAPI, ctx: ExtensionContext, captured: AgentM
 	const instruction = buildCompactionInstruction({
 		reason: event.reason,
 		customInstructions: event.customInstructions,
-		keptTail: keptTailOf(captured, event.preparation),
+		keptTail: keptTailOf(conversation, preparation, api),
 	});
-	return { systemPrompt: ctx.getSystemPrompt(), messages: [...convertToLlm(captured), instructionMessage(instruction)], tools };
+	return { systemPrompt: captured.systemPrompt, messages: [...convertToLlm(conversation), instructionMessage(instruction)], tools };
 }
 
 /**
  * The standalone shape: the doomed span reconstructed from session entries,
- * its assistant usage zeroed and its largest tool results cleared until pi's
- * clamp leaves room for the summary (`fit.ts`), no tools, a one-line system
- * prompt. Gets no kept-tail note: it holds only the doomed span. If it fails,
+ * its assistant usage zeroed, its signed thinking removed (it would fail the
+ * check under this system prompt; `kept-thinking.ts`), and its largest tool
+ * results cleared until pi's clamp leaves room for the summary (`fit.ts`), no
+ * tools, a one-line system prompt. Gets no kept-tail note: it holds only the doomed span. If it fails,
  * pi's own compaction serves. Exported for the unit test.
  */
 export function standaloneRequest(model: Model<Api>, preparation: Preparation, instruction: string, maxTokens: number): Context {
-	const messages = [...withoutUsage(convertToLlm(reconstructFromEntries(preparation))), instructionMessage(instruction)];
+	const span = withoutThinking(withoutUsage(convertToLlm(reconstructFromEntries(preparation))), model.api);
+	const messages = [...span, instructionMessage(instruction)];
 	return fitToBudget(model, { systemPrompt: STANDALONE_SYSTEM_PROMPT, messages }, maxTokens).request;
 }
 
 const instructionMessage = (instruction: string): Message => ({ role: "user", content: instruction, timestamp: Date.now() });
 
+/**
+ * APIs whose request puts a run of consecutive tool results into ONE user
+ * message (pi-ai's converters: Anthropic and Bedrock require it, Gemini merges
+ * function responses into one turn). The model counts messages on the wire, so
+ * the kept-tail note counts such a run once.
+ */
+const MERGES_TOOL_RESULTS = new Set(["anthropic-messages", "bedrock-converse-stream", "google-generative-ai", "google-vertex"]);
+const GOOGLE_APIS = new Set(["google-generative-ai", "google-vertex"]);
+
+type TailMessage = { role: string; content?: unknown; toolName?: unknown };
+
 /**
  * The verbatim-kept tail of the captured request: everything after the doomed
  * span. pi builds the context as `[compactionSummary?] + one message per entry`
@@ -273,37 +389,64 @@ const instructionMessage = (instruction: string): Message => ({ role: "user", co
  * `messagesToSummarize`/`turnPrefixMessages` with the same mapping, so the
  * doomed span is a prefix of the captured array. Alignment is checked role by
  * role; on any mismatch (an extension that inserted a message) no note is made
- * rather than a wrong one. Exported for the unit test.
+ * rather than a wrong one.
+ *
+ * `count` is in the provider's messages (`api`): a parallel batch's results
+ * are one message on Anthropic. `landmark` names the first kept message so the
+ * model need not count: how its text opens, else the tool it calls, else the
+ * tool whose result it is. Exported for the unit test.
  */
 export function keptTailOf(
-	captured: readonly { role: string; content?: unknown }[],
+	captured: readonly TailMessage[],
 	preparation: Preparation,
-): { count: number; opening?: string } | undefined {
-	const doomed: { role: string }[] = [
-		...(preparation.previousSummary ? [{ role: "compactionSummary" }] : []),
-		...preparation.messagesToSummarize,
-		...(preparation.isSplitTurn ? preparation.turnPrefixMessages : []),
-	];
+	api?: string,
+): { count: number; landmark?: string } | undefined {
+	const doomed: { role: string }[] = [...(preparation.previousSummary ? [{ role: "compactionSummary" }] : []), ...doomedMessages(preparation)];
 	if (doomed.length === 0 || doomed.length > captured.length) return undefined;
 	for (let i = 0; i < doomed.length; i++) {
 		if (captured[i].role !== doomed[i].role) return undefined;
 	}
-	const count = captured.length - doomed.length;
-	if (count === 0) return { count };
-	return { count, opening: openingText(captured[doomed.length]) };
+	const tail = captured.slice(doomed.length);
+	if (tail.length === 0) return { count: 0 };
+	// On Google a tool result's image can become a user message of its own,
+	// depending on the model: the count cannot be known, so no note.
+	const imageResult = tail.some((m) => m.role === "toolResult" && Array.isArray(m.content) && (m.content as { type?: string }[]).some((b) => b?.type === "image"));
+	if (imageResult && api !== undefined && GOOGLE_APIS.has(api)) return undefined;
+	const merges = api !== undefined && MERGES_TOOL_RESULTS.has(api);
+	const count = tail.filter((m, i) => !(merges && m.role === "toolResult" && tail[i - 1]?.role === "toolResult")).length;
+	return { count, landmark: landmarkOf(tail[0]) };
+}
+
+/** How the note points at the first kept message, or undefined when nothing identifies it. */
+function landmarkOf(message: TailMessage): string | undefined {
+	if (message.role === "toolResult" && typeof message.toolName === "string") return `the result of the ${message.toolName} call`;
+	const content = Array.isArray(message.content) ? (message.content as { type?: string; text?: string; name?: unknown; arguments?: unknown }[]) : [];
+	const text = typeof message.content === "string" ? message.content : content.find((b) => b?.type === "text" && b.text?.trim())?.text;
+	const opening = oneLine(text);
+	if (opening) return `the message that opens "${opening}"`;
+	const call = content.find((b) => b?.type === "toolCall" && typeof b.name === "string");
+	if (message.role === "assistant" && call) {
+		const hint = oneLine(callHint(call.arguments));
+		return `the assistant message that calls ${call.name as string}${hint ? ` (${hint})` : ""}`;
+	}
+	return undefined;
+}
+
+/** The argument that says what a call is about: its path, command or pattern, else its first string argument. */
+function callHint(args: unknown): string | undefined {
+	if (!args || typeof args !== "object") return undefined;
+	const record = args as Record<string, unknown>;
+	for (const key of ["path", "file_path", "command", "pattern", "url", "query"]) {
+		if (typeof record[key] === "string") return record[key] as string;
+	}
+	return Object.values(record).find((value): value is string => typeof value === "string");
 }
 
-/** The first ~80 characters of a message's text, single-line, for the landmark quote. */
-function openingText(message: { content?: unknown }): string | undefined {
-	const content = message.content;
-	const text =
-		typeof content === "string"
-			? content
-			: Array.isArray(content)
-				? (content.find((b) => b && typeof b === "object" && (b as { type?: string }).type === "text") as { text?: string } | undefined)?.text
-				: undefined;
+/** The first ~80 characters of a text, single-line, for a landmark. */
+function oneLine(text: string | undefined): string | undefined {
 	if (!text) return undefined;
 	const line = text.replace(/\s+/g, " ").trim();
+	if (!line) return undefined;
 	return line.length > 80 ? `${line.slice(0, 80)}…` : line;
 }
 
@@ -319,9 +462,7 @@ function openingText(message: { content?: unknown }): string | undefined {
  * summarized with the rest.
  */
 function reconstructFromEntries(preparation: Preparation): AgentMessage[] {
-	const doomed = preparation.isSplitTurn
-		? [...preparation.messagesToSummarize, ...preparation.turnPrefixMessages]
-		: preparation.messagesToSummarize;
+	const doomed = doomedMessages(preparation);
 	return preparation.previousSummary
 		? [
 				{