@oh-my-pi/pi-coding-agent 1.340.0 → 1.341.0

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 ## [Unreleased]
 
+## [1.341.0] - 2026-01-03
+### Added
+
+- Added interruptMode setting to control when queued messages are processed during tool execution.
+- Implemented getter and setter methods in SettingsManager for interrupt mode persistence.
+- Exposed interruptMode configuration in interactive settings UI with immediate/wait options.
+- Wired interrupt mode through AgentSession and SDK to enable runtime configuration.
+- Model roles: Configure different models for different purposes (default, smol, slow) via `/model` selector
+- Model selector key bindings: Enter sets default, S sets smol, L sets slow, Escape closes
+- Model selector shows role markers: ✓ for default, ⚡ for smol, 🧠 for slow
+- `pi/<role>` model aliases in Task tool agent definitions (e.g., `model: pi/smol, haiku, flash, mini`)
+- Smol model auto-discovery using priority chain: haiku > flash > mini
+- Slow model auto-discovery using priority chain: gpt-5.2-codex > codex > gpt > opus > pro
+- CLI args for model roles: `--smol <model>` and `--slow <model>` (ephemeral, not persisted)
+- Env var overrides: `PI_SMOL_MODEL` and `PI_SLOW_MODEL`
+- Title generation now uses configured smol model from settings
+- LSP diagnostics on edit: Edit tool can now return LSP diagnostics after editing code files. Disabled by default to avoid noise during multi-edit sequences. Enable via `lsp.diagnosticsOnEdit` setting.
+- LSP workspace diagnostics: New `lsp action=workspace_diagnostics` command checks the entire project for errors. Auto-detects project type and uses appropriate checker (rust-analyzer/cargo for Rust, tsc for TypeScript, go build for Go, pyright for Python).
+- LSP local binary resolution: LSP servers installed in project-local directories are now discovered automatically. Checks `node_modules/.bin/` for Node.js projects, `.venv/bin/`/`venv/bin/` for Python projects, and `vendor/bundle/bin/` for Ruby projects before falling back to `$PATH`.
+- LSP format on write: Write tool now automatically formats code files using LSP after writing. Uses the language server's built-in formatter (e.g., rustfmt for Rust, gofmt for Go). Controlled via `lsp.formatOnWrite` setting (enabled by default).
+- LSP diagnostics on write: Write tool now returns LSP diagnostics (errors/warnings) after writing code files. This gives immediate feedback on syntax errors and type issues. Controlled via `lsp.diagnosticsOnWrite` setting (enabled by default).
+- LSP server warmup at startup: LSP servers are now started at launch to avoid cold-start delays when first writing files.
+- LSP server status in welcome banner: Shows which language servers are active and ready.
+- Edit fuzzy match setting: Added `edit.fuzzyMatch` setting (enabled by default) to control whether the edit tool accepts high-confidence fuzzy matches for whitespace/indentation differences. Toggle via `/settings`.
+- Multi-server LSP diagnostics: Diagnostics now query all applicable language servers for a file type. For TypeScript/JavaScript projects with Biome, this means both type errors (from tsserver) and lint errors (from Biome) are reported together.
+- Comprehensive LSP server configurations for 40+ languages including Rust, Go, Python, Java, Kotlin, Scala, Haskell, OCaml, Elixir, Ruby, PHP, C#, Lua, Nix, and many more. Each server includes sensible defaults for args, settings, and init options.
+- Extended LSP config file search paths: Now searches for `lsp.json`, `.lsp.json` in project root and `.pi/` subdirectory, plus user-level configs in `~/.pi/` and home directory.
+
+### Changed
+
+- LSP settings moved to dedicated "LSP" tab in `/settings` for better organization
+- Improved grep tool description to document pagination options (`headLimit`, `offset`) and clarify recursive search behavior
+- LSP idle timeout now disabled by default. Configure via `idleTimeoutMs` in lsp.json to auto-shutdown inactive servers.
+- Model settings now use role-based storage (`modelRoles` map) instead of single `defaultProvider`/`defaultModel` fields. Supports multiple model roles (default, small, etc.)
+- Session model persistence now uses `"provider/modelId"` string format with optional role field
+
+### Fixed
+
+- Recent sessions now show in welcome banner (was never wired up).
+- Auto-generated session titles: Sessions are now automatically titled based on the first message using a small model (Haiku/GPT-4o-mini/Flash). Titles are shown in the terminal window title, recent sessions list, and --resume picker. The resume picker shows title with dimmed first message preview below.
+
 ## [1.340.0] - 2026-01-03
 
 ### Changed
@@ -1286,4 +1327,4 @@ Initial public release.
 - Git branch display in footer
 - Message queueing during streaming responses
 - OAuth integration for Gmail and Google Calendar access
-- HTML export with syntax highlighting and collapsible sections
+- HTML export with syntax highlighting and collapsible sections

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "1.340.0",
+	"version": "1.341.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {

package/src/cli/args.ts

@@ -12,6 +12,8 @@ export type Mode = "text" | "json" | "rpc";
 export interface Args {
 	provider?: string;
 	model?: string;
+	smol?: string;
+	slow?: string;
 	apiKey?: string;
 	systemPrompt?: string;
 	appendSystemPrompt?: string;
@@ -69,6 +71,10 @@ export function parseArgs(args: string[]): Args {
 			result.provider = args[++i];
 		} else if (arg === "--model" && i + 1 < args.length) {
 			result.model = args[++i];
+		} else if (arg === "--smol" && i + 1 < args.length) {
+			result.smol = args[++i];
+		} else if (arg === "--slow" && i + 1 < args.length) {
+			result.slow = args[++i];
 		} else if (arg === "--api-key" && i + 1 < args.length) {
 			result.apiKey = args[++i];
 		} else if (arg === "--system-prompt" && i + 1 < args.length) {
@@ -148,6 +154,8 @@ ${chalk.bold("Usage:")}
 ${chalk.bold("Options:")}
   --provider <name>              Provider name (default: google)
   --model <id>                   Model ID (default: gemini-2.5-flash)
+  --smol <id>                    Smol/fast model for lightweight tasks (or PI_SMOL_MODEL env)
+  --slow <id>                    Slow/reasoning model for thorough analysis (or PI_SLOW_MODEL env)
   --api-key <key>                API key (defaults to env vars)
   --system-prompt <text>         System prompt (default: coding assistant prompt)
   --append-system-prompt <text>  Append text or file contents to the system prompt

package/src/core/agent-session.ts

@@ -424,6 +424,11 @@ export class AgentSession {
 		return this.agent.getQueueMode();
 	}
 
+	/** Current interrupt mode */
+	get interruptMode(): "immediate" | "wait" {
+		return this.agent.getInterruptMode();
+	}
+
 	/** Current session file path, or undefined if sessions are disabled */
 	get sessionFile(): string | undefined {
 		return this.sessionManager.getSessionFile();
@@ -701,15 +706,15 @@ export class AgentSession {
 	 * Validates API key, saves to session and settings.
 	 * @throws Error if no API key available for the model
 	 */
-	async setModel(model: Model<any>): Promise<void> {
+	async setModel(model: Model<any>, role: string = "default"): Promise<void> {
 		const apiKey = await this._modelRegistry.getApiKey(model);
 		if (!apiKey) {
 			throw new Error(`No API key for ${model.provider}/${model.id}`);
 		}
 
 		this.agent.setModel(model);
-		this.sessionManager.appendModelChange(model.provider, model.id);
-		this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+		this.sessionManager.appendModelChange(`${model.provider}/${model.id}`, role);
+		this.settingsManager.setModelRole(role, `${model.provider}/${model.id}`);
 
 		// Re-clamp thinking level for new model's capabilities
 		this.setThinkingLevel(this.thinkingLevel);
@@ -747,8 +752,8 @@ export class AgentSession {
 
 		// Apply model
 		this.agent.setModel(next.model);
-		this.sessionManager.appendModelChange(next.model.provider, next.model.id);
-		this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+		this.sessionManager.appendModelChange(`${next.model.provider}/${next.model.id}`);
+		this.settingsManager.setModelRole("default", `${next.model.provider}/${next.model.id}`);
 
 		// Apply thinking level (setThinkingLevel clamps to model capabilities)
 		this.setThinkingLevel(next.thinkingLevel);
@@ -774,8 +779,8 @@ export class AgentSession {
 		}
 
 		this.agent.setModel(nextModel);
-		this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
-		this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
+		this.sessionManager.appendModelChange(`${nextModel.provider}/${nextModel.id}`);
+		this.settingsManager.setModelRole("default", `${nextModel.provider}/${nextModel.id}`);
 
 		// Re-clamp thinking level for new model's capabilities
 		this.setThinkingLevel(this.thinkingLevel);
@@ -861,6 +866,15 @@ export class AgentSession {
 		this.settingsManager.setQueueMode(mode);
 	}
 
+	/**
+	 * Set interrupt mode.
+	 * Saves to settings.
+	 */
+	setInterruptMode(mode: "immediate" | "wait"): void {
+		this.agent.setInterruptMode(mode);
+		this.settingsManager.setInterruptMode(mode);
+	}
+
 	// =========================================================================
 	// Compaction
 	// =========================================================================
@@ -1472,13 +1486,17 @@ export class AgentSession {
 		this.agent.replaceMessages(sessionContext.messages);
 
 		// Restore model if saved
-		if (sessionContext.model) {
-			const availableModels = await this._modelRegistry.getAvailable();
-			const match = availableModels.find(
-				(m) => m.provider === sessionContext.model!.provider && m.id === sessionContext.model!.modelId,
-			);
-			if (match) {
-				this.agent.setModel(match);
+		const defaultModelStr = sessionContext.models.default;
+		if (defaultModelStr) {
+			const slashIdx = defaultModelStr.indexOf("/");
+			if (slashIdx > 0) {
+				const provider = defaultModelStr.slice(0, slashIdx);
+				const modelId = defaultModelStr.slice(slashIdx + 1);
+				const availableModels = await this._modelRegistry.getAvailable();
+				const match = availableModels.find((m) => m.provider === provider && m.id === modelId);
+				if (match) {
+					this.agent.setModel(match);
+				}
 			}
 		}
 

package/src/core/model-resolver.ts

@@ -30,6 +30,29 @@ export interface ScopedModel {
 	thinkingLevel: ThinkingLevel;
 }
 
+/** Priority chain for auto-discovering smol/fast models */
+export const SMOL_MODEL_PRIORITY = ["claude-haiku-4-5", "haiku", "flash", "mini"];
+
+/** Priority chain for auto-discovering slow/comprehensive models (reasoning, codex) */
+export const SLOW_MODEL_PRIORITY = ["gpt-5.2-codex", "gpt-5.2", "codex", "gpt", "opus", "pro"];
+
+/**
+ * Parse a model string in "provider/modelId" format.
+ * Returns undefined if the format is invalid.
+ */
+export function parseModelString(modelStr: string): { provider: string; id: string } | undefined {
+	const slashIdx = modelStr.indexOf("/");
+	if (slashIdx <= 0) return undefined;
+	return { provider: modelStr.slice(0, slashIdx), id: modelStr.slice(slashIdx + 1) };
+}
+
+/**
+ * Format a model as "provider/modelId" string.
+ */
+export function formatModelString(model: Model<Api>): string {
+	return `${model.provider}/${model.id}`;
+}
+
 /**
  * Helper to check if a model ID looks like an alias (no date suffix)
  * Dates are typically in format: -20241022 or -20250929
@@ -391,3 +414,81 @@ export async function restoreModelFromSession(
 	// No models available
 	return { model: undefined, fallbackMessage: undefined };
 }
+
+/**
+ * Find a smol/fast model using the priority chain.
+ * Tries exact matches first, then fuzzy matches.
+ *
+ * @param modelRegistry The model registry to search
+ * @param savedModel Optional saved model string from settings (provider/modelId)
+ * @returns The best available smol model, or undefined if none found
+ */
+export async function findSmolModel(
+	modelRegistry: ModelRegistry,
+	savedModel?: string,
+): Promise<Model<Api> | undefined> {
+	const availableModels = await modelRegistry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+
+	// 1. Try saved model from settings
+	if (savedModel) {
+		const parsed = parseModelString(savedModel);
+		if (parsed) {
+			const match = availableModels.find((m) => m.provider === parsed.provider && m.id === parsed.id);
+			if (match) return match;
+		}
+	}
+
+	// 2. Try priority chain
+	for (const pattern of SMOL_MODEL_PRIORITY) {
+		// Try exact match first
+		const exactMatch = availableModels.find((m) => m.id.toLowerCase() === pattern.toLowerCase());
+		if (exactMatch) return exactMatch;
+
+		// Try fuzzy match (substring)
+		const fuzzyMatch = availableModels.find((m) => m.id.toLowerCase().includes(pattern.toLowerCase()));
+		if (fuzzyMatch) return fuzzyMatch;
+	}
+
+	// 3. Fallback to first available (same as default)
+	return availableModels[0];
+}
+
+/**
+ * Find a slow/comprehensive model using the priority chain.
+ * Prioritizes reasoning and codex models for thorough analysis.
+ *
+ * @param modelRegistry The model registry to search
+ * @param savedModel Optional saved model string from settings (provider/modelId)
+ * @returns The best available slow model, or undefined if none found
+ */
+export async function findSlowModel(
+	modelRegistry: ModelRegistry,
+	savedModel?: string,
+): Promise<Model<Api> | undefined> {
+	const availableModels = await modelRegistry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+
+	// 1. Try saved model from settings
+	if (savedModel) {
+		const parsed = parseModelString(savedModel);
+		if (parsed) {
+			const match = availableModels.find((m) => m.provider === parsed.provider && m.id === parsed.id);
+			if (match) return match;
+		}
+	}
+
+	// 2. Try priority chain
+	for (const pattern of SLOW_MODEL_PRIORITY) {
+		// Try exact match first
+		const exactMatch = availableModels.find((m) => m.id.toLowerCase() === pattern.toLowerCase());
+		if (exactMatch) return exactMatch;
+
+		// Try fuzzy match (substring)
+		const fuzzyMatch = availableModels.find((m) => m.id.toLowerCase().includes(pattern.toLowerCase()));
+		if (fuzzyMatch) return fuzzyMatch;
+	}
+
+	// 3. Fallback to first available (same as default)
+	return availableModels[0];
+}

package/src/core/sdk.ts

@@ -78,6 +78,7 @@ import {
 	readOnlyTools,
 	readTool,
 	type Tool,
+	warmupLspServers,
 	writeTool,
 } from "./tools/index.js";
 
@@ -146,6 +147,8 @@ export interface CreateAgentSessionResult {
 	mcpManager?: MCPManager;
 	/** Warning if session was restored with a different model than saved */
 	modelFallbackMessage?: string;
+	/** LSP servers that were warmed up at startup */
+	lspServers?: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }>;
 }
 
 // Re-exports
@@ -323,8 +326,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 export function loadSettings(cwd?: string, agentDir?: string): Settings {
 	const manager = SettingsManager.create(cwd ?? process.cwd(), agentDir ?? getDefaultAgentDir());
 	return {
-		defaultProvider: manager.getDefaultProvider(),
-		defaultModel: manager.getDefaultModel(),
+		modelRoles: manager.getModelRoles(),
 		defaultThinkingLevel: manager.getDefaultThinkingLevel(),
 		queueMode: manager.getQueueMode(),
 		theme: manager.getTheme(),
@@ -479,24 +481,34 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	let modelFallbackMessage: string | undefined;
 
 	// If session has data, try to restore model from it
-	if (!model && hasExistingSession && existingSession.model) {
-		const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
-		if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
-			model = restoredModel;
-		}
-		if (!model) {
-			modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
+	const defaultModelStr = existingSession.models.default;
+	if (!model && hasExistingSession && defaultModelStr) {
+		const slashIdx = defaultModelStr.indexOf("/");
+		if (slashIdx > 0) {
+			const provider = defaultModelStr.slice(0, slashIdx);
+			const modelId = defaultModelStr.slice(slashIdx + 1);
+			const restoredModel = modelRegistry.find(provider, modelId);
+			if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
+				model = restoredModel;
+			}
+			if (!model) {
+				modelFallbackMessage = `Could not restore model ${defaultModelStr}`;
+			}
 		}
 	}
 
 	// If still no model, try settings default
 	if (!model) {
-		const defaultProvider = settingsManager.getDefaultProvider();
-		const defaultModelId = settingsManager.getDefaultModel();
-		if (defaultProvider && defaultModelId) {
-			const settingsModel = modelRegistry.find(defaultProvider, defaultModelId);
-			if (settingsModel && (await modelRegistry.getApiKey(settingsModel))) {
-				model = settingsModel;
+		const settingsDefaultModel = settingsManager.getModelRole("default");
+		if (settingsDefaultModel) {
+			const slashIdx = settingsDefaultModel.indexOf("/");
+			if (slashIdx > 0) {
+				const provider = settingsDefaultModel.slice(0, slashIdx);
+				const modelId = settingsDefaultModel.slice(slashIdx + 1);
+				const settingsModel = modelRegistry.find(provider, modelId);
+				if (settingsModel && (await modelRegistry.getApiKey(settingsModel))) {
+					model = settingsModel;
+				}
 			}
 		}
 	}
@@ -566,7 +578,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const sessionContext = {
 		getSessionFile: () => sessionManager.getSessionFile() ?? null,
 	};
-	const builtInTools = options.tools ?? createCodingTools(cwd, options.hasUI ?? false, sessionContext);
+	const builtInTools =
+		options.tools ??
+		createCodingTools(cwd, options.hasUI ?? false, sessionContext, {
+			lspFormatOnWrite: settingsManager.getLspFormatOnWrite(),
+			lspDiagnosticsOnWrite: settingsManager.getLspDiagnosticsOnWrite(),
+			lspDiagnosticsOnEdit: settingsManager.getLspDiagnosticsOnEdit(),
+			editFuzzyMatch: settingsManager.getEditFuzzyMatch(),
+		});
 	time("createCodingTools");
 
 	let customToolsResult: CustomToolsLoadResult;
@@ -728,6 +747,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				}
 			: undefined,
 		queueMode: settingsManager.getQueueMode(),
+		interruptMode: settingsManager.getInterruptMode(),
 		getToolContext: toolContextStore.getContext,
 		getApiKey: async () => {
 			const currentModel = agent.state.model;
@@ -749,7 +769,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	} else {
 		// Save initial model and thinking level for new sessions so they can be restored on resume
 		if (model) {
-			sessionManager.appendModelChange(model.provider, model.id);
+			sessionManager.appendModelChange(`${model.provider}/${model.id}`);
 		}
 		sessionManager.appendThinkingLevelChange(thinkingLevel);
 	}
@@ -767,10 +787,23 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	});
 	time("createAgentSession");
 
+	// Warm up LSP servers (connects to detected servers)
+	let lspServers: CreateAgentSessionResult["lspServers"];
+	if (settingsManager.getLspDiagnosticsOnWrite()) {
+		try {
+			const result = await warmupLspServers(cwd);
+			lspServers = result.servers;
+			time("warmupLspServers");
+		} catch {
+			// Ignore warmup errors
+		}
+	}
+
 	return {
 		session,
 		customToolsResult,
 		mcpManager,
 		modelFallbackMessage,
+		lspServers,
 	};
 }

package/src/core/session-manager.ts

@@ -28,6 +28,7 @@ export interface SessionHeader {
 	type: "session";
 	version?: number; // v1 sessions don't have this
 	id: string;
+	title?: string; // Auto-generated title from first message
 	timestamp: string;
 	cwd: string;
 	parentSession?: string;
@@ -56,8 +57,10 @@ export interface ThinkingLevelChangeEntry extends SessionEntryBase {
 
 export interface ModelChangeEntry extends SessionEntryBase {
 	type: "model_change";
-	provider: string;
-	modelId: string;
+	/** Model in "provider/modelId" format */
+	model: string;
+	/** Role: "default", "smol", "slow", etc. Undefined treated as "default" */
+	role?: string;
 }
 
 export interface CompactionEntry<T = unknown> extends SessionEntryBase {
@@ -149,12 +152,14 @@ export interface SessionTreeNode {
 export interface SessionContext {
 	messages: AgentMessage[];
 	thinkingLevel: string;
-	model: { provider: string; modelId: string } | null;
+	/** Model roles: { default: "provider/modelId", small: "provider/modelId", ... } */
+	models: Record<string, string>;
 }
 
 export interface SessionInfo {
 	path: string;
 	id: string;
+	title?: string;
 	created: Date;
 	modified: Date;
 	messageCount: number;
@@ -290,7 +295,7 @@ export function buildSessionContext(
 	let leaf: SessionEntry | undefined;
 	if (leafId === null) {
 		// Explicitly null - return no messages (navigated to before first entry)
-		return { messages: [], thinkingLevel: "off", model: null };
+		return { messages: [], thinkingLevel: "off", models: {} };
 	}
 	if (leafId) {
 		leaf = byId.get(leafId);
@@ -301,7 +306,7 @@ export function buildSessionContext(
 	}
 
 	if (!leaf) {
-		return { messages: [], thinkingLevel: "off", model: null };
+		return { messages: [], thinkingLevel: "off", models: {} };
 	}
 
 	// Walk from leaf to root, collecting path
@@ -314,16 +319,21 @@ export function buildSessionContext(
 
 	// Extract settings and find compaction
 	let thinkingLevel = "off";
-	let model: { provider: string; modelId: string } | null = null;
+	const models: Record<string, string> = {};
 	let compaction: CompactionEntry | null = null;
 
 	for (const entry of path) {
 		if (entry.type === "thinking_level_change") {
 			thinkingLevel = entry.thinkingLevel;
 		} else if (entry.type === "model_change") {
-			model = { provider: entry.provider, modelId: entry.modelId };
+			// New format: { model: "provider/id", role?: string }
+			if (entry.model) {
+				const role = entry.role ?? "default";
+				models[role] = entry.model;
+			}
 		} else if (entry.type === "message" && entry.message.role === "assistant") {
-			model = { provider: entry.message.provider, modelId: entry.message.model };
+			// Infer default model from assistant messages
+			models.default = `${entry.message.provider}/${entry.message.model}`;
 		} else if (entry.type === "compaction") {
 			compaction = entry;
 		}
@@ -379,7 +389,7 @@ export function buildSessionContext(
 		}
 	}
 
-	return { messages, thinkingLevel, model };
+	return { messages, thinkingLevel, models };
 }
 
 /**
@@ -454,6 +464,67 @@ export function findMostRecentSession(sessionDir: string): string | null {
 	}
 }
 
+/** Recent session info for display */
+export interface RecentSessionInfo {
+	name: string;
+	path: string;
+	timeAgo: string;
+}
+
+/** Format a time difference as a human-readable string */
+function formatTimeAgo(date: Date): string {
+	const now = Date.now();
+	const diffMs = now - date.getTime();
+	const diffMins = Math.floor(diffMs / 60000);
+	const diffHours = Math.floor(diffMs / 3600000);
+	const diffDays = Math.floor(diffMs / 86400000);
+
+	if (diffMins < 1) return "just now";
+	if (diffMins < 60) return `${diffMins}m ago`;
+	if (diffHours < 24) return `${diffHours}h ago`;
+	if (diffDays < 7) return `${diffDays}d ago`;
+	return date.toLocaleDateString();
+}
+
+/** Get recent sessions for display in welcome screen */
+export function getRecentSessions(sessionDir: string, limit = 3): RecentSessionInfo[] {
+	try {
+		const files = readdirSync(sessionDir)
+			.filter((f) => f.endsWith(".jsonl"))
+			.map((f) => join(sessionDir, f))
+			.filter(isValidSessionFile)
+			.map((path) => {
+				const stat = statSync(path);
+				// Try to get session title or id from first line
+				let name = path.split("/").pop()?.replace(".jsonl", "") ?? "Unknown";
+				try {
+					const content = readFileSync(path, "utf-8");
+					const firstLine = content.split("\n")[0];
+					if (firstLine) {
+						const header = JSON.parse(firstLine) as SessionHeader;
+						if (header.type === "session") {
+							// Prefer title over id
+							name = header.title ?? header.id ?? name;
+						}
+					}
+				} catch {
+					// Use filename as fallback
+				}
+				return { path, name, mtime: stat.mtime };
+			})
+			.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
+			.slice(0, limit);
+
+		return files.map((f) => ({
+			name: f.name.length > 40 ? `${f.name.slice(0, 37)}...` : f.name,
+			path: f.path,
+			timeAgo: formatTimeAgo(f.mtime),
+		}));
+	} catch {
+		return [];
+	}
+}
+
 /**
  * Manages conversation sessions as append-only trees stored in JSONL files.
  *
@@ -467,6 +538,7 @@ export function findMostRecentSession(sessionDir: string): string | null {
  */
 export class SessionManager {
 	private sessionId: string = "";
+	private sessionTitle: string | undefined;
 	private sessionFile: string | undefined;
 	private sessionDir: string;
 	private cwd: string;
@@ -499,6 +571,7 @@ export class SessionManager {
 			this.fileEntries = loadEntriesFromFile(this.sessionFile);
 			const header = this.fileEntries.find((e) => e.type === "session") as SessionHeader | undefined;
 			this.sessionId = header?.id ?? crypto.randomUUID();
+			this.sessionTitle = header?.title;
 
 			if (migrateToCurrentVersion(this.fileEntries)) {
 				this._rewriteFile();
@@ -579,6 +652,31 @@ export class SessionManager {
 		return this.sessionFile;
 	}
 
+	getSessionTitle(): string | undefined {
+		return this.sessionTitle;
+	}
+
+	setSessionTitle(title: string): void {
+		this.sessionTitle = title;
+		// Update the session file header with the title
+		if (this.persist && this.sessionFile && existsSync(this.sessionFile)) {
+			try {
+				const content = readFileSync(this.sessionFile, "utf-8");
+				const lines = content.split("\n");
+				if (lines.length > 0) {
+					const header = JSON.parse(lines[0]) as SessionHeader;
+					if (header.type === "session") {
+						header.title = title;
+						lines[0] = JSON.stringify(header);
+						writeFileSync(this.sessionFile, lines.join("\n"));
+					}
+				}
+			} catch {
+				// Ignore errors updating title
+			}
+		}
+	}
+
 	_persist(entry: SessionEntry): void {
 		if (!this.persist || !this.sessionFile) return;
 
@@ -633,15 +731,19 @@ export class SessionManager {
 		return entry.id;
 	}
 
-	/** Append a model change as child of current leaf, then advance leaf. Returns entry id. */
-	appendModelChange(provider: string, modelId: string): string {
+	/**
+	 * Append a model change as child of current leaf, then advance leaf. Returns entry id.
+	 * @param model Model in "provider/modelId" format
+	 * @param role Optional role (default: "default")
+	 */
+	appendModelChange(model: string, role?: string): string {
 		const entry: ModelChangeEntry = {
 			type: "model_change",
 			id: generateId(this.byId),
 			parentId: this.leafId,
 			timestamp: new Date().toISOString(),
-			provider,
-			modelId,
+			model,
+			role,
 		};
 		this._appendEntry(entry);
 		return entry.id;
@@ -1061,7 +1163,7 @@ export class SessionManager {
 					if (lines.length === 0) continue;
 
 					// Check first line for valid session header
-					let header: { type: string; id: string; timestamp: string } | null = null;
+					let header: { type: string; id: string; title?: string; timestamp: string } | null = null;
 					try {
 						const first = JSON.parse(lines[0]);
 						if (first.type === "session" && first.id) {
@@ -1107,6 +1209,7 @@ export class SessionManager {
 					sessions.push({
 						path: file,
 						id: header.id,
+						title: header.title,
 						created: new Date(header.timestamp),
 						modified: stats.mtime,
 						messageCount,