@oh-my-pi/pi-coding-agent 17.1.8 → 17.2.0

package/src/session/credential-pin.ts

@@ -0,0 +1,93 @@
+/**
+ * Session-file persistence of the OAuth account that served a session.
+ *
+ * Provider prompt caches are account-scoped (Anthropic bills a full cache
+ * re-write after an account flip), and the auth store's session-sticky routing
+ * is process-local when a remote auth broker is configured — the broker
+ * store's KV cache is in-memory, so sticky rows die with the CLI process.
+ * Resuming a session in a fresh process then re-ranks accounts by usage
+ * headroom, which is biased *away* from the account that just served the
+ * session (it has the highest recent burn), cold-missing the entire prefix.
+ *
+ * These helpers close the loop through the session file itself: after each
+ * assistant turn the serving account is recorded as a `credential_pin` entry,
+ * and on session adoption the pin is matched against the stored accounts and
+ * seeded back into the auth store with the session's effective last-use
+ * timestamp, so the provider's warm-window semantics still decide whether to
+ * stick or re-rank.
+ */
+
+import type { AuthStorage } from "./auth-storage";
+import type { SessionManager } from "./session-manager";
+
+/** Account fields shared by `OAuthAccountIdentity` and `OAuthAccountSummary`. */
+interface CredentialPinIdentity {
+	accountId?: string;
+	email?: string;
+	projectId?: string;
+	orgId?: string;
+}
+
+/**
+ * Stable identifier for a provider account within its billing scope. The
+ * digest covers the full scope tuple — the same account in two orgs (Anthropic
+ * multi-subscription) or projects (Gemini) is two distinct cache domains and
+ * must produce two distinct pins. The digest input is the persisted contract
+ * for `CredentialPinEntry.hash` — changing it orphans every recorded pin.
+ *
+ * Hashing avoids embedding raw emails/uuids in session files, but an unsalted
+ * digest of a guessable email is still linkable — treat exported sessions
+ * accordingly.
+ *
+ * Returns `undefined` when the identity carries no account key at all.
+ */
+export function credentialPinHash(provider: string, identity: CredentialPinIdentity): string | undefined {
+	if (!identity.accountId && !identity.email) return undefined;
+	const key = [
+		provider,
+		identity.accountId ?? "",
+		identity.email ?? "",
+		identity.orgId ?? "",
+		identity.projectId ?? "",
+	].join("\0");
+	return new Bun.CryptoHasher("sha256").update(key).digest("hex");
+}
+
+/**
+ * Record the account that served the latest assistant turn for `provider`.
+ * Appends a `credential_pin` entry only when the account differs from the
+ * branch's latest pin, so steady-state sessions add a single entry; the
+ * effective last-use time is derived from later assistant turns on read
+ * (see `SessionManager.getCredentialPins`).
+ */
+export function recordCredentialPin(
+	authStorage: AuthStorage,
+	sessionManager: SessionManager,
+	sessionId: string,
+	provider: string,
+): void {
+	const identity = authStorage.getOAuthAccountIdentity(provider, sessionId);
+	if (!identity) return;
+	const hash = credentialPinHash(provider, identity);
+	if (!hash || sessionManager.getCredentialPins().get(provider)?.hash === hash) return;
+	sessionManager.appendCredentialPin(provider, hash);
+}
+
+/**
+ * Re-pin the accounts recorded in the session file onto the auth store's
+ * session stickiness. No-op per provider when the account is gone (logged out)
+ * or when a live sticky already exists (same-process branch/session switches
+ * must not clobber fresher routing). Seeds with the session's effective
+ * last-use time so stale resumes still fall through to usage ranking.
+ */
+export function seedCredentialPins(authStorage: AuthStorage, sessionManager: SessionManager, sessionId: string): void {
+	for (const [provider, pin] of sessionManager.getCredentialPins()) {
+		const accounts = authStorage.listOAuthAccounts(provider, sessionId);
+		if (accounts.length === 0 || accounts.some(account => account.active)) continue;
+		const match = accounts.find(account => credentialPinHash(provider, account) === pin.hash);
+		if (!match) continue;
+		authStorage.pinSessionOAuthAccount(provider, sessionId, match.credentialId, {
+			lastUsedAtMs: pin.lastUsedAt,
+		});
+	}
+}

package/src/session/foreign-session-import.ts

@@ -0,0 +1,52 @@
+import { directoryExists } from "@oh-my-pi/pi-utils";
+import { ClaudeSessionStore } from "./claude-session-store";
+import { CodexSessionStore } from "./codex-session-store";
+import type { ForeignSessionInfo, ForeignSessionSource, ForeignSessionStore } from "./foreign-session-store";
+import type { SessionInfo } from "./session-listing";
+import type { SessionManager } from "./session-manager";
+
+/** Construct the importer for a supported foreign session source. */
+export function createForeignSessionStore(source: ForeignSessionSource): ForeignSessionStore {
+	return source === "claude" ? new ClaudeSessionStore() : new CodexSessionStore();
+}
+
+/** Display name for a supported foreign session source. */
+export function foreignSessionSourceName(source: ForeignSessionSource): string {
+	return source === "claude" ? "Claude" : "Codex";
+}
+
+/** Convert lightweight foreign metadata for the existing session picker. */
+export function foreignSessionInfoToSessionInfo(info: ForeignSessionInfo): SessionInfo {
+	const firstMessage = info.firstMessage ?? "(no messages)";
+	return {
+		path: info.path,
+		id: info.id,
+		cwd: info.cwd,
+		title: info.title,
+		created: info.created,
+		modified: info.modified,
+		messageCount: info.messageCount ?? 0,
+		size: 0,
+		firstMessage,
+		allMessagesText: firstMessage,
+	};
+}
+
+/** Import and persist one foreign session under a fresh OMP session identity. */
+export async function persistForeignSession(
+	store: ForeignSessionStore,
+	info: ForeignSessionInfo,
+	options?: { fallbackCwd?: string; sessionDir?: string; suppressBreadcrumb?: boolean },
+): Promise<SessionManager> {
+	const imported = await store.load(info);
+	imported.appendCustomEntry("foreign_session_import", {
+		source: info.source,
+		sourceId: info.id,
+		sourcePath: info.path,
+		sourceCwd: info.cwd,
+	});
+	if (options?.fallbackCwd && !(await directoryExists(imported.getCwd()))) {
+		await imported.moveTo(options.fallbackCwd);
+	}
+	return await imported.persistCopy(options);
+}

package/src/session/foreign-session-jsonl.ts

@@ -0,0 +1,29 @@
+import { isRecord, readLines } from "@oh-my-pi/pi-utils";
+
+/** One readable object record from a foreign JSONL transcript. */
+export interface ForeignJsonRecord {
+	readonly value: Record<string, unknown>;
+	readonly line: number;
+}
+
+/** Stream valid object records while tolerating malformed or truncated lines. */
+export async function* readForeignJsonRecords(filePath: string): AsyncGenerator<ForeignJsonRecord> {
+	const decoder = new TextDecoder();
+	let line = 0;
+	for await (const bytes of readLines(Bun.file(filePath).stream())) {
+		line += 1;
+		try {
+			const value: unknown = JSON.parse(decoder.decode(bytes));
+			if (isRecord(value)) yield { value, line };
+		} catch {
+			// A partially-written line must not hide the readable transcript prefix.
+		}
+	}
+}
+
+/** Read every valid object record from a foreign JSONL transcript. */
+export async function collectForeignJsonRecords(filePath: string): Promise<ForeignJsonRecord[]> {
+	const records: ForeignJsonRecord[] = [];
+	for await (const record of readForeignJsonRecords(filePath)) records.push(record);
+	return records;
+}

package/src/session/foreign-session-store.ts

@@ -0,0 +1,26 @@
+import type { SessionManager } from "./session-manager";
+
+/** External coding-agent session source supported by OMP imports. */
+export type ForeignSessionSource = "claude" | "codex";
+
+/** Lightweight source metadata used to choose a foreign session before loading its transcript. */
+export interface ForeignSessionInfo {
+	readonly source: ForeignSessionSource;
+	readonly id: string;
+	readonly path: string;
+	readonly cwd: string;
+	readonly title?: string;
+	readonly created: Date;
+	readonly modified: Date;
+	readonly messageCount?: number;
+	readonly firstMessage?: string;
+}
+
+/** Lists and converts sessions owned by another coding agent. */
+export interface ForeignSessionStore {
+	readonly source: ForeignSessionSource;
+	/** Lists source sessions without parsing complete transcripts. */
+	list(): Promise<ForeignSessionInfo[]>;
+	/** Converts one source session into a non-persistent OMP session. */
+	load(session: ForeignSessionInfo): Promise<SessionManager>;
+}

package/src/session/model-controls.ts

@@ -3,6 +3,7 @@ import type { Model, ProviderSessionState, ServiceTier, ServiceTierByFamily, Ser
 import {
 	clearAnthropicFastModeFallback,
 	Effort,
+	isAnthropicFastModeFallbackDisabled,
 	realizesPriorityServiceTier,
 	resolveModelServiceTier,
 	serviceTierFamily,
@@ -596,8 +597,8 @@ export class ModelControls {
 		let resolved: Effort | undefined;
 		if (this.#host.magicKeywordEnabled("ultrathink") && containsUltrathink(promptText)) {
 			// The user explicitly asked for maximum thinking; bypass the classifier
-			// (and its xhigh auto ceiling) and jump straight to the highest
-			// supported level for this model.
+			// (and the `providers.autoThinkingMaxEffort` ceiling) and jump straight
+			// to the highest supported level for this model.
 			resolved = clampAutoThinkingEffort(model, Effort.Max);
 		} else {
 			const controller = new AbortController();
@@ -666,7 +667,11 @@ export class ModelControls {
 	 */
 	isFastModeActive(): boolean {
 		const model = this.#model;
-		return !!model && realizesPriorityServiceTier(this.effectiveServiceTier(model), model);
+		if (!model || !realizesPriorityServiceTier(this.effectiveServiceTier(model), model)) return false;
+		if (model.provider === "anthropic") {
+			return !isAnthropicFastModeFallbackDisabled(this.#host.providerSessionState, model);
+		}
+		return true;
 	}
 
 	/**
@@ -731,6 +736,9 @@ export class ModelControls {
 			if (this.#serviceTierByFamily[family] === "priority") this.setServiceTierFamily(family, undefined);
 			return true;
 		}
+		if (family === "anthropic" && this.#serviceTierByFamily.anthropic === "priority") {
+			clearAnthropicFastModeFallback(this.#host.providerSessionState);
+		}
 		this.setServiceTierFamily(family, "priority");
 		return true;
 	}

package/src/session/session-advisors.ts

@@ -2,6 +2,7 @@ import {
 	Agent,
 	type AgentMessage,
 	type AgentTool,
+	type AgentToolContext,
 	AppendOnlyContextManager,
 	type CompactionSummaryMessage,
 	countTokens,
@@ -16,9 +17,11 @@ import {
 	compactionContextTokens,
 	createCompactionSummaryMessage,
 	estimateTokens,
+	NativeCompactionError,
 	prepareCompaction,
 	type SessionMessageEntry,
 	shouldCompact,
+	shouldUseProviderNativeCompaction,
 } from "@oh-my-pi/pi-agent-core/compaction";
 import type {
 	AssistantMessage,
@@ -67,7 +70,8 @@ import {
 import { MODEL_ROLES } from "../config/model-roles";
 import { serviceTierForAllFamilies, serviceTierSettingToTier } from "../config/service-tier";
 import type { Settings } from "../config/settings";
-import { CursorExecHandlers } from "../cursor";
+import { CursorExecHandlers, type CursorMcpResourceAdapter } from "../cursor";
+import { bridgeToolMap } from "../cursor-bridge-tools";
 import { estimateToolSchemaTokens } from "../modes/utils/context-usage";
 import type { PlanModeState } from "../plan-mode/state";
 import advisorSystemPrompt from "../prompts/advisor/system.md" with { type: "text" };
@@ -177,12 +181,44 @@ interface AdvisorRuntimeDescriptor {
 export interface SessionAdvisorsOptions {
 	enabled: boolean;
 	tools?: AgentTool[];
+	/**
+	 * Build a `grep` honoring a Cursor `pi_grep` frame's own context width and
+	 * match cap. The advisor's tools are fixed instances carrying session
+	 * defaults, so without this an advisor running against Cursor silently
+	 * drops both fields — the same gap the primary bridge closes.
+	 */
+	createGrepTool?(options: { context?: number; totalMatchLimit?: number }): AgentTool | undefined;
+	/**
+	 * Build the `replace`-mode `edit` a Cursor `pi_edit` frame needs. The
+	 * advisor's own instance follows the configured `edit.mode` (`hashline` by
+	 * default), whose schema the frame's `old_text`/`new_text` pairs do not
+	 * match, so without this every native advisor edit fails validation.
+	 */
+	createEditTool?(): AgentTool | undefined;
+	/**
+	 * The execute-time context the bridge's tools resolve approval from.
+	 *
+	 * `ExtensionToolWrapper` reads the approval mode, per-tool policies and
+	 * `autoApprove` only from here; with none it falls back to `yolo` and empty
+	 * policies, so a native frame would run past a configured `ask` or `deny`.
+	 */
+	getToolContext?: () => AgentToolContext | undefined;
+	/**
+	 * The live MCP connections Cursor's resource frames answer from.
+	 *
+	 * Advisors share the session's connections and may hold tools from those
+	 * same servers, so without this their frames report that every server
+	 * advertises nothing.
+	 */
+	mcpResources?: CursorMcpResourceAdapter;
 	watchdogPrompt?: string;
 	sharedInstructions?: string;
 	contextPrompt?: string;
 	configs?: AdvisorConfig[];
 	streamFn?: StreamFn;
 	transformProviderContext?: (context: Context, model: Model) => Context | Promise<Context>;
+	/** Advisor spend already persisted for this session, restored on resume. */
+	initialCosts?: ReadonlyMap<string, number>;
 }
 
 /** Options accepted when an advisor injects a primary-session message. */
@@ -221,7 +257,11 @@ export interface SessionAdvisorsHost {
 	hasPendingNextTurnMessages(): boolean;
 	convertToLlmForSideRequest(messages: AgentMessage[]): Message[];
 	effectiveServiceTier(model: Model): ServiceTier | undefined;
-	resolveContextPromotionTarget(currentModel: Model, contextWindow: number): Promise<Model | undefined>;
+	resolveContextPromotionTarget(
+		currentModel: Model,
+		contextWindow: number,
+		signal: AbortSignal,
+	): Promise<Model | undefined>;
 	resolveCompactionModelCandidates(preferredModel: Model | null | undefined, availableModels: Model[]): Model[];
 	resolveRetryFallbackRole(currentSelector: string, currentModel?: Model | null): string | undefined;
 	findRetryFallbackCandidates(
@@ -244,6 +284,10 @@ export class SessionAdvisors {
 	readonly #host: SessionAdvisorsHost;
 	#advisorEnabled: boolean;
 	#advisorTools: AgentTool[] | undefined;
+	#advisorCreateGrepTool: SessionAdvisorsOptions["createGrepTool"];
+	#advisorCreateEditTool: SessionAdvisorsOptions["createEditTool"];
+	#advisorGetToolContext: SessionAdvisorsOptions["getToolContext"];
+	#advisorMcpResources: SessionAdvisorsOptions["mcpResources"];
 	#advisorWatchdogPrompt: string | undefined;
 	#advisorSharedInstructions: string | undefined;
 	#advisorContextPrompt: string | undefined;
@@ -266,12 +310,17 @@ export class SessionAdvisors {
 		this.#host = host;
 		this.#advisorEnabled = options.enabled;
 		this.#advisorTools = options.tools;
+		this.#advisorCreateGrepTool = options.createGrepTool;
+		this.#advisorCreateEditTool = options.createEditTool;
+		this.#advisorGetToolContext = options.getToolContext;
+		this.#advisorMcpResources = options.mcpResources;
 		this.#advisorWatchdogPrompt = options.watchdogPrompt;
 		this.#advisorSharedInstructions = options.sharedInstructions;
 		this.#advisorContextPrompt = options.contextPrompt;
 		this.#advisorConfigs = options.configs;
 		this.#advisorStreamFn = options.streamFn;
 		this.#transformProviderContext = options.transformProviderContext;
+		if (options.initialCosts) this.#advisorCosts = new Map(options.initialCosts);
 		if (this.#advisorEnabled) this.#buildAdvisorRuntime();
 	}
 
@@ -313,6 +362,15 @@ export class SessionAdvisors {
 		this.#stopAdvisorRuntime();
 	}
 
+	/**
+	 * Pause advisor work while old-session recorder feeds remain attached, then
+	 * detach only after any active prompt has settled.
+	 */
+	async drainAndDetachRecorders(): Promise<void> {
+		await Promise.all(this.#advisors.map(advisor => advisor.runtime.pauseForSessionTransition()));
+		await this.detachAndCloseRecorders();
+	}
+
 	/** Detaches and drains recorder feeds before transcript artifacts are removed. */
 	async detachAndCloseRecorders(): Promise<void> {
 		const closes: Promise<void>[] = [];
@@ -325,6 +383,14 @@ export class SessionAdvisors {
 		await Promise.all(closes);
 	}
 
+	/** Reattach recorder feeds and resume work after a rolled-back or preserving transition. */
+	reattachRecorderFeeds(): void {
+		for (const advisor of this.#advisors) {
+			if (!advisor.agentUnsubscribe) this.#attachAdvisorRecorderFeed(advisor);
+			advisor.runtime.resumeAfterSessionTransition();
+		}
+	}
+
 	/** Re-primes advisor transcript views across a conversation boundary. */
 	resetSessionState(options: { preserveCost?: boolean } = {}): void {
 		this.#resetAdvisorSessionState(options.preserveCost === true);
@@ -335,6 +401,11 @@ export class SessionAdvisors {
 		this.#advisorCosts.clear();
 	}
 
+	/** Replace the ledger with the spend recorded for the session becoming active. */
+	restoreCost(costs: ReadonlyMap<string, number>): void {
+		this.#advisorCosts = new Map(costs);
+	}
+
 	/**
 	 * Rebind every live advisor to the active primary conversation's provider
 	 * identity (session id, prompt-cache key, credential + metadata resolvers,
@@ -689,11 +760,29 @@ export class SessionAdvisors {
 			// to delete workspace files it was never granted (issue #5680 review).
 			const advisorCanMutateFiles = advisorToolMap.has("write") || advisorToolMap.has("edit");
 			if (advisorCanMutateFiles) availableAdvisorToolNames.add("delete");
+			// `pi_edit` speaks `replace`'s `old_text`/`new_text` schema, which the
+			// advisor's ordinary `EditTool` (built at the session's configured
+			// `edit.mode`, `hashline` by default) does not accept. The bridge map
+			// swaps in a `replace` instance for the exec channel only — the
+			// advisor's own loop keeps the tool it was given — and only when
+			// `edit` was actually granted.
 			const advisorCursorExecHandlers = new CursorExecHandlers({
 				cwd: this.#host.sessionManager.getCwd(),
 				getCwd: () => this.#host.sessionManager.getCwd(),
-				tools: advisorToolMap,
-				allowNativeDelete: advisorCanMutateFiles,
+				tools: bridgeToolMap(advisorToolMap, this.#advisorCreateEditTool),
+				// Approval mode, per-tool policies and `autoApprove` live only on
+				// this context; without it every bridge tool resolves as `yolo`.
+				getToolContext: this.#advisorGetToolContext,
+				allowDirectFileMutation: advisorCanMutateFiles,
+				// Gated on the advisor's own grant: the factory builds a fresh
+				// tool, so handing it over unconditionally would give a roster
+				// without `grep` a search tool it was denied.
+				createGrepTool: advisorToolMap.has("grep") ? this.#advisorCreateGrepTool : undefined,
+				// Advisors share the session's live MCP connections, so their
+				// resource frames answer from the same catalog the primary sees.
+				// Not gated on a tool grant: reading what a server advertises is
+				// not the same permission as calling one of its tools.
+				mcpResources: this.#advisorMcpResources,
 			});
 			const baseAdvisorStreamFn = this.#advisorStreamFn ?? streamSimple;
 			const advisorStreamFn: StreamFn = (requestModel, context, options) =>
@@ -784,10 +873,13 @@ export class SessionAdvisors {
 			const runtime = new AdvisorRuntime(advisorAgentFacade, {
 				snapshotMessages: () => this.#host.agent.state.messages,
 				enqueueAdvice: (note, severity) => this.#routeAdvice(advisorRef, note, severity),
-				maintainContext: incomingTokens => this.#maintainAdvisorContext(advisorRef, incomingTokens),
+				maintainContext: (incomingTokens, signal) =>
+					this.#maintainAdvisorContext(advisorRef, incomingTokens, signal),
 				obfuscator: this.#host.obfuscator,
+				getModelIdentity: () => formatModelString(advisorRef.agent.state.model),
 				beginAdvisorUpdate: () => advisorRef.emissionGuard.beginUpdate(),
-				onTurnError: (error, failedMessages) => this.#recoverAdvisorTurn(advisorRef, error, failedMessages),
+				onTurnError: (error, failedMessages, signal) =>
+					this.#recoverAdvisorTurn(advisorRef, error, failedMessages, signal),
 				onTurnSuccess: async () => {
 					const fallback = advisorRef.retryFallback;
 					if (!advisorRef.retryFallbackPendingSuccess || !fallback) return;
@@ -1015,7 +1107,7 @@ export class SessionAdvisors {
 	}
 
 	/** Restore an advisor's configured primary once its fallback cooldown expires. */
-	async #maybeRestoreAdvisorRetryFallbackPrimary(advisor: ActiveAdvisor): Promise<void> {
+	async #maybeRestoreAdvisorRetryFallbackPrimary(advisor: ActiveAdvisor, signal: AbortSignal): Promise<void> {
 		const fallback = advisor.retryFallback;
 		if (!fallback || getRetryFallbackRevertPolicy(this.#host.settings) !== "cooldown-expiry") return;
 
@@ -1043,8 +1135,9 @@ export class SessionAdvisors {
 		const primaryModel =
 			resolvedPrimary.model ?? this.#host.modelRegistry.find(originalSelector.provider, originalSelector.id);
 		if (!primaryModel) return;
-		const apiKey = await this.#host.modelRegistry.getApiKey(primaryModel, advisor.providerSessionId);
+		const apiKey = await this.#host.modelRegistry.getApiKey(primaryModel, advisor.providerSessionId, { signal });
 		if (!apiKey) return;
+		signal.throwIfAborted();
 
 		const thinkingToApply =
 			advisor.thinkingLevel === fallback.lastAppliedThinkingLevel
@@ -1064,6 +1157,7 @@ export class SessionAdvisors {
 		advisor: ActiveAdvisor,
 		error: unknown,
 		failedMessages: readonly AgentMessage[],
+		signal: AbortSignal,
 	): Promise<boolean> {
 		if (error instanceof AdvisorOutputQuarantinedError) return false;
 
@@ -1086,6 +1180,7 @@ export class SessionAdvisors {
 					retryAfterMs: extractRetryHint(undefined, message),
 					baseUrl: currentModel.baseUrl,
 					modelId: currentModel.id,
+					signal,
 				},
 			);
 			return outcome.switched;
@@ -1117,6 +1212,7 @@ export class SessionAdvisors {
 					retryAfterMs,
 					baseUrl: currentModel.baseUrl,
 					modelId: currentModel.id,
+					signal,
 				},
 			);
 			if (outcome.switched) return true;
@@ -1134,8 +1230,9 @@ export class SessionAdvisors {
 			const resolved = resolveModelOverride([selector.raw], this.#host.modelRegistry, this.#host.settings);
 			const candidate = resolved.model ?? this.#host.modelRegistry.find(selector.provider, selector.id);
 			if (!candidate || modelsAreEqual(candidate, currentModel)) continue;
-			const apiKey = await this.#host.modelRegistry.getApiKey(candidate, advisor.providerSessionId);
+			const apiKey = await this.#host.modelRegistry.getApiKey(candidate, advisor.providerSessionId, { signal });
 			if (!apiKey) continue;
+			signal.throwIfAborted();
 
 			const originalThinkingLevel = advisor.thinkingLevel;
 			const requestedThinkingLevel = selector.thinkingLevel ?? originalThinkingLevel;
@@ -1163,13 +1260,18 @@ export class SessionAdvisors {
 		return false;
 	}
 
-	async #promoteAdvisorContextModel(advisor: ActiveAdvisor, currentModel: Model): Promise<boolean> {
+	async #promoteAdvisorContextModel(
+		advisor: ActiveAdvisor,
+		currentModel: Model,
+		signal: AbortSignal,
+	): Promise<boolean> {
 		const promotionSettings = this.#host.settings.getGroup("contextPromotion");
 		if (!promotionSettings.enabled) return false;
 		const contextWindow = currentModel.contextWindow ?? 0;
 		if (contextWindow <= 0) return false;
-		const targetModel = await this.#host.resolveContextPromotionTarget(currentModel, contextWindow);
+		const targetModel = await this.#host.resolveContextPromotionTarget(currentModel, contextWindow, signal);
 		if (!targetModel) return false;
+		signal.throwIfAborted();
 
 		// Preserve this advisor's own thinking level (a configured `model:...:high`
 		// keeps its suffix across a promotion); only the model changes.
@@ -1193,8 +1295,12 @@ export class SessionAdvisors {
 		}
 	}
 
-	async #maintainAdvisorContext(advisor: ActiveAdvisor, incomingTokens: number): Promise<boolean> {
-		await this.#maybeRestoreAdvisorRetryFallbackPrimary(advisor);
+	async #maintainAdvisorContext(
+		advisor: ActiveAdvisor,
+		incomingTokens: number,
+		signal: AbortSignal,
+	): Promise<boolean> {
+		await this.#maybeRestoreAdvisorRetryFallbackPrimary(advisor, signal);
 		const agent = advisor.agent;
 
 		const compactionSettings = this.#host.settings.getGroup("compaction");
@@ -1229,7 +1335,7 @@ export class SessionAdvisors {
 		}
 
 		// 1. Try promotion first
-		if (await this.#promoteAdvisorContextModel(advisor, advisorModel)) {
+		if (await this.#promoteAdvisorContextModel(advisor, advisorModel, signal)) {
 			// Promotion succeeded, check if new model has enough space
 			const newModel = agent.state.model;
 			const newWindow = newModel.contextWindow ?? 0;
@@ -1296,6 +1402,7 @@ export class SessionAdvisors {
 
 		let compactResult: CompactionResult | undefined;
 		let lastError: unknown;
+		let nativeCompactionFailure: { error: NativeCompactionError; provider: string } | undefined;
 		// Instrument the advisor's overflow-compaction one-shot like the primary
 		// compaction path so the advisor model's maintenance call also emits spans.
 		const telemetry = resolveTelemetry(agent.telemetry, advisorProviderSessionId);
@@ -1307,8 +1414,16 @@ export class SessionAdvisors {
 		});
 
 		for (const candidate of candidates) {
-			const apiKey = await this.#host.modelRegistry.getApiKey(candidate, advisorProviderSessionId);
+			const apiKey = await this.#host.modelRegistry.getApiKey(candidate, advisorProviderSessionId, { signal });
 			if (!apiKey) continue;
+			if (
+				nativeCompactionFailure &&
+				(candidate.provider !== nativeCompactionFailure.provider ||
+					!shouldUseProviderNativeCompaction(candidate, compactionSettings))
+			) {
+				throw nativeCompactionFailure.error;
+			}
+
 			// The advisor overflow-compaction one-shot bypasses the advisor `Agent`,
 			// so its installed metadata resolver never runs. Emit the same
 			// `metadata.user_id` identity here (resolved per candidate provider,
@@ -1324,7 +1439,7 @@ export class SessionAdvisors {
 					candidate,
 					this.#host.modelRegistry.resolver(candidate, advisorProviderSessionId),
 					undefined,
-					undefined,
+					signal,
 					{
 						thinkingLevel: advisorCompactionThinkingLevel,
 						convertToLlm: messages => this.#host.convertToLlmForSideRequest(messages),
@@ -1339,10 +1454,19 @@ export class SessionAdvisors {
 				);
 				break;
 			} catch (error) {
+				if (signal.aborted) throw error;
+				const id = AIError.classify(error, candidate.api);
+				if (error instanceof NativeCompactionError && !AIError.is(id, AIError.Flag.AuthFailed)) {
+					nativeCompactionFailure ??= { error, provider: candidate.provider };
+					lastError = nativeCompactionFailure.error;
+					continue;
+				}
 				lastError = error;
 			}
 		}
 
+		if (!compactResult && nativeCompactionFailure) throw nativeCompactionFailure.error;
+
 		if (!compactResult) {
 			logger.warn("Advisor compaction failed, falling back to re-prime", { error: String(lastError) });
 			return true;

package/src/session/session-entries.ts

@@ -154,6 +154,7 @@ export interface TitleChangeEntry extends SessionEntryBase {
 declare module "@oh-my-pi/pi-agent-core/compaction/entries" {
 	interface CustomCompactionSessionEntries {
 		titleChange: TitleChangeEntry;
+		credentialPin: CredentialPinEntry;
 	}
 }
 
@@ -164,6 +165,24 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
 	injectedRules: string[];
 }
 
+/**
+ * Records which OAuth account served this session's requests for a provider.
+ *
+ * Provider prompt caches (Anthropic in particular) are account-scoped, and the
+ * auth store's session-sticky routing is process-local under a remote auth
+ * broker, so resume must re-pin the same account to reuse the warm cache
+ * prefix. Stores a sha-256 of the account + billing-scope tuple instead of
+ * the raw email/uuid/org; note an unsalted digest of a guessable email is
+ * still linkable, so exported sessions are pseudonymous, not anonymous.
+ */
+export interface CredentialPinEntry extends SessionEntryBase {
+	type: "credential_pin";
+	/** Provider id the pin applies to (e.g. "anthropic"). */
+	provider: string;
+	/** `credentialPinHash()` of the serving account's identity + scope tuple. */
+	hash: string;
+}
+
 /** Session init entry - captures initial context for subagent sessions (debugging/replay). */
 export interface SessionInitEntry extends SessionEntryBase {
 	type: "session_init";
@@ -230,7 +249,8 @@ export type SessionEntry =
 	| TitleChangeEntry
 	| TtsrInjectionEntry
 	| SessionInitEntry
-	| ModeChangeEntry;
+	| ModeChangeEntry
+	| CredentialPinEntry;
 
 /** Raw logical file entry after loaders strip any fixed-width title slot. */
 export type FileEntry = SessionHeader | SessionEntry;