@oh-my-pi/pi-coding-agent 13.8.0 → 13.9.2

package/src/modes/theme/theme.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import type { ThinkingLevel } from "@oh-my-pi/pi-ai";
 import {
 	detectMacOSAppearance,
 	type HighlightColors as NativeHighlightColors,
@@ -1219,7 +1220,7 @@ export class Theme {
 		return this.mode;
 	}
 
-	getThinkingBorderColor(level: "off" | "minimal" | "low" | "medium" | "high" | "xhigh"): (str: string) => string {
+	getThinkingBorderColor(level: ThinkingLevel): (str: string) => string {
 		// Map thinking levels to dedicated theme colors
 		switch (level) {
 			case "off":

package/src/patch/hashline.ts

@@ -458,6 +458,18 @@ function maybeWarnSuspiciousUnicodeEscapePlaceholder(edits: HashlineEdit[], warn
 // Edit Application
 // ═══════════════════════════════════════════════════════════════════════════
 
+const MIN_AUTOCORRECT_LENGTH = 2;
+
+function shouldAutocorrect(line: string, otherLine: string): boolean {
+	if (!line || line !== otherLine) return false;
+	line = line.trim();
+	if (line.length < MIN_AUTOCORRECT_LENGTH) {
+		// if brace, we allow
+		return line.endsWith("}") || line.endsWith(")");
+	}
+	return true;
+}
+
 /**
  * Apply an array of hashline edits to file content.
  *
@@ -630,9 +642,7 @@ export function applyHashlineEdits(
 					const trailingReplacementLine = newLines[newLines.length - 1]?.trimEnd();
 					const nextSurvivingLine = fileLines[edit.end.line]?.trimEnd();
 					if (
-						trailingReplacementLine &&
-						nextSurvivingLine &&
-						trailingReplacementLine === nextSurvivingLine &&
+						shouldAutocorrect(trailingReplacementLine, nextSurvivingLine) &&
 						// Safety: only correct when end-line content differs from the duplicate.
 						// If end already points to the boundary, matching next line is coincidence.
 						fileLines[edit.end.line - 1]?.trimEnd() !== trailingReplacementLine
@@ -642,6 +652,19 @@ export function applyHashlineEdits(
 							`Auto-corrected range replace ${edit.pos.line}#${edit.pos.hash}-${edit.end.line}#${edit.end.hash}: removed trailing replacement line "${trailingReplacementLine}" that duplicated next surviving line`,
 						);
 					}
+					const leadingReplacementLine = newLines[0]?.trimEnd();
+					const prevSurvivingLine = fileLines[edit.pos.line - 2]?.trimEnd();
+					if (
+						shouldAutocorrect(leadingReplacementLine, prevSurvivingLine) &&
+						// Safety: only correct when pos-line content differs from the duplicate.
+						// If pos already points to the boundary, matching prev line is coincidence.
+						fileLines[edit.pos.line - 1]?.trimEnd() !== leadingReplacementLine
+					) {
+						newLines.shift();
+						warnings.push(
+							`Auto-corrected range replace ${edit.pos.line}#${edit.pos.hash}-${edit.end.line}#${edit.end.hash}: removed leading replacement line "${leadingReplacementLine}" that duplicated preceding surviving line`,
+						);
+					}
 					fileLines.splice(edit.pos.line - 1, count, ...newLines);
 					trackFirstChanged(edit.pos.line);
 				}

package/src/patch/index.ts

@@ -322,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.
@@ -408,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;
 	}
 
 	/**

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,20 +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;
-					// Apply thinking level from config role suffix if not already set
-					if (options.thinkingLevel === undefined && parsedModel.thinkingLevel) {
-						options.thinkingLevel = parsedModel.thinkingLevel;
-					}
-				}
-			}
+	if (!hasExplicitModel && !model && defaultRoleSpec.model) {
+		if (await hasModelApiKey(defaultRoleSpec.model)) {
+			model = defaultRoleSpec.model;
 		}
 	}
 
@@ -704,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; thinkingLevel?: ThinkingLevel }> = [];
+		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, thinkingLevel: parsed?.thinkingLevel });
+			roleModels.push({
+				role,
+				model: resolved.model,
+				thinkingLevel: resolved.thinkingLevel,
+				explicitThinkingLevel: resolved.explicitThinkingLevel,
+			});
 		}
 
 		if (roleModels.length <= 1) return undefined;
@@ -2724,12 +2726,8 @@ export class AgentSession {
 			await this.setModel(next.model, next.role);
 		}
 
-		// Apply per-role thinking level from config suffix and preserve it for round-tripping
-		if (next.thinkingLevel) {
+		if (next.explicitThinkingLevel && next.thinkingLevel !== undefined) {
 			this.setThinkingLevel(next.thinkingLevel);
-			if (!options?.temporary) {
-				this.settings.setModelRole(next.role, `${next.model.provider}/${next.model.id}:${next.thinkingLevel}`);
-			}
 		}
 
 		return { model: next.model, thinkingLevel: this.thinkingLevel, role: next.role };
@@ -2772,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)
@@ -2800,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
@@ -2862,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());
 	}
 
 	/**
@@ -2881,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) {
@@ -3585,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;
@@ -3607,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[] {
@@ -4563,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 };
@@ -4717,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";