@vanillagreen/pi-claude-bridge 4.0.0 → 4.0.2

package/src/index.ts

@@ -7,8 +7,8 @@ import { PROVIDER_ID, messageContentToText } from "./convert.js";
 import { buildModels, modelDisplayName } from "./models.js";
 import { MCP_SERVER_NAME, MCP_TOOL_PREFIX } from "./skills.js";
 import { extractAllToolResults as _extractAllToolResults, type McpResult } from "./extract-tool-results.js";
-import { QueryContext, ctx, deleteQueryLane, drainPendingToolCalls, drainStrandedToolCalls, popContext, stackDepth, pushContext, summarizeDroppedUserMessages, takeQueuedOrParkedResult, toolCallDrainCause, type DeferredUserMessage } from "./query-state.js";
-import { teardownQuery } from "./query-teardown.js";
+import { QueryContext, ctx, deleteQueryLane, drainPendingToolCalls, drainStrandedToolCalls, popContext, stackDepth, pushContext, summarizeDroppedUserMessages, takeQueuedOrParkedResult, toolCallDrainCause, type DeferredUserMessage, type QueryRestartRequest } from "./query-state.js";
+import { abortSdkQuery, closeSdkQuery, teardownQuery } from "./query-teardown.js";
 import { loadConfig, recordProjectTrust, registerExternalConfigResolver } from "./config.js";
 import { hasClaudeCredentials } from "./auth-presence.js";
 import { NATIVE_PROVIDER_UNSUPPORTED_MESSAGE, buildNativeProvider, supportsNativeProvider } from "./native-provider.js";
@@ -59,6 +59,7 @@ import {
 	type ClaudeAccountRoute,
 } from "./account-router.js";
 import { BRIDGE_ACCOUNT_HOST } from "./account-host.js";
+import { BRIDGE_BILLING_IDENTITY, CLAUDE_BILLING_IDENTITY_SYMBOL, beginBillingIdentityAttempt, deleteBillingIdentityLane } from "./billing-identity.js";
 import { registerBridgeCommands } from "./bridge-commands.js";
 import { consumeQuery, emitRateLimitEvent, type ClaudeAttemptFailure } from "./consume-query.js";
 import { buildClaudeQueryOptions } from "./query-options.js";
@@ -79,7 +80,7 @@ export { cancelScheduledSessionPersistence, conversationFingerprint, conversatio
 export { NATIVE_PROVIDER_UNSUPPORTED_MESSAGE, buildNativeProvider, claudeAuthSourceLabel, supportsNativeProvider } from "./native-provider.js";
 export { DEFAULT_STREAM_IDLE_TIMEOUT_MS, STREAM_IDLE_BACKOFF_HINT_MS, STREAM_IDLE_TIMEOUT_ENV, buildStreamIdleTimeoutErrorMessage, createStreamIdleWatchdog, streamIdleTimeoutMsFromEnv, type StreamIdleTimeoutInfo, type StreamIdleWatchdog, type StreamIdleWatchdogState } from "./stream-idle-watchdog.js";
 export { ALLOWED_RATE_LIMIT_WARNING_UTILIZATION_THRESHOLD, formatAllowedRateLimitWarning, formatResetTimestamp, isUsageLimitMessage, normalizeRateLimitUtilization, resetTimestampMs, uniqueNonEmptyLines } from "./rate-limit.js";
-export { mapToolName } from "./tool-mapping.js";
+export { isPiDispatchable, mapToolName } from "./tool-mapping.js";
 export { cancelScheduledToolUseEnd, endToolUseTurn, finalizeToolUseTurnFromMcpInvocation, noteChildExecutedToolResults, processAssistantMessage, processStreamEvent, reapStaleQueuedResults, scheduleToolUseTurnEnd } from "./assistant-stream.js";
 export {
 	accountSessionScope,
@@ -239,18 +240,17 @@ export interface DeferredUserReplayPlan {
 	// with no image blocks).
 	prompt: string | null;
 	// Present when the run carries image blocks — the replay must send these
-	// (via wrapPromptStream) or the images are silently lost (kendex#993).
+	// (via wrapPromptStream) or the images are silently lost.
 	blocks: ContentBlockParam[] | null;
 }
 
 /** Plan replay of user messages pi injected mid-query (steer drain, followUp).
  *  Captures the ENTIRE trailing consecutive user run, not just the last
- *  message — dropping the earlier ones was silent input loss (kendex#967) —
- *  but never walks below `capturedThrough`, the position an earlier callback
+ *  message, but never walks below `capturedThrough`, the position a prior callback
  *  of the SAME query already captured (or deliberately held at, for an
  *  all-empty run). Without that lower bound a second mid-query steer re-planned
  *  the whole run from scratch and the first steer was queued — and delivered to
- *  Claude — twice (kendex#1009). */
+ *  Claude — twice. */
 export function planDeferredUserReplay(messages: Context["messages"], capturedThrough = 0): DeferredUserReplayPlan {
 	let runStart = messages.length;
 	while (runStart > capturedThrough && messages[runStart - 1]?.role === "user") runStart--;
@@ -299,7 +299,7 @@ export function resolveMcpTools(context: Context, excludeToolName?: string): {
 		// namespace belongs to the child's own MCP servers, so a Pi tool sitting
 		// on it would be advertised a SECOND time under our prefix — two names
 		// for one capability, and the model picking the wrong one gets a real
-		// `Tool ... not found` from the dispatcher (memsira#320). It would also
+		// `Tool... not found` from the dispatcher. It would also
 		// be uncallable in any case: a `tool_use` under that namespace is treated
 		// as child-executed and never handed to Pi (isChildExecutedTool), so
 		// filtering here is what makes the two halves agree end to end.
@@ -418,8 +418,8 @@ function buildMcpServers(tools: Tool[], queryCtx: QueryContext): Record<string,
 // 2. consumeQuery() iterates the SDK generator, pushing events to currentPiStream
 // 3. On tool_use: ends the current pi stream, nulls it out. The MCP handler
 //    blocks the generator naturally — no events arrive until resolved.
-// 4. Pi executes the tool, calls streamSimple again. We swap in the new stream,
-//    resolve the MCP handler, and the generator unblocks — events flow to new stream.
+// 4. Pi executes the tool and calls streamSimple again. We swap in the replacement
+//    stream, resolve the MCP handler, and the generator unblocks into that stream.
 //
 // Note: resetTurnState clears turnSawStreamEvent while the generator may still
 // have queued messages from the previous turn. This is safe because step 3 nulls
@@ -448,6 +448,10 @@ function releaseProviderTokens(event: string): void {
 	if (g[CLAUDE_BRIDGE_ACCOUNT_HOST_SYMBOL] === BRIDGE_ACCOUNT_HOST) {
 		g[CLAUDE_BRIDGE_ACCOUNT_HOST_SYMBOL] = undefined;
 	}
+	// Billing identity is request-lane state. The shutdown handler removes its
+	// one lane after this call. The process publisher remains available to
+	// sibling sessions and reads the shared lane registry across reloads until a
+	// new primary replaces it.
 	if (g[ACTIVE_STREAM_SIMPLE_KEY] === streamClaudeAgentSdk) {
 		debug(`${event}: clearing ACTIVE_STREAM_SIMPLE_KEY`);
 		g[ACTIVE_STREAM_SIMPLE_KEY] = undefined;
@@ -502,7 +506,7 @@ function applyProviderRegistration(trigger: string): void {
 	debug(`${trigger}: native registration upsert, credentialed=${credentialed} (module=${moduleInstanceId})`);
 	// Start the connector inventory now, not on the first turn: the query path
 	// can only read a synchronous snapshot, so priming here is what gets the
-	// declarations in place before turn 1 (kendex#832). Fire and forget —
+	// declarations in place before turn 1. Fire and forget —
 	// registration must not wait on the network. Primes the DEFAULT credential
 	// scope only; managed profiles are primed per request in their own scope.
 	if (hasClaudeCredentials() && connectorsEnabledFor(loadConfig(process.cwd()))) primeConnectorServers();
@@ -529,7 +533,60 @@ function applyProviderRegistration(trigger: string): void {
 	}
 }
 
-/** Provider entry point. Pi calls this for each new prompt and each tool result.
+/** Prompt for the query that replaces one whose Pi history was replaced. Pi's
+ *  whole context becomes imported history — the summary, the retained messages
+ *  and the results of the tool calls that already ran — so the replacement query
+ *  is only told to carry on from it. */
+export const HISTORY_REPLACED_PROMPT = "The conversation above was rewritten by Pi (compaction or history navigation). It is the complete current history, including the results of every tool call that has already run. Continue the turn from there, and do not repeat a tool call whose result is already above.";
+
+/** Pi's new context plus the continuation prompt, so the rebuild imports every
+ *  message Pi holds — trailing tool results included, which keeps each one
+ *  paired with its tool call and present exactly once. */
+function restartContext(request: QueryRestartRequest): Context {
+	return {
+		...request.context,
+		messages: [...request.context.messages, { role: "user", content: HISTORY_REPLACED_PROMPT, timestamp: Date.now() }],
+	};
+}
+
+/** Pi replaced the conversation's history: pi /compact and session-tree
+ *  navigation (rewind / fork-at-point / branch switch) both mutate pi's messages
+ *  array out from under the bridge. syncSharedSession's REUSE check would
+ *  otherwise see slice(cursor) === [] (or skip entries) and keep --resume'ing a
+ *  CC session that does not match pi's history; /compact in particular triggers
+ *  CC's autocompact-thrashing guard. Force the next call down the REBUILD path,
+ *  and mark an ACTIVE query stale so the next provider callback restarts it
+ *  rather than continuing it on history Pi has thrown away.
+ *
+ *  Exported for the compaction-restart unit test; pi.on wires the two events. */
+export function onPiHistoryReplaced(event: string): void {
+	const activeSession = getSharedSession();
+	const queryCtx = ctx();
+	// Whether THIS call requests a restart. A query with no claim on the shared
+	// record — a reentrant subagent, a foreign one-shot — is running its own
+	// conversation, so pi's replacement is not its history and it is never
+	// restarted on it. Read here rather than off piHistoryReplaced below, which
+	// outlives a query that ended without its restart.
+	const running = queryCtx.activeQuery !== null;
+	const restarts = running && !queryCtx.detachedFromSharedSession;
+	if (running) {
+		if (restarts) queryCtx.piHistoryReplaced = true;
+		// A restart re-imports the interrupted calls' results from pi's own
+		// history, so their interruption is expected teardown rather than the
+		// integrity fault an unhandled one reports.
+		reportToolResultMismatch(queryCtx, event, activeSession?.cwd ?? process.cwd(), { expectedInterruption: restarts });
+	}
+	if (activeSession) {
+		debug(`${event}: marking needsRebuild on session ${activeSession.sessionId.slice(0, 8)}`);
+		// A restart kills the child, which goes on flushing its jsonl: rebuilding
+		// in place would race that writer, so the replacement takes a new session
+		// id and leaves the old transcript alone. A compaction that kills nothing
+		// has no writer to race and rebuilds in place.
+		markSessionForRebuild({ forceRotate: restarts });
+	}
+}
+
+/** Provider entry point. Pi calls this for each prompt and each tool result.
  *  Two cases: tool result delivery (active query) or fresh query. Exported for
  *  the rotation-stream unit tests, which drive it with a fake SDK factory. */
 export function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
@@ -550,6 +607,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 		if (!ephemeralLane) return;
 		deleteSharedSessionLane(laneId);
 		deleteQueryLane(laneId);
+		deleteBillingIdentityLane(laneId);
 	};
 
 	// DEBUG: trace followUp message triggering
@@ -563,6 +621,44 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 	// handlers. Results that arrive before their handler get queued in pendingResults.
 	if (ctx().activeQuery) {
 		const queryCtx = ctx();
+		if (queryCtx.piHistoryReplaced) {
+			// Pi compacted or navigated this conversation while the query ran, so the
+			// query's Claude session holds history Pi has replaced. Restart from THIS
+			// context instead of delivering into it: Pi's messages already carry every
+			// tool call Pi executed, so the rebuilt session imports each result once
+			// and no such tool runs again. The dying query's own chain performs the
+			// restart, once teardown has released the query state.
+			//
+			// Except when the CHILD ran a call pi never sees — a claude.ai connector,
+			// or a foreign MCP tool it loaded from filesystem settings. Those calls are
+			// never mirrored into pi's messages and their results are observed at most,
+			// never recorded, so no rebuild from pi's context can carry them. Handing
+			// the replacement a history missing an account-visible call, under a
+			// prompt saying every result is present, invites the model to run it
+			// again. Keep this query on its stale history instead, and keep the
+			// marker set: pi replaced the history whether or not the bridge acts on
+			// it, so the record this query writes as it ends must still say so or the
+			// NEXT turn resumes the history the compaction threw away. Report the
+			// refusal once, not once per remaining tool result.
+			if (queryCtx.childSideCalls.size > 0) {
+				if (!queryCtx.reportedHistoryRestartDecline) {
+					queryCtx.reportedHistoryRestartDecline = true;
+					const names = [...new Set([...queryCtx.childSideCalls.values()].map((call) => call.name))];
+					debug(`provider: pi replaced this query's history, but ${queryCtx.childSideCalls.size} child-executed call(s) are absent from pi's context; not restarting (${names.join(", ")})`);
+					appendIntegrityEntry("history_restart_declined", { reason: "child-executed calls pi's history cannot carry", count: queryCtx.childSideCalls.size, names });
+				}
+			} else {
+				// Consumed: the pending request carries the replacement from here, and
+				// persistSession reads it there.
+				queryCtx.piHistoryReplaced = false;
+				queryCtx.restartRequest = { model, context, options, stream };
+				// Nothing the dying query still emits belongs to the new history.
+				queryCtx.currentPiStream = null;
+				debug(`provider: pi replaced this query's history; restarting from ${context.messages.length} message(s)`);
+				abortSdkQuery(queryCtx.activeQuery);
+				return stream;
+			}
+		}
 		queryCtx.currentPiStream = stream;
 		queryCtx.resetTurnState(model);
 		// A fresh callback separates handlers registered for settled turns from
@@ -619,7 +715,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 		if (queryCtx.pendingToolCalls.size > 0) {
 			// A waiting handler whose call never reached Pi can never be answered —
 			// fail it now with a retryable error instead of letting the SDK await it
-			// forever (the 2026-08-17 five-and-a-half-hour deadlock, kendex#1469).
+			// indefinitely.
 			// Forwarded-but-unanswered handlers stay: steer-split batches legitimately
 			// deliver their results in a later callback.
 			const stranded = drainStrandedToolCalls(queryCtx);
@@ -646,7 +742,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 		// so we save them for replay as continuation queries after consumeQuery ends.
 		// The cursor may only advance over messages actually captured for replay:
 		// claiming Claude owns a user message that was never deferred is permanent
-		// silent input loss (kendex#967 — only the LAST of several trailing user
+		// silent input loss ( — only the LAST of several trailing user
 		// messages was captured while the cursor skipped them all).
 		let capturedThrough = context.messages.length;
 		if (lastMsgRole === "user") {
@@ -654,13 +750,13 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 			// Math.max-advances with every callback's capturedThrough below), so a
 			// second steer callback only queues messages BEYOND what the first one
 			// already owns — re-planning the whole trailing run queued the earlier
-			// steer twice (kendex#1009). latestCursor, not the shared record's
+			// steer twice. latestCursor, not the shared record's
 			// cursor, deliberately: it lives on this QueryContext, so it is correct
 			// for reentrant and detached foreign queries too, whose contexts the
-			// shared cursor does not index (kendex#1001).
+			// shared cursor does not index.
 			const replay = planDeferredUserReplay(context.messages, queryCtx.latestCursor);
 			// Image-only runs have no usable text but must still replay — capture
-			// whenever EITHER form has content (kendex#993).
+			// whenever EITHER form has content.
 			if (replay.prompt || replay.blocks) {
 				ctx().deferredUserMessages.push({ text: replay.prompt ?? "", blocks: replay.blocks ?? undefined });
 				debug(`provider: deferred ${replay.userMessageCount} user message(s) for replay after query${replay.blocks ? ` (${replay.blocks.length} blocks incl. images)` : ""}: ${(replay.prompt ?? "[image-only]").slice(0, 60)}`);
@@ -678,12 +774,12 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 		// Cursor may only ADVANCE, and only for a query that holds the record's
 		// claim. A reentrant subagent call routed through this instance arrives
 		// here with a SHORT foreign context (its own [user…] conversation, not
-		// the one the cursor indexes) — writing its length used to shrink the
+		// the one the cursor indexes). Writing its length would shrink the
 		// parent cursor and make the next REUSE replay already-owned history.
 		// The stackDepth guard covers a pushed subagent context; the detached
 		// flag covers a foreign one-shot on the top-level ctx, whose GROWN
 		// mid-query context could otherwise out-length the parent's cursor and
-		// advance it past history Claude never saw (kendex#1001); Math.max
+		// advance it past history Claude never saw; Math.max
 		// remains the backstop for a legacy-record foreign context the
 		// fingerprint guard could not classify.
 		const activeSession = getSharedSession();
@@ -702,7 +798,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 		debug(`provider: orphaned tool result after abort, emitting end_turn`);
 		// The detached flag deliberately survives query end: an orphaned result
 		// from a foreign one-shot indexes ITS conversation, and writing that
-		// length here would move (even shrink) the parent's cursor (kendex#1001).
+		// length here would move (even shrink) the parent's cursor.
 		const activeSession = getSharedSession();
 		if (activeSession && stackDepth() === 0 && !ctx().detachedFromSharedSession) setSharedSession({ ...activeSession, cursor: context.messages.length });
 		const c = ctx();  // capture current context for the microtask
@@ -716,6 +812,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 	}
 
 	// --- Fresh query ---
+	const recordBillingIdentity = beginBillingIdentityAttempt();
 
 	// Fail-fast credential re-check (only for a fresh query — NEVER for
 	// tool-result delivery of an in-flight query, handled above, where creds were
@@ -757,6 +854,9 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 	ctx().pendingToolCalls.clear();
 	ctx().pendingResults.clear();
 	ctx().reapedResults.clear();
+	// Teardown flushed the previous query's calls; carrying them into this one
+	// would make it look like it ran child-side calls it never ran.
+	ctx().childSideCalls.clear();
 	ctx().forwardedToolCallIds.clear();
 	ctx().deadToolCallIds.clear();
 	ctx().callbackGeneration = 0;
@@ -765,6 +865,10 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 	ctx().resetToolTracking();
 	ctx().latestCursor = 0;
 	ctx().committedOutput = false;
+	// This query is built from the context Pi holds now; only a replacement that
+	// arrives while it runs makes it stale.
+	ctx().piHistoryReplaced = false;
+	ctx().reportedHistoryRestartDecline = false;
 	// A reentrant query never claims the shared record; a foreign-conversation
 	// one-shot joins it below once syncSharedSession has ruled.
 	ctx().detachedFromSharedSession = isReentrant;
@@ -883,7 +987,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 	const { sessionId: resumeSessionId, promptStart } = syncResult;
 	// A FOREIGN-conversation query (conversation-fingerprint mismatch against
 	// the shared record — a subagent-shaped request arriving while the parent
-	// is IDLE, kendex#1001) also runs as a clean one-shot and gets the same
+	// is IDLE,) also runs as a clean one-shot and gets the same
 	// hands-off treatment as a reentrant one below: never persist over the
 	// module-level record, never mark it for rebuild. The flag also rides the
 	// QueryContext so the mismatch/abort/teardown paths that mutate the record
@@ -953,6 +1057,9 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 
 	// 3. Start SDK query and claim it for this context
 	let wasAborted = false;
+	// The stream the post-teardown re-entry feeds: an account retry continues this
+	// call's own stream, a history restart the callback stream that requested it.
+	let reentryStream = stream;
 	let streamIdleTimedOut = false;
 	let retryRequested = false;
 	let retryFailure: ClaudeAttemptFailure | undefined;
@@ -961,22 +1068,36 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 
 	// 4. Capture context for abort handling (must be AFTER pushContext)
 	const abortCtx = ctx();
-	// Failure metadata consumeQuery observed, surviving an iterator THROW (the
-	// .catch below reuses it instead of re-classifying — see C5 note there).
+	// Failure metadata from consumeQuery survives an iterator throw. The catch
+	// below reuses it instead of re-classifying it; see the C5 note.
 	const attemptFailure: { failure?: ClaudeAttemptFailure } = {};
 	// A reentrant (subagent) query must never write the module-level shared
 	// session: its completion/failure handlers would overwrite the PARENT's
 	// record with the child's session id and cursor. A foreign-conversation
-	// one-shot (kendex#1001) has exactly the same non-claim on the record.
+	// one-shot has exactly the same non-claim on the record.
 	const persistSession = (next: SessionState | null): void => {
 		if (isReentrant || foreignContext) return;
-		setSharedSession(next && conversationFp ? { conversationFingerprint: conversationFp, ...next } : next);
+		// A history replacement pi made while this query ran describes PI's
+		// messages, not this query, so every record the query writes — this
+		// turn's, a terminal failure's, a continuation's — has to keep it.
+		// Dropping it lets the next sync resume history pi has thrown away, or
+		// read the post-compaction context as a foreign conversation and run it
+		// as a historyless one-shot. forceRotate rides along only while a
+		// restart is pending, which is the case where a child was killed and may
+		// still be flushing to the session jsonl.
+		// Observed and not yet acted on, or already consumed into a pending
+		// restart: both mean pi replaced the history after this query started.
+		const restartPending = abortCtx.restartRequest !== null;
+		const replaced = next && (abortCtx.piHistoryReplaced || restartPending)
+			? { ...next, needsRebuild: true, ...(restartPending ? { forceRotate: true } : {}) }
+			: next;
+		setSharedSession(replaced && conversationFp ? { conversationFingerprint: conversationFp, ...replaced } : replaced);
 	};
 	const markRebuildForThisQuery = (opts: { forceRotate?: boolean } = {}): void => {
 		if (isReentrant || foreignContext) return;
 		markSessionForRebuild(opts);
 	};
-	// #967 invariant: a deferred (mid-query) user message may be dropped only
+	//  invariant: a deferred (mid-query) user message may be dropped only
 	// LOUDLY — the cursor already advanced over it on the promise of replay.
 	// Callers that keep a session record after a non-empty drop must persist it
 	// with needsRebuild so the next turn re-imports the steers from Pi history.
@@ -1000,13 +1121,6 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 		accountFailureRecorded = true;
 	};
 
-	const requestAbort = () => {
-		// interrupt() asks the CLI to stop gracefully; close() kills it immediately.
-		// Both are needed — interrupt alone lets the current API call finish.
-		void sdkQuery.interrupt().catch(() => {});
-		try { sdkQuery.close(); } catch {}
-	};
-
 	// Decide whether a classified failure may be replayed on the next profile.
 	// Records the failure with the router either way (a post-output failure is
 	// not replayable but the next prompt's routing should still avoid the
@@ -1062,7 +1176,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 				// specifics (needsRebuild/forceRotate, killing the child) stay here;
 				// eligibility and retry bookkeeping are requestRotation's.
 				if (requestRotation(idleFailure)) {
-					requestAbort();
+					abortSdkQuery(sdkQuery);
 					return;
 				}
 				abortCtx.handledTerminalError = true;
@@ -1090,7 +1204,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 				abortCtx.currentPiStream?.push({ type: "error", reason: "error", error: abortCtx.turnOutput! });
 				abortCtx.currentPiStream?.end();
 				abortCtx.currentPiStream = null;
-				requestAbort();
+				abortSdkQuery(sdkQuery);
 			},
 			timeoutMs: streamIdleTimeoutMs,
 		})
@@ -1113,7 +1227,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 		const drained = drainPendingToolCalls(abortCtx, "abort");
 		if (drained > 0) debug(`provider: abort drained ${drained} waiting MCP handler(s) as errors`);
 		abortCtx.pendingResults.clear();
-		requestAbort();
+		abortSdkQuery(sdkQuery);
 	});
 	if (options?.signal) {
 		if (options.signal.aborted) onAbort();
@@ -1154,9 +1268,16 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 	// query CAN end in that window (abort, child process death throwing out of
 	// the generator). Live-ctx handlers there mutated the subagent's turn state
 	// and stream and skipped the parent's own teardown entirely.
-	consumeQuery(sdkQuery, abortCtx, customToolNameToPi, queryModel, bridgeConfig, () => wasAborted, account, router, attemptFailure)
+	consumeQuery(sdkQuery, abortCtx, customToolNameToPi, queryModel, bridgeConfig, () => wasAborted, recordBillingIdentity, account, router, attemptFailure)
 		.then(async ({ capturedSessionId, failure }) => {
 			debug(`provider: consumeQuery completed, stopReason=${abortCtx.turnOutput?.stopReason}, failure=${failure?.kind ?? "none"}, aborted=${wasAborted}`);
+			if (abortCtx.restartRequest) {
+				// The replacement query owns this turn's outcome. This one must not
+				// surface its interruption, end a stream, or write the record: its
+				// session id and cursor describe history Pi has replaced.
+				debug("provider: query ended for a history restart; leaving the outcome to the replacement query");
+				return;
+			}
 			if (streamIdleTimedOut) {
 				dropDeferredUserMessages("stream-idle-timeout-completion");
 				debug(`provider: stream idle timeout ${retryRequested ? "queued account rotation" : "already surfaced"}; skipping normal completion`);
@@ -1185,7 +1306,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 				// execute. Deferred user input is dropped LOUDLY, and when steers
 				// were dropped the record is marked needsRebuild: the cursor already
 				// advanced over them on the promise of replay, so a plain REUSE next
-				// turn would silently lose them forever (#967).
+					// turn would silently lose them forever.
 				if (!abortCtx.handledTerminalError) surfaceFailure(failure);
 				const droppedSteers = dropDeferredUserMessages("terminal-failure");
 				const activeSession = getSharedSession();
@@ -1206,6 +1327,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 				debug(`provider: query done, session=${sessionId.slice(0, 8)}, cursor=${cursor}, account=${account?.label ?? "legacy"}`);
 				// Fresh record on purpose: a transient mid-turn needsRebuild/forceRotate
 				// must not survive a completed query and force a rebuild next turn.
+				// persistSession re-adds what a pi history replacement requires.
 				persistSession({ sessionId, cursor, cwd, ...accountScope });
 			}
 			// The failure branch above returned, so reaching here means success.
@@ -1235,14 +1357,18 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 
 					const contOptions = { ...queryOptions, resume: resumeId, ...makeCliDebugOptions("continuation") };
 					// Runs carrying image blocks replay as blocks (wrapPromptStream) so
-					// the images survive; text-only runs stay plain strings (kendex#993).
+					// the images survive; text-only runs stay plain strings.
 					const contQuery = sdkQueryFactory({ prompt: steer.blocks ? wrapPromptStream(steer.blocks) : steer.text, options: contOptions });
 					abortCtx.activeQuery = contQuery;
 
 					debug(`provider: continuation query, model=${queryModel.id}, resume=${resumeId.slice(0, 8)}, account=${account?.label ?? "legacy"}, prompt=${steerPreview}`);
 
 					try {
-						const continuation = await consumeQuery(contQuery, abortCtx, customToolNameToPi, queryModel, bridgeConfig, () => wasAborted, account, router);
+						const continuation = await consumeQuery(contQuery, abortCtx, customToolNameToPi, queryModel, bridgeConfig, () => wasAborted, recordBillingIdentity, account, router);
+						// Superseded: the restart killed this attempt, so its end is not
+						// an outcome to record. The replacement carries the remaining
+						// steers, which pi's history holds and the rebuild imports.
+						if (abortCtx.restartRequest) break;
 						if (continuation.failure) {
 							// Continuations never rotate: the original prompt already
 							// committed on this account.
@@ -1250,7 +1376,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 							if (!abortCtx.handledTerminalError) surfaceFailure(continuation.failure);
 							// The shifted steer may never have reached the child, and any
 							// remaining ones certainly did not — the record must rebuild so
-							// they re-import from Pi history (#967).
+							// they re-import from Pi history.
 							if (dropDeferredUserMessages("continuation-failure", steer).length > 0) {
 								markRebuildForThisQuery();
 							}
@@ -1262,6 +1388,10 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 							persistSession({ sessionId: sid, cursor: activeSession?.cursor ?? 0, cwd, ...accountScope });
 						}
 					} catch (contError) {
+						// Killing the child can throw out of its iterator; that is this
+						// restart's own doing, not an attempt failure to charge to the
+						// account or a reason to drop input the rebuild carries.
+						if (abortCtx.restartRequest) break;
 						debug(`provider: continuation query error:`, contError);
 						const continuationFailure: ClaudeAttemptFailure = {
 							kind: classifyClaudeFailure(contError),
@@ -1269,7 +1399,7 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 						};
 						recordAttemptFailure(continuationFailure);
 						if (!abortCtx.handledTerminalError) surfaceFailure(continuationFailure);
-						// Same #967 posture as the failure branch above.
+						// Apply the same rebuild rule as the failure branch above.
 						if (dropDeferredUserMessages("continuation-error", steer).length > 0) {
 							markRebuildForThisQuery();
 						}
@@ -1287,11 +1417,16 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 		})
 		.catch((error) => {
 			debug(`provider: query error, model=${queryModel.id}, aborted=${Boolean(options?.signal?.aborted)}, error=`, error);
+			if (abortCtx.restartRequest) {
+				// Killed for the restart: the replacement query surfaces the outcome.
+				debug("provider: query error while a history restart was pending; suppressed");
+				return;
+			}
 			const suppressDuplicateError = abortCtx.handledTerminalError || (streamIdleTimedOut && !retryRequested);
 			if (wasAborted || options?.signal?.aborted) {
 				markRebuildForThisQuery({ forceRotate: true });
 			}
-			// #967: a record kept past this error with steers behind its cursor
+			// a record kept past this error with steers behind its cursor
 			// must rebuild so they re-import from Pi history. (The non-abort
 			// surface path below replaces the record with null, which rebuilds too.)
 			if (dropDeferredUserMessages("query-error").length > 0) {
@@ -1322,9 +1457,38 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 			if (options?.signal) options.signal.removeEventListener("abort", onAbort);
 			const cause = toolCallDrainCause({ wasAborted, signalAborted: options?.signal?.aborted, streamIdleTimedOut });
 			teardownQuery(abortCtx, sdkQuery, cause, cwd, isReentrant);
-			sdkQuery.close();
+			closeSdkQuery(sdkQuery);
 		})
 		.then(async () => {
+			// --- History restart re-entry ---
+			// Runs AFTER teardown, like the account retry below: the replacement is
+			// a fresh outermost query over Pi's new context, and its events belong to
+			// the callback that observed the replacement, not to this one.
+			const restart = abortCtx.restartRequest;
+			if (restart) {
+				abortCtx.restartRequest = null;
+				reentryStream = restart.stream;
+				if (wasAborted || options?.signal?.aborted || restart.options?.signal?.aborted) {
+					// The request died between the restart and this teardown: rebuilding
+					// the session and spawning a child the fresh-query path kills on the
+					// same signal buys nothing. Terminate the callback's stream instead.
+					debug("provider: abort before the history restart — terminating the stream without restarting");
+					// A fresh output for THIS message: the restart branch returned before
+					// resetTurnState, so turnOutput is still the message pi already holds
+					// for the pre-compaction turn. Stamping "aborted" onto it would
+					// rewrite a delivered turn whose tools really ran.
+					abortCtx.resetTurnState(restart.model);
+					abortCtx.turnOutput!.stopReason = "aborted";
+					abortCtx.turnOutput!.errorMessage = "Operation aborted";
+					reentryStream.push({ type: "error", reason: "aborted", error: abortCtx.turnOutput! });
+					reentryStream.end();
+					return;
+				}
+				debug(`provider: restarting query on replaced history, ${restart.context.messages.length} pi message(s)`);
+				for await (const event of streamClaudeAgentSdk(restart.model, restartContext(restart), restart.options)) reentryStream.push(event);
+				reentryStream.end();
+				return;
+			}
 			// --- Account retry re-entry ---
 			// Runs AFTER teardown so the failed attempt's query state is fully
 			// released. The recursive call re-enters the fresh-query path with the
@@ -1342,8 +1506,8 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 					abortCtx.turnOutput.stopReason = "aborted";
 					abortCtx.turnOutput.errorMessage = "Operation aborted";
 				}
-				stream.push({ type: "error", reason: "aborted", error: abortCtx.turnOutput! });
-				stream.end();
+				reentryStream.push({ type: "error", reason: "aborted", error: abortCtx.turnOutput! });
+				reentryStream.end();
 				return;
 			}
 			debug(`provider: starting account retry after ${retryFailure?.kind ?? "failure"}; excluded=${[...rotationState.excludedProfileIds].join(",")}`);
@@ -1351,22 +1515,35 @@ function streamClaudeAgentSdkInLane(model: Model<any>, context: Context, options
 				...(options ?? {}),
 				[ROTATION_STATE_KEY]: rotationState,
 			} as BridgeStreamOptions);
-			// End exactly once per outcome (VST-53). Ending in a `finally` ran on
+			// End exactly once per outcome. Ending in a `finally` ran on
 			// the throw path too, BEFORE the .catch below could push its error
 			// event — and EventStream.push is a silent no-op after end, so a failed
 			// rotation ended the turn with no error event at all. Success ends
 			// here; every throw ends in the .catch, after the error is pushed.
-			for await (const event of retryStream) stream.push(event);
-			stream.end();
+			for await (const event of retryStream) reentryStream.push(event);
+			reentryStream.end();
 		})
 		.catch((error) => {
-			debug("provider: account retry pipeline failed:", error);
+			debug("provider: re-entry pipeline failed:", error);
+			// A throw BEFORE the re-entry ran — teardown, or closing the stale query
+			// — skips it, leaving reentryStream on this call's own stream, which has
+			// already ended, while pi still waits on the callback stream the restart
+			// was meant to feed. Take that request over so the failure reaches the
+			// stream pi is holding, and clear it so nothing stale outlives this chain.
+			const restart = abortCtx.restartRequest;
+			if (restart) {
+				abortCtx.restartRequest = null;
+				reentryStream = restart.stream;
+				// Same reason as the abort branch above: without a restart this
+				// message would be the delivered pre-compaction turn.
+				abortCtx.resetTurnState(restart.model);
+			}
 			if (abortCtx.turnOutput) {
 				abortCtx.turnOutput.stopReason = "error";
 				abortCtx.turnOutput.errorMessage = error instanceof Error ? error.message : String(error);
 			}
-			stream.push({ type: "error", reason: "error", error: abortCtx.turnOutput! });
-			stream.end();
+			reentryStream.push({ type: "error", reason: "error", error: abortCtx.turnOutput! });
+			reentryStream.end();
 		})
 		// After teardown and any retry pipeline: nothing else reads this lane.
 		.finally(releaseEphemeralLane);
@@ -1398,6 +1575,10 @@ export default function (pi: ExtensionAPI) {
 	if (claimPrimaryInstance()) {
 		const host = globalThis as Record<symbol, any>;
 		host[CLAUDE_BRIDGE_ACCOUNT_HOST_SYMBOL] = BRIDGE_ACCOUNT_HOST;
+		// Published beside it so a reader finds a store that answers "no login
+		// confirmed yet" rather than nothing at all, and so both are owned by
+		// the same instance.
+		host[CLAUDE_BILLING_IDENTITY_SYMBOL] = BRIDGE_BILLING_IDENTITY;
 	}
 
 	// Reset shared (Claude) conversation state on pi session lifecycle events.
@@ -1435,31 +1616,17 @@ export default function (pi: ExtensionAPI) {
 		});
 		deleteSharedSessionLane(sessionId);
 		deleteQueryLane(sessionId);
+		deleteBillingIdentityLane(sessionId);
 	});
 	pi.on("message_end", (event, ctx) => runInRequestLane(ctx.sessionManager.getSessionId(), () => {
 		const message = (event as { message?: AssistantMessage }).message;
 		if (message?.role === "assistant" && message.provider === PROVIDER_ID) schedulePersistSharedSession(ctx);
 	}));
 
-	// pi /compact and session-tree navigation (rewind / fork-at-point /
-	// branch switch) both mutate pi's messages array out from under the
-	// bridge. syncSharedSession's REUSE check would otherwise see
-	// slice(cursor) === [] (or skip entries) and keep --resume'ing a CC
-	// session that no longer matches pi's history. /compact in particular
-	// triggers CC's autocompact-thrashing guard (issue #8). Force the next
-	// call down the REBUILD path so CC sees the current history.
-	const markRebuild = (event: string) => {
-		const activeSession = getSharedSession();
-		if (ctx().activeQuery) {
-			reportToolResultMismatch(ctx(), event, activeSession?.cwd ?? process.cwd());
-		}
-		if (activeSession) {
-			debug(`${event}: marking needsRebuild on session ${activeSession.sessionId.slice(0, 8)}`);
-			markSessionForRebuild();
-		}
-	};
-	pi.on("session_compact", (_event, ctx) => runInRequestLane(ctx.sessionManager.getSessionId(), () => markRebuild("session_compact")));
-	pi.on("session_tree", (_event, ctx) => runInRequestLane(ctx.sessionManager.getSessionId(), () => markRebuild("session_tree")));
+	// Both events replace pi's messages array out from under the bridge; see
+	// onPiHistoryReplaced for what that forces.
+	pi.on("session_compact", (_event, ctx) => runInRequestLane(ctx.sessionManager.getSessionId(), () => onPiHistoryReplaced("session_compact")));
+	pi.on("session_tree", (_event, ctx) => runInRequestLane(ctx.sessionManager.getSessionId(), () => onPiHistoryReplaced("session_tree")));
 
 	// --- Provider ---
 	//