@oh-my-pi/pi-coding-agent 17.1.7 → 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,
@@ -581,9 +582,9 @@ export class ModelControls {
 
 	/**
 	 * Classify the current user turn and set the effective thinking level for it.
-	 * Bounded by a timeout + abort; on any failure (no smol model, timeout, parse
-	 * error) it falls back to the provisional concrete level and continues. Never
-	 * throws into the turn, and never clears `#autoThinking` (auto stays active).
+	 * Bounded by a timeout + abort; on failure it preserves the last classified
+	 * level, or uses the provisional concrete level before the first resolution.
+	 * Never throws into the turn, and never clears `#autoThinking`.
 	 */
 	async applyAutoThinkingLevel(promptText: string, generation: number): Promise<void> {
 		const model = this.#model;
@@ -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();
@@ -625,7 +626,7 @@ export class ModelControls {
 
 		const effort = clampThinkingLevelToCeiling(
 			model,
-			resolved ?? resolveProvisionalAutoLevel(model),
+			resolved ?? this.#autoResolvedLevel ?? resolveProvisionalAutoLevel(model),
 			this.#thinkingLevelCeiling,
 		);
 		if (effort === undefined) return;
@@ -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,
@@ -48,7 +51,6 @@ import {
 	type AdvisorSeverity,
 	AdvisorTranscriptRecorder,
 	advisorTranscriptFilename,
-	annotateForStaleness,
 	buildAdvisorQuarantineSourceText,
 	formatAdvisorBatchContent,
 	getOrCreateAdvisorProviderSessionId,
@@ -68,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" };
@@ -178,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. */
@@ -222,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(
@@ -245,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;
@@ -267,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();
 	}
 
@@ -314,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>[] = [];
@@ -326,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);
@@ -336,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,
@@ -690,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) =>
@@ -785,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;
@@ -890,10 +981,6 @@ export class SessionAdvisors {
 			logger.debug("advisor advice suppressed by emission guard", { severity, advisor: advisor.name });
 			return;
 		}
-		// When newer primary turns already arrived while the advisor model was
-		// processing this batch, the advice was generated without seeing them.
-		// Append a lightweight staleness caveat so the primary can weigh recency.
-		const deliveredNote = annotateForStaleness(note, advisor.runtime.hasFreshBacklog);
 		// The implicit single ("default") advisor stamps no source name, so its
 		// agent-facing `<advisory>` bytes stay identical to the pre-multi-advisor path.
 		const source = advisor.slug ? advisor.name : undefined;
@@ -911,10 +998,10 @@ export class SessionAdvisors {
 			interruptImmuneTurnActive: interrupting && this.#isAdvisorInterruptImmuneTurnActive(),
 		});
 		if (channel === "aside") {
-			this.#host.yieldQueue.enqueue("advisor", { note: deliveredNote, severity, advisor: source });
+			this.#host.yieldQueue.enqueue("advisor", { note, severity, advisor: source });
 			return;
 		}
-		const notes: AdvisorNote[] = [{ note: deliveredNote, severity, advisor: source }];
+		const notes: AdvisorNote[] = [{ note, severity, advisor: source }];
 		const content = formatAdvisorBatchContent(notes);
 		const details = { notes } satisfies AdvisorMessageDetails;
 		if (channel === "preserve") {
@@ -1020,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;
 
@@ -1048,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
@@ -1069,6 +1157,7 @@ export class SessionAdvisors {
 		advisor: ActiveAdvisor,
 		error: unknown,
 		failedMessages: readonly AgentMessage[],
+		signal: AbortSignal,
 	): Promise<boolean> {
 		if (error instanceof AdvisorOutputQuarantinedError) return false;
 
@@ -1091,6 +1180,7 @@ export class SessionAdvisors {
 					retryAfterMs: extractRetryHint(undefined, message),
 					baseUrl: currentModel.baseUrl,
 					modelId: currentModel.id,
+					signal,
 				},
 			);
 			return outcome.switched;
@@ -1122,6 +1212,7 @@ export class SessionAdvisors {
 					retryAfterMs,
 					baseUrl: currentModel.baseUrl,
 					modelId: currentModel.id,
+					signal,
 				},
 			);
 			if (outcome.switched) return true;
@@ -1139,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;
@@ -1168,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.
@@ -1198,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");
@@ -1234,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;
@@ -1301,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);
@@ -1312,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,
@@ -1329,7 +1439,7 @@ export class SessionAdvisors {
 					candidate,
 					this.#host.modelRegistry.resolver(candidate, advisorProviderSessionId),
 					undefined,
-					undefined,
+					signal,
 					{
 						thinkingLevel: advisorCompactionThinkingLevel,
 						convertToLlm: messages => this.#host.convertToLlmForSideRequest(messages),
@@ -1344,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;