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

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [4.6.0] - 2026-01-12
+
+### Added
+- Add `/skill:name` slash commands for quick skill access (toggle via `skills.enableSkillCommands` setting)
+- Add `cwd` to SessionInfo for session list display
+- Add custom summarization instructions option in tree selector
+- Add Alt+Up (dequeue) to restore all queued messages at once
+- Add `shutdownRequested` and `checkShutdownRequested()` for extension-initiated shutdown
+
+### Fixed
+- Component `invalidate()` now properly rebuilds content on theme changes
+- Force full re-render after returning from external editor
+
 ## [4.5.0] - 2026-01-12
 
 ## [4.4.9] - 2026-01-12

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "4.5.0",
+	"version": "4.6.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.5.0",
-		"@oh-my-pi/pi-agent-core": "4.5.0",
-		"@oh-my-pi/pi-git-tool": "4.5.0",
-		"@oh-my-pi/pi-tui": "4.5.0",
+		"@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",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/hooks/loader.ts

@@ -25,7 +25,7 @@ type HandlerFn = (...args: unknown[]) => Promise<unknown>;
  */
 export type SendMessageHandler = <T = unknown>(
 	message: Pick<HookMessage<T>, "customType" | "content" | "display" | "details">,
-	triggerTurn?: boolean,
+	options?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" },
 ) => void;
 
 /**
@@ -129,11 +129,14 @@ function createHookAPI(
 			}
 			handlers.get(event)!.push(handler);
 		},
-		sendMessage<T = unknown>(message: HookMessage<T>, triggerTurn?: boolean): void {
+		sendMessage<T = unknown>(
+			message: HookMessage<T>,
+			options?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" },
+		): void {
 			if (!sendMessageHandler) {
 				throw new Error("sendMessage handler not initialized");
 			}
-			sendMessageHandler(message, triggerTurn);
+			sendMessageHandler(message, options);
 		},
 		appendEntry<T = unknown>(customType: string, data?: T): void {
 			if (!appendEntryHandler) {

package/src/core/hooks/tool-wrapper.ts

@@ -59,6 +59,7 @@ export function wrapToolWithHooks<T>(tool: AgentTool<any, T>, hookRunner: HookRu
 						input: params,
 						content: result.content,
 						details: result.details,
+						isError: false,
 					})) as ToolResultEventResult | undefined;
 
 					// Apply modifications if any

package/src/core/session-manager.ts

@@ -164,6 +164,8 @@ export interface SessionContext {
 export interface SessionInfo {
 	path: string;
 	id: string;
+	/** Working directory where the session was started. Empty string for old sessions. */
+	cwd: string;
 	title?: string;
 	created: Date;
 	modified: Date;
@@ -1707,7 +1709,7 @@ export class SessionManager {
 					if (lines.length === 0) continue;
 
 					// Check first line for valid session header
-					let header: { type: string; id: string; title?: string; timestamp: string } | null = null;
+					let header: { type: string; id: string; cwd?: string; title?: string; timestamp: string } | null = null;
 					try {
 						const first = JSON.parse(lines[0]);
 						if (first.type === "session" && first.id) {
@@ -1753,6 +1755,7 @@ export class SessionManager {
 					sessions.push({
 						path: file,
 						id: header.id,
+						cwd: typeof header.cwd === "string" ? header.cwd : "",
 						title: header.title,
 						created: new Date(header.timestamp),
 						modified: stats.mtime,

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
@@ -821,6 +822,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 +834,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/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/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) {

package/src/modes/interactive/controllers/command-controller.ts

@@ -476,6 +476,17 @@ export class CommandController {
 		await this.executeCompaction(customInstructions, false);
 	}
 
+	async handleSkillCommand(skillPath: string, args: string): Promise<void> {
+		try {
+			const content = fs.readFileSync(skillPath, "utf-8");
+			const body = content.replace(/^---\n[\s\S]*?\n---\n/, "").trim();
+			const message = args ? `${body}\n\n---\n\nUser: ${args}` : body;
+			await this.ctx.session.prompt(message);
+		} catch (err) {
+			this.ctx.showError(`Failed to load skill: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+
 	async executeCompaction(customInstructions?: string, isAuto = false): Promise<void> {
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();

package/src/modes/interactive/controllers/event-controller.ts

@@ -150,6 +150,15 @@ export class EventController {
 				if (event.message.role === "user") break;
 				if (this.ctx.streamingComponent && event.message.role === "assistant") {
 					this.ctx.streamingMessage = event.message;
+					let errorMessage: string | undefined;
+					if (this.ctx.streamingMessage.stopReason === "aborted" && !this.ctx.session.isTtsrAbortPending) {
+						const retryAttempt = this.ctx.session.retryAttempt;
+						errorMessage =
+							retryAttempt > 0
+								? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+								: "Operation aborted";
+						this.ctx.streamingMessage.errorMessage = errorMessage;
+					}
 					if (this.ctx.session.isTtsrAbortPending && this.ctx.streamingMessage.stopReason === "aborted") {
 						const msgWithoutAbort = { ...this.ctx.streamingMessage, stopReason: "stop" as const };
 						this.ctx.streamingComponent.updateContent(msgWithoutAbort);
@@ -162,14 +171,7 @@ export class EventController {
 						this.ctx.streamingMessage.stopReason === "error"
 					) {
 						if (!this.ctx.session.isTtsrAbortPending) {
-							let errorMessage: string;
-							if (this.ctx.streamingMessage.stopReason === "aborted") {
-								const retryAttempt = this.ctx.session.retryAttempt;
-								errorMessage =
-									retryAttempt > 0
-										? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
-										: "Operation aborted";
-							} else {
+							if (!errorMessage) {
 								errorMessage = this.ctx.streamingMessage.errorMessage || "Error";
 							}
 							for (const [toolCallId, component] of this.ctx.pendingTools.entries()) {

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

@@ -24,14 +24,7 @@ export class InputController {
 	setupKeyHandlers(): void {
 		this.ctx.editor.onEscape = () => {
 			if (this.ctx.loadingAnimation) {
-				// Abort and restore queued messages to editor
-				const queuedMessages = this.ctx.session.clearQueue();
-				const queuedText = [...queuedMessages.steering, ...queuedMessages.followUp].join("\n\n");
-				const currentText = this.ctx.editor.getText();
-				const combinedText = [queuedText, currentText].filter((t) => t.trim()).join("\n\n");
-				this.ctx.editor.setText(combinedText);
-				this.ctx.updatePendingMessagesDisplay();
-				this.ctx.agent.abort();
+				this.restoreQueuedMessagesToEditor({ abort: true });
 			} else if (this.ctx.session.isBashRunning) {
 				this.ctx.session.abortBash();
 			} else if (this.ctx.isBashMode) {
@@ -241,6 +234,27 @@ export class InputController {
 				return;
 			}
 
+			// Handle skill commands (/skill:name [args])
+			if (text.startsWith("/skill:")) {
+				const spaceIndex = text.indexOf(" ");
+				const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+				const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
+				const skillPath = this.ctx.skillCommands?.get(commandName);
+				if (skillPath) {
+					this.ctx.editor.addToHistory(text);
+					this.ctx.editor.setText("");
+					try {
+						const content = fs.readFileSync(skillPath, "utf-8");
+						const body = content.replace(/^---\n[\s\S]*?\n---\n/, "").trim();
+						const message = args ? `${body}\n\n---\n\nUser: ${args}` : body;
+						await this.ctx.session.prompt(message);
+					} catch (err) {
+						this.ctx.showError(`Failed to load skill: ${err instanceof Error ? err.message : String(err)}`);
+					}
+					return;
+				}
+			}
+
 			// Handle bash command (! for normal, !! for excluded from context)
 			if (text.startsWith("!")) {
 				const isExcluded = text.startsWith("!!");
@@ -341,15 +355,33 @@ export class InputController {
 	}
 
 	handleDequeue(): void {
-		const message = this.ctx.session.popLastQueuedMessage();
-		if (!message) return;
+		const restored = this.restoreQueuedMessagesToEditor();
+		if (restored === 0) {
+			this.ctx.showStatus("No queued messages to restore");
+		} else {
+			this.ctx.showStatus(`Restored ${restored} queued message${restored > 1 ? "s" : ""} to editor`);
+		}
+	}
 
-		// Prepend to existing editor text (if any)
-		const currentText = this.ctx.editor.getText();
-		const newText = currentText ? `${message}\n\n${currentText}` : message;
-		this.ctx.editor.setText(newText);
+	restoreQueuedMessagesToEditor(options?: { abort?: boolean; currentText?: string }): number {
+		const { steering, followUp } = this.ctx.session.clearQueue();
+		const allQueued = [...steering, ...followUp];
+		if (allQueued.length === 0) {
+			this.ctx.updatePendingMessagesDisplay();
+			if (options?.abort) {
+				this.ctx.agent.abort();
+			}
+			return 0;
+		}
+		const queuedText = allQueued.join("\n\n");
+		const currentText = options?.currentText ?? this.ctx.editor.getText();
+		const combinedText = [queuedText, currentText].filter((t) => t.trim()).join("\n\n");
+		this.ctx.editor.setText(combinedText);
 		this.ctx.updatePendingMessagesDisplay();
-		this.ctx.ui.requestRender();
+		if (options?.abort) {
+			this.ctx.agent.abort();
+		}
+		return allQueued.length;
 	}
 
 	handleBackgroundCommand(): void {

package/src/modes/interactive/controllers/selector-controller.ts

@@ -352,16 +352,41 @@ export class SelectorController {
 						return;
 					}
 
-					// Ask about summarization (or skip if disabled in settings)
+					// Ask about summarization
 					done(); // Close selector first
 
+					// Loop until user makes a complete choice or cancels to tree
+					let wantsSummary = false;
+					let customInstructions: string | undefined;
+
 					const branchSummariesEnabled = this.ctx.settingsManager.getBranchSummaryEnabled();
-					const wantsSummary = branchSummariesEnabled
-						? await this.ctx.showHookConfirm(
-								"Summarize branch?",
-								"Create a summary of the branch you're leaving?",
-							)
-						: false;
+
+					while (branchSummariesEnabled) {
+						const summaryChoice = await this.ctx.showHookSelector("Summarize branch?", [
+							"No summary",
+							"Summarize",
+							"Summarize with custom prompt",
+						]);
+
+						if (summaryChoice === undefined) {
+							// User pressed escape - re-show tree selector
+							this.showTreeSelector();
+							return;
+						}
+
+						wantsSummary = summaryChoice !== "No summary";
+
+						if (summaryChoice === "Summarize with custom prompt") {
+							customInstructions = await this.ctx.showHookEditor("Custom summarization instructions");
+							if (customInstructions === undefined) {
+								// User cancelled - loop back to summary selector
+								continue;
+							}
+						}
+
+						// User made a complete choice
+						break;
+					}
 
 					// Set up escape handler and loader if summarizing
 					let summaryLoader: Loader | undefined;
@@ -384,7 +409,10 @@ export class SelectorController {
 					}
 
 					try {
-						const result = await this.ctx.session.navigateTree(entryId, { summarize: wantsSummary });
+						const result = await this.ctx.session.navigateTree(entryId, {
+							summarize: wantsSummary,
+							customInstructions,
+						});
 
 						if (result.aborted) {
 							// Summarization aborted - re-show tree selector

package/src/modes/interactive/interactive-mode.ts

@@ -109,6 +109,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	public lastEscapeTime = 0;
 	public lastVoiceInterruptAt = 0;
 	public voiceAutoModeEnabled = false;
+	public shutdownRequested = false;
+	private isShuttingDown = false;
 	public voiceProgressTimer: ReturnType<typeof setTimeout> | undefined = undefined;
 	public voiceProgressSpoken = false;
 	public voiceProgressLastLength = 0;
@@ -118,6 +120,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	public lastStatusSpacer: Spacer | undefined = undefined;
 	public lastStatusText: Text | undefined = undefined;
 	public fileSlashCommands: Set<string> = new Set();
+	public skillCommands: Map<string, string> = new Map();
 
 	private pendingSlashCommands: SlashCommand[] = [];
 	private cleanupUnsubscribe?: () => void;
@@ -231,8 +234,18 @@ export class InteractiveMode implements InteractiveModeContext {
 			description: `${loaded.command.description} (${loaded.source})`,
 		}));
 
+		// Build skill commands from session.skills (if enabled)
+		const skillCommandList: SlashCommand[] = [];
+		if (this.settingsManager.getEnableSkillCommands?.()) {
+			for (const skill of this.session.skills) {
+				const commandName = `skill:${skill.name}`;
+				this.skillCommands.set(commandName, skill.filePath);
+				skillCommandList.push({ name: commandName, description: skill.description });
+			}
+		}
+
 		// Store pending commands for init() where file commands are loaded async
-		this.pendingSlashCommands = [...slashCommands, ...hookCommands, ...customCommands];
+		this.pendingSlashCommands = [...slashCommands, ...hookCommands, ...customCommands, ...skillCommandList];
 
 		this.uiHelpers = new UiHelpers(this);
 		this.voiceManager = new VoiceManager(this);
@@ -486,6 +499,9 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	async shutdown(): Promise<void> {
+		if (this.isShuttingDown) return;
+		this.isShuttingDown = true;
+
 		this.voiceAutoModeEnabled = false;
 		await this.voiceSupervisor.stop();
 
@@ -499,6 +515,11 @@ export class InteractiveMode implements InteractiveModeContext {
 		process.exit(0);
 	}
 
+	async checkShutdownRequested(): Promise<void> {
+		if (!this.shutdownRequested) return;
+		await this.shutdown();
+	}
+
 	// Extension UI integration
 	setToolUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void {
 		this.toolUiContextSetter(uiContext, hasUI);

package/src/modes/interactive/types.ts

@@ -74,6 +74,7 @@ export interface InteractiveModeContext {
 	lastEscapeTime: number;
 	lastVoiceInterruptAt: number;
 	voiceAutoModeEnabled: boolean;
+	shutdownRequested: boolean;
 	voiceProgressTimer: ReturnType<typeof setTimeout> | undefined;
 	voiceProgressSpoken: boolean;
 	voiceProgressLastLength: number;
@@ -83,11 +84,13 @@ export interface InteractiveModeContext {
 	lastStatusSpacer: Spacer | undefined;
 	lastStatusText: Text | undefined;
 	fileSlashCommands: Set<string>;
+	skillCommands: Map<string, string>;
 	todoItems: TodoItem[];
 
 	// Lifecycle
 	init(): Promise<void>;
 	shutdown(): Promise<void>;
+	checkShutdownRequested(): Promise<void>;
 
 	// Extension UI integration
 	setToolUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;

package/src/modes/rpc/rpc-mode.ts

@@ -189,6 +189,14 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			// Component factories are not supported in RPC mode - would need TUI access
 		},
 
+		setFooter(_factory: unknown): void {
+			// Custom footer not supported in RPC mode - requires TUI access
+		},
+
+		setHeader(_factory: unknown): void {
+			// Custom header not supported in RPC mode - requires TUI access
+		},
+
 		setTitle(title: string): void {
 			// Fire and forget - host can implement terminal title control
 			output({
@@ -257,9 +265,9 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			return { success: false, error: "Theme switching not supported in RPC mode" };
 		},
 
-		setFooter() {},
-		setHeader() {},
-		setEditorComponent() {},
+		setEditorComponent(): void {
+			// Custom editor components not supported in RPC mode
+		},
 	});
 
 	// Set up extensions with RPC-based UI context