gsd-pi 2.64.0 → 2.65.0-dev.16e10d7

package/packages/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-coding-agent",
-  "version": "2.64.0",
+  "version": "2.65.0",
   "description": "Coding agent CLI (vendored from pi-mono)",
   "type": "module",
   "piConfig": {

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

@@ -0,0 +1,64 @@
+// GSD-2 — Regression tests for #3616: tool list persistence across newSession() calls
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const source = readFileSync(
+	join(process.cwd(), "packages/pi-coding-agent/src/core/agent-session.ts"),
+	"utf-8",
+);
+
+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");
+
+		// Get the method body (up to the next top-level method)
+		const methodBody = source.slice(newSessionStart, newSessionStart + 3000);
+
+		// Verify the cwd-changed branch rebuilds tools
+		assert.ok(
+			methodBody.includes("if (this._cwd !== previousCwd)"),
+			"should have cwd-change guard",
+		);
+
+		// 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");
+
+		const elseBranch = methodBody.slice(elseIdx, elseIdx + 800);
+		assert.ok(
+			elseBranch.includes("_refreshToolRegistry"),
+			"else branch should call _refreshToolRegistry",
+		);
+		assert.ok(
+			elseBranch.includes("includeAllExtensionTools: true"),
+			"else branch should pass includeAllExtensionTools: true to restore narrowed tools",
+		);
+	});
+
+	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");
+	});
+
+	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);
+		assert.ok(
+			!resetBody.includes("tools"),
+			"reset() should NOT touch _state.tools — tools are managed by agent-session",
+		);
+	});
+});

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

@@ -1577,6 +1577,16 @@ export class AgentSession {
 				activeToolNames: this.getActiveToolNames(),
 				includeAllExtensionTools: true,
 			});
+		} else {
+			// Even when cwd hasn't changed, restore the full tool set (#3616).
+			// Extensions (e.g., discuss flows) may narrow the active tool list
+			// via setActiveTools() during a session. Without this refresh, the
+			// narrowed set persists into the next session — causing tools like
+			// gsd_plan_slice to be missing from auto-mode subagent sessions.
+			this._refreshToolRegistry({
+				activeToolNames: this.getActiveToolNames(),
+				includeAllExtensionTools: true,
+			});
 		}
 
 		// Run setup callback if provided (e.g., to append initial messages)

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

@@ -0,0 +1,42 @@
+// GSD-2 — Regression test for #3616: reload() must reset jiti extension loader cache
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const source = readFileSync(
+	join(process.cwd(), "packages/pi-coding-agent/src/core/resource-loader.ts"),
+	"utf-8",
+);
+
+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",
+		);
+	});
+
+	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);
+
+		const resetIdx = reloadBody.indexOf("resetExtensionLoaderCache()");
+		assert.ok(resetIdx >= 0, "reload() should call resetExtensionLoaderCache()");
+
+		const loadIdx = reloadBody.indexOf("loadExtensions(");
+		assert.ok(loadIdx >= 0, "reload() should call loadExtensions");
+
+		assert.ok(
+			resetIdx < loadIdx,
+			"resetExtensionLoaderCache() must be called BEFORE loadExtensions to ensure fresh modules",
+		);
+	});
+});

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

@@ -9,7 +9,7 @@ import type { ResourceCollision, ResourceDiagnostic } from "./diagnostics.js";
 export type { ResourceCollision, ResourceDiagnostic } from "./diagnostics.js";
 
 import { createEventBus, type EventBus } from "./event-bus.js";
-import { createExtensionRuntime, loadExtensionFromFactory, loadExtensions } from "./extensions/loader.js";
+import { createExtensionRuntime, loadExtensionFromFactory, loadExtensions, resetExtensionLoaderCache } from "./extensions/loader.js";
 import type { Extension, ExtensionFactory, ExtensionRuntime, LoadExtensionsResult } from "./extensions/types.js";
 import { DefaultPackageManager, type PathMetadata } from "./package-manager.js";
 import type { PromptTemplate } from "./prompt-templates.js";
@@ -320,6 +320,10 @@ export class DefaultResourceLoader implements ResourceLoader {
 	}
 
 	async reload(): Promise<void> {
+		// Invalidate the shared jiti module cache so updated extension code
+		// on disk is re-compiled instead of served from the stale cache (#3616).
+		resetExtensionLoaderCache();
+
 		const resolvedPaths = await this.packageManager.resolve();
 		const cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
 			temporary: true,

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

@@ -278,5 +278,85 @@ describe("RetryHandler — long-context entitlement 429 (#2803)", () => {
 			const msg = errorMessage("Extra usage is required for long context requests.");
 			assert.equal(handler.isRetryableError(msg), true);
 		});
+
+		it("does NOT consider credential cooldown error as retryable (#3429)", () => {
+			// The credential cooldown message from getApiKey() must not re-enter
+			// the retry handler. Re-entry creates cascading empty error entries
+			// in the session file that break resume.
+			const { deps } = createMockDeps();
+			const handler = new RetryHandler(deps);
+			const msg = errorMessage(
+				'All credentials for "anthropic" are in a cooldown window. ' +
+				'Please wait a moment and try again, or switch to a different provider.',
+			);
+			assert.equal(handler.isRetryableError(msg), false);
+		});
+	});
+
+	describe("quota_exhausted credential backoff (#3430)", () => {
+		it("does NOT call markUsageLimitReached for quota_exhausted errors", async () => {
+			// "Extra usage is required" is an account-level billing gate.
+			// Backing off the credential for 30 minutes blocks all provider
+			// requests and has no effect on the billing condition.
+			const { deps, markUsageLimitReached } = createMockDeps({
+				model: createMockModel("anthropic", "claude-opus-4-6[1m]"),
+				markUsageLimitReachedResult: false,
+				fallbackResult: null,
+				findModelResult: () => undefined,
+			});
+
+			const handler = new RetryHandler(deps);
+			const msg = errorMessage(
+				'429 {"type":"error","error":{"type":"rate_limit_error","message":"Extra usage is required for long context requests."}}',
+			);
+
+			await handler.handleRetryableError(msg);
+
+			assert.equal(
+				markUsageLimitReached.mock.calls.length,
+				0,
+				"markUsageLimitReached must NOT be called for quota_exhausted errors",
+			);
+		});
+
+		it("still calls markUsageLimitReached for regular rate_limit errors", async () => {
+			const { deps, markUsageLimitReached } = createMockDeps({
+				model: createMockModel("anthropic", "claude-opus-4-6"),
+				markUsageLimitReachedResult: false,
+				fallbackResult: null,
+			});
+
+			const handler = new RetryHandler(deps);
+			const msg = errorMessage("429 Too Many Requests");
+
+			await handler.handleRetryableError(msg);
+
+			assert.equal(
+				markUsageLimitReached.mock.calls.length,
+				1,
+				"markUsageLimitReached should be called for rate_limit errors",
+			);
+		});
+
+		it("still tries cross-provider fallback for quota_exhausted without credential backoff", async () => {
+			const fallbackModel = createMockModel("openai", "gpt-4o");
+			const { deps, markUsageLimitReached, continueFn } = createMockDeps({
+				model: createMockModel("anthropic", "claude-opus-4-6[1m]"),
+				markUsageLimitReachedResult: false,
+				fallbackResult: { model: fallbackModel, reason: "cross-provider fallback" },
+			});
+
+			const handler = new RetryHandler(deps);
+			const msg = errorMessage("Extra usage is required for long context requests.");
+
+			const result = await handler.handleRetryableError(msg);
+
+			assert.equal(result, true, "should retry with fallback provider");
+			assert.equal(
+				markUsageLimitReached.mock.calls.length,
+				0,
+				"should NOT back off credentials before trying fallback",
+			);
+		});
 	});
 });

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

@@ -109,7 +109,11 @@ export class RetryHandler {
 		if (isContextOverflow(message, contextWindow)) return false;
 
 		const err = message.errorMessage;
-		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|temporarily backed off|extra usage is required/i.test(
+		// "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|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/i.test(
 			err,
 		);
 	}
@@ -139,34 +143,42 @@ export class RetryHandler {
 		const retryGeneration = this._retryGeneration;
 		if (this._deps.getModel() && message.errorMessage) {
 			const errorType = this._classifyErrorType(message.errorMessage);
-			const isCredentialError = errorType === "rate_limit" || errorType === "quota_exhausted";
-			const hasAlternate =
-				isCredentialError &&
-				this._deps.modelRegistry.authStorage.markUsageLimitReached(
-					this._deps.getModel()!.provider,
-					this._deps.getSessionId(),
-					{ errorType },
-				);
-
-			if (hasAlternate) {
-				this._removeLastAssistantError();
+			const isRateLimit = errorType === "rate_limit";
+			const isQuotaError = errorType === "quota_exhausted";
+
+			// 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
+			// and the 30-minute backoff blocks all provider requests needlessly.
+			if (isRateLimit) {
+				const hasAlternate =
+					this._deps.modelRegistry.authStorage.markUsageLimitReached(
+						this._deps.getModel()!.provider,
+						this._deps.getSessionId(),
+						{ errorType },
+					);
+
+				if (hasAlternate) {
+					this._removeLastAssistantError();
 
-				this._deps.emit({
-					type: "auto_retry_start",
-					attempt: this._retryAttempt + 1,
-					maxAttempts: settings.maxRetries,
-					delayMs: 0,
-					errorMessage: `${message.errorMessage} (switching credential)`,
-				});
+					this._deps.emit({
+						type: "auto_retry_start",
+						attempt: this._retryAttempt + 1,
+						maxAttempts: settings.maxRetries,
+						delayMs: 0,
+						errorMessage: `${message.errorMessage} (switching credential)`,
+					});
 
-				// Retry immediately with the next credential - don't increment _retryAttempt
-				this._scheduleContinue(retryGeneration);
+					// Retry immediately with the next credential - don't increment _retryAttempt
+					this._scheduleContinue(retryGeneration);
 
-				return true;
+					return true;
+				}
 			}
 
-			// All credentials are backed off. Try cross-provider fallback before giving up.
-			if (isCredentialError) {
+			// Cross-provider fallback — for rate limits with all creds backed off,
+			// or quota errors (which skip credential backoff entirely).
+			if (isRateLimit || isQuotaError) {
 				const fallbackResult = await this._deps.fallbackResolver.findFallback(
 					this._deps.getModel()!,
 					errorType,
@@ -200,7 +212,7 @@ export class RetryHandler {
 				}
 
 				// No fallback available either
-				if (errorType === "quota_exhausted") {
+				if (isQuotaError) {
 					// Try long-context model downgrade ([1m] → base) before giving up
 					const downgraded = this._tryLongContextDowngrade(message, retryGeneration);
 					if (downgraded) return true;

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

@@ -371,16 +371,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				await new Promise(resolve => setTimeout(resolve, baseDelayMs * attempt));
 			}
 
-			// All retries exhausted — throw descriptive error
-			// Check if credentials exist but are temporarily backed off
-			// (e.g., after a 429 quota exhaustion). Provide a specific error
-			// so the retry handler knows this is transient, not a permanent
-			// auth failure.
+			// All retries exhausted — throw descriptive error.
+			// Check if credentials exist but are temporarily in a backoff window
+			// (e.g., after a 429). This message intentionally avoids phrases like
+			// "rate limit" / "429" to prevent isRetryableError() from re-entering
+			// 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 temporarily backed off due to rate limiting. ` +
-						`The request will be retried automatically when backoff expires.`,
+					`All credentials for "${resolvedProvider}" are in a cooldown window. ` +
+						`Please wait a moment and try again, or switch to a different provider.`,
 				);
 			}
 			const model = agent.state.model;
@@ -390,8 +390,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				// surface a specific message instead of the misleading "Authentication failed".
 				if (modelRegistry.authStorage.areAllCredentialsBackedOff(resolvedProvider)) {
 					throw new Error(
-						`Rate limit in effect for "${resolvedProvider}". ` +
-							`Please wait before retrying or switch to a different model.`,
+						`All credentials for "${resolvedProvider}" are in a cooldown window. ` +
+							`Please wait a moment and try again, or switch to a different provider.`,
 					);
 				}
 				throw new Error(

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

@@ -43,6 +43,7 @@ export class ProviderManagerComponent extends Container implements Focusable {
 	private modelsJsonWriter: ModelsJsonWriter;
 	private onDone: () => void;
 	private onDiscover: (provider: string) => void;
+	private onSetupAuth: (provider: string) => void;
 	private confirmingRemove = false;
 	private hintsContainer: Container;
 
@@ -52,6 +53,7 @@ export class ProviderManagerComponent extends Container implements Focusable {
 		modelRegistry: ModelRegistry,
 		onDone: () => void,
 		onDiscover: (provider: string) => void,
+		onSetupAuth?: (provider: string) => void,
 	) {
 		super();
 
@@ -61,6 +63,7 @@ export class ProviderManagerComponent extends Container implements Focusable {
 		this.modelsJsonWriter = new ModelsJsonWriter(this.modelRegistry.modelsJsonPath);
 		this.onDone = onDone;
 		this.onDiscover = onDiscover;
+		this.onSetupAuth = onSetupAuth ?? (() => {});
 
 		// Header
 		this.addChild(new Text(theme.fg("accent", "Provider Manager"), 0, 0));
@@ -125,6 +128,7 @@ export class ProviderManagerComponent extends Container implements Focusable {
 			this.hintsContainer.addChild(new Text(hints, 0, 0));
 		} else {
 			const hints = [
+				rawKeyHint("enter", "setup auth"),
 				rawKeyHint("d", "discover"),
 				rawKeyHint("r", "remove auth"),
 				rawKeyHint("esc", "close"),
@@ -203,6 +207,12 @@ export class ProviderManagerComponent extends Container implements Focusable {
 					this.tui.requestRender();
 				}
 			}
+		} else if (kb.matches(keyData, "selectConfirm")) {
+			// Enter key → initiate auth setup for the selected provider (#3579)
+			const provider = this.providers[this.selectedIndex];
+			if (provider) {
+				this.onSetupAuth(provider.name);
+			}
 		}
 	}
 }

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

@@ -3,6 +3,7 @@ import {
 	Container,
 	getCapabilities,
 	Image,
+	type ImageDimensions,
 	imageFallback,
 	Spacer,
 	Text,
@@ -88,6 +89,9 @@ export class ToolExecutionComponent extends Container {
 	private editDiffArgsKey?: string; // Track which args the preview is for
 	// Cached converted images for Kitty protocol (which requires PNG), keyed by index
 	private convertedImages: Map<number, { data: string; mimeType: string }> = new Map();
+	// Cached resolved image dimensions to avoid re-triggering async parsing
+	// when updateDisplay() recreates Image components (#3455).
+	private resolvedImageDimensions: Map<number, ImageDimensions> = new Map();
 	// Incremental syntax highlighting cache for write tool call args
 	private writeHighlightCache?: WriteHighlightCache;
 	// When true, this component intentionally renders no lines
@@ -137,6 +141,15 @@ export class ToolExecutionComponent extends Container {
 		return isBuiltInName && !hasCustomRenderers;
 	}
 
+	dispose(): void {
+		this.convertedImages.clear();
+		this.imageComponents = [];
+		this.imageSpacers = [];
+		this.editDiffPreview = undefined;
+		this.writeHighlightCache = undefined;
+		this.result = undefined;
+	}
+
 	updateArgs(args: any): void {
 		this.args = args;
 		if (this.toolName === "write" && this.isPartial) {
@@ -472,16 +485,28 @@ export class ToolExecutionComponent extends Container {
 					const spacer = new Spacer(1);
 					this.addChild(spacer);
 					this.imageSpacers.push(spacer);
+					// Pass cached dimensions to avoid re-triggering async parsing
+					// when updateDisplay() recreates Image components (#3455).
+					const cachedDims = this.resolvedImageDimensions.get(i);
 					const imageComponent = new Image(
 						imageData,
 						imageMimeType,
 						{ fallbackColor: (s: string) => theme.fg("toolOutput", s) },
 						{ maxWidthCells: 60 },
+						cachedDims,
 					);
-					imageComponent.setOnDimensionsResolved(() => {
-						this.updateDisplay();
-						this.ui.requestRender();
-					});
+					if (!cachedDims) {
+						const imgIdx = i;
+						imageComponent.setOnDimensionsResolved(() => {
+							// Cache resolved dimensions so future updateDisplay() calls
+							// don't re-trigger async parsing → infinite loop (#3455).
+							const dims = imageComponent.getDimensions?.();
+							if (dims) this.resolvedImageDimensions.set(imgIdx, dims);
+							// Just re-render — don't call updateDisplay() which would
+							// destroy and recreate all Image components.
+							this.ui.requestRender();
+						});
+					}
 					this.imageComponents.push(imageComponent);
 					this.addChild(imageComponent);
 				}

package/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.test.ts

@@ -154,3 +154,30 @@ test("input-controller: truly unknown slash commands stop before session.prompt"
 	);
 	assert.equal(getEditorText(), "", "unknown slash commands should clear the editor after showing the error");
 });
+
+test("input-controller: absolute file paths are not treated as slash commands (#3478)", async () => {
+	const { host, prompted, errors } = createHost();
+
+	await host.defaultEditor.onSubmit("/Users/name/Desktop/screenshot.png");
+
+	assert.deepEqual(errors, [], "file paths should not trigger unknown command error");
+	assert.deepEqual(prompted, ["/Users/name/Desktop/screenshot.png"], "file paths should be sent as plain input");
+});
+
+test("input-controller: Linux absolute paths are not treated as slash commands (#3478)", async () => {
+	const { host, prompted, errors } = createHost();
+
+	await host.defaultEditor.onSubmit("/home/user/documents/file.txt");
+
+	assert.deepEqual(errors, [], "Linux paths should not trigger unknown command error");
+	assert.deepEqual(prompted, ["/home/user/documents/file.txt"], "Linux paths should be sent as plain input");
+});
+
+test("input-controller: /tmp paths are not treated as slash commands (#3478)", async () => {
+	const { host, prompted, errors } = createHost();
+
+	await host.defaultEditor.onSubmit("/tmp/some-file.log");
+
+	assert.deepEqual(errors, []);
+	assert.deepEqual(prompted, ["/tmp/some-file.log"]);
+});

package/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.ts

@@ -18,7 +18,7 @@ export function setupEditorSubmitHandler(host: InteractiveModeStateHost & {
 		text = text.trim();
 		if (!text) return;
 
-		if (text.startsWith("/")) {
+		if (text.startsWith("/") && !looksLikeFilePath(text)) {
 			const handled = await dispatchSlashCommand(text, host.getSlashCommandContext());
 			if (handled) {
 				host.editor.setText("");
@@ -104,3 +104,18 @@ export function setupEditorSubmitHandler(host: InteractiveModeStateHost & {
 		}
 	};
 }
+
+/**
+ * Distinguish absolute file paths from slash commands (#3478).
+ * Drag-and-drop inserts paths like "/Users/name/Desktop/file.png" which
+ * should be treated as plain text input, not a /Users command.
+ *
+ * Heuristic: a slash command is a single token like "/help" or "/gsd auto".
+ * File paths have a second "/" within the first token (e.g., "/Users/...").
+ */
+function looksLikeFilePath(text: string): boolean {
+	const firstToken = text.split(/\s/)[0];
+	// Slash commands: /help, /gsd, /commit — single "/" at start only.
+	// File paths: /Users/name/file, /home/user/file, /tmp/x — contain "/" after position 0.
+	return firstToken.indexOf("/", 1) !== -1;
+}

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

@@ -7,6 +7,7 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { listDescendants } from "@gsd/native";
 import type { AgentMessage } from "@gsd/pi-agent-core";
 import type { AssistantMessage, ImageContent, Message, Model, OAuthProviderId } from "@gsd/pi-ai";
 import type {
@@ -157,6 +158,10 @@ export interface InteractiveModeOptions {
 }
 
 export class InteractiveMode {
+	// Cap rendered chat components to prevent unbounded memory/CPU growth.
+	// Only render-components are removed — session transcript stays on disk.
+	private static readonly MAX_CHAT_COMPONENTS = 100;
+
 	private session: AgentSession;
 	private ui: TUI;
 	private chatContainer: Container;
@@ -2138,6 +2143,18 @@ export class InteractiveMode {
 				const _exhaustive: never = message;
 			}
 		}
+		this.trimChatHistory();
+	}
+
+	/**
+	 * Remove oldest components when chat exceeds MAX_CHAT_COMPONENTS.
+	 * Only render-components are removed — session data stays in SessionManager.
+	 */
+	private trimChatHistory(): void {
+		while (this.chatContainer.children.length > InteractiveMode.MAX_CHAT_COMPONENTS) {
+			const oldest = this.chatContainer.children[0];
+			this.chatContainer.removeChild(oldest);
+		}
 	}
 
 	/**
@@ -2232,6 +2249,7 @@ export class InteractiveMode {
 		}
 
 		this.pendingTools.clear();
+		this.trimChatHistory();
 		this.ui.requestRender();
 	}
 
@@ -2325,6 +2343,21 @@ export class InteractiveMode {
 		if (shutdownBehavior === "stop_ui") {
 			return;
 		}
+
+		// Kill ALL descendant processes to prevent orphans (next-server, pnpm dev, etc.)
+		try {
+			const descendants = listDescendants(process.pid);
+			for (const childPid of descendants) {
+				try { process.kill(childPid, "SIGTERM"); } catch {}
+			}
+			if (descendants.length > 0) {
+				await new Promise(resolve => setTimeout(resolve, 500));
+				for (const childPid of descendants) {
+					try { process.kill(childPid, "SIGKILL"); } catch {}
+				}
+			}
+		} catch {}
+
 		process.exit(0);
 	}
 
@@ -3378,6 +3411,11 @@ export class InteractiveMode {
 					done();
 					this.ui.requestRender();
 				},
+				async (provider: string) => {
+					// Enter key → auth setup for selected provider (#3579)
+					done();
+					await this.showLoginDialog(provider);
+				},
 			);
 			return { component, focus: component };
 		});

package/packages/pi-tui/dist/__tests__/overlay-layout.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=overlay-layout.test.d.ts.map

package/packages/pi-tui/dist/__tests__/overlay-layout.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-layout.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/overlay-layout.test.ts"],"names":[],"mappings":""}