gsd-pi 2.77.0-dev.1d17f366c → 2.77.0-dev.2daa994b6

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

@@ -1,57 +1,133 @@
-import test, { describe } from "node:test";
+// Regression test for #4243 — abort() must be called BEFORE
+// _disconnectFromAgent() inside newSession() and switchSession() so that
+// message_end/agent_end events (and the #4216 finalization code) fire
+// before we unsubscribe from the event bus.
+//
+// Verified behaviourally: we construct a real AgentSession, wrap `abort`
+// and `_disconnectFromAgent` with call-order recording, trigger each
+// session-transition method, and assert the observed call order.
+
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+
+import { Agent } from "@gsd/pi-agent-core";
+import { AgentSession } from "./agent-session.js";
+import { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { SessionManager } from "./session-manager.js";
+import { SettingsManager } from "./settings-manager.js";
 
-const source = readFileSync(
-	join(process.cwd(), "packages/pi-coding-agent/src/core/agent-session.ts"),
-	"utf-8",
-);
+let testDir: string;
 
-describe("#4243 — abort() must be called before _disconnectFromAgent()", () => {
-	test("newSession() calls abort() before _disconnectFromAgent()", () => {
-		// Find the newSession method body where the fix was applied
-		const newSessionStart = source.indexOf("async newSession(options?:");
-		assert.ok(newSessionStart >= 0, "should find newSession method");
+async function createSession(opts: { persistSessions?: boolean } = {}): Promise<AgentSession> {
+	const agentDir = join(testDir, "agent-home");
+	const authStorage = AuthStorage.inMemory({});
+	const modelRegistry = new ModelRegistry(authStorage, join(agentDir, "models.json"));
+	const settingsManager = SettingsManager.inMemory();
+	const resourceLoader = new DefaultResourceLoader({
+		cwd: testDir,
+		agentDir,
+		settingsManager,
+		noExtensions: true,
+		noPromptTemplates: true,
+		noThemes: true,
+	});
+	await resourceLoader.reload();
 
-		// Get a window that includes the abort/disconnect section.
-		// Use 2000 chars to accommodate guard checks inserted between the two calls.
-		const window = source.slice(newSessionStart, newSessionStart + 2000);
+	// switchSession() needs a sessionFile; in-memory manager returns undefined.
+	// Use file-backed manager when the test needs to resume.
+	const sessionManager = opts.persistSessions
+		? SessionManager.create(testDir, join(testDir, "sessions"))
+		: SessionManager.inMemory(testDir);
+
+	return new AgentSession({
+		agent: new Agent(),
+		sessionManager,
+		settingsManager,
+		cwd: testDir,
+		resourceLoader,
+		modelRegistry,
+	});
+}
 
-		// Find the abort and _disconnectFromAgent calls
-		const abortIdx = window.indexOf("await this.abort();");
-		const disconnectIdx = window.indexOf("this._disconnectFromAgent();");
+/**
+ * Wrap two methods on the same object so their call order is recorded.
+ * Returns the recording array — assertions use index lookups.
+ */
+function recordCallOrder<O extends object>(
+	target: O,
+	methods: Array<keyof O>,
+): string[] {
+	const order: string[] = [];
+	for (const method of methods) {
+		const name = String(method);
+		const original = (target as any)[name] as (...args: unknown[]) => unknown;
+		if (typeof original !== "function") {
+			throw new Error(`recordCallOrder: ${name} is not a function on target`);
+		}
+		(target as any)[name] = function (this: O, ...args: unknown[]) {
+			order.push(name);
+			return original.apply(this, args);
+		};
+	}
+	return order;
+}
+
+describe("#4243 — abort() must run before _disconnectFromAgent()", () => {
+	beforeEach(() => {
+		testDir = mkdtempSync(join(tmpdir(), "agent-session-abort-"));
+	});
+
+	afterEach(() => {
+		rmSync(testDir, { recursive: true, force: true });
+	});
 
-		assert.ok(abortIdx >= 0, "newSession should call await this.abort()");
-		assert.ok(disconnectIdx >= 0, "newSession should call this._disconnectFromAgent()");
+	it("newSession() invokes abort() before _disconnectFromAgent()", async () => {
+		const session = await createSession();
+		const order = recordCallOrder(session as any, ["abort", "_disconnectFromAgent"]);
+
+		const ok = await session.newSession();
+		assert.equal(ok, true);
+
+		const abortIdx = order.indexOf("abort");
+		const disconnectIdx = order.indexOf("_disconnectFromAgent");
+		assert.ok(abortIdx >= 0, `newSession should call abort(); order=${order.join(",")}`);
+		assert.ok(
+			disconnectIdx >= 0,
+			`newSession should call _disconnectFromAgent(); order=${order.join(",")}`,
+		);
 		assert.ok(
 			abortIdx < disconnectIdx,
-			"abort() must be called BEFORE _disconnectFromAgent() so that message_end/agent_end events fire before unsubscribing from the event bus",
+			`abort() must run before _disconnectFromAgent(); order=${order.join(",")}`,
 		);
 	});
 
-	test("newSession() references #4243 in the abort/disconnect comment", () => {
-		const idx = source.indexOf("#4243");
-		assert.ok(idx >= 0, "source should reference issue #4243 for the abort-order fix");
-	});
-
-	test("switchSession() calls abort() before _disconnectFromAgent()", () => {
-		// Find the switchSession method body
-		const switchStart = source.indexOf("async switchSession(sessionPath:");
-		assert.ok(switchStart >= 0, "should find switchSession method");
+	it("switchSession() invokes abort() before _disconnectFromAgent()", async () => {
+		const session = await createSession({ persistSessions: true });
+		// Seed a session file to switch to (switchSession reads from the session manager).
+		await session.newSession();
+		const sessionFile = session.sessionFile;
+		assert.ok(typeof sessionFile === "string" && sessionFile.length > 0, "need a session file to switch to");
 
-		// Get a window that includes the abort/disconnect section
-		const window = source.slice(switchStart, switchStart + 800);
+		const order = recordCallOrder(session as any, ["abort", "_disconnectFromAgent"]);
 
-		// Find the abort and _disconnectFromAgent calls
-		const abortIdx = window.indexOf("await this.abort();");
-		const disconnectIdx = window.indexOf("this._disconnectFromAgent();");
+		const ok = await session.switchSession(sessionFile);
+		assert.equal(ok, true);
 
-		assert.ok(abortIdx >= 0, "switchSession should call await this.abort()");
-		assert.ok(disconnectIdx >= 0, "switchSession should call this._disconnectFromAgent()");
+		const abortIdx = order.indexOf("abort");
+		const disconnectIdx = order.indexOf("_disconnectFromAgent");
+		assert.ok(abortIdx >= 0, `switchSession should call abort(); order=${order.join(",")}`);
+		assert.ok(
+			disconnectIdx >= 0,
+			`switchSession should call _disconnectFromAgent(); order=${order.join(",")}`,
+		);
 		assert.ok(
 			abortIdx < disconnectIdx,
-			"abort() must be called BEFORE _disconnectFromAgent() in switchSession so that events fire before unsubscribing",
+			`abort() must run before _disconnectFromAgent() in switchSession; order=${order.join(",")}`,
 		);
 	});
 });

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

@@ -1,21 +1,93 @@
-import test from "node:test";
+// Regression test: explicit model switches must cancel any in-flight retry
+// BEFORE applying the new model. Otherwise stale provider backoff errors
+// from the previous model can continue to land after the switch.
+//
+// Verified behaviourally: construct a real AgentSession, wrap
+// `_retryHandler.abortRetry` and `agent.setModel` to record call order,
+// invoke setModel(), and assert the observed order.
+
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+
+import { Agent } from "@gsd/pi-agent-core";
+import { getModel } from "@gsd/pi-ai";
+import { AgentSession } from "./agent-session.js";
+import { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { SessionManager } from "./session-manager.js";
+import { SettingsManager } from "./settings-manager.js";
+
+let testDir: string;
+
+async function createSession(): Promise<AgentSession> {
+	const agentDir = join(testDir, "agent-home");
+	const authStorage = AuthStorage.inMemory({});
+	// Seed a runtime anthropic API key so modelRegistry.isProviderRequestReady()
+	// returns true and setModel() doesn't throw on missing credentials.
+	authStorage.setRuntimeApiKey("anthropic", "sk-test-not-used");
+	const modelRegistry = new ModelRegistry(authStorage, join(agentDir, "models.json"));
+	const settingsManager = SettingsManager.inMemory();
+	const resourceLoader = new DefaultResourceLoader({
+		cwd: testDir,
+		agentDir,
+		settingsManager,
+		noExtensions: true,
+		noPromptTemplates: true,
+		noThemes: true,
+	});
+	await resourceLoader.reload();
+
+	return new AgentSession({
+		agent: new Agent(),
+		sessionManager: SessionManager.inMemory(testDir),
+		settingsManager,
+		cwd: testDir,
+		resourceLoader,
+		modelRegistry,
+	});
+}
+
+describe("AgentSession — explicit model switch cancels retry before applying new model", () => {
+	beforeEach(() => {
+		testDir = mkdtempSync(join(tmpdir(), "agent-session-model-switch-"));
+	});
+
+	afterEach(() => {
+		rmSync(testDir, { recursive: true, force: true });
+	});
+
+	it("setModel() calls _retryHandler.abortRetry() before agent.setModel()", async () => {
+		const session = await createSession();
+
+		const order: string[] = [];
+		const retryHandler = (session as any)._retryHandler;
+		const originalAbortRetry = retryHandler.abortRetry.bind(retryHandler);
+		retryHandler.abortRetry = () => {
+			order.push("abortRetry");
+			return originalAbortRetry();
+		};
+
+		const agent = (session as any).agent;
+		const originalSetModel = agent.setModel.bind(agent);
+		agent.setModel = (model: unknown) => {
+			order.push("setModel");
+			return originalSetModel(model);
+		};
+
+		const newModel = getModel("anthropic", "claude-3-5-sonnet-20241022");
+		await session.setModel(newModel, { persist: false });
 
-const source = readFileSync(join(process.cwd(), "packages/pi-coding-agent/src/core/agent-session.ts"), "utf-8");
-
-test("agent-session: explicit model switches cancel retry before applying new model", () => {
-	const start = source.indexOf("private async _applyModelChange(");
-	assert.ok(start >= 0, "missing _applyModelChange");
-	const window = source.slice(start, start + 900);
-	const abortIdx = window.indexOf("this._retryHandler.abortRetry();");
-	const setModelIdx = window.indexOf("this.agent.setModel(model);");
-
-	assert.ok(abortIdx >= 0, "_applyModelChange should cancel any in-flight retry");
-	assert.ok(setModelIdx >= 0, "_applyModelChange should set the new model");
-	assert.ok(
-		abortIdx < setModelIdx,
-		"retry cancellation must happen before applying the new model to prevent stale provider retries",
-	);
+		const abortIdx = order.indexOf("abortRetry");
+		const setIdx = order.indexOf("setModel");
+		assert.ok(abortIdx >= 0, `setModel should cancel in-flight retry; order=${order.join(",")}`);
+		assert.ok(setIdx >= 0, `setModel should call agent.setModel; order=${order.join(",")}`);
+		assert.ok(
+			abortIdx < setIdx,
+			`retry cancellation must happen before applying the new model; order=${order.join(",")}`,
+		);
+	});
 });

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

@@ -1,64 +1,133 @@
-// GSD-2 — Regression tests for #3616: tool list persistence across newSession() calls
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+// Regression test for #3616: newSession() must restore the full tool set
+// when cwd is unchanged.
+//
+// The bug: extensions may narrow the active tool list via setActiveTools()
+// during a session. Without a refresh in the else branch of newSession(),
+// the narrowed set persists into the next session — breaking auto-mode
+// subagent sessions that expect a full tool palette.
+//
+// Verified behaviourally: construct an AgentSession, wrap _refreshToolRegistry
+// to record its args, call newSession() with cwd unchanged, and assert that
+// a refresh was requested with includeAllExtensionTools: true.
 
-import test, { describe } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
 
-const source = readFileSync(
-	join(process.cwd(), "packages/pi-coding-agent/src/core/agent-session.ts"),
-	"utf-8",
-);
+import { Agent } from "@gsd/pi-agent-core";
+import { AgentSession } from "./agent-session.js";
+import { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { SessionManager } from "./session-manager.js";
+import { SettingsManager } from "./settings-manager.js";
 
-describe("#3616 — newSession() must restore full tool set", () => {
-	test("newSession() calls _refreshToolRegistry with includeAllExtensionTools when cwd is unchanged", () => {
-		// Find the newSession method
-		const newSessionStart = source.indexOf("async newSession(options?:");
-		assert.ok(newSessionStart >= 0, "should find newSession method");
+let testDir: string;
 
-		// Get the method body (up to the next top-level method)
-		const methodBody = source.slice(newSessionStart, newSessionStart + 3000);
+async function createSession(): Promise<AgentSession> {
+	const agentDir = join(testDir, "agent-home");
+	const authStorage = AuthStorage.inMemory({});
+	const modelRegistry = new ModelRegistry(authStorage, join(agentDir, "models.json"));
+	const settingsManager = SettingsManager.inMemory();
+	const resourceLoader = new DefaultResourceLoader({
+		cwd: testDir,
+		agentDir,
+		settingsManager,
+		noExtensions: true,
+		noPromptTemplates: true,
+		noThemes: true,
+	});
+	await resourceLoader.reload();
 
-		// Verify the cwd-changed branch rebuilds tools
-		assert.ok(
-			methodBody.includes("if (this._cwd !== previousCwd)"),
-			"should have cwd-change guard",
-		);
+	return new AgentSession({
+		agent: new Agent(),
+		sessionManager: SessionManager.inMemory(testDir),
+		settingsManager,
+		cwd: testDir,
+		resourceLoader,
+		modelRegistry,
+	});
+}
+
+describe("#3616 — newSession() restores narrowed tool set when cwd unchanged", () => {
+	beforeEach(() => {
+		testDir = mkdtempSync(join(tmpdir(), "agent-session-tool-refresh-"));
+	});
+
+	afterEach(() => {
+		rmSync(testDir, { recursive: true, force: true });
+	});
 
-		// Verify the else branch exists and refreshes tools with includeAllExtensionTools
-		const elseIdx = methodBody.indexOf("} else {");
-		assert.ok(elseIdx >= 0, "should have else branch for cwd-unchanged case");
+	it("calls _refreshToolRegistry with includeAllExtensionTools: true when cwd unchanged", async () => {
+		const session = await createSession();
+		// Pin _cwd so newSession()'s `process.cwd()` branch takes the
+		// cwd-unchanged path. The production code compares `this._cwd !==
+		// previousCwd`; we force equality by setting _cwd to current cwd.
+		(session as any)._cwd = process.cwd();
+
+		const refreshCalls: Array<{ includeAllExtensionTools?: boolean }> = [];
+		const originalRefresh = (session as any)._refreshToolRegistry.bind(session);
+		(session as any)._refreshToolRegistry = (options?: { includeAllExtensionTools?: boolean }) => {
+			refreshCalls.push(options ?? {});
+			return originalRefresh(options);
+		};
+
+		const ok = await session.newSession();
+		assert.equal(ok, true);
 
-		const elseBranch = methodBody.slice(elseIdx, elseIdx + 800);
 		assert.ok(
-			elseBranch.includes("_refreshToolRegistry"),
-			"else branch should call _refreshToolRegistry",
+			refreshCalls.length > 0,
+			"newSession() should invoke _refreshToolRegistry in the cwd-unchanged branch",
 		);
 		assert.ok(
-			elseBranch.includes("includeAllExtensionTools: true"),
-			"else branch should pass includeAllExtensionTools: true to restore narrowed tools",
+			refreshCalls.some((o) => o.includeAllExtensionTools === true),
+			`at least one _refreshToolRegistry call must pass includeAllExtensionTools: true; observed=${JSON.stringify(refreshCalls)}`,
 		);
 	});
 
-	test("newSession() references #3616 in the else-branch comment", () => {
-		const idx = source.indexOf("#3616");
-		assert.ok(idx >= 0, "source should reference issue #3616 for the tool restore fix");
+	it("agent.reset() does not clear _state.tools (tools persist across reset)", () => {
+		// Structural invariant protecting #3616: if reset() starts clearing
+		// tools, newSession()'s refresh becomes the only defense against loss.
+		// Assertion is behavioural — seed tools, call reset(), observe survival.
+		const agent = new Agent();
+		const tool = {
+			name: "test_tool",
+			description: "x",
+			schema: { type: "object", properties: {}, additionalProperties: false } as any,
+			execute: async () => ({ content: [] }),
+		};
+		(agent as any)._state.tools = [tool];
+		agent.reset();
+		assert.deepEqual(
+			(agent as any)._state.tools,
+			[tool],
+			"Agent.reset() must preserve _state.tools",
+		);
 	});
 
-	test("agent.reset() does not clear _state.tools (tools persist across reset)", () => {
-		// This is a structural invariant — if reset() starts clearing tools,
-		// the newSession() refresh becomes the only defense against tool loss.
-		const agentSource = readFileSync(
-			join(process.cwd(), "packages/pi-agent-core/src/agent.ts"),
-			"utf-8",
-		);
-		const resetStart = agentSource.indexOf("reset()");
-		assert.ok(resetStart >= 0, "should find reset() method");
-		const resetBody = agentSource.slice(resetStart, resetStart + 400);
+	it("takes the cwd-changed branch (rebuilds runtime) when cwd differs", async () => {
+		const session = await createSession();
+		// Force the cwd-changed branch: set _cwd to something that won't equal process.cwd().
+		(session as any)._cwd = join(testDir, "some", "other", "cwd");
+
+		let buildRuntimeCalled = false;
+		let buildRuntimeIncludedAll = false;
+		const originalBuild = (session as any)._buildRuntime.bind(session);
+		(session as any)._buildRuntime = (options?: { includeAllExtensionTools?: boolean }) => {
+			buildRuntimeCalled = true;
+			if (options?.includeAllExtensionTools === true) buildRuntimeIncludedAll = true;
+			return originalBuild(options);
+		};
+
+		const ok = await session.newSession();
+		assert.equal(ok, true);
+
+		assert.ok(buildRuntimeCalled, "cwd-changed branch must rebuild the tool runtime");
 		assert.ok(
-			!resetBody.includes("tools"),
-			"reset() should NOT touch _state.tools — tools are managed by agent-session",
+			buildRuntimeIncludedAll,
+			"cwd-changed branch must rebuild with includeAllExtensionTools: true",
 		);
 	});
 });

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

@@ -653,15 +653,72 @@ export function containsTypeScriptSyntax(source: string): boolean {
  * are compiled once and reused across all extensions.
  */
 let _extensionLoaderJiti: ReturnType<typeof createJiti> | null = null;
+// Tracks every extension-module path that jiti has compiled through the shared
+// singleton so resetExtensionLoaderCache() can also evict Node's global
+// require.cache entries for those modules. jiti stores compiled modules under
+// `nativeRequire.cache[filename]` when `moduleCache: true`, so a new singleton
+// still returns the stale cached module on re-import without this eviction.
+const _loadedExtensionPaths = new Set<string>();
+const _extensionRequire = createRequire(import.meta.url);
 
 /**
  * Reset the shared jiti singleton so the next call to getExtensionLoaderJiti()
  * creates a fresh instance.  This prevents memory leaks in long-running daemon
  * processes (every loaded module stays cached forever) and ensures stale modules
  * are not returned when extension source changes on disk.
+ *
+ * #3616: resetting the singleton alone is insufficient — jiti stores compiled
+ * modules in Node's global require.cache when `moduleCache: true`, which is
+ * shared across singletons. We also evict cached entries for every extension
+ * path we've previously loaded so the next import recompiles from disk.
  */
 export function resetExtensionLoaderCache(): void {
 	_extensionLoaderJiti = null;
+	// Build a set of exact cache keys we expect (raw path, resolved path,
+	// realpath) AND a set of (basename, containing-directory) pairs so we
+	// can also catch entries that jiti/Node wrote under a canonicalized
+	// form (Windows drive-letter case, separator swap, UNC prefix, symlink
+	// resolution). require.cache is shared across all createRequire
+	// instances for CJS, so iterating any instance's cache covers jiti's
+	// internal `nativeRequire.cache` writes.
+	const exact = new Set<string>();
+	const signatures = new Set<string>();
+	const makeSignature = (p: string): string => {
+		const normalized = p.replace(/\\/g, "/").toLowerCase();
+		const slash = normalized.lastIndexOf("/");
+		const base = slash >= 0 ? normalized.slice(slash + 1) : normalized;
+		// Use the trailing two path segments as the signature — unique
+		// enough to avoid collisions in typical filesystems while tolerating
+		// drive-letter / separator variations that differ in the prefix.
+		const parent = slash >= 0 ? normalized.slice(0, slash) : "";
+		const parentSlash = parent.lastIndexOf("/");
+		const parentSeg = parentSlash >= 0 ? parent.slice(parentSlash + 1) : parent;
+		return `${parentSeg}/${base}`;
+	};
+	for (const raw of _loadedExtensionPaths) {
+		exact.add(raw);
+		try {
+			exact.add(_extensionRequire.resolve(raw));
+		} catch {
+			// unresolvable — fall through; signature scan may still hit it
+		}
+		try {
+			exact.add(fs.realpathSync(raw));
+		} catch {
+			// file may have been deleted already; ignore
+		}
+		signatures.add(makeSignature(raw));
+	}
+	for (const key of Object.keys(_extensionRequire.cache)) {
+		if (exact.has(key) || signatures.has(makeSignature(key))) {
+			try {
+				delete _extensionRequire.cache[key];
+			} catch {
+				// require.cache is best-effort; ignore failures (e.g. frozen cache).
+			}
+		}
+	}
+	_loadedExtensionPaths.clear();
 }
 
 function getExtensionLoaderJiti() {
@@ -696,6 +753,7 @@ async function loadExtensionModule(extensionPath: string) {
 	const jiti = getExtensionLoaderJiti();
 
 	const module = await jiti.import(extensionPath, { default: true });
+	_loadedExtensionPaths.add(extensionPath);
 	const factory = module as ExtensionFactory;
 	return typeof factory !== "function" ? undefined : factory;
 }

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

@@ -315,8 +315,19 @@ test("LSP integration: typescript-language-server", async (t) => {
 			textDocument: { uri: mathUri, languageId: "typescript", version: 1, text: mathContent },
 		});
 
-		// Give the server time to index
-		await new Promise((r) => setTimeout(r, 3000));
+		// Poll for a published diagnostics notification on main.ts, which
+		// is the observable signal that TypeScript has finished indexing
+		// the opened file. Previous magic-sleep (3000ms) was too short on
+		// slow CI machines and wasteful on fast ones (#4798).
+		const INDEX_DEADLINE_MS = 15_000;
+		const indexDeadline = Date.now() + INDEX_DEADLINE_MS;
+		while (Date.now() < indexDeadline) {
+			const diags = lsp
+				.getNotifications("textDocument/publishDiagnostics")
+				.filter((n) => (n.params as { uri: string }).uri === mainUri);
+			if (diags.length > 0) break;
+			await new Promise((r) => setTimeout(r, 50));
+		}
 
 		// ---- Hover ----
 		await t.test("hover on 'add' call", async () => {
@@ -381,8 +392,28 @@ test("LSP integration: typescript-language-server", async (t) => {
 
 		// ---- Diagnostics (published via notification) ----
 		await t.test("diagnostics for type error", async () => {
-			// Wait a bit more for diagnostics to arrive
-			await new Promise((r) => setTimeout(r, 2000));
+			// Poll for the specific type-error diagnostic on main.ts
+			// instead of sleeping a fixed 2s. tsserver pushes diagnostics
+			// incrementally — we need to wait until at least one diag
+			// contains a type-error signal, not just any diag.
+			const DIAG_DEADLINE_MS = 10_000;
+			const diagDeadline = Date.now() + DIAG_DEADLINE_MS;
+			while (Date.now() < diagDeadline) {
+				const candidates = lsp
+					.getNotifications("textDocument/publishDiagnostics")
+					.filter((n) => (n.params as { uri: string }).uri === mainUri)
+					.flatMap(
+						(n) => (n.params as { diagnostics: Array<{ message: string }> }).diagnostics,
+					);
+				if (
+					candidates.some(
+						(d) => d.message.includes("not assignable") || d.message.includes("Type"),
+					)
+				) {
+					break;
+				}
+				await new Promise((r) => setTimeout(r, 50));
+			}
 
 			const diagNotifications = lsp.getNotifications("textDocument/publishDiagnostics");
 			const mainDiags = diagNotifications.filter(

package/packages/pi-coding-agent/src/core/model-registry-auth-mode.test.ts

@@ -39,6 +39,10 @@ function findModel(registry: ModelRegistry, provider: string, id: string): Model
 	return registry.getAvailable().find((m) => m.provider === provider && m.id === id);
 }
 
+function availableModelIds(registry: ModelRegistry): Set<string> {
+	return new Set(registry.getAvailable().map((model) => `${model.provider}/${model.id}`));
+}
+
 function makeModel(provider: string, id: string, api: string): Model<Api> {
 	return {
 		id,
@@ -93,6 +97,22 @@ function createStreamSpy(): {
 // ─── Registration ─────────────────────────────────────────────────────────────
 
 describe("ModelRegistry authMode — registration", () => {
+	it("includes GPT-5.5 in the authenticated all-models menu backing list", () => {
+		const registry = createInMemoryRegistry({
+			openai: { type: "api_key", key: "sk-test" },
+			"openai-codex": {
+				type: "oauth",
+				access: "codex-access",
+				refresh: "codex-refresh",
+				expires: Date.now() + 60_000,
+			},
+		});
+
+		const ids = availableModelIds(registry);
+		assert.ok(ids.has("openai/gpt-5.5"), "all-models menu backing list should include openai/gpt-5.5");
+		assert.ok(ids.has("openai-codex/gpt-5.5"), "all-models menu backing list should include openai-codex/gpt-5.5");
+	});
+
 	it("registers externalCli provider with streamSimple and without apiKey/oauth", () => {
 		const registry = createRegistry();
 		const spy = createStreamSpy();