gsd-pi 2.77.0-dev.58d3d4d6c → 2.77.0-dev.cfd69e714

package/src/resources/extensions/gsd/workflow-mcp.ts

@@ -33,6 +33,7 @@ const MCP_WORKFLOW_TOOL_SURFACE = new Set([
   "gsd_journal_query",
   "gsd_milestone_complete",
   "gsd_milestone_generate_id",
+  "gsd_milestone_reopen",
   "gsd_checkpoint_db",
   "gsd_milestone_status",
   "gsd_milestone_validate",
@@ -41,6 +42,9 @@ const MCP_WORKFLOW_TOOL_SURFACE = new Set([
   "gsd_plan_slice",
   "gsd_replan_slice",
   "gsd_reassess_roadmap",
+  "gsd_reopen_milestone",
+  "gsd_reopen_slice",
+  "gsd_reopen_task",
   "gsd_requirement_save",
   "gsd_requirement_update",
   "gsd_roadmap_reassess",
@@ -50,9 +54,11 @@ const MCP_WORKFLOW_TOOL_SURFACE = new Set([
   "gsd_skip_slice",
   "gsd_slice_replan",
   "gsd_slice_complete",
+  "gsd_slice_reopen",
   "gsd_summary_save",
   "gsd_task_plan",
   "gsd_task_complete",
+  "gsd_task_reopen",
   "gsd_update_requirement",
   "gsd_validate_milestone",
 ]);

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

@@ -30,6 +30,7 @@ import {
   nativeDiffNameStatus,
   nativeDiffNumstat,
   nativeGetCurrentBranch,
+  nativeIsAncestor,
   nativeLogOneline,
   nativeMergeSquash,
   nativeWorktreeAdd,
@@ -227,6 +228,17 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
   // otherwise fall back to the repo's detected main branch.
   const startPoint = opts.startPoint ?? nativeDetectMainBranch(basePath);
 
+  // Reject early if startPoint resolves to an empty/invalid ref. On an
+  // unborn branch (zero-commit repo) nativeDetectMainBranch returns "",
+  // which would flow into `git worktree add ... ""` and crash with
+  // `fatal: not a valid object name`. (Issue #4980 HIGH-9)
+  if (!startPoint || startPoint.length === 0) {
+    throw new GSDError(
+      GSD_GIT_ERROR,
+      "Repository has no commits yet (unborn branch). Make an initial commit before creating worktrees.",
+    );
+  }
+
   // Check if the branch already exists (leftover from a previous worktree)
   const branchAlreadyExists = nativeBranchExists(basePath, branch);
 
@@ -249,6 +261,21 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
       // from prior sessions that must not be reset.
       nativeWorktreeAdd(basePath, wtPath, branch);
     } else {
+      // Ancestry guard: refuse to force-reset a branch that has commits not
+      // reachable from startPoint. A crash-then-resume cycle that didn't
+      // write the resume file would silently orphan prior-session commits
+      // (recoverable from reflog for 90d, then gone — branch is also
+      // deleted at teardown). (Issue #4980 HIGH-3)
+      const branchIsAncestor = nativeIsAncestor(basePath, branch, startPoint);
+      if (!branchIsAncestor) {
+        throw new GSDError(
+          GSD_GIT_ERROR,
+          `Branch "${branch}" already exists with commits not reachable from "${startPoint}". ` +
+          `Refusing to force-reset — would orphan prior work. ` +
+          `If you intend to keep those commits, retry with reuseExistingBranch=true. ` +
+          `If you intend to discard, run \`git branch -D ${branch}\` manually first.`,
+        );
+      }
       // Reset the stale branch to the start point, then attach worktree to it
       nativeBranchForceReset(basePath, branch, startPoint);
       nativeWorktreeAdd(basePath, wtPath, branch);
@@ -504,17 +531,38 @@ export function removeWorktree(
         (line: string) => line.startsWith("+") || line.startsWith("-"),
       );
       if (hasSubmoduleChanges) {
-        // Stash submodule changes so they are not lost during force removal.
-        // The stash is created in the worktree before it's torn down.
+        // Save submodule changes to a labeled rescue branch instead of the
+        // shared stash list. Stash is per-repo (not per-worktree), so an
+        // entry created here would appear in the user's main-tree stash
+        // list and reference paths that disappear after worktree removal.
+        // A branch persists in the shared .git refs after worktree removal
+        // and is discoverable via `git branch --list 'gsd/submodule-rescue/*'`.
+        // (Issue #4980 HIGH-11)
+        const rescueBranch = `gsd/submodule-rescue/${name}-${Date.now()}`;
         try {
           execFileSync(
-            "git", ["stash", "push", "-m", "gsd: auto-stash submodule changes before worktree teardown"],
+            "git", ["add", "-A"],
             { cwd: resolvedWtPath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" },
           );
-          logWarning("reconcile", `Stashed uncommitted submodule changes before worktree teardown`, { worktree: name, path: resolvedWtPath });
-        } catch {
-          // Stash failed — warn the user that submodule changes may be lost
-          logWarning("reconcile", `Submodule changes detected — stash failed, changes may be lost during force removal`, { worktree: name, path: resolvedWtPath });
+          execFileSync(
+            "git", ["commit", "-m", `gsd: rescue submodule changes from worktree ${name}`, "--allow-empty"],
+            { cwd: resolvedWtPath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" },
+          );
+          execFileSync(
+            "git", ["branch", rescueBranch, "HEAD"],
+            { cwd: resolvedWtPath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" },
+          );
+          logWarning(
+            "reconcile",
+            `Saved uncommitted submodule changes to rescue branch ${rescueBranch}`,
+            { worktree: name, path: resolvedWtPath, rescueBranch },
+          );
+        } catch (err) {
+          logWarning(
+            "reconcile",
+            `Submodule rescue branch creation failed — changes may be lost during force removal: ${err instanceof Error ? err.message : String(err)}`,
+            { worktree: name, path: resolvedWtPath },
+          );
         }
       }
     } catch (e) {

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

@@ -203,7 +203,9 @@ async function assertTrustedStdioServer(
 	return trustKey;
 }
 
-function getServerConfig(name: string): McpServerConfig | undefined {
+// Exported for tests (see tests/server-name-spaces.test.ts).
+// Production call sites treat this as module-private.
+export function getServerConfig(name: string): McpServerConfig | undefined {
 	const trimmed = name.trim();
 	return readConfigs().find((s) =>
 		s.name === trimmed ||

package/src/resources/extensions/mcp-client/tests/server-name-spaces.test.ts

@@ -1,55 +1,89 @@
 /**
  * Regression test for #3029 — mcp_discover fails for server names with spaces.
  *
- * The getServerConfig lookup must handle:
- *   1. Exact match (already works)
+ * getServerConfig must handle:
+ *   1. Exact match
  *   2. Names with leading/trailing whitespace (trimming)
  *   3. Case-insensitive matching (e.g. "Langgraph code" vs "langgraph Code")
  *
- * We test at the source level since getServerConfig is not exported.
+ * getOrConnect must use the canonical (config.name) as the cache key so that
+ * subsequent lookups with variant casing/whitespace hit the same connection.
+ *
+ * These are behaviour tests against the real exported getServerConfig — no
+ * source grep.
  */
 
-import test from "node:test";
+import test, { before, after } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { writeFileSync, unlinkSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+import { getServerConfig } from "../index.js";
+
+// readConfigs() anchors to process.cwd() — run each test in a sandbox dir
+// with a purpose-built .mcp.json so the extension reads our fixture, not
+// whatever .mcp.json happens to live in the current working directory.
+let sandboxDir: string;
+let originalCwd: string;
+
+before(() => {
+	originalCwd = process.cwd();
+	sandboxDir = mkdtempSync(join(tmpdir(), "mcp-name-spaces-"));
+	const mcpConfig = {
+		mcpServers: {
+			"Langgraph Code": {
+				command: "echo",
+				args: ["test"],
+			},
+			"other-server": {
+				url: "https://example.com",
+			},
+		},
+	};
+	writeFileSync(join(sandboxDir, ".mcp.json"), JSON.stringify(mcpConfig), "utf-8");
+	process.chdir(sandboxDir);
+});
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+after(() => {
+	process.chdir(originalCwd);
+	try {
+		rmSync(sandboxDir, { recursive: true, force: true });
+	} catch {
+		// Best-effort cleanup
+	}
+});
 
-const source = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
+test("#3029: getServerConfig finds exact match", () => {
+	const cfg = getServerConfig("Langgraph Code");
+	assert.ok(cfg, "exact name must resolve");
+	assert.equal(cfg?.name, "Langgraph Code");
+});
 
 test("#3029: getServerConfig trims whitespace from input name", () => {
-	assert.ok(
-		source.includes(".trim()"),
-		"getServerConfig should trim the input name before comparison",
-	);
+	const cfg = getServerConfig("   Langgraph Code  ");
+	assert.ok(cfg, "whitespace-padded name must resolve to the same server");
+	assert.equal(cfg?.name, "Langgraph Code");
 });
 
 test("#3029: getServerConfig performs case-insensitive matching", () => {
-	assert.ok(
-		source.includes(".toLowerCase()"),
-		"getServerConfig should compare names case-insensitively",
-	);
+	const cfg = getServerConfig("langgraph code");
+	assert.ok(cfg, "lower-cased name must resolve");
+	assert.equal(cfg?.name, "Langgraph Code");
+
+	const mixed = getServerConfig("LANGGRAPH CODE");
+	assert.ok(mixed, "upper-cased name must resolve");
+	assert.equal(mixed?.name, "Langgraph Code");
+});
+
+test("#3029: getServerConfig combines trim + case-insensitive", () => {
+	const cfg = getServerConfig("  LANGGRAPH code  ");
+	assert.ok(cfg, "padded + mixed-case must resolve");
+	assert.equal(cfg?.name, "Langgraph Code");
 });
 
-test("#3029: getOrConnect normalizes name for connection cache lookup", () => {
-	// The connections Map key must use the canonical (config) name, not the
-	// raw user input, so that subsequent lookups hit the cache even when the
-	// user's casing differs.
-	const getOrConnectMatch = source.match(
-		/async function getOrConnect\(name: string[\s\S]*?const existing = connections\.get\(/,
-	);
-	assert.ok(
-		getOrConnectMatch,
-		"getOrConnect function should exist",
-	);
-	// After the fix, getOrConnect should normalize the name via getServerConfig
-	// or use config.name as the canonical cache key.
-	assert.ok(
-		source.includes("connections.get(config.name") ||
-		source.includes("connections.set(config.name"),
-		"getOrConnect should use config.name (canonical) as the connections cache key",
-	);
+test("#3029: getServerConfig returns undefined for unknown name", () => {
+	const cfg = getServerConfig("does-not-exist");
+	assert.equal(cfg, undefined);
 });

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

@@ -45,8 +45,12 @@ let providerRegistered = false;
 /**
  * Probe Ollama and register discovered models.
  * Safe to call multiple times — re-discovers and re-registers.
+ *
+ * Exported for tests (see ollama-auth-mode.test.ts, ollama-status-indicator.test.ts)
+ * so a fake HTTP endpoint can drive the registration/unregistration paths.
+ * Production callers always go through the session_start handler below.
  */
-async function probeAndRegister(pi: ExtensionAPI): Promise<boolean> {
+export async function probeAndRegister(pi: ExtensionAPI): Promise<boolean> {
 	const running = await client.isRunning();
 	if (!running) {
 		if (providerRegistered) {

package/src/resources/extensions/ollama/ollama-auth-mode.test.ts

@@ -1,20 +1,128 @@
 /**
  * Regression test for #3440: Ollama extension must register with
- * authMode "apiKey" (not "none") to avoid streamSimple requirement.
+ * authMode "apiKey" (not "none"), otherwise the core bails out because
+ * the provider has no streamSimple.
+ *
+ * Behaviour test: spin up a fake Ollama endpoint, point OLLAMA_HOST at
+ * it, and invoke probeAndRegister with a mock pi. Assert that
+ * registerProvider was called with authMode "apiKey".
  */
-import { test } from "node:test";
+import { test, before, after, beforeEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-test("Ollama registers with authMode apiKey, not none (#3440)", () => {
-  const src = readFileSync(join(__dirname, "index.ts"), "utf-8");
-  // Find the registerProvider call
-  const registerBlock = src.slice(src.indexOf("pi.registerProvider(\"ollama\""));
-  const authLine = registerBlock.match(/authMode:\s*"(\w+)"/);
-  assert.ok(authLine, "registerProvider must specify authMode");
-  assert.equal(authLine![1], "apiKey", "authMode must be apiKey, not none");
+import { createServer, type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+
+import { probeAndRegister } from "./index.js";
+
+type RegisterCall = [string, Record<string, unknown>];
+
+function makeMockPi() {
+	const calls: { registerProvider: RegisterCall[]; unregisterProvider: string[] } = {
+		registerProvider: [],
+		unregisterProvider: [],
+	};
+	const pi = {
+		registerProvider(id: string, spec: Record<string, unknown>) {
+			calls.registerProvider.push([id, spec]);
+		},
+		unregisterProvider(id: string) {
+			calls.unregisterProvider.push(id);
+		},
+	} as unknown as Parameters<typeof probeAndRegister>[0];
+	return { pi, calls };
+}
+
+let server: Server;
+let savedHost: string | undefined;
+
+before(async () => {
+	// Fake Ollama endpoint that:
+	//   GET /          → 200 (isRunning probe)
+	//   GET /api/tags  → one model
+	//   POST /api/show → minimal capability info
+	server = createServer((req, res) => {
+		if (req.method === "GET" && req.url === "/") {
+			res.writeHead(200, { "Content-Type": "text/plain" });
+			res.end("Ollama is running");
+			return;
+		}
+		if (req.method === "GET" && req.url === "/api/tags") {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(
+				JSON.stringify({
+					models: [
+						{
+							name: "llama3:latest",
+							modified_at: new Date().toISOString(),
+							size: 1_000_000,
+							digest: "abc",
+							details: {
+								parent_model: "",
+								format: "gguf",
+								family: "llama",
+								families: ["llama"],
+								parameter_size: "8B",
+								quantization_level: "Q4_0",
+							},
+						},
+					],
+				}),
+			);
+			return;
+		}
+		if (req.method === "POST" && req.url === "/api/show") {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(
+				JSON.stringify({
+					modelfile: "",
+					parameters: "",
+					template: "",
+					details: {
+						parent_model: "",
+						format: "gguf",
+						family: "llama",
+						families: ["llama"],
+						parameter_size: "8B",
+						quantization_level: "Q4_0",
+					},
+					model_info: { "llama.context_length": 8192 },
+					capabilities: [],
+				}),
+			);
+			return;
+		}
+		res.writeHead(404);
+		res.end();
+	});
+	await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+	const { port } = server.address() as AddressInfo;
+	savedHost = process.env.OLLAMA_HOST;
+	process.env.OLLAMA_HOST = `http://127.0.0.1:${port}`;
+});
+
+after(async () => {
+	await new Promise<void>((resolve) => server.close(() => resolve()));
+	if (savedHost === undefined) delete process.env.OLLAMA_HOST;
+	else process.env.OLLAMA_HOST = savedHost;
+});
+
+beforeEach(() => {
+	// Each test starts from a clean providerRegistered state in the module.
+	// probeAndRegister is idempotent — calling it is safe regardless.
+});
+
+test("Ollama registers with authMode apiKey, not none (#3440)", async () => {
+	const { pi, calls } = makeMockPi();
+
+	const found = await probeAndRegister(pi);
+	assert.equal(found, true, "probeAndRegister should return true when models are discovered");
+
+	assert.equal(calls.registerProvider.length, 1, "registerProvider should be called exactly once");
+	const [providerId, spec] = calls.registerProvider[0];
+	assert.equal(providerId, "ollama");
+	assert.equal(
+		spec.authMode,
+		"apiKey",
+		"authMode must be apiKey so the core doesn't require streamSimple for every model",
+	);
 });

package/src/resources/extensions/ollama/ollama-status-indicator.test.ts

@@ -1,28 +1,215 @@
 /**
  * Regression test: don't show an Ollama footer status unless Ollama is
  * actually usable (running with at least one discovered model).
+ *
+ * Behaviour tests:
+ *   1. probeAndRegister returns false when /api/tags returns no models
+ *      (running-without-models should not be treated as available).
+ *   2. The session_start handler calls ctx.ui.setStatus("ollama", "Ollama")
+ *      when probeAndRegister reports true, and setStatus("ollama", undefined)
+ *      when it reports false — keeping the footer clean on unavailable Ollama.
  */
-import { test } from "node:test";
+import { test, before, after } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const src = readFileSync(join(__dirname, "index.ts"), "utf-8");
-
-test("probeAndRegister returns false when no Ollama models are discovered", () => {
-	assert.match(
-		src,
-		/if \(models\.length === 0\)[\s\S]*return false;/,
-		"running-without-models should not be treated as available",
-	);
+import { createServer, type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+
+import ollamaExtension, { probeAndRegister } from "./index.js";
+
+type RegisterCall = [string, Record<string, unknown>];
+
+function makeMockPi() {
+	const calls: {
+		registerProvider: RegisterCall[];
+		unregisterProvider: string[];
+		registerTool: unknown[];
+		onHandlers: Map<string, Array<(...args: unknown[]) => unknown>>;
+	} = {
+		registerProvider: [],
+		unregisterProvider: [],
+		registerTool: [],
+		onHandlers: new Map(),
+	};
+	const pi = {
+		registerProvider(id: string, spec: Record<string, unknown>) {
+			calls.registerProvider.push([id, spec]);
+		},
+		unregisterProvider(id: string) {
+			calls.unregisterProvider.push(id);
+		},
+		registerTool(tool: unknown) {
+			calls.registerTool.push(tool);
+		},
+		registerCommand() {
+			/* no-op */
+		},
+		on(event: string, handler: (...args: unknown[]) => unknown) {
+			if (!calls.onHandlers.has(event)) calls.onHandlers.set(event, []);
+			calls.onHandlers.get(event)!.push(handler);
+		},
+	} as unknown as Parameters<typeof probeAndRegister>[0];
+	return { pi, calls };
+}
+
+// Server mode:
+//   "empty"  → /api/tags returns { models: [] }
+//   "loaded" → /api/tags returns one model + /api/show with 8k context
+let server: Server;
+let serverMode: "empty" | "loaded" = "empty";
+let savedHost: string | undefined;
+
+before(async () => {
+	server = createServer((req, res) => {
+		if (req.method === "GET" && req.url === "/") {
+			res.writeHead(200);
+			res.end("Ollama is running");
+			return;
+		}
+		if (req.method === "GET" && req.url === "/api/tags") {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			if (serverMode === "empty") {
+				res.end(JSON.stringify({ models: [] }));
+			} else {
+				res.end(
+					JSON.stringify({
+						models: [
+							{
+								name: "llama3:latest",
+								modified_at: new Date().toISOString(),
+								size: 1_000_000,
+								digest: "abc",
+								details: {
+									parent_model: "",
+									format: "gguf",
+									family: "llama",
+									families: ["llama"],
+									parameter_size: "8B",
+									quantization_level: "Q4_0",
+								},
+							},
+						],
+					}),
+				);
+			}
+			return;
+		}
+		if (req.method === "POST" && req.url === "/api/show") {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(
+				JSON.stringify({
+					modelfile: "",
+					parameters: "",
+					template: "",
+					details: {
+						parent_model: "",
+						format: "gguf",
+						family: "llama",
+						families: ["llama"],
+						parameter_size: "8B",
+						quantization_level: "Q4_0",
+					},
+					model_info: { "llama.context_length": 8192 },
+					capabilities: [],
+				}),
+			);
+			return;
+		}
+		res.writeHead(404);
+		res.end();
+	});
+	await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+	const { port } = server.address() as AddressInfo;
+	savedHost = process.env.OLLAMA_HOST;
+	process.env.OLLAMA_HOST = `http://127.0.0.1:${port}`;
+});
+
+after(async () => {
+	await new Promise<void>((resolve) => server.close(() => resolve()));
+	if (savedHost === undefined) delete process.env.OLLAMA_HOST;
+	else process.env.OLLAMA_HOST = savedHost;
 });
 
-test("interactive session clears ollama footer status when unavailable", () => {
-	assert.match(
-		src,
-		/ctx\.ui\.setStatus\("ollama", found \? "Ollama" : undefined\)/,
-		"status should be cleared when probeAndRegister reports unavailable",
+test("probeAndRegister returns false when no Ollama models are discovered", async () => {
+	serverMode = "empty";
+	const { pi, calls } = makeMockPi();
+	const found = await probeAndRegister(pi);
+	assert.equal(found, false, "no models should be reported as unavailable");
+	assert.equal(
+		calls.registerProvider.length,
+		0,
+		"provider must not be registered when no models are discoverable",
 	);
 });
+
+test("probeAndRegister returns true when Ollama has at least one model", async () => {
+	serverMode = "loaded";
+	const { pi, calls } = makeMockPi();
+	const found = await probeAndRegister(pi);
+	assert.equal(found, true);
+	assert.equal(calls.registerProvider.length, 1);
+});
+
+test("interactive session sets ollama status based on probeAndRegister result", async () => {
+	// Load case: status should be set to "Ollama".
+	{
+		serverMode = "loaded";
+		const { pi, calls } = makeMockPi();
+		ollamaExtension(pi);
+		const handlers = calls.onHandlers.get("session_start") ?? [];
+		assert.equal(handlers.length, 1, "extension registers one session_start handler");
+
+		const statusCalls: Array<[string, string | undefined]> = [];
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setStatus: (slot: string, value: string | undefined) => {
+					statusCalls.push([slot, value]);
+				},
+				notify: () => {},
+			},
+		};
+
+		// Fire session_start; wait a tick for the internal promise chain to resolve.
+		await handlers[0]({}, ctx);
+		// Give probeAndRegister + .then(setStatus) time to complete.
+		for (let i = 0; i < 50; i++) {
+			if (statusCalls.length > 0) break;
+			await new Promise((r) => setTimeout(r, 20));
+		}
+		assert.deepEqual(
+			statusCalls,
+			[["ollama", "Ollama"]],
+			"status should be set to 'Ollama' when probe reports available",
+		);
+	}
+
+	// Unavailable case: status should be cleared (undefined).
+	{
+		serverMode = "empty";
+		const { pi, calls } = makeMockPi();
+		ollamaExtension(pi);
+		const handlers = calls.onHandlers.get("session_start") ?? [];
+
+		const statusCalls: Array<[string, string | undefined]> = [];
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setStatus: (slot: string, value: string | undefined) => {
+					statusCalls.push([slot, value]);
+				},
+				notify: () => {},
+			},
+		};
+
+		await handlers[0]({}, ctx);
+		for (let i = 0; i < 50; i++) {
+			if (statusCalls.length > 0) break;
+			await new Promise((r) => setTimeout(r, 20));
+		}
+		assert.deepEqual(
+			statusCalls,
+			[["ollama", undefined]],
+			"status must be cleared (undefined) when probe reports unavailable",
+		);
+	}
+});