gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

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

@@ -15,11 +15,11 @@ function createRegistry(hasAuthFn?: (provider: string) => boolean): ModelRegistr
 		getApiKey: async () => undefined,
 	} as unknown as AuthStorage;
 
-	return new ModelRegistry(authStorage, undefined);
+	return new ModelRegistry(authStorage, "");
 }
 
 function createInMemoryRegistry(data: AuthStorageData = {}): ModelRegistry {
-	return new ModelRegistry(AuthStorage.inMemory(data), undefined);
+	return new ModelRegistry(AuthStorage.inMemory(data), "");
 }
 
 function createProviderModel(id: string, api?: string): NonNullable<Parameters<ModelRegistry["registerProvider"]>[1]["models"]>[number] {
@@ -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/resource-loader.ts

@@ -242,7 +242,7 @@ export class DefaultResourceLoader implements ResourceLoader {
 		this.systemPromptOverride = options.systemPromptOverride;
 		this.appendSystemPromptOverride = options.appendSystemPromptOverride;
 
-		this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() };
+		this.extensionsResult = { extensions: [], errors: [], warnings: [], runtime: createExtensionRuntime() };
 		this.skills = [];
 		this.skillDiagnostics = [];
 		this.prompts = [];

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/sdk.test.ts

@@ -3,7 +3,8 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { CredentialCooldownError } from "./sdk.js";
+import { canRestoreSessionModel, CredentialCooldownError } from "./sdk.js";
+import type { Model } from "@gsd/pi-ai";
 
 // ─── CredentialCooldownError ──────────────────────────────────────────────────
 
@@ -87,3 +88,26 @@ describe("CredentialCooldownError", () => {
 		assert.equal(plain.retryAfterMs, 15_000);
 	});
 });
+
+describe("canRestoreSessionModel", () => {
+	const model = {
+		provider: "claude-code",
+		id: "claude-sonnet",
+	} as Model<any>;
+
+	it("allows keyless external providers when the provider is request-ready", () => {
+		const registry = {
+			isProviderRequestReady: (provider: string) => provider === "claude-code",
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), true);
+	});
+
+	it("blocks restore when the provider is not request-ready", () => {
+		const registry = {
+			isProviderRequestReady: () => false,
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), false);
+	});
+});

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

@@ -31,6 +31,13 @@ export class CredentialCooldownError extends Error {
 		this.retryAfterMs = retryAfterMs;
 	}
 }
+
+export function canRestoreSessionModel(
+	modelRegistry: Pick<ModelRegistry, "isProviderRequestReady">,
+	model: Model<any>,
+): boolean {
+	return modelRegistry.isProviderRequestReady(model.provider);
+}
 import { Agent, type AgentMessage, type ThinkingLevel } from "@gsd/pi-agent-core";
 import type { Message, Model } from "@gsd/pi-ai";
 import { getAgentDir, getDocsPath } from "../config.js";
@@ -262,9 +269,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// If session has data, try to restore model from it
 	if (!model && hasExistingSession && existingSession.model) {
 		const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
-		if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
-			model = restoredModel;
-		}
+			if (restoredModel && canRestoreSessionModel(modelRegistry, restoredModel)) {
+				model = restoredModel;
+			}
 		if (!model) {
 			modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
 		}

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;
@@ -109,9 +143,9 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	}
 
 	// Get absolute paths to documentation and examples
-	const readmePath = getReadmePath();
-	const docsPath = getDocsPath();
-	const examplesPath = getExamplesPath();
+	const readmePath = toPosixPath(getReadmePath());
+	const docsPath = toPosixPath(getDocsPath());
+	const examplesPath = toPosixPath(getExamplesPath());
 
 	// Build tools list based on selected tools.
 	// Built-ins use toolDescriptions. Custom tools can provide one-line snippets.

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

@@ -1,11 +1,12 @@
 import { describe, it, mock, afterEach } from "node:test";
 import assert from "node:assert/strict";
+import { resolve as resolvePath } from "node:path";
 import { resolveToCwd, expandPath } from "./path-utils.js";
 
 describe("resolveToCwd", () => {
 	it("resolves relative paths against cwd", () => {
 		const result = resolveToCwd("foo/bar.txt", "/home/user/project");
-		assert.equal(result, "/home/user/project/foo/bar.txt");
+		assert.equal(result, resolvePath("/home/user/project", "foo/bar.txt"));
 	});
 
 	it("returns absolute paths unchanged", () => {

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__/provider-display-name.test.ts

@@ -1,14 +1,11 @@
-// GSD-2 — Provider display name mapping tests
+// GSD-2 — Provider display name + auth badge tests
 import { test, describe } from "node:test";
 import assert from "node:assert/strict";
-import { providerDisplayName } from "../model-selector.js";
+import { providerAuthBadge, providerDisplayName } from "../model-selector.js";
 
 describe("providerDisplayName", () => {
-	test("renames 'anthropic' to 'anthropic-api'", () => {
-		assert.equal(providerDisplayName("anthropic"), "anthropic-api");
-	});
-
-	test("passes through unmapped providers unchanged", () => {
+	test("passes providers through unchanged", () => {
+		assert.equal(providerDisplayName("anthropic"), "anthropic");
 		assert.equal(providerDisplayName("claude-code"), "claude-code");
 		assert.equal(providerDisplayName("openai"), "openai");
 		assert.equal(providerDisplayName("bedrock"), "bedrock");
@@ -16,3 +13,16 @@ describe("providerDisplayName", () => {
 		assert.equal(providerDisplayName("openrouter"), "openrouter");
 	});
 });
+
+describe("providerAuthBadge", () => {
+	test("returns human-readable labels for each auth mode", () => {
+		assert.equal(providerAuthBadge("apiKey"), "API key");
+		assert.equal(providerAuthBadge("oauth"), "OAuth");
+		assert.equal(providerAuthBadge("externalCli"), "CLI");
+	});
+
+	test("returns empty string for 'none' and undefined", () => {
+		assert.equal(providerAuthBadge("none"), "");
+		assert.equal(providerAuthBadge(undefined), "");
+	});
+});

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", () => {

package/packages/pi-coding-agent/src/modes/interactive/components/footer.ts

@@ -2,7 +2,7 @@ import { type Component, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import type { AgentSession } from "../../../core/agent-session.js";
 import type { ReadonlyFooterDataProvider } from "../../../core/footer-data-provider.js";
 import { theme } from "../theme/theme.js";
-import { providerDisplayName } from "./model-selector.js";
+import { providerAuthBadge, providerDisplayName } from "./model-selector.js";
 
 /**
  * Sanitize text for display in a single-line status.
@@ -199,13 +199,22 @@ export class FooterComponent implements Component {
 				thinkingLevel === "off" ? `${modelName} • thinking off` : `${modelName} • ${thinkingLevel}`;
 		}
 
-		// Prepend the provider in parentheses if there are multiple providers and there's enough room
+		// Prepend the provider in parentheses if there are multiple providers and there's enough room.
+		// Include the auth mode so users can tell at a glance whether the active model is
+		// API-key-backed, OAuth-backed, or delegated to a third-party CLI.
 		let rightSide = rightSideWithoutProvider;
 		if (this.footerData.getAvailableProviderCount() > 1 && displayModel) {
-			rightSide = `(${providerDisplayName(displayModel.provider)}) ${rightSideWithoutProvider}`;
+			const authMode = this.session.modelRegistry.getProviderAuthMode(displayModel.provider);
+			const authLabel = providerAuthBadge(authMode);
+			const providerLabel = providerDisplayName(displayModel.provider);
+			const parenthetical = authLabel ? `${providerLabel} · ${authLabel}` : providerLabel;
+			rightSide = `(${parenthetical}) ${rightSideWithoutProvider}`;
 			if (statsLeftWidth + minPadding + visibleWidth(rightSide) > width) {
-				// Too wide, fall back
-				rightSide = rightSideWithoutProvider;
+				// Too wide: drop the auth suffix first, then fall back to no parenthetical.
+				rightSide = `(${providerLabel}) ${rightSideWithoutProvider}`;
+				if (statsLeftWidth + minPadding + visibleWidth(rightSide) > width) {
+					rightSide = rightSideWithoutProvider;
+				}
 			}
 		}