gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

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();

package/packages/pi-coding-agent/src/core/resource-loader-cache-reset.test.ts

@@ -1,42 +1,107 @@
-// GSD-2 — Regression test for #3616: reload() must reset jiti extension loader cache
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+// Regression test for #3616: DefaultResourceLoader.reload() must invalidate
+// the jiti module cache before loading extensions, so that edits to
+// extension source on disk are picked up on the next reload (not served
+// stale from memory).
+//
+// Verified end-to-end behaviourally: we write a .ts extension that
+// registers a tool whose NAME is a module-scope constant, load it,
+// rewrite the source with a new constant value, reload(), and assert
+// the observable tool name reflects the NEW source. Without jiti cache
+// invalidation, the second reload would re-register the stale name.
 
-import test, { describe } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync, utimesSync, writeFileSync } 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/resource-loader.ts"),
-	"utf-8",
-);
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { SettingsManager } from "./settings-manager.js";
+import { resetExtensionLoaderCache } from "./extensions/loader.js";
 
-describe("#3616 — reload() must invalidate jiti module cache", () => {
-	test("resource-loader imports resetExtensionLoaderCache from loader.js", () => {
-		assert.ok(
-			source.includes("resetExtensionLoaderCache"),
-			"resource-loader.ts should import resetExtensionLoaderCache",
-		);
-		assert.ok(
-			source.includes('from "./extensions/loader.js"'),
-			"resetExtensionLoaderCache should be imported from extensions/loader.js",
-		);
+let testDir: string;
+
+function writeExtensionWithToolName(extPath: string, toolName: string): void {
+	// Extension factory signature expected by the loader. Uses `any` so the
+	// test stays decoupled from the ExtensionAPI type shape.
+	writeFileSync(
+		extPath,
+		[
+			`const TOOL_NAME = "${toolName}";`,
+			`export default function activate(api: any) {`,
+			`  api.registerTool({`,
+			`    name: TOOL_NAME,`,
+			`    label: TOOL_NAME,`,
+			`    description: "test tool — source-generated name",`,
+			`    parameters: { type: "object", properties: {}, additionalProperties: false },`,
+			`    execute: async () => ({ content: [], details: undefined }),`,
+			`  });`,
+			`}`,
+			"",
+		].join("\n"),
+	);
+}
+
+describe("#3616 — DefaultResourceLoader.reload() invalidates extension module cache", () => {
+	beforeEach(() => {
+		testDir = mkdtempSync(join(tmpdir(), "resource-loader-cache-reset-"));
+		// Ensure a clean jiti singleton — prior tests in this process may
+		// have populated it with unrelated entries.
+		resetExtensionLoaderCache();
+	});
+
+	afterEach(() => {
+		resetExtensionLoaderCache();
+		rmSync(testDir, { recursive: true, force: true });
 	});
 
-	test("reload() calls resetExtensionLoaderCache before loadExtensions", () => {
-		const reloadStart = source.indexOf("async reload(): Promise<void>");
-		assert.ok(reloadStart >= 0, "should find reload() method");
-		const reloadBody = source.slice(reloadStart, reloadStart + 4000);
+	it("reload() picks up source edits after the extension has been loaded once", async () => {
+		const agentDir = join(testDir, "agent-home");
+		const extPath = join(testDir, "reload-probe.ts");
 
-		const resetIdx = reloadBody.indexOf("resetExtensionLoaderCache()");
-		assert.ok(resetIdx >= 0, "reload() should call resetExtensionLoaderCache()");
+		// v1 — initial content
+		writeExtensionWithToolName(extPath, "probe_v1");
 
-		const loadIdx = reloadBody.indexOf("loadExtensions(");
-		assert.ok(loadIdx >= 0, "reload() should call loadExtensions");
+		const loader = new DefaultResourceLoader({
+			cwd: testDir,
+			agentDir,
+			settingsManager: SettingsManager.inMemory(),
+			noExtensions: true,
+			noPromptTemplates: true,
+			noThemes: true,
+			additionalExtensionPaths: [extPath],
+		});
 
+		await loader.reload();
+
+		const toolsV1 = [...loader.getExtensions().extensions.flatMap((e) => [...e.tools.keys()])];
+		assert.ok(
+			toolsV1.includes("probe_v1"),
+			`first reload should register probe_v1; got=${JSON.stringify(toolsV1)}`,
+		);
+
+		// v2 — overwrite the source on disk with a different tool name.
+		writeExtensionWithToolName(extPath, "probe_v2");
+		// Bump mtime explicitly so file-stat–based cache strategies (jiti's
+		// moduleCache consults Node's require.cache, which some runtimes
+		// tiebreak on mtime) always see "newer than last seen". On Windows
+		// NTFS + node the default fs mtime resolution can silently collapse
+		// two writes in the same tick to an identical mtime — that fooled
+		// the Windows CI run on #3616.
+		const futureTime = new Date(Date.now() + 5000);
+		utimesSync(extPath, futureTime, futureTime);
+
+		await loader.reload();
+
+		const toolsV2 = [...loader.getExtensions().extensions.flatMap((e) => [...e.tools.keys()])];
+		assert.ok(
+			toolsV2.includes("probe_v2"),
+			`second reload must observe the edited source (probe_v2) — if reload() ` +
+				`fails to reset the jiti cache, the stale module returns probe_v1. got=${JSON.stringify(toolsV2)}`,
+		);
 		assert.ok(
-			resetIdx < loadIdx,
-			"resetExtensionLoaderCache() must be called BEFORE loadExtensions to ensure fresh modules",
+			!toolsV2.includes("probe_v1"),
+			`second reload must NOT still expose the stale probe_v1 name; got=${JSON.stringify(toolsV2)}`,
 		);
 	});
 });

package/packages/pi-coding-agent/src/core/retry-handler.test.ts

@@ -281,7 +281,11 @@ describe("RetryHandler — long-context entitlement 429 (#2803)", () => {
 			assert.equal(result, true, "retry should be initiated");
 
 			handler.abortRetry();
-			await new Promise((resolve) => setTimeout(resolve, 10));
+			// Yield the microtask queue so any synchronous continuation
+			// scheduled by abortRetry() settles before we assert. This is
+			// deterministic — no magic-sleep dependency (#4798 / #4784).
+			await Promise.resolve();
+			await Promise.resolve();
 
 			assert.equal(continueFn.mock.calls.length, 0, "cancelled retry must not continue after explicit abort");
 			const endEvents = emittedEvents.filter((e) => e.type === "auto_retry_end");

package/packages/pi-coding-agent/src/core/retry-handler.ts

@@ -18,6 +18,7 @@ import type { ModelRegistry } from "./model-registry.js";
 import type { SettingsManager } from "./settings-manager.js";
 import { sleep } from "../utils/sleep.js";
 import type { AgentSessionEvent } from "./agent-session.js";
+import { RETRYABLE_ERROR_RE } from "./retryable-error-regex.js";
 
 /** Dependencies injected from AgentSession into RetryHandler */
 export interface RetryHandlerDeps {
@@ -111,14 +112,7 @@ export class RetryHandler {
 		const contextWindow = this._deps.getModel()?.contextWindow ?? 0;
 		if (isContextOverflow(message, contextWindow)) return false;
 
-		const err = message.errorMessage;
-		// "temporarily backed off" is intentionally excluded: it is an internally-
-		// generated error from getApiKey() when credentials are in a backoff window.
-		// Re-entering the retry handler for that message creates a cascade of empty
-		// error entries in the session file, breaking resume (#3429).
-		return /overloaded|rate.?limit|too many requests|402|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|requires more credits|can only afford|insufficient credits|not enough credits|extra usage is required|(?:out of|no) extra usage|third.party.*draw from extra|third.party.*not.*available/i.test(
-			err,
-		);
+		return RETRYABLE_ERROR_RE.test(message.errorMessage);
 	}
 
 	/**

package/packages/pi-coding-agent/src/core/retryable-error-regex.ts

@@ -0,0 +1,18 @@
+/**
+ * Regex matching retryable provider errors — overloaded, rate limits, transient
+ * server/connection failures, credential-backoff, quota/credit issues.
+ *
+ * Kept in its own zero-import module so tests can consume the live pattern
+ * without pulling in the full RetryHandler dependency graph (Agent /
+ * FallbackResolver / ModelRegistry / @gsd/pi-ai …). The test in
+ * `src/resources/extensions/gsd/tests/provider-errors.test.ts` previously
+ * redefined this regex inline, which meant runtime and test could drift
+ * silently on every edit (see #4837).
+ *
+ * "temporarily backed off" is intentionally excluded: it is an internally-
+ * generated error from getApiKey() when credentials are in a backoff window.
+ * Re-entering the retry handler for that message creates a cascade of empty
+ * error entries in the session file, breaking resume (#3429).
+ */
+export const RETRYABLE_ERROR_RE =
+	/overloaded|rate.?limit|too many requests|402|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|requires more credits|can only afford|insufficient credits|not enough credits|extra usage is required|(?:out of|no) extra usage|third.party.*draw from extra|third.party.*not.*available/i;

package/packages/pi-coding-agent/src/core/system-prompt.ts

@@ -35,6 +35,26 @@ export interface BuildSystemPromptOptions {
 	contextFiles?: Array<{ path: string; content: string }>;
 	/** Pre-loaded skills. */
 	skills?: Skill[];
+	/**
+	 * Optional predicate applied to the `skills` list before rendering the
+	 * <available_skills> catalog. Returning `false` omits a skill from the
+	 * prompt (the skill remains loaded and invocable by name — only the
+	 * catalog listing is suppressed).
+	 *
+	 * Intended for consumers that can narrow the relevant skill surface
+	 * (e.g. per-unit-type manifests) to reduce cached system-prompt bloat.
+	 * When omitted, all non-`disableModelInvocation` skills render — i.e.
+	 * behavior is unchanged from before this option existed.
+	 *
+	 * Contract: the predicate must be **pure and synchronous**. It may be
+	 * invoked on every system-prompt rebuild (tool-set changes and
+	 * runtime resource-loader extensions both trigger one), so any state
+	 * the closure captures should be stable across the rebuild window.
+	 * If the predicate throws, `buildSystemPrompt` logs a warning and
+	 * falls back to the unfiltered skill list — callers never see the
+	 * exception and the session stays consistent.
+	 */
+	skillFilter?: (skill: Skill) => boolean;
 }
 
 /** Build the system prompt with tools, guidelines, and context */
@@ -48,6 +68,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		cwd,
 		contextFiles: providedContextFiles,
 		skills: providedSkills,
+		skillFilter,
 	} = options;
 	const resolvedCwd = toPosixPath(cwd ?? process.cwd());
 
@@ -66,7 +87,20 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	const appendSection = appendSystemPrompt ? `\n\n${appendSystemPrompt}` : "";
 
 	const contextFiles = providedContextFiles ?? [];
-	const skills = providedSkills ?? [];
+	const skillsBase = providedSkills ?? [];
+	let skills = skillsBase;
+	if (skillFilter) {
+		try {
+			skills = skillsBase.filter(skillFilter);
+		} catch (error) {
+			// A consumer's predicate threw. Fall back to the unfiltered list so
+			// the session stays consistent — callers (e.g. AgentSession.setTools)
+			// must not be left with updated tools but a stale system prompt.
+			const message = error instanceof Error ? error.message : String(error);
+			console.warn(`buildSystemPrompt: skillFilter threw; falling back to unfiltered skills. Error: ${message}`);
+			skills = skillsBase;
+		}
+	}
 
 	if (customPrompt) {
 		let prompt = customPrompt;

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

@@ -188,6 +188,7 @@ export type { PackageCommand, PackageCommandOptions, PackageCommandRunnerOptions
 export { getPackageCommandUsage, parsePackageCommand, runPackageCommand } from "./core/package-commands.js";
 export type { ResourceCollision, ResourceDiagnostic, ResourceLoader } from "./core/resource-loader.js";
 export { DefaultResourceLoader } from "./core/resource-loader.js";
+export { RETRYABLE_ERROR_RE } from "./core/retryable-error-regex.js";
 // SDK for programmatic usage
 export {
 	type CreateAgentSessionOptions,

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/tool-execution.test.ts

@@ -14,12 +14,13 @@ function renderTool(
 		isError: boolean;
 		details?: Record<string, unknown>;
 	},
+	toolDefinition?: { label?: string },
 ): string {
 	const component = new ToolExecutionComponent(
 		toolName,
 		args,
 		{},
-		undefined,
+		toolDefinition as any,
 		{ requestRender() {} } as any,
 	);
 	component.setExpanded(true);
@@ -35,12 +36,13 @@ function renderToolCollapsed(
 		isError: boolean;
 		details?: Record<string, unknown>;
 	},
+	toolDefinition?: { label?: string },
 ): string {
 	const component = new ToolExecutionComponent(
 		toolName,
 		args,
 		{},
-		undefined,
+		toolDefinition as any,
 		{ requestRender() {} } as any,
 	);
 	if (result) component.updateResult(result);
@@ -110,13 +112,57 @@ describe("ToolExecutionComponent", () => {
 			{ count: 3, enabled: true, label: "hello" },
 		);
 
-		assert.match(rendered, /some_unknown_tool/);
+		assert.match(rendered, /Some Unknown Tool/);
 		assert.match(rendered, /count=3/);
 		assert.match(rendered, /enabled=true/);
 		assert.match(rendered, /label="hello"/);
 		assert.doesNotMatch(rendered, /^\{$/m);
 	});
 
+	test("frame header prefers toolDefinition.label over raw tool name", () => {
+		const rendered = renderToolCollapsed(
+			"gsd_slice_complete",
+			{ sliceId: "S03" },
+			undefined,
+			{ label: "Complete Slice" },
+		);
+
+		assert.match(rendered, /Tool Complete Slice/);
+		assert.doesNotMatch(rendered, /gsd_slice_complete/);
+	});
+
+	test("frame header strips gsd_ prefix and title-cases when no label is registered", () => {
+		const rendered = renderToolCollapsed("gsd_requirement_update", { id: "R005" });
+
+		assert.match(rendered, /Tool Requirement Update/);
+		assert.doesNotMatch(rendered, /gsd_requirement_update/);
+	});
+
+	test("formatCompactArgs truncates long string values inline instead of dumping JSON", () => {
+		const longPath = "/Users/alice/.gsd/projects/4dce7b775013/worktrees/slice-S03-some-long-path-that-exceeds-limit";
+		const rendered = renderToolCollapsed("gsd_slice_complete", {
+			sliceId: "S03",
+			milestoneId: "M001",
+			worktree: longPath,
+		});
+
+		assert.match(rendered, /sliceId="S03"/);
+		assert.match(rendered, /milestoneId="M001"/);
+		assert.match(rendered, /worktree=".*…"/);
+		assert.doesNotMatch(rendered, /"sliceId":\s*"S03"/);
+	});
+
+	test("formatCompactArgs shows full string values when expanded", () => {
+		const longPath = "/Users/alice/.gsd/projects/4dce7b775013/worktrees/slice-S03-some-long-path-that-exceeds-limit";
+		const rendered = renderTool("gsd_slice_complete", {
+			sliceId: "S03",
+			worktree: longPath,
+		});
+
+		assert.match(rendered, new RegExp(longPath.replace(/\//g, "\\/")));
+		assert.doesNotMatch(rendered, /…/);
+	});
+
 	test("generic fallback truncates long output when collapsed", () => {
 		const longOutput = Array.from({ length: 25 }, (_, i) => `line ${i + 1}`).join("\n");
 		const rendered = renderToolCollapsed(

package/packages/pi-coding-agent/src/modes/interactive/components/dynamic-border.test.ts

@@ -37,26 +37,32 @@ describe("DynamicBorder spinner", () => {
 		border.stopSpinner();
 	});
 
-	it("triggers standalone render when no external render occurred recently", async () => {
-		const border = new DynamicBorder((s) => s);
-		const tui = makeTUI();
-
-		// Set lastExternalRender to a time well in the past
-		const anyBorder = border as any;
-		anyBorder.lastExternalRender = 0;
-
-		border.startSpinner(tui as any, (s) => s);
-		const initialCount = tui.renderCount;
-
-		// Wait for one spinner tick (200ms interval + buffer)
-		await new Promise((r) => setTimeout(r, 250));
-
-		assert.ok(
-			tui.renderCount > initialCount,
-			"spinner should trigger requestRender when no recent external render",
-		);
-
-		border.stopSpinner();
+	it("triggers standalone render when no external render occurred recently", () => {
+		mock.timers.enable({ apis: ["setInterval"], now: 0 });
+		try {
+			const border = new DynamicBorder((s) => s);
+			const tui = makeTUI();
+
+			// Set lastExternalRender to a time well in the past
+			const anyBorder = border as any;
+			anyBorder.lastExternalRender = 0;
+
+			border.startSpinner(tui as any, (s) => s);
+			const initialCount = tui.renderCount;
+
+			// Advance exactly one spinner interval (200ms). With mocked timers
+			// this is deterministic — no flake under CI load.
+			mock.timers.tick(200);
+
+			assert.ok(
+				tui.renderCount > initialCount,
+				"spinner should trigger requestRender after one 200ms interval when no recent external render",
+			);
+
+			border.stopSpinner();
+		} finally {
+			mock.timers.reset();
+		}
 	});
 
 	it("updates lastExternalRender on each render() call", () => {