gsd-pi 2.27.0 → 2.28.0-dev.346ee62

package/packages/pi-coding-agent/package.json

@@ -13,10 +13,6 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
-    },
-    "./hooks": {
-      "types": "./dist/core/hooks/index.d.ts",
-      "import": "./dist/core/hooks/index.js"
     }
   },
   "scripts": {

package/packages/pi-coding-agent/src/core/agent-session.ts

@@ -2427,7 +2427,7 @@ export class AgentSession {
 
 		const err = message.errorMessage;
 		// Match: overloaded_error, rate limit, 429, 500, 502, 503, 504, service unavailable, connection errors, fetch failed, terminated, retry delay exceeded, network unavailable / auth expired (transient network failures)
-		return /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|temporarily backed off/i.test(
+		return /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|temporarily backed off/i.test(
 			err,
 		);
 	}

package/packages/pi-coding-agent/src/core/auth-storage.ts

@@ -20,6 +20,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "f
 import { dirname, join } from "path";
 import lockfile from "proper-lockfile";
 import { getAgentDir } from "../config.js";
+import { AUTH_LOCK_STALE_MS } from "./constants.js";
 import { resolveConfigValue } from "./resolve-config-value.js";
 
 export type ApiKeyCredential = {
@@ -136,7 +137,7 @@ export class FileAuthStorageBackend implements AuthStorageBackend {
 					maxTimeout: 10000,
 					randomize: true,
 				},
-				stale: 30000,
+				stale: AUTH_LOCK_STALE_MS,
 				onCompromised: (err) => {
 					lockCompromised = true;
 					lockCompromisedError = err;

package/packages/pi-coding-agent/src/core/bash-executor.ts

@@ -7,10 +7,28 @@
  */
 
 import { randomBytes } from "node:crypto";
-import { createWriteStream, type WriteStream } from "node:fs";
+import { createWriteStream, unlinkSync, type WriteStream } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { type ChildProcess, spawn } from "child_process";
+
+/** Track temp files created by bash execution for cleanup on exit. */
+const bashTempFiles = new Set<string>();
+
+let cleanupRegistered = false;
+function registerTempCleanup(): void {
+	if (cleanupRegistered) return;
+	cleanupRegistered = true;
+	process.on("exit", () => {
+		for (const file of bashTempFiles) {
+			try {
+				unlinkSync(file);
+			} catch {
+				// Best-effort cleanup
+			}
+		}
+	});
+}
 import { processStreamChunk, type StreamState } from "@gsd/native";
 import { getShellConfig, getShellEnv, killProcessTree, sanitizeCommand } from "../utils/shell.js";
 import type { BashOperations } from "./tools/bash.js";
@@ -111,8 +129,10 @@ export function executeBash(command: string, options?: BashExecutorOptions): Pro
 
 			// Start writing to temp file if exceeds threshold
 			if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
+				registerTempCleanup();
 				const id = randomBytes(8).toString("hex");
 				tempFilePath = join(tmpdir(), `pi-bash-${id}.log`);
+				bashTempFiles.add(tempFilePath);
 				tempFileStream = createWriteStream(tempFilePath);
 				// Write already-buffered chunks to temp file
 				for (const chunk of outputChunks) {
@@ -212,8 +232,10 @@ export async function executeBashWithOperations(
 
 		// Start writing to temp file if exceeds threshold
 		if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
+			registerTempCleanup();
 			const id = randomBytes(8).toString("hex");
 			tempFilePath = join(tmpdir(), `pi-bash-${id}.log`);
+			bashTempFiles.add(tempFilePath);
 			tempFileStream = createWriteStream(tempFilePath);
 			for (const chunk of outputChunks) {
 				tempFileStream.write(chunk);

package/packages/pi-coding-agent/src/core/blob-store.ts

@@ -6,7 +6,7 @@
  * provides automatic deduplication across sessions.
  */
 import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, writeFileSync, existsSync, accessSync } from "node:fs";
+import { mkdirSync, readdirSync, readFileSync, writeFileSync, existsSync, accessSync, unlinkSync, statSync } from "node:fs";
 import { join } from "node:path";
 
 const BLOB_PREFIX = "blob:sha256:";
@@ -64,6 +64,51 @@ export class BlobStore {
 			return false;
 		}
 	}
+
+	/**
+	 * Remove blobs not referenced by any session file.
+	 * @param referencedHashes Set of SHA-256 hashes still referenced in session files.
+	 * @returns Number of orphaned blobs removed.
+	 */
+	gc(referencedHashes: Set<string>): number {
+		let removed = 0;
+		try {
+			const entries = readdirSync(this.dir);
+			for (const entry of entries) {
+				if (!SHA256_HEX_RE.test(entry)) continue;
+				if (!referencedHashes.has(entry)) {
+					try {
+						unlinkSync(join(this.dir, entry));
+						removed++;
+					} catch {
+						// Best-effort removal
+					}
+				}
+			}
+		} catch {
+			// Blob dir may not exist or be unreadable
+		}
+		return removed;
+	}
+
+	/** Get total size of all blobs in bytes, or 0 if the directory is empty/unreadable. */
+	totalSize(): number {
+		try {
+			const entries = readdirSync(this.dir);
+			let total = 0;
+			for (const entry of entries) {
+				if (!SHA256_HEX_RE.test(entry)) continue;
+				try {
+					total += statSync(join(this.dir, entry)).size;
+				} catch {
+					// Skip unreadable files
+				}
+			}
+			return total;
+		} catch {
+			return 0;
+		}
+	}
 }
 
 /** Check if a data string is a blob reference. */

package/packages/pi-coding-agent/src/core/compaction/branch-summarization.ts

@@ -8,6 +8,7 @@
 import type { AgentMessage } from "@gsd/pi-agent-core";
 import type { Model } from "@gsd/pi-ai";
 import { completeSimple } from "@gsd/pi-ai";
+import { COMPACTION_RESERVE_TOKENS } from "../constants.js";
 import {
 	convertToLlm,
 	createBranchSummaryMessage,
@@ -281,7 +282,7 @@ export async function generateBranchSummary(
 	entries: SessionEntry[],
 	options: GenerateBranchSummaryOptions,
 ): Promise<BranchSummaryResult> {
-	const { model, apiKey, signal, customInstructions, replaceInstructions, reserveTokens = 16384 } = options;
+	const { model, apiKey, signal, customInstructions, replaceInstructions, reserveTokens = COMPACTION_RESERVE_TOKENS } = options;
 
 	// Token budget = context window minus reserved space for prompt + response
 	const contextWindow = model.contextWindow || 128000;

package/packages/pi-coding-agent/src/core/compaction/compaction.ts

@@ -8,6 +8,7 @@
 import type { AgentMessage } from "@gsd/pi-agent-core";
 import type { AssistantMessage, Model, Usage } from "@gsd/pi-ai";
 import { completeSimple } from "@gsd/pi-ai";
+import { COMPACTION_KEEP_RECENT_TOKENS, COMPACTION_RESERVE_TOKENS } from "../constants.js";
 import {
 	convertToLlm,
 	createBranchSummaryMessage,
@@ -113,8 +114,8 @@ export interface CompactionSettings {
 
 export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
 	enabled: true,
-	reserveTokens: 16384,
-	keepRecentTokens: 20000,
+	reserveTokens: COMPACTION_RESERVE_TOKENS,
+	keepRecentTokens: COMPACTION_KEEP_RECENT_TOKENS,
 };
 
 // ============================================================================

package/packages/pi-coding-agent/src/core/compaction/utils.ts

@@ -4,6 +4,7 @@
 
 import type { AgentMessage } from "@gsd/pi-agent-core";
 import type { Message } from "@gsd/pi-ai";
+import { TOOL_RESULT_MAX_CHARS } from "../constants.js";
 
 // ============================================================================
 // File Operation Tracking
@@ -85,8 +86,7 @@ export function formatFileOperations(readFiles: string[], modifiedFiles: string[
 // Message Serialization
 // ============================================================================
 
-/** Maximum characters for a tool result in serialized summaries. */
-const TOOL_RESULT_MAX_CHARS = 2000;
+// TOOL_RESULT_MAX_CHARS imported from ../constants.js
 
 /**
  * Truncate text to a maximum character length for summarization.

package/packages/pi-coding-agent/src/core/constants.ts

@@ -0,0 +1,59 @@
+/**
+ * Centralized configuration constants for the coding agent.
+ *
+ * Values grouped by subsystem. Each constant documents where it is consumed
+ * so that changes can be audited in one place.
+ */
+
+// =============================================================================
+// Timeouts
+// =============================================================================
+
+/** Shell command execution timeout used by resolve-config-value. */
+export const COMMAND_EXECUTION_TIMEOUT_MS = 10_000;
+
+/** LSP server liveness check timeout (lspmux). */
+export const LSP_LIVENESS_TIMEOUT_MS = 1_000;
+
+/** Staleness threshold for the async auth-storage file lock. */
+export const AUTH_LOCK_STALE_MS = 30_000;
+
+// =============================================================================
+// Caches
+// =============================================================================
+
+/** TTL for the cached lspmux state detection result. */
+export const LSP_STATE_CACHE_TTL_MS = 5 * 60 * 1_000;
+
+// =============================================================================
+// Compaction & Summarization
+// =============================================================================
+
+/** Tokens reserved for the LLM prompt + response during compaction and branch summarization. */
+export const COMPACTION_RESERVE_TOKENS = 16_384;
+
+/** Tokens from the tail of the conversation kept verbatim after compaction. */
+export const COMPACTION_KEEP_RECENT_TOKENS = 20_000;
+
+/** Max characters kept per tool-result block when serializing for summarization. */
+export const TOOL_RESULT_MAX_CHARS = 2_000;
+
+// =============================================================================
+// Retry
+// =============================================================================
+
+/** Base delay for exponential back-off retries (2 s, 4 s, 8 s ...). */
+export const RETRY_BASE_DELAY_MS = 2_000;
+
+/** Maximum server-requested delay before the retry loop gives up. */
+export const RETRY_MAX_DELAY_MS = 300_000;
+
+// =============================================================================
+// Tool Defaults
+// =============================================================================
+
+/** Default result-count cap for the find/glob tool. */
+export const FIND_DEFAULT_LIMIT = 1_000;
+
+/** Default line-count cap for tool-output truncation. */
+export const TRUNCATE_DEFAULT_MAX_LINES = 2_000;

package/packages/pi-coding-agent/src/core/extensions/loader.ts

@@ -105,7 +105,7 @@ function getAliases(): Record<string, string> {
 	return _aliases;
 }
 
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+const UNICODE_SPACES = /[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g;
 
 function normalizeUnicodeSpaces(str: string): string {
 	return str.replace(UNICODE_SPACES, " ");

package/packages/pi-coding-agent/src/core/extensions/runner.test.ts

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import { describe, it, mock } from "node:test";
+import { ExtensionRunner } from "./runner.js";
+import type { Extension, ExtensionRuntime, ToolCallEvent } from "./index.js";
+import { SessionManager } from "../session-manager.js";
+import { ModelRegistry } from "../model-registry.js";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { AuthStorage } from "../auth-storage.js";
+
+function makeMinimalRuntime(): ExtensionRuntime {
+	return {
+		sendMessage: async () => {},
+		sendUserMessage: async () => {},
+		appendEntry: () => {},
+		setSessionName: () => {},
+		getSessionName: () => undefined,
+		setLabel: () => {},
+		getActiveTools: () => [],
+		getAllTools: () => [],
+		setActiveTools: () => {},
+		refreshTools: () => {},
+		getCommands: () => [],
+		setModel: async () => {},
+		getThinkingLevel: () => undefined,
+		setThinkingLevel: () => {},
+		registerProvider: () => {},
+		unregisterProvider: () => {},
+		pendingProviderRegistrations: [],
+	} as unknown as ExtensionRuntime;
+}
+
+function makeThrowingExtension(eventType: string, error: Error): Extension {
+	const handlers = new Map();
+	handlers.set(eventType, [
+		async () => {
+			throw error;
+		},
+	]);
+	return {
+		path: "/test/throwing-ext",
+		handlers,
+		commands: [],
+		shortcuts: [],
+		diagnostics: [],
+	} as unknown as Extension;
+}
+
+describe("ExtensionRunner.emitToolCall", () => {
+	it("catches throwing extension handler and routes to emitError", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "runner-test-"));
+		try {
+			const sessionManager = SessionManager.create(dir, dir);
+			const authStorage = AuthStorage.create();
+			const modelRegistry = new ModelRegistry(authStorage, join(dir, "models.json"));
+
+			const throwingExt = makeThrowingExtension("tool_call", new Error("handler crashed"));
+			const runtime = makeMinimalRuntime();
+			const runner = new ExtensionRunner([throwingExt], runtime, dir, sessionManager, modelRegistry);
+
+			const errors: any[] = [];
+			runner.onError((err) => errors.push(err));
+
+			const event: ToolCallEvent = {
+				type: "tool_call",
+				toolCallId: "test-123",
+				toolName: "test_tool",
+				input: {},
+			} as ToolCallEvent;
+
+			const result = await runner.emitToolCall(event);
+
+			// Should not throw — error is caught and routed to emitError
+			assert.equal(result, undefined);
+			assert.equal(errors.length, 1);
+			assert.equal(errors[0].error, "handler crashed");
+			assert.equal(errors[0].event, "tool_call");
+			assert.equal(errors[0].extensionPath, "/test/throwing-ext");
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});

package/packages/pi-coding-agent/src/core/extensions/runner.ts

@@ -211,11 +211,21 @@ export class ExtensionRunner {
 	private getContextUsageFn: () => ContextUsage | undefined = () => undefined;
 	private compactFn: (options?: CompactOptions) => void = () => {};
 	private getSystemPromptFn: () => string = () => "";
-	private newSessionHandler: NewSessionHandler = async () => ({ cancelled: false });
-	private forkHandler: ForkHandler = async () => ({ cancelled: false });
-	private navigateTreeHandler: NavigateTreeHandler = async () => ({ cancelled: false });
-	private switchSessionHandler: SwitchSessionHandler = async () => ({ cancelled: false });
-	private reloadHandler: ReloadHandler = async () => {};
+	private newSessionHandler: NewSessionHandler = async () => {
+		throw new Error("Command context not yet bound: newSession is unavailable during early lifecycle");
+	};
+	private forkHandler: ForkHandler = async () => {
+		throw new Error("Command context not yet bound: fork is unavailable during early lifecycle");
+	};
+	private navigateTreeHandler: NavigateTreeHandler = async () => {
+		throw new Error("Command context not yet bound: navigateTree is unavailable during early lifecycle");
+	};
+	private switchSessionHandler: SwitchSessionHandler = async () => {
+		throw new Error("Command context not yet bound: switchSession is unavailable during early lifecycle");
+	};
+	private reloadHandler: ReloadHandler = async () => {
+		throw new Error("Command context not yet bound: reload is unavailable during early lifecycle");
+	};
 	private shutdownHandler: ShutdownHandler = () => {};
 	private shortcutDiagnostics: ResourceDiagnostic[] = [];
 	private commandDiagnostics: ResourceDiagnostic[] = [];
@@ -637,13 +647,24 @@ export class ExtensionRunner {
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
-				const handlerResult = await handler(event, ctx);
+				try {
+					const handlerResult = await handler(event, ctx);
 
-				if (handlerResult) {
-					result = handlerResult as ToolCallEventResult;
-					if (result.block) {
-						return result;
+					if (handlerResult) {
+						result = handlerResult as ToolCallEventResult;
+						if (result.block) {
+							return result;
+						}
 					}
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					const stack = err instanceof Error ? err.stack : undefined;
+					this.emitError({
+						extensionPath: ext.path,
+						event: "tool_call",
+						error: message,
+						stack,
+					});
 				}
 			}
 		}

package/packages/pi-coding-agent/src/core/fs-utils.test.ts

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { mkdtempSync, readFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { atomicWriteFileSync } from "./fs-utils.js";
+
+describe("atomicWriteFileSync", () => {
+	it("writes file content atomically", () => {
+		const dir = mkdtempSync(join(tmpdir(), "fs-utils-test-"));
+		try {
+			const filePath = join(dir, "test.txt");
+			atomicWriteFileSync(filePath, "hello world");
+			assert.equal(readFileSync(filePath, "utf-8"), "hello world");
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("overwrites existing file atomically", () => {
+		const dir = mkdtempSync(join(tmpdir(), "fs-utils-test-"));
+		try {
+			const filePath = join(dir, "test.txt");
+			atomicWriteFileSync(filePath, "first");
+			atomicWriteFileSync(filePath, "second");
+			assert.equal(readFileSync(filePath, "utf-8"), "second");
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not leave .tmp file after successful write", () => {
+		const dir = mkdtempSync(join(tmpdir(), "fs-utils-test-"));
+		try {
+			const filePath = join(dir, "test.txt");
+			atomicWriteFileSync(filePath, "content");
+			assert.equal(existsSync(filePath + ".tmp"), false);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("supports Buffer content", () => {
+		const dir = mkdtempSync(join(tmpdir(), "fs-utils-test-"));
+		try {
+			const filePath = join(dir, "test.bin");
+			const buf = Buffer.from([0x00, 0x01, 0x02, 0xff]);
+			atomicWriteFileSync(filePath, buf);
+			const result = readFileSync(filePath);
+			assert.deepEqual(result, buf);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("supports encoding parameter", () => {
+		const dir = mkdtempSync(join(tmpdir(), "fs-utils-test-"));
+		try {
+			const filePath = join(dir, "test.txt");
+			atomicWriteFileSync(filePath, "utf8 content", "utf-8");
+			assert.equal(readFileSync(filePath, "utf-8"), "utf8 content");
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});

package/packages/pi-coding-agent/src/core/fs-utils.ts

@@ -0,0 +1,12 @@
+import { renameSync, writeFileSync } from "node:fs";
+
+/**
+ * Atomically write a file by writing to a temporary path then renaming.
+ * This prevents data loss if the process crashes mid-write — either the
+ * old file remains intact or the new content is fully written.
+ */
+export function atomicWriteFileSync(filePath: string, content: string | Buffer, encoding?: BufferEncoding): void {
+	const tmpPath = filePath + ".tmp";
+	writeFileSync(tmpPath, content, encoding);
+	renameSync(tmpPath, filePath);
+}

package/packages/pi-coding-agent/src/core/lsp/client.ts

@@ -197,8 +197,12 @@ function parseMessage(
 	let message: LspJsonRpcResponse | LspJsonRpcNotification;
 	try {
 		message = JSON.parse(messageText);
-	} catch {
-		// Malformed JSON from LSP server — skip this message and advance past it
+	} catch (err) {
+		// Malformed JSON from LSP server — log and skip this message
+		if (process.env.DEBUG) {
+			const preview = messageText.length > 200 ? messageText.slice(0, 200) + "..." : messageText;
+			console.error(`[lsp] Dropped malformed JSON message: ${err instanceof Error ? err.message : err} — ${preview}`);
+		}
 		return { message: null, remaining };
 	}
 
@@ -409,6 +413,22 @@ export const WARMUP_TIMEOUT_MS = 5000;
  * Get or create an LSP client for the given server configuration and working directory.
  */
 export async function getOrCreateClient(config: ServerConfig, cwd: string, initTimeoutMs?: number): Promise<LspClient> {
+	const maxRetries = 2;
+	let lastErr: unknown;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		try {
+			return await getOrCreateClientOnce(config, cwd, initTimeoutMs);
+		} catch (err) {
+			lastErr = err;
+			if (attempt < maxRetries) {
+				await new Promise((resolve) => setTimeout(resolve, 1000 * (attempt + 1)));
+			}
+		}
+	}
+	throw lastErr;
+}
+
+async function getOrCreateClientOnce(config: ServerConfig, cwd: string, initTimeoutMs?: number): Promise<LspClient> {
 	const key = `${config.command}:${cwd}`;
 
 	const existingClient = clients.get(key);

package/packages/pi-coding-agent/src/core/lsp/index.ts

@@ -14,7 +14,7 @@ import {
 	setIdleTimeout,
 	WARMUP_TIMEOUT_MS,
 } from "./client.js";
-import { getServersForFile, type LspConfig, loadConfig } from "./config.js";
+import { getServersForFile, type LspConfig, loadConfig, hasRootMarkers, resolveCommand } from "./config.js";
 import { applyTextEdits, applyWorkspaceEdit } from "./edits.js";
 import { ToolAbortError, clampTimeout, throwIfAborted } from "./helpers.js";
 import { detectLspmux } from "./lspmux.js";
@@ -370,10 +370,36 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 						: "lspmux: installed but server not running"
 					: "";
 
-				const serverStatus =
-					servers.length > 0
-						? `Active language servers: ${servers.join(", ")}`
-						: "No language servers configured for this project";
+				let serverStatus: string;
+				if (servers.length > 0) {
+					serverStatus = `Active language servers: ${servers.join(", ")}`;
+				} else {
+					// Diagnose why no servers were detected
+					const DEFAULTS = (await import("./defaults.json", { with: { type: "json" } })).default as Record<string, { command: string; rootMarkers: string[] }>;
+					const diagnostics: string[] = ["No language servers configured for this project."];
+					const matchedButMissing: string[] = [];
+					const noMarkers: string[] = [];
+
+					for (const [name, def] of Object.entries(DEFAULTS)) {
+						if (hasRootMarkers(cwd, def.rootMarkers)) {
+							const resolved = resolveCommand(def.command, cwd);
+							if (!resolved) {
+								matchedButMissing.push(`  ${name}: project detected (${def.rootMarkers[0]}) but '${def.command}' not found — install it with npm/pip/brew`);
+							}
+						}
+					}
+
+					if (matchedButMissing.length > 0) {
+						diagnostics.push("\nDetected projects missing language servers:");
+						diagnostics.push(...matchedButMissing);
+						diagnostics.push("\nInstall the missing server command and restart GSD, or run: lsp reload");
+					} else {
+						diagnostics.push("No recognized project markers found in the working directory.");
+						diagnostics.push("LSP auto-detects projects via files like package.json, Cargo.toml, go.mod, pyproject.toml, etc.");
+					}
+
+					serverStatus = diagnostics.join("\n");
+				}
 
 				const output = lspmuxStatus ? `${serverStatus}\n${lspmuxStatus}` : serverStatus;
 				return {

package/packages/pi-coding-agent/src/core/lsp/lspmux.ts

@@ -2,6 +2,7 @@ import { execSync, spawn } from "node:child_process";
 import * as fsPromises from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import { LSP_LIVENESS_TIMEOUT_MS, LSP_STATE_CACHE_TTL_MS } from "../constants.js";
 
 /**
  * lspmux integration for LSP server multiplexing.
@@ -41,8 +42,6 @@ const DEFAULT_SUPPORTED_SERVERS = new Set([
 	"rust-analyzer",
 ]);
 
-const LIVENESS_TIMEOUT_MS = 1000;
-const STATE_CACHE_TTL_MS = 5 * 60 * 1000;
 
 // =============================================================================
 // Helpers
@@ -50,7 +49,16 @@ const STATE_CACHE_TTL_MS = 5 * 60 * 1000;
 
 function which(command: string): string | null {
 	try {
-		return execSync(`which ${command}`, { encoding: "utf-8" }).trim() || null;
+		// On Windows, prefer `where.exe` over `which` — MSYS/Git Bash's `which`
+		// returns POSIX paths (/c/Users/...) that Node's spawn() can't execute (#1121).
+		const isWindows = process.platform === "win32";
+		const cmd = isWindows ? "where.exe" : "which";
+		const result = isWindows
+			? execSync(`${cmd} ${command}`, { encoding: "utf-8" })
+			: execSync(`which ${command}`, { encoding: "utf-8" });
+		// `where.exe` may return multiple lines — take the first
+		const resolved = result.trim().split(/\r?\n/)[0]?.trim();
+		return resolved || null;
 	} catch {
 		return null;
 	}
@@ -108,7 +116,7 @@ async function checkServerRunning(binaryPath: string): Promise<boolean> {
 			new Promise<number>((resolve) => {
 				proc.on("exit", (code: number | null) => resolve(code ?? 1));
 			}),
-			new Promise<null>(resolve => setTimeout(() => resolve(null), LIVENESS_TIMEOUT_MS)),
+			new Promise<null>(resolve => setTimeout(() => resolve(null), LSP_LIVENESS_TIMEOUT_MS)),
 		]);
 
 		if (exited === null) {
@@ -124,7 +132,7 @@ async function checkServerRunning(binaryPath: string): Promise<boolean> {
 
 export async function detectLspmux(): Promise<LspmuxState> {
 	const now = Date.now();
-	if (cachedState && now - cacheTimestamp < STATE_CACHE_TTL_MS) {
+	if (cachedState && now - cacheTimestamp < LSP_STATE_CACHE_TTL_MS) {
 		return cachedState;
 	}
 

package/packages/pi-coding-agent/src/core/model-resolver.ts

@@ -504,6 +504,20 @@ export async function findInitialModel(options: {
 	if (defaultProvider && defaultModelId) {
 		const found = modelRegistry.find(defaultProvider, defaultModelId);
 		if (found) {
+			// Check if the provider's recommended default is a higher-capability variant
+			// of the saved model (e.g. saved "claude-opus-4-6" vs recommended "claude-opus-4-6[1m]").
+			// If so, prefer the recommended variant to avoid using a smaller context window (#1125).
+			const recommendedId = defaultModelPerProvider[defaultProvider as KnownProvider];
+			if (recommendedId && recommendedId !== defaultModelId && recommendedId.startsWith(defaultModelId)) {
+				const recommended = modelRegistry.find(defaultProvider, recommendedId);
+				if (recommended) {
+					model = recommended;
+					if (defaultThinkingLevel) {
+						thinkingLevel = defaultThinkingLevel;
+					}
+					return { model, thinkingLevel, fallbackMessage: undefined };
+				}
+			}
 			model = found;
 			if (defaultThinkingLevel) {
 				thinkingLevel = defaultThinkingLevel;