@vanillagreen/pi-claude-bridge 2.0.0 → 3.2.2

package/src/query-state.ts

@@ -6,11 +6,47 @@
 //
 // Extracted from index.ts so tests can import without activating the extension.
 
+import type { ContentBlockParam } from "@anthropic-ai/sdk/resources";
 import type { AssistantMessage, AssistantMessageEventStream, Model } from "@earendil-works/pi-ai";
+import { isConnectorTool } from "./connectors.js";
 import type { McpResult } from "./extract-tool-results.js";
+import { currentRequestLaneId } from "./request-lane.js";
+
+/** A mid-query user run captured for replay after the active query ends.
+ *  `text` is the joined text form (previews, and the replay prompt when no
+ *  image blocks were captured). `blocks` is present when the run carried
+ *  images — the replay must send the blocks or the images are silently lost
+ *  (vstack#993). */
+export interface DeferredUserMessage {
+	text: string;
+	blocks?: ContentBlockParam[];
+}
+
+/** Diag payload for a deferred-message drop: counts, sites, and lengths only.
+ *  The messages are user-authored prompt text and the diag log sits outside
+ *  any host app's retention boundary, so no content — not even a preview —
+ *  may appear in the entry (VST-15). */
+export function summarizeDroppedUserMessages(site: string, dropped: DeferredUserMessage[]): Record<string, unknown> {
+	return {
+		site,
+		count: dropped.length,
+		textLengths: dropped.map((message) => message.text.length),
+		imageOnlyCount: dropped.filter((message) => !message.text && message.blocks?.length).length,
+	};
+}
 
 export interface PendingToolCall {
 	toolName: string;
+	/** The MCP invocation's schema-validated arguments. The SDK hands the handler
+	 *  the COMPLETE input, so this is the authoritative copy — the grace-timer
+	 *  finalize settles a still-partial streamed block from here instead of from
+	 *  its truncated partial JSON (vstack#1469: a `{}` settle made Pi execute
+	 *  empty-argument calls). */
+	args: Record<string, unknown>;
+	/** `QueryContext.callbackGeneration` at registration. A handler from an older
+	 *  generation whose id was never forwarded to Pi can never be answered — see
+	 *  drainStrandedToolCalls. */
+	generation: number;
 	resolve: (result: McpResult) => void;
 }
 
@@ -56,6 +92,74 @@ export function drainPendingToolCalls(queryCtx: QueryContext, cause: ToolCallDra
 	return drained;
 }
 
+/** The error a stranded handler resolves with: its call never reached Pi and
+ *  the forward paths have marked it dead, so no result can ever arrive and the
+ *  call is guaranteed not to have executed on the Pi side. */
+export function strandedToolCallResult(): McpResult {
+	return {
+		content: [{ type: "text", text: "Claude bridge: this tool call was never forwarded to Pi before its turn ended, so it did not execute and no result can arrive. Re-run the tool." }],
+		isError: true,
+	};
+}
+
+/** Fail ONE waiting handler whose call never reached Pi. No-op when the id was
+ *  forwarded (Pi owes it a result — steer-split deliveries arrive turns later)
+ *  or nothing is waiting. Marks the id dead so a lagging stream replay can
+ *  never forward it AFTER the model was told it failed — that late forward
+ *  would execute the call a second time behind the model's back (vstack#1469).
+ *  Returns true when a handler was failed. */
+export function failStrandedToolCall(queryCtx: QueryContext, id: string): boolean {
+	if (queryCtx.forwardedToolCallIds.has(id)) return false;
+	const pending = queryCtx.pendingToolCalls.get(id);
+	if (!pending) return false;
+	queryCtx.pendingToolCalls.delete(id);
+	queryCtx.deadToolCallIds.add(id);
+	pending.resolve(strandedToolCallResult());
+	return true;
+}
+
+/** Fail every waiting handler that provably can never be answered: registered
+ *  before the CURRENT provider callback (older `generation`) with an id Pi was
+ *  never told about. Runs at the delivery site, where a fresh callback proves
+ *  the previous turn is settled. Handlers whose id WAS forwarded stay waiting —
+ *  Pi may deliver their result in a later callback (steer-split batches).
+ *  Handlers from the current generation stay untouched: their turn is still
+ *  streaming and the forward may simply not have happened yet. Failed ids are
+ *  marked dead exactly like failStrandedToolCall. */
+export function drainStrandedToolCalls(queryCtx: QueryContext): Array<{ id: string; toolName: string }> {
+	const stranded: Array<{ id: string; toolName: string }> = [];
+	for (const [id, pending] of queryCtx.pendingToolCalls) {
+		if (pending.generation >= queryCtx.callbackGeneration) continue;
+		if (queryCtx.forwardedToolCallIds.has(id)) continue;
+		stranded.push({ id, toolName: pending.toolName });
+	}
+	for (const { id } of stranded) {
+		const pending = queryCtx.pendingToolCalls.get(id)!;
+		queryCtx.pendingToolCalls.delete(id);
+		queryCtx.deadToolCallIds.add(id);
+		pending.resolve(strandedToolCallResult());
+	}
+	return stranded;
+}
+
+/** Consume a result waiting for `id`, checking the live queue first and the
+ *  reap-parked store second. Late handlers land here: Pi delivers every result
+ *  of a turn in one callback, while the SDK staggers handler invocations, so a
+ *  handler can fire after a message boundary already parked its result. */
+export function takeQueuedOrParkedResult(queryCtx: QueryContext, id: string): McpResult | undefined {
+	const queued = queryCtx.pendingResults.get(id);
+	if (queued !== undefined) {
+		queryCtx.pendingResults.delete(id);
+		return queued;
+	}
+	const parked = queryCtx.reapedResults.get(id);
+	if (parked !== undefined) {
+		queryCtx.reapedResults.delete(id);
+		return parked;
+	}
+	return undefined;
+}
+
 /** One connector call's audit state for the life of a query. `recorded` means an
  *  entry for it has already been appended (or attempted), so neither a re-yielded
  *  result nor the teardown flush can record it twice. */
@@ -148,6 +252,33 @@ export class QueryContext {
 	latestCursor = 0;
 	pendingToolCalls = new Map<string, PendingToolCall>();
 	pendingResults = new Map<string, McpResult>();
+	/** Results a message-boundary reap moved OUT of pendingResults so they stop
+	 *  poisoning mismatch reports, kept CONSUMABLE for a handler that fires later.
+	 *  The 2026-08-17 deadlock session showed the reap's "no consumer will ever
+	 *  come" assumption failing routinely: Pi delivers a turn's results in one
+	 *  callback while the SDK staggers handler invocations past the next message
+	 *  boundary. Query-scoped, bounded by the query's tool-call count. */
+	reapedResults = new Map<string, McpResult>();
+	/** Every tool-call id this query has handed to Pi inside an ENDED turn — the
+	 *  set endToolUseTurn stamps from the turn's content. A forwarded id is one Pi
+	 *  will execute and answer; it must never be emitted again (a lagging stream
+	 *  replays the same tool_use into the NEXT turn, and per-message turnBlocks
+	 *  dedup cannot see across turns — vstack#1469's duplicate executions), and a
+	 *  handler waiting on it must be left waiting at the stranded-handler drains.
+	 *  Query-scoped, never reset per message. */
+	forwardedToolCallIds = new Set<string>();
+	/** Ids whose waiting handler was resolved with strandedToolCallResult. The
+	 *  model has been told these calls failed; forwarding one later would execute
+	 *  it behind the model's back, so every forward path skips them. */
+	deadToolCallIds = new Set<string>();
+	/** Streamed block indexes suppressed as duplicate or dead tool_use blocks —
+	 *  their deltas and stops must be ignored the same way child-executed indexes
+	 *  are. Per message; reset by resetToolTracking. */
+	suppressedStreamIndexes = new Set<number>();
+	/** Bumped at every provider callback for this query. Stamped onto handlers at
+	 *  registration so the stranded-handler drain can tell "registered before this
+	 *  callback, provably settled" from "racing this callback's own stream". */
+	callbackGeneration = 0;
 	turnToolCallIds: string[] = [];
 	turnToolCalls: TurnToolCallRecord[] = [];
 	/**
@@ -160,13 +291,33 @@ export class QueryContext {
 	 * showed. Bounded by the number of tool calls in one query.
 	 */
 	queryToolNames = new Map<string, string>();
+	/** id → last-known arguments, query-scoped like queryToolNames and for the
+	 *  same reason: a late handler firing after resetToolTracking wiped the
+	 *  per-message records must still be able to exact-match the parked/queued
+	 *  result of ITS OWN call — without stored args the only fallback is
+	 *  sole-same-name, which can hand it a LIVE sibling's id (vstack#1469). */
+	queryToolArgs = new Map<string, Record<string, unknown>>();
 	claimedToolCallIds = new Set<string>();
 	deliveredToolResultIds = new Set<string>();
 	resolvedToolResultIds = new Set<string>();
 	unmatchedToolResultIds = new Set<string>();
 	reportedToolResultMismatch = false;
-	deferredUserMessages: string[] = [];
+	deferredUserMessages: DeferredUserMessage[] = [];
 	handledTerminalError = false;
+	// Once visible text/thinking, a complete tool call, or a child-executed
+	// CONNECTOR dispatch reaches Pi, the request must never be replayed on
+	// another account (duplicate side effects). Query-scoped, not per-turn:
+	// resetTurnState must not clear it.
+	committedOutput = false;
+	/** True when this query holds NO claim on the module-level shared session
+	 *  record: a reentrant (subagent) query, or a foreign-conversation one-shot
+	 *  (vstack#1001). Every shared-record mutation reachable from this context —
+	 *  reportToolResultMismatch's needsRebuild/forceRotate mark, the cursor
+	 *  advances on the tool-result-delivery and orphaned-result paths — must
+	 *  no-op so the PARENT's record stays untouched. Assigned at fresh-query
+	 *  setup; deliberately NOT cleared at query end, so a late orphaned tool
+	 *  result arriving after this query settled is still attributed to it. */
+	detachedFromSharedSession = false;
 	/** Armed grace timer for ending a tool_use turn whose terminal stream events
 	 *  (message_delta/message_stop) never arrive. The normal path ends the turn at
 	 *  message_stop, AFTER message_delta delivered the real output-token count;
@@ -174,12 +325,13 @@ export class QueryContext {
 	 *  by schedule/cancelToolUseTurnEnd in assistant-stream.ts. */
 	scheduledToolUseEnd: { stream: unknown; timer: ReturnType<typeof setTimeout> } | null = null;
 
-	// Tool calls the CHILD executes itself (claude.ai connectors — see
-	// isChildExecutedTool). Deliberately NOT in turnToolCalls/turnToolCallIds:
-	// those track calls Pi owes a result for, and Pi owes nothing here. Kept only
-	// so the child's real result can be recognized when it comes back on the SDK's
-	// `user` message, and so the streamed block's deltas can be skipped silently
-	// instead of logging as "unmatched" (which reads like a bug).
+	// Tool calls the CHILD executes itself (see isChildExecutedTool).
+	// Deliberately NOT in turnToolCalls/turnToolCallIds: those track calls Pi
+	// owes a result for, and Pi owes nothing here. CONNECTORS ONLY — kept so the
+	// child's real result can be recognized when it comes back on the SDK's
+	// `user` message and audited. A child-internal built-in (ToolSearch et al.)
+	// never enters this map: its result needs no recognition and no audit, only
+	// its streamed deltas need skipping (childExecutedStreamIndexes below).
 	/** tool_use id → raw SDK tool name. */
 	childExecutedToolCalls = new Map<string, string>();
 	/**
@@ -294,12 +446,26 @@ export class QueryContext {
 		this.reportedToolResultMismatch = false;
 		this.childExecutedToolCalls.clear();
 		this.childExecutedStreamIndexes.clear();
+		this.suppressedStreamIndexes.clear();
 	}
 
 	/** Note a tool_use the child runs itself. `streamIndex` is present only on the
-	 *  streamed path, where later deltas/stops for that block must be skipped. */
+	 *  streamed path, where later deltas/stops for that block must be skipped —
+	 *  that skip applies to every child-executed call. Result recognition and the
+	 *  connector-call audit apply to CONNECTORS only: a child-internal built-in
+	 *  (ToolSearch et al.) is tool plumbing, not account-data access, so nothing
+	 *  about it belongs in the audit trail and no result needs matching. */
 	noteChildExecutedToolCall(id: string | undefined, rawName: string, streamIndex?: number): void {
-		if (id) {
+		if (isConnectorTool(rawName)) {
+			// A connector call is an account-visible side effect the child may run
+			// before any Pi-visible event; crossing it permanently forbids account
+			// replay even when the result or a later text delta never arrives.
+			// Child-internal built-ins (ToolSearch et al.) are pure plumbing and
+			// deliberately do NOT commit — an early ToolSearch must not make the
+			// whole turn non-rotatable.
+			this.markOutputCommitted();
+		}
+		if (id && isConnectorTool(rawName)) {
 			this.childExecutedToolCalls.set(id, rawName);
 			// Both emission paths can see the same call (streamed block, then the
 			// SDK's completed copy), so never overwrite an existing audit state —
@@ -318,6 +484,7 @@ export class QueryContext {
 	recordToolCall(id: string | undefined, toolName: string, args: Record<string, unknown> = {}): void {
 		if (!id) return;
 		this.queryToolNames.set(id, toolName);
+		this.queryToolArgs.set(id, args);
 		if (!this.turnToolCallIds.includes(id)) this.turnToolCallIds.push(id);
 		const existing = this.turnToolCalls.find((call) => call.id === id);
 		if (existing) {
@@ -330,6 +497,7 @@ export class QueryContext {
 
 	updateToolCallArgs(id: string | undefined, args: Record<string, unknown>): void {
 		if (!id) return;
+		this.queryToolArgs.set(id, args);
 		const existing = this.turnToolCalls.find((call) => call.id === id);
 		if (existing) existing.arguments = args;
 	}
@@ -338,10 +506,35 @@ export class QueryContext {
 		return Boolean(id && (this.turnToolCallIds.includes(id) || this.turnToolCalls.some((call) => call.id === id)));
 	}
 
+	markOutputCommitted(): void {
+		this.committedOutput = true;
+	}
+
 	claimToolCall(toolName: string, args: Record<string, unknown> = {}): ClaimedToolCall {
 		const unclaimed = this.turnToolCalls.filter((call) => !this.claimedToolCallIds.has(call.id));
 		const byName = unclaimed.filter((call) => call.toolName === toolName);
 		const exact = byName.filter((call) => sameArgs(call.arguments, args));
+		// Ids whose RESULT already sits queued or parked. A handler can fire after
+		// the message boundary wiped the per-message records — by then Pi has
+		// executed its call and only these query-scoped stores still know it
+		// (vstack#1469: the boundary reap used to make such a handler error out
+		// and the model re-run an already-executed side-effectful call). An
+		// exact-args match here outranks the live sole-same-name fallback below,
+		// so a late handler can never steal a live sibling's id while its own
+		// result waits; without an exact match it is only a last resort.
+		const resultBacked = [...new Set([...this.pendingResults.keys(), ...this.reapedResults.keys()])]
+			.filter((id) => !this.claimedToolCallIds.has(id) && this.queryToolNames.get(id) === toolName);
+		const backedExact = resultBacked.filter((id) => sameArgs(this.queryToolArgs.get(id), args));
+		const claimBacked = (id: string, viaExact: boolean): ClaimedToolCall => {
+			this.claimedToolCallIds.add(id);
+			return {
+				toolCallId: id,
+				match: viaExact ? "tool-args" : "tool-name",
+				ambiguous: viaExact && backedExact.length > 1,
+				available: unclaimed.length,
+				...(!viaExact && hasRecordedArgs(this.queryToolArgs.get(id)) ? { argsMismatch: true } : {}),
+			};
+		};
 		let chosen: TurnToolCallRecord | undefined;
 		let match: ClaimedToolCall["match"] = "none";
 		let ambiguous = false;
@@ -351,6 +544,8 @@ export class QueryContext {
 			chosen = exact[0];
 			match = "tool-args";
 			ambiguous = exact.length > 1;
+		} else if (backedExact.length > 0) {
+			return claimBacked(backedExact[0], true);
 		} else if (byName.length === 1) {
 			// A single unclaimed call of this tool type is the only call this
 			// handler can possibly belong to, so claim it even when the recorded
@@ -372,29 +567,36 @@ export class QueryContext {
 			argsMismatch = hasRecordedArgs(byName[0].arguments);
 		}
 
+		// Last resort: nothing live matched and no exact result-backed pairing —
+		// a sole result-backed same-name id is still this handler's only possible
+		// owner, same reasoning as the live sole-candidate fallback above.
+		if (!chosen && resultBacked.length === 1) return claimBacked(resultBacked[0], false);
+
 		if (!chosen) return { match: "none", ambiguous: false, available: unclaimed.length };
 		this.claimedToolCallIds.add(chosen.id);
 		return { toolCallId: chosen.id, match, ambiguous, available: unclaimed.length, ...(argsMismatch ? { argsMismatch } : {}) };
 	}
 
 	/**
-	 * Drain results still queued in `pendingResults` and report what was dropped.
+	 * Move results still queued in `pendingResults` into the parked store and
+	 * report what moved.
 	 *
 	 * Called at a child MESSAGE boundary (message_start / the no-stream-events
-	 * assistant fallback): by then the child has necessarily received every tool
-	 * result for the previous message — a handler that matched resolved its result
-	 * directly or from this queue, and one that never matched already returned an
-	 * error. Whatever is still queued therefore belongs to a call whose handler
-	 * gave up, and no consumer will ever come for it. Left in place, each entry
-	 * poisons every later mismatch report for the whole query (queued>0 with 0/0
-	 * counters and no tool names) and forces a session rebuild per turn.
+	 * assistant fallback). Left in pendingResults, each entry poisons every later
+	 * mismatch report for the whole query (queued>0 with 0/0 counters and no tool
+	 * names) and forces a session rebuild per turn. But the boundary does NOT
+	 * prove the handler gave up — the SDK staggers handler invocations, and the
+	 * 2026-08-17 deadlock session (vstack#1469) had three of five parallel
+	 * handlers fire after this reap destroyed their results. So the reap parks
+	 * instead of dropping: reports stay clean, and a late handler still gets its
+	 * real result through takeQueuedOrParkedResult.
 	 */
 	takeStaleQueuedResults(): Array<{ id: string; toolName: string }> {
 		if (this.pendingResults.size === 0) return [];
-		const stale = [...this.pendingResults.keys()].map((id) => ({
-			id,
-			toolName: this.queryToolNames.get(id) ?? "unknown",
-		}));
+		const stale = [...this.pendingResults.entries()].map(([id, result]) => {
+			this.reapedResults.set(id, result);
+			return { id, toolName: this.queryToolNames.get(id) ?? "unknown" };
+		});
 		this.pendingResults.clear();
 		return stale;
 	}
@@ -463,24 +665,60 @@ export class QueryContext {
 	}
 }
 
-let _ctx = new QueryContext();
-const contextStack: QueryContext[] = [];
+interface QueryLaneState {
+	current: QueryContext;
+	stack: QueryContext[];
+}
 
-export function ctx(): QueryContext { return _ctx; }
+interface QueryLaneStoreV1 {
+	defaultLane: QueryLaneState;
+	sessionLanes: Map<string, QueryLaneState>;
+}
 
-export function stackDepth(): number { return contextStack.length; }
+const QUERY_LANES_SYMBOL = Symbol.for("vstack.pi.claude-bridge.query-lanes.v1");
+
+function queryLaneStore(): QueryLaneStoreV1 {
+	const host = globalThis as Record<symbol, unknown>;
+	let store = host[QUERY_LANES_SYMBOL] as QueryLaneStoreV1 | undefined;
+	if (!store) {
+		store = {
+			defaultLane: { current: new QueryContext(), stack: [] },
+			sessionLanes: new Map(),
+		};
+		host[QUERY_LANES_SYMBOL] = store;
+	}
+	return store;
+}
+
+function lane(): QueryLaneState {
+	const store = queryLaneStore();
+	const sessionId = currentRequestLaneId();
+	if (sessionId === undefined) return store.defaultLane;
+	let state = store.sessionLanes.get(sessionId);
+	if (!state) {
+		state = { current: new QueryContext(), stack: [] };
+		store.sessionLanes.set(sessionId, state);
+	}
+	return state;
+}
+
+export function ctx(): QueryContext { return lane().current; }
+
+export function stackDepth(): number { return lane().stack.length; }
 
 export function pushContext(): void {
-	if (!_ctx.activeQuery) throw new Error("pushContext() called with no active query");
-	contextStack.push(_ctx);
-	_ctx = new QueryContext();
+	const state = lane();
+	if (!state.current.activeQuery) throw new Error("pushContext() called with no active query");
+	state.stack.push(state.current);
+	state.current = new QueryContext();
 }
 
 export function popContext(): void {
-	if (contextStack.length === 0) throw new Error("popContext() called with empty stack");
-	const parent = contextStack[contextStack.length - 1];
-	parent.deferredUserMessages.push(..._ctx.deferredUserMessages);
-	_ctx = contextStack.pop()!;
+	const state = lane();
+	if (state.stack.length === 0) throw new Error("popContext() called with empty stack");
+	const parent = state.stack[state.stack.length - 1];
+	parent.deferredUserMessages.push(...state.current.deferredUserMessages);
+	state.current = state.stack.pop()!;
 }
 
 /** Pop the context that belongs to ONE specific query, wherever it sits.
@@ -495,21 +733,39 @@ export function popContext(): void {
  *  the correct lineage. Returns false when `target` is nowhere in the state —
  *  already popped — so callers can treat that as "someone else tore this down". */
 export function popContextFor(target: QueryContext): boolean {
-	if (_ctx === target) {
+	const state = lane();
+	if (state.current === target) {
 		popContext();
 		return true;
 	}
-	const idx = contextStack.indexOf(target);
+	const idx = state.stack.indexOf(target);
 	if (idx < 0) return false;
-	const parent = idx > 0 ? contextStack[idx - 1] : undefined;
+	const parent = idx > 0 ? state.stack[idx - 1] : undefined;
 	parent?.deferredUserMessages.push(...target.deferredUserMessages);
-	contextStack.splice(idx, 1);
+	state.stack.splice(idx, 1);
 	return true;
 }
 
-// Test-only: drop all state so test files can start from a clean module.
-// Not called from production.
+// Test-only: drop every lane so test files can start clean.
 export function resetStack(): void {
-	_ctx = new QueryContext();
-	contextStack.length = 0;
+	clearQueryLanes();
+}
+
+export function deleteQueryLane(sessionId: string | undefined): void {
+	const store = queryLaneStore();
+	if (sessionId === undefined) {
+		store.defaultLane.current = new QueryContext();
+		store.defaultLane.stack.length = 0;
+	} else store.sessionLanes.delete(sessionId);
+}
+
+export function clearQueryLanes(): void {
+	const store = queryLaneStore();
+	store.sessionLanes.clear();
+	store.defaultLane.current = new QueryContext();
+	store.defaultLane.stack.length = 0;
+}
+
+export function __testQueryLaneCount(): number {
+	return queryLaneStore().sessionLanes.size;
 }

package/src/rate-limit.ts

@@ -16,12 +16,6 @@ function coerceMessageText(value: unknown): string {
 	catch { return String(value); }
 }
 
-/** Narrow test: this message is about EXTRA usage specifically — the paid
- *  beyond-plan pool the /extra-usage helper flow can enable. */
-export function isExtraUsageRequiredMessage(value: unknown): boolean {
-	return /extra[-\s]?usage|overage|extra usage billing|extra usage credits|1M context/i.test(coerceMessageText(value));
-}
-
 /** Broad test: any "a usage limit was genuinely reached" message, matched
  *  against the CLI's own copy (SDK `USAGE_LIMIT_ERROR_PREFIXES`, e.g. "You've
  *  hit your weekly limit…"). Substring rather than prefix match because the
@@ -47,13 +41,18 @@ export function uniqueNonEmptyLines(values: unknown[]): string[] {
  *  `SDKRateLimitInfo.resetsAt` is a bare number in epoch SECONDS (measured:
  *  treating it as ms rendered "resets Jan 21, 1970" for a Jul 2026 reset).
  *  The unit is undocumented, so detect by magnitude — epoch seconds stay below
- *  1e12 until the year 33658, epoch ms passed 1e12 in 2001 — and accept ISO
- *  strings for older payloads. */
+ *  1e12 until the year 33658, epoch ms passed 1e12 in 2001. A numeric STRING
+ *  gets the same magnitude treatment (rate_limit_event payloads have carried
+ *  both), and anything else falls back to Date.parse for ISO strings. */
 export function resetTimestampMs(value: unknown): number | undefined {
-	let parsed = typeof value === "number" ? value : typeof value === "string" ? Date.parse(value) : Number.NaN;
-	if (!Number.isFinite(parsed)) return undefined;
-	if (typeof value === "number" && Math.abs(parsed) < 1e12) parsed *= 1000;
-	return parsed;
+	if (typeof value === "number" && Number.isFinite(value)) {
+		return Math.abs(value) < 1e12 ? value * 1000 : value;
+	}
+	if (typeof value !== "string" || !value.trim()) return undefined;
+	const numeric = Number(value);
+	if (Number.isFinite(numeric)) return Math.abs(numeric) < 1e12 ? numeric * 1000 : numeric;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
 }
 
 export function formatResetTimestamp(value: unknown): string {
@@ -76,8 +75,12 @@ export function normalizeRateLimitUtilization(value: unknown): number | undefine
 	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return undefined;
 	if (value === 0) return 0;
 	// Claude SDK payloads have appeared as both fractions and percentages.
-	// Exact 1 is unit-ambiguous (1% vs 100%), so do not use it for allowed-warning copy.
-	if (value > 0 && value < 1) return value * 100;
+	// Exact 1 is unit-ambiguous (1% vs 100%); read it as the fractional form
+	// (100%) because that is the fail-closed direction — under the fraction
+	// convention 1 is the fully-consumed case the warning exists to surface,
+	// while under the percent convention 1% sits below the threshold anyway,
+	// so nothing is lost by warning (VST-16).
+	if (value > 0 && value <= 1) return value * 100;
 	if (value > 1 && value <= 100) return value;
 	return undefined;
 }

package/src/request-lane.ts

@@ -0,0 +1,36 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+/**
+ * Selects the Pi agent session whose provider request is currently executing.
+ *
+ * Pi forwards a stable `SimpleStreamOptions.sessionId` on every model request,
+ * including tool-result continuations.  The bridge may serve the parent agent
+ * and several in-process subagents concurrently, so process-global query state
+ * cannot identify the request that a callback belongs to.  AsyncLocalStorage
+ * keeps that identity attached to every promise, SDK iterator, and timer born
+ * during the provider call without threading the id through every helper.
+ */
+const REQUEST_LANE_SYMBOL = Symbol.for("vstack.pi.claude-bridge.request-lane.v1");
+
+function requestLaneStorage(): AsyncLocalStorage<string> {
+	const host = globalThis as Record<symbol, unknown>;
+	let storage = host[REQUEST_LANE_SYMBOL] as AsyncLocalStorage<string> | undefined;
+	if (!storage) {
+		storage = new AsyncLocalStorage<string>();
+		host[REQUEST_LANE_SYMBOL] = storage;
+	}
+	return storage;
+}
+
+/** Run `callback` in the lane for `sessionId`. `undefined` selects the default
+ *  (direct-host) lane even when a named lane is active — a listener that fires
+ *  inside another request's context must not inherit that request's lane. */
+export function runInRequestLane<T>(sessionId: string | undefined, callback: () => T): T {
+	const storage = requestLaneStorage();
+	if (sessionId !== undefined) return storage.run(sessionId, callback);
+	return storage.getStore() === undefined ? callback() : storage.exit(callback);
+}
+
+export function currentRequestLaneId(): string | undefined {
+	return requestLaneStorage().getStore();
+}

package/src/sdk-query.ts

@@ -0,0 +1,16 @@
+// Shared mutable SDK query factory + its test seam. In its own module so both
+// the provider entry (index.ts) and the account host spawn children through
+// the same seam — tests swap the factory once and every spawn path honors it.
+
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+export type SdkQueryFactory = typeof query;
+
+// ESM live binding: importers read the CURRENT factory at call time.
+export let sdkQueryFactory: SdkQueryFactory = query;
+
+/** Test seam for exercising the real bridge retry/session orchestration without
+ *  spending Claude usage. Production never calls this. */
+export function __testSetSdkQueryFactory(factory?: SdkQueryFactory): void {
+	sdkQueryFactory = factory ?? query;
+}