one-code-extension 0.5.0 → 0.6.0

package/extensions/lib/request-replay.ts

@@ -20,26 +20,72 @@
  */
 
 import type { Message } from "@earendil-works/pi-ai";
+import { settleSystemMessages } from "./ledger/layout.ts";
+import { isObject } from "./ledger/records.ts";
+import { appendPoint, isToolsItem, leadingToolsItem, listKey, loadedInList, preludeLength, responsesDeclarations, stripMarkers, toolName, toolsItemFor } from "./ledger/wire.ts";
 import { estimateMessageTokens } from "./pi-ai-estimate.ts";
 
 /** The compaction extension publishes a RequestCapture here, or undefined when none is valid. */
 export const LAST_REQUEST_CHANNEL = "one-code:last-request";
 
 /** The provider APIs whose request body can be extended by appending to one list. */
-export type ReplayApi = "anthropic-messages" | "openai-completions" | "openai-responses";
+export type ReplayApi =
+	| "anthropic-messages"
+	| "openai-completions"
+	| "openai-responses"
+	| "azure-openai-responses"
+	| "openai-codex-responses"
+	| "bedrock-converse-stream"
+	| "google-generative-ai"
+	| "google-vertex";
 
-const LIST_KEY: Record<ReplayApi, string> = {
-	"anthropic-messages": "messages",
-	"openai-completions": "messages",
-	"openai-responses": "input",
+/**
+ * Where the output cap lives, first match in the captured body wins: a
+ * top-level field, or one level down (Bedrock's `inferenceConfig.maxTokens`,
+ * Google's `config.maxOutputTokens`). Codex sends none.
+ */
+const CAP_PATHS: Record<ReplayApi, ReadonlyArray<readonly string[]>> = {
+	"anthropic-messages": [["max_tokens"]],
+	"openai-completions": [["max_completion_tokens"], ["max_tokens"]],
+	"openai-responses": [["max_output_tokens"]],
+	"azure-openai-responses": [["max_output_tokens"]],
+	"openai-codex-responses": [],
+	"bedrock-converse-stream": [["inferenceConfig", "maxTokens"]],
+	"google-generative-ai": [["config", "maxOutputTokens"]],
+	"google-vertex": [["config", "maxOutputTokens"]],
 };
 
-/** The output cap's field, first match in the captured body wins. */
-const MAX_TOKEN_KEYS: Record<ReplayApi, readonly string[]> = {
-	"anthropic-messages": ["max_tokens"],
-	"openai-completions": ["max_completion_tokens", "max_tokens"],
-	"openai-responses": ["max_output_tokens"],
-};
+const REPLAY_APIS: ReadonlySet<string> = new Set<ReplayApi>([
+	"anthropic-messages",
+	"openai-completions",
+	"openai-responses",
+	"azure-openai-responses",
+	"openai-codex-responses",
+	"bedrock-converse-stream",
+	"google-generative-ai",
+	"google-vertex",
+]);
+
+/** The value at `path` in `payload`, when it is a number. */
+function capAt(payload: Record<string, unknown>, path: readonly string[]): number | undefined {
+	let value: unknown = payload;
+	for (const key of path) value = isObject(value) ? value[key] : undefined;
+	return typeof value === "number" ? value : undefined;
+}
+
+/** The path of the cap `payload` carries for `api`, or the first one the API takes. */
+function capPath(api: ReplayApi, payload: Record<string, unknown>): readonly string[] | undefined {
+	const paths = CAP_PATHS[api];
+	return paths.find((path) => capAt(payload, path) !== undefined) ?? paths[0];
+}
+
+/** `payload` with `value` at `path`, copying only the objects on the way. */
+function withCap(payload: Record<string, unknown>, path: readonly string[], value: number): Record<string, unknown> {
+	const [head, ...rest] = path;
+	if (rest.length === 0) return { ...payload, [head]: value };
+	const inner = isObject(payload[head]) ? (payload[head] as Record<string, unknown>) : {};
+	return { ...payload, [head]: withCap(inner, rest, value) };
+}
 
 /** The session's last provider request body, and the model it went to. */
 export interface RequestCapture {
@@ -68,9 +114,9 @@ interface ModelRef {
 /** A capture of `payload` for `model`, or undefined when its API cannot be replayed. */
 export function captureRequest(model: ModelRef | undefined, payload: unknown, covers?: CoveredThrough, sessionId?: string): RequestCapture | undefined {
 	const api = model?.api;
-	if (api !== "anthropic-messages" && api !== "openai-completions" && api !== "openai-responses") return undefined;
-	if (!model?.provider || !model.id || !isRecord(payload) || !Array.isArray(payload[LIST_KEY[api]])) return undefined;
-	return { api, provider: model.provider, modelId: model.id, payload, ...(covers ? { covers } : {}), ...(sessionId ? { sessionId } : {}) };
+	if (!api || !REPLAY_APIS.has(api)) return undefined;
+	if (!model?.provider || !model.id || !isObject(payload) || !Array.isArray(payload[listKey(api)])) return undefined;
+	return { api: api as ReplayApi, provider: model.provider, modelId: model.id, payload, ...(covers ? { covers } : {}), ...(sessionId ? { sessionId } : {}) };
 }
 
 /** The model fields pi-ai reads to choose its session-affinity headers. */
@@ -176,23 +222,46 @@ export class LastExchange<Reply extends MessageLike = MessageLike> {
  * trailing user message, so the roles still alternate.
  */
 export function extendPayload(capture: RequestCapture, tail: Record<string, unknown>, maxTokens?: number): Record<string, unknown> {
-	const key = LIST_KEY[capture.api];
+	const key = listKey(capture.api);
 	const base = capture.payload[key] as unknown[];
-	const extra = withoutCacheControl(Array.isArray(tail[key]) ? (tail[key] as unknown[]) : []) as unknown[];
-	const list = capture.api === "anthropic-messages" ? appendAnthropic(base, extra) : [...base, ...extra];
-	const out: Record<string, unknown> = { ...capture.payload, [key]: list };
-	if (maxTokens !== undefined) {
-		const keys = MAX_TOKEN_KEYS[capture.api];
-		out[keys.find((k) => k in capture.payload) ?? keys[0]] = maxTokens;
+	// The tail's own markers are dropped: the capture's mark the entry the session wrote.
+	const extra = stripMarkers(Array.isArray(tail[key]) ? (tail[key] as unknown[]) : []);
+	const list =
+		capture.api === "anthropic-messages"
+			? settleSystemMessages(appendAnthropic(base, extra), capture.api, base.length)
+			: capture.api === "bedrock-converse-stream" || capture.api.startsWith("google-")
+				? joinTurns(base, extra, capture.api.startsWith("google-") ? "parts" : "content")
+				: [...base, ...extra];
+	let out: Record<string, unknown> = { ...capture.payload, [key]: list };
+	// Google's config carries the request's live abort signal: the side call's own, never the session's.
+	if (capture.api.startsWith("google-") && isObject(out.config)) {
+		const { abortSignal: _session, ...config } = out.config;
+		const own = isObject(tail.config) ? tail.config.abortSignal : undefined;
+		out = { ...out, config: own === undefined ? config : { ...config, abortSignal: own } };
 	}
-	return out;
+	const path = maxTokens === undefined ? undefined : capPath(capture.api, capture.payload);
+	return path && maxTokens !== undefined ? withCap(out, path, maxTokens) : out;
+}
+
+/**
+ * The tail appended so turns still alternate: a tail that opens with a user
+ * turn joins a captured trailing user turn (Bedrock and Google reject two in
+ * a row). `field` is where a turn keeps its blocks (`parts` on Google).
+ */
+function joinTurns(base: unknown[], tail: unknown[], field: "content" | "parts"): unknown[] {
+	const last = base.at(-1) as Record<string, unknown> | undefined;
+	const first = tail[0] as Record<string, unknown> | undefined;
+	if (last?.role === "user" && first?.role === "user" && Array.isArray(last[field]) && Array.isArray(first[field])) {
+		return [...base.slice(0, -1), { ...last, [field]: [...(last[field] as unknown[]), ...(first[field] as unknown[])] }, ...tail.slice(1)];
+	}
+	return [...base, ...tail];
 }
 
 /** The output cap the captured body carries, if any. */
 function capturedMaxTokens(capture: RequestCapture): number | undefined {
-	for (const key of MAX_TOKEN_KEYS[capture.api]) {
-		const value = capture.payload[key];
-		if (typeof value === "number") return value;
+	for (const path of CAP_PATHS[capture.api]) {
+		const value = capAt(capture.payload, path);
+		if (value !== undefined) return value;
 	}
 	return undefined;
 }
@@ -262,24 +331,63 @@ export const MAX_CACHE_MARKERS = 4;
  *   tail's mark the fork's own entry, and the earliest are dropped past four.
  */
 export function forkRequestPayload(capture: RequestCapture, child: Record<string, unknown>, baseline: ReadonlySet<string>): Record<string, unknown> {
-	const key = LIST_KEY[capture.api];
+	const key = listKey(capture.api);
 	const base = capture.payload[key] as unknown[];
-	const tail = (Array.isArray(child[key]) ? (child[key] as WireMessage[]) : []).filter((entry) => entry.role !== "system" && entry.role !== "developer");
-	const out: Record<string, unknown> = { ...capture.payload, [key]: capture.api === "anthropic-messages" ? joinUserTurns(base, tail) : [...base, ...tail] };
-	const tools = forkTools(capture.payload.tools, child.tools, baseline, tail);
-	if (tools) out.tools = tools;
-	const capKey = MAX_TOKEN_KEYS[capture.api].find((k) => typeof capture.payload[k] === "number");
+	const childList = Array.isArray(child[key]) ? (child[key] as WireMessage[]) : [];
+	const parentDeclared = captureDeclarations(capture);
+	// The child's own prelude and system messages go; a Responses load item its
+	// tool_search placed in the tail stays, less what the capture declares.
+	const tail = childList.slice(preludeLength(childList, capture.api)).flatMap((entry): WireMessage[] => {
+		if (isToolsItem(entry)) {
+			const tools = entry.tools.filter((tool) => !parentDeclared.has(toolName(tool) ?? ""));
+			return tools.length > 0 ? [{ ...entry, tools } as WireMessage] : [];
+		}
+		return entry.role !== "system" && entry.role !== "developer" ? [entry] : [];
+	});
+	const childTools = [...(Array.isArray(child.tools) ? child.tools : []), ...(leadingToolsItem(child.tools, childList)?.tools ?? [])];
+	const inTail = loadedInList(tail);
+	const gained = forkGainedTools(parentDeclared, childTools.filter((tool) => !inTail.has(toolName(tool) ?? "")), baseline, tail);
+	// A gained tool goes where the capture keeps its tools: in an item at the
+	// start of the fork's tail when the capture declares in a leading item
+	// (after the parent's prefix, which it then keeps), else appended to the
+	// top-level array.
+	const parentItem = leadingToolsItem(capture.payload.tools, base);
+	const ownTail = gained.length > 0 && parentItem ? [toolsItemFor(gained, parentItem) as WireMessage, ...tail] : tail;
+	const out: Record<string, unknown> = { ...capture.payload, [key]: capture.api === "anthropic-messages" ? settleSystemMessages(appendTurns(base, ownTail), capture.api, base.length) : [...base, ...ownTail] };
+	// A capture that declares no tools at its head takes the child's own,
+	// wherever the child declared them.
+	const parentTools = capture.payload.tools;
+	const appended = !parentItem && Array.isArray(parentTools) ? gained : [];
+	if (!parentItem) {
+		const tools = Array.isArray(parentTools) ? (appended.length > 0 ? [...parentTools, ...appended] : parentTools) : childTools.length > 0 ? stripMarkers(childTools) : undefined;
+		if (tools) out.tools = tools;
+	}
+	const capKey = CAP_PATHS[capture.api].find((path) => capAt(capture.payload, path) !== undefined);
 	// Appended tool schemas spend room too; the parent's own tools are already in its cap.
-	const appended = Array.isArray(tools) && Array.isArray(capture.payload.tools) ? tools.slice(capture.payload.tools.length) : [];
-	const tailRoom = forkOutputRoom(capture, tail);
+	const tailRoom = forkOutputRoom(capture, ownTail);
 	const room = tailRoom === undefined ? undefined : tailRoom - (appended.length > 0 ? Math.ceil(JSON.stringify(appended).length / 4) : 0);
+	let result = out;
 	if (capKey && room !== undefined) {
 		// Never above the room: the fork chose the fallback before this when too little was left.
-		const own = typeof child[capKey] === "number" ? (child[capKey] as number) : room;
-		out[capKey] = Math.max(1, Math.min(own, room));
+		const own = capAt(child, capKey) ?? room;
+		result = withCap(out, capKey, Math.max(1, Math.min(own, room)));
 	}
-	capCacheMarkers(out, key, capture, tail);
-	return out;
+	capCacheMarkers(result, key, capture, ownTail);
+	return result;
+}
+
+/** The tool names a fork's first request declares, wherever it keeps them: the baseline its later gains are measured from. */
+export function forkBaselineNames(payload: Record<string, unknown>, api: string): Set<string> {
+	return new Set(api.endsWith("-responses") ? responsesDeclarations(payload, api).keys() : toolNames(payload.tools));
+}
+
+/** What each capture declares, computed once: every request of a fork splices the same capture. */
+const declaredByCapture = new WeakMap<RequestCapture, Set<string>>();
+
+function captureDeclarations(capture: RequestCapture): Set<string> {
+	let names = declaredByCapture.get(capture);
+	if (!names) declaredByCapture.set(capture, (names = forkBaselineNames(capture.payload, capture.api)));
+	return names;
 }
 
 /**
@@ -289,49 +397,60 @@ export function forkRequestPayload(capture: RequestCapture, child: Record<string
  * `MIN_REPLAY_OUTPUT_TOKENS` must not be spliced: it goes out whole instead.
  */
 export function forkOutputRoom(capture: RequestCapture, tail: unknown): number | undefined {
-	const capKey = MAX_TOKEN_KEYS[capture.api].find((k) => typeof capture.payload[k] === "number");
-	return capKey === undefined ? undefined : (capture.payload[capKey] as number) - Math.ceil(JSON.stringify(tail).length / 4);
+	const cap = capturedMaxTokens(capture);
+	return cap === undefined ? undefined : cap - Math.ceil(JSON.stringify(tail).length / 4);
 }
 
-/** The names a body's tool list declares (Anthropic, Chat Completions and Responses shapes). */
+/** The names a body's tool list declares, in any API's shape (lib/ledger/wire.ts toolName). */
 export function toolNames(tools: unknown): string[] {
 	return Array.isArray(tools) ? tools.map(toolName).filter((name): name is string => name !== undefined) : [];
 }
 
-function toolName(tool: unknown): string | undefined {
-	if (!isRecord(tool)) return undefined;
-	if (typeof tool.name === "string") return tool.name;
-	return isRecord(tool.function) && typeof tool.function.name === "string" ? tool.function.name : undefined;
-}
-
-function forkTools(parent: unknown, child: unknown, baseline: ReadonlySet<string>, tail: unknown[]): unknown[] | undefined {
-	if (!Array.isArray(parent)) return Array.isArray(child) ? (withoutCacheControl(child) as unknown[]) : undefined;
-	const declared = new Set(toolNames(parent));
+/**
+ * The child's tools the capture does not declare and the fork needs: one it
+ * gained after its first request (not in `baseline`), or one a tail
+ * `tool_reference` names. Markers stripped: the capture's own mark stays.
+ */
+function forkGainedTools(declared: ReadonlySet<string>, child: readonly unknown[], baseline: ReadonlySet<string>, tail: unknown[]): unknown[] {
 	const referenced = referencedTools(tail);
-	const extra = (Array.isArray(child) ? child : []).filter((tool) => {
-		const name = toolName(tool);
-		return name !== undefined && !declared.has(name) && (!baseline.has(name) || referenced.has(name));
-	});
-	return extra.length > 0 ? [...parent, ...(withoutCacheControl(extra) as unknown[])] : parent;
+	return stripMarkers(
+		child.filter((tool) => {
+			const name = toolName(tool);
+			return name !== undefined && !declared.has(name) && (!baseline.has(name) || referenced.has(name));
+		}),
+	);
 }
 
 /** Tool names the tail's `tool_reference` blocks load (Anthropic tool search). */
 function referencedTools(value: unknown, found = new Set<string>()): Set<string> {
 	if (Array.isArray(value)) for (const entry of value) referencedTools(entry, found);
-	else if (isRecord(value)) {
+	else if (isObject(value)) {
 		if (value.type === "tool_reference" && typeof value.tool_name === "string") found.add(value.tool_name);
 		for (const entry of Object.values(value)) referencedTools(entry, found);
 	}
 	return found;
 }
 
-/** Anthropic needs alternating roles: a tail that opens with a user turn joins the captured last one. */
-function joinUserTurns(base: unknown[], tail: unknown[]): unknown[] {
+/**
+ * `tail` after a captured Anthropic list, with the capture kept a byte
+ * prefix. A tail that opens with a user turn joins the captured last one, so
+ * the roles alternate. A capture that ends in a content system run (a
+ * `<total_tokens>` countdown, a context message) took no clean reply: a user
+ * turn after it would strand the run, and the layout pass would move the run
+ * behind it, rewriting what the session cached there (findings §73). A text
+ * turn goes in as a system message instead, so the run stays where its cache
+ * entry was written. A side prompt opens its tail that way, and so does a fork
+ * taken before the capture's reply landed (a `/btw` fork while it streams).
+ */
+function appendTurns(base: unknown[], tail: unknown[]): unknown[] {
 	const last = base.at(-1) as WireMessage | undefined;
 	const first = tail[0] as WireMessage | undefined;
 	if (last?.role === "user" && first?.role === "user") {
 		return [...base.slice(0, -1), { ...last, content: [...blocksOf(last.content), ...blocksOf(first.content)] }, ...tail.slice(1)];
 	}
+	if (first?.role === "user" && endsInSystemRun(base) && blocksOf(first.content).every((block) => block.type === "text")) {
+		return [...base, { role: "system", content: blocksOf(first.content) }, ...tail.slice(1)];
+	}
 	return [...base, ...tail];
 }
 
@@ -357,7 +476,7 @@ function captureMarkers(capture: RequestCapture): number {
 	let count = capturedMarkerCounts.get(capture);
 	if (count === undefined) {
 		const payload = capture.payload;
-		count = countMarkers(payload.tools) + countMarkers(payload.system) + countMarkers(payload[LIST_KEY[capture.api]]);
+		count = countMarkers(payload.tools) + countMarkers(payload.system) + countMarkers(payload[listKey(capture.api)]);
 		capturedMarkerCounts.set(capture, count);
 	}
 	return count;
@@ -365,7 +484,7 @@ function captureMarkers(capture: RequestCapture): number {
 
 function countMarkers(value: unknown): number {
 	if (Array.isArray(value)) return value.reduce((sum: number, entry) => sum + countMarkers(entry), 0);
-	if (!isRecord(value)) return 0;
+	if (!isObject(value)) return 0;
 	let count = "cache_control" in value ? 1 : 0;
 	for (const [key, entry] of Object.entries(value)) if (key !== "cache_control") count += countMarkers(entry);
 	return count;
@@ -382,7 +501,7 @@ function dropFirstMarkers(value: unknown, budget: { drop: number }): unknown {
 		});
 		return changed ? out : value;
 	}
-	if (!isRecord(value)) return value;
+	if (!isObject(value)) return value;
 	let out: Record<string, unknown> | undefined;
 	if ("cache_control" in value) {
 		const { cache_control: _, ...rest } = value;
@@ -413,27 +532,16 @@ function appendAnthropic(base: unknown[], extra: unknown[]): unknown[] {
 		const content = replyBlocks.map((block, index) => (index === anchor ? { ...block, cache_control: markers.at(-1) } : block));
 		return [...base.slice(0, -1), lastUnmarked, { ...first, content }, ...extra.slice(1)];
 	}
-	if (last && last.role === "user" && first.role === "user") {
-		return [...base.slice(0, -1), { ...last, content: [...blocksOf(last.content), ...blocksOf(first.content)] }, ...extra.slice(1)];
-	}
-	return [...base, ...extra];
+	return appendTurns(base, extra);
+}
+
+/** Whether the list, past its trailing directives, ends in a system message with content. */
+function endsInSystemRun(list: unknown[]): boolean {
+	const last = list[appendPoint(list, "anthropic-messages") - 1] as WireMessage | undefined;
+	return last?.role === "system" && blocksOf(last.content).length > 0;
 }
 
 function blocksOf(content: unknown): Block[] {
 	if (typeof content === "string") return [{ type: "text", text: content }];
 	return Array.isArray(content) ? (content as Block[]) : [];
 }
-
-function withoutCacheControl(value: unknown): unknown {
-	if (Array.isArray(value)) return value.map(withoutCacheControl);
-	if (!isRecord(value)) return value;
-	const out: Record<string, unknown> = {};
-	for (const [key, entry] of Object.entries(value)) {
-		if (key !== "cache_control") out[key] = withoutCacheControl(entry);
-	}
-	return out;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/extensions/lib/side-call.ts

@@ -26,6 +26,17 @@ export function toolStubs(names: readonly string[], reason = "Unavailable for th
 	);
 }
 
+/**
+ * The messages the current branch holds, as pi builds a request from them
+ * (compaction-aware), read when the side call runs. A copy kept from the last
+ * `context` event goes stale at a `/tree` or a compaction, which fire no
+ * `context` event, and the fallback then answered from the abandoned branch or
+ * the whole pre-compaction history.
+ */
+export function branchMessages<M>(ctx: { sessionManager: { buildSessionProjection(): { messages: M[] } } }): M[] {
+	return ctx.sessionManager.buildSessionProjection().messages;
+}
+
 /**
  * Trim a message history forward to the first clean turn boundary — a `user`
  * prompt or an `assistant` reply. A raw history can begin mid-exchange with a

package/extensions/lib/subagent-handback.ts

@@ -104,7 +104,6 @@ export function subagentHandbackExtension(slot: HandbackSlot, options: { deferre
 		pi.on("session_start", () => {
 			pi.events.emit(REMINDER_CHANNEL, {
 				text: options.deferred ? `${SUBAGENT_HANDBACK_LOAD_FIRST}\n${SUBAGENT_HANDBACK_REMINDER}` : SUBAGENT_HANDBACK_REMINDER,
-				scope: "every-turn",
 				key: "subagent-handback",
 				placement: "sticky-append",
 			} satisfies ReminderPayload);

package/extensions/lib/tool-additions.ts

@@ -1,7 +1,7 @@
 /**
  * Claude Code's `tool_addition` for tools that arrive mid-session (pure). One
- * Code stores the arrival as the deferred-tool addendum one-shot
- * (lib/deferred.ts deferredAddendumText), which reads correctly on any model.
+ * Code renders the arrival as the deferred-tool addendum on the request's
+ * tail (lib/deferred.ts deferredAddendumText), which reads correctly on any model.
  * On a first-party model that takes mid-conversation tool changes, the
  * addendum leaves the message that carries it for a system message right
  * after it: Claude Code's sentence and names, then one reference-form
@@ -127,23 +127,3 @@ export function withToolAdditions(
 	if (all.size === 0) return undefined;
 	return { payload: { ...payload, messages: reseatMessageMark(out) }, names: [...all] };
 }
-
-/** A stored message as far as the addendum scan is concerned. */
-type BranchEntry = { type?: string; message?: { role?: string; content?: unknown } };
-
-/**
- * The names every addendum persisted into a tool result on the branch
- * announced: on resume they are re-activated, since their addition blocks
- * are rebuilt from the same stored blocks and the model may call them.
- */
-export function addendumNamesOnBranch(branch: readonly BranchEntry[]): string[] {
-	const names = new Set<string>();
-	for (const entry of branch) {
-		const message = entry?.type === "message" ? entry.message : undefined;
-		if (message?.role !== "toolResult" || !Array.isArray(message.content)) continue;
-		for (const block of message.content as StoredBlock[]) {
-			for (const name of (typeof block?.text === "string" ? addendumNames(block.text) : undefined) ?? []) names.add(name);
-		}
-	}
-	return [...names];
-}

package/extensions/lib/turn-budget-layout.ts

@@ -73,6 +73,8 @@ export interface TurnBudgetOptions {
 	nudge?: boolean;
 	/** False when the budget is off: no prompt carries a marker, so a user's own tag stays text. */
 	markers?: boolean;
+	/** False when the list is a request's tail: its first user message is a later prompt, not the stack carrier. Defaults to true. */
+	stackCarrier?: boolean;
 }
 
 /** The call ids a wire message answers: Anthropic `tool_result` blocks, an OpenAI output item or tool message. */
@@ -85,6 +87,16 @@ function answeredCalls(message: WireMessage): string[] {
 	return [];
 }
 
+/** Whether the next message after `index` that is not a system message is a user message. */
+function followedByUser(messages: readonly unknown[], index: number): boolean {
+	for (let i = index + 1; i < messages.length; i++) {
+		const role = (messages[i] as WireMessage | undefined)?.role;
+		if (role === "system" || role === "developer") continue;
+		return role === "user" && !answeredCalls(messages[i] as WireMessage).length;
+	}
+	return false;
+}
+
 export function withTurnBudgetMessages(payload: Record<string, unknown>, opts: TurnBudgetOptions): Record<string, unknown> | undefined {
 	const key = messagesKey(opts.shape);
 	const messages = payload[key];
@@ -94,7 +106,7 @@ export function withTurnBudgetMessages(payload: Record<string, unknown>, opts: T
 	/** The lowest countdown of the tool results not yet followed by their message. */
 	let pending: number | undefined;
 	/** The first user message carries the context stack, never a marker (context-budget's `skipStackCarrier`). */
-	let stackCarrierSeen = false;
+	let stackCarrierSeen = opts.stackCarrier === false;
 	for (let i = 0; i < messages.length; i++) {
 		let message = messages[i] as WireMessage;
 		const after: WireMessage[] = [];
@@ -111,7 +123,10 @@ export function withTurnBudgetMessages(payload: Record<string, unknown>, opts: T
 			const rest = at === -1 ? undefined : withoutParts(parts, (_, index) => index === at);
 			if (rest) {
 				const line = parts[at].text as string;
-				if (opts.systemRole) {
+				// A system message must reach an assistant message: before another
+				// user message (a prompt whose request failed, pi having dropped the
+				// error reply) the line stays on the prompt, framed (findings §52).
+				if (opts.systemRole && !followedByUser(messages, i)) {
 					message = { ...message, content: rest };
 					after.push(systemMessage(opts.shape, opts.role, line));
 				} else {
@@ -127,6 +142,7 @@ export function withTurnBudgetMessages(payload: Record<string, unknown>, opts: T
 			// On the OpenAI APIs a batch of results is a run of items; one message follows the run.
 			const next = messages[i + 1] as WireMessage | undefined;
 			const runContinues = opts.shape !== "anthropic" && (next?.type === "function_call_output" || next?.role === "tool");
+			if (pending !== undefined && !runContinues && followedByUser(messages, i)) pending = undefined;
 			if (pending !== undefined && !runContinues) {
 				after.push(systemMessage(opts.shape, opts.role, `<total_tokens>${pending} tokens left</total_tokens>`));
 				if (opts.nudge) {

package/extensions/lsp/index.ts

@@ -5,9 +5,8 @@
  *  1. A session-wide watcher (watcher.ts): new diagnostics — cross-file, all
  *     severities, deduplicated against what was already delivered — ride the
  *     tool result of the round that surfaced them as a raw `<new-diagnostics>`
- *     block (a reminder-queue one-shot, pinned to the trailing tool result
- *     after the `<total_tokens>` line — the exact place a Claude Code session
- *     shows them), or the message that opens the next run when they arrived
+ *     block (a reminder-queue one-shot, delivered on the trailing tool result
+ *     of the next request — the exact place a Claude Code session shows them), or the message that opens the next run when they arrived
  *     while idle (`agent_start`, so a notification-opened run gets them too).
  *     Until 2026-09-05 they went out as a custom steer message of their own
  *     (a separate user turn on the wire). Editing a file clears its
@@ -289,11 +288,10 @@ export default function lspExtension(pi: ExtensionAPI) {
 
 	/**
 	 * Queue the block where the model reads next. Raw (no `<system-reminder>`
-	 * frame, as in Claude Code) and last-append: from a `tool_result` hook this
-	 * extension runs after system-reminder's, so the one-shot is pending at the
-	 * next `context` and pinned to the trailing tool result (process memory,
-	 * same mechanism as the file-tracker's per-round report); from `agent_start`
-	 * it pins to the message that opened the run.
+	 * frame, as in Claude Code) and last-append: persisted as a pending entry,
+	 * it rides the trailing tool result of the next request (the same mechanism
+	 * as the file-tracker's per-round report); from `agent_start` it rides the
+	 * message that opened the run.
 	 */
 	const queueNewDiagnostics = (text: string) => {
 		pi.events.emit(REMINDER_CHANNEL, { text, placement: "last-append", raw: true } satisfies ReminderPayload);