@oh-my-pi/pi-coding-agent 16.4.6 → 16.5.0

package/src/modes/components/plan-review-overlay.ts

@@ -82,6 +82,8 @@ export interface PlanReviewOverlayCallbacks {
 	onPick: (label: string) => void;
 	/** Invoked on Esc / cancel. */
 	onCancel: () => void;
+	/** Invoked with the current full plan text when the copy hotkey is pressed. */
+	onCopyPlan?: (content: string) => void | Promise<void>;
 	/** Invoked when the external-editor key is pressed (overlay stays open). */
 	onExternalEditor?: () => void;
 	/** Invoked when the external-editor key edits the active annotation draft. */
@@ -302,6 +304,10 @@ export class PlanReviewOverlay implements Component {
 			this.callbacks.onExternalEditor();
 			return;
 		}
+		if (this.callbacks.onCopyPlan && keyData === "c") {
+			void this.callbacks.onCopyPlan(joinPlanSections(this.#sections));
+			return;
+		}
 		if (matchesKey(keyData, "tab") || keyData === "\t") {
 			this.#cycleRegion(1);
 			return;
@@ -677,6 +683,7 @@ export class PlanReviewOverlay implements Component {
 				parts.push("↑↓ scroll", "⇧ faster", "pgup/pgdn", "g/G ends");
 				break;
 		}
+		if (this.callbacks.onCopyPlan) parts.push("c copy");
 		parts.push("tab regions");
 		if (this.#externalEditorLabel && this.#focus !== "toc") parts.push(`${this.#externalEditorLabel} editor`);
 		parts.push(this.#helpSuffix);

package/src/modes/components/snapcompact-shape-preview-doc.md

@@ -1,18 +1,14 @@
-# User ¶
-Fix the settings overlay crash. Wheeling past the last row throws.
+¶user:Fix the settings overlay crash. Wheeling past the last row throws.
 
-# Tool call ¶
-//Reading the select-list hit test
-read(path="src/select-list.ts:140-180")
+¶call:read(path="src/select-list.ts:140-180")//Reading the select-list hit test
 <out>
 162: const index = Math.floor(line / rowHeight); index is never checked against bounds.
 </out>
 
-# Assistant ¶
-Found it. The hit test indexes past the filtered list; clamping to the last row fixes the crash.
+¶ai:Found it. The hit test indexes past the filtered list; clamping to the last row fixes the crash.
 
-# User ¶
-Does the fix survive filtering?
+¶user:Does the fix survive filtering?
 
-# Assistant ¶
-Yes. The clamp applies after the filter pass, so a narrowed list keeps the hit map in sync. Added a regression test that wheels past the last row with a filter active and asserts no throw.
+¶think:Check whether the clamp runs before or after filtering.
+
+¶ai:Yes. The clamp applies after the filter pass, so a narrowed list keeps the hit map in sync. Added a regression test that wheels past the last row with a filter active and asserts no throw.

package/src/modes/components/status-line/component.test.ts

@@ -4,15 +4,43 @@ import type { AgentSession } from "../../../session/agent-session";
 import { getThemeByName, setThemeInstance } from "../../theme/theme";
 import { StatusLineComponent } from "./component";
 
-function makeSessionWithLastMessage(lastMessage: unknown) {
+function makeSessionWithLastMessage(lastMessage: unknown, prewalkArmed: boolean = false) {
 	return {
-		messages: [lastMessage],
+		messages: lastMessage ? [lastMessage] : [],
 		model: { contextWindow: 128000 },
 		contextUsageRevision: 0,
 		systemPrompt: [],
 		agent: { state: { tools: [] } },
 		skills: [],
 		getContextUsage: () => ({ tokens: 42, contextWindow: 128000 }),
+		state: {
+			messages: lastMessage ? [lastMessage] : [],
+			model: { contextWindow: 128000 },
+		},
+		sessionManager: {
+			getUsageStatistics: () => ({
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				orchestrationInput: 0,
+				orchestrationOutput: 0,
+				orchestrationCacheRead: 0,
+				premiumRequests: 0,
+				cost: 0,
+				tokensPerSecond: null,
+			}),
+			getSessionName: () => "test-session",
+		},
+		getPrewalkState: () => (prewalkArmed ? { target: { id: "cheap-model", provider: "openai" } } : undefined),
+		getAsyncJobSnapshot: () => undefined,
+		isAdvisorActive: () => false,
+		isFastModeActive: () => false,
+		configuredThinkingLevel: () => undefined,
+		modelRegistry: {
+			isUsingOAuth: () => false,
+		},
 	};
 }
 
@@ -41,4 +69,15 @@ describe("StatusLineComponent", () => {
 
 		expect(statusLine.getCachedContextBreakdown()).toEqual({ usedTokens: 42, contextWindow: 128000 });
 	});
+
+	it("renders Prewalk annotation when prewalk is armed", () => {
+		const statusLine = new StatusLineComponent(makeSessionWithLastMessage(null, true) as unknown as AgentSession);
+
+		// By default preset, 'mode' segment is included in left/right segments.
+		// Let's get the border and see if Prewalk is rendered.
+		const border = statusLine.getTopBorder(100);
+		// SGR codes might be included, so we check if the stripped content contains "Prewalk"
+		const stripped = border.content.replace(/\x1b\[[0-9;]*m/g, "");
+		expect(stripped).toContain("Prewalk");
+	});
 });

package/src/modes/components/status-line/component.ts

@@ -1051,6 +1051,10 @@ export class StatusLineComponent implements Component {
 			compactThinkingLevel: this.#resolveSettings().compactThinkingLevel ?? false,
 			planMode: this.#planModeStatus,
 			loopMode: this.#loopModeStatus,
+			prewalk:
+				typeof this.session.getPrewalkState === "function" && this.session.getPrewalkState()
+					? { enabled: true }
+					: null,
 			goalMode: this.#goalModeStatus,
 			vibeMode: this.#vibeModeStatus,
 			collab: this.#collabStatus,

package/src/modes/components/status-line/segments.ts

@@ -208,6 +208,12 @@ const modeSegment: StatusLineSegment = {
 			return { content: theme.fg(color, content), visible: true };
 		}
 
+		const prewalk = ctx.prewalk;
+		if (prewalk?.enabled) {
+			const content = withIcon(theme.icon.prewalk, "Prewalk");
+			return { content: theme.fg("accent", content), visible: true };
+		}
+
 		const goal = ctx.goalMode;
 		if (goal && (goal.enabled || goal.paused)) {
 			return renderGoalMode(ctx, goal);

package/src/modes/components/status-line/types.ts

@@ -60,6 +60,9 @@ export interface SegmentContext {
 		enabled: boolean;
 		paused: boolean;
 	} | null;
+	prewalk: {
+		enabled: boolean;
+	} | null;
 	loopMode: {
 		enabled: boolean;
 	} | null;

package/src/modes/components/tips.txt

@@ -21,4 +21,5 @@ Pair up live: `/collab` shares your session through an end-to-end encrypted rela
 Press ← ← to drill into a running or finished agent and inspect its tool calls and transcript
 Hit a Codex rate limit? `/usage reset` spends a saved reset credit to immediately restore your quota
 No native tool_calling? Inference provider botches parsing them? `PI_DIALECT=glm|kimi|anthropic…` rolls it locally for them!
-Turn on `/advisor` to attach a second model that reviews every turn and quietly injects advice [NEW]
+Turn on `/advisor` to attach a second model that reviews every turn and quietly injects advice
+Try starting your prompt with a ->, and writing a list (1. Do X, 2. Do Y)

package/src/modes/components/welcome.ts

@@ -44,20 +44,19 @@ const NEW_GLOW_PERIOD_MS = 1500;
  *  affordance surfaces this many times as often. */
 const NEW_TIP_WEIGHT = 4;
 
-/** Per-tip selection weights, parallel to {@link TIPS}. */
-const TIP_WEIGHTS: readonly number[] = TIPS.map(tip => (NEW_TIP_MARKER.test(tip) ? NEW_TIP_WEIGHT : 1));
-const TIP_WEIGHT_TOTAL = TIP_WEIGHTS.reduce((sum, weight) => sum + weight, 0);
-
-/** Pick a tip at random, biased toward "[NEW]" tips by {@link NEW_TIP_WEIGHT}.
- *  Returns "" when no tips are embedded. */
-function pickWeightedTip(): string {
-	if (TIPS.length === 0) return "";
-	let r = Math.random() * TIP_WEIGHT_TOTAL;
-	for (let i = 0; i < TIPS.length; i++) {
-		r -= TIP_WEIGHTS[i] ?? 1;
-		if (r < 0) return TIPS[i] ?? "";
+/** Pick a tip from `tips`, biased toward "[NEW]" tips by {@link NEW_TIP_WEIGHT};
+ *  `r` is a uniform sample in [0, 1). Returns "" when `tips` is empty.
+ *  Exported for tests. */
+export function pickWeightedTip(tips: readonly string[], r: number): string {
+	if (tips.length === 0) return "";
+	const weights = tips.map(tip => (NEW_TIP_MARKER.test(tip) ? NEW_TIP_WEIGHT : 1));
+	const total = weights.reduce((sum, weight) => sum + weight, 0);
+	let acc = r * total;
+	for (let i = 0; i < tips.length; i++) {
+		acc -= weights[i] ?? 1;
+		if (acc < 0) return tips[i] ?? "";
 	}
-	return TIPS[TIPS.length - 1] ?? "";
+	return tips[tips.length - 1] ?? "";
 }
 
 type ColorEncoding = "ansi-16m" | "ansi-256";
@@ -161,7 +160,7 @@ export class WelcomeComponent implements Component {
 			if (theme.getSymbolPreset() === "unicode" && Math.random() < 0.1) {
 				this.#selectedTip = "Please use nerdfont 😭.";
 			} else {
-				this.#selectedTip = pickWeightedTip();
+				this.#selectedTip = pickWeightedTip(TIPS, Math.random());
 			}
 		}
 		return this.#selectedTip || undefined;

package/src/modes/controllers/command-controller.ts

@@ -1200,7 +1200,15 @@ export class CommandController {
 			this.ctx.rebuildChatFromMessages();
 
 			this.ctx.statusLine.invalidate();
-			this.ctx.ui.requestRender();
+			// Same as the auto-compaction rebuild: a collapsed transcript is an
+			// intentional replacement, so drop the stale pre-compaction scrollback
+			// instead of repainting the shrunken frame below it. With collapse
+			// disabled the full history stays inline and scrollback is kept.
+			if (this.ctx.settings.get("display.collapseCompacted")) {
+				this.ctx.ui.requestRender(true, { clearScrollback: true });
+			} else {
+				this.ctx.ui.requestRender();
+			}
 		} catch (error) {
 			if (error instanceof CompactionCancelledError) {
 				outcome = "cancelled";

package/src/modes/controllers/event-controller.ts

@@ -76,7 +76,7 @@ export class EventController {
 	#lastVisibleBlockCount = 0;
 	#renderedCustomMessages = new Set<string>();
 	#lastIntent: string | undefined = undefined;
-	#backgroundToolCallIds = new Set<string>();
+	#backgroundTaskCallIds = new Set<string>();
 	#readToolCallArgs = new Map<string, Record<string, unknown>>();
 	#readToolCallAssistantComponents = new Map<string, AssistantMessageComponent>();
 	#lastAssistantComponent: AssistantMessageComponent | undefined = undefined;
@@ -281,7 +281,7 @@ export class EventController {
 		this.#lastVisibleBlockCount = 0;
 		this.#renderedCustomMessages.clear();
 		this.#lastIntent = undefined;
-		this.#backgroundToolCallIds.clear();
+		this.#backgroundTaskCallIds.clear();
 		this.#readToolCallArgs.clear();
 		this.#readToolCallAssistantComponents.clear();
 		this.#lastAssistantComponent = undefined;
@@ -828,9 +828,9 @@ export class EventController {
 				// The turn ended without running these calls (abort/error/TTSR rewind),
 				// so they will never produce a result. Seal them so they stop animating
 				// and freeze instead of pinning the transcript live region while a retry
-				// streams fresh blocks below them. Background tools keep updating.
+				// streams fresh blocks below them. Background task calls keep updating.
 				for (const [toolCallId, component] of this.ctx.pendingTools.entries()) {
-					if (!this.#backgroundToolCallIds.has(toolCallId) && component instanceof ToolExecutionComponent) {
+					if (!this.#backgroundTaskCallIds.has(toolCallId) && component instanceof ToolExecutionComponent) {
 						component.seal();
 					}
 				}
@@ -948,7 +948,7 @@ export class EventController {
 			// While the call is still executing — a mixed blocking+async task
 			// call whose jobs settle before its blocking subset — treat it as a
 			// partial frame: `tool_execution_end` still owns the terminal result.
-			const isTerminal = isFinalAsyncState && this.#backgroundToolCallIds.has(event.toolCallId);
+			const isTerminal = isFinalAsyncState && this.#backgroundTaskCallIds.has(event.toolCallId);
 			component.updateResult(
 				{ ...event.partialResult, isError: asyncState === "failed" },
 				!isTerminal,
@@ -956,7 +956,7 @@ export class EventController {
 			);
 			if (isTerminal) {
 				this.ctx.pendingTools.delete(event.toolCallId);
-				this.#backgroundToolCallIds.delete(event.toolCallId);
+				this.#backgroundTaskCallIds.delete(event.toolCallId);
 			}
 			this.ctx.ui.requestRender();
 		}
@@ -977,13 +977,7 @@ export class EventController {
 					component.updateResult({ ...event.result, isError: event.isError }, false, event.toolCallId);
 					this.ctx.pendingTools.delete(event.toolCallId);
 				}
-				const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
-				if (asyncState === "running") {
-					this.#backgroundToolCallIds.add(event.toolCallId);
-				} else {
-					this.#backgroundToolCallIds.delete(event.toolCallId);
-					this.#clearReadToolCall(event.toolCallId);
-				}
+				this.#clearReadToolCall(event.toolCallId);
 				this.ctx.ui.requestRender();
 			} else {
 				let component = this.ctx.pendingTools.get(event.toolCallId);
@@ -996,29 +990,22 @@ export class EventController {
 					component = group;
 					this.ctx.pendingTools.set(event.toolCallId, group);
 				}
-				const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
-				const isBackgroundRunning = asyncState === "running";
-				component.updateResult({ ...event.result, isError: event.isError }, isBackgroundRunning, event.toolCallId);
-				if (isBackgroundRunning) {
-					this.#backgroundToolCallIds.add(event.toolCallId);
-				} else {
-					this.ctx.pendingTools.delete(event.toolCallId);
-					this.#backgroundToolCallIds.delete(event.toolCallId);
-					this.#clearReadToolCall(event.toolCallId);
-				}
+				component.updateResult({ ...event.result, isError: event.isError }, false, event.toolCallId);
+				this.ctx.pendingTools.delete(event.toolCallId);
+				this.#clearReadToolCall(event.toolCallId);
 				this.ctx.ui.requestRender();
 			}
 		} else {
 			const component = this.ctx.pendingTools.get(event.toolCallId);
 			if (component) {
 				const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
-				const isBackgroundRunning = asyncState === "running";
-				component.updateResult({ ...event.result, isError: event.isError }, isBackgroundRunning, event.toolCallId);
-				if (isBackgroundRunning) {
-					this.#backgroundToolCallIds.add(event.toolCallId);
+				const isBackgroundTask = event.toolName === "task" && asyncState === "running";
+				component.updateResult({ ...event.result, isError: event.isError }, isBackgroundTask, event.toolCallId);
+				if (isBackgroundTask) {
+					this.#backgroundTaskCallIds.add(event.toolCallId);
 				} else {
 					this.ctx.pendingTools.delete(event.toolCallId);
-					this.#backgroundToolCallIds.delete(event.toolCallId);
+					this.#backgroundTaskCallIds.delete(event.toolCallId);
 				}
 				if (component instanceof ToolExecutionComponent && component.isDisplaceableBlock()) {
 					if (event.toolName === "job" && component.canBeDisplacedBy("job")) {
@@ -1098,7 +1085,7 @@ export class EventController {
 		}
 		await this.ctx.flushPendingModelSwitch();
 		for (const toolCallId of Array.from(this.ctx.pendingTools.keys())) {
-			if (!this.#backgroundToolCallIds.has(toolCallId)) {
+			if (!this.#backgroundTaskCallIds.has(toolCallId)) {
 				// A foreground tool still pending at turn end never delivered a result;
 				// seal it so it freezes (and stops animating) rather than lingering in
 				// the transcript live region as a streaming preview until the next thaw.
@@ -1112,8 +1099,8 @@ export class EventController {
 				this.ctx.pendingTools.delete(toolCallId);
 			}
 		}
-		this.#backgroundToolCallIds = new Set(
-			Array.from(this.#backgroundToolCallIds).filter(toolCallId => this.ctx.pendingTools.has(toolCallId)),
+		this.#backgroundTaskCallIds = new Set(
+			Array.from(this.#backgroundTaskCallIds).filter(toolCallId => this.ctx.pendingTools.has(toolCallId)),
 		);
 		this.#readToolCallArgs.clear();
 		this.#readToolCallAssistantComponents.clear();
@@ -1247,7 +1234,19 @@ export class EventController {
 			this.ctx.lastAssistantUsage = undefined;
 			this.ctx.rebuildChatFromMessages();
 			this.ctx.statusLine.invalidate();
-			this.ctx.ui.requestRender();
+			// When history collapses behind the summary divider, the frame
+			// shrinks far below the committed row count; without clearing, the
+			// differential renderer's "duplication, never loss" resync repaints
+			// the whole collapsed transcript (welcome box included) BELOW the
+			// stale pre-compaction scrollback. Compaction is an intentional
+			// transcript replacement then — same as auto-handoff below. With
+			// collapse disabled the rebuilt transcript keeps the full history,
+			// so the resync handles it and scrollback stays.
+			if (settings.get("display.collapseCompacted")) {
+				this.ctx.ui.requestRender(true, { clearScrollback: true });
+			} else {
+				this.ctx.ui.requestRender();
+			}
 		} else if (event.errorMessage) {
 			this.ctx.showWarning(event.errorMessage);
 		} else if (isHandoffAction) {

package/src/modes/controllers/selector-controller.ts

@@ -67,10 +67,12 @@ import { ExtensionDashboard } from "../components/extensions";
 import { HistorySearchComponent } from "../components/history-search";
 import { LoginDialogComponent } from "../components/login-dialog";
 import { LogoutAccountSelectorComponent } from "../components/logout-account-selector";
-import { ModelHubComponent, type ModelHubMode } from "../components/model-hub";
+import { ModelHubComponent } from "../components/model-hub";
+import { ModelPickerComponent } from "../components/model-picker";
 import { OAuthSelectorComponent } from "../components/oauth-selector";
 import { PluginSelectorComponent } from "../components/plugin-selector";
 import { ResetUsageSelectorComponent } from "../components/reset-usage-selector";
+import { renderSegmentTrack } from "../components/segment-track";
 import { SessionSelectorComponent } from "../components/session-selector";
 import { SettingsSelectorComponent } from "../components/settings-selector";
 import { ToolExecutionComponent } from "../components/tool-execution";
@@ -451,12 +453,23 @@ export class SelectorController {
 				this.ctx.rebuildChatFromMessages();
 				this.ctx.ui.resetDisplay();
 				break;
+			case "display.collapseCompacted":
+				// Rebuild swaps between the collapsed tail and the full inline
+				// history; full reset retires blocks already committed to native
+				// scrollback (mirrors cacheMissMarker).
+				this.ctx.rebuildChatFromMessages();
+				this.ctx.ui.resetDisplay();
+				break;
 			case "tui.tight":
 				setTuiTight(value as boolean);
 				this.ctx.ui.invalidate();
 				this.ctx.ui.requestRender();
 				break;
 
+			case "tui.scrollbackRebuild":
+				this.ctx.ui.setScrollbackRebuild(value as boolean);
+				break;
+
 			case "tui.renderMermaid":
 				setMarkdownMermaidRendering(value as boolean);
 				this.ctx.session.refreshBaseSystemPrompt().catch(err => {
@@ -586,7 +599,85 @@ export class SelectorController {
 	}
 
 	showModelSelector(options?: { temporaryOnly?: boolean }): void {
-		this.#showModelHub({ mode: options?.temporaryOnly ? "pick" : "roles" });
+		if (options?.temporaryOnly) {
+			this.#showModelPicker();
+			return;
+		}
+		this.#showModelHub({});
+	}
+
+	/**
+	 * Compact session-only model picker (alt+p / `/switch`): a floating
+	 * bottom-anchored overlay over the transcript. The current model is
+	 * highlighted and preselected; a leading `@` searches ctrl+p quick roles.
+	 */
+	#showModelPicker(): void {
+		const currentContextTokens = this.ctx.session.getContextUsage()?.tokens ?? 0;
+		const current = this.ctx.session.model;
+		const quickRoleOrder = this.ctx.settings.get("cycleOrder");
+		const quickRoleCycle = this.ctx.session.getRoleModelCycle(quickRoleOrder);
+		let overlayHandle: OverlayHandle | undefined;
+		let closed = false;
+		const done = () => {
+			if (closed) return;
+			closed = true;
+			overlayHandle?.hide();
+			this.focusActiveEditorArea();
+			this.ctx.ui.requestRender();
+		};
+		const picker = new ModelPickerComponent(
+			this.ctx.ui,
+			this.ctx.settings,
+			this.ctx.session.modelRegistry,
+			this.ctx.session.scopedModels,
+			{
+				onPick: async (model, selector) => {
+					try {
+						// Session-only: update agent state but don't persist the model to settings.
+						await this.ctx.session.setModelTemporary(model);
+						this.ctx.statusLine.invalidate();
+						this.ctx.updateEditorBorderColor();
+						const roleSelectorHint = this.ctx.keybindings.getKeys("app.model.select")[0] ?? "Alt+M";
+						this.ctx.showStatus(`Session-only model: ${selector}. Use ${roleSelectorHint} or /model for roles.`);
+						done();
+					} catch (error) {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					}
+				},
+				onPickRole: async entry => {
+					try {
+						await this.ctx.session.applyRoleModel(entry);
+						this.ctx.statusLine.invalidate();
+						this.ctx.updateEditorBorderColor();
+						this.ctx.showModelCycleTrack(
+							renderSegmentTrack(
+								quickRoleOrder.map(role => ({ label: role })),
+								quickRoleOrder.indexOf(entry.role),
+							),
+						);
+						done();
+					} catch (error) {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					}
+				},
+				onCancel: done,
+			},
+			{
+				currentContextTokens,
+				currentSelector: current ? `${current.provider}/${current.id}` : undefined,
+				quickRoles: quickRoleCycle?.models,
+				quickRoleOrder,
+				currentQuickRole: quickRoleCycle?.models[quickRoleCycle.currentIndex]?.role,
+			},
+		);
+		overlayHandle = this.ctx.ui.showOverlay(picker, {
+			anchor: "bottom-center",
+			width: "100%",
+			maxHeight: "100%",
+			margin: 0,
+		});
+		this.ctx.ui.setFocus(picker);
+		this.ctx.ui.requestRender();
 	}
 
 	/**
@@ -595,13 +686,13 @@ export class SelectorController {
 	 * untouched underneath. `initialProviderId` preselects a provider's sidebar
 	 * entry — used when reopening the hub after a /login round-trip.
 	 */
-	#showModelHub(hubOptions: { mode: ModelHubMode; initialProviderId?: string }): void {
+	#showModelHub(hubOptions: { initialProviderId?: string }): void {
 		const currentContextTokens = this.ctx.session.getContextUsage()?.tokens ?? 0;
 		let overlayHandle: OverlayHandle | undefined;
 		let hub: ModelHubComponent | undefined;
 		let closed = false;
 		const done = () => {
-			// Re-entrant guard: cancel paths (Esc, pick, login forward) may race;
+			// Re-entrant guard: cancel paths (Esc, login forward) may race;
 			// the overlay must hide exactly once.
 			if (closed) return;
 			closed = true;
@@ -686,21 +777,6 @@ export class SelectorController {
 						this.ctx.showError(error instanceof Error ? error.message : String(error));
 					}
 				},
-				onPick: async (model, selector) => {
-					try {
-						// Session-only: update agent state but don't persist the model to settings.
-						await this.ctx.session.setModelTemporary(model);
-						this.ctx.statusLine.invalidate();
-						this.ctx.updateEditorBorderColor();
-						const roleSelectorHint = this.ctx.keybindings.getKeys("app.model.select")[0] ?? "Alt+M";
-						this.ctx.showStatus(
-							`Session-only model: ${selector ?? model.id}. Use ${roleSelectorHint} or /model for roles.`,
-						);
-						done();
-					} catch (error) {
-						this.ctx.showError(error instanceof Error ? error.message : String(error));
-					}
-				},
 				onLoginRequest: providerId => {
 					done();
 					void this.#loginThenReopenModelHub(providerId);
@@ -718,8 +794,6 @@ export class SelectorController {
 				onCancel: () => done(),
 			},
 			{
-				mode: hubOptions.mode,
-				currentContextTokens,
 				initialProviderId: hubOptions.initialProviderId,
 			},
 		);
@@ -738,7 +812,7 @@ export class SelectorController {
 	async #loginThenReopenModelHub(providerId: string): Promise<void> {
 		const succeeded = await this.#handleOAuthLogin(providerId);
 		if (succeeded) {
-			this.#showModelHub({ mode: "roles", initialProviderId: providerId });
+			this.#showModelHub({ initialProviderId: providerId });
 		}
 	}
 

package/src/modes/controllers/tan-command-controller.ts

@@ -3,12 +3,14 @@ import * as path from "node:path";
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { prompt, Snowflake } from "@oh-my-pi/pi-utils";
 import backgroundTanDispatchPrompt from "../../prompts/system/background-tan-dispatch.md" with { type: "text" };
+import tanContextSwitchPrompt from "../../prompts/system/tan-context-switch.md" with { type: "text" };
 import { AgentRegistry, MAIN_AGENT_ID } from "../../registry/agent-registry";
 import * as sdk from "../../sdk";
 import type { AgentSession } from "../../session/agent-session";
 import { BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE } from "../../session/messages";
 import { SessionManager } from "../../session/session-manager";
 import { createMCPProxyTools, createSubagentSettings } from "../../task/executor";
+import { USER_TODO_EDIT_CUSTOM_TYPE } from "../../tools/todo";
 import type { InteractiveModeContext } from "../types";
 
 const TAN_LABEL_PREVIEW_LENGTH = 80;
@@ -66,6 +68,11 @@ export class TanCommandController {
 		}
 
 		const parentSessionId = session.sessionId;
+		// Providers route on `promptCacheKey ?? sessionId`, so the parent's live
+		// requests may cache under a pinned key that differs from its session id
+		// (the parent being itself a fork/tan). Mirror exactly what the parent
+		// populated the cache under — same rule as advisor and handoff calls.
+		const parentPromptCacheKey = session.agent.promptCacheKey ?? parentSessionId;
 		const thinkingLevel = session.configuredThinkingLevel();
 		const systemPrompt = [...session.systemPrompt];
 		const toolNames = session.getActiveToolNames();
@@ -111,7 +118,7 @@ export class TanCommandController {
 							systemPrompt,
 							toolNames,
 							providerSessionId: `${parentSessionId}:tan:${Snowflake.next()}`,
-							providerPromptCacheKey: parentSessionId,
+							providerPromptCacheKey: parentPromptCacheKey,
 							modelRegistry,
 							authStorage: modelRegistry.authStorage,
 							settings,
@@ -127,19 +134,51 @@ export class TanCommandController {
 							disableExtensionDiscovery: true,
 						});
 						clone = created.session;
+						clone.sessionManager?.appendSessionInit?.({
+							systemPrompt: clone.systemPrompt ? clone.systemPrompt.join("\n\n") : systemPrompt.join("\n\n"),
+							task: trimmedWork,
+							tools: clone.getActiveToolNames ? clone.getActiveToolNames() : toolNames,
+						});
 						const abortClone = () => {
 							void clone?.abort();
 						};
 						signal.addEventListener("abort", abortClone, { once: true });
+						// The fork inherits the parent's todo list via session entries;
+						// its reminders would drag the tan back onto the parent's task.
+						// Clear runtime state and persist an empty edit so reloads agree.
+						clone.setTodoPhases([]);
+						cloneManager.appendCustomEntry(USER_TODO_EDIT_CUSTOM_TYPE, { phases: [] });
+						const injectContextSwitch = () => {
+							clone?.agent.appendMessage({
+								role: "developer",
+								content: tanContextSwitchPrompt,
+								attribution: "agent",
+								timestamp: Date.now(),
+							});
+						};
+						// Compaction summarizes the fork notice away with the rest of the
+						// history, after which the clone re-adopts the parent's task as its
+						// own (the summary blends both). Re-inject after every successful
+						// compaction so the fork boundary survives summarization.
+						const unsubscribeCompaction = clone.subscribe(event => {
+							if (event.type === "auto_compaction_end" && event.result && !event.aborted) {
+								injectContextSwitch();
+							}
+						});
 						try {
 							if (signal.aborted) {
 								abortClone();
 								throw new Error("Aborted before execution");
 							}
+							// Inject a context-switch developer message so the clone knows
+							// it is a tangential fork — its parent owns the prior conversation;
+							// this agent must focus exclusively on the user's request.
+							injectContextSwitch();
 							await clone.prompt(trimmedWork, { attribution: "user" });
 							await clone.waitForIdle();
 							return extractAssistantText(clone.getLastAssistantMessage()) || "(no output)";
 						} finally {
+							unsubscribeCompaction();
 							signal.removeEventListener("abort", abortClone);
 						}
 					} finally {