lsd-pi 1.2.4 → 1.3.6

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

@@ -143,6 +143,7 @@ test("AgentSession switches supported Anthropic models to adaptive when the sett
 	const settingsManager = SettingsManager.inMemory();
 	settingsManager.setDefaultModelAndProvider("openai", "gpt-5.4");
 	settingsManager.setDefaultThinkingLevel("high");
+	settingsManager.setClientAdaptiveByDefault(false);
 	settingsManager.setAnthropicAdaptiveByDefault(true);
 	const sessionManager = SessionManager.inMemory(tempDir);
 	const resourceLoader = new DefaultResourceLoader({
@@ -180,3 +181,47 @@ test("AgentSession switches supported Anthropic models to adaptive when the sett
 	assert.equal(session.thinkingLevel, "adaptive");
 	session.dispose();
 });
+
+test("createAgentSession defaults to adaptive for reasoning models when clientAdaptiveByDefault is enabled", async () => {
+	const tempDir = join(
+		process.cwd(),
+		".tmp-tests",
+		`sdk-client-adaptive-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(tempDir, { recursive: true });
+	tempDirs.push(tempDir);
+
+	const authStorage = AuthStorage.inMemory({
+		openai: { type: "api_key", key: "test-openai-key" },
+	});
+	const modelRegistry = new ModelRegistry(authStorage, join(tempDir, "models.json"));
+	const settingsManager = SettingsManager.inMemory();
+	settingsManager.setDefaultModelAndProvider("openai", "gpt-5.4");
+	settingsManager.setDefaultThinkingLevel("high");
+	settingsManager.setClientAdaptiveByDefault(true);
+	const sessionManager = SessionManager.inMemory(tempDir);
+	const resourceLoader = new DefaultResourceLoader({
+		cwd: tempDir,
+		agentDir: tempDir,
+		settingsManager,
+		noExtensions: true,
+		noSkills: true,
+		noPromptTemplates: true,
+		noThemes: true,
+	});
+
+	const { session } = await createAgentSession({
+		cwd: tempDir,
+		agentDir: tempDir,
+		authStorage,
+		modelRegistry,
+		settingsManager,
+		sessionManager,
+		resourceLoader,
+	});
+
+	assert.equal(session.model?.provider, "openai");
+	assert.equal(session.model?.id, "gpt-5.4");
+	assert.equal(session.thinkingLevel, "adaptive");
+	session.dispose();
+});

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

@@ -144,11 +144,15 @@ function shouldPreferAdaptiveThinkingByDefault(
     model: Model<any> | undefined,
     settingsManager: SettingsManager,
 ): boolean {
-    return !!model &&
-        model.provider === "anthropic" &&
-        model.reasoning === true &&
-        settingsManager.getAnthropicAdaptiveByDefault() &&
-        supportsAdaptiveThinking(model.id);
+    if (!model || model.reasoning !== true) {
+        return false;
+    }
+
+    if (model.provider === "anthropic" && supportsAdaptiveThinking(model.id)) {
+        return settingsManager.getClientAdaptiveByDefault() || settingsManager.getAnthropicAdaptiveByDefault();
+    }
+
+    return settingsManager.getClientAdaptiveByDefault() && !!settingsManager.getAdaptiveClassifierModel();
 }
 
 /**
@@ -278,9 +282,23 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
     const balancedToolNames = editMode === "hashline"
         ? ["hashline_read", "bash", "hashline_edit", "write", "lsp", "bg_shell", "tool_search", "tool_enable", "Skill", "subagent", "await_subagent", "ask_user_questions"]
         : ["read", "bash", "edit", "write", "lsp", "bg_shell", "tool_search", "tool_enable", "Skill", "subagent", "await_subagent", "ask_user_questions"];
+    const standardToolNames = [
+        "read", "bash", "edit", "write", "lsp", "grep", "find", "ls",
+        "bg_shell",
+        "web_search", "fetch_page",
+        "resolve_library", "get_library_docs",
+        "subagent", "await_subagent", "Skill",
+        "ask_user_questions", "secure_env_collect",
+        "browser_navigate", "browser_click", "browser_type", "browser_screenshot",
+        "browser_scroll", "browser_key_press", "browser_evaluate",
+        "browser_find", "browser_wait_for", "browser_close",
+        "browser_assert", "browser_batch",
+        "tool_search", "tool_enable",
+    ];
+    const profileToolNames = toolProfile === "standard" ? standardToolNames : balancedToolNames;
     const defaultActiveToolNames: string[] = toolProfile === "full"
         ? []
-        : balancedToolNames;
+        : profileToolNames;
     const initialActiveToolNames: string[] = options.tools
         ? options.tools.map((t) => t.name).filter((n): n is string => typeof n === "string" && n in allTools)
         : defaultActiveToolNames;
@@ -326,7 +344,17 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
     const extensionRunnerRef: { current?: ExtensionRunner } = {};
 
-    agent = new Agent({
+    // Resolve the adaptive classifier model for LLM-based adaptive thinking classification.
+    const adaptiveClassifierModelRef = settingsManager.getAdaptiveClassifierModel();
+    let adaptiveClassifierModel: Model<any> | undefined;
+    if (adaptiveClassifierModelRef) {
+        const parts = adaptiveClassifierModelRef.split("/");
+        if (parts.length === 2) {
+            adaptiveClassifierModel = modelRegistry.find(parts[0]!, parts[1]!) ?? undefined;
+        }
+    }
+
+    const agentOptions: ConstructorParameters<typeof Agent>[0] & { getFastMode?: () => boolean } = {
         initialState: {
             systemPrompt: "",
             model,
@@ -341,6 +369,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
             }
             return runner.emitBeforeProviderRequest(payload, currentModel);
         },
+        getFastMode: () => settingsManager.getFastMode(),
         sessionId: sessionManager.getSessionId(),
         transformContext: async (messages) => {
             const runner = extensionRunnerRef.current;
@@ -353,6 +382,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
         thinkingBudgets: settingsManager.getThinkingBudgets(),
         maxRetryDelayMs: settingsManager.getRetrySettings().maxDelayMs,
         externalToolExecution: (m) => modelRegistry.getProviderAuthMode(m.provider) === "externalCli",
+        adaptiveClassifierModel,
         getApiKey: async (provider) => {
             // Use the provider argument from the in-flight request;
             // agent.state.model may already be switched mid-turn.
@@ -422,7 +452,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
                 `Set an API key environment variable or run '/login ${resolvedProvider}'.`,
             );
         },
-    });
+    };
+    agent = new Agent(agentOptions);
 
     // Restore messages if session has existing data
     if (hasExistingSession) {

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

@@ -59,10 +59,18 @@ export interface SessionHeader {
 	timestamp: string;
 	cwd: string;
 	parentSession?: string;
+	subagentName?: string;
+	subagentTask?: string;
+	subagentSystemPrompt?: string;
+	subagentTools?: string[];
 }
 
 export interface NewSessionOptions {
 	parentSession?: string;
+	subagentName?: string;
+	subagentTask?: string;
+	subagentSystemPrompt?: string;
+	subagentTools?: string[];
 }
 
 export interface SessionEntryBase {
@@ -915,6 +923,10 @@ export class SessionManager {
 			timestamp,
 			cwd: this.cwd,
 			parentSession: options?.parentSession,
+			subagentName: options?.subagentName,
+			subagentTask: options?.subagentTask,
+			subagentSystemPrompt: options?.subagentSystemPrompt,
+			subagentTools: options?.subagentTools,
 		};
 		this.fileEntries = [header];
 		this.sessionEntries = [];

package/packages/pi-coding-agent/src/core/settings-manager.fast-mode.test.ts

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+
+import { SettingsManager } from "./settings-manager.js";
+
+describe("SettingsManager fastMode", () => {
+	it("defaults fastMode to false", () => {
+		const manager = SettingsManager.inMemory();
+		assert.equal(manager.getFastMode(), false);
+	});
+
+	it("persists fastMode changes to settings.json", async () => {
+		const root = mkdtempSync(join(tmpdir(), "pi-fast-mode-settings-"));
+		const cwd = join(root, "project");
+		const agentDir = join(root, "agent");
+
+		try {
+			const manager = SettingsManager.create(cwd, agentDir);
+			assert.equal(manager.getFastMode(), false);
+
+			manager.setFastMode(true);
+			await manager.flush();
+
+			const rawEnabled = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf8")) as {
+				fastMode?: boolean;
+			};
+			assert.equal(rawEnabled.fastMode, true);
+
+			const reloaded = SettingsManager.create(cwd, agentDir);
+			assert.equal(reloaded.getFastMode(), true);
+
+			reloaded.setFastMode(false);
+			await reloaded.flush();
+
+			const rawDisabled = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf8")) as {
+				fastMode?: boolean;
+			};
+			assert.equal(rawDisabled.fastMode, false);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -41,7 +41,6 @@ export interface ImageSettings {
 }
 
 export interface ThinkingBudgetsSettings {
-	minimal?: number;
 	low?: number;
 	medium?: number;
 	high?: number;
@@ -131,8 +130,10 @@ export interface Settings {
 	autoSwitchPlanModel?: boolean; // default: false — enable opusplan-style model switching (auto-switch to reasoning model on entry, new-session option on approval)
 	permissionMode?: "danger-full-access" | "accept-on-edit" | "auto" | "plan";
 	classifierModel?: string;
-	defaultThinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive";
+	adaptiveClassifierModel?: string;
+	defaultThinkingLevel?: "off" | "low" | "medium" | "high" | "xhigh" | "adaptive";
 	anthropicAdaptiveByDefault?: boolean; // default: false — prefer adaptive thinking when using supported Anthropic models
+	clientAdaptiveByDefault?: boolean; // default: true — prefer adaptive thinking for any reasoning-capable model
 	transport?: TransportSetting; // default: "sse"
 	steeringMode?: "all" | "one-at-a-time";
 	followUpMode?: "all" | "one-at-a-time";
@@ -153,11 +154,12 @@ export interface Settings {
 	themes?: string[]; // Array of local theme file paths or directories
 	enableSkillCommands?: boolean; // default: true - register skills as /skill:name commands
 	toolSearch?: boolean; // legacy boolean toggle from deprecated minimal profile; retained for migration only
-	toolProfile?: "balanced" | "full"; // default: "balanced"
+	toolProfile?: "balanced" | "standard" | "full"; // default: "balanced"
 	terminal?: TerminalSettings;
 	images?: ImageSettings;
 	enabledModels?: string[]; // Model patterns for cycling (same format as --models CLI flag)
 	codexRotate?: boolean; // Enable the bundled codex-rotate extension (default: false)
+	fastMode?: boolean; // Enable OpenAI/Codex fast tier routing (priority service tier where supported)
 	cacheTimer?: boolean; // Show elapsed time since last response in the footer (default: true)
 	pinLastPrompt?: boolean; // Pin last sent prompt above the editor as a reminder (default: false)
 	doubleEscapeAction?: "fork" | "tree" | "none"; // Action for double-escape with empty editor (default: "tree")
@@ -185,6 +187,7 @@ export interface Settings {
 	editorScheme?: "auto" | "vscode" | "cursor" | "zed" | "jetbrains" | "sublime" | "file"; // URI scheme for Cmd+click file links (default: "auto")
 	autoDream?: boolean; // default: false — enable automatic memory consolidation (dream) after sessions
 	autoMemory?: boolean; // default: false — enable automatic memory extraction from session transcripts
+	notificationSound?: boolean; // default: false — play terminal bell when agent finishes responding
 	telegramLiveRelayAutoConnect?: boolean; // default: false — auto-run /lsd telegram connect on startup
 }
 
@@ -752,6 +755,10 @@ export class SettingsManager {
 		return this.settings.classifierModel;
 	}
 
+	getAdaptiveClassifierModel(): string | undefined {
+		return this.settings.adaptiveClassifierModel;
+	}
+
 	setDefaultProvider(provider: string): void {
 		this.setScopedSetting("defaultProvider", provider);
 	}
@@ -839,6 +846,16 @@ export class SettingsManager {
 		this.setGlobalSetting("classifierModel", modelRef);
 	}
 
+	setAdaptiveClassifierModel(modelRef: string | undefined): void {
+		if (modelRef === undefined) {
+			delete this.globalSettings.adaptiveClassifierModel;
+			this.markModified("adaptiveClassifierModel");
+			this.save();
+			return;
+		}
+		this.setGlobalSetting("adaptiveClassifierModel", modelRef);
+	}
+
 	setDefaultModelAndProvider(provider: string, modelId: string): void {
 		if (this.hasProjectSettings()) {
 			this.projectSettings.defaultProvider = provider;
@@ -893,11 +910,11 @@ export class SettingsManager {
 		this.setGlobalSetting("themeAccent", accent);
 	}
 
-	getDefaultThinkingLevel(): "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive" | undefined {
+	getDefaultThinkingLevel(): "off" | "low" | "medium" | "high" | "xhigh" | "adaptive" | undefined {
 		return this.settings.defaultThinkingLevel;
 	}
 
-	setDefaultThinkingLevel(level: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive"): void {
+	setDefaultThinkingLevel(level: "off" | "low" | "medium" | "high" | "xhigh" | "adaptive"): void {
 		this.setGlobalSetting("defaultThinkingLevel", level);
 	}
 
@@ -909,6 +926,14 @@ export class SettingsManager {
 		this.setGlobalSetting("anthropicAdaptiveByDefault", enabled);
 	}
 
+	getClientAdaptiveByDefault(): boolean {
+		return this.settings.clientAdaptiveByDefault ?? true;
+	}
+
+	setClientAdaptiveByDefault(enabled: boolean): void {
+		this.setGlobalSetting("clientAdaptiveByDefault", enabled);
+	}
+
 	getTransport(): TransportSetting {
 		return this.settings.transport ?? "sse";
 	}
@@ -1094,15 +1119,15 @@ export class SettingsManager {
 		this.setGlobalSetting("enableSkillCommands", enabled);
 	}
 
-	getToolProfile(): "balanced" | "full" {
+	getToolProfile(): "balanced" | "standard" | "full" {
 		const profile = this.settings.toolProfile;
-		if (profile === "balanced" || profile === "full") return profile;
+		if (profile === "balanced" || profile === "standard" || profile === "full") return profile;
 		// Migrate legacy minimal/toolSearch settings to balanced.
 		if (this.settings.toolSearch !== undefined) return "balanced";
-		return "full";
+		return "standard";
 	}
 
-	setToolProfile(profile: "balanced" | "full"): void {
+	setToolProfile(profile: "balanced" | "standard" | "full"): void {
 		this.setGlobalSetting("toolProfile", profile);
 		// Keep legacy field in sync with deprecated minimal mode removal.
 		this.setGlobalSetting("toolSearch", false);
@@ -1164,6 +1189,14 @@ export class SettingsManager {
 		this.setGlobalSetting("codexRotate", enabled);
 	}
 
+	getFastMode(): boolean {
+		return this.settings.fastMode ?? false;
+	}
+
+	setFastMode(enabled: boolean): void {
+		this.setGlobalSetting("fastMode", enabled);
+	}
+
 	getCacheTimer(): boolean {
 		return this.settings.cacheTimer ?? true;
 	}
@@ -1422,6 +1455,14 @@ export class SettingsManager {
 		this.setGlobalSetting("autoMemory", enabled);
 	}
 
+	getNotificationSound(): boolean {
+		return this.settings.notificationSound ?? false;
+	}
+
+	setNotificationSound(enabled: boolean): void {
+		this.setGlobalSetting("notificationSound", enabled);
+	}
+
 	getTelegramLiveRelayAutoConnect(): boolean {
 		return this.settings.telegramLiveRelayAutoConnect ?? false;
 	}

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

@@ -332,9 +332,12 @@ export function formatSkillsForPrompt(skills: Skill[]): string {
 	];
 
 	for (const skill of visibleSkills) {
+		const cappedDescription = skill.description.length > 200
+			? skill.description.slice(0, 197) + "..."
+			: skill.description;
 		lines.push("  <skill>");
 		lines.push(`    <name>${escapeXml(skill.name)}</name>`);
-		lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+		lines.push(`    <description>${escapeXml(cappedDescription)}</description>`);
 		lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
 		lines.push("  </skill>");
 	}

package/packages/pi-coding-agent/src/core/slash-commands.ts

@@ -27,6 +27,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	{ name: "session", description: "Show session info and stats" },
 	{ name: "changelog", description: "Show changelog entries" },
 	{ name: "hotkeys", description: "Show all keyboard shortcuts" },
+	{ name: "btw", description: "Ask a side question without interrupting the current task" },
 	{ name: "fork", description: "Create a new fork from a previous message" },
 	{ name: "tree", description: "Navigate session tree (switch branches)" },
 	{ name: "provider", description: "Manage provider configuration" },
@@ -40,7 +41,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	{ name: "compact", description: "Manually compact the session context" },
 	{ name: "resume", description: "Resume a different session" },
 	{ name: "reload", description: "Reload extensions, skills, prompts, and themes" },
-	{ name: "thinking", description: "Set thinking level (off/minimal/low/medium/high/xhigh)" },
+	{ name: "thinking", description: "Set thinking level (off/low/medium/high/xhigh)" },
 	{ name: "edit-mode", description: "Toggle edit mode (standard/hashline)" },
 	{ name: "terminal", description: "Run a shell command directly (e.g. /terminal ping -c3 1.1.1.1)" },
 	{ name: "quit", description: "Quit pi" },

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

@@ -149,14 +149,22 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	const hasLsp = tools.includes("lsp");
 
 	// Priority-ordered compact guidelines
-	addGuideline("Be concise. Prefer short, direct answers over preamble.");
+	addGuideline("Terse output. All technical substance stays. Only fluff dies.");
+	addGuideline("Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging (might be worth/could consider).");
+	addGuideline("Fragments OK. Short synonyms (big not extensive, fix not implement a solution for). Pattern: [thing] [action] [reason]. [next step].");
+	addGuideline("Never announce what you're about to do — just do it. Never summarize what you just did unless the user asks.");
+	addGuideline("Code blocks, error messages, file paths, and technical terms stay exact. Only compress prose.");
+	addGuideline("For security warnings, irreversible actions, or multi-step sequences where fragments risk misread — use full clear sentences. Resume terse after.");
 	addGuideline("For conceptual, product, or UX questions, answer first; inspect code only if implementation detail is needed.");
 
 	const hasSubagent = tools.includes("subagent");
 
 	if (hasLsp) {
 		addGuideline(
-			"Code navigation in typed codebases: use lsp for symbols (definition, references, implementation, hover, diagnostics, rename, format). Use grep/find/ls for text patterns, filenames, and non-code files.",
+			"Code navigation in typed codebases: use lsp first for symbols (definition, references, implementation, type info, hover, callers, diagnostics, rename, format). Do not use grep/find as a substitute for symbol navigation when LSP is available. Use grep/find/ls for raw text patterns, filenames, and non-code files. If LSP is unavailable or failing, say so briefly and then fall back to grep/read.",
+		);
+		addGuideline(
+			"Before choosing a code navigation tool, classify intent: symbol lookup (definition/reference/implementation/type/caller/rename) → lsp; raw text or filename search → grep/find.",
 		);
 	} else {
 		addGuideline("Use grep/find/ls for code search and file exploration (faster than bash, respects .gitignore)");
@@ -219,6 +227,9 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	}
 
 	const guidelines = guidelinesList.map((g) => `- ${g}`).join("\n");
+	const lspDecisionTable = hasLsp
+		? `\n\nTool selection — code navigation quick map:\n\n| Intent | Use | Avoid |\n| --- | --- | --- |\n| Find where a symbol is defined | \`lsp definition\` | \`grep\` |\n| Find all usages of a symbol | \`lsp references\` | \`grep\` |\n| Find implementations of an interface/type | \`lsp implementation\` | \`grep\` |\n| Get type info/docs for a symbol | \`lsp hover\` | raw text search |\n| Find callers of a function | \`lsp incoming_calls\` | \`grep\` |\n| Search literal text patterns (TODO, logs, strings) | \`grep\` | \`lsp\` |\n| Search filenames/paths | \`find\` / \`ls\` | \`lsp\` |\n| Rename a symbol across codebase | \`lsp rename\` | find-and-replace |\n| Check type errors after edits | \`lsp diagnostics\` | ad-hoc grep |\n| Format a file | \`lsp format\` | external formatter guesswork |`
+		: "";
 
 	const piDocsBlock = existsSync(readmePath)
 		? `\n\nPi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):
@@ -236,7 +247,7 @@ ${toolsList}
 In addition to the tools above, you may have access to other custom tools depending on the project.
 
 Guidelines:
-${guidelines}${piDocsBlock}`;
+${guidelines}${lspDecisionTable}${piDocsBlock}`;
 
 	if (appendSection) {
 		prompt += appendSection;

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

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { getToolPriority, shouldCollapse } from "./tool-priority.js";
+
+describe("tool priority", () => {
+	it("keeps edit and write always visible", () => {
+		assert.equal(getToolPriority("edit"), "always");
+		assert.equal(getToolPriority("write"), "always");
+		assert.equal(shouldCollapse("edit", false), false);
+		assert.equal(shouldCollapse("write", true), false);
+	});
+
+	it("collapses bash and bg_shell only on success", () => {
+		assert.equal(getToolPriority("bash"), "on-error");
+		assert.equal(getToolPriority("bg_shell"), "on-error");
+		assert.equal(shouldCollapse("bash", false), true);
+		assert.equal(shouldCollapse("bash", true), false);
+		assert.equal(shouldCollapse("bg_shell", false), true);
+		assert.equal(shouldCollapse("bg_shell", true), false);
+	});
+
+	it("collapses read, grep, and unknown tools", () => {
+		assert.equal(getToolPriority("read"), "collapse");
+		assert.equal(getToolPriority("grep"), "collapse");
+		assert.equal(getToolPriority("unknown-tool"), "collapse");
+		assert.equal(shouldCollapse("read", false), true);
+		assert.equal(shouldCollapse("unknown-tool", true), true);
+	});
+});

package/packages/pi-coding-agent/src/core/tool-priority.ts

@@ -0,0 +1,17 @@
+export type ToolPriority = "always" | "on-error" | "collapse";
+
+const ALWAYS_VISIBLE = new Set(["edit", "write"]);
+const ON_ERROR = new Set(["bash", "bg_shell"]);
+
+export function getToolPriority(toolName: string): ToolPriority {
+	if (ALWAYS_VISIBLE.has(toolName)) return "always";
+	if (ON_ERROR.has(toolName)) return "on-error";
+	return "collapse";
+}
+
+export function shouldCollapse(toolName: string, isError: boolean): boolean {
+	const priority = getToolPriority(toolName);
+	if (priority === "always") return false;
+	if (priority === "on-error") return !isError;
+	return true;
+}

package/packages/pi-coding-agent/src/core/tools/grep.ts

@@ -66,7 +66,7 @@ export function createGrepTool(cwd: string, options?: GrepToolOptions): AgentToo
 	return {
 		name: "grep",
 		label: "grep",
-		description: `Search file contents for a text pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars. For finding symbol definitions, references, type info, or callers in code, prefer the \`lsp\` tool instead — it resolves semantically.`,
+		description: `Search file contents for a text pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars. Use this for raw text search, not semantic code navigation. For symbol definitions, references, type info, callers, implementations, or rename targets in code, use the \`lsp\` tool instead when available.`,
 		parameters: grepSchema,
 		execute: async (
 			_toolCallId: string,

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

@@ -148,6 +148,9 @@ export const readOnlyTools: Tool[] = [readTool, grepTool, findTool, lsTool];
 
 const ptyBuiltinTools = createPtyTools(process.cwd());
 
+/** Write raw input to an active agent PTY session. Used by the UI for user-controlled focus. */
+export const writeToPtySession: (sessionId: string, input: string) => void = ptyBuiltinTools.writeToSession;
+
 // All available tools (using process.cwd())
 export const allTools = {
 	read: readTool,

package/packages/pi-coding-agent/src/core/tools/pty.ts

@@ -81,7 +81,7 @@ export interface PtyToolDetails {
 }
 
 class PtySessionManager {
-	private sessions = new Map<string, ManagedPtySession>();
+	readonly sessions = new Map<string, ManagedPtySession>();
 
 	constructor(private cwd: string) {}
 
@@ -196,17 +196,34 @@ class PtySessionManager {
 
 	async wait(
 		sessionId: string,
-		options?: { text?: string; view?: "viewport" | "buffer"; timeoutMs?: number; stableMs?: number },
+		options?: { text?: string; view?: "viewport" | "buffer"; timeoutMs?: number; stableMs?: number; signal?: AbortSignal; onUpdate?: (result: { content: Array<{ type: string; text: string }>; details: any }) => void },
 	): Promise<{ session: ManagedPtySession; text: string }> {
 		const timeoutMs = Math.max(50, options?.timeoutMs ?? 30000);
 		const stableMs = Math.max(50, options?.stableMs ?? 800);
 		const view = options?.view ?? "viewport";
+		const signal = options?.signal;
+		const onUpdate = options?.onUpdate;
 		const start = Date.now();
 		let lastSnapshot = "";
 		let stableSince = Date.now();
+		let lastUpdateText = "";
 
 		while (Date.now() - start < timeoutMs) {
+			if (signal?.aborted) {
+				throw new Error(`pty_wait cancelled`);
+			}
 			const { text } = await this.read(sessionId, view);
+
+			// Push live screen text updates to UI
+			if (onUpdate && text !== lastUpdateText) {
+				lastUpdateText = text;
+				const session = this.get(sessionId);
+				onUpdate({
+					content: [{ type: "text", text: buildReadText(session, view, text) }],
+					details: { sessionId, pid: session.pty.handle.pid, completed: session.completed, cancelled: session.cancelled, exitCode: session.exitCode, view, screenText: text },
+				});
+			}
+
 			if (options?.text) {
 				if (text.includes(options.text)) {
 					return { session: this.get(sessionId), text };
@@ -222,7 +239,10 @@ class PtySessionManager {
 					return { session: this.get(sessionId), text };
 				}
 			}
-			await new Promise((resolve) => setTimeout(resolve, 100));
+			await new Promise<void>((resolve) => {
+				const t = setTimeout(resolve, 100);
+				signal?.addEventListener("abort", () => { clearTimeout(t); resolve(); }, { once: true });
+			});
 		}
 
 		await this.read(sessionId, view);
@@ -249,7 +269,17 @@ function buildReadText(session: ManagedPtySession, view: "viewport" | "buffer",
 	return text ? `${header}\n${text}` : `${header}\n(no visible text)`;
 }
 
-export function createPtyTools(cwd: string): Record<string, AgentTool<any, PtyToolDetails>> {
+export interface PtyToolsResult {
+	pty_start: AgentTool<any, PtyToolDetails>;
+	pty_send: AgentTool<any, PtyToolDetails>;
+	pty_read: AgentTool<any, PtyToolDetails>;
+	pty_wait: AgentTool<any, PtyToolDetails>;
+	pty_resize: AgentTool<any, PtyToolDetails>;
+	pty_kill: AgentTool<any, PtyToolDetails>;
+	writeToSession: (sessionId: string, input: string) => void;
+}
+
+export function createPtyTools(cwd: string): PtyToolsResult {
 	const manager = new PtySessionManager(cwd);
 
 	const ptyStartTool: AgentTool<typeof ptyStartSchema, PtyToolDetails> = {
@@ -302,9 +332,9 @@ export function createPtyTools(cwd: string): Record<string, AgentTool<any, PtyTo
 		label: "pty_wait",
 		description: "Wait until text appears in a PTY session or until the PTY screen stops changing. Useful between pty_send calls.",
 		parameters: ptyWaitSchema,
-		execute: async (_toolCallId, { sessionId, text, view, timeoutMs, stableMs }) => {
+		execute: async (_toolCallId, { sessionId, text, view, timeoutMs, stableMs }, signal, onUpdate) => {
 			const effectiveView = view ?? "viewport";
-			const result = await manager.wait(sessionId, { text, view: effectiveView, timeoutMs, stableMs });
+			const result = await manager.wait(sessionId, { text, view: effectiveView, timeoutMs, stableMs, signal, onUpdate: onUpdate as ((result: { content: Array<{ type: string; text: string }>; details: any }) => void) | undefined });
 			return {
 				content: [{ type: "text", text: buildReadText(result.session, effectiveView, result.text) }],
 				details: { sessionId, pid: result.session.pty.handle.pid, completed: result.session.completed, cancelled: result.session.cancelled, exitCode: result.session.exitCode, view: effectiveView, screenText: result.text },
@@ -341,6 +371,14 @@ export function createPtyTools(cwd: string): Record<string, AgentTool<any, PtyTo
 		},
 	};
 
+	/** Write raw input to an active PTY session by ID. Used by the UI when the user focuses and types into an agent PTY terminal. */
+	function writeToSession(sessionId: string, input: string): void {
+		const session = manager.sessions.get(sessionId);
+		if (session && !session.completed && session.pty.handle.isActive()) {
+			session.pty.handle.write(input);
+		}
+	}
+
 	return {
 		pty_start: ptyStartTool,
 		pty_send: ptySendTool,
@@ -348,6 +386,7 @@ export function createPtyTools(cwd: string): Record<string, AgentTool<any, PtyTo
 		pty_wait: ptyWaitTool,
 		pty_resize: ptyResizeTool,
 		pty_kill: ptyKillTool,
+		writeToSession,
 	};
 }
 

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

@@ -0,0 +1,31 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import stripAnsi from "strip-ansi";
+
+import { ToolSummaryLine } from "../tool-summary-line.js";
+import { initTheme } from "../../theme/theme.js";
+
+initTheme("dark");
+
+describe("ToolSummaryLine", () => {
+	it("aggregates repeated tools with tool-row style formatting", () => {
+		const summary = new ToolSummaryLine();
+		summary.addTool("read", 600);
+		summary.addTool("lsp", 250);
+		summary.addTool("read", 150);
+
+		const rendered = stripAnsi(summary.render(160).join("\n"));
+		assert.match(rendered, /^ ● collapsed tools /);
+		assert.ok(rendered.includes("read ×2 · lsp · 1.0s"));
+		assert.equal(rendered.includes("⎯"), false);
+	});
+
+	it("renders nothing when empty or hidden", () => {
+		const summary = new ToolSummaryLine();
+		assert.deepEqual(summary.render(80), []);
+
+		summary.addTool("grep", 100);
+		summary.setHidden(true);
+		assert.deepEqual(summary.render(80), []);
+	});
+});