@selesai/code 0.13.1 → 0.13.3

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.3] - 2026-08-31
+
+### Added
+- **Token-In multi-key auto-failover.** The `tokenin-onboarding` extension now registers a `tokenin` provider whose `streamSimple` automatically rotates to an alternative saved account when the active key fails with a 401, 429, or budget/quota error. Failed keys go on a 5-minute in-memory cooldown before being retried, and the newly active credential is persisted to both `tokenin-auth.json` and `auth.json`.
+
+### Changed
+- **Cost reconciliation replaces the finalized assistant cost.** The `cost-reconcile` fetch wrapper now finishes capturing the provider-reported cost before the provider SDK finalizes its assistant message, so `message_end` replaces `usage.cost.total` with the billed amount before the message is persisted. Providers whose payloads carry no cost keep their rate-card estimate.
+- **Default model catalog reasoning maps.** Added `thinkingLevelMap` entries (and `low`=low / `max` mappings) across bundled model defaults and enabled reasoning on Qwen3.8 27B and Gemini 3.7 Flash so thinking budgets map correctly.
+
+## [0.13.2] - 2026-08-30
+
+### Added
+- **Rewind submodule support.** `pi-rewind-hook` now snapshots gitlink commits and restores submodule worktrees to their target commits during exact rewind, with safety checks: submodule paths must stay unchanged, worktrees must be clean and initialized, and target commits must be available locally. Unsupported submodule states (dirty, uninitialized, added/removed paths, nested submodules) are refused with a clear error instead of being reported as exact restores.
+- **Rewind retention sweep concurrency safety.** The retention sweep now uses a compare-and-swap on the store ref with retries, so concurrent sessions adding snapshots mid-sweep are preserved instead of being clobbered; the startup sweep is reused across session replacement instead of racing a second sweep.
+
+### Changed
+- **Herdr status bridge drops agent scoping.** `pi-subagents` no longer passes `--agent pi` / `--applies-to-source herdr:pi` to Herdr `report-metadata` calls; state labels are reported under the `pi-subagents:herdr` source directly.
+- **Rewind extension packaging.** `pi-rewind-hook` declares `@selesai/code` as a peer dependency (was devDependency) and bumps to 1.8.6.
+
 ## [0.13.1] - 2026-08-30
 
 ### Fixed

package/dist/defaults/models.json

@@ -19,7 +19,7 @@
           "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
-            "low": null,
+            "low": "low",
             "medium": null,
             "high": "high",
             "xhigh": null,
@@ -38,7 +38,7 @@
           "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
-            "low": null,
+            "low": "low",
             "medium": null,
             "high": "high",
             "xhigh": null,
@@ -57,7 +57,7 @@
           "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
-            "low": null,
+            "low": "low",
             "medium": null,
             "high": "high",
             "xhigh": null,
@@ -114,7 +114,7 @@
           "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
-            "low": null,
+            "low": "low",
             "medium": null,
             "high": "high",
             "xhigh": null,
@@ -130,7 +130,15 @@
           "reasoning": true,
           "input": ["text", "image"],
           "contextWindow": 512000,
-          "maxTokens": 128000
+          "maxTokens": 128000,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": "low",
+            "medium": null,
+            "high": "high",
+            "xhigh": null,
+            "max": "max"
+          }
         },
         {
           "id": "gpt-5.6-terra",
@@ -138,7 +146,15 @@
           "reasoning": true,
           "input": ["text", "image"],
           "contextWindow": 512000,
-          "maxTokens": 128000
+          "maxTokens": 128000,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": "low",
+            "medium": null,
+            "high": "high",
+            "xhigh": null,
+            "max": null
+          }
         },
         {
           "id": "gpt-5.6-sol",
@@ -146,7 +162,15 @@
           "reasoning": true,
           "input": ["text", "image"],
           "contextWindow": 512000,
-          "maxTokens": 128000
+          "maxTokens": 128000,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": "low",
+            "medium": null,
+            "high": "high",
+            "xhigh": null,
+            "max": null
+          }
         },
         {
           "id": "kimi-k3",
@@ -209,16 +233,24 @@
             "medium": null,
             "high": "high",
             "xhigh": null,
-            "max": null
+            "max": "max"
           }
         },
         {
           "id": "qwen3.8-27b",
           "name": "Qwen3.8 27B",
-          "reasoning": false,
+          "reasoning": true,
           "input": ["text", "image"],
           "contextWindow": 256000,
           "maxTokens": 64000,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": "low",
+            "medium": null,
+            "high": "high",
+            "xhigh": null,
+            "max": "max"
+          },
           "compat": {
             "thinkingFormat": "qwen"
           }
@@ -226,10 +258,18 @@
         {
           "id": "gemini-3.7-flash",
           "name": "Gemini 3.7 Flash",
-          "reasoning": false,
-          "input": ["text", "image" ],
+          "reasoning": true,
+          "input": ["text", "image"],
           "contextWindow": 512000,
-          "maxTokens": 64000
+          "maxTokens": 64000,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": "low",
+            "medium": null,
+            "high": "high",
+            "xhigh": null,
+            "max": null
+          }
         },
         {
           "id": "Qwen3-VL",
@@ -238,6 +278,14 @@
           "input": ["text", "image"],
           "contextWindow": 256000,
           "maxTokens": 8192,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": "low",
+            "medium": null,
+            "high": "high",
+            "xhigh": null,
+            "max": null
+          },
           "compat": {
             "supportsDeveloperRole": false,
             "supportsReasoningEffort": false,
@@ -251,6 +299,14 @@
           "input": ["text", "image"],
           "contextWindow": 256000,
           "maxTokens": 8192,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": "low",
+            "medium": null,
+            "high": "high",
+            "xhigh": null,
+            "max": null
+          },
           "compat": {
             "supportsDeveloperRole": false,
             "supportsReasoningEffort": false,

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

@@ -1,5 +1,63 @@
-import { describe, expect, it } from "vitest";
-import { extractCosts, parseCostHeader } from "./cost-reconcile.ts";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import costReconcileExtension, { extractCosts, parseCostHeader } from "./cost-reconcile.ts";
+
+type Handler = (event: any, ctx: any) => any;
+
+const FETCH_PATCHED = Symbol.for("selesai.cost-reconcile.fetch-patched");
+let originalFetch: typeof globalThis.fetch;
+
+function createHarness() {
+	const handlers = new Map<string, Handler>();
+	const appendEntry = vi.fn();
+	const pi = {
+		on: vi.fn((event: string, handler: Handler) => handlers.set(event, handler)),
+		appendEntry,
+	};
+	costReconcileExtension(pi as any);
+	return { appendEntry, handlers };
+}
+
+async function startSession(handlers: Map<string, Handler>): Promise<void> {
+	await handlers.get("session_start")!({}, { sessionManager: { getEntries: () => [] } });
+}
+
+function assistantMessage(responseId: string, total = 0.75) {
+	return {
+		role: "assistant",
+		provider: "openrouter",
+		model: "openai/gpt-4.1-mini",
+		responseModel: "openai/gpt-4.1-mini",
+		responseId,
+		stopReason: "stop",
+		content: [],
+		usage: {
+			input: 10,
+			output: 5,
+			cacheRead: 2,
+			cacheWrite: 1,
+			cost: { input: 0.2, output: 0.4, cacheRead: 0.1, cacheWrite: 0.05, total },
+		},
+	};
+}
+
+function installFetch(body: string, headers: Record<string, string> = {}) {
+	const upstreamFetch = vi.fn(async () =>
+		new Response(body, { headers: { "content-type": "text/event-stream", ...headers } }),
+	);
+	globalThis.fetch = upstreamFetch as typeof globalThis.fetch;
+	return upstreamFetch;
+}
+
+beforeEach(() => {
+	originalFetch = globalThis.fetch;
+	delete (globalThis as typeof globalThis & { [FETCH_PATCHED]?: boolean })[FETCH_PATCHED];
+});
+
+afterEach(() => {
+	globalThis.fetch = originalFetch;
+	delete (globalThis as typeof globalThis & { [FETCH_PATCHED]?: boolean })[FETCH_PATCHED];
+	vi.restoreAllMocks();
+});
 
 describe("parseCostHeader", () => {
 	it("parses LiteLLM scientific-notation cost", () => {
@@ -10,11 +68,17 @@ describe("parseCostHeader", () => {
 		expect(parseCostHeader("0.00123")).toBe(0.00123);
 	});
 
-	it("rejects null, garbage, and negatives", () => {
+	it("rejects null, blank, garbage, and negative values", () => {
 		expect(parseCostHeader(null)).toBeUndefined();
+		expect(parseCostHeader("")).toBeUndefined();
+		expect(parseCostHeader(" \t ")).toBeUndefined();
 		expect(parseCostHeader("abc")).toBeUndefined();
 		expect(parseCostHeader("-1")).toBeUndefined();
 	});
+
+	it("trims valid zero-valued headers", () => {
+		expect(parseCostHeader(" 0 ")).toBe(0);
+	});
 });
 
 describe("extractCosts", () => {
@@ -73,4 +137,117 @@ describe("extractCosts", () => {
 		const { ids } = extractCosts(body);
 		expect(ids.length).toBe(50);
 	});
-});
+});
+
+describe("live assistant usage reconciliation", () => {
+	it("replaces finalized assistant usage only after the streamed body completes and keeps the custom entry", async () => {
+		const responseId = "live-reconcile-1";
+		const body = `data: {"id":"${responseId}","usage":{"cost":0.0123}}\n\ndata: [DONE]\n\n`;
+		installFetch(body);
+		const { appendEntry, handlers } = createHarness();
+		await startSession(handlers);
+
+		const response = await globalThis.fetch("https://openrouter.ai/api/v1/chat/completions");
+		const messageEnd = handlers.get("message_end")!;
+		expect(await messageEnd({ message: assistantMessage(responseId) }, {})).toBeUndefined();
+
+		expect(await response.text()).toBe(body);
+		const result = await messageEnd({ message: assistantMessage(responseId) }, {});
+		expect(result.message.usage.cost).toEqual({
+			input: 0.2,
+			output: 0.4,
+			cacheRead: 0.1,
+			cacheWrite: 0.05,
+			total: 0.0123,
+		});
+		expect(appendEntry).toHaveBeenCalledWith(
+			"cost-reconcile",
+			expect.objectContaining({ provider: "openrouter", responseId, cost: 0.0123, source: "payload" }),
+		);
+	});
+
+	it("uses a valid zero-valued billed header over the payload cost", async () => {
+		const responseId = "live-header-zero-2";
+		installFetch(`data: {"id":"${responseId}","usage":{"cost":0.0123}}\n\n`, {
+			"x-litellm-response-cost": "0",
+		});
+		const { handlers } = createHarness();
+		await startSession(handlers);
+
+		const response = await globalThis.fetch("https://gateway.example/v1/chat/completions");
+		await response.text();
+		const result = await handlers.get("message_end")!({ message: assistantMessage(responseId) }, {});
+		expect(result.message.usage.cost.total).toBe(0);
+	});
+
+	it("falls back when a captured body has multiple candidate response ids", async () => {
+		const responseId = "live-ambiguous-response-3";
+		installFetch(
+			`data: {"id":"${responseId}","usage":{"cost":0.0123},"tool_calls":[{"id":"tool-ambiguous-3"}]}\n\n`,
+		);
+		const { appendEntry, handlers } = createHarness();
+		await startSession(handlers);
+
+		const response = await globalThis.fetch("https://gateway.example/v1/chat/completions");
+		await response.text();
+		const message = assistantMessage(responseId);
+		expect(await handlers.get("message_end")!({ message }, {})).toBeUndefined();
+		expect(message.usage.cost.total).toBe(0.75);
+		expect(appendEntry).not.toHaveBeenCalled();
+	});
+
+	it("falls back when the process cache sees a duplicate response id", async () => {
+		const responseId = "live-duplicate-response-4";
+		installFetch(`data: {"id":"${responseId}","usage":{"cost":0.0123}}\n\n`);
+		const { appendEntry, handlers } = createHarness();
+		await startSession(handlers);
+
+		const first = await globalThis.fetch("https://gateway.example/v1/chat/completions");
+		const second = await globalThis.fetch("https://gateway.example/v1/chat/completions");
+		await Promise.all([first.text(), second.text()]);
+		const message = assistantMessage(responseId);
+		expect(await handlers.get("message_end")!({ message }, {})).toBeUndefined();
+		expect(message.usage.cost.total).toBe(0.75);
+		expect(appendEntry).not.toHaveBeenCalled();
+	});
+
+	it("preserves the original message when no valid billed cost was captured", async () => {
+		const responseId = "live-no-cost-3";
+		installFetch(`data: {"id":"${responseId}","usage":{"cost":-1}}\n\n`);
+		const { appendEntry, handlers } = createHarness();
+		await startSession(handlers);
+
+		const response = await globalThis.fetch("https://gateway.example/v1/chat/completions");
+		await response.text();
+		const message = assistantMessage(responseId);
+		expect(await handlers.get("message_end")!({ message }, {})).toBeUndefined();
+		expect(message.usage.cost.total).toBe(0.75);
+		expect(appendEntry).not.toHaveBeenCalled();
+	});
+
+	it("preserves terminal error messages even when a billed cost was captured", async () => {
+		const responseId = "live-terminal-4";
+		installFetch(`data: {"id":"${responseId}","usage":{"cost":0.0123}}\n\n`);
+		const { appendEntry, handlers } = createHarness();
+		await startSession(handlers);
+
+		const response = await globalThis.fetch("https://gateway.example/v1/chat/completions");
+		await response.text();
+		const message = { ...assistantMessage(responseId), stopReason: "error" };
+		expect(await handlers.get("message_end")!({ message }, {})).toBeUndefined();
+		expect(message.usage.cost.total).toBe(0.75);
+		expect(appendEntry).not.toHaveBeenCalled();
+	});
+
+	it("does not capture unrelated fetches", async () => {
+		const responseId = "unrelated-fetch-5";
+		const body = `data: {"id":"${responseId}","usage":{"cost":0.0123}}\n\n`;
+		installFetch(body);
+		const { handlers } = createHarness();
+		await startSession(handlers);
+
+		const response = await globalThis.fetch("https://example.com/data.json");
+		expect(await response.text()).toBe(body);
+		expect(await handlers.get("message_end")!({ message: assistantMessage(responseId) }, {})).toBeUndefined();
+	});
+});

package/dist/extensions/cost-reconcile.ts

@@ -9,19 +9,16 @@
  *
  * 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`.
+ * fall back to `globalThis.fetch`. This extension installs a stream-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 response id. The wrapper
+ * finishes capture before the provider SDK finalizes its assistant message, so
+ * `message_end` can replace `usage.cost.total` before session persistence.
  *
- * 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.
+ * Providers whose payloads carry no cost retain their rate-card estimate.
+ * Reconciled entries remain persisted for zentui and existing-session
+ * compatibility.
  */
 
 import type { ExtensionAPI } from "@selesai/code";
@@ -31,11 +28,10 @@ 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.
+// Only LLM API paths are 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 = {
@@ -49,46 +45,34 @@ type ReconcileEntry = {
 	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 }
->();
+// Process-wide capture state. The fetch patch is installed once per process;
+// per-session message_end handlers consume the matching response id. A duplicate
+// capture for the same id is marked ambiguous rather than assigning either bill.
+const processCaptured = new Map<string, number | null>();
 
-/**
- * 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);
+	const trimmed = value?.trim();
+	if (!trimmed) return undefined;
+	const cost = Number(trimmed);
 	return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
 }
 
-export function extractCosts(
-	text: string,
-): { ids: string[]; cost?: number } {
+/**
+ * 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
+ * valid cost match wins.
+ */
+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]);
@@ -151,26 +135,22 @@ export default function costReconcileExtension(pi: ExtensionAPI): void {
 		try {
 			pi.appendEntry(ENTRY_TYPE, entry);
 		} catch {
-			// transcript persistence failure must not break the session
+			// 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.
+		// 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.
+		// 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);
-			}
-		}
+		// A cost must identify exactly one response. Applying it to every `id` in
+		// a body can mistake nested tool/message ids for the assistant response.
+		if (effectiveCost === undefined || ids.length !== 1) return;
+		const responseId = ids[0]!;
+		processCaptured.set(responseId, processCaptured.has(responseId) ? null : effectiveCost);
 		if (processCaptured.size > 500) {
 			for (const key of [...processCaptured.keys()].slice(0, processCaptured.size - 500))
 				processCaptured.delete(key);
@@ -191,7 +171,7 @@ export default function costReconcileExtension(pi: ExtensionAPI): void {
 				if (typeof responseId === "string") seen.add(responseId);
 			}
 		} catch {
-			// best effort only
+			// Best effort only.
 		}
 
 		const globalFetch = globalThis as typeof globalThis & { [FETCH_PATCHED]?: boolean };
@@ -205,26 +185,36 @@ export default function costReconcileExtension(pi: ExtensionAPI): void {
 				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;
+				let raw = "";
+				let captureFailed = false;
+				const decoder = new TextDecoder();
+				const capture = new TransformStream<Uint8Array, Uint8Array>({
+					transform(chunk, controller) {
+						controller.enqueue(chunk);
+						if (captureFailed) return;
+						try {
+							raw += decoder.decode(chunk, { stream: true });
+							if (raw.length > MAX_CAPTURE_BYTES) captureFailed = true;
+						} catch {
+							captureFailed = true;
 						}
-					} 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, {
+					},
+					flush() {
+						if (captureFailed) return;
+						try {
+							raw += decoder.decode();
+							finishCapture(raw, headerCost);
+						} catch {
+							// Capture is best-effort; the response stream is unaffected.
+						}
+					},
+				});
+				// flush() runs before the SDK observes EOF, so message_end can safely
+				// replace the finalized message usage without waiting on another fetch.
+				const body = response.body.pipeThrough(capture);
+				return new Response(body, {
 					status: response.status,
 					statusText: response.statusText,
 					headers: response.headers,
@@ -236,43 +226,32 @@ export default function costReconcileExtension(pi: ExtensionAPI): void {
 	});
 
 	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;
+		const message = event.message;
+		if (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);
+		if (cost === undefined || cost === null || !message.usage?.cost) {
+			processCaptured.delete(responseId);
 			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 });
-		}
+		processCaptured.delete(responseId);
+
+		writeEntry(
+			{
+				provider: message.provider ?? "",
+				model: message.responseModel ?? message.model ?? "",
+				responseId,
+			},
+			cost,
+		);
+		return {
+			message: {
+				...message,
+				usage: { ...message.usage, cost: { ...message.usage.cost, total: cost } },
+			},
+		};
 	});
 }
-
-// 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);
-	}
-}