@oh-my-pi/pi-coding-agent 8.10.11 → 8.10.12

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "8.10.11",
+	"version": "8.10.12",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -83,18 +83,18 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "8.10.11",
-		"@oh-my-pi/pi-agent-core": "8.10.11",
-		"@oh-my-pi/pi-ai": "8.10.11",
-		"@oh-my-pi/pi-tui": "8.10.11",
-		"@oh-my-pi/pi-utils": "8.10.11",
-		"@openai/agents": "^0.4.3",
-		"@sinclair/typebox": "^0.34.46",
+		"@oh-my-pi/omp-stats": "8.10.12",
+		"@oh-my-pi/pi-agent-core": "8.10.12",
+		"@oh-my-pi/pi-ai": "8.10.12",
+		"@oh-my-pi/pi-tui": "8.10.12",
+		"@oh-my-pi/pi-utils": "8.10.12",
+		"@openai/agents": "^0.4.4",
+		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",
-		"chalk": "^5.5.0",
+		"chalk": "^5.6.2",
 		"cli-highlight": "^2.1.11",
-		"diff": "^8.0.2",
-		"file-type": "^21.1.1",
+		"diff": "^8.0.3",
+		"file-type": "^21.3.0",
 		"glob": "^13.0.0",
 		"handlebars": "^4.7.8",
 		"highlight.js": "^11.11.1",
@@ -103,7 +103,7 @@
 		"node-html-parser": "^7.0.2",
 		"smol-toml": "^1.6.0",
 		"strip-ansi": "^7.1.2",
-		"zod": "^4.3.5"
+		"zod": "^4.3.6"
 	},
 	"devDependencies": {
 		"@types/diff": "^8.0.0",

package/src/cli/stats-cli.ts

@@ -107,6 +107,15 @@ export async function runStatsCommand(cmd: StatsCommandArgs): Promise<void> {
 	// Start the dashboard server
 	const { port } = await startServer(cmd.port);
 	console.log(chalk.green(`Dashboard available at: http://localhost:${port}`));
+
+	// Open browser
+	const url = `http://localhost:${port}`;
+	const openCommand = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+	Bun.spawn(openCommand === "cmd" ? ["cmd", "/c", "start", url] : [openCommand, url], {
+		stdout: "ignore",
+		stderr: "ignore",
+	}).unref();
+
 	console.log("Press Ctrl+C to stop\n");
 
 	// Keep process running

package/src/config/model-resolver.ts

@@ -28,6 +28,7 @@ export const defaultModelPerProvider: Record<KnownProvider, string> = {
 	mistral: "devstral-medium-latest",
 	minimax: "MiniMax-M2",
 	opencode: "claude-opus-4-5",
+	"kimi-code": "kimi-k2.5",
 };
 
 export interface ScopedModel {

package/src/config/prompt-templates.ts

@@ -1,8 +1,8 @@
 import * as path from "node:path";
-import { jtdToTypeScript } from "@oh-my-pi/pi-coding-agent/tools/jtd-to-typescript";
 import { logger } from "@oh-my-pi/pi-utils";
 import Handlebars from "handlebars";
 import { CONFIG_DIR_NAME, getPromptsDir } from "../config";
+import { jtdToTypeScript } from "../tools/jtd-to-typescript";
 import { parseFrontmatter } from "../utils/frontmatter";
 
 /**

package/src/config/settings-manager.ts

@@ -135,6 +135,8 @@ export interface EditSettings {
 	fuzzyThreshold?: number; // default: 0.95 (similarity threshold for fuzzy matching)
 	patchMode?: boolean; // default: true (use codex-style apply-patch format instead of old_text/new_text)
 	streamingAbort?: boolean; // default: false (abort streaming edit tool calls when patch preview fails)
+	/** Model-specific variant overrides. Keys are model pattern substrings (e.g., "kimi", "deepseek"). */
+	modelVariants?: Record<string, "patch" | "replace">;
 }
 
 export type { SymbolPreset };
@@ -1387,6 +1389,57 @@ export class SettingsManager {
 		await this.save();
 	}
 
+	/**
+	 * Default model patterns that should use replace mode instead of patch mode.
+	 * These are models known to struggle with unified diff format.
+	 */
+	static readonly DEFAULT_REPLACE_MODE_PATTERNS = ["kimi"];
+
+	/**
+	 * Get the edit variant for a specific model.
+	 * Returns "patch", "replace", or null (use global default).
+	 */
+	getEditVariantForModel(model: string | undefined): "patch" | "replace" | null {
+		if (!model) return null;
+		const modelLower = model.toLowerCase();
+
+		const userVariants = this.settings.edit?.modelVariants;
+		if (userVariants) {
+			for (const [pattern, variant] of Object.entries(userVariants)) {
+				if (modelLower.includes(pattern.toLowerCase())) {
+					return variant;
+				}
+			}
+		}
+
+		for (const pattern of SettingsManager.DEFAULT_REPLACE_MODE_PATTERNS) {
+			if (modelLower.includes(pattern)) {
+				return "replace";
+			}
+		}
+
+		return null;
+	}
+
+	getEditModelVariants(): Record<string, "patch" | "replace"> {
+		return this.settings.edit?.modelVariants ?? {};
+	}
+
+	async setEditModelVariant(pattern: string, variant: "patch" | "replace" | null): Promise<void> {
+		if (!this.globalSettings.edit) {
+			this.globalSettings.edit = {};
+		}
+		if (!this.globalSettings.edit.modelVariants) {
+			this.globalSettings.edit.modelVariants = {};
+		}
+		if (variant === null) {
+			delete this.globalSettings.edit.modelVariants[pattern];
+		} else {
+			this.globalSettings.edit.modelVariants[pattern] = variant;
+		}
+		await this.save();
+	}
+
 	getNormativeRewrite(): boolean {
 		return this.settings.normativeRewrite ?? false;
 	}

package/src/modes/components/hook-selector.ts

@@ -50,7 +50,15 @@ export class HookSelectorComponent extends Container {
 				opts.timeout,
 				opts.tui,
 				s => this.titleText.setText(theme.fg("accent", `${this.baseTitle} (${s}s)`)),
-				() => this.onCancelCallback(),
+				() => {
+					// Auto-select current option on timeout (typically the first/recommended option)
+					const selected = this.options[this.selectedIndex];
+					if (selected) {
+						this.onSelectCallback(selected);
+					} else {
+						this.onCancelCallback();
+					}
+				},
 			);
 		}
 

package/src/modes/controllers/extension-ui-controller.ts

@@ -8,6 +8,7 @@ import type {
 	ExtensionContextActions,
 	ExtensionError,
 	ExtensionUIContext,
+	ExtensionUIDialogOptions,
 } from "../../extensibility/extensions";
 import { HookEditorComponent } from "../../modes/components/hook-editor";
 import { HookInputComponent } from "../../modes/components/hook-input";
@@ -25,7 +26,7 @@ export class ExtensionUiController {
 	async initHooksAndCustomTools(): Promise<void> {
 		// Create and set hook & tool UI context
 		const uiContext: ExtensionUIContext = {
-			select: (title, options, dialogOptions) => this.showHookSelector(title, options, dialogOptions?.initialIndex),
+			select: (title, options, dialogOptions) => this.showHookSelector(title, options, dialogOptions),
 			confirm: (title, message, _dialogOptions) => this.showHookConfirm(title, message),
 			input: (title, placeholder, _dialogOptions) => this.showHookInput(title, placeholder),
 			notify: (message, type) => this.showHookNotify(message, type),
@@ -484,7 +485,11 @@ export class ExtensionUiController {
 	/**
 	 * Show a selector for hooks.
 	 */
-	showHookSelector(title: string, options: string[], initialIndex?: number): Promise<string | undefined> {
+	showHookSelector(
+		title: string,
+		options: string[],
+		dialogOptions?: ExtensionUIDialogOptions,
+	): Promise<string | undefined> {
 		const { promise, resolve } = Promise.withResolvers<string | undefined>();
 		this.ctx.hookSelector = new HookSelectorComponent(
 			title,
@@ -497,7 +502,7 @@ export class ExtensionUiController {
 				this.hideHookSelector();
 				resolve(undefined);
 			},
-			{ initialIndex },
+			{ initialIndex: dialogOptions?.initialIndex, timeout: dialogOptions?.timeout, tui: this.ctx.ui },
 		);
 
 		this.ctx.editorContainer.clear();

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

@@ -32,12 +32,12 @@ export class InputController {
 				this.ctx.editor.setText("");
 				this.ctx.isBashMode = false;
 				this.ctx.updateEditorBorderColor();
+			} else if (this.ctx.session.isPythonRunning) {
+				this.ctx.session.abortPython();
 			} else if (this.ctx.isPythonMode) {
 				this.ctx.editor.setText("");
 				this.ctx.isPythonMode = false;
 				this.ctx.updateEditorBorderColor();
-			} else if (this.ctx.session.isPythonRunning) {
-				this.ctx.session.abortPython();
 			} else if (!this.ctx.editor.getText().trim()) {
 				// Double-escape with empty editor triggers /tree or /branch based on setting
 				const now = Date.now();

package/src/modes/interactive-mode.ts

@@ -20,7 +20,7 @@ import chalk from "chalk";
 import { KeybindingsManager } from "../config/keybindings";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { SettingsManager } from "../config/settings-manager";
-import type { ExtensionUIContext } from "../extensibility/extensions";
+import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
 import { loadSlashCommands } from "../extensibility/slash-commands";
 import { resolvePlanUrlToPath } from "../internal-urls";
@@ -1020,8 +1020,12 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.extensionUiController.setHookStatus(key, text);
 	}
 
-	showHookSelector(title: string, options: string[], initialIndex?: number): Promise<string | undefined> {
-		return this.extensionUiController.showHookSelector(title, options, initialIndex);
+	showHookSelector(
+		title: string,
+		options: string[],
+		dialogOptions?: ExtensionUIDialogOptions,
+	): Promise<string | undefined> {
+		return this.extensionUiController.showHookSelector(title, options, dialogOptions);
 	}
 
 	hideHookSelector(): void {

package/src/modes/types.ts

@@ -3,7 +3,7 @@ import type { AssistantMessage, ImageContent, Message, UsageReport } from "@oh-m
 import type { Component, Container, Loader, Spacer, Text, TUI } from "@oh-my-pi/pi-tui";
 import type { KeybindingsManager } from "../config/keybindings";
 import type { SettingsManager } from "../config/settings-manager";
-import type { ExtensionUIContext } from "../extensibility/extensions";
+import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
 import type { MCPManager } from "../mcp";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
@@ -189,7 +189,11 @@ export interface InteractiveModeContext {
 	): Promise<void>;
 	setHookWidget(key: string, content: unknown): void;
 	setHookStatus(key: string, text: string | undefined): void;
-	showHookSelector(title: string, options: string[], initialIndex?: number): Promise<string | undefined>;
+	showHookSelector(
+		title: string,
+		options: string[],
+		dialogOptions?: ExtensionUIDialogOptions,
+	): Promise<string | undefined>;
 	hideHookSelector(): void;
 	showHookInput(title: string, placeholder?: string): Promise<string | undefined>;
 	hideHookInput(): void;

package/src/patch/index.ts

@@ -202,14 +202,12 @@ type TInput = typeof replaceEditSchema | typeof patchEditSchema;
 export class EditTool implements AgentTool<TInput> {
 	public readonly name = "edit";
 	public readonly label = "Edit";
-	public readonly description: string;
-	public readonly parameters: TInput;
 
 	private readonly session: ToolSession;
-	private readonly patchMode: boolean;
 	private readonly allowFuzzy: boolean;
 	private readonly fuzzyThreshold: number;
 	private readonly writethrough: WritethroughCallback;
+	private readonly envEditVariant: string;
 
 	constructor(session: ToolSession) {
 		this.session = session;
@@ -217,22 +215,14 @@ export class EditTool implements AgentTool<TInput> {
 		const {
 			OMP_EDIT_FUZZY: editFuzzy = "auto",
 			OMP_EDIT_FUZZY_THRESHOLD: editFuzzyThreshold = "auto",
-			OMP_EDIT_VARIANT: editVariant = "auto",
+			OMP_EDIT_VARIANT: envEditVariant = "auto",
 		} = process.env;
+		this.envEditVariant = envEditVariant;
 
-		switch (editVariant) {
-			case "replace":
-				this.patchMode = false;
-				break;
-			case "patch":
-				this.patchMode = true;
-				break;
-			case "auto":
-				this.patchMode = session.settings?.getEditPatchMode?.() ?? true;
-				break;
-			default:
-				throw new Error(`Invalid OMP_EDIT_VARIANT: ${process.env.OMP_EDIT_VARIANT}`);
+		if (envEditVariant !== "replace" && envEditVariant !== "patch" && envEditVariant !== "auto") {
+			throw new Error(`Invalid OMP_EDIT_VARIANT: ${envEditVariant}`);
 		}
+
 		switch (editFuzzy) {
 			case "true":
 			case "1":
@@ -266,10 +256,37 @@ export class EditTool implements AgentTool<TInput> {
 		this.writethrough = enableLsp
 			? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
 			: writethroughNoop;
-		this.description = this.patchMode
-			? renderPromptTemplate(patchDescription)
-			: renderPromptTemplate(replaceDescription);
-		this.parameters = this.patchMode ? patchEditSchema : replaceEditSchema;
+	}
+
+	/**
+	 * Determine patch mode dynamically based on current model.
+	 * This is re-evaluated on each access so tool definitions stay current when model changes.
+	 */
+	private get patchMode(): boolean {
+		if (this.envEditVariant === "replace") return false;
+		if (this.envEditVariant === "patch") return true;
+
+		// Auto mode: check model-specific settings
+		const activeModel = this.session.getActiveModelString?.();
+		const modelVariant = this.session.settings?.getEditVariantForModel?.(activeModel);
+		if (modelVariant === "replace") return false;
+		if (modelVariant === "patch") return true;
+
+		return this.session.settings?.getEditPatchMode?.() ?? true;
+	}
+
+	/**
+	 * Dynamic description based on current patch mode (which depends on current model).
+	 */
+	public get description(): string {
+		return this.patchMode ? renderPromptTemplate(patchDescription) : renderPromptTemplate(replaceDescription);
+	}
+
+	/**
+	 * Dynamic parameters schema based on current patch mode (which depends on current model).
+	 */
+	public get parameters(): TInput {
+		return this.patchMode ? patchEditSchema : replaceEditSchema;
 	}
 
 	public async execute(

package/src/prompts/tools/ask.md

@@ -10,7 +10,7 @@ Ask the user a question when you need clarification or input during task executi
 </conditions>
 
 <instruction>
-- Place recommended option first with " (Recommended)" suffix
+- Use `recommended: <index>` to mark the default option (0-indexed); " (Recommended)" suffix is added automatically
 - Use `questions` array for multiple related questions instead of asking one at a time
 - Set `multi: true` on a question to allow multiple selections
 </instruction>
@@ -37,12 +37,13 @@ If you can make a reasonable inference from the user's request, **do it**. Users
 
 <example name="single">
 question: "Which authentication method should this API use?"
-options: [{"label": "JWT (Recommended)"}, {"label": "OAuth2"}, {"label": "Session cookies"}]
+options: [{"label": "JWT"}, {"label": "OAuth2"}, {"label": "Session cookies"}]
+recommended: 0
 </example>
 
 <example name="multi-part">
 questions: [
-  {"id": "auth", "question": "Which auth method?", "options": [{"label": "JWT"}, {"label": "OAuth2"}]},
+  {"id": "auth", "question": "Which auth method?", "options": [{"label": "JWT"}, {"label": "OAuth2"}], "recommended": 0},
   {"id": "cache", "question": "Enable caching?", "options": [{"label": "Yes"}, {"label": "No"}]},
   {"id": "features", "question": "Which features to include?", "options": [{"label": "Logging"}, {"label": "Metrics"}, {"label": "Tracing"}], "multi": true}
 ]

package/src/sdk.ts

@@ -753,7 +753,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		getModelString: () => (hasExplicitModel && model ? formatModelString(model) : undefined),
 		getActiveModelString: () => {
 			const activeModel = agent?.state.model;
-			return activeModel ? formatModelString(activeModel) : undefined;
+			if (activeModel) return formatModelString(activeModel);
+			// Fall back to initial model during tool creation (before agent exists)
+			if (model) return formatModelString(model);
+			return undefined;
 		},
 		getPlanModeState: () => session.getPlanModeState(),
 		settings: settingsManager,

package/src/session/auth-storage.ts

@@ -11,11 +11,13 @@ import {
 	getOAuthApiKey,
 	githubCopilotUsageProvider,
 	googleGeminiCliUsageProvider,
+	kimiUsageProvider,
 	loginAnthropic,
 	loginAntigravity,
 	loginCursor,
 	loginGeminiCli,
 	loginGitHubCopilot,
+	loginKimi,
 	loginOpenAICodex,
 	type OAuthController,
 	type OAuthCredentials,
@@ -85,6 +87,7 @@ export type AuthStorageOptions = {
 
 const DEFAULT_USAGE_PROVIDERS: UsageProvider[] = [
 	openaiCodexUsageProvider,
+	kimiUsageProvider,
 	antigravityUsageProvider,
 	googleGeminiCliUsageProvider,
 	claudeUsageProvider,
@@ -770,6 +773,9 @@ export class AuthStorage {
 			case "openai-codex":
 				credentials = await loginOpenAICodex(ctrl);
 				break;
+			case "kimi-code":
+				credentials = await loginKimi(ctrl);
+				break;
 			case "cursor":
 				credentials = await loginCursor(
 					url => ctrl.onAuth({ url }),

package/src/task/executor.ts

@@ -6,26 +6,26 @@
 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 { ModelRegistry } from "@oh-my-pi/pi-coding-agent/config/model-registry";
-import { parseModelPattern } from "@oh-my-pi/pi-coding-agent/config/model-resolver";
-import { type PromptTemplate, renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import { SettingsManager } from "@oh-my-pi/pi-coding-agent/config/settings-manager";
-import type { CustomTool } from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
-import type { Skill } from "@oh-my-pi/pi-coding-agent/extensibility/skills";
-import { callTool } from "@oh-my-pi/pi-coding-agent/mcp/client";
-import type { MCPManager } from "@oh-my-pi/pi-coding-agent/mcp/manager";
-import { createAgentSession, discoverAuthStorage, discoverModels } from "@oh-my-pi/pi-coding-agent/sdk";
-import type { AgentSession, AgentSessionEvent } from "@oh-my-pi/pi-coding-agent/session/agent-session";
-import type { AuthStorage } from "@oh-my-pi/pi-coding-agent/session/auth-storage";
-import { SessionManager } from "@oh-my-pi/pi-coding-agent/session/session-manager";
-import type { ContextFileEntry } from "@oh-my-pi/pi-coding-agent/tools";
-import { jtdToJsonSchema } from "@oh-my-pi/pi-coding-agent/tools/jtd-to-json-schema";
-import { ToolAbortError } from "@oh-my-pi/pi-coding-agent/tools/tool-errors";
-import type { EventBus } from "@oh-my-pi/pi-coding-agent/utils/event-bus";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import Ajv, { type ValidateFunction } from "ajv";
+import type { ModelRegistry } from "../config/model-registry";
+import { parseModelPattern } from "../config/model-resolver";
+import { type PromptTemplate, renderPromptTemplate } from "../config/prompt-templates";
+import { SettingsManager } from "../config/settings-manager";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import type { Skill } from "../extensibility/skills";
+import { callTool } from "../mcp/client";
+import type { MCPManager } from "../mcp/manager";
 import subagentSystemPromptTemplate from "../prompts/system/subagent-system-prompt.md" with { type: "text" };
+import { createAgentSession, discoverAuthStorage, discoverModels } from "../sdk";
+import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
+import type { AuthStorage } from "../session/auth-storage";
+import { SessionManager } from "../session/session-manager";
+import type { ContextFileEntry } from "../tools";
+import { jtdToJsonSchema } from "../tools/jtd-to-json-schema";
+import { ToolAbortError } from "../tools/tool-errors";
+import type { EventBus } from "../utils/event-bus";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import {
 	type AgentDefinition,

package/src/tools/ask.ts

@@ -11,8 +11,8 @@
  * Usage notes:
  *   - Users will always be able to select "Other" to provide custom text input
  *   - Use multi: true to allow multiple answers to be selected for a question
- *   - If you recommend a specific option, make that the first option in the list
- *     and add "(Recommended)" at the end of the label
+ *   - Use recommended: <index> to mark the default option; "(Recommended)" suffix is added automatically
+ *   - Questions time out after 30 seconds and auto-select the recommended option
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
@@ -39,12 +39,14 @@ const QuestionItem = Type.Object({
 	question: Type.String({ description: "Question text" }),
 	options: Type.Array(OptionItem, { description: "Available options" }),
 	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections" })),
+	recommended: Type.Optional(Type.Number({ description: "Index of recommended option (0-indexed)" })),
 });
 
 const askSchema = Type.Object({
 	question: Type.Optional(Type.String({ description: "Question to ask" })),
 	options: Type.Optional(Type.Array(OptionItem, { description: "Available options" })),
 	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections (default: false)" })),
+	recommended: Type.Optional(Type.Number({ description: "Index of recommended option (0-indexed, default: 0)" })),
 	questions: Type.Optional(Type.Array(QuestionItem, { description: "Multiple questions in sequence" })),
 });
 
@@ -74,10 +76,30 @@ export interface AskToolDetails {
 // =============================================================================
 
 const OTHER_OPTION = "Other (type your own)";
+const RECOMMENDED_SUFFIX = " (Recommended)";
+
 function getDoneOptionLabel(): string {
 	return `${theme.status.success} Done selecting`;
 }
 
+/** Add "(Recommended)" suffix to the option at the given index if not already present */
+function addRecommendedSuffix(labels: string[], recommendedIndex?: number): string[] {
+	if (recommendedIndex === undefined || recommendedIndex < 0 || recommendedIndex >= labels.length) {
+		return labels;
+	}
+	return labels.map((label, i) => {
+		if (i === recommendedIndex && !label.endsWith(RECOMMENDED_SUFFIX)) {
+			return label + RECOMMENDED_SUFFIX;
+		}
+		return label;
+	});
+}
+
+/** Strip "(Recommended)" suffix from a label */
+function stripRecommendedSuffix(label: string): string {
+	return label.endsWith(RECOMMENDED_SUFFIX) ? label.slice(0, -RECOMMENDED_SUFFIX.length) : label;
+}
+
 // =============================================================================
 // Question Selection Logic
 // =============================================================================
@@ -88,7 +110,11 @@ interface SelectionResult {
 }
 
 interface UIContext {
-	select(prompt: string, options: string[], options_?: { initialIndex?: number }): Promise<string | undefined>;
+	select(
+		prompt: string,
+		options: string[],
+		options_?: { initialIndex?: number; timeout?: number },
+	): Promise<string | undefined>;
 	input(prompt: string): Promise<string | undefined>;
 }
 
@@ -97,6 +123,7 @@ async function askSingleQuestion(
 	question: string,
 	optionLabels: string[],
 	multi: boolean,
+	recommended?: number,
 ): Promise<SelectionResult> {
 	const doneLabel = getDoneOptionLabel();
 	let selectedOptions: string[] = [];
@@ -155,12 +182,16 @@ async function askSingleQuestion(
 		}
 		selectedOptions = Array.from(selected);
 	} else {
-		const choice = await ui.select(question, [...optionLabels, OTHER_OPTION]);
+		const displayLabels = addRecommendedSuffix(optionLabels, recommended);
+		const choice = await ui.select(question, [...displayLabels, OTHER_OPTION], {
+			timeout: 30000,
+			initialIndex: recommended,
+		});
 		if (choice === OTHER_OPTION) {
 			const input = await ui.input("Enter your response:");
 			if (input) customInput = input;
 		} else if (choice) {
-			selectedOptions = [choice];
+			selectedOptions = [stripRecommendedSuffix(choice)];
 		}
 	}
 
@@ -187,11 +218,13 @@ interface AskParams {
 	question?: string;
 	options?: Array<{ label: string }>;
 	multi?: boolean;
+	recommended?: number;
 	questions?: Array<{
 		id: string;
 		question: string;
 		options: Array<{ label: string }>;
 		multi?: boolean;
+		recommended?: number;
 	}>;
 }
 
@@ -243,6 +276,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					q.question,
 					optionLabels,
 					q.multi ?? false,
+					q.recommended,
 				);
 
 				results.push({
@@ -275,7 +309,13 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 			};
 		}
 
-		const { selectedOptions, customInput } = await askSingleQuestion(ui, question, optionLabels, multi);
+		const { selectedOptions, customInput } = await askSingleQuestion(
+			ui,
+			question,
+			optionLabels,
+			multi,
+			params.recommended,
+		);
 
 		const details: AskToolDetails = {
 			question,

package/src/tools/fetch.ts

@@ -20,9 +20,11 @@ import { convertWithMarkitdown, fetchBinary } from "../web/scrapers/utils";
 import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
 import type { OutputMeta } from "./output-meta";
+import { allocateOutputArtifact } from "./output-utils";
 import { formatExpandHint } from "./render-utils";
 import { ToolAbortError } from "./tool-errors";
 import { toolResult } from "./tool-result";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateHead } from "./truncate";
 
 // =============================================================================
 // Types and Constants
@@ -921,29 +923,46 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 
 		const scratchDir = this.session.getArtifactsDir?.() ?? this.session.cwd;
 		const result = await renderUrl(url, effectiveTimeout, raw, scratchDir, signal);
+		const truncation = truncateHead(result.content, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES });
+		const needsArtifact = truncation.truncated;
+		let artifactId: string | undefined;
+
+		const buildOutput = (content: string): string => {
+			let output = "";
+			output += `URL: ${result.finalUrl}\n`;
+			output += `Content-Type: ${result.contentType}\n`;
+			output += `Method: ${result.method}\n`;
+			if (result.notes.length > 0) {
+				output += `Notes: ${result.notes.join("; ")}\n`;
+			}
+			output += `\n---\n\n`;
+			output += content;
+			return output;
+		};
 
-		// Format output
-		let output = "";
-		output += `URL: ${result.finalUrl}\n`;
-		output += `Content-Type: ${result.contentType}\n`;
-		output += `Method: ${result.method}\n`;
-		if (result.notes.length > 0) {
-			output += `Notes: ${result.notes.join("; ")}\n`;
+		if (needsArtifact) {
+			const { artifactPath, artifactId: allocatedId } = await allocateOutputArtifact(this.session, "fetch");
+			if (artifactPath) {
+				await Bun.write(artifactPath, buildOutput(result.content));
+				artifactId = allocatedId;
+			}
 		}
-		output += `\n---\n\n`;
-		output += result.content;
+
+		const output = buildOutput(needsArtifact ? truncation.content : result.content);
 
 		const details: FetchToolDetails = {
 			url: result.url,
 			finalUrl: result.finalUrl,
 			contentType: result.contentType,
 			method: result.method,
-			truncated: result.truncated,
+			truncated: result.truncated || needsArtifact,
 			notes: result.notes,
 		};
 
 		const resultBuilder = toolResult(details).text(output).sourceUrl(result.finalUrl);
-		if (result.truncated) {
+		if (needsArtifact) {
+			resultBuilder.truncation(truncation, { direction: "head", artifactId });
+		} else if (result.truncated) {
 			const outputLines = result.content.split("\n").length;
 			const outputBytes = Buffer.byteLength(result.content, "utf-8");
 			const totalBytes = Math.max(outputBytes + 1, MAX_OUTPUT_CHARS + 1);

package/src/tools/index.ts

@@ -1,8 +1,7 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { SettingsManager } from "@oh-my-pi/pi-coding-agent/config/settings-manager";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { PromptTemplate } from "../config/prompt-templates";
-import type { BashInterceptorRule } from "../config/settings-manager";
+import type { BashInterceptorRule, SettingsManager } from "../config/settings-manager";
 import type { Skill } from "../extensibility/skills";
 import type { InternalUrlRouter } from "../internal-urls";
 import { getPreludeDocs, warmPythonEnvironment } from "../ipy/executor";
@@ -164,6 +163,7 @@ export interface ToolSession {
 		getEditFuzzyMatch(): boolean;
 		getEditFuzzyThreshold?(): number;
 		getEditPatchMode?(): boolean;
+		getEditVariantForModel?(model: string | undefined): "patch" | "replace" | null;
 		getBashInterceptorEnabled(): boolean;
 		getBashInterceptorSimpleLsEnabled(): boolean;
 		getBashInterceptorRules(): BashInterceptorRule[];