@oh-my-pi/pi-coding-agent 11.2.3 → 11.3.0

package/src/modes/rpc/rpc-mode.ts

@@ -286,6 +286,15 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			return Promise.resolve({ success: false, error: "Theme switching not supported in RPC mode" });
 		}
 
+		getToolsExpanded() {
+			// Tool expansion not supported in RPC mode - no TUI
+			return false;
+		}
+
+		setToolsExpanded(_expanded: boolean) {
+			// Tool expansion not supported in RPC mode - no TUI
+		}
+
 		setEditorComponent(): void {
 			// Custom editor components not supported in RPC mode
 		}
@@ -316,6 +325,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				getActiveTools: () => session.getActiveToolNames(),
 				getAllTools: () => session.getAllToolNames(),
 				setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
+				getCommands: () => [],
 				setModel: async model => {
 					const key = await session.modelRegistry.getApiKey(model);
 					if (!key) return false;
@@ -335,6 +345,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					shutdownState.requested = true;
 				},
 				getContextUsage: () => session.getContextUsage(),
+				getSystemPrompt: () => session.systemPrompt,
 				compact: async instructionsOrOptions => {
 					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
 					const options =
@@ -364,6 +375,10 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					const result = await session.navigateTree(targetId, { summarize: options?.summarize });
 					return { cancelled: result.cancelled };
 				},
+				switchSession: async sessionPath => {
+					const success = await session.switchSession(sessionPath);
+					return { cancelled: !success };
+				},
 				compact: async instructionsOrOptions => {
 					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
 					const options =
@@ -412,12 +427,12 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			}
 
 			case "steer": {
-				await session.steer(command.message);
+				await session.steer(command.message, command.images);
 				return success(id, "steer");
 			}
 
 			case "follow_up": {
-				await session.followUp(command.message);
+				await session.followUp(command.message, command.images);
 				return success(id, "follow_up");
 			}
 

package/src/modes/rpc/rpc-types.ts

@@ -17,8 +17,8 @@ import type { CompactionResult } from "../../session/compaction";
 export type RpcCommand =
 	// Prompting
 	| { id?: string; type: "prompt"; message: string; images?: ImageContent[]; streamingBehavior?: "steer" | "followUp" }
-	| { id?: string; type: "steer"; message: string }
-	| { id?: string; type: "follow_up"; message: string }
+	| { id?: string; type: "steer"; message: string; images?: ImageContent[] }
+	| { id?: string; type: "follow_up"; message: string; images?: ImageContent[] }
 	| { id?: string; type: "abort" }
 	| { id?: string; type: "new_session"; parentSession?: string }
 

package/src/modes/types.ts

@@ -176,6 +176,7 @@ export interface InteractiveModeContext {
 	cycleThinkingLevel(): void;
 	cycleRoleModel(options?: { temporary?: boolean }): Promise<void>;
 	toggleToolOutputExpansion(): void;
+	setToolsExpanded(expanded: boolean): void;
 	toggleThinkingBlockVisibility(): void;
 	openExternalEditor(): void;
 	registerExtensionShortcuts(): void;

package/src/modes/utils/ui-helpers.ts

@@ -203,7 +203,9 @@ export class UiHelpers {
 
 				// Render tool call components
 				for (const content of message.content) {
-					if (content.type !== "toolCall") continue;
+					if (content.type !== "toolCall") {
+						continue;
+					}
 
 					if (content.name === "read") {
 						if (!readGroup) {

package/src/patch/applicator.ts

@@ -434,8 +434,7 @@ function formatSequenceMatchPreview(lines: string[], startIdx: number): string {
 	return previewLines
 		.map((line, i) => {
 			const num = start + i + 1;
-			const truncated =
-				line.length > MATCH_PREVIEW_MAX_LEN ? `${line.slice(0, MATCH_PREVIEW_MAX_LEN - 3)}...` : line;
+			const truncated = line.length > MATCH_PREVIEW_MAX_LEN ? `${line.slice(0, MATCH_PREVIEW_MAX_LEN - 1)}…` : line;
 			return `  ${num} | ${truncated}`;
 		})
 		.join("\n");
@@ -1103,7 +1102,7 @@ function computeReplacements(
 					return lines
 						.map((line, i) => {
 							const num = start + i + 1;
-							const truncated = line.length > maxLineLength ? `${line.slice(0, maxLineLength - 3)}...` : line;
+							const truncated = line.length > maxLineLength ? `${line.slice(0, maxLineLength - 1)}…` : line;
 							return `  ${num} | ${truncated}`;
 						})
 						.join("\n");

package/src/patch/fuzzy.ts

@@ -241,7 +241,7 @@ export function findMatch(
 				const preview = previewLines
 					.map((line, idx) => {
 						const num = start + idx + 1;
-						return `  ${num} | ${line.length > OCCURRENCE_PREVIEW_MAX_LEN ? `${line.slice(0, OCCURRENCE_PREVIEW_MAX_LEN - 3)}...` : line}`;
+						return `  ${num} | ${line.length > OCCURRENCE_PREVIEW_MAX_LEN ? `${line.slice(0, OCCURRENCE_PREVIEW_MAX_LEN - 1)}…` : line}`;
 					})
 					.join("\n");
 				occurrencePreviews.push(preview);

package/src/patch/shared.ts

@@ -13,12 +13,13 @@ import {
 	formatExpandHint,
 	formatStatusIcon,
 	getDiffStats,
+	PREVIEW_LIMITS,
 	shortenPath,
 	ToolUIKit,
 	truncateDiffByHunk,
 } from "../tools/render-utils";
 import type { RenderCallOptions } from "../tools/renderers";
-import { renderStatusLine } from "../tui";
+import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
 import type { DiffError, DiffResult, Operation } from "./types";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -85,8 +86,6 @@ export interface EditRenderContext {
 	renderDiff?: (diffText: string, options?: { filePath?: string }) => string;
 }
 
-const EDIT_DIFF_PREVIEW_HUNKS = 2;
-const EDIT_DIFF_PREVIEW_LINES = 24;
 const EDIT_STREAMING_PREVIEW_LINES = 12;
 
 function countLines(text: string): number {
@@ -140,7 +139,7 @@ function renderDiffSection(
 		hiddenLines,
 	} = expanded
 		? { text: diff, hiddenHunks: 0, hiddenLines: 0 }
-		: truncateDiffByHunk(diff, EDIT_DIFF_PREVIEW_HUNKS, EDIT_DIFF_PREVIEW_LINES);
+		: truncateDiffByHunk(diff, PREVIEW_LIMITS.DIFF_COLLAPSED_HUNKS, PREVIEW_LIMITS.DIFF_COLLAPSED_LINES);
 
 	text += `\n\n${renderDiffFn(truncatedDiff, { filePath: rawPath })}`;
 	if (!expanded && (hiddenHunks > 0 || hiddenLines > 0)) {
@@ -209,75 +208,89 @@ export const editToolRenderer = {
 		args?: EditRenderArgs,
 	): Component {
 		const ui = new ToolUIKit(uiTheme);
-		const { expanded, renderContext } = options;
 		const rawPath = args?.file_path || args?.path || "";
 		const filePath = shortenPath(rawPath);
 		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
 		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
-		const editDiffPreview = renderContext?.editDiffPreview;
-		const renderDiffFn = renderContext?.renderDiff ?? ((t: string) => t);
 
-		// Get op and rename from args or details
 		const op = args?.op || result.details?.op;
 		const rename = args?.rename || result.details?.rename;
+		const opTitle = op === "create" ? "Create" : op === "delete" ? "Delete" : "Edit";
 
-		// Build path display with line number if available
-		let pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
-		const firstChangedLine =
-			(editDiffPreview && "firstChangedLine" in editDiffPreview ? editDiffPreview.firstChangedLine : undefined) ||
-			(result.details && !result.isError ? result.details.firstChangedLine : undefined);
-		if (firstChangedLine) {
-			pathDisplay += uiTheme.fg("warning", `:${firstChangedLine}`);
-		}
+		// Pre-compute metadata line (static across renders)
+		const metadataLine =
+			op !== "delete"
+				? `\n${formatMetadataLine(countLines(args?.newText ?? args?.oldText ?? args?.diff ?? args?.patch ?? ""), editLanguage, uiTheme)}`
+				: "";
 
-		// Add arrow for rename operations
-		if (rename) {
-			pathDisplay += ` ${uiTheme.fg("dim", "→")} ${uiTheme.fg("accent", shortenPath(rename))}`;
-		}
+		// Pre-compute error text (static)
+		const errorText = result.isError ? (result.content?.find(c => c.type === "text")?.text ?? "") : "";
 
-		// Show operation type for patch mode
-		const opTitle = op === "create" ? "Create" : op === "delete" ? "Delete" : "Edit";
-		const header = renderStatusLine(
-			{
-				icon: result.isError ? "error" : "success",
-				title: opTitle,
-				description: `${editIcon} ${pathDisplay}`,
-			},
-			uiTheme,
-		);
-		let text = header;
-
-		// Skip metadata line for delete operations
-		if (op !== "delete") {
-			const editLineCount = countLines(args?.newText ?? args?.oldText ?? args?.diff ?? args?.patch ?? "");
-			text += `\n${formatMetadataLine(editLineCount, editLanguage, uiTheme)}`;
-		}
+		let cached: RenderCache | undefined;
 
-		if (result.isError) {
-			// Show error from result
-			const errorText = result.content?.find(c => c.type === "text")?.text ?? "";
-			if (errorText) {
-				text += `\n\n${uiTheme.fg("error", errorText)}`;
-			}
-		} else if (result.details?.diff) {
-			// Prefer actual diff after execution
-			text += renderDiffSection(result.details.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
-		} else if (editDiffPreview) {
-			// Use cached diff preview when no actual diff is available
-			if ("error" in editDiffPreview) {
-				text += `\n\n${uiTheme.fg("error", editDiffPreview.error)}`;
-			} else if (editDiffPreview.diff) {
-				text += renderDiffSection(editDiffPreview.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
-			}
-		}
+		return {
+			render(width) {
+				const { expanded, renderContext } = options;
+				const editDiffPreview = renderContext?.editDiffPreview;
+				const renderDiffFn = renderContext?.renderDiff ?? ((t: string) => t);
+				const key = new Hasher().bool(expanded).u32(width).digest();
+				if (cached?.key === key) return cached.lines;
 
-		// Show LSP diagnostics if available
-		if (result.details?.diagnostics) {
-			text += ui.formatDiagnostics(result.details.diagnostics, expanded, (fp: string) =>
-				uiTheme.getLangIcon(getLanguageFromPath(fp)),
-			);
-		}
+				// Build path display with line number
+				let pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
+				const firstChangedLine =
+					(editDiffPreview && "firstChangedLine" in editDiffPreview
+						? editDiffPreview.firstChangedLine
+						: undefined) || (result.details && !result.isError ? result.details.firstChangedLine : undefined);
+				if (firstChangedLine) {
+					pathDisplay += uiTheme.fg("warning", `:${firstChangedLine}`);
+				}
 
-		return new Text(text, 0, 0);
+				// Add arrow for rename operations
+				if (rename) {
+					pathDisplay += ` ${uiTheme.fg("dim", "→")} ${uiTheme.fg("accent", shortenPath(rename))}`;
+				}
+
+				const header = renderStatusLine(
+					{
+						icon: result.isError ? "error" : "success",
+						title: opTitle,
+						description: `${editIcon} ${pathDisplay}`,
+					},
+					uiTheme,
+				);
+				let text = header;
+				text += metadataLine;
+
+				if (result.isError) {
+					if (errorText) {
+						text += `\n\n${uiTheme.fg("error", errorText)}`;
+					}
+				} else if (result.details?.diff) {
+					text += renderDiffSection(result.details.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
+				} else if (editDiffPreview) {
+					if ("error" in editDiffPreview) {
+						text += `\n\n${uiTheme.fg("error", editDiffPreview.error)}`;
+					} else if (editDiffPreview.diff) {
+						text += renderDiffSection(editDiffPreview.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
+					}
+				}
+
+				// Show LSP diagnostics if available
+				if (result.details?.diagnostics) {
+					text += ui.formatDiagnostics(result.details.diagnostics, expanded, (fp: string) =>
+						uiTheme.getLangIcon(getLanguageFromPath(fp)),
+					);
+				}
+
+				const lines =
+					width > 0 ? text.split("\n").map(line => truncateToWidth(line, width, Ellipsis.Omit)) : text.split("\n");
+				cached = { key, lines };
+				return lines;
+			},
+			invalidate() {
+				cached = undefined;
+			},
+		};
 	},
 };

package/src/prompts/system/system-prompt.md

@@ -221,6 +221,7 @@ Main branch: {{git.mainBranch}}
 {{#if skills.length}}
 <skills>
 Scan descriptions vs domain. Skill covers output? Read `skill://<name>` first.
+When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.
 
 {{#list skills join="\n"}}
 <skill name="{{name}}">

package/src/prompts/tools/task.md

@@ -70,6 +70,10 @@ Run in isolated git worktree; returns patches. Use when tasks edit overlapping f
 ### `schema` (optional — recommended for structured output)
 
 JTD schema defining expected response structure. Use typed properties. If you care about parsing result, define here — **never describe output format in `context` or `assignment`**.
+
+<caution>
+**Schema vs agent mismatch causes null output.** Agents with `output="structured"` (e.g., `explore`) have a built-in schema. If you also pass `schema`, yours takes precedence — but if you describe output format in `context`/`assignment` instead, the agent's built-in schema wins. The agent gets confused trying to fit your requested format into its schema shape and submits `null`. Either: (1) use `schema` to override the built-in one, (2) use `task` agent which has no built-in schema, or (3) match your instructions to the agent's expected output shape.
+</caution>
 ---
 
 ## Writing an assignment
@@ -115,6 +119,8 @@ Use structure every assignment:
 - "No WASM."
 
 If tempted to write above, expand using templates.
+**Output format in prose instead of `schema`** — agent returns null:
+Structured agents (`explore`, `reviewer`) have built-in output schemas. Describing a different output format in `context`/`assignment` without overriding via `schema` creates a mismatch — the agent can't reconcile your prose instructions with its schema and submits null data. Always use `schema` for output structure, or pick an agent whose built-in schema matches your needs.
 **Test/lint commands in parallel tasks** — edit wars:
 Parallel agents share working tree. If two agents run `bun check` or `bun test` concurrently, they see each other's half-finished edits, "fix" phantom errors, loop. **Never tell parallel tasks run project-wide build/test/lint commands.** Each task edits, stops. Caller verifies after all tasks complete.
 **If you can’t specify scope yet**, create **Discovery task** first: enumerate files, find callsites, list candidates. Then fan out with explicit paths.

package/src/sdk.ts

@@ -387,7 +387,7 @@ function customToolToDefinition(tool: CustomTool): ToolDefinition {
 		label: tool.label,
 		description: tool.description,
 		parameters: tool.parameters,
-		execute: (toolCallId, params, onUpdate, ctx, signal) =>
+		execute: (toolCallId, params, signal, onUpdate, ctx) =>
 			tool.execute(toolCallId, params, onUpdate, createCustomToolContext(ctx), signal),
 		onSession: tool.onSession ? (event, ctx) => tool.onSession?.(event, createCustomToolContext(ctx)) : undefined,
 		renderCall: tool.renderCall,
@@ -506,6 +506,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const existingSession = sessionManager.buildSessionContext();
 	time("loadSession");
 	const hasExistingSession = existingSession.messages.length > 0;
+	const hasThinkingEntry = sessionManager.getBranch().some(entry => entry.type === "thinking_level_change");
 
 	const hasExplicitModel = options.model !== undefined;
 	let model = options.model;
@@ -563,7 +564,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// If session has data, restore thinking level from it
 	if (thinkingLevel === undefined && hasExistingSession) {
-		thinkingLevel = existingSession.thinkingLevel as ThinkingLevel;
+		thinkingLevel = hasThinkingEntry
+			? (existingSession.thinkingLevel as ThinkingLevel)
+			: ((settingsInstance.get("defaultThinkingLevel") ?? "off") as ThinkingLevel);
 	}
 
 	// Fall back to settings default
@@ -698,7 +701,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			onConnecting: serverNames => {
 				if (options.hasUI && serverNames.length > 0) {
 					process.stderr.write(
-						chalk.gray(`Connecting to MCP servers: ${serverNames.join(", ")}...
+						chalk.gray(`Connecting to MCP servers: ${serverNames.join(", ")}…
 `),
 					);
 				}
@@ -1016,14 +1019,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		thinkingBudgets: settingsInstance.getGroup("thinkingBudgets"),
 		kimiApiFormat: settingsInstance.get("providers.kimiApiFormat") ?? "anthropic",
 		getToolContext: tc => toolContextStore.getContext(tc),
-		getApiKey: async () => {
-			const currentModel = agent.state.model;
-			if (!currentModel) {
-				throw new Error("No model selected");
-			}
-			const key = await modelRegistry.getApiKey(currentModel, sessionId);
+		getApiKey: async provider => {
+			// Use the provider argument from the in-flight request;
+			// agent.state.model may already be switched mid-turn.
+			const key = await modelRegistry.getApiKeyForProvider(provider, sessionId);
 			if (!key) {
-				throw new Error(`No API key found for provider "${currentModel.provider}"`);
+				throw new Error(`No API key found for provider "${provider}"`);
 			}
 			return key;
 		},
@@ -1036,6 +1037,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// Restore messages if session has existing data
 	if (hasExistingSession) {
 		agent.replaceMessages(existingSession.messages);
+		if (!hasThinkingEntry) {
+			sessionManager.appendThinkingLevelChange(thinkingLevel);
+		}
 	} else {
 		// Save initial model and thinking level for new sessions so they can be restored on resume
 		if (model) {
@@ -1072,7 +1076,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			const result = await warmupLspServers(cwd, {
 				onConnecting: serverNames => {
 					if (options.hasUI && serverNames.length > 0) {
-						process.stderr.write(chalk.gray(`Starting LSP servers: ${serverNames.join(", ")}...\n`));
+						process.stderr.write(chalk.gray(`Starting LSP servers: ${serverNames.join(", ")}…\n`));
 					}
 				},
 			});

package/src/session/agent-session.ts

@@ -237,6 +237,8 @@ const noOpUIContext: ExtensionUIContext = {
 	setFooter: () => {},
 	setHeader: () => {},
 	setEditorComponent: () => {},
+	getToolsExpanded: () => false,
+	setToolsExpanded: () => {},
 };
 
 async function cleanupSshResources(): Promise<void> {
@@ -906,6 +908,11 @@ export class AgentSession {
 		return this.agent.state.isStreaming || this._promptInFlight;
 	}
 
+	/** Current effective system prompt (includes any per-turn extension modifications) */
+	get systemPrompt(): string {
+		return this.agent.state.systemPrompt;
+	}
+
 	/** Current retry attempt (0 if not retrying) */
 	get retryAttempt(): number {
 		return this._retryAttempt;
@@ -1426,6 +1433,11 @@ export class AgentSession {
 					instructionsOrOptions && typeof instructionsOrOptions === "object" ? instructionsOrOptions : undefined;
 				await this.compact(instructions, options);
 			},
+			switchSession: async sessionPath => {
+				const success = await this.switchSession(sessionPath);
+				return { cancelled: !success };
+			},
+			getSystemPrompt: () => this.systemPrompt,
 		};
 	}
 
@@ -1477,25 +1489,25 @@ export class AgentSession {
 	/**
 	 * Queue a steering message to interrupt the agent mid-run.
 	 */
-	async steer(text: string): Promise<void> {
+	async steer(text: string, images?: ImageContent[]): Promise<void> {
 		if (text.startsWith("/")) {
 			this._throwIfExtensionCommand(text);
 		}
 
 		const expandedText = expandPromptTemplate(text, [...this._promptTemplates]);
-		await this._queueSteer(expandedText);
+		await this._queueSteer(expandedText, images);
 	}
 
 	/**
 	 * Queue a follow-up message to process after the agent would otherwise stop.
 	 */
-	async followUp(text: string): Promise<void> {
+	async followUp(text: string, images?: ImageContent[]): Promise<void> {
 		if (text.startsWith("/")) {
 			this._throwIfExtensionCommand(text);
 		}
 
 		const expandedText = expandPromptTemplate(text, [...this._promptTemplates]);
-		await this._queueFollowUp(expandedText);
+		await this._queueFollowUp(expandedText, images);
 	}
 
 	/**
@@ -1733,6 +1745,9 @@ export class AgentSession {
 		this._steeringMessages = [];
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
+
+		this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
+
 		this._todoReminderCount = 0;
 		this._planReferenceSent = false;
 		this._reconnectToAgent();
@@ -1934,22 +1949,39 @@ export class AgentSession {
 		return { model: next.model, thinkingLevel: this.thinkingLevel, role: next.role };
 	}
 
+	private async _getScopedModelsWithApiKey(): Promise<Array<{ model: Model; thinkingLevel: ThinkingLevel }>> {
+		const apiKeysByProvider = new Map<string, string | undefined>();
+		const result: Array<{ model: Model; thinkingLevel: ThinkingLevel }> = [];
+
+		for (const scoped of this._scopedModels) {
+			const provider = scoped.model.provider;
+			let apiKey: string | undefined;
+			if (apiKeysByProvider.has(provider)) {
+				apiKey = apiKeysByProvider.get(provider);
+			} else {
+				apiKey = await this._modelRegistry.getApiKeyForProvider(provider, this.sessionId);
+				apiKeysByProvider.set(provider, apiKey);
+			}
+
+			if (apiKey) {
+				result.push(scoped);
+			}
+		}
+
+		return result;
+	}
+
 	private async _cycleScopedModel(direction: "forward" | "backward"): Promise<ModelCycleResult | undefined> {
-		if (this._scopedModels.length <= 1) return undefined;
+		const scopedModels = await this._getScopedModelsWithApiKey();
+		if (scopedModels.length <= 1) return undefined;
 
 		const currentModel = this.model;
-		let currentIndex = this._scopedModels.findIndex(sm => modelsAreEqual(sm.model, currentModel));
+		let currentIndex = scopedModels.findIndex(sm => modelsAreEqual(sm.model, currentModel));
 
 		if (currentIndex === -1) currentIndex = 0;
-		const len = this._scopedModels.length;
+		const len = scopedModels.length;
 		const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
-		const next = this._scopedModels[nextIndex];
-
-		// Validate API key
-		const apiKey = await this._modelRegistry.getApiKey(next.model, this.sessionId);
-		if (!apiKey) {
-			throw new Error(`No API key for ${next.model.provider}/${next.model.id}`);
-		}
+		const next = scopedModels[nextIndex];
 
 		// Apply model
 		this.agent.setModel(next.model);
@@ -2005,15 +2037,22 @@ export class AgentSession {
 	/**
 	 * Set thinking level.
 	 * Clamps to model capabilities based on available thinking levels.
-	 * Saves to session, with optional persistence to settings.
+	 * Saves to session and settings only if the level actually changes.
 	 */
 	setThinkingLevel(level: ThinkingLevel, persist: boolean = false): void {
 		const availableLevels = this.getAvailableThinkingLevels();
 		const effectiveLevel = availableLevels.includes(level) ? level : this._clampThinkingLevel(level, availableLevels);
+
+		// Only persist if actually changing
+		const isChanging = effectiveLevel !== this.agent.state.thinkingLevel;
+
 		this.agent.setThinkingLevel(effectiveLevel);
-		this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-		if (persist) {
-			this.settings.set("defaultThinkingLevel", effectiveLevel);
+
+		if (isChanging) {
+			this.sessionManager.appendThinkingLevelChange(effectiveLevel);
+			if (persist) {
+				this.settings.set("defaultThinkingLevel", effectiveLevel);
+			}
 		}
 	}
 
@@ -2903,8 +2942,8 @@ Be thorough - include exact file paths, function names, error messages, and tech
 	}
 
 	private _isRetryableErrorMessage(errorMessage: string): boolean {
-		// Match: overloaded_error, rate limit, usage limit, 429, 500, 502, 503, 504, service unavailable, connection error, fetch failed
-		return /overloaded|rate.?limit|usage.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|fetch failed/i.test(
+		// Match: overloaded_error, rate limit, usage limit, 429, 500, 502, 503, 504, service unavailable, connection error, fetch failed, retry delay exceeded
+		return /overloaded|rate.?limit|usage.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|fetch failed|retry delay/i.test(
 			errorMessage,
 		);
 	}
@@ -3354,9 +3393,19 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			}
 		}
 
-		// Restore thinking level if saved (setThinkingLevel clamps to model capabilities)
-		if (sessionContext.thinkingLevel) {
+		const hasThinkingEntry = this.sessionManager.getBranch().some(entry => entry.type === "thinking_level_change");
+		const defaultThinkingLevel = (this.settings.get("defaultThinkingLevel") ?? "off") as ThinkingLevel;
+
+		if (hasThinkingEntry) {
+			// Restore thinking level if saved (setThinkingLevel clamps to model capabilities)
 			this.setThinkingLevel(sessionContext.thinkingLevel as ThinkingLevel);
+		} else {
+			const availableLevels = this.getAvailableThinkingLevels();
+			const effectiveLevel = availableLevels.includes(defaultThinkingLevel)
+				? defaultThinkingLevel
+				: this._clampThinkingLevel(defaultThinkingLevel, availableLevels);
+			this.agent.setThinkingLevel(effectiveLevel);
+			this.sessionManager.appendThinkingLevelChange(effectiveLevel);
 		}
 
 		this._reconnectToAgent();
@@ -3404,7 +3453,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		await this.sessionManager.flush();
 
 		if (!selectedEntry.parentId) {
-			this.sessionManager.newSession();
+			this.sessionManager.newSession({ parentSession: previousSessionFile });
 		} else {
 			this.sessionManager.createBranchedSession(selectedEntry.parentId);
 		}

package/src/session/auth-storage.ts

@@ -34,6 +34,7 @@ import {
 } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
 import { getAgentDbPath } from "../config";
+import { resolveConfigValue } from "../config/resolve-config-value";
 import { AgentStorage } from "./agent-storage";
 
 export type ApiKeyCredential = {
@@ -1294,7 +1295,7 @@ export class AuthStorage {
 		const apiKeySelection = this.selectCredentialByType(provider, "api_key", sessionId);
 		if (apiKeySelection) {
 			this.recordSessionCredential(provider, sessionId, "api_key", apiKeySelection.index);
-			return apiKeySelection.credential.key;
+			return resolveConfigValue(apiKeySelection.credential.key);
 		}
 
 		const oauthKey = await this.resolveOAuthApiKey(provider, sessionId, options);