@oh-my-pi/pi-coding-agent 14.0.5 → 14.1.1

package/src/ipy/kernel.ts

@@ -49,6 +49,10 @@ interface KernelShutdownOptions {
 	timeoutMs?: number;
 }
 
+export interface KernelShutdownResult {
+	confirmed: boolean;
+}
+
 function getRemainingTimeMs(deadlineMs?: number): number | undefined {
 	if (deadlineMs === undefined) return undefined;
 	return Math.max(0, deadlineMs - Date.now());
@@ -399,10 +403,11 @@ export class PythonKernel {
 	#ws: WebSocket | null = null;
 	#disposed = false;
 	#alive = true;
+	#shutdownStarted = false;
+	#shutdownConfirmed = false;
 	#messageHandlers = new Map<string, (msg: JupyterMessage) => void>();
 	#channelHandlers = new Map<string, Set<(msg: JupyterMessage) => void>>();
 	#pendingExecutions = new Map<string, (reason: string) => void>();
-
 	private constructor(
 		readonly id: string,
 		readonly kernelId: string,
@@ -1004,11 +1009,18 @@ export class PythonKernel {
 		}
 	}
 
-	async shutdown(options?: KernelShutdownOptions): Promise<void> {
-		if (this.#disposed) return;
-		this.#disposed = true;
-		this.#alive = false;
-		this.#abortPendingExecutions("Kernel shutdown");
+	async shutdown(options?: KernelShutdownOptions): Promise<KernelShutdownResult> {
+		if (this.#shutdownConfirmed) return { confirmed: true };
+		if (!this.#shutdownStarted) {
+			this.#shutdownStarted = true;
+			this.#alive = false;
+			this.#abortPendingExecutions("Kernel shutdown");
+
+			if (this.#ws) {
+				this.#ws.close();
+				this.#ws = null;
+			}
+		}
 
 		const shutdownSignal = combineAbortSignal(
 			{ signal: options?.signal },
@@ -1016,24 +1028,38 @@ export class PythonKernel {
 			"Python kernel shutdown timed out",
 		);
 
+		let confirmed = false;
 		try {
-			await fetch(`${this.gatewayUrl}/api/kernels/${this.kernelId}`, {
+			const response = await fetch(`${this.gatewayUrl}/api/kernels/${this.kernelId}`, {
 				method: "DELETE",
 				headers: this.#authHeaders(),
 				signal: shutdownSignal,
 			});
+			const deleteConfirmed = response.status === 404 || response.status === 410;
+			confirmed = response.ok || deleteConfirmed;
+			if (!confirmed) {
+				logger.warn("Kernel delete request was not confirmed", {
+					status: response.status,
+					statusText: response.statusText,
+				});
+			}
 		} catch (err: unknown) {
 			logger.warn("Failed to delete kernel via API", { error: err instanceof Error ? err.message : String(err) });
 		}
-
-		if (this.#ws) {
-			this.#ws.close();
-			this.#ws = null;
-		}
+		this.#shutdownConfirmed = confirmed;
+		this.#disposed = confirmed;
 
 		if (this.isSharedGateway) {
-			await releaseSharedGateway();
+			try {
+				await releaseSharedGateway();
+			} catch (err: unknown) {
+				logger.warn("Failed to release shared gateway after kernel shutdown", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
 		}
+
+		return { confirmed };
 	}
 
 	#sendMessage(msg: JupyterMessage): void {

package/src/lsp/client.ts

@@ -23,7 +23,7 @@ const fileOperationLocks = new Map<string, Promise<void>>();
 
 // Idle timeout configuration (disabled by default)
 let idleTimeoutMs: number | null = null;
-let idleCheckInterval: Timer | null = null;
+let idleCheckInterval: NodeJS.Timeout | null = null;
 const IDLE_CHECK_INTERVAL_MS = 60 * 1000;
 
 /**
@@ -136,6 +136,9 @@ const CLIENT_CAPABILITIES = {
 			dataSupport: true,
 		},
 	},
+	window: {
+		workDoneProgress: true,
+	},
 	workspace: {
 		applyEdit: true,
 		workspaceEdit: {
@@ -267,6 +270,16 @@ async function startMessageReader(client: LspClient): Promise<void> {
 							version: params.version ?? null,
 						});
 						client.diagnosticsVersion += 1;
+					} else if (message.method === "$/progress" && message.params) {
+						const params = message.params as { token: string | number; value?: { kind?: string } };
+						if (params.value?.kind === "begin") {
+							client.activeProgressTokens.add(params.token);
+						} else if (params.value?.kind === "end") {
+							client.activeProgressTokens.delete(params.token);
+							if (client.activeProgressTokens.size === 0) {
+								client.resolveProjectLoaded();
+							}
+						}
 					}
 				}
 
@@ -338,6 +351,13 @@ async function handleServerRequest(client: LspClient, message: LspJsonRpcRequest
 		await handleApplyEditRequest(client, message);
 		return;
 	}
+	if (message.method === "window/workDoneProgress/create") {
+		// Accept progress token registration from the server
+		if (typeof message.id === "number") {
+			await sendResponse(client, message.id, null, message.method);
+		}
+		return;
+	}
 	if (typeof message.id !== "number") return;
 	await sendResponse(client, message.id, null, message.method, {
 		code: -32601,
@@ -375,6 +395,9 @@ async function sendResponse(
 /** Timeout for warmup initialize requests (5 seconds) */
 export const WARMUP_TIMEOUT_MS = 5000;
 
+/** Max time to wait for the server to report project loading completion via $/progress */
+const PROJECT_LOAD_TIMEOUT_MS = 15_000;
+
 /**
  * Get or create an LSP client for the given server configuration and working directory.
  * @param config - Server configuration
@@ -413,6 +436,18 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			env: env ? { ...Bun.env, ...env } : undefined,
 		});
 
+		let resolveProjectLoaded!: () => void;
+		const projectLoaded = new Promise<void>(resolve => {
+			resolveProjectLoaded = resolve;
+		});
+		// Auto-resolve after timeout in case server doesn't use progress tokens
+		const projectLoadTimeout = setTimeout(resolveProjectLoaded, PROJECT_LOAD_TIMEOUT_MS);
+		const originalResolve = resolveProjectLoaded;
+		resolveProjectLoaded = () => {
+			clearTimeout(projectLoadTimeout);
+			originalResolve();
+		};
+
 		const client: LspClient = {
 			name: key,
 			cwd,
@@ -426,6 +461,9 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			messageBuffer: new Uint8Array(0),
 			isReading: false,
 			lastActivity: Date.now(),
+			activeProgressTokens: new Set(),
+			projectLoaded,
+			resolveProjectLoaded,
 		};
 		clients.set(key, client);
 
@@ -433,6 +471,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 		proc.exited.then(() => {
 			clients.delete(key);
 			clientLocks.delete(key);
+			client.resolveProjectLoaded();
 
 			// Reject any pending requests — the server is gone, they will never complete.
 			if (client.pendingRequests.size > 0) {
@@ -554,6 +593,21 @@ export async function ensureFileOpen(client: LspClient, filePath: string, signal
 	}
 }
 
+/**
+ * Wait for the server's initial project loading to complete.
+ * Races the server's $/progress tracking against the abort signal.
+ * Returns immediately if loading already completed or timed out.
+ */
+export async function waitForProjectLoaded(client: LspClient, signal?: AbortSignal): Promise<void> {
+	if (signal?.aborted) return;
+	await Promise.race([
+		client.projectLoaded,
+		...(signal
+			? [new Promise<void>(resolve => signal.addEventListener("abort", () => resolve(), { once: true }))]
+			: []),
+	]);
+}
+
 /**
  * Sync in-memory content to the LSP client without reading from disk.
  * Use this to provide instant feedback during edits before the file is saved.

package/src/lsp/index.ts

@@ -20,6 +20,7 @@ import {
 	setIdleTimeout,
 	syncContent,
 	WARMUP_TIMEOUT_MS,
+	waitForProjectLoaded,
 } from "./client";
 import { getLinterClient } from "./clients";
 import { getServersForFile, type LspConfig, loadConfig } from "./config";
@@ -1427,6 +1428,13 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 			let output: string;
 
+			// Wait for project loading to complete before cross-file operations
+			// to ensure the server has indexed all project files.
+			const crossFileActions = new Set(["definition", "type_definition", "implementation", "references", "rename"]);
+			if (crossFileActions.has(action)) {
+				await waitForProjectLoaded(client, signal);
+			}
+
 			switch (action) {
 				// =====================================================================
 				// Standard LSP Operations

package/src/lsp/types.ts

@@ -411,6 +411,12 @@ export interface LspClient {
 	isReading: boolean;
 	serverCapabilities?: LspServerCapabilities;
 	lastActivity: number;
+	/** Tracks active work-done progress tokens from the server */
+	activeProgressTokens: Set<string | number>;
+	/** Resolves when the server's initial project loading completes (or after timeout) */
+	projectLoaded: Promise<void>;
+	/** Call to signal that project loading has completed */
+	resolveProjectLoaded: () => void;
 }
 
 // =============================================================================

package/src/main.ts

@@ -79,6 +79,8 @@ const RPC_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"todo.eager",
 	"async.enabled",
 	"async.maxJobs",
+	"bash.autoBackground.enabled",
+	"bash.autoBackground.thresholdMs",
 	"task.isolation.mode",
 	"task.isolation.merge",
 	"task.isolation.commits",
@@ -453,7 +455,9 @@ async function buildSessionOptions(
 			}
 		} else if (resolved.model) {
 			options.model = resolved.model;
-			settings.overrideModelRoles({ default: `${resolved.model.provider}/${resolved.model.id}` });
+			settings.overrideModelRoles({
+				default: resolved.selector ?? `${resolved.model.provider}/${resolved.model.id}`,
+			});
 			if (!parsed.thinking && resolved.thinkingLevel) {
 				options.thinkingLevel = resolved.thinkingLevel;
 			}
@@ -467,6 +471,7 @@ async function buildSessionOptions(
 				{
 					settings,
 					matchPreferences: modelMatchPreferences,
+					modelRegistry,
 				},
 			);
 			const rememberedResolvedModel = rememberedSpec.model;
@@ -834,7 +839,6 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 			settings: nextSettings,
 			authStorage,
 			modelRegistry,
-			searchDb: session.searchDb,
 			hasUI: false,
 		});
 		if (nextSession.extensionRunner) {

package/src/memories/index.ts

@@ -6,7 +6,7 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
 import { getAgentDbPath, getMemoriesDir, logger, parseJsonlLenient, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
-import { parseModelString } from "../config/model-resolver";
+import { resolveModelRoleValue } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
 import consolidationTemplate from "../prompts/memories/consolidation.md" with { type: "text" };
 import readPathTemplate from "../prompts/memories/read-path.md" with { type: "text" };
@@ -1055,11 +1055,12 @@ async function resolveMemoryModel(options: {
 	const { modelRegistry, session, fallbackRole } = options;
 	const requestedModel = session.settings.getModelRole(fallbackRole) || session.settings.getModelRole("default");
 	if (requestedModel) {
-		const parsed = parseModelString(requestedModel);
-		if (parsed) {
-			const found = modelRegistry.find(parsed.provider, parsed.id);
-			if (found) return found;
-		}
+		const resolved = resolveModelRoleValue(requestedModel, modelRegistry.getAll(), {
+			settings: session.settings,
+			matchPreferences: { usageOrder: session.settings.getStorage()?.getModelUsageOrder() },
+			modelRegistry,
+		});
+		if (resolved.model) return resolved.model;
 	}
 	return session.model ?? modelRegistry.getAll()[0];
 }

package/src/modes/acp/acp-agent.ts

@@ -1148,10 +1148,13 @@ export class AcpAgent implements Agent {
 				},
 				getThinkingLevel: () => record.session.thinkingLevel,
 				setThinkingLevel: level => record.session.setThinkingLevel(level),
+				getSessionName: () => record.session.sessionManager.getSessionName(),
+				setSessionName: async name => {
+					await record.session.sessionManager.setSessionName(name, "user");
+				},
 			},
 			{
 				getModel: () => record.session.model,
-				getSearchDb: () => record.session.searchDb,
 				isIdle: () => !record.session.isStreaming,
 				abort: () => {
 					void record.session.abort();

package/src/modes/components/bash-execution.ts

@@ -3,7 +3,18 @@
  */
 
 import { sanitizeText } from "@oh-my-pi/pi-natives";
-import { Container, ImageProtocol, Loader, Spacer, TERMINAL, Text, type TUI } from "@oh-my-pi/pi-tui";
+import {
+	Container,
+	Ellipsis,
+	ImageProtocol,
+	Loader,
+	Spacer,
+	TERMINAL,
+	Text,
+	type TUI,
+	truncateToWidth,
+	visibleWidth,
+} from "@oh-my-pi/pi-tui";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import { formatTruncationMetaNotice, type TruncationMeta } from "../../tools/output-meta";
 import { getSixelLineMask, isSixelPassthroughEnabled, sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
@@ -210,11 +221,12 @@ export class BashExecutionComponent extends Container {
 	}
 
 	#clampDisplayLine(line: string): string {
-		if (line.length <= MAX_DISPLAY_LINE_CHARS) {
+		const visible = visibleWidth(line);
+		if (visible <= MAX_DISPLAY_LINE_CHARS) {
 			return line;
 		}
-		const omitted = line.length - MAX_DISPLAY_LINE_CHARS;
-		return `${line.slice(0, MAX_DISPLAY_LINE_CHARS)}… [${omitted} chars omitted]`;
+		const omitted = visible - MAX_DISPLAY_LINE_CHARS;
+		return `${truncateToWidth(line, MAX_DISPLAY_LINE_CHARS, Ellipsis.Omit)}… [${omitted} visible columns omitted]`;
 	}
 
 	#clampLinesPreservingSixel(lines: string[]): string[] {