@oh-my-pi/pi-coding-agent 3.31.0 → 3.32.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [3.32.0] - 2026-01-08
+### Added
+
+- Added progress indicator when starting LSP servers at session startup
+- Added bundled `/init` slash command available by default
+
+### Changed
+
+- Changed LSP server warmup to use a 5-second timeout, falling back to lazy initialization for slow servers
+
+### Fixed
+
+- Fixed Task tool subagent model selection to inherit explicit CLI `--model` overrides
+
 ## [3.31.0] - 2026-01-08
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "3.31.0",
+	"version": "3.32.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,9 +40,9 @@
 	},
 	"dependencies": {
 		"@mariozechner/pi-ai": "^0.37.8",
-		"@oh-my-pi/pi-agent-core": "3.31.0",
-		"@oh-my-pi/pi-git-tool": "3.31.0",
-		"@oh-my-pi/pi-tui": "3.31.0",
+		"@oh-my-pi/pi-agent-core": "3.32.0",
+		"@oh-my-pi/pi-git-tool": "3.32.0",
+		"@oh-my-pi/pi-tui": "3.32.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/custom-commands/bundled/review/index.ts

@@ -435,13 +435,11 @@ export function createReviewCommand(api: CustomCommandAPI): CustomCommand {
 					if (hasDiff) {
 						const stats = parseDiff(diffResult.stdout);
 						// Even if all files filtered, include the custom instructions
-						return (
-							buildReviewPrompt(
-								`Custom review: ${instructions.split("\n")[0].slice(0, 60)}...`,
-								stats,
-								diffResult.stdout,
-							) + `\n\n### Additional Instructions\n\n${instructions}`
-						);
+						return `${buildReviewPrompt(
+							`Custom review: ${instructions.split("\n")[0].slice(0, 60)}...`,
+							stats,
+							diffResult.stdout,
+						)}\n\n### Additional Instructions\n\n${instructions}`;
 					}
 
 					// No diff available, just pass instructions

package/src/core/sdk.ts

@@ -61,7 +61,7 @@ import { logger } from "./logger";
 import { discoverAndLoadMCPTools, type MCPManager, type MCPToolsLoadResult } from "./mcp/index";
 import { convertToLlm } from "./messages";
 import { ModelRegistry } from "./model-registry";
-import { parseModelString } from "./model-resolver";
+import { formatModelString, parseModelString } from "./model-resolver";
 import { loadPromptTemplates as loadPromptTemplatesInternal, type PromptTemplate } from "./prompt-templates";
 import { SessionManager } from "./session-manager";
 import { type Settings, SettingsManager, type SkillsSettings } from "./settings-manager";
@@ -520,6 +520,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	time("loadSession");
 	const hasExistingSession = existingSession.messages.length > 0;
 
+	const hasExplicitModel = options.model !== undefined;
 	let model = options.model;
 	let modelFallbackMessage: string | undefined;
 
@@ -617,6 +618,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		requireCompleteTool: options.requireCompleteTool,
 		getSessionFile: () => sessionManager.getSessionFile() ?? null,
 		getSessionSpawns: () => options.spawns ?? "*",
+		getModelString: () => (hasExplicitModel && model ? formatModelString(model) : undefined),
 		settings: settingsManager,
 	};
 
@@ -931,7 +933,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	let lspServers: CreateAgentSessionResult["lspServers"];
 	if (settingsManager.getLspDiagnosticsOnWrite()) {
 		try {
-			const result = await warmupLspServers(cwd);
+			const result = await warmupLspServers(cwd, {
+				onConnecting: (serverNames) => {
+					if (options.hasUI && serverNames.length > 0) {
+						process.stderr.write(chalk.gray(`Starting LSP servers: ${serverNames.join(", ")}...\n`));
+					}
+				},
+			});
 			lspServers = result.servers;
 			time("warmupLspServers");
 		} catch {

package/src/core/slash-commands.ts

@@ -2,6 +2,7 @@ import { slashCommandCapability } from "../capability/slash-command";
 import type { SlashCommand } from "../discovery";
 import { loadSync } from "../discovery";
 import { parseFrontmatter } from "../discovery/helpers";
+import { EMBEDDED_COMMAND_TEMPLATES } from "./tools/task/commands";
 
 /**
  * Represents a custom slash command loaded from a file
@@ -15,6 +16,25 @@ export interface FileSlashCommand {
 	_source?: { providerName: string; level: "user" | "project" | "native" };
 }
 
+const EMBEDDED_SLASH_COMMANDS = EMBEDDED_COMMAND_TEMPLATES;
+
+function parseCommandTemplate(content: string): { description: string; body: string } {
+	const { frontmatter, body } = parseFrontmatter(content);
+	const frontmatterDesc = typeof frontmatter.description === "string" ? frontmatter.description.trim() : "";
+
+	// Get description from frontmatter or first non-empty line
+	let description = frontmatterDesc;
+	if (!description) {
+		const firstLine = body.split("\n").find((line) => line.trim());
+		if (firstLine) {
+			description = firstLine.slice(0, 60);
+			if (firstLine.length > 60) description += "...";
+		}
+	}
+
+	return { description, body };
+}
+
 /**
  * Parse command arguments respecting quoted strings (bash-style)
  * Returns array of arguments
@@ -90,19 +110,8 @@ export interface LoadSlashCommandsOptions {
 export function loadSlashCommands(options: LoadSlashCommandsOptions = {}): FileSlashCommand[] {
 	const result = loadSync<SlashCommand>(slashCommandCapability.id, { cwd: options.cwd });
 
-	return result.items.map((cmd) => {
-		const { frontmatter, body } = parseFrontmatter(cmd.content);
-		const frontmatterDesc = typeof frontmatter.description === "string" ? frontmatter.description.trim() : "";
-
-		// Get description from frontmatter or first non-empty line
-		let description = frontmatterDesc;
-		if (!description) {
-			const firstLine = body.split("\n").find((line) => line.trim());
-			if (firstLine) {
-				description = firstLine.slice(0, 60);
-				if (firstLine.length > 60) description += "...";
-			}
-		}
+	const fileCommands: FileSlashCommand[] = result.items.map((cmd) => {
+		const { description, body } = parseCommandTemplate(cmd.content);
 
 		// Format source label: "via ProviderName Level"
 		const capitalizedLevel = cmd.level.charAt(0).toUpperCase() + cmd.level.slice(1);
@@ -116,6 +125,23 @@ export function loadSlashCommands(options: LoadSlashCommandsOptions = {}): FileS
 			_source: { providerName: cmd._source.providerName, level: cmd.level },
 		};
 	});
+
+	const seenNames = new Set(fileCommands.map((cmd) => cmd.name));
+	for (const cmd of EMBEDDED_SLASH_COMMANDS) {
+		const name = cmd.name.replace(/\.md$/, "");
+		if (seenNames.has(name)) continue;
+
+		const { description, body } = parseCommandTemplate(cmd.content);
+		fileCommands.push({
+			name,
+			description,
+			content: body,
+			source: "bundled",
+		});
+		seenNames.add(name);
+	}
+
+	return fileCommands;
 }
 
 /**

package/src/core/tools/index.ts

@@ -17,6 +17,7 @@ export {
 	getLspStatus,
 	type LspServerStatus,
 	type LspToolDetails,
+	type LspWarmupOptions,
 	type LspWarmupResult,
 	warmupLspServers,
 } from "./lsp/index";
@@ -93,6 +94,8 @@ export interface ToolSession {
 	getSessionFile: () => string | null;
 	/** Get session spawns */
 	getSessionSpawns: () => string | null;
+	/** Get resolved model string if explicitly set for this session */
+	getModelString?: () => string | undefined;
 	/** Settings manager (optional) */
 	settings?: {
 		getImageAutoResize(): boolean;
@@ -148,7 +151,10 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 
 	const entries = requestedTools
 		? requestedTools.filter((name) => name in allTools).map((name) => [name, allTools[name]] as const)
-		: [...Object.entries(BUILTIN_TOOLS), ...(includeComplete ? ([["complete", HIDDEN_TOOLS.complete]] as const) : [])];
+		: [
+				...Object.entries(BUILTIN_TOOLS),
+				...(includeComplete ? ([["complete", HIDDEN_TOOLS.complete]] as const) : []),
+			];
 	const results = await Promise.all(entries.map(([, factory]) => factory(session)));
 	const tools = results.filter((t): t is Tool => t !== null);
 

package/src/core/tools/lsp/client.ts

@@ -373,10 +373,16 @@ async function sendResponse(
 // Client Management
 // =============================================================================
 
+/** Timeout for warmup initialize requests (5 seconds) */
+export const WARMUP_TIMEOUT_MS = 5000;
+
 /**
  * Get or create an LSP client for the given server configuration and working directory.
+ * @param config - Server configuration
+ * @param cwd - Working directory
+ * @param initTimeoutMs - Optional timeout for the initialize request (defaults to 30s)
  */
-export async function getOrCreateClient(config: ServerConfig, cwd: string): Promise<LspClient> {
+export async function getOrCreateClient(config: ServerConfig, cwd: string, initTimeoutMs?: number): Promise<LspClient> {
 	const key = `${config.command}:${cwd}`;
 
 	// Check if client already exists
@@ -430,14 +436,20 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string): Prom
 
 		try {
 			// Send initialize request
-			const initResult = (await sendRequest(client, "initialize", {
-				processId: process.pid,
-				rootUri: fileToUri(cwd),
-				rootPath: cwd,
-				capabilities: CLIENT_CAPABILITIES,
-				initializationOptions: config.initOptions ?? {},
-				workspaceFolders: [{ uri: fileToUri(cwd), name: cwd.split("/").pop() ?? "workspace" }],
-			})) as { capabilities?: unknown };
+			const initResult = (await sendRequest(
+				client,
+				"initialize",
+				{
+					processId: process.pid,
+					rootUri: fileToUri(cwd),
+					rootPath: cwd,
+					capabilities: CLIENT_CAPABILITIES,
+					initializationOptions: config.initOptions ?? {},
+					workspaceFolders: [{ uri: fileToUri(cwd), name: cwd.split("/").pop() ?? "workspace" }],
+				},
+				undefined, // signal
+				initTimeoutMs,
+			)) as { capabilities?: unknown };
 
 			if (!initResult) {
 				throw new Error("Failed to initialize LSP: no response");
@@ -662,6 +674,9 @@ export function shutdownClient(key: string): void {
 // LSP Protocol Methods
 // =============================================================================
 
+/** Default timeout for LSP requests (30 seconds) */
+const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+
 /**
  * Send an LSP request and wait for response.
  */
@@ -670,6 +685,7 @@ export async function sendRequest(
 	method: string,
 	params: unknown,
 	signal?: AbortSignal,
+	timeoutMs: number = DEFAULT_REQUEST_TIMEOUT_MS,
 ): Promise<unknown> {
 	// Atomically increment and capture request ID
 	const id = ++client.requestId;
@@ -712,7 +728,7 @@ export async function sendRequest(
 				cleanup();
 				reject(err);
 			}
-		}, 30000);
+		}, timeoutMs);
 		if (signal) {
 			signal.addEventListener("abort", abortHandler, { once: true });
 			if (signal.aborted) {

package/src/core/tools/lsp/index.ts

@@ -19,6 +19,7 @@ import {
 	sendRequest,
 	setIdleTimeout,
 	syncContent,
+	WARMUP_TIMEOUT_MS,
 } from "./client";
 import { getLinterClient } from "./clients";
 import { getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config";
@@ -72,23 +73,36 @@ export interface LspWarmupResult {
 	}>;
 }
 
+/** Options for warming up LSP servers */
+export interface LspWarmupOptions {
+	/** Called when starting to connect to servers */
+	onConnecting?: (serverNames: string[]) => void;
+}
+
 /**
  * Warm up LSP servers for a directory by connecting to all detected servers.
  * This should be called at startup to avoid cold-start delays.
  *
  * @param cwd - Working directory to detect and start servers for
+ * @param options - Optional callbacks for progress reporting
  * @returns Status of each server that was started
  */
-export async function warmupLspServers(cwd: string): Promise<LspWarmupResult> {
+export async function warmupLspServers(cwd: string, options?: LspWarmupOptions): Promise<LspWarmupResult> {
 	const config = await loadConfig(cwd);
 	setIdleTimeout(config.idleTimeoutMs);
 	const servers: LspWarmupResult["servers"] = [];
 	const lspServers = getLspServers(config);
 
-	// Start all detected servers in parallel
+	// Notify caller which servers we're connecting to
+	if (lspServers.length > 0 && options?.onConnecting) {
+		options.onConnecting(lspServers.map(([name]) => name));
+	}
+
+	// Start all detected servers in parallel with a short timeout
+	// Servers that don't respond quickly will be initialized lazily on first use
 	const results = await Promise.allSettled(
 		lspServers.map(async ([name, serverConfig]) => {
-			const client = await getOrCreateClient(serverConfig, cwd);
+			const client = await getOrCreateClient(serverConfig, cwd, WARMUP_TIMEOUT_MS);
 			return { name, client, fileTypes: serverConfig.fileTypes };
 		}),
 	);

package/src/core/tools/task/commands.ts

@@ -12,13 +12,17 @@ import { loadSync } from "../../../discovery";
 import architectPlanMd from "../../../prompts/architect-plan.md" with { type: "text" };
 import implementMd from "../../../prompts/implement.md" with { type: "text" };
 import implementWithCriticMd from "../../../prompts/implement-with-critic.md" with { type: "text" };
+import initMd from "../../../prompts/init.md" with { type: "text" };
 
 const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
 	{ name: "architect-plan.md", content: architectPlanMd },
 	{ name: "implement-with-critic.md", content: implementWithCriticMd },
 	{ name: "implement.md", content: implementMd },
+	{ name: "init.md", content: initMd },
 ];
 
+export const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{ name: string; content: string }> = EMBEDDED_COMMANDS;
+
 /** Workflow command definition */
 export interface WorkflowCommand {
 	name: string;

package/src/core/tools/task/index.ts

@@ -135,6 +135,7 @@ export async function createTaskTool(
 			const startTime = Date.now();
 			const { agents, projectAgentsDir } = await discoverAgents(session.cwd);
 			const { agent: agentName, context, model, output: outputSchema } = params;
+			const modelOverride = model ?? session.getModelString?.();
 
 			// Validate agent exists
 			const agent = getAgent(agents, agentName);
@@ -323,7 +324,7 @@ export async function createTaskTool(
 						toolCount: 0,
 						tokens: 0,
 						durationMs: 0,
-						modelOverride: model,
+						modelOverride,
 						description: t.description,
 					});
 				}
@@ -342,7 +343,7 @@ export async function createTaskTool(
 							index,
 							taskId: task.taskId,
 							context: undefined, // Already prepended above
-							modelOverride: model,
+							modelOverride,
 							outputSchema,
 							sessionFile,
 							persistArtifacts: !!artifactsDir,

package/src/main.ts

@@ -5,10 +5,10 @@
  * createAgentSession() options. The SDK does the heavy lifting.
  */
 
-import { type ImageContent, supportsXhigh } from "@mariozechner/pi-ai";
-import chalk from "chalk";
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import { type ImageContent, supportsXhigh } from "@mariozechner/pi-ai";
+import chalk from "chalk";
 import { type Args, parseArgs, printHelp } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
 import { listModels } from "./cli/list-models";

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

@@ -1906,31 +1906,6 @@ export class InteractiveMode {
 		this.voiceSupervisor.notifyProgress(text);
 	}
 
-	private async toggleVoiceListening(): Promise<void> {
-		if (!this.settingsManager.getVoiceEnabled()) {
-			this.settingsManager.setVoiceEnabled(true);
-			this.showStatus("Voice mode enabled.");
-		}
-
-		if (this.voiceAutoModeEnabled) {
-			this.voiceAutoModeEnabled = false;
-			this.stopVoiceProgressTimer();
-			await this.voiceSupervisor.stop();
-			this.setVoiceStatus(undefined);
-			this.showStatus("Voice mode disabled.");
-			return;
-		}
-
-		this.voiceAutoModeEnabled = true;
-		try {
-			await this.voiceSupervisor.start();
-		} catch (error) {
-			this.voiceAutoModeEnabled = false;
-			this.setVoiceStatus(undefined);
-			this.showError(error instanceof Error ? error.message : String(error));
-		}
-	}
-
 	private async submitVoiceText(text: string): Promise<void> {
 		const cleaned = text.trim();
 		if (!cleaned) {