gsd-pi 2.78.0 → 2.78.1-dev.2d3fd6e71

package/src/resources/extensions/gsd/worktree-root.ts

@@ -0,0 +1,182 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { gsdHome } from "./gsd-home.js";
+
+export interface WorktreeSegment {
+  gsdIdx: number;
+  afterWorktrees: number;
+}
+
+export function normalizeWorktreePathForCompare(path: string): string {
+  let normalized: string;
+  try {
+    normalized = realpathSync(path);
+  } catch {
+    normalized = resolve(path);
+  }
+  const slashed = normalized.replaceAll("\\", "/");
+  const trimmed = slashed.replace(/\/+$/, "");
+  return process.platform === "win32" ? (trimmed || "/").toLowerCase() : (trimmed || "/");
+}
+
+/**
+ * Find the GSD worktree segment in both direct project layout and the
+ * symlink-resolved external-state layout used by ~/.gsd/projects/<hash>.
+ */
+export function findWorktreeSegment(normalizedPath: string): WorktreeSegment | null {
+  const directMarker = "/.gsd/worktrees/";
+  const directIdx = normalizedPath.indexOf(directMarker);
+  if (directIdx !== -1) {
+    return { gsdIdx: directIdx, afterWorktrees: directIdx + directMarker.length };
+  }
+
+  const externalRe = /\/\.gsd\/projects\/[^/]+\/worktrees\//;
+  const externalMatch = normalizedPath.match(externalRe);
+  if (externalMatch && externalMatch.index !== undefined) {
+    return {
+      gsdIdx: externalMatch.index,
+      afterWorktrees: externalMatch.index + externalMatch[0].length,
+    };
+  }
+
+  return null;
+}
+
+export function isGsdWorktreePath(path: string): boolean {
+  return findWorktreeSegment(path.replaceAll("\\", "/")) !== null;
+}
+
+/**
+ * Resolve the canonical project root for worktree operations.
+ *
+ * `originalBasePath` wins when available because session state already knows the
+ * root. `GSD_PROJECT_ROOT` is the next strongest signal for worker processes.
+ * Otherwise, derive the root from direct `.gsd/worktrees` paths, or recover it
+ * from the worktree `.git` file for symlink-resolved ~/.gsd/project paths.
+ */
+export function resolveWorktreeProjectRoot(
+  basePath: string,
+  originalBasePath?: string | null,
+): string {
+  const explicitOriginal = originalBasePath?.trim();
+  if (explicitOriginal) return resolveProjectRootFromPath(explicitOriginal);
+
+  const envProjectRoot = process.env.GSD_PROJECT_ROOT?.trim();
+  if (envProjectRoot && isGsdWorktreePath(basePath)) {
+    return resolveProjectRootFromPath(envProjectRoot);
+  }
+
+  return resolveProjectRootFromPath(basePath || envProjectRoot || process.cwd());
+}
+
+function resolveProjectRootFromPath(path: string): string {
+  const normalizedPath = path.replaceAll("\\", "/");
+  const segment = findWorktreeSegment(normalizedPath);
+  if (!segment) {
+    return resolveNearestBootstrappedGsdRoot(path) ?? resolveGitWorkingTreeRoot(path) ?? path;
+  }
+
+  const sepChar = path.includes("\\") ? "\\" : "/";
+  const gsdMarker = `${sepChar}.gsd${sepChar}`;
+  const markerIdx = path.indexOf(gsdMarker);
+  const candidate = markerIdx !== -1
+    ? path.slice(0, markerIdx)
+    : path.slice(0, segment.gsdIdx);
+
+  const gsdHomeNorm = normalizeWorktreePathForCompare(gsdHome());
+  const candidateGsdPath = normalizeWorktreePathForCompare(join(candidate, ".gsd"));
+
+  if (candidateGsdPath === gsdHomeNorm || candidateGsdPath.startsWith(`${gsdHomeNorm}/`)) {
+    const realRoot = resolveProjectRootFromGitFile(path);
+    return realRoot ?? path;
+  }
+
+  return candidate;
+}
+
+function resolveNearestBootstrappedGsdRoot(path: string): string | null {
+  try {
+    let dir = existsSync(path) && !statSync(path).isDirectory()
+      ? resolve(path, "..")
+      : path;
+    const externalStateParent = normalizeWorktreePathForCompare(resolve(gsdHome(), ".."));
+
+    for (let i = 0; i < 30; i++) {
+      if (normalizeWorktreePathForCompare(dir) === externalStateParent) return null;
+      if (hasGsdBootstrapArtifacts(join(dir, ".gsd"))) return dir;
+
+      const gitPath = join(dir, ".git");
+      if (existsSync(gitPath)) return null;
+
+      const parent = resolve(dir, "..");
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    // Non-fatal: callers fall back to git root resolution.
+  }
+  return null;
+}
+
+function hasGsdBootstrapArtifacts(gsdPath: string): boolean {
+  return existsSync(gsdPath) &&
+    (existsSync(join(gsdPath, "PREFERENCES.md")) ||
+      existsSync(join(gsdPath, "preferences.md")) ||
+      existsSync(join(gsdPath, "milestones")));
+}
+
+function resolveGitWorkingTreeRoot(path: string): string | null {
+  try {
+    let dir = existsSync(path) && !statSync(path).isDirectory()
+      ? resolve(path, "..")
+      : path;
+    const externalStateParent = normalizeWorktreePathForCompare(resolve(gsdHome(), ".."));
+
+    for (let i = 0; i < 30; i++) {
+      if (normalizeWorktreePathForCompare(dir) === externalStateParent) return null;
+      const gitPath = join(dir, ".git");
+      if (existsSync(gitPath)) return dir;
+
+      const parent = resolve(dir, "..");
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    // Non-fatal: callers either keep the original path or fail closed.
+  }
+  return null;
+}
+
+function resolveProjectRootFromGitFile(worktreePath: string): string | null {
+  try {
+    let dir = worktreePath;
+    for (let i = 0; i < 30; i++) {
+      const gitPath = join(dir, ".git");
+      if (existsSync(gitPath)) {
+        const content = readFileSync(gitPath, "utf8").trim();
+        if (content.startsWith("gitdir: ")) {
+          const gitDir = resolve(dir, content.slice(8));
+          const dotGitDir = resolve(gitDir, "..", "..");
+          if (dotGitDir.endsWith(".git") || dotGitDir.endsWith(".git/") || dotGitDir.endsWith(".git\\")) {
+            return resolve(dotGitDir, "..");
+          }
+
+          const commonDirPath = join(gitDir, "commondir");
+          if (existsSync(commonDirPath)) {
+            const commonDir = readFileSync(commonDirPath, "utf8").trim();
+            const resolvedCommonDir = resolve(gitDir, commonDir);
+            return resolve(resolvedCommonDir, "..");
+          }
+        }
+        break;
+      }
+
+      const parent = resolve(dir, "..");
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    // Non-fatal: callers either keep the original path or fail closed.
+  }
+  return null;
+}

package/src/resources/extensions/gsd/worktree-session-state.ts

@@ -0,0 +1,35 @@
+// GSD worktree session state
+let originalCwd: string | null = null;
+
+export function getWorktreeOriginalCwd(): string | null {
+  return originalCwd;
+}
+
+export function setWorktreeOriginalCwd(cwd: string): void {
+  originalCwd = cwd;
+}
+
+export function clearWorktreeOriginalCwd(): void {
+  originalCwd = null;
+}
+
+export function ensureWorktreeOriginalCwdFromPath(cwd: string = process.cwd()): string | null {
+  if (originalCwd) return originalCwd;
+  const marker = `${/\\/.test(cwd) ? "\\" : "/"}.gsd${/\\/.test(cwd) ? "\\" : "/"}worktrees${/\\/.test(cwd) ? "\\" : "/"}`;
+  const markerIdx = cwd.indexOf(marker);
+  if (markerIdx !== -1) {
+    originalCwd = cwd.slice(0, markerIdx);
+  }
+  return originalCwd;
+}
+
+export function getActiveWorktreeName(): string | null {
+  if (!originalCwd) return null;
+  const cwd = process.cwd();
+  const wtDir = `${originalCwd.replace(/[\\/]+$/, "")}/.gsd/worktrees`.replaceAll("\\", "/");
+  const normalizedCwd = cwd.replaceAll("\\", "/");
+  if (!normalizedCwd.startsWith(`${wtDir}/`)) return null;
+  const rel = normalizedCwd.slice(wtDir.length + 1);
+  const name = rel.split("/")[0];
+  return name || null;
+}

package/src/resources/extensions/gsd/worktree.ts

@@ -12,12 +12,16 @@
  * SLICE_BRANCH_RE) remain for backwards compatibility with legacy branches.
  */
 
-import { existsSync, readFileSync, realpathSync, utimesSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-import { homedir } from "node:os";
+import { existsSync, readFileSync, utimesSync } from "node:fs";
+import { join, resolve } from "node:path";
 
 import { GitServiceImpl, writeIntegrationBranch, type TaskCommitContext } from "./git-service.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import {
+  findWorktreeSegment,
+  resolveWorktreeProjectRoot,
+} from "./worktree-root.js";
+export { resolveWorktreeProjectRoot } from "./worktree-root.js";
 
 export { MergeConflictError } from "./git-service.js";
 export type { TaskCommitContext } from "./git-service.js";
@@ -78,29 +82,6 @@ export function captureIntegrationBranch(basePath: string, milestoneId: string):
 
 // ─── Pure Utility Functions (unchanged) ────────────────────────────────────
 
-/**
- * Find the worktrees segment in a path, supporting both direct
- * (`/.gsd/worktrees/`) and symlink-resolved (`/.gsd/projects/<hash>/worktrees/`)
- * layouts.  When `.gsd` is a symlink to `~/.gsd/projects/<hash>`, resolved
- * paths contain the intermediate `projects/<hash>/` segment that the old
- * single-marker check missed.
- */
-function findWorktreeSegment(normalizedPath: string): { gsdIdx: number; afterWorktrees: number } | null {
-  // Direct layout: /.gsd/worktrees/<name>
-  const directMarker = "/.gsd/worktrees/";
-  const idx = normalizedPath.indexOf(directMarker);
-  if (idx !== -1) {
-    return { gsdIdx: idx, afterWorktrees: idx + directMarker.length };
-  }
-  // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/<name>
-  const symlinkRe = /\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//;
-  const match = normalizedPath.match(symlinkRe);
-  if (match && match.index !== undefined) {
-    return { gsdIdx: match.index, afterWorktrees: match.index + match[0].length };
-  }
-  return null;
-}
-
 /**
  * Detect the active worktree name from the current working directory.
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
@@ -133,99 +114,7 @@ export function detectWorktreeName(basePath: string): string | null {
  * operate against the real project root, not a worktree subdirectory.
  */
 export function resolveProjectRoot(basePath: string): string {
-  // Layer 1: If the coordinator passed the real project root, use it.
-  if (process.env.GSD_PROJECT_ROOT) {
-    return process.env.GSD_PROJECT_ROOT;
-  }
-
-  const normalizedPath = basePath.replaceAll("\\", "/");
-  const seg = findWorktreeSegment(normalizedPath);
-  if (!seg) return basePath;
-
-  // Candidate root via the string-slice heuristic
-  const sepChar = basePath.includes("\\") ? "\\" : "/";
-  const gsdMarker = `${sepChar}.gsd${sepChar}`;
-  const gsdIdx = basePath.indexOf(gsdMarker);
-  const candidate = gsdIdx !== -1
-    ? basePath.slice(0, gsdIdx)
-    : basePath.slice(0, seg.gsdIdx);
-
-  // Layer 2: Guard against resolving to the user's home directory.
-  // When .gsd is a symlink into ~/.gsd/projects/<hash>, the resolved path
-  // contains /.gsd/ at the user-level boundary. Slicing there yields ~ — wrong.
-  const gsdHome = normalizePathForCompare(process.env.GSD_HOME || join(homedir(), ".gsd"));
-  const candidateGsdPath = normalizePathForCompare(join(candidate, ".gsd"));
-
-  if (candidateGsdPath === gsdHome || candidateGsdPath.startsWith(gsdHome + "/")) {
-    // The candidate is the home directory (or within it in a way that .gsd
-    // maps to the user-level GSD dir). Try to recover the real project root
-    // from the worktree's .git file.
-    const realRoot = resolveProjectRootFromGitFile(basePath);
-    if (realRoot) return realRoot;
-    // If git file resolution failed, return basePath unchanged rather than ~
-    return basePath;
-  }
-
-  return candidate;
-}
-
-/**
- * Recover the real project root from a worktree's .git file.
- *
- * Each git worktree has a `.git` file (not directory) containing:
- *   gitdir: /real/project/.git/worktrees/<name>
- *
- * Walking up from that gitdir gives us `/real/project/.git`, and its
- * parent is the real project root.
- */
-function resolveProjectRootFromGitFile(worktreePath: string): string | null {
-  try {
-    // Walk up from the worktree path to find the .git file
-    let dir = worktreePath;
-    for (let i = 0; i < 30; i++) {
-      const gitPath = join(dir, ".git");
-      if (existsSync(gitPath)) {
-        const content = readFileSync(gitPath, "utf8").trim();
-        if (content.startsWith("gitdir: ")) {
-          // gitdir points to: <real-project>/.git/worktrees/<name>
-          const gitDir = resolve(dir, content.slice(8));
-          // Walk up: .git/worktrees/<name> → .git/worktrees → .git → project root
-          const dotGitDir = resolve(gitDir, "..", "..");
-          // Verify this looks like a .git directory
-          if (dotGitDir.endsWith(".git") || dotGitDir.endsWith(".git/") || dotGitDir.endsWith(".git\\")) {
-            return resolve(dotGitDir, "..");
-          }
-          // Alternative: the commondir file inside the worktree gitdir
-          // points to the main .git directory
-          const commonDirPath = join(gitDir, "commondir");
-          if (existsSync(commonDirPath)) {
-            const commonDir = readFileSync(commonDirPath, "utf8").trim();
-            const resolvedCommonDir = resolve(gitDir, commonDir);
-            return resolve(resolvedCommonDir, "..");
-          }
-        }
-        break;
-      }
-      const parent = resolve(dir, "..");
-      if (parent === dir) break;
-      dir = parent;
-    }
-  } catch {
-    // Non-fatal — caller will use fallback
-  }
-  return null;
-}
-
-function normalizePathForCompare(path: string): string {
-  let normalized: string;
-  try {
-    normalized = realpathSync(path);
-  } catch {
-    normalized = resolve(path);
-  }
-  const slashed = normalized.replaceAll("\\", "/");
-  const trimmed = slashed.replace(/\/+$/, "");
-  return trimmed || "/";
+  return resolveWorktreeProjectRoot(basePath);
 }
 
 /**

package/src/resources/extensions/gsd/write-intercept.ts

@@ -91,9 +91,9 @@ function matchesBlockedPattern(path: string): boolean {
  * Directs the agent to use engine tool calls instead.
  */
 export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md and .gsd/gsd.db are blocked. Use engine tool calls instead:
-- To complete a task: call gsd_complete_task(milestone_id, slice_id, task_id, summary)
-- To complete a slice: call gsd_complete_slice(milestone_id, slice_id, summary, uat_result)
-- To save a decision: call gsd_save_decision(scope, decision, choice, rationale)
+- To complete a task: call gsd_task_complete(milestone_id, slice_id, task_id, summary)
+- To complete a slice: call gsd_slice_complete(milestone_id, slice_id, summary, uat_result)
+- To save a decision: call gsd_decision_save(scope, decision, choice, rationale)
 - To start a task: call gsd_start_task(milestone_id, slice_id, task_id)
 - To record verification: call gsd_record_verification(milestone_id, slice_id, task_id, evidence)
 - To report a blocker: call gsd_report_blocker(milestone_id, slice_id, task_id, description)`;

package/src/resources/extensions/mcp-client/index.ts

@@ -2,7 +2,8 @@
  * MCP Client Extension — Native MCP server integration for pi
  *
  * Provides on-demand access to MCP servers configured in project files
- * (.mcp.json, .gsd/mcp.json) using the @modelcontextprotocol/sdk Client
+ * (.mcp.json, .gsd/mcp.json) and the global ~/.gsd/mcp.json (or
+ * $GSD_HOME/mcp.json) using the @modelcontextprotocol/sdk Client
  * directly — no external CLI dependency required.
  *
  * Three tools:
@@ -27,6 +28,7 @@ import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { buildHttpTransportOpts } from "./auth.js";
 import type { McpHttpAuthConfig } from "./auth.js";
+import { gsdHome } from "../gsd/gsd-home.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -102,6 +104,7 @@ function readConfigs(): McpServerConfig[] {
 	const configPaths = [
 		join(process.cwd(), ".mcp.json"),
 		join(process.cwd(), ".gsd", "mcp.json"),
+		join(gsdHome(), "mcp.json"),
 	];
 
 	for (const configPath of configPaths) {
@@ -321,7 +324,7 @@ async function closeAll(): Promise<void> {
 // ─── Formatters ───────────────────────────────────────────────────────────────
 
 function formatServerList(servers: McpServerConfig[]): string {
-	if (servers.length === 0) return "No MCP servers configured. Add servers to .mcp.json or .gsd/mcp.json.";
+	if (servers.length === 0) return "No MCP servers configured. Add servers to .mcp.json, .gsd/mcp.json, or $GSD_HOME/mcp.json (default: ~/.gsd/mcp.json).";
 
 	const lines: string[] = [`${servers.length} MCP servers configured:\n`];
 
@@ -384,7 +387,7 @@ export default function (pi: ExtensionAPI) {
 		name: "mcp_servers",
 		label: "MCP Servers",
 		description:
-			"List all available MCP servers configured in project files (.mcp.json, .gsd/mcp.json). " +
+			"List all available MCP servers configured in project files (.mcp.json, .gsd/mcp.json) or globally ($GSD_HOME/mcp.json, default: ~/.gsd/mcp.json). " +
 			"Shows server names, transport type, and connection status. Use mcp_discover to get full tool schemas for a server.",
 		promptSnippet:
 			"List available MCP servers from project configuration",
@@ -624,13 +627,6 @@ export default function (pi: ExtensionAPI) {
 
 	// ── Lifecycle ─────────────────────────────────────────────────────────────
 
-	pi.on("session_start", async (_event, ctx) => {
-		const servers = readConfigs();
-		if (servers.length > 0) {
-			ctx.ui.notify(`MCP client ready — ${servers.length} server(s) configured`, "info");
-		}
-	});
-
 	pi.on("session_shutdown", async () => {
 		await closeAll();
 	});

package/src/resources/extensions/mcp-client/tests/global-config.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Regression test for #4757 — readConfigs() must also read the global
+ * ~/.gsd/mcp.json (resolved as $GSD_HOME/mcp.json when GSD_HOME is set).
+ *
+ * Behaviour test against the exported getServerConfig — no source grep.
+ * The fixture is anchored via $GSD_HOME so the test never touches the
+ * developer's real ~/.gsd directory.
+ */
+
+import test, { before, after } from "node:test";
+import assert from "node:assert/strict";
+import { writeFileSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { getServerConfig } from "../index.js";
+
+let cwdDir: string;
+let gsdHomeDir: string;
+let originalCwd: string;
+let originalGsdHome: string | undefined;
+
+before(() => {
+	originalCwd = process.cwd();
+	originalGsdHome = process.env.GSD_HOME;
+
+	// realpathSync resolves any symlink in tmpdir() — on macOS /var → /private/var
+	// so process.cwd() after chdir matches what mkdtempSync returned.
+	cwdDir = realpathSync(mkdtempSync(join(tmpdir(), "mcp-cwd-")));
+	gsdHomeDir = realpathSync(mkdtempSync(join(tmpdir(), "mcp-gsdhome-")));
+
+	// Project-local fixture (also defines `shared-server` for the precedence test)
+	writeFileSync(
+		join(cwdDir, ".mcp.json"),
+		JSON.stringify({
+			mcpServers: {
+				"project-server": { command: "echo", args: ["proj"] },
+				"shared-server": { command: "echo", args: ["from-project"] },
+			},
+		}),
+		"utf-8",
+	);
+
+	// Global fixture rooted at $GSD_HOME (also defines `shared-server` to test
+	// that project-local takes precedence on name collision)
+	writeFileSync(
+		join(gsdHomeDir, "mcp.json"),
+		JSON.stringify({
+			mcpServers: {
+				"global-server": { command: "echo", args: ["glob"] },
+				"shared-server": { command: "echo", args: ["from-global"] },
+			},
+		}),
+		"utf-8",
+	);
+
+	process.chdir(cwdDir);
+	process.env.GSD_HOME = gsdHomeDir;
+});
+
+after(() => {
+	process.chdir(originalCwd);
+	if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+	else process.env.GSD_HOME = originalGsdHome;
+	try { rmSync(cwdDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+	try { rmSync(gsdHomeDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+});
+
+test("#4757: getServerConfig resolves servers declared in $GSD_HOME/mcp.json", () => {
+	const cfg = getServerConfig("global-server");
+	assert.ok(cfg, "server defined in $GSD_HOME/mcp.json must resolve");
+	assert.equal(cfg?.name, "global-server");
+	assert.equal(cfg?.sourcePath, join(gsdHomeDir, "mcp.json"));
+});
+
+test("#4757: project-local servers still resolve when global config exists", () => {
+	const cfg = getServerConfig("project-server");
+	assert.ok(cfg, "project-local server must continue to resolve");
+	assert.equal(cfg?.sourcePath, join(cwdDir, ".mcp.json"));
+});
+
+test("#4757: project-local config wins on server-name collision", () => {
+	const cfg = getServerConfig("shared-server");
+	assert.ok(cfg, "shared server must resolve");
+	assert.equal(
+		cfg?.sourcePath,
+		join(cwdDir, ".mcp.json"),
+		"project-local config must take precedence over $GSD_HOME on name collision",
+	);
+	assert.deepEqual(cfg?.args, ["from-project"]);
+});

package/src/resources/extensions/ollama/index.ts

@@ -119,17 +119,31 @@ export default function ollama(pi: ExtensionAPI) {
 		// In headless/auto mode, await the probe so the fallback resolver can
 		// see Ollama before the first LLM call (#3531 race condition).
 		// In interactive mode, keep it async for fast startup.
+		// Surface probe failures under GSD_DEBUG so users can diagnose silent
+		// "Ollama is missing from /model" reports without patching dist/. The
+		// probe still soft-fails (registration is best-effort) — we just stop
+		// dropping the error on the floor. See #4982.
+		const debugOllama = (where: string, error: unknown): void => {
+			if (process.env.GSD_DEBUG) {
+				const msg = error instanceof Error ? error.message : String(error);
+				process.stderr.write(`[ollama] ${where} probe failed: ${msg}\n`);
+			}
+		};
+
 		if (!ctx.hasUI) {
 			try {
 				await probeAndRegister(pi);
-			} catch { /* non-fatal */ }
+			} catch (error) {
+				debugOllama("headless", error);
+			}
 		} else {
 			probeAndRegister(pi)
 				.then((found) => {
 					ctx.ui.setStatus("ollama", found ? "Ollama" : undefined);
 				})
-				.catch(() => {
+				.catch((error) => {
 					ctx.ui.setStatus("ollama", undefined);
+					debugOllama("interactive", error);
 				});
 		}
 	});

package/src/resources/extensions/ollama/model-capabilities.ts

@@ -56,10 +56,44 @@ const KNOWN_MODELS: Array<[pattern: string, caps: ModelCapability]> = [
 	["llama2", { contextWindow: 4096, maxTokens: 4096, ollamaOptions: { num_ctx: 4096 } }],
 
 	// ─── Qwen family ────────────────────────────────────────────────────
+	// Long-variant entries MUST appear before the bare `qwen3` base —
+	// `baseName.startsWith(pattern)` returns true for `qwen3.5`/`qwen3-coder`/
+	// `qwen3-next` against `qwen3`, and the first match wins (#4991).
+	// ref: qwen3-next 1M ctx — https://qwen.ai/blog?id=qwen3-next
+	["qwen3-next", { contextWindow: 1048576, maxTokens: 32768, ollamaOptions: { num_ctx: 1048576 } }],
+	// ref: qwen3-coder 256K ctx — https://qwenlm.github.io/blog/qwen3-coder/
+	["qwen3-coder", { contextWindow: 262144, maxTokens: 32768, ollamaOptions: { num_ctx: 262144 } }],
+	// ref: qwen3.5 / qwen3.6 1M ctx — Ollama Cloud release notes
+	["qwen3.6", { contextWindow: 1048576, maxTokens: 32768, ollamaOptions: { num_ctx: 1048576 } }],
+	["qwen3.5", { contextWindow: 1048576, maxTokens: 32768, ollamaOptions: { num_ctx: 1048576 } }],
 	["qwen3", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
 	["qwen2.5", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
 	["qwen2", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
 
+	// ─── GLM family (Z.ai, Ollama Cloud) ────────────────────────────────
+	// ref: glm 4.6 / 5.x 200K ctx — https://docs.z.ai/devpack/using5.1
+	// Long-variant entries before bare `glm-5` / `glm-4` would-be bases to
+	// avoid prefix shadowing (#4991).
+	["glm-5.1", { contextWindow: 204800, maxTokens: 16384, ollamaOptions: { num_ctx: 204800 } }],
+	["glm-5", { contextWindow: 204800, maxTokens: 16384, ollamaOptions: { num_ctx: 204800 } }],
+	["glm-4.6", { contextWindow: 204800, maxTokens: 16384, ollamaOptions: { num_ctx: 204800 } }],
+	["glm-4", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+
+	// ─── Kimi K2 (Moonshot, Ollama Cloud) ──────────────────────────────
+	// ref: kimi-k2 256K ctx — https://platform.moonshot.ai/docs
+	// Same shadowing concern: kimi-k2-thinking and kimi-k2.{5,6} must
+	// match before any future bare `kimi-k2` entry (#4991).
+	["kimi-k2-thinking", { contextWindow: 262144, maxTokens: 16384, ollamaOptions: { num_ctx: 262144 } }],
+	["kimi-k2.6", { contextWindow: 262144, maxTokens: 16384, ollamaOptions: { num_ctx: 262144 } }],
+	["kimi-k2.5", { contextWindow: 262144, maxTokens: 16384, ollamaOptions: { num_ctx: 262144 } }],
+	["kimi-k2", { contextWindow: 262144, maxTokens: 16384, ollamaOptions: { num_ctx: 262144 } }],
+
+	// ─── MiniMax M2 (Ollama Cloud) ─────────────────────────────────────
+	// ref: minimax-m2 1M ctx — https://www.minimax.io/news/minimax-m2
+	["minimax-m2.7", { contextWindow: 1048576, maxTokens: 16384, ollamaOptions: { num_ctx: 1048576 } }],
+	["minimax-m2.5", { contextWindow: 1048576, maxTokens: 16384, ollamaOptions: { num_ctx: 1048576 } }],
+	["minimax-m2", { contextWindow: 1048576, maxTokens: 16384, ollamaOptions: { num_ctx: 1048576 } }],
+
 	// ─── Gemma family ───────────────────────────────────────────────────
 	["gemma3", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
 	["gemma2", { contextWindow: 8192, maxTokens: 8192, ollamaOptions: { num_ctx: 8192 } }],

package/src/resources/extensions/ollama/ollama-client.ts

@@ -19,8 +19,45 @@ import type {
 import { parseNDJsonStream } from "./ndjson-stream.js";
 
 const DEFAULT_HOST = "http://localhost:11434";
-const PROBE_TIMEOUT_MS = 1500;
-const REQUEST_TIMEOUT_MS = 10000;
+const DEFAULT_PROBE_TIMEOUT_MS = 1500;
+const DEFAULT_REQUEST_TIMEOUT_MS = 10000;
+export const MAX_TIMER_DELAY_MS = 2_147_483_647;
+
+/**
+ * Parse a positive integer from an environment variable, falling back to
+ * `fallback` when the var is unset, empty, non-numeric, zero, or negative.
+ *
+ * Defensive parsing: a typo like `OLLAMA_PROBE_TIMEOUT_MS=abc` or
+ * `OLLAMA_PROBE_TIMEOUT_MS=0` should not silently disable the timeout —
+ * fall back to the documented default instead.
+ */
+export function envPositiveInt(name: string, fallback: number): number {
+	const raw = process.env[name];
+	if (!raw) return fallback;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return Math.min(parsed, MAX_TIMER_DELAY_MS);
+}
+
+/**
+ * Effective probe timeout for the startup `isRunning()` health check.
+ * Override with `OLLAMA_PROBE_TIMEOUT_MS=<ms>` for slower networks (LAN
+ * Ollama hosts, cloud endpoints, contended cold starts).
+ *
+ * Resolved at call time — tests and downstream callers can mutate
+ * `process.env` between invocations and pick up the new value.
+ */
+export function getProbeTimeoutMs(): number {
+	return envPositiveInt("OLLAMA_PROBE_TIMEOUT_MS", DEFAULT_PROBE_TIMEOUT_MS);
+}
+
+/**
+ * Effective per-request timeout for REST calls. Override with
+ * `OLLAMA_REQUEST_TIMEOUT_MS=<ms>`.
+ */
+export function getRequestTimeoutMs(): number {
+	return envPositiveInt("OLLAMA_REQUEST_TIMEOUT_MS", DEFAULT_REQUEST_TIMEOUT_MS);
+}
 
 /**
  * Get the Ollama host URL from OLLAMA_HOST or default.
@@ -57,7 +94,7 @@ function withAuth(options: RequestInit = {}): RequestInit {
 	};
 }
 
-async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = REQUEST_TIMEOUT_MS): Promise<Response> {
+async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = getRequestTimeoutMs()): Promise<Response> {
 	const controller = new AbortController();
 	const timeout = setTimeout(() => controller.abort(), timeoutMs);
 	try {
@@ -77,7 +114,7 @@ export async function isRunning(): Promise<boolean> {
 		const host = getOllamaHost();
 		const isCloud = host.includes("ollama.com") || host.includes("cloud");
 		const probeUrl = isCloud ? `${host}/api/tags` : `${host}/`;
-		const timeout = isCloud ? REQUEST_TIMEOUT_MS : PROBE_TIMEOUT_MS;
+		const timeout = isCloud ? getRequestTimeoutMs() : getProbeTimeoutMs();
 		const response = await fetchWithTimeout(probeUrl, isCloud ? { method: "GET" } : {}, timeout);
 		return response.ok;
 	} catch {