gsd-pi 2.71.0 → 2.72.0-dev.593fa74

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

@@ -0,0 +1,85 @@
+/**
+ * Regression test for the #unconfigured-models fix: findInitialModel() must
+ * skip the saved default when its provider has no working auth, rather than
+ * returning an unusable model that every selector surface would display as
+ * "current".
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { findInitialModel } from "./model-resolver.js";
+
+function fakeRegistry(options: {
+	models: Array<{ provider: string; id: string }>;
+	readyProviders: Set<string>;
+}) {
+	const fullModels = options.models.map((m) => ({
+		...m,
+		name: m.id,
+		api: "anthropic-messages",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 128_000,
+		maxTokens: 4096,
+	}));
+	const available = fullModels.filter((m) => options.readyProviders.has(m.provider));
+	return {
+		find(provider: string, id: string) {
+			return fullModels.find((m) => m.provider === provider && m.id === id);
+		},
+		getAvailable() {
+			return available;
+		},
+		isProviderRequestReady(provider: string) {
+			return options.readyProviders.has(provider);
+		},
+	};
+}
+
+test("findInitialModel skips saved default when provider has no auth", async () => {
+	// User saved xai/grok-4 as default, but XAI_API_KEY is unset so xai is
+	// in the registry but not ready. Previously findInitialModel() step 3
+	// returned xai anyway — now it must fall through to step 4 and pick
+	// an available model.
+	const registry = fakeRegistry({
+		models: [
+			{ provider: "xai", id: "grok-4-fast-non-reasoning" },
+			{ provider: "anthropic", id: "claude-opus-4-6" },
+		],
+		readyProviders: new Set(["anthropic"]),
+	});
+
+	const result = await findInitialModel({
+		scopedModels: [],
+		isContinuing: false,
+		defaultProvider: "xai",
+		defaultModelId: "grok-4-fast-non-reasoning",
+		modelRegistry: registry as any,
+	});
+
+	assert.ok(result.model, "a model must be returned");
+	assert.equal(result.model!.provider, "anthropic", "unauth'd saved default must be skipped");
+});
+
+test("findInitialModel keeps saved default when provider has auth", async () => {
+	const registry = fakeRegistry({
+		models: [
+			{ provider: "anthropic", id: "claude-opus-4-6" },
+			{ provider: "openai", id: "gpt-5.4" },
+		],
+		readyProviders: new Set(["anthropic", "openai"]),
+	});
+
+	const result = await findInitialModel({
+		scopedModels: [],
+		isContinuing: false,
+		defaultProvider: "openai",
+		defaultModelId: "gpt-5.4",
+		modelRegistry: registry as any,
+	});
+
+	assert.equal(result.model?.provider, "openai");
+	assert.equal(result.model?.id, "gpt-5.4");
+});

package/packages/pi-coding-agent/src/core/model-resolver.ts

@@ -504,27 +504,31 @@ export async function findInitialModel(options: {
 
 	// 3. Try saved default from settings
 	if (defaultProvider && defaultModelId) {
-		const found = modelRegistry.find(defaultProvider, defaultModelId);
-		if (found) {
-			// Check if the provider's recommended default is a higher-capability variant
-			// of the saved model (e.g. saved "claude-opus-4-6" vs recommended "claude-opus-4-6-extended").
-			// If so, prefer the recommended variant to avoid using a smaller context window (#1125).
-			const recommendedId = defaultModelPerProvider[defaultProvider as KnownProvider];
-			if (recommendedId && recommendedId !== defaultModelId && recommendedId.startsWith(defaultModelId)) {
-				const recommended = modelRegistry.find(defaultProvider, recommendedId);
-				if (recommended) {
-					model = recommended;
-					if (defaultThinkingLevel) {
-						thinkingLevel = defaultThinkingLevel;
+		// Guard against stale settings defaults: only use the saved provider/model
+		// if the provider is actually request-ready (auth/OAuth/CLI ready).
+		if (modelRegistry.isProviderRequestReady(defaultProvider)) {
+			const found = modelRegistry.find(defaultProvider, defaultModelId);
+			if (found) {
+				// Check if the provider's recommended default is a higher-capability variant
+				// of the saved model (e.g. saved "claude-opus-4-6" vs recommended "claude-opus-4-6-extended").
+				// If so, prefer the recommended variant to avoid using a smaller context window (#1125).
+				const recommendedId = defaultModelPerProvider[defaultProvider as KnownProvider];
+				if (recommendedId && recommendedId !== defaultModelId && recommendedId.startsWith(defaultModelId)) {
+					const recommended = modelRegistry.find(defaultProvider, recommendedId);
+					if (recommended) {
+						model = recommended;
+						if (defaultThinkingLevel) {
+							thinkingLevel = defaultThinkingLevel;
+						}
+						return { model, thinkingLevel, fallbackMessage: undefined };
 					}
-					return { model, thinkingLevel, fallbackMessage: undefined };
 				}
+				model = found;
+				if (defaultThinkingLevel) {
+					thinkingLevel = defaultThinkingLevel;
+				}
+				return { model, thinkingLevel, fallbackMessage: undefined };
 			}
-			model = found;
-			if (defaultThinkingLevel) {
-				thinkingLevel = defaultThinkingLevel;
-			}
-			return { model, thinkingLevel, fallbackMessage: undefined };
 		}
 	}
 

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

@@ -171,6 +171,25 @@ describe("RetryHandler — long-context entitlement 429 (#2803)", () => {
 			const retryStart = emittedEvents.find((e) => e.type === "auto_retry_start");
 			assert.ok(retryStart, "Regular 429 should enter backoff retry");
 		});
+
+		it("classifies OpenRouter credit affordability errors as quota_exhausted", async () => {
+			const { deps, emittedEvents } = createMockDeps({
+				model: createMockModel("openrouter", "openai/gpt-5-pro"),
+				markUsageLimitReachedResult: false,
+				fallbackResult: null,
+			});
+
+			const handler = new RetryHandler(deps);
+			const msg = errorMessage(
+				"402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
+			);
+
+			const result = await handler.handleRetryableError(msg);
+
+			assert.equal(result, true, "affordability error should trigger credit-aware retry");
+			const retryStart = emittedEvents.find((e) => e.type === "auto_retry_start");
+			assert.ok(retryStart, "Expected immediate retry after reducing max tokens");
+		});
 	});
 
 	describe("long-context model downgrade", () => {
@@ -271,6 +290,61 @@ describe("RetryHandler — long-context entitlement 429 (#2803)", () => {
 		});
 	});
 
+	describe("credit-aware maxTokens retry", () => {
+		it("reduces maxTokens on same model when provider reports affordable cap", async () => {
+			const expensiveModel = createMockModel("openrouter", "openai/gpt-5-pro");
+			expensiveModel.maxTokens = 128000;
+
+			const { deps, emittedEvents, onModelChangeFn } = createMockDeps({
+				model: expensiveModel,
+				markUsageLimitReachedResult: false,
+				fallbackResult: null,
+			});
+
+			const handler = new RetryHandler(deps);
+			const msg = errorMessage(
+				"402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
+			);
+
+			const result = await handler.handleRetryableError(msg);
+			assert.equal(result, true, "should retry after reducing maxTokens");
+
+			const setModelCalls = (deps.agent.setModel as any).mock.calls;
+			assert.equal(setModelCalls.length, 1, "should apply one model downgrade");
+			const downgraded = setModelCalls[0].arguments[0] as Model<Api>;
+			assert.equal(downgraded.provider, "openrouter");
+			assert.equal(downgraded.id, "openai/gpt-5-pro");
+			assert.equal(downgraded.maxTokens, 297, "expected affordability cap with safety buffer");
+
+			assert.equal(onModelChangeFn.mock.calls.length, 1, "should notify about model update");
+			const switchEvent = emittedEvents.find((e) => e.type === "fallback_provider_switch");
+			assert.ok(switchEvent, "should emit model-adjustment event");
+			assert.ok(
+				String(switchEvent?.reason || "").includes("credit-aware retry"),
+				"switch reason should mention credit-aware retry",
+			);
+		});
+
+		it("does not mark credentials in cooldown for affordability quota errors", async () => {
+			const expensiveModel = createMockModel("openrouter", "openai/gpt-5-pro");
+			expensiveModel.maxTokens = 128000;
+
+			const { deps, markUsageLimitReached } = createMockDeps({
+				model: expensiveModel,
+				markUsageLimitReachedResult: false,
+				fallbackResult: null,
+			});
+
+			const handler = new RetryHandler(deps);
+			const msg = errorMessage(
+				"402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
+			);
+
+			await handler.handleRetryableError(msg);
+			assert.equal(markUsageLimitReached.mock.calls.length, 0, "quota error should skip credential cooldown");
+		});
+	});
+
 	describe("isRetryableError", () => {
 		it("considers long-context entitlement error as retryable", () => {
 			const { deps } = createMockDeps();
@@ -291,6 +365,15 @@ describe("RetryHandler — long-context entitlement 429 (#2803)", () => {
 			);
 			assert.equal(handler.isRetryableError(msg), false);
 		});
+
+		it("considers OpenRouter affordability credit errors as retryable", () => {
+			const { deps } = createMockDeps();
+			const handler = new RetryHandler(deps);
+			const msg = errorMessage(
+				"402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
+			);
+			assert.equal(handler.isRetryableError(msg), true);
+		});
 	});
 
 	describe("third-party block claude-code fallback (#3772)", () => {

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

@@ -116,7 +116,7 @@ export class RetryHandler {
 		// 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|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|extra usage is required|(?:out of|no) extra usage|third.party.*draw from extra|third.party.*not.*available/i.test(
+		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,
 		);
 	}
@@ -158,6 +158,14 @@ export class RetryHandler {
 			const isRateLimit = errorType === "rate_limit";
 			const isQuotaError = errorType === "quota_exhausted";
 
+			// Credit-aware retry (OpenRouter-style 402 affordability errors):
+			// when provider reports "can only afford N", lower maxTokens and retry
+			// on the same model before rotating credentials/providers.
+			if (isQuotaError) {
+				const adjusted = this._tryAffordableMaxTokensRetry(message, retryGeneration);
+				if (adjusted) return true;
+			}
+
 			// Credential rotation — only for transient rate limits (#3430).
 			// Quota errors ("Extra usage is required") are account-level billing
 			// gates; rotating to another credential on the same account won't help
@@ -409,12 +417,63 @@ export class RetryHandler {
 		// Long-context entitlement errors are billing gates, not transient rate limits.
 		// Must be checked before the generic 429/rate_limit regex.
 		if (/extra usage is required|long context required/i.test(err)) return "quota_exhausted";
+		if (/requires more credits|can only afford|insufficient credits|not enough credits|credit balance/i.test(err))
+			return "quota_exhausted";
 		if (/quota|billing|exceeded.*limit|usage.*limit/i.test(err)) return "quota_exhausted";
 		if (/rate.?limit|too many requests|429/i.test(err)) return "rate_limit";
 		if (/500|502|503|504|server.?error|internal.?error|service.?unavailable/i.test(err)) return "server_error";
 		return "unknown";
 	}
 
+	/**
+	 * Attempt a same-model retry by reducing maxTokens when provider reports
+	 * an affordability cap (e.g., "can only afford 329").
+	 */
+	private _tryAffordableMaxTokensRetry(message: AssistantMessage, retryGeneration: number): boolean {
+		const currentModel = this._deps.getModel();
+		if (!currentModel || !message.errorMessage) return false;
+
+		// Example: "can only afford 329"
+		const match = message.errorMessage.match(/can only afford\s+([\d,]+)/i);
+		if (!match?.[1]) return false;
+
+		const affordable = Number.parseInt(match[1].replace(/,/g, ""), 10);
+		if (!Number.isFinite(affordable) || affordable <= 0) return false;
+
+		// Leave a small buffer so slight input variance doesn't immediately re-fail.
+		const safetyBuffer = Math.min(64, Math.max(16, Math.floor(affordable * 0.1)));
+		const targetMaxTokens = Math.max(64, affordable - safetyBuffer);
+		const downgradedMaxTokens = Math.min(currentModel.maxTokens, targetMaxTokens);
+		if (downgradedMaxTokens >= currentModel.maxTokens) return false;
+
+		const downgradedModel = {
+			...currentModel,
+			maxTokens: downgradedMaxTokens,
+		};
+
+		this._deps.agent.setModel(downgradedModel);
+		this._deps.onModelChange(downgradedModel);
+		this._removeLastAssistantError();
+
+		this._deps.emit({
+			type: "fallback_provider_switch",
+			from: `${currentModel.provider}/${currentModel.id} (maxTokens=${currentModel.maxTokens})`,
+			to: `${downgradedModel.provider}/${downgradedModel.id} (maxTokens=${downgradedModel.maxTokens})`,
+			reason: `credit-aware retry: provider affordable cap ${affordable} tokens`,
+		});
+
+		this._deps.emit({
+			type: "auto_retry_start",
+			attempt: this._retryAttempt + 1,
+			maxAttempts: this._deps.settingsManager.getRetrySettings().maxRetries,
+			delayMs: 0,
+			errorMessage: `${message.errorMessage} (reducing max tokens)`,
+		});
+
+		this._scheduleContinue(retryGeneration);
+		return true;
+	}
+
 	/**
 	 * Attempt to downgrade a long-context model (e.g. claude-opus-4-6[1m]) to its
 	 * base model (claude-opus-4-6) when the account lacks the long-context billing

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

@@ -0,0 +1,89 @@
+// pi-coding-agent / CredentialCooldownError unit tests
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { CredentialCooldownError } from "./sdk.js";
+
+// ─── CredentialCooldownError ──────────────────────────────────────────────────
+
+describe("CredentialCooldownError", () => {
+	it("is an instance of Error", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.ok(err instanceof Error);
+	});
+
+	it("has name set to CredentialCooldownError", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.equal(err.name, "CredentialCooldownError");
+	});
+
+	it("has code set to AUTH_COOLDOWN", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.equal(err.code, "AUTH_COOLDOWN");
+	});
+
+	it("message includes the provider name", () => {
+		const err = new CredentialCooldownError("openai");
+		assert.ok(
+			err.message.includes("openai"),
+			`Expected message to include provider "openai", got: ${err.message}`,
+		);
+	});
+
+	it("message mentions cooldown window", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.ok(
+			/cooldown window/i.test(err.message),
+			`Expected message to mention "cooldown window", got: ${err.message}`,
+		);
+	});
+
+	it("retryAfterMs is undefined when not provided", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.equal(err.retryAfterMs, undefined);
+	});
+
+	it("retryAfterMs holds the provided value when specified", () => {
+		const err = new CredentialCooldownError("anthropic", 30_000);
+		assert.equal(err.retryAfterMs, 30_000);
+	});
+
+	it("retryAfterMs is 0 when explicitly passed as 0", () => {
+		const err = new CredentialCooldownError("anthropic", 0);
+		assert.equal(err.retryAfterMs, 0);
+	});
+
+	it("code property is readonly and always AUTH_COOLDOWN regardless of provider", () => {
+		for (const provider of ["anthropic", "openai", "google", "openrouter"]) {
+			const err = new CredentialCooldownError(provider);
+			assert.equal(err.code, "AUTH_COOLDOWN", `code should be AUTH_COOLDOWN for provider "${provider}"`);
+		}
+	});
+
+	it("different providers produce different messages", () => {
+		const err1 = new CredentialCooldownError("anthropic");
+		const err2 = new CredentialCooldownError("openai");
+		assert.notEqual(err1.message, err2.message);
+	});
+
+	it("can be caught as an Error in a try/catch", () => {
+		let caught: unknown;
+		try {
+			throw new CredentialCooldownError("anthropic", 5_000);
+		} catch (e) {
+			caught = e;
+		}
+		assert.ok(caught instanceof Error);
+		assert.ok(caught instanceof CredentialCooldownError);
+		assert.equal((caught as CredentialCooldownError).retryAfterMs, 5_000);
+	});
+
+	it("code property is detectable via plain object check (cross-process pattern)", () => {
+		const err = new CredentialCooldownError("anthropic", 15_000);
+		// Simulate cross-process serialization: only plain properties survive JSON round-trip
+		const plain = { code: err.code, retryAfterMs: err.retryAfterMs, message: err.message };
+		assert.equal(plain.code, "AUTH_COOLDOWN");
+		assert.equal(plain.retryAfterMs, 15_000);
+	});
+});

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

@@ -1,4 +1,24 @@
 import { join } from "node:path";
+
+/**
+ * Structured error thrown when all credentials for a provider are in a
+ * backoff window.  Carries typed metadata so callers (e.g. the auto-loop)
+ * can make informed retry decisions instead of string-matching the message.
+ */
+export class CredentialCooldownError extends Error {
+	readonly code = "AUTH_COOLDOWN" as const;
+	/** Milliseconds until the earliest credential becomes available, or undefined if unknown. */
+	readonly retryAfterMs: number | undefined;
+
+	constructor(provider: string, retryAfterMs?: number) {
+		super(
+			`All credentials for "${provider}" are in a cooldown window. ` +
+				`Please wait a moment and try again, or switch to a different provider.`,
+		);
+		this.name = "CredentialCooldownError";
+		this.retryAfterMs = retryAfterMs;
+	}
+}
 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";
@@ -363,8 +383,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 			// Retry key resolution with backoff to handle transient network failures
 			// (e.g., OAuth token refresh failing due to brief connectivity loss).
+			// When credentials are in a cooldown window (e.g., after a 429), wait
+			// for the backoff to expire instead of using fixed delays that are
+			// shorter than the cooldown duration.
 			const maxAttempts = 3;
 			const baseDelayMs = 2000;
+			const maxCooldownWaitMs = 60_000; // Don't wait longer than 60s (skip quota-exhausted 30min backoffs)
 			for (let attempt = 1; attempt <= maxAttempts; attempt++) {
 				const key = await modelRegistry.getApiKeyForProvider(resolvedProvider);
 				if (key) return key;
@@ -379,7 +403,21 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				const isOAuth = model && modelRegistry.isUsingOAuth(model);
 				if (!hasAuth && !isOAuth) break;
 
-				// Wait with exponential backoff before retrying
+				// If credentials are in a cooldown window, wait for the earliest
+				// one to expire rather than using a fixed delay that's too short.
+				const backoffExpiry = modelRegistry.authStorage.getEarliestBackoffExpiry(resolvedProvider);
+				if (backoffExpiry !== undefined) {
+					const waitMs = backoffExpiry - Date.now() + 500; // 500ms buffer
+					if (waitMs > 0 && waitMs <= maxCooldownWaitMs) {
+						await new Promise(resolve => setTimeout(resolve, waitMs));
+						continue; // Retry immediately after cooldown clears
+					}
+					if (waitMs > maxCooldownWaitMs) {
+						break; // Quota-exhausted or very long backoff — don't block
+					}
+				}
+
+				// Standard exponential backoff for non-cooldown transient failures
 				await new Promise(resolve => setTimeout(resolve, baseDelayMs * attempt));
 			}
 
@@ -390,10 +428,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			// the retry handler and creating cascading error entries (#3429).
 			const hasAuth = modelRegistry.authStorage.hasAuth(resolvedProvider);
 			if (hasAuth) {
-				throw new Error(
-					`All credentials for "${resolvedProvider}" are in a cooldown window. ` +
-						`Please wait a moment and try again, or switch to a different provider.`,
-				);
+				const expiry = modelRegistry.authStorage.getEarliestBackoffExpiry(resolvedProvider);
+				const retryAfterMs = expiry !== undefined ? Math.max(0, expiry - Date.now()) : undefined;
+				throw new CredentialCooldownError(resolvedProvider, retryAfterMs);
 			}
 			const model = agent.state.model;
 			const isOAuth = model && modelRegistry.isUsingOAuth(model);
@@ -401,10 +438,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				// If credentials exist but are all in a backoff window (quota / rate-limit),
 				// surface a specific message instead of the misleading "Authentication failed".
 				if (modelRegistry.authStorage.areAllCredentialsBackedOff(resolvedProvider)) {
-					throw new Error(
-						`All credentials for "${resolvedProvider}" are in a cooldown window. ` +
-							`Please wait a moment and try again, or switch to a different provider.`,
-					);
+					const expiry = modelRegistry.authStorage.getEarliestBackoffExpiry(resolvedProvider);
+					const retryAfterMs = expiry !== undefined ? Math.max(0, expiry - Date.now()) : undefined;
+					throw new CredentialCooldownError(resolvedProvider, retryAfterMs);
 				}
 				throw new Error(
 					`Authentication failed for "${resolvedProvider}". ` +

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

@@ -176,6 +176,7 @@ export { DefaultResourceLoader } from "./core/resource-loader.js";
 export {
 	type CreateAgentSessionOptions,
 	type CreateAgentSessionResult,
+	CredentialCooldownError,
 	// Factory
 	createAgentSession,
 	createBashTool,

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/login-dialog.test.ts

@@ -0,0 +1,24 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { buildAuthUrlPresentation } from "../login-dialog.js";
+
+describe("LoginDialogComponent", () => {
+	test("shows the full OAuth URL when the hyperlink label is truncated", () => {
+		const presentation = buildAuthUrlPresentation(
+			"https://auth.example.com/device?code=ABCD-1234&callback=oauth&state=needs-full-visibility",
+			52,
+		);
+
+		assert.notEqual(
+			presentation.displayUrl,
+			"https://auth.example.com/device?code=ABCD-1234&callback=oauth&state=needs-full-visibility",
+			"narrow terminals should still truncate the hyperlink label",
+		);
+		assert.ok(presentation.fullUrlLines.length > 1, "truncated URLs should expose wrapped full-url lines");
+		assert.match(presentation.fullUrlLines[0] ?? "", /https:\/\/auth\.example\.com\/device\?code=ABCD-1234&/);
+		assert.match(
+			presentation.fullUrlLines[presentation.fullUrlLines.length - 1] ?? "",
+			/state=needs-full-visibility/,
+		);
+	});
+});

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

@@ -27,6 +27,26 @@ function renderTool(
 	return stripAnsi(component.render(120).join("\n"));
 }
 
+function renderToolCollapsed(
+	toolName: string,
+	args: Record<string, unknown>,
+	result?: {
+		content: Array<{ type: string; text?: string }>;
+		isError: boolean;
+		details?: Record<string, unknown>;
+	},
+): string {
+	const component = new ToolExecutionComponent(
+		toolName,
+		args,
+		{},
+		undefined,
+		{ requestRender() {} } as any,
+	);
+	if (result) component.updateResult(result);
+	return stripAnsi(component.render(120).join("\n"));
+}
+
 describe("ToolExecutionComponent", () => {
 	test("renders capitalized Claude Code Bash tool names with bash output instead of generic args JSON", () => {
 		const rendered = renderTool(
@@ -51,4 +71,56 @@ describe("ToolExecutionComponent", () => {
 		assert.match(rendered, /hello/);
 		assert.match(rendered, /world/);
 	});
+
+	test("generic fallback strips mcp__<server>__ prefix and shows server·tool title", () => {
+		const rendered = renderTool(
+			"mcp__context7__resolve_library_id",
+			{ name: "react" },
+			{ content: [{ type: "text", text: "react@18.3.1" }], isError: false },
+		);
+
+		assert.match(rendered, /context7\u00b7resolve_library_id/);
+		assert.doesNotMatch(rendered, /mcp__/);
+		assert.match(rendered, /name="react"/);
+		assert.match(rendered, /react@18\.3\.1/);
+	});
+
+	test("generic fallback renders compact key=value args for primitive args", () => {
+		const rendered = renderTool(
+			"some_unknown_tool",
+			{ count: 3, enabled: true, label: "hello" },
+		);
+
+		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("generic fallback truncates long output when collapsed", () => {
+		const longOutput = Array.from({ length: 25 }, (_, i) => `line ${i + 1}`).join("\n");
+		const rendered = renderToolCollapsed(
+			"mcp__demo__do_thing",
+			{ ok: true },
+			{ content: [{ type: "text", text: longOutput }], isError: false },
+		);
+
+		assert.match(rendered, /line 1\b/);
+		assert.match(rendered, /line 10\b/);
+		assert.doesNotMatch(rendered, /line 20\b/);
+		assert.match(rendered, /\(15 more lines/);
+	});
+
+	test("generic fallback falls back to truncated JSON for complex args", () => {
+		const rendered = renderTool(
+			"mcp__demo__nested",
+			{ payload: { nested: { deeply: ["a", "b", "c"] } }, name: "x" },
+		);
+
+		assert.match(rendered, /demo\u00b7nested/);
+		// Multi-line JSON dump for the complex payload
+		assert.match(rendered, /"payload"/);
+		assert.match(rendered, /"nested"/);
+	});
 });