@selesai/code 0.10.2 → 0.11.0

package/dist/extensions/auto-session-name.ts

@@ -0,0 +1,96 @@
+/**
+ * auto-session-name
+ *
+ * Names the session on every user message using the currently selected model.
+ * Sends only user messages (current prompt plus previous user messages,
+ * truncated) for context, capped at 10 output tokens (1-5 word name).
+ * Thinking is never enabled. Equivalent to running /name automatically.
+ */
+
+import { complete } from "@earendil-works/pi-ai/compat";
+import type { ExtensionAPI, SessionEntry } from "@selesai/code";
+
+export const NAMING_SYSTEM_PROMPT =
+	"Reply with only a short session name (1-5 words) for this conversation based on the user's messages. No punctuation, no quotes, no explanation.";
+
+export const NAMING_MAX_TOKENS = 10;
+/** Hard cap on the name itself: at most 5 words (≈5 tokens). */
+export const MAX_NAME_WORDS = 5;
+/** How many previous user messages to include, newest first. */
+export const MAX_PREVIOUS_MESSAGES = 20;
+/** Per-message character cap when truncating. */
+export const MAX_MESSAGE_CHARS = 200;
+
+function truncate(text: string): string {
+	return text.length > MAX_MESSAGE_CHARS ? `${text.slice(0, MAX_MESSAGE_CHARS)}…` : text;
+}
+
+/** Collect previous user message texts from the session branch, newest first, truncated. */
+export function previousUserMessages(sessionManager: { getBranch(): SessionEntry[] }): string[] {
+	const branch = sessionManager.getBranch();
+	const texts: string[] = [];
+	for (let i = branch.length - 1; i >= 0 && texts.length < MAX_PREVIOUS_MESSAGES; i--) {
+		const entry = branch[i];
+		if (entry.type !== "message" || entry.message.role !== "user") continue;
+		const content = entry.message.content;
+		const text = typeof content === "string" ? content : content
+			.filter((c): c is { type: "text"; text: string } => c.type === "text")
+			.map((c) => c.text)
+			.join("\n");
+		if (text.trim()) texts.push(truncate(text.trim()));
+	}
+	return texts;
+}
+
+export default function autoSessionNameExtension(pi: ExtensionAPI): void {
+	// Guards run synchronously; the naming call itself is fire-and-forget so it
+	// never blocks the user's message from being sent.
+	let namingSeq = 0;
+	pi.on("input", (event, ctx) => {
+		// Only real user messages; skip extension-sourced messages and commands.
+		if (event.source === "extension") return;
+		const text = event.text.trim();
+		if (!text || text.startsWith("/")) return;
+		if (!ctx.model) return;
+
+		const seq = ++namingSeq;
+		void (async () => {
+			try {
+				const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+				if (!auth.ok || !auth.apiKey) return;
+
+				const previous = previousUserMessages(ctx.sessionManager);
+				const conversation = [...previous, text].join("\n");
+
+				const response = await complete(
+					ctx.model,
+					{
+						systemPrompt: NAMING_SYSTEM_PROMPT,
+						messages: [{ role: "user", content: conversation, timestamp: Date.now() }],
+					},
+					{
+						apiKey: auth.apiKey,
+						headers: auth.headers,
+						maxTokens: NAMING_MAX_TOKENS,
+						cacheRetention: "none",
+						// The tokenin gateway ignores `thinking: {type:"disabled"}` and burns the
+						// whole budget on reasoning; `reasoning_effort: "none"` is what disables it.
+						samplingParams: { reasoning_effort: "none" },
+					},
+				);
+				const name = response.content
+					.filter((c): c is { type: "text"; text: string } => c.type === "text")
+					.map((c) => c.text)
+					.join("")
+					.trim()
+					.split(/\s+/)
+					.slice(0, MAX_NAME_WORDS)
+					.join(" ");
+				// Only the latest request may set the name; slower older responses lose.
+				if (name && seq === namingSeq) pi.setSessionName(name);
+			} catch {
+				// Best-effort naming; never break the user's message flow.
+			}
+		})();
+	});
+}

package/dist/extensions/context-compaction-reminder.test.ts

@@ -1,82 +1,82 @@
-import { describe, expect, it, vi } from "vitest";
-import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
-import contextCompactionReminderExtension, {
-	CONTEXT_COMPACTION_REMINDER_MESSAGE,
-} from "./context-compaction-reminder.ts";
-
-type Handler = (event: unknown, ctx: ExtensionContext) => void | Promise<void>;
-
-function createHarness(tokens: number | null | undefined = undefined) {
-	const handlers = new Map<string, Handler>();
-	const notify = vi.fn();
-	const pi = {
-		on: vi.fn((event: string, handler: Handler) => handlers.set(event, handler)),
-	} as unknown as ExtensionAPI;
-	const ctx = {
-		getContextUsage: () =>
-			tokens === undefined ? undefined : { tokens, contextWindow: 200_000, percent: tokens === null ? null : tokens / 2_000 },
-		ui: { notify },
-	} as unknown as ExtensionContext;
-
-	contextCompactionReminderExtension(pi);
-
-	return {
-		notify,
-		setTokens: (value: number | null | undefined) => {
-			tokens = value;
-		},
-		settle: () => handlers.get("agent_settled")!({ type: "agent_settled" }, ctx),
-		compact: () => handlers.get("session_compact")!({ type: "session_compact" }, ctx),
-	};
-}
-
-describe("context-compaction-reminder", () => {
-	it("warns once when known context reaches 128k", async () => {
-		const { notify, setTokens, settle } = createHarness(127_999);
-
-		await settle();
-		setTokens(128_000);
-		await settle();
-		setTokens(130_000);
-		await settle();
-
-		expect(notify).toHaveBeenCalledTimes(1);
-		expect(notify).toHaveBeenCalledWith(CONTEXT_COMPACTION_REMINDER_MESSAGE, "warning");
-	});
-
-	it("does not reset the reminder for unavailable or post-compaction usage", async () => {
-		const { notify, setTokens, settle } = createHarness(128_000);
-
-		await settle();
-		setTokens(undefined);
-		await settle();
-		setTokens(null);
-		await settle();
-		setTokens(130_000);
-		await settle();
-
-		expect(notify).toHaveBeenCalledTimes(1);
-	});
-
-	it("allows another warning after successful compaction", async () => {
-		const { notify, settle, compact } = createHarness(128_000);
-
-		await settle();
-		await compact();
-		await settle();
-
-		expect(notify).toHaveBeenCalledTimes(2);
-	});
-
-	it("allows another warning after known usage drops below 128k", async () => {
-		const { notify, setTokens, settle } = createHarness(128_000);
-
-		await settle();
-		setTokens(127_999);
-		await settle();
-		setTokens(128_000);
-		await settle();
-
-		expect(notify).toHaveBeenCalledTimes(2);
-	});
-});
+import { describe, expect, it, vi } from "vitest";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
+import contextCompactionReminderExtension, {
+	CONTEXT_COMPACTION_REMINDER_MESSAGE,
+} from "./context-compaction-reminder.ts";
+
+type Handler = (event: unknown, ctx: ExtensionContext) => void | Promise<void>;
+
+function createHarness(tokens: number | null | undefined = undefined) {
+	const handlers = new Map<string, Handler>();
+	const notify = vi.fn();
+	const pi = {
+		on: vi.fn((event: string, handler: Handler) => handlers.set(event, handler)),
+	} as unknown as ExtensionAPI;
+	const ctx = {
+		getContextUsage: () =>
+			tokens === undefined ? undefined : { tokens, contextWindow: 200_000, percent: tokens === null ? null : tokens / 2_000 },
+		ui: { notify },
+	} as unknown as ExtensionContext;
+
+	contextCompactionReminderExtension(pi);
+
+	return {
+		notify,
+		setTokens: (value: number | null | undefined) => {
+			tokens = value;
+		},
+		settle: () => handlers.get("agent_settled")!({ type: "agent_settled" }, ctx),
+		compact: () => handlers.get("session_compact")!({ type: "session_compact" }, ctx),
+	};
+}
+
+describe("context-compaction-reminder", () => {
+	it("warns once when known context reaches 128k", async () => {
+		const { notify, setTokens, settle } = createHarness(127_999);
+
+		await settle();
+		setTokens(128_000);
+		await settle();
+		setTokens(130_000);
+		await settle();
+
+		expect(notify).toHaveBeenCalledTimes(1);
+		expect(notify).toHaveBeenCalledWith(CONTEXT_COMPACTION_REMINDER_MESSAGE, "warning");
+	});
+
+	it("does not reset the reminder for unavailable or post-compaction usage", async () => {
+		const { notify, setTokens, settle } = createHarness(128_000);
+
+		await settle();
+		setTokens(undefined);
+		await settle();
+		setTokens(null);
+		await settle();
+		setTokens(130_000);
+		await settle();
+
+		expect(notify).toHaveBeenCalledTimes(1);
+	});
+
+	it("allows another warning after successful compaction", async () => {
+		const { notify, settle, compact } = createHarness(128_000);
+
+		await settle();
+		await compact();
+		await settle();
+
+		expect(notify).toHaveBeenCalledTimes(2);
+	});
+
+	it("allows another warning after known usage drops below 128k", async () => {
+		const { notify, setTokens, settle } = createHarness(128_000);
+
+		await settle();
+		setTokens(127_999);
+		await settle();
+		setTokens(128_000);
+		await settle();
+
+		expect(notify).toHaveBeenCalledTimes(2);
+	});
+});

package/dist/extensions/context-compaction-reminder.ts

@@ -1,28 +1,28 @@
-import type { ExtensionAPI } from "@selesai/code";
-
-export const CONTEXT_COMPACTION_REMINDER_THRESHOLD = 128_000;
-export const CONTEXT_COMPACTION_REMINDER_MESSAGE =
-	`Conversation context has reached ${CONTEXT_COMPACTION_REMINDER_THRESHOLD.toLocaleString()} tokens. Run /handoff-new to summarize into a new chat, or enable Auto Handoff in Settings to do this automatically. Bigger context windows eat up tokens quickly and degrade AI quality.`;
-
-export default function contextCompactionReminderExtension(pi: ExtensionAPI): void {
-	let reminderShown = false;
-
-	pi.on("session_compact", () => {
-		reminderShown = false;
-	});
-
-	pi.on("agent_settled", (_event, ctx) => {
-		const tokens = ctx.getContextUsage()?.tokens;
-		if (tokens === undefined || tokens === null) return;
-
-		if (tokens < CONTEXT_COMPACTION_REMINDER_THRESHOLD) {
-			reminderShown = false;
-			return;
-		}
-
-		if (!reminderShown) {
-			ctx.ui.notify(CONTEXT_COMPACTION_REMINDER_MESSAGE, "warning");
-			reminderShown = true;
-		}
-	});
-}
+import type { ExtensionAPI } from "@selesai/code";
+
+export const CONTEXT_COMPACTION_REMINDER_THRESHOLD = 128_000;
+export const CONTEXT_COMPACTION_REMINDER_MESSAGE =
+	`Conversation context has reached ${CONTEXT_COMPACTION_REMINDER_THRESHOLD.toLocaleString()} tokens. Run /handoff-new to summarize into a new chat, or enable Auto Handoff in Settings to do this automatically. Bigger context windows eat up tokens quickly and degrade AI quality.`;
+
+export default function contextCompactionReminderExtension(pi: ExtensionAPI): void {
+	let reminderShown = false;
+
+	pi.on("session_compact", () => {
+		reminderShown = false;
+	});
+
+	pi.on("agent_settled", (_event, ctx) => {
+		const tokens = ctx.getContextUsage()?.tokens;
+		if (tokens === undefined || tokens === null) return;
+
+		if (tokens < CONTEXT_COMPACTION_REMINDER_THRESHOLD) {
+			reminderShown = false;
+			return;
+		}
+
+		if (!reminderShown) {
+			ctx.ui.notify(CONTEXT_COMPACTION_REMINDER_MESSAGE, "warning");
+			reminderShown = true;
+		}
+	});
+}

package/dist/extensions/cost-reconcile.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { extractCosts, parseCostHeader } from "./cost-reconcile.ts";
+
+describe("parseCostHeader", () => {
+	it("parses LiteLLM scientific-notation cost", () => {
+		expect(parseCostHeader("4.45284e-06")).toBe(4.45284e-6);
+	});
+
+	it("parses plain decimal cost", () => {
+		expect(parseCostHeader("0.00123")).toBe(0.00123);
+	});
+
+	it("rejects null, garbage, and negatives", () => {
+		expect(parseCostHeader(null)).toBeUndefined();
+		expect(parseCostHeader("abc")).toBeUndefined();
+		expect(parseCostHeader("-1")).toBeUndefined();
+	});
+});
+
+describe("extractCosts", () => {
+	it("reads OpenRouter chat-completions usage cost from a final SSE chunk", () => {
+		const body =
+			'Data: {"id":"gen-abc","provider":"OpenAI"}\n\n' +
+			'data: {"id":"gen-abc","usage":{"prompt_tokens":10,"cost":0.0123},"choices":[]}\n\n' +
+			"data: [DONE]\n\n";
+		const { ids, cost } = extractCosts(body);
+		expect(ids).toContain("gen-abc");
+		expect(cost).toBe(0.0123);
+	});
+
+	it("reads OpenRouter native total_cost from a JSON body", () => {
+		const { ids, cost } = extractCosts(
+			'{"id":"gen-xyz","total_cost":0.05152,"usage":{"total_tokens":330}}',
+		);
+		expect(ids).toEqual(["gen-xyz"]);
+		expect(cost).toBe(0.05152);
+	});
+
+	it("reads object-shaped cost {total} payloads", () => {
+		const { cost } = extractCosts('{"id":"gen-obj","cost":{"input":0.01,"total":0.0456}}');
+		expect(cost).toBe(0.0456);
+	});
+
+	it("keeps the last cost when multiple chunks carry usage", () => {
+		const body =
+			'data: {"id":"gen-1","usage":{"cost":0.01}}\n\ndata: {"id":"gen-1","usage":{"cost":0.02}}\n\n';
+		const { cost } = extractCosts(body);
+		expect(cost).toBe(0.02);
+	});
+
+	it("returns no cost when the payload has none", () => {
+		const { ids, cost } = extractCosts('data: {"id":"resp-1","delta":"hi"}\n\n');
+		expect(ids).toContain("resp-1");
+		expect(cost).toBeUndefined();
+	});
+
+	it("ignores negative or non-finite costs", () => {
+		const { cost } = extractCosts('{"id":"gen-neg","cost":-1}');
+		expect(cost).toBeUndefined();
+	});
+
+	it("extracts ids from anthropic-style message_start without cost", () => {
+		const body =
+			'event: message_start\ndata: {"type":"message_start","message":{"id":"msg_01ABC","usage":{}}}\n\n' +
+			'event: message_delta\ndata: {"type":"message_delta","usage":{"output_tokens":15}}\n\n';
+		const { ids, cost } = extractCosts(body);
+		expect(ids).toContain("msg_01ABC");
+		expect(cost).toBeUndefined();
+	});
+
+	it("caps captured ids", () => {
+		const body = Array.from({ length: 100 }, (_, i) => `{"id":"id-${i}"}`).join("\n");
+		const { ids } = extractCosts(body);
+		expect(ids.length).toBe(50);
+	});
+});

package/dist/extensions/cost-reconcile.ts

@@ -0,0 +1,278 @@
+/**
+ * Cost Reconcile — records the real billed cost the provider reports in its
+ * own response payload, for any provider that includes one.
+ *
+ * pi-ai reads token counts from provider payloads but discards any
+ * provider-reported `cost` field, recomputing cost from the local rate card.
+ * For gateways (OpenRouter etc.) and custom catalog entries that bill with
+ * their own tokenizers or dated pricing, the estimate diverges from the bill.
+ *
+ * Extensions cannot hook the response body through the event API
+ * (`after_provider_response` exposes only status/headers), but provider SDKs
+ * fall back to `globalThis.fetch`. This extension installs a tee-wrapping
+ * fetch once per process: LLM API responses are scanned for a
+ * provider-reported cost (LiteLLM `x-litellm-response-cost` header,
+ * OpenRouter `usage.cost`, `total_cost`, plus object-shaped `cost.total`)
+ * and its response id, then recorded as a custom session entry on
+ * `message_end`.
+ *
+ * Providers whose payloads carry no cost (first-party OpenAI/Anthropic due to
+ * their usage APIs) simply record nothing — their rate-card estimate matches
+ * their bill anyway when catalog prices are configured.
+ *
+ * The zentui footer prefers reconciled entries over the rate-card total when
+ * both exist for the same response id.
+ */
+
+import type { ExtensionAPI } from "@selesai/code";
+
+const ENTRY_TYPE = "cost-reconcile";
+const ENTRY_VERSION = 1 as const;
+
+// Guard against pathological bodies; real usage chunks arrive well under 1MB.
+const MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
+// Only LLM API paths are tee'd and scanned; unrelated fetches (web fetch tool,
+// model catalog refreshes) pass through untouched.
+const LLM_PATH_RE = /(\/chat\/completions|\/responses|\/messages\b|:streamGenerateContent)/;
+const MAX_CAPTURED_IDS = 50;
+const MAX_PENDING_LOOKUPS = 200;
+const MAX_SESSION_ENTRIES = 2_000;
+
+type ReconcileEntry = {
+	version: typeof ENTRY_VERSION;
+	provider: string;
+	model: string;
+	responseId: string;
+	/** Provider-reported billed cost in USD. */
+	cost: number;
+	reconciledAt: number;
+	source: "payload";
+};
+
+/**
+ * Scan a captured SSE/JSON body for provider-reported cost and response ids.
+ * Exported for tests.
+ *
+ * In streams, usage lands in the final chunk, so the LAST cost match wins.
+ */
+type MessageInfo = {
+	provider: string;
+	model: string;
+	responseId: string;
+};
+
+// Process-wide capture state. The fetch patch is installed once per process
+// and must not capture session-bound `pi`; per-session message_end handlers
+// read these maps and write entries through their own session's appendEntry.
+const processCaptured = new Map<string, number>();
+const processWaiting = new Map<
+	string,
+	{ info: MessageInfo; write: (info: MessageInfo, cost: number) => void }
+>();
+
+/**
+ * Scan a captured SSE/JSON body for provider-reported cost and response ids.
+ * Pure function; exported for tests.
+ *
+ * In streams, usage lands in the final chunk, so the LAST cost match wins.
+ */
+/**
+ * Parse a LiteLLM `x-litellm-response-cost` header value (a USD float,
+ * possibly in scientific notation). Exported for tests.
+ */
+export function parseCostHeader(value: string | null): number | undefined {
+	if (value === null) return undefined;
+	const cost = Number(value);
+	return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
+}
+
+export function extractCosts(
+	text: string,
+): { ids: string[]; cost?: number } {
+	const ids = new Set<string>();
+	for (const match of text.matchAll(/"id"\s*:\s*"([^"]{1,200})"/g)) {
+		ids.add(match[1]);
+		if (ids.size >= MAX_CAPTURED_IDS) break;
+	}
+
+	// OpenRouter native API uses `total_cost`; chat-completions streams use
+	// `cost` (number or `{total}`); gateways behind the responses API have
+	// been observed with object-shaped cost too.
+	let cost: number | undefined;
+	for (const match of text.matchAll(
+		/"total_cost"\s*:\s*(-?[\d.eE+]+)|"cost"\s*:\s*(-?[\d.eE+]+)|"cost"\s*:\s*\{[^}]*?"total"\s*:\s*(-?[\d.eE+]+)/g,
+	)) {
+		const value = Number(match[1] ?? match[2] ?? match[3]);
+		if (Number.isFinite(value) && value >= 0) cost = value;
+	}
+
+	return { ids: [...ids], cost };
+}
+
+function isLlmUrl(input: unknown): boolean {
+	try {
+		const url =
+			typeof input === "string"
+				? input
+				: input instanceof URL
+					? input.href
+					: input instanceof Request
+						? input.url
+						: undefined;
+		if (!url) return false;
+		if (!/^https?:/i.test(url)) return false;
+		return LLM_PATH_RE.test(url);
+	} catch {
+		return false;
+	}
+}
+
+/** Install the capture fetch once per process, across extension reloads. */
+const FETCH_PATCHED = Symbol.for("selesai.cost-reconcile.fetch-patched");
+
+export default function costReconcileExtension(pi: ExtensionAPI): void {
+	/** Response ids already written to this session's file. */
+	const seen = new Set<string>();
+	let entriesWritten = 0;
+
+	const writeEntry = (info: MessageInfo, cost: number): void => {
+		if (seen.has(info.responseId) || entriesWritten >= MAX_SESSION_ENTRIES) return;
+		seen.add(info.responseId);
+		entriesWritten += 1;
+		const entry: ReconcileEntry = {
+			version: ENTRY_VERSION,
+			provider: info.provider,
+			model: info.model,
+			responseId: info.responseId,
+			cost,
+			reconciledAt: Date.now(),
+			source: "payload",
+		};
+		try {
+			pi.appendEntry(ENTRY_TYPE, entry);
+		} catch {
+			// transcript persistence failure must not break the session
+		}
+	};
+
+	const finishCapture = (rawBody: string, headerCost?: number): void => {
+		// ponytail: one naive regex pass over the whole body; a streaming
+		// parser only matters if bodies grow past the 4MB cap.
+		const { ids, cost } = extractCosts(rawBody);
+		// LiteLLM's header is the amount the gateway billed; prefer it over
+		// any cost the upstream payload reports.
+		const effectiveCost = headerCost ?? cost;
+		if (effectiveCost === undefined) return;
+		for (const responseId of ids) {
+			processCaptured.set(responseId, effectiveCost);
+			const waiting = processWaiting.get(responseId);
+			if (waiting) {
+				processWaiting.delete(responseId);
+				waiting.write(waiting.info, effectiveCost);
+			}
+		}
+		if (processCaptured.size > 500) {
+			for (const key of [...processCaptured.keys()].slice(0, processCaptured.size - 500))
+				processCaptured.delete(key);
+		}
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		try {
+			const entries =
+				(
+					ctx.sessionManager as {
+						getEntries?: () => readonly { type?: string; customType?: string; data?: ReconcileEntry }[];
+					}
+				).getEntries?.() ?? [];
+			for (const entry of entries) {
+				if (entry?.type !== "custom" || entry?.customType !== ENTRY_TYPE) continue;
+				const responseId = entry?.data?.responseId;
+				if (typeof responseId === "string") seen.add(responseId);
+			}
+		} catch {
+			// best effort only
+		}
+
+		const globalFetch = globalThis as typeof globalThis & { [FETCH_PATCHED]?: boolean };
+		if (globalFetch[FETCH_PATCHED]) return;
+		globalFetch[FETCH_PATCHED] = true;
+		const realFetch = globalThis.fetch.bind(globalThis);
+		globalThis.fetch = async (input, init) => {
+			const response = await realFetch(input as Parameters<typeof realFetch>[0], init);
+			try {
+				if (!isLlmUrl(input)) return response;
+				const contentType = response.headers.get("content-type") ?? "";
+				if (!contentType.includes("json") && !contentType.includes("event-stream")) return response;
+				if (!response.body) return response;
+				const headerCost = parseCostHeader(response.headers.get("x-litellm-response-cost"));
+				const [main, tee] = response.body.tee();
+				void (async () => {
+					let raw = "";
+					try {
+						const reader = tee.getReader();
+						const decoder = new TextDecoder();
+						for (;;) {
+							const { done, value } = await reader.read();
+							if (done) break;
+							raw += decoder.decode(value, { stream: true });
+							if (raw.length > MAX_CAPTURE_BYTES) break;
+						}
+					} catch {
+						// capture is best-effort; the main branch is unaffected
+					}
+					finishCapture(raw, headerCost);
+				})();
+				// Preserve response identity as seen by the SDK: body swapped, rest identical.
+				return new Response(main, {
+					status: response.status,
+					statusText: response.statusText,
+					headers: response.headers,
+				});
+			} catch {
+				return response;
+			}
+		};
+	});
+
+	pi.on("message_end", (event) => {
+		const message = event.message as
+			| {
+					role?: string;
+					provider?: string;
+					model?: string;
+					responseId?: string;
+					stopReason?: string;
+				}
+			| undefined;
+		if (!message || message.role !== "assistant") return;
+		if (message.stopReason === "error" || message.stopReason === "aborted") return;
+		const responseId = message.responseId;
+		if (typeof responseId !== "string" || responseId.length === 0) return;
+
+		const info: MessageInfo = {
+			provider: message.provider ?? "",
+			model: message.responseModel ?? message.model ?? "",
+			responseId,
+		};
+		const cost = processCaptured.get(responseId);
+		if (cost !== undefined) {
+			writeEntry(info, cost);
+			return;
+		}
+		// The tee branch may finish after message_end; remember the message so
+		// the capture can match it on completion and write via this session.
+		if (!seen.has(responseId) && !processWaiting.has(responseId)) {
+			waitingLimitGuard();
+			processWaiting.set(responseId, { info, write: writeEntry });
+		}
+	});
+}
+
+// Trim oldest waiting entries so unclaimed captures cannot grow unbounded.
+function waitingLimitGuard(): void {
+	if (processWaiting.size >= MAX_PENDING_LOOKUPS) {
+		for (const key of [...processWaiting.keys()].slice(0, processWaiting.size - MAX_PENDING_LOOKUPS + 1))
+			processWaiting.delete(key);
+	}
+}