@oh-my-pi/pi-coding-agent 14.1.0 → 14.1.2

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

@@ -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

@@ -839,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/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[] {

package/src/modes/components/status-line/presets.ts

@@ -3,7 +3,7 @@ import type { PresetDef, StatusLinePreset } from "./types";
 export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 	default: {
 		leftSegments: ["pi", "model", "plan_mode", "path", "git", "pr", "context_pct", "token_total", "cost"],
-		rightSegments: [],
+		rightSegments: ["session_name"],
 		separator: "powerline-thin",
 		segmentOptions: {
 			model: { showThinkingLevel: true },
@@ -14,7 +14,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 
 	minimal: {
 		leftSegments: ["path", "git"],
-		rightSegments: ["plan_mode", "context_pct"],
+		rightSegments: ["session_name", "plan_mode", "context_pct"],
 		separator: "slash",
 		segmentOptions: {
 			path: { abbreviate: true, maxLength: 30 },
@@ -24,7 +24,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 
 	compact: {
 		leftSegments: ["model", "plan_mode", "git", "pr"],
-		rightSegments: ["cost", "context_pct"],
+		rightSegments: ["session_name", "cost", "context_pct"],
 		separator: "powerline-thin",
 		segmentOptions: {
 			model: { showThinkingLevel: false },
@@ -34,7 +34,17 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 
 	full: {
 		leftSegments: ["pi", "hostname", "model", "plan_mode", "path", "git", "pr", "subagents"],
-		rightSegments: ["token_in", "token_out", "token_rate", "cache_read", "cost", "context_pct", "time_spent", "time"],
+		rightSegments: [
+			"session_name",
+			"token_in",
+			"token_out",
+			"token_rate",
+			"cache_read",
+			"cost",
+			"context_pct",
+			"time_spent",
+			"time",
+		],
 		separator: "powerline",
 		segmentOptions: {
 			model: { showThinkingLevel: true },
@@ -48,6 +58,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 		// Full preset with all Nerd Font icons
 		leftSegments: ["pi", "hostname", "model", "plan_mode", "path", "git", "pr", "session", "subagents"],
 		rightSegments: [
+			"session_name",
 			"token_in",
 			"token_out",
 			"cache_read",
@@ -71,7 +82,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 	ascii: {
 		// No Nerd Font dependencies
 		leftSegments: ["model", "plan_mode", "path", "git", "pr"],
-		rightSegments: ["token_total", "cost", "context_pct"],
+		rightSegments: ["session_name", "token_total", "cost", "context_pct"],
 		separator: "ascii",
 		segmentOptions: {
 			model: { showThinkingLevel: true },
@@ -83,7 +94,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 	custom: {
 		// User-defined - these are just defaults that get overridden
 		leftSegments: ["model", "plan_mode", "path", "git", "pr"],
-		rightSegments: ["token_total", "cost", "context_pct"],
+		rightSegments: ["session_name", "token_total", "cost", "context_pct"],
 		separator: "powerline-thin",
 		segmentOptions: {},
 	},

package/src/modes/components/status-line/segments.ts

@@ -5,6 +5,8 @@ import { TERMINAL } from "@oh-my-pi/pi-tui";
 import { formatDuration, formatNumber, getProjectDir, relativePathWithinRoot } from "@oh-my-pi/pi-utils";
 import { theme } from "../../../modes/theme/theme";
 import { shortenPath } from "../../../tools/render-utils";
+import { getSessionAccentAnsi, getSessionAccentHex } from "../../../utils/session-color";
+import { sanitizeStatusText } from "../../shared";
 import { getContextUsageLevel, getContextUsageThemeColor } from "./context-thresholds";
 import type { RenderedSegment, SegmentContext, StatusLineSegment, StatusLineSegmentId } from "./types";
 
@@ -354,6 +356,18 @@ const cacheWriteSegment: StatusLineSegment = {
 	},
 };
 
+const sessionNameSegment: StatusLineSegment = {
+	id: "session_name",
+	render(ctx) {
+		const sessionManager = ctx.session.sessionManager;
+		const name = sessionManager?.titleSource === "auto" ? undefined : sessionManager?.getSessionName();
+		if (!name) return { content: "", visible: false };
+
+		const ansi = getSessionAccentAnsi(getSessionAccentHex(name)) ?? theme.getFgAnsi("accent");
+		return { content: `${ansi}${sanitizeStatusText(name)}\x1b[39m`, visible: true };
+	},
+};
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Segment Registry
 // ═══════════════════════════════════════════════════════════════════════════
@@ -379,6 +393,7 @@ export const SEGMENTS: Record<StatusLineSegmentId, StatusLineSegment> = {
 	hostname: hostnameSegment,
 	cache_read: cacheReadSegment,
 	cache_write: cacheWriteSegment,
+	session_name: sessionNameSegment,
 };
 
 export function renderSegment(id: StatusLineSegmentId, ctx: SegmentContext): RenderedSegment {

package/src/modes/components/status-line-segment-editor.ts

@@ -36,6 +36,7 @@ const SEGMENT_INFO: Record<StatusLineSegmentId, { label: string; short: string }
 	hostname: { label: "Host", short: "hostname" },
 	cache_read: { label: "Cache ↓", short: "cache read" },
 	cache_write: { label: "Cache ↑", short: "cache write" },
+	session_name: { label: "Session Name", short: "named session" },
 };
 
 type Column = "left" | "right" | "disabled";

package/src/modes/components/status-line.ts

@@ -9,6 +9,7 @@ import { theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
 import { calculatePromptTokens } from "../../session/compaction/compaction";
 import * as git from "../../utils/git";
+import { getSessionAccentAnsi, getSessionAccentHexForTitle } from "../../utils/session-color";
 import { sanitizeStatusText } from "../shared";
 import {
 	canReuseCachedPr,
@@ -471,7 +472,12 @@ export class StatusLineComponent implements Component {
 		leftWidth = groupWidth(left, leftCapWidth, leftSepWidth);
 		rightWidth = groupWidth(right, rightCapWidth, rightSepWidth);
 		const gapWidth = Math.max(1, topFillWidth - leftWidth - rightWidth);
-		const gapFill = theme.fg("border", theme.boxRound.horizontal.repeat(gapWidth));
+		const accentHex = getSessionAccentHexForTitle(
+			this.session.sessionManager?.getSessionName(),
+			this.session.sessionManager?.titleSource,
+		);
+		const gapColor = getSessionAccentAnsi(accentHex) ?? theme.getFgAnsi("border");
+		const gapFill = `${gapColor}${theme.boxRound.horizontal.repeat(gapWidth)}\x1b[39m`;
 		return leftGroup + gapFill + rightGroup;
 	}