@oh-my-pi/pi-coding-agent 13.7.6 → 13.9.1

package/src/patch/hashline.ts

@@ -710,3 +710,116 @@ export function applyHashlineEdits(
 		}
 	}
 }
+
+export interface CompactHashlineDiffPreview {
+	preview: string;
+	addedLines: number;
+	removedLines: number;
+}
+
+export interface CompactHashlineDiffOptions {
+	maxUnchangedRun?: number;
+	maxAdditionRun?: number;
+	maxDeletionRun?: number;
+	maxOutputLines?: number;
+}
+
+const NUMBERED_DIFF_LINE_RE = /^([ +-])(\d+)\|(.*)$/;
+
+type DiffRunKind = " " | "+" | "-" | "meta";
+type DiffRun = { kind: DiffRunKind; lines: string[] };
+
+function collapseFromStart(lines: string[], maxLines: number, label: string): string[] {
+	if (lines.length <= maxLines) return lines;
+	const hidden = lines.length - maxLines;
+	return [...lines.slice(0, maxLines), ` ... ${hidden} more ${label} lines`];
+}
+
+function collapseFromEnd(lines: string[], maxLines: number, label: string): string[] {
+	if (lines.length <= maxLines) return lines;
+	const hidden = lines.length - maxLines;
+	return [` ... ${hidden} more ${label} lines`, ...lines.slice(-maxLines)];
+}
+
+function collapseFromMiddle(lines: string[], maxLines: number, label: string): string[] {
+	if (lines.length <= maxLines * 2) return lines;
+	const hidden = lines.length - maxLines * 2;
+	return [...lines.slice(0, maxLines), ` ... ${hidden} more ${label} lines`, ...lines.slice(-maxLines)];
+}
+
+function splitDiffRuns(lines: string[]): DiffRun[] {
+	const runs: DiffRun[] = [];
+	for (const line of lines) {
+		const match = NUMBERED_DIFF_LINE_RE.exec(line);
+		const kind = (match?.[1] as " " | "+" | "-" | undefined) ?? "meta";
+		const prev = runs[runs.length - 1];
+		if (prev && prev.kind === kind) {
+			prev.lines.push(line);
+			continue;
+		}
+		runs.push({ kind, lines: [line] });
+	}
+	return runs;
+}
+
+/**
+ * Build a compact diff preview suitable for model-visible tool responses.
+ *
+ * Collapses long unchanged runs and long consecutive additions/removals so the
+ * model sees the shape of edits without replaying full file content.
+ */
+export function buildCompactHashlineDiffPreview(
+	diff: string,
+	options: CompactHashlineDiffOptions = {},
+): CompactHashlineDiffPreview {
+	const maxUnchangedRun = options.maxUnchangedRun ?? 2;
+	const maxAdditionRun = options.maxAdditionRun ?? 2;
+	const maxDeletionRun = options.maxDeletionRun ?? 2;
+	const maxOutputLines = options.maxOutputLines ?? 16;
+
+	const inputLines = diff.length === 0 ? [] : diff.split("\n");
+	const runs = splitDiffRuns(inputLines);
+
+	const out: string[] = [];
+	let addedLines = 0;
+	let removedLines = 0;
+
+	for (let runIndex = 0; runIndex < runs.length; runIndex++) {
+		const run = runs[runIndex];
+		switch (run.kind) {
+			case "meta":
+				out.push(...run.lines);
+				break;
+			case "+":
+				addedLines += run.lines.length;
+				out.push(...collapseFromStart(run.lines, maxAdditionRun, "added"));
+				break;
+			case "-":
+				removedLines += run.lines.length;
+				out.push(...collapseFromStart(run.lines, maxDeletionRun, "removed"));
+				break;
+			case " ":
+				if (runIndex === 0) {
+					out.push(...collapseFromEnd(run.lines, maxUnchangedRun, "unchanged"));
+					break;
+				}
+				if (runIndex === runs.length - 1) {
+					out.push(...collapseFromStart(run.lines, maxUnchangedRun, "unchanged"));
+					break;
+				}
+				out.push(...collapseFromMiddle(run.lines, maxUnchangedRun, "unchanged"));
+				break;
+		}
+	}
+
+	if (out.length > maxOutputLines) {
+		const hidden = out.length - maxOutputLines;
+		return {
+			preview: [...out.slice(0, maxOutputLines), ` ... ${hidden} more preview lines`].join("\n"),
+			addedLines,
+			removedLines,
+		};
+	}
+
+	return { preview: out.join("\n"), addedLines, removedLines };
+}

package/src/patch/index.ts

@@ -34,7 +34,14 @@ import { enforcePlanModeWrite, resolvePlanPath } from "../tools/plan-mode-guard"
 import { applyPatch } from "./applicator";
 import { generateDiffString, generateUnifiedDiffString, replaceText } from "./diff";
 import { findMatch } from "./fuzzy";
-import { type Anchor, applyHashlineEdits, computeLineHash, type HashlineEdit, parseTag } from "./hashline";
+import {
+	type Anchor,
+	applyHashlineEdits,
+	buildCompactHashlineDiffPreview,
+	computeLineHash,
+	type HashlineEdit,
+	parseTag,
+} from "./hashline";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
 import { type EditToolDetails, getLspBatchRequest } from "./shared";
 // Internal imports
@@ -315,18 +322,10 @@ export type EditMode = "replace" | "patch" | "hashline";
 
 export const DEFAULT_EDIT_MODE: EditMode = "hashline";
 
-export function normalizeEditMode(mode?: string | null): EditMode | null {
-	switch (mode) {
-		case "replace":
-			return "replace";
-		case "patch":
-			return "patch";
-		case "hashline":
-			return "hashline";
-		default:
-			return null;
-	}
-}
+const EDIT_ID: Record<string, EditMode> = Object.fromEntries(
+	["replace", "patch", "hashline"].map(mode => [mode, mode as EditMode]),
+);
+export const normalizeEditMode = (mode?: string | null): EditMode | undefined => EDIT_ID[mode ?? ""];
 
 /**
  * Edit tool implementation.
@@ -401,11 +400,17 @@ export class EditTool implements AgentTool<TInput> {
 	 */
 	get mode(): EditMode {
 		if (this.#editMode) return this.#editMode;
+		// 1. Check if edit mode is explicitly set for this model
 		const activeModel = this.session.getActiveModelString?.();
-		const editVariant =
-			this.session.settings.getEditVariantForModel(activeModel) ??
-			normalizeEditMode(this.session.settings.get("edit.mode"));
-		return editVariant ?? DEFAULT_EDIT_MODE;
+		const modelVariant = this.session.settings.getEditVariantForModel(activeModel);
+		if (modelVariant) return modelVariant;
+		// 2. Check if model contains "-spark" substring (default to replace mode)
+		if (activeModel?.includes("-spark")) return "replace";
+		// 3. Check if edit mode is explicitly set in session settings
+		const settingsMode = normalizeEditMode(this.session.settings.get("edit.mode"));
+		if (settingsMode) return settingsMode;
+		// 4. Default to DEFAULT_EDIT_MODE
+		return DEFAULT_EDIT_MODE;
 	}
 
 	/**
@@ -597,11 +602,15 @@ export class EditTool implements AgentTool<TInput> {
 				.get();
 
 			const resultText = move ? `Moved ${path} to ${move}` : `Updated ${path}`;
+			const preview = buildCompactHashlineDiffPreview(diffResult.diff);
+			const summaryLine = `Changes: +${preview.addedLines} -${preview.removedLines}${preview.preview ? "" : " (no textual diff preview)"}`;
+			const warningsBlock = result.warnings?.length ? `\n\nWarnings:\n${result.warnings.join("\n")}` : "";
+			const previewBlock = preview.preview ? `\n\nDiff preview:\n${preview.preview}` : "";
 			return {
 				content: [
 					{
 						type: "text",
-						text: `${resultText}${result.warnings?.length ? `\n\nWarnings:\n${result.warnings.join("\n")}` : ""}`,
+						text: `${resultText}\n${summaryLine}${previewBlock}${warningsBlock}`,
 					},
 				],
 				details: {

package/src/prompts/tools/hashline.md

@@ -12,23 +12,22 @@ Follow these steps in order for every edit:
 **`move`** — if set, move the file to the given path.
 **`delete`** — if true, delete the file.
 **`edits[n].pos`** — the anchor line. Meaning depends on `op`:
-- `replace`: start of range (or the single line to replace)
-- `prepend`: insert new lines **before** this line; omit for beginning of file
-- `append`: insert new lines **after** this line; omit for end of file
+  - if `replace`: line to rewrite
+  - if `prepend`: line to insert new lines **before**; omit for beginning of file
+  - if `append`: line to insert new lines **after**; omit for end of file
 **`edits[n].end`** — range replace only. The last line of the range (inclusive). Omit for single-line replace.
 **`edits[n].lines`** — the replacement content:
-- `["line1", "line2"]` — replace with these lines (array of strings)
-- `"line1"` — shorthand for `["line1"]` (single-line replace)
-- `[""]` — replace content with a blank line (line preserved, content cleared)
-- `null` or `[]` — **delete** the line(s) entirely
+  - `["line1", "line2"]` — insert `line1` and `line2`
+  - `[""]` — blank line
+  - `null` or `[]` — delete if replace, no-op if append or prepend
 
 Tags are applied bottom-up: later edits (by position) are applied first, so earlier tags remain valid even when subsequent ops add or remove lines. Tags **MUST** be referenced from the most recent `read` output.
 </operations>
 
 <rules>
-1. **Anchor on unique, structural lines.** You **SHOULD** choose anchors like function signatures, class declarations, or distinct statements — lines that appear exactly once. Blank lines, `}`, and `return null;` repeat throughout a file; anchoring on them risks matching the wrong location. When inserting between blocks, anchor on the nearest unique declaration using `prepend` or `append`.
-2. **Prefer insertion over neighbor rewrites.** You **SHOULD** use `prepend`/`append` anchored on a structural boundary (`}`, `]`, `},`) rather than replacing adjacent lines when adding code near existing code. This keeps the edit minimal and avoids accidentally rewriting lines that should stay.
-3. **Include boundary lines in the replaced range.** `end` is inclusive and **MUST** point to the final line being replaced. If your replacement `lines` include a closing token (`}`, `]`, `)`, `);`, `},`), `end` **MUST** include the original closing line. Otherwise the original closer survives and you get a duplicate.
+1. **Anchor on unique, structural lines.** When inserting between blocks, anchor on the nearest unique declaration using `prepend` or `append`.
+2. **Use `prepend`/`append` only when the anchor line itself is not changing.** Inserting near an unchanged boundary keeps the edit minimal.
+3. **Use range `replace` when any line in the span changes.** If you need to both insert lines and modify a neighboring line, a range replace covering all lines to remove is way to go.
 </rules>
 
 <recovery>

package/src/prompts/tools/read.md

@@ -1,8 +1,8 @@
 Reads files from local filesystem or internal URLs.
 
 <instruction>
-- Reads up to {{DEFAULT_MAX_LINES}} lines default
-- Use `offset` and `limit` for large files
+- Reads up to {{DEFAULT_LIMIT}} lines default
+- Use `offset` and `limit` for large files; max {{DEFAULT_MAX_LINES}} lines per call
 {{#if IS_HASHLINE_MODE}}
 - Text output is CID prefixed: `LINE#ID:content`
 {{else}}

package/src/sdk.ts

@@ -1,12 +1,6 @@
-import {
-	Agent,
-	type AgentEvent,
-	type AgentMessage,
-	type AgentTool,
-	INTENT_FIELD,
-	type ThinkingLevel,
-} from "@oh-my-pi/pi-agent-core";
-import { type Message, type Model, supportsXhigh } from "@oh-my-pi/pi-ai";
+import { Agent, type AgentEvent, type AgentMessage, type AgentTool, INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
+import { type Message, type Model, supportsXhigh, type ThinkingLevel } from "@oh-my-pi/pi-ai";
+
 import { prewarmOpenAICodexResponses } from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { $env, getAgentDbPath, getAgentDir, getProjectDir, logger, postmortem } from "@oh-my-pi/pi-utils";
@@ -15,7 +9,7 @@ import { AsyncJobManager } from "./async";
 import { loadCapability } from "./capability";
 import { type Rule, ruleCapability } from "./capability/rule";
 import { ModelRegistry } from "./config/model-registry";
-import { formatModelString, parseModelPattern, parseModelString } from "./config/model-resolver";
+import { formatModelString, parseModelPattern, parseModelString, resolveModelRoleValue } from "./config/model-resolver";
 import {
 	loadPromptTemplates as loadPromptTemplatesInternal,
 	type PromptTemplate,
@@ -651,6 +645,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const hasThinkingEntry = sessionManager.getBranch().some(entry => entry.type === "thinking_level_change");
 
 	const hasExplicitModel = options.model !== undefined || options.modelPattern !== undefined;
+	const modelMatchPreferences = {
+		usageOrder: settings.getStorage()?.getModelUsageOrder(),
+	};
+	const defaultRoleSpec = resolveModelRoleValue(settings.getModelRole("default"), modelRegistry.getAvailable(), {
+		settings,
+		matchPreferences: modelMatchPreferences,
+	});
 	let model = options.model;
 	let modelFallbackMessage: string | undefined;
 	// If session has data, try to restore model from it.
@@ -671,16 +672,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// If still no model, try settings default.
 	// Skip settings fallback when an explicit model was requested.
-	if (!hasExplicitModel && !model) {
-		const settingsDefaultModel = settings.getModelRole("default");
-		if (settingsDefaultModel) {
-			const parsedModel = parseModelString(settingsDefaultModel);
-			if (parsedModel) {
-				const settingsModel = modelRegistry.find(parsedModel.provider, parsedModel.id);
-				if (settingsModel && (await hasModelApiKey(settingsModel))) {
-					model = settingsModel;
-				}
-			}
+	if (!hasExplicitModel && !model && defaultRoleSpec.model) {
+		if (await hasModelApiKey(defaultRoleSpec.model)) {
+			model = defaultRoleSpec.model;
 		}
 	}
 
@@ -700,11 +694,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	let thinkingLevel = options.thinkingLevel;
 
-	// If session has data, restore thinking level from it
-	if (thinkingLevel === undefined && hasExistingSession) {
-		thinkingLevel = hasThinkingEntry
-			? (existingSession.thinkingLevel as ThinkingLevel)
-			: ((settings.get("defaultThinkingLevel") ?? "off") as ThinkingLevel);
+	// If session has data and includes a thinking entry, restore it
+	if (thinkingLevel === undefined && hasExistingSession && hasThinkingEntry) {
+		thinkingLevel = existingSession.thinkingLevel as ThinkingLevel;
+	}
+
+	if (thinkingLevel === undefined && !hasExplicitModel && !hasThinkingEntry && defaultRoleSpec.explicitThinkingLevel) {
+		thinkingLevel = defaultRoleSpec.thinkingLevel;
 	}
 
 	// Fall back to settings default

package/src/session/agent-session.ts

@@ -24,7 +24,6 @@ import {
 	type AgentState,
 	type AgentTool,
 	INTENT_FIELD,
-	type ThinkingLevel,
 } from "@oh-my-pi/pi-agent-core";
 import type {
 	AssistantMessage,
@@ -33,6 +32,7 @@ import type {
 	Model,
 	ProviderSessionState,
 	TextContent,
+	ThinkingLevel,
 	ToolCall,
 	ToolChoice,
 	Usage,
@@ -40,6 +40,7 @@ import type {
 } from "@oh-my-pi/pi-ai";
 import {
 	calculateRateLimitBackoffMs,
+	getAvailableThinkingLevels,
 	isContextOverflow,
 	modelsAreEqual,
 	parseRateLimitReason,
@@ -49,7 +50,7 @@ import { abortableSleep, getAgentDbPath, isEnoent, logger } from "@oh-my-pi/pi-u
 import type { AsyncJob, AsyncJobManager } from "../async";
 import type { Rule } from "../capability/rule";
 import { MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "../config/model-registry";
-import { expandRoleAlias, parseModelString } from "../config/model-resolver";
+import { extractExplicitThinkingSelector, parseModelString, resolveModelRoleValue } from "../config/model-resolver";
 import { expandPromptTemplate, type PromptTemplate, renderPromptTemplate } from "../config/prompt-templates";
 import type { Settings, SkillsSettings } from "../config/settings";
 import { type BashResult, executeBash as executeBashCommand } from "../exec/bash-executor";
@@ -252,10 +253,6 @@ export interface HandoffResult {
 // ============================================================================
 
 /** Standard thinking levels */
-const THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high"];
-
-/** Thinking levels including xhigh (for supported models) */
-const THINKING_LEVELS_WITH_XHIGH: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
 
 const noOpUIContext: ExtensionUIContext = {
 	select: async (_title, _options, _dialogOptions) => undefined,
@@ -295,7 +292,6 @@ export class AgentSession {
 	readonly settings: Settings;
 
 	#asyncJobManager: AsyncJobManager | undefined = undefined;
-
 	#scopedModels: Array<{ model: Model; thinkingLevel: ThinkingLevel }>;
 	#promptTemplates: PromptTemplate[];
 	#slashCommands: FileSlashCommand[];
@@ -2630,7 +2626,7 @@ export class AgentSession {
 
 		this.#setModelWithProviderSessionReset(model);
 		this.sessionManager.appendModelChange(`${model.provider}/${model.id}`, role);
-		this.settings.setModelRole(role, `${model.provider}/${model.id}`);
+		this.settings.setModelRole(role, this.#formatRoleModelValue(role, model));
 		this.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
 
 		// Re-clamp thinking level for new model's capabilities without persisting settings
@@ -2684,7 +2680,13 @@ export class AgentSession {
 
 		const currentModel = this.model;
 		if (!currentModel) return undefined;
-		const roleModels: Array<{ role: ModelRole; model: Model }> = [];
+		const matchPreferences = { usageOrder: this.settings.getStorage()?.getModelUsageOrder() };
+		const roleModels: Array<{
+			role: ModelRole;
+			model: Model;
+			thinkingLevel?: ThinkingLevel;
+			explicitThinkingLevel: boolean;
+		}> = [];
 
 		for (const role of roleOrder) {
 			const roleModelStr =
@@ -2693,18 +2695,18 @@ export class AgentSession {
 					: this.settings.getModelRole(role);
 			if (!roleModelStr) continue;
 
-			const expandedRoleModelStr = expandRoleAlias(roleModelStr, this.settings);
-			const parsed = parseModelString(expandedRoleModelStr);
-			let match: Model | undefined;
-			if (parsed) {
-				match = availableModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
-			}
-			if (!match) {
-				match = availableModels.find(m => m.id.toLowerCase() === expandedRoleModelStr.toLowerCase());
-			}
-			if (!match) continue;
+			const resolved = resolveModelRoleValue(roleModelStr, availableModels, {
+				settings: this.settings,
+				matchPreferences,
+			});
+			if (!resolved.model) continue;
 
-			roleModels.push({ role, model: match });
+			roleModels.push({
+				role,
+				model: resolved.model,
+				thinkingLevel: resolved.thinkingLevel,
+				explicitThinkingLevel: resolved.explicitThinkingLevel,
+			});
 		}
 
 		if (roleModels.length <= 1) return undefined;
@@ -2724,6 +2726,10 @@ export class AgentSession {
 			await this.setModel(next.model, next.role);
 		}
 
+		if (next.explicitThinkingLevel && next.thinkingLevel !== undefined) {
+			this.setThinkingLevel(next.thinkingLevel);
+		}
+
 		return { model: next.model, thinkingLevel: this.thinkingLevel, role: next.role };
 	}
 
@@ -2764,7 +2770,7 @@ export class AgentSession {
 		// Apply model
 		this.#setModelWithProviderSessionReset(next.model);
 		this.sessionManager.appendModelChange(`${next.model.provider}/${next.model.id}`);
-		this.settings.setModelRole("default", `${next.model.provider}/${next.model.id}`);
+		this.settings.setModelRole("default", this.#formatRoleModelValue("default", next.model));
 		this.settings.getStorage()?.recordModelUsage(`${next.model.provider}/${next.model.id}`);
 
 		// Apply thinking level (setThinkingLevel clamps to model capabilities)
@@ -2792,7 +2798,7 @@ export class AgentSession {
 
 		this.#setModelWithProviderSessionReset(nextModel);
 		this.sessionManager.appendModelChange(`${nextModel.provider}/${nextModel.id}`);
-		this.settings.setModelRole("default", `${nextModel.provider}/${nextModel.id}`);
+		this.settings.setModelRole("default", this.#formatRoleModelValue("default", nextModel));
 		this.settings.getStorage()?.recordModelUsage(`${nextModel.provider}/${nextModel.id}`);
 
 		// Re-clamp thinking level for new model's capabilities without persisting settings
@@ -2854,9 +2860,9 @@ export class AgentSession {
 	 * Get available thinking levels for current model.
 	 * The provider will clamp to what the specific model supports internally.
 	 */
-	getAvailableThinkingLevels(): ThinkingLevel[] {
+	getAvailableThinkingLevels(): ReadonlyArray<ThinkingLevel> {
 		if (!this.supportsThinking()) return ["off"];
-		return this.supportsXhighThinking() ? THINKING_LEVELS_WITH_XHIGH : THINKING_LEVELS;
+		return getAvailableThinkingLevels(this.supportsXhighThinking());
 	}
 
 	/**
@@ -2873,8 +2879,8 @@ export class AgentSession {
 		return !!this.model?.reasoning;
 	}
 
-	#clampThinkingLevel(level: ThinkingLevel, availableLevels: ThinkingLevel[]): ThinkingLevel {
-		const ordered = THINKING_LEVELS_WITH_XHIGH;
+	#clampThinkingLevel(level: ThinkingLevel, availableLevels: ReadonlyArray<ThinkingLevel>): ThinkingLevel {
+		const ordered = getAvailableThinkingLevels(true);
 		const available = new Set(availableLevels);
 		const requestedIndex = ordered.indexOf(level);
 		if (requestedIndex === -1) {
@@ -3531,33 +3537,13 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		const availableModels = this.#modelRegistry.getAvailable();
 		if (availableModels.length === 0) return undefined;
 
-		const candidates: Model[] = [];
-		const seen = new Set<string>();
-		const addCandidate = (candidate: Model | undefined): void => {
-			if (!candidate) return;
-			const key = this.#getModelKey(candidate);
-			if (seen.has(key)) return;
-			seen.add(key);
-			candidates.push(candidate);
-		};
-
-		addCandidate(this.#resolveContextPromotionConfiguredTarget(currentModel, availableModels));
-
-		const sameProviderLarger = [...availableModels]
-			.filter(
-				m => m.provider === currentModel.provider && m.api === currentModel.api && m.contextWindow > contextWindow,
-			)
-			.sort((a, b) => a.contextWindow - b.contextWindow);
-		addCandidate(sameProviderLarger[0]);
-		for (const candidate of candidates) {
-			if (modelsAreEqual(candidate, currentModel)) continue;
-			if (candidate.contextWindow <= contextWindow) continue;
-			const apiKey = await this.#modelRegistry.getApiKey(candidate, this.sessionId);
-			if (!apiKey) continue;
-			return candidate;
-		}
-
-		return undefined;
+		const candidate = this.#resolveContextPromotionConfiguredTarget(currentModel, availableModels);
+		if (!candidate) return undefined;
+		if (modelsAreEqual(candidate, currentModel)) return undefined;
+		if (candidate.contextWindow <= contextWindow) return undefined;
+		const apiKey = await this.#modelRegistry.getApiKey(candidate, this.sessionId);
+		if (!apiKey) return undefined;
+		return candidate;
 	}
 
 	#setModelWithProviderSessionReset(model: Model): void {
@@ -3597,6 +3583,15 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		return `${model.provider}/${model.id}`;
 	}
 
+	#formatRoleModelValue(role: ModelRole, model: Model): string {
+		const modelKey = `${model.provider}/${model.id}`;
+		const existingRoleValue = this.settings.getModelRole(role);
+		if (!existingRoleValue) return modelKey;
+
+		const thinkingLevel = extractExplicitThinkingSelector(existingRoleValue, this.settings);
+		if (thinkingLevel === undefined) return modelKey;
+		return `${modelKey}:${thinkingLevel}`;
+	}
 	#resolveContextPromotionConfiguredTarget(currentModel: Model, availableModels: Model[]): Model | undefined {
 		const configuredTarget = currentModel.contextPromotionTarget?.trim();
 		if (!configuredTarget) return undefined;
@@ -3619,12 +3614,10 @@ Be thorough - include exact file paths, function names, error messages, and tech
 
 		if (!roleModelStr) return undefined;
 
-		const parsed = parseModelString(roleModelStr);
-		if (parsed) {
-			return availableModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
-		}
-		const roleLower = roleModelStr.toLowerCase();
-		return availableModels.find(m => m.id.toLowerCase() === roleLower);
+		return resolveModelRoleValue(roleModelStr, availableModels, {
+			settings: this.settings,
+			matchPreferences: { usageOrder: this.settings.getStorage()?.getModelUsageOrder() },
+		}).model;
 	}
 
 	#getCompactionModelCandidates(availableModels: Model[]): Model[] {
@@ -4575,6 +4568,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 
 		if (!skipConversationRestore) {
 			this.agent.replaceMessages(sessionContext.messages);
+			this.#closeCodexProviderSessionsForHistoryRewrite();
 		}
 
 		return { selectedText, cancelled: false };
@@ -4729,6 +4723,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		const sessionContext = this.sessionManager.buildSessionContext();
 		this.agent.replaceMessages(sessionContext.messages);
 		this.#syncTodoPhasesFromBranch();
+		this.#closeCodexProviderSessionsForHistoryRewrite();
 
 		// Emit session_tree event
 		if (this.#extensionRunner) {

package/src/task/executor.ts

@@ -4,8 +4,8 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 import path from "node:path";
-import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model, ToolChoice } from "@oh-my-pi/pi-ai";
+import type { AgentEvent } from "@oh-my-pi/pi-agent-core";
+import type { Api, Model, ThinkingLevel, ToolChoice } from "@oh-my-pi/pi-ai";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import Ajv, { type ValidateFunction } from "ajv";
@@ -938,12 +938,14 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			await modelRegistry.refresh();
 			checkAbort();
 
-			const { model, thinkingLevel: resolvedThinkingLevel } = resolveModelOverride(
-				modelPatterns,
-				modelRegistry,
-				settings,
-			);
-			const effectiveThinkingLevel = thinkingLevel ?? resolvedThinkingLevel;
+			const {
+				model,
+				thinkingLevel: resolvedThinkingLevel,
+				explicitThinkingLevel,
+			} = resolveModelOverride(modelPatterns, modelRegistry, settings);
+			const effectiveThinkingLevel = explicitThinkingLevel
+				? resolvedThinkingLevel
+				: (thinkingLevel ?? resolvedThinkingLevel);
 
 			const sessionManager = sessionFile
 				? await SessionManager.open(sessionFile)

package/src/task/types.ts

@@ -1,5 +1,4 @@
-import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Usage } from "@oh-my-pi/pi-ai";
+import type { ThinkingLevel, Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { NestedRepoPatch } from "./worktree";