@oh-my-pi/pi-coding-agent 4.6.0 → 4.7.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [4.7.0] - 2026-01-12
+### Added
+
+- Add `omp config` subcommand for managing settings (`list`, `get`, `set`, `reset`, `path`)
+- Add `todoCompletion` setting to warn agent when it stops with incomplete todos (up to 3 reminders)
+- Add multi-part questions support to `ask` tool via `questions` array parameter
+
+### Changed
+
+- Updated multi-select cursor behavior in `ask` tool to stay on the toggled option instead of jumping to top
+- Single-file reads now render inline (e.g., `Read AGENTS.md:23`) instead of tree structure
+
+### Fixed
+
+- Subagent model resolution now respects explicit provider prefix (e.g., `zai/glm-4.7` no longer matches `cerebras/zai-glm-4.7`)
+- Auto-compaction now skips to next model candidate when retry delay exceeds 30 seconds
+
 ## [4.6.0] - 2026-01-12
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "4.6.0",
+	"version": "4.7.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,10 +39,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "4.6.0",
-		"@oh-my-pi/pi-agent-core": "4.6.0",
-		"@oh-my-pi/pi-git-tool": "4.6.0",
-		"@oh-my-pi/pi-tui": "4.6.0",
+		"@oh-my-pi/pi-ai": "4.7.0",
+		"@oh-my-pi/pi-agent-core": "4.7.0",
+		"@oh-my-pi/pi-git-tool": "4.7.0",
+		"@oh-my-pi/pi-tui": "4.7.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/cli/config-cli.ts

@@ -0,0 +1,344 @@
+/**
+ * Config CLI command handlers.
+ *
+ * Handles `omp config <command>` subcommands for managing settings.
+ * Uses SETTINGS_DEFS as the source of truth for available settings.
+ */
+
+import chalk from "chalk";
+import { APP_NAME, getAgentDir } from "../config";
+import { SettingsManager } from "../core/settings-manager";
+import { SETTINGS_DEFS, type SettingDef } from "../modes/interactive/components/settings-defs";
+import { theme } from "../modes/interactive/theme/theme";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export type ConfigAction = "list" | "get" | "set" | "reset" | "path";
+
+export interface ConfigCommandArgs {
+	action: ConfigAction;
+	key?: string;
+	value?: string;
+	flags: {
+		json?: boolean;
+	};
+}
+
+// =============================================================================
+// Setting Filtering
+// =============================================================================
+
+/** Find setting definition by ID */
+function findSettingDef(id: string): SettingDef | undefined {
+	return SETTINGS_DEFS.find((def) => def.id === id);
+}
+
+/** Get available values for a setting */
+function getSettingValues(def: SettingDef, sm: SettingsManager): readonly string[] | undefined {
+	if (def.type === "enum") {
+		return def.values;
+	}
+	if (def.type === "submenu") {
+		const options = def.getOptions(sm);
+		if (options.length > 0) {
+			return options.map((o) => o.value);
+		}
+	}
+	return undefined;
+}
+
+// =============================================================================
+// Argument Parser
+// =============================================================================
+
+const VALID_ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path"];
+
+/**
+ * Parse config subcommand arguments.
+ * Returns undefined if not a config command.
+ */
+export function parseConfigArgs(args: string[]): ConfigCommandArgs | undefined {
+	if (args.length === 0 || args[0] !== "config") {
+		return undefined;
+	}
+
+	if (args.length < 2 || args[1] === "--help" || args[1] === "-h") {
+		return { action: "list", flags: {} };
+	}
+
+	const action = args[1];
+	if (!VALID_ACTIONS.includes(action as ConfigAction)) {
+		console.error(chalk.red(`Unknown config command: ${action}`));
+		console.error(`Valid commands: ${VALID_ACTIONS.join(", ")}`);
+		process.exit(1);
+	}
+
+	const result: ConfigCommandArgs = {
+		action: action as ConfigAction,
+		flags: {},
+	};
+
+	const positionalArgs: string[] = [];
+	for (let i = 2; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--json") {
+			result.flags.json = true;
+		} else if (!arg.startsWith("-")) {
+			positionalArgs.push(arg);
+		}
+	}
+
+	if (positionalArgs.length > 0) {
+		result.key = positionalArgs[0];
+	}
+	if (positionalArgs.length > 1) {
+		result.value = positionalArgs.slice(1).join(" ");
+	}
+
+	return result;
+}
+
+// =============================================================================
+// Value Parsing
+// =============================================================================
+
+function parseValue(value: string, def: SettingDef, sm: SettingsManager): unknown {
+	if (def.type === "boolean") {
+		const lower = value.toLowerCase();
+		if (lower === "true" || lower === "1" || lower === "yes" || lower === "on") {
+			return true;
+		}
+		if (lower === "false" || lower === "0" || lower === "no" || lower === "off") {
+			return false;
+		}
+		throw new Error(`Invalid boolean value: ${value}. Use true/false, yes/no, on/off, or 1/0`);
+	}
+
+	const validValues = getSettingValues(def, sm);
+	if (validValues && validValues.length > 0 && !validValues.includes(value)) {
+		throw new Error(`Invalid value: ${value}. Valid values: ${validValues.join(", ")}`);
+	}
+
+	return value;
+}
+
+function formatValue(value: unknown): string {
+	if (value === undefined || value === null) {
+		return chalk.dim("(not set)");
+	}
+	if (typeof value === "boolean") {
+		return value ? chalk.green("true") : chalk.red("false");
+	}
+	if (typeof value === "number") {
+		return chalk.cyan(String(value));
+	}
+	return chalk.yellow(String(value));
+}
+
+function getTypeDisplay(def: SettingDef, sm: SettingsManager): string {
+	if (def.type === "boolean") {
+		return "(boolean)";
+	}
+	const values = getSettingValues(def, sm);
+	if (values && values.length > 0) {
+		return `(${values.join("|")})`;
+	}
+	return "(string)";
+}
+
+// =============================================================================
+// Command Handlers
+// =============================================================================
+
+export async function runConfigCommand(cmd: ConfigCommandArgs): Promise<void> {
+	const settingsManager = await SettingsManager.create();
+
+	switch (cmd.action) {
+		case "list":
+			handleList(settingsManager, cmd.flags);
+			break;
+		case "get":
+			handleGet(settingsManager, cmd.key, cmd.flags);
+			break;
+		case "set":
+			await handleSet(settingsManager, cmd.key, cmd.value, cmd.flags);
+			break;
+		case "reset":
+			await handleReset(settingsManager, cmd.key, cmd.flags);
+			break;
+		case "path":
+			handlePath();
+			break;
+	}
+}
+
+function handleList(settingsManager: SettingsManager, flags: { json?: boolean }): void {
+	if (flags.json) {
+		const result: Record<string, { value: unknown; type: string; description: string }> = {};
+		for (const def of SETTINGS_DEFS) {
+			result[def.id] = {
+				value: def.get(settingsManager),
+				type: def.type,
+				description: def.description,
+			};
+		}
+		console.log(JSON.stringify(result, null, 2));
+		return;
+	}
+
+	console.log(chalk.bold("Settings:\n"));
+
+	// Group by tab
+	const groups: Record<string, SettingDef[]> = {};
+	for (const def of SETTINGS_DEFS) {
+		if (!groups[def.tab]) {
+			groups[def.tab] = [];
+		}
+		groups[def.tab].push(def);
+	}
+
+	const sortedGroups = Object.keys(groups).sort((a, b) => {
+		if (a === "config") return -1;
+		if (b === "config") return 1;
+		return a.localeCompare(b);
+	});
+
+	for (const group of sortedGroups) {
+		console.log(chalk.bold.blue(`[${group}]`));
+		for (const def of groups[group]) {
+			const value = def.get(settingsManager);
+			const valueStr = formatValue(value);
+			const typeStr = getTypeDisplay(def, settingsManager);
+			console.log(`  ${chalk.white(def.id)} = ${valueStr} ${chalk.dim(typeStr)}`);
+		}
+		console.log("");
+	}
+}
+
+function handleGet(settingsManager: SettingsManager, key: string | undefined, flags: { json?: boolean }): void {
+	if (!key) {
+		console.error(chalk.red(`Usage: ${APP_NAME} config get <key>`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	const def = findSettingDef(key);
+	if (!def) {
+		console.error(chalk.red(`Unknown setting: ${key}`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	const value = def.get(settingsManager);
+
+	if (flags.json) {
+		console.log(JSON.stringify({ key: def.id, value, type: def.type, description: def.description }, null, 2));
+		return;
+	}
+
+	console.log(formatValue(value));
+}
+
+async function handleSet(
+	settingsManager: SettingsManager,
+	key: string | undefined,
+	value: string | undefined,
+	flags: { json?: boolean },
+): Promise<void> {
+	if (!key || value === undefined) {
+		console.error(chalk.red(`Usage: ${APP_NAME} config set <key> <value>`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	const def = findSettingDef(key);
+	if (!def) {
+		console.error(chalk.red(`Unknown setting: ${key}`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	let parsedValue: unknown;
+	try {
+		parsedValue = parseValue(value, def, settingsManager);
+	} catch (err) {
+		console.error(chalk.red(String(err)));
+		process.exit(1);
+	}
+
+	def.set(settingsManager, parsedValue as never);
+
+	if (flags.json) {
+		console.log(JSON.stringify({ key: def.id, value: parsedValue }));
+	} else {
+		console.log(chalk.green(`${theme.status.success} Set ${def.id} = ${formatValue(parsedValue)}`));
+	}
+}
+
+async function handleReset(
+	settingsManager: SettingsManager,
+	key: string | undefined,
+	flags: { json?: boolean },
+): Promise<void> {
+	if (!key) {
+		console.error(chalk.red(`Usage: ${APP_NAME} config reset <key>`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	const def = findSettingDef(key);
+	if (!def) {
+		console.error(chalk.red(`Unknown setting: ${key}`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	// Get default value from a fresh in-memory settings manager
+	const defaults = SettingsManager.inMemory();
+	const defaultValue = def.get(defaults);
+
+	def.set(settingsManager, defaultValue as never);
+
+	if (flags.json) {
+		console.log(JSON.stringify({ key: def.id, value: defaultValue }));
+	} else {
+		console.log(chalk.green(`${theme.status.success} Reset ${def.id} to ${formatValue(defaultValue)}`));
+	}
+}
+
+function handlePath(): void {
+	console.log(getAgentDir());
+}
+
+// =============================================================================
+// Help
+// =============================================================================
+
+export function printConfigHelp(): void {
+	console.log(`${chalk.bold(`${APP_NAME} config`)} - Manage settings
+
+${chalk.bold("Commands:")}
+  list               List all settings with current values
+  get <key>          Get a specific setting value
+  set <key> <value>  Set a setting value
+  reset <key>        Reset a setting to its default value
+  path               Print the config directory path
+
+${chalk.bold("Options:")}
+  --json             Output as JSON
+
+${chalk.bold("Examples:")}
+  ${APP_NAME} config list
+  ${APP_NAME} config get theme
+  ${APP_NAME} config set theme catppuccin-mocha
+  ${APP_NAME} config set autoCompact false
+  ${APP_NAME} config set thinkingLevel medium
+  ${APP_NAME} config reset steeringMode
+  ${APP_NAME} config list --json
+
+${chalk.bold("Boolean Values:")}
+  true, false, yes, no, on, off, 1, 0
+`);
+}

package/src/core/agent-session.ts

@@ -57,6 +57,8 @@ import { expandSlashCommand, type FileSlashCommand } from "./slash-commands";
 import { closeAllConnections } from "./ssh/connection-manager";
 import { unmountAll } from "./ssh/sshfs-mount";
 import type { BashOperations } from "./tools/bash";
+import { getArtifactsDir } from "./tools/task/artifacts";
+import type { TodoItem } from "./tools/todo-write";
 import type { TtsrManager } from "./ttsr";
 
 /** Session-specific events that extend the core AgentEvent */
@@ -66,7 +68,8 @@ export type AgentSessionEvent =
 	| { type: "auto_compaction_end"; result: CompactionResult | undefined; aborted: boolean; willRetry: boolean }
 	| { type: "auto_retry_start"; attempt: number; maxAttempts: number; delayMs: number; errorMessage: string }
 	| { type: "auto_retry_end"; success: boolean; attempt: number; finalError?: string }
-	| { type: "ttsr_triggered"; rules: Rule[] };
+	| { type: "ttsr_triggered"; rules: Rule[] }
+	| { type: "todo_reminder"; todos: TodoItem[]; attempt: number; maxAttempts: number };
 
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
@@ -228,6 +231,9 @@ export class AgentSession {
 	private _retryPromise: Promise<void> | undefined = undefined;
 	private _retryResolve: (() => void) | undefined = undefined;
 
+	// Todo completion reminder state
+	private _todoReminderCount = 0;
+
 	// Bash execution state
 	private _bashAbortController: AbortController | undefined = undefined;
 	private _pendingBashMessages: BashExecutionMessage[] = [];
@@ -442,6 +448,11 @@ export class AgentSession {
 			}
 
 			await this._checkCompaction(msg);
+
+			// Check for incomplete todos (unless there was an error or abort)
+			if (msg.stopReason !== "error" && msg.stopReason !== "aborted") {
+				await this._checkTodoCompletion();
+			}
 		}
 	};
 
@@ -757,6 +768,9 @@ export class AgentSession {
 		// Flush any pending bash messages before the new prompt
 		this._flushPendingBashMessages();
 
+		// Reset todo reminder count on new user prompt
+		this._todoReminderCount = 0;
+
 		// Validate model
 		if (!this.model) {
 			throw new Error(
@@ -1218,6 +1232,7 @@ export class AgentSession {
 		this._steeringMessages = [];
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
+		this._todoReminderCount = 0;
 		this._reconnectToAgent();
 
 		// Emit session_switch event with reason "new" to hooks
@@ -1702,6 +1717,83 @@ export class AgentSession {
 		}
 	}
 
+	/**
+	 * Check if agent stopped with incomplete todos and prompt to continue.
+	 */
+	private async _checkTodoCompletion(): Promise<void> {
+		const settings = this.settingsManager.getTodoCompletionSettings();
+		if (!settings.enabled) {
+			this._todoReminderCount = 0;
+			return;
+		}
+
+		const maxReminders = settings.maxReminders ?? 3;
+		if (this._todoReminderCount >= maxReminders) {
+			logger.debug("Todo completion: max reminders reached", { count: this._todoReminderCount });
+			return;
+		}
+
+		// Load current todos from artifacts
+		const sessionFile = this.sessionManager.getSessionFile();
+		if (!sessionFile) return;
+
+		const artifactsDir = getArtifactsDir(sessionFile);
+		if (!artifactsDir) return;
+
+		const todoPath = `${artifactsDir}/todos.json`;
+		const file = Bun.file(todoPath);
+		if (!(await file.exists())) {
+			this._todoReminderCount = 0;
+			return;
+		}
+
+		let todos: TodoItem[];
+		try {
+			const data = await file.json();
+			todos = data?.todos ?? [];
+		} catch {
+			return;
+		}
+
+		// Check for incomplete todos
+		const incomplete = todos.filter((t) => t.status !== "completed");
+		if (incomplete.length === 0) {
+			this._todoReminderCount = 0;
+			return;
+		}
+
+		// Build reminder message
+		this._todoReminderCount++;
+		const todoList = incomplete.map((t) => `- ${t.content}`).join("\n");
+		const reminder =
+			`<system_reminder>\n` +
+			`You stopped with ${incomplete.length} incomplete todo item(s):\n${todoList}\n\n` +
+			`Please continue working on these tasks or mark them complete if finished.\n` +
+			`(Reminder ${this._todoReminderCount}/${maxReminders})\n` +
+			`</system_reminder>`;
+
+		logger.debug("Todo completion: sending reminder", {
+			incomplete: incomplete.length,
+			attempt: this._todoReminderCount,
+		});
+
+		// Emit event for UI to render notification
+		this._emit({
+			type: "todo_reminder",
+			todos: incomplete,
+			attempt: this._todoReminderCount,
+			maxAttempts: maxReminders,
+		});
+
+		// Inject reminder and continue the conversation
+		this.agent.appendMessage({
+			role: "user",
+			content: [{ type: "text", text: reminder }],
+			timestamp: Date.now(),
+		});
+		this.agent.continue().catch(() => {});
+	}
+
 	private _getModelKey(model: Model<any>): string {
 		return `${model.provider}/${model.id}`;
 	}
@@ -1862,6 +1954,24 @@ export class AgentSession {
 
 							const baseDelayMs = retrySettings.baseDelayMs * 2 ** attempt;
 							const delayMs = retryAfterMs !== undefined ? Math.max(baseDelayMs, retryAfterMs) : baseDelayMs;
+
+							// If retry delay is too long (>30s), try next candidate instead of waiting
+							const maxAcceptableDelayMs = 30_000;
+							if (delayMs > maxAcceptableDelayMs) {
+								const hasMoreCandidates = candidates.indexOf(candidate) < candidates.length - 1;
+								if (hasMoreCandidates) {
+									logger.warn("Auto-compaction retry delay too long, trying next model", {
+										delayMs,
+										retryAfterMs,
+										error: message,
+										model: `${candidate.provider}/${candidate.id}`,
+									});
+									lastError = error;
+									break; // Exit retry loop, continue to next candidate
+								}
+								// No more candidates - we have to wait
+							}
+
 							attempt++;
 							logger.warn("Auto-compaction failed, retrying", {
 								attempt,
@@ -1869,6 +1979,7 @@ export class AgentSession {
 								delayMs,
 								retryAfterMs,
 								error: message,
+								model: `${candidate.provider}/${candidate.id}`,
 							});
 							await new Promise((resolve) => setTimeout(resolve, delayMs));
 						}

package/src/core/extensions/types.ts

@@ -46,6 +46,8 @@ export type { AppAction, KeybindingsManager } from "../keybindings";
 export interface ExtensionUIDialogOptions {
 	signal?: AbortSignal;
 	timeout?: number;
+	/** Initial cursor position for select dialogs (0-indexed) */
+	initialIndex?: number;
 }
 
 /**

package/src/core/settings-manager.ts

@@ -124,6 +124,11 @@ export interface TtsrSettings {
 	repeatGap?: number; // default: 10
 }
 
+export interface TodoCompletionSettings {
+	enabled?: boolean; // default: false - warn agent when it stops with incomplete todos
+	maxReminders?: number; // default: 3 - maximum reminders before giving up
+}
+
 export interface VoiceSettings {
 	enabled?: boolean; // default: false
 	transcriptionModel?: string; // default: "whisper-1"
@@ -207,6 +212,7 @@ export interface Settings {
 	lsp?: LspSettings;
 	edit?: EditSettings;
 	ttsr?: TtsrSettings;
+	todoCompletion?: TodoCompletionSettings;
 	voice?: VoiceSettings;
 	providers?: ProviderSettings;
 	disabledProviders?: string[]; // Discovery provider IDs that are disabled
@@ -767,6 +773,37 @@ export class SettingsManager {
 		};
 	}
 
+	getTodoCompletionSettings(): { enabled: boolean; maxReminders: number } {
+		return {
+			enabled: this.settings.todoCompletion?.enabled ?? false,
+			maxReminders: this.settings.todoCompletion?.maxReminders ?? 3,
+		};
+	}
+
+	getTodoCompletionEnabled(): boolean {
+		return this.settings.todoCompletion?.enabled ?? false;
+	}
+
+	async setTodoCompletionEnabled(enabled: boolean): Promise<void> {
+		if (!this.globalSettings.todoCompletion) {
+			this.globalSettings.todoCompletion = {};
+		}
+		this.globalSettings.todoCompletion.enabled = enabled;
+		await this.save();
+	}
+
+	getTodoCompletionMaxReminders(): number {
+		return this.settings.todoCompletion?.maxReminders ?? 3;
+	}
+
+	async setTodoCompletionMaxReminders(maxReminders: number): Promise<void> {
+		if (!this.globalSettings.todoCompletion) {
+			this.globalSettings.todoCompletion = {};
+		}
+		this.globalSettings.todoCompletion.maxReminders = maxReminders;
+		await this.save();
+	}
+
 	getThinkingBudgets(): ThinkingBudgetsSettings | undefined {
 		return this.settings.thinkingBudgets;
 	}