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

package/src/core/settings-manager.ts

@@ -26,6 +26,7 @@ export interface RetrySettings {
 
 export interface SkillsSettings {
 	enabled?: boolean; // default: true
+	enableSkillCommands?: boolean; // default: true - register skills as /skill:name commands
 	enableCodexUser?: boolean; // default: true
 	enableClaudeUser?: boolean; // default: true
 	enableClaudeProject?: boolean; // default: true
@@ -123,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"
@@ -206,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
@@ -766,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;
 	}
@@ -821,6 +859,7 @@ export class SettingsManager {
 	getSkillsSettings(): Required<SkillsSettings> {
 		return {
 			enabled: this.settings.skills?.enabled ?? true,
+			enableSkillCommands: this.settings.skills?.enableSkillCommands ?? true,
 			enableCodexUser: this.settings.skills?.enableCodexUser ?? true,
 			enableClaudeUser: this.settings.skills?.enableClaudeUser ?? true,
 			enableClaudeProject: this.settings.skills?.enableClaudeProject ?? true,
@@ -832,6 +871,10 @@ export class SettingsManager {
 		};
 	}
 
+	getEnableSkillCommands(): boolean {
+		return this.settings.skills?.enableSkillCommands ?? true;
+	}
+
 	getCommandsSettings(): Required<CommandsSettings> {
 		return {
 			enableClaudeUser: this.settings.commands?.enableClaudeUser ?? true,

package/src/core/tools/ask.ts

@@ -34,17 +34,31 @@ const OptionItem = Type.Object({
 	label: Type.String({ description: "Display label for this option" }),
 });
 
+const QuestionItem = Type.Object({
+	id: Type.String({ description: "Short identifier for this question (e.g., 'auth', 'cache')" }),
+	question: Type.String({ description: "The question text" }),
+	options: Type.Array(OptionItem, { description: "Options for this question" }),
+	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections for this question" })),
+});
+
 const askSchema = Type.Object({
-	question: Type.String({ description: "The question to ask the user" }),
-	options: Type.Array(OptionItem, { description: "Available options for the user to choose from." }),
+	question: Type.Optional(Type.String({ description: "The question to ask the user" })),
+	options: Type.Optional(Type.Array(OptionItem, { description: "Available options for the user to choose from." })),
 	multi: Type.Optional(
 		Type.Boolean({
 			description: "Allow multiple options to be selected (default: false)",
 		}),
 	),
+	questions: Type.Optional(
+		Type.Array(QuestionItem, {
+			description: "Multiple questions to ask in sequence, each with their own options",
+		}),
+	),
 });
 
-export interface AskToolDetails {
+/** Result for a single question */
+export interface QuestionResult {
+	id: string;
 	question: string;
 	options: string[];
 	multi: boolean;
@@ -52,6 +66,17 @@ export interface AskToolDetails {
 	customInput?: string;
 }
 
+export interface AskToolDetails {
+	/** Single question mode (backwards compatible) */
+	question?: string;
+	options?: string[];
+	multi?: boolean;
+	selectedOptions?: string[];
+	customInput?: string;
+	/** Multi-part question mode */
+	results?: QuestionResult[];
+}
+
 // =============================================================================
 // Constants
 // =============================================================================
@@ -61,10 +86,123 @@ function getDoneOptionLabel(): string {
 	return `${theme.status.success} Done selecting`;
 }
 
+// =============================================================================
+// Question Selection Logic
+// =============================================================================
+
+interface SelectionResult {
+	selectedOptions: string[];
+	customInput?: string;
+}
+
+interface UIContext {
+	select(prompt: string, options: string[], options_?: { initialIndex?: number }): Promise<string | undefined>;
+	input(prompt: string): Promise<string | undefined>;
+}
+
+async function askSingleQuestion(
+	ui: UIContext,
+	question: string,
+	optionLabels: string[],
+	multi: boolean,
+): Promise<SelectionResult> {
+	const doneLabel = getDoneOptionLabel();
+	let selectedOptions: string[] = [];
+	let customInput: string | undefined;
+
+	if (multi) {
+		const selected = new Set<string>();
+		let cursorIndex = 0;
+
+		while (true) {
+			const opts: string[] = [];
+
+			for (const opt of optionLabels) {
+				const checkbox = selected.has(opt) ? theme.checkbox.checked : theme.checkbox.unchecked;
+				opts.push(`${checkbox} ${opt}`);
+			}
+
+			// Done after options, before Other - so cursor stays on options after toggle
+			if (selected.size > 0) {
+				opts.push(doneLabel);
+			}
+			opts.push(OTHER_OPTION);
+
+			const prefix = selected.size > 0 ? `(${selected.size} selected) ` : "";
+			const choice = await ui.select(`${prefix}${question}`, opts, { initialIndex: cursorIndex });
+
+			if (choice === undefined || choice === doneLabel) break;
+
+			if (choice === OTHER_OPTION) {
+				const input = await ui.input("Enter your response:");
+				if (input) customInput = input;
+				break;
+			}
+
+			// Find which index was selected and update cursor position
+			const selectedIdx = opts.indexOf(choice);
+			if (selectedIdx >= 0) {
+				cursorIndex = selectedIdx;
+			}
+
+			const checkedPrefix = `${theme.checkbox.checked} `;
+			const uncheckedPrefix = `${theme.checkbox.unchecked} `;
+			let opt: string | undefined;
+			if (choice.startsWith(checkedPrefix)) {
+				opt = choice.slice(checkedPrefix.length);
+			} else if (choice.startsWith(uncheckedPrefix)) {
+				opt = choice.slice(uncheckedPrefix.length);
+			}
+			if (opt) {
+				if (selected.has(opt)) {
+					selected.delete(opt);
+				} else {
+					selected.add(opt);
+				}
+			}
+		}
+		selectedOptions = Array.from(selected);
+	} else {
+		const choice = await ui.select(question, [...optionLabels, OTHER_OPTION]);
+		if (choice === OTHER_OPTION) {
+			const input = await ui.input("Enter your response:");
+			if (input) customInput = input;
+		} else if (choice) {
+			selectedOptions = [choice];
+		}
+	}
+
+	return { selectedOptions, customInput };
+}
+
+function formatQuestionResult(result: QuestionResult): string {
+	if (result.customInput) {
+		return `${result.id}: "${result.customInput}"`;
+	}
+	if (result.selectedOptions.length > 0) {
+		return result.multi
+			? `${result.id}: [${result.selectedOptions.join(", ")}]`
+			: `${result.id}: ${result.selectedOptions[0]}`;
+	}
+	return `${result.id}: (cancelled)`;
+}
+
 // =============================================================================
 // Tool Implementation
 // =============================================================================
 
+interface AskParams {
+	question?: string;
+	options?: Array<{ label: string }>;
+	multi?: boolean;
+	questions?: Array<{
+		id: string;
+		question: string;
+		options: Array<{ label: string }>;
+		multi?: boolean;
+	}>;
+}
+
 export function createAskTool(session: ToolSession): null | AgentTool<typeof askSchema, AskToolDetails> {
 	if (!session.hasUI) {
 		return null;
@@ -77,99 +215,66 @@ export function createAskTool(session: ToolSession): null | AgentTool<typeof ask
 
 		async execute(
 			_toolCallId: string,
-			params: { question: string; options: Array<{ label: string }>; multi?: boolean },
+			params: AskParams,
 			_signal?: AbortSignal,
 			_onUpdate?: AgentToolUpdateCallback<AskToolDetails>,
 			context?: AgentToolContext,
 		) {
-			const { question, options, multi = false } = params;
-			const optionLabels = options.map((o) => o.label);
-			const doneLabel = getDoneOptionLabel();
-
-			// Headless fallback - return error if no UI available
+			// Headless fallback
 			if (!context?.hasUI || !context.ui) {
 				return {
-					content: [
-						{
-							type: "text" as const,
-							text: "Error: User prompt requires interactive mode",
-						},
-					],
-					details: {
-						question,
-						options: optionLabels,
-						multi,
-						selectedOptions: [],
-					},
+					content: [{ type: "text" as const, text: "Error: User prompt requires interactive mode" }],
+					details: {},
 				};
 			}
 
 			const { ui } = context;
-			let selectedOptions: string[] = [];
-			let customInput: string | undefined;
-
-			if (multi) {
-				// Multi-select: show checkboxes in the label to indicate selection state
-				const selected = new Set<string>();
-
-				while (true) {
-					// Build options with checkbox indicators
-					const opts: string[] = [];
-
-					// Add "Done" option if any selected
-					if (selected.size > 0) {
-						opts.push(doneLabel);
-					}
-
-					// Add all options with checkbox prefix
-					for (const opt of optionLabels) {
-						const checkbox = selected.has(opt) ? theme.checkbox.checked : theme.checkbox.unchecked;
-						opts.push(`${checkbox} ${opt}`);
-					}
 
-					// Add "Other" option
-					opts.push(OTHER_OPTION);
+			// Multi-part questions mode
+			if (params.questions && params.questions.length > 0) {
+				const results: QuestionResult[] = [];
+
+				for (const q of params.questions) {
+					const optionLabels = q.options.map((o) => o.label);
+					const { selectedOptions, customInput } = await askSingleQuestion(
+						ui,
+						q.question,
+						optionLabels,
+						q.multi ?? false,
+					);
+
+					results.push({
+						id: q.id,
+						question: q.question,
+						options: optionLabels,
+						multi: q.multi ?? false,
+						selectedOptions,
+						customInput,
+					});
+				}
 
-					const prefix = selected.size > 0 ? `(${selected.size} selected) ` : "";
-					const choice = await ui.select(`${prefix}${question}`, opts);
+				const details: AskToolDetails = { results };
+				const responseLines = results.map(formatQuestionResult);
+				const responseText = `User answers:\n${responseLines.join("\n")}`;
 
-					if (choice === undefined || choice === doneLabel) break;
+				return { content: [{ type: "text" as const, text: responseText }], details };
+			}
 
-					if (choice === OTHER_OPTION) {
-						const input = await ui.input("Enter your response:");
-						if (input) customInput = input;
-						break;
-					}
+			// Single question mode (backwards compatible)
+			const question = params.question ?? "";
+			const options = params.options ?? [];
+			const multi = params.multi ?? false;
+			const optionLabels = options.map((o) => o.label);
 
-					// Toggle selection - extract the actual option name
-					const checkedPrefix = `${theme.checkbox.checked} `;
-					const uncheckedPrefix = `${theme.checkbox.unchecked} `;
-					let opt: string | undefined;
-					if (choice.startsWith(checkedPrefix)) {
-						opt = choice.slice(checkedPrefix.length);
-					} else if (choice.startsWith(uncheckedPrefix)) {
-						opt = choice.slice(uncheckedPrefix.length);
-					}
-					if (opt) {
-						if (selected.has(opt)) {
-							selected.delete(opt);
-						} else {
-							selected.add(opt);
-						}
-					}
-				}
-				selectedOptions = Array.from(selected);
-			} else {
-				// Single select with "Other" option
-				const choice = await ui.select(question, [...optionLabels, OTHER_OPTION]);
-				if (choice === OTHER_OPTION) {
-					const input = await ui.input("Enter your response:");
-					if (input) customInput = input;
-				} else if (choice) {
-					selectedOptions = [choice];
-				}
+			if (!question || optionLabels.length === 0) {
+				return {
+					content: [{ type: "text" as const, text: "Error: question and options are required" }],
+					details: {},
+				};
 			}
 
+			const { selectedOptions, customInput } = await askSingleQuestion(ui, question, optionLabels, multi);
+
 			const details: AskToolDetails = {
 				question,
 				options: optionLabels,
@@ -207,21 +312,59 @@ export const askTool = createAskTool({
 // =============================================================================
 
 interface AskRenderArgs {
-	question: string;
+	question?: string;
 	options?: Array<{ label: string }>;
 	multi?: boolean;
+	questions?: Array<{
+		id: string;
+		question: string;
+		options: Array<{ label: string }>;
+		multi?: boolean;
+	}>;
 }
 
 export const askToolRenderer = {
 	renderCall(args: AskRenderArgs, uiTheme: Theme): Component {
 		const ui = createToolUIKit(uiTheme);
+		const label = ui.title("Ask");
+
+		// Multi-part questions
+		if (args.questions && args.questions.length > 0) {
+			let text = `${label} ${uiTheme.fg("muted", `${args.questions.length} questions`)}`;
+
+			for (let i = 0; i < args.questions.length; i++) {
+				const q = args.questions[i];
+				const isLastQ = i === args.questions.length - 1;
+				const qBranch = isLastQ ? uiTheme.tree.last : uiTheme.tree.branch;
+				const continuation = isLastQ ? " " : uiTheme.tree.vertical;
+
+				// Question line with metadata
+				const meta: string[] = [];
+				if (q.multi) meta.push("multi");
+				if (q.options?.length) meta.push(`options:${q.options.length}`);
+				const metaStr = meta.length > 0 ? uiTheme.fg("dim", ` · ${meta.join(" · ")}`) : "";
+
+				text += `\n ${uiTheme.fg("dim", qBranch)} ${uiTheme.fg("dim", `[${q.id}]`)} ${uiTheme.fg("accent", q.question)}${metaStr}`;
+
+				// Options under question
+				if (q.options?.length) {
+					for (let j = 0; j < q.options.length; j++) {
+						const opt = q.options[j];
+						const isLastOpt = j === q.options.length - 1;
+						const optBranch = isLastOpt ? uiTheme.tree.last : uiTheme.tree.branch;
+						text += `\n ${uiTheme.fg("dim", continuation)}   ${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} ${uiTheme.fg("muted", opt.label)}`;
+					}
+				}
+			}
+			return new Text(text, 0, 0);
+		}
+
+		// Single question
 		if (!args.question) {
 			return new Text(ui.errorMessage("No question provided"), 0, 0);
 		}
 
-		const label = ui.title("Ask");
 		let text = `${label} ${uiTheme.fg("accent", args.question)}`;
-
 		const meta: string[] = [];
 		if (args.multi) meta.push("multi");
 		if (args.options?.length) meta.push(`options:${args.options.length}`);
@@ -250,7 +393,47 @@ export const askToolRenderer = {
 			return new Text(txt?.type === "text" && txt.text ? txt.text : "", 0, 0);
 		}
 
-		const hasSelection = details.customInput || details.selectedOptions.length > 0;
+		// Multi-part results
+		if (details.results && details.results.length > 0) {
+			const lines: string[] = [];
+
+			for (const r of details.results) {
+				const hasSelection = r.customInput || r.selectedOptions.length > 0;
+				const statusIcon = hasSelection
+					? uiTheme.styledSymbol("status.success", "success")
+					: uiTheme.styledSymbol("status.warning", "warning");
+
+				lines.push(`${statusIcon} ${uiTheme.fg("dim", `[${r.id}]`)} ${uiTheme.fg("accent", r.question)}`);
+
+				if (r.customInput) {
+					lines.push(
+						` ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", r.customInput)}`,
+					);
+				} else if (r.selectedOptions.length > 0) {
+					for (let j = 0; j < r.selectedOptions.length; j++) {
+						const isLast = j === r.selectedOptions.length - 1;
+						const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+						lines.push(
+							` ${uiTheme.fg("dim", branch)} ${uiTheme.fg("success", uiTheme.checkbox.checked)} ${uiTheme.fg("toolOutput", r.selectedOptions[j])}`,
+						);
+					}
+				} else {
+					lines.push(
+						` ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.warning", "warning")} ${uiTheme.fg("warning", "Cancelled")}`,
+					);
+				}
+			}
+
+			return new Text(lines.join("\n"), 0, 0);
+		}
+
+		// Single question result
+		if (!details.question) {
+			const txt = result.content[0];
+			return new Text(txt?.type === "text" && txt.text ? txt.text : "", 0, 0);
+		}
+
+		const hasSelection = details.customInput || (details.selectedOptions && details.selectedOptions.length > 0);
 		const statusIcon = hasSelection
 			? uiTheme.styledSymbol("status.success", "success")
 			: uiTheme.styledSymbol("status.warning", "warning");
@@ -258,25 +441,15 @@ export const askToolRenderer = {
 		let text = `${statusIcon} ${uiTheme.fg("accent", details.question)}`;
 
 		if (details.customInput) {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol(
-				"status.success",
-				"success",
-			)} ${uiTheme.fg("toolOutput", details.customInput)}`;
-		} else if (details.selectedOptions.length > 0) {
-			const selected = details.selectedOptions;
-			for (let i = 0; i < selected.length; i++) {
-				const isLast = i === selected.length - 1;
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", details.customInput)}`;
+		} else if (details.selectedOptions && details.selectedOptions.length > 0) {
+			for (let i = 0; i < details.selectedOptions.length; i++) {
+				const isLast = i === details.selectedOptions.length - 1;
 				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
-				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg(
-					"success",
-					uiTheme.checkbox.checked,
-				)} ${uiTheme.fg("toolOutput", selected[i])}`;
+				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("success", uiTheme.checkbox.checked)} ${uiTheme.fg("toolOutput", details.selectedOptions[i])}`;
 			}
 		} else {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol(
-				"status.warning",
-				"warning",
-			)} ${uiTheme.fg("warning", "Cancelled")}`;
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.warning", "warning")} ${uiTheme.fg("warning", "Cancelled")}`;
 		}
 
 		return new Text(text, 0, 0);

package/src/core/tools/index.ts

@@ -1,5 +1,5 @@
 export { type AskToolDetails, askTool, createAskTool } from "./ask";
-export { type BashOperations, type BashToolDetails, createBashTool } from "./bash";
+export { type BashOperations, type BashToolDetails, type BashToolOptions, createBashTool } from "./bash";
 export { type CalculatorToolDetails, createCalculatorTool } from "./calculator";
 export { createCompleteTool } from "./complete";
 export { createEditTool, type EditToolDetails } from "./edit";

package/src/core/tools/schema-validation.test.ts

@@ -198,6 +198,36 @@ describe("sanitizeSchemaForGoogle", () => {
 		expect(sanitizeSchemaForGoogle(true)).toBe(true);
 		expect(sanitizeSchemaForGoogle(null)).toBe(null);
 	});
+
+	it("preserves property names that match schema keywords (e.g., 'pattern')", () => {
+		const schema = {
+			type: "object",
+			properties: {
+				pattern: { type: "string", description: "The search pattern" },
+				format: { type: "string", description: "Output format" },
+			},
+			required: ["pattern"],
+		};
+		const sanitized = sanitizeSchemaForGoogle(schema) as Record<string, unknown>;
+		const props = sanitized.properties as Record<string, unknown>;
+		expect(props.pattern).toEqual({ type: "string", description: "The search pattern" });
+		expect(props.format).toEqual({ type: "string", description: "Output format" });
+		expect(sanitized.required).toEqual(["pattern"]);
+	});
+
+	it("still strips schema keywords from non-properties contexts", () => {
+		const schema = {
+			type: "string",
+			pattern: "^[a-z]+$",
+			format: "email",
+			minLength: 1,
+		};
+		const sanitized = sanitizeSchemaForGoogle(schema) as Record<string, unknown>;
+		expect(sanitized.pattern).toBeUndefined();
+		expect(sanitized.format).toBeUndefined();
+		expect(sanitized.minLength).toBeUndefined();
+		expect(sanitized.type).toBe("string");
+	});
 });
 
 describe("tool schema validation (post-sanitization)", () => {

package/src/core/tools/task/model-resolver.ts

@@ -118,6 +118,15 @@ function getModelId(fullModel: string): string {
 	return slashIdx > 0 ? fullModel.slice(slashIdx + 1) : fullModel;
 }
 
+/**
+ * Extract provider from "provider/modelId" format.
+ * Returns undefined if no provider prefix.
+ */
+function getProvider(fullModel: string): string | undefined {
+	const slashIdx = fullModel.indexOf("/");
+	return slashIdx > 0 ? fullModel.slice(0, slashIdx) : undefined;
+}
+
 /**
  * Resolve a fuzzy model pattern to "provider/modelId" format.
  *
@@ -165,8 +174,25 @@ export async function resolveModelPattern(
 		const exactId = models.find((m) => getModelId(m).toLowerCase() === p.toLowerCase());
 		if (exactId) return exactId;
 
-		// Try fuzzy match on model ID (substring)
-		const fuzzyMatch = models.find((m) => getModelId(m).toLowerCase().includes(p.toLowerCase()));
+		// Check if pattern has provider prefix (e.g., "zai/glm-4.7")
+		const patternProvider = getProvider(p);
+		const patternModelId = getModelId(p);
+
+		// If pattern has provider prefix, fuzzy match must stay within that provider
+		// (don't cross provider boundaries when user explicitly specifies provider)
+		if (patternProvider) {
+			const providerFuzzyMatch = models.find(
+				(m) =>
+					getProvider(m)?.toLowerCase() === patternProvider.toLowerCase() &&
+					getModelId(m).toLowerCase().includes(patternModelId.toLowerCase()),
+			);
+			if (providerFuzzyMatch) return providerFuzzyMatch;
+			// No match in specified provider - don't fall through to other providers
+			continue;
+		}
+
+		// No provider prefix - fall back to general fuzzy match on model ID (substring)
+		const fuzzyMatch = models.find((m) => getModelId(m).toLowerCase().includes(patternModelId.toLowerCase()));
 		if (fuzzyMatch) return fuzzyMatch;
 	}
 

package/src/main.ts

@@ -10,6 +10,7 @@ import { join, resolve } from "node:path";
 import { type ImageContent, supportsXhigh } from "@oh-my-pi/pi-ai";
 import chalk from "chalk";
 import { type Args, parseArgs, printHelp } from "./cli/args";
+import { parseConfigArgs, printConfigHelp, runConfigCommand } from "./cli/config-cli";
 import { processFileArguments } from "./cli/file-processor";
 import { listModels } from "./cli/list-models";
 import { parsePluginArgs, printPluginHelp, runPluginCommand } from "./cli/plugin-cli";
@@ -418,6 +419,17 @@ export async function main(args: string[]) {
 		return;
 	}
 
+	// Handle config subcommand
+	const configCmd = parseConfigArgs(args);
+	if (configCmd) {
+		if (args.includes("--help") || args.includes("-h")) {
+			printConfigHelp();
+			return;
+		}
+		await runConfigCommand(configCmd);
+		return;
+	}
+
 	const parsed = parseArgs(args);
 	time("parseArgs");
 	await maybeAutoChdir(parsed);

package/src/modes/interactive/components/hook-editor.ts

@@ -113,7 +113,7 @@ export class HookEditorComponent extends Container {
 				// Ignore cleanup errors
 			}
 			this.tui.start();
-			this.tui.requestRender();
+			this.tui.requestRender(true);
 		}
 	}
 }

package/src/modes/interactive/components/hook-message.ts

@@ -36,6 +36,11 @@ export class HookMessageComponent extends Container {
 		}
 	}
 
+	override invalidate(): void {
+		super.invalidate();
+		this.rebuild();
+	}
+
 	private rebuild(): void {
 		// Remove previous content component
 		if (this.customComponent) {