lsd-pi 1.1.9 → 1.2.0

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

@@ -127,9 +127,12 @@ export interface Settings {
 	planModeReasoningModel?: string;
 	planModeReviewModel?: string;
 	planModeCodingModel?: string;
+	autoSuggestPlanMode?: boolean; // default: false — append a system-prompt instruction so the LLM proposes plan mode for large tasks
+	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";
+	defaultThinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive";
+	anthropicAdaptiveByDefault?: boolean; // default: false — prefer adaptive thinking when using supported Anthropic models
 	transport?: TransportSetting; // default: "sse"
 	steeringMode?: "all" | "one-at-a-time";
 	followUpMode?: "all" | "one-at-a-time";
@@ -149,7 +152,8 @@ export interface Settings {
 	prompts?: string[]; // Array of local prompt template paths or directories
 	themes?: string[]; // Array of local theme file paths or directories
 	enableSkillCommands?: boolean; // default: true - register skills as /skill:name commands
-	toolSearch?: boolean; // default: false - start with a minimal tool set and use tool_search/tool_enable to lazily activate tools
+	toolSearch?: boolean; // legacy boolean toggle from deprecated minimal profile; retained for migration only
+	toolProfile?: "balanced" | "full"; // default: "balanced"
 	terminal?: TerminalSettings;
 	images?: ImageSettings;
 	enabledModels?: string[]; // Model patterns for cycling (same format as --models CLI flag)
@@ -805,6 +809,22 @@ export class SettingsManager {
 		this.setGlobalSetting("planModeCodingModel", modelRef.trim());
 	}
 
+	getAutoSuggestPlanMode(): boolean {
+		return this.settings.autoSuggestPlanMode ?? false;
+	}
+
+	setAutoSuggestPlanMode(enabled: boolean): void {
+		this.setGlobalSetting("autoSuggestPlanMode", enabled);
+	}
+
+	getAutoSwitchPlanModel(): boolean {
+		return this.settings.autoSwitchPlanModel ?? false;
+	}
+
+	setAutoSwitchPlanModel(enabled: boolean): void {
+		this.setGlobalSetting("autoSwitchPlanModel", enabled);
+	}
+
 	setPermissionMode(mode: "danger-full-access" | "accept-on-edit" | "auto" | "plan"): void {
 		this.setGlobalSetting("permissionMode", mode);
 	}
@@ -873,14 +893,22 @@ export class SettingsManager {
 		this.setGlobalSetting("themeAccent", accent);
 	}
 
-	getDefaultThinkingLevel(): "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined {
+	getDefaultThinkingLevel(): "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive" | undefined {
 		return this.settings.defaultThinkingLevel;
 	}
 
-	setDefaultThinkingLevel(level: "off" | "minimal" | "low" | "medium" | "high" | "xhigh"): void {
+	setDefaultThinkingLevel(level: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive"): void {
 		this.setGlobalSetting("defaultThinkingLevel", level);
 	}
 
+	getAnthropicAdaptiveByDefault(): boolean {
+		return this.settings.anthropicAdaptiveByDefault ?? false;
+	}
+
+	setAnthropicAdaptiveByDefault(enabled: boolean): void {
+		this.setGlobalSetting("anthropicAdaptiveByDefault", enabled);
+	}
+
 	getTransport(): TransportSetting {
 		return this.settings.transport ?? "sse";
 	}
@@ -1066,12 +1094,18 @@ export class SettingsManager {
 		this.setGlobalSetting("enableSkillCommands", enabled);
 	}
 
-	getToolSearch(): boolean {
-		return this.settings.toolSearch ?? false;
+	getToolProfile(): "balanced" | "full" {
+		const profile = this.settings.toolProfile;
+		if (profile === "balanced" || profile === "full") return profile;
+		// Migrate legacy minimal/toolSearch settings to balanced.
+		if (this.settings.toolSearch !== undefined) return "balanced";
+		return "balanced";
 	}
 
-	setToolSearch(enabled: boolean): void {
-		this.setGlobalSetting("toolSearch", enabled);
+	setToolProfile(profile: "balanced" | "full"): void {
+		this.setGlobalSetting("toolProfile", profile);
+		// Keep legacy field in sync with deprecated minimal mode removal.
+		this.setGlobalSetting("toolSearch", false);
 	}
 
 	getThinkingBudgets(): ThinkingBudgetsSettings | undefined {

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

@@ -2,6 +2,7 @@
  * System prompt construction and project context loading
  */
 
+import { existsSync } from "node:fs";
 import { getDocsPath, getExamplesPath, getReadmePath } from "../config.js";
 import { toPosixPath } from "../utils/path-display.js";
 import { formatSkillsForPrompt, type Skill } from "./skills.js";
@@ -19,7 +20,12 @@ const toolDescriptions: Record<string, string> = {
 };
 
 export interface BuildSystemPromptOptions {
-	/** Custom system prompt (replaces default). */
+	/**
+	 * Custom system prompt that replaces the default role header, tool list,
+	 * and guidelines entirely. You are responsible for providing your own
+	 * tool-usage guidance. Project context, skills, extension promptGuidelines,
+	 * date/cwd, and appendSystemPrompt are still applied on top.
+	 */
 	customPrompt?: string;
 	/** Tools to include in prompt. Default: [read, bash, edit, write] */
 	selectedTools?: string[];
@@ -90,10 +96,6 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 			prompt += formatSkillsForPrompt(skills);
 		}
 
-		// Add date/time and working directory last
-		prompt += `\nCurrent date and time: ${dateTime}`;
-		prompt += `\nCurrent working directory: ${resolvedCwd}`;
-
 		// Append promptGuidelines from extension-registered tools.
 		// Without this, tools registered via pi.registerTool() with promptGuidelines
 		// have their definitions reach the API but the model has no guidance on when
@@ -105,6 +107,10 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 			}
 		}
 
+		// Add date/time and working directory last
+		prompt += `\nCurrent date and time: ${dateTime}`;
+		prompt += `\nCurrent working directory: ${resolvedCwd}`;
+
 		return prompt;
 	}
 
@@ -137,90 +143,45 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		guidelinesList.push(guideline);
 	};
 
-	const hasBash = tools.includes("bash");
 	const hasEdit = tools.includes("edit");
 	const hasWrite = tools.includes("write");
-	const hasGrep = tools.includes("grep");
-	const hasFind = tools.includes("find");
-	const hasLs = tools.includes("ls");
 	const hasRead = tools.includes("read");
 	const hasLsp = tools.includes("lsp");
 
-	// LSP guideline — must come FIRST so it outranks grep/bash in the model's priority
-	if (hasLsp) {
-		addGuideline(
-			`Use lsp as the primary tool for code navigation in typed codebases:
-- Navigation: definition, type_definition, implementation, references, incoming_calls, outgoing_calls
-- Understanding: hover (types + docs), signature (parameter info), symbols (file/workspace search)
-- Refactoring: rename (project-wide), code_actions (quick-fixes, imports, refactors), format (formatter)
-- Verification: diagnostics after edits to catch type errors immediately
-- Before choosing a code-navigation tool, classify your intent: symbol lookup (definition, references, type info, callers, rename, formatting, diagnostics) or text search. Symbols → lsp. Text patterns / non-code files → grep/find/ls
-- Tool selection — code navigation:
-  • Find where a symbol is defined → lsp definition (not grep)
-  • Find all usages of a symbol → lsp references (not grep)
-  • Find implementations of an interface or method → lsp implementation (not grep)
-  • Get type info or docs for a symbol → lsp hover/signature (not reading source first)
-  • Find all callers of a function → lsp incoming_calls (not grep)
-  • Search for a text pattern, TODO, log message, or non-code content → grep
-  • Search for filenames or directory structure → find/ls
-  • Rename a symbol across the codebase → lsp rename (not find-and-replace)
-  • Check typed errors after edits → lsp diagnostics (not manual scans)
-  • Format a file → lsp format when available (not shelling out)
-- When lsp is available, ALWAYS prefer it over grep/bash/find for: finding definitions, finding references, getting type info, renaming symbols, listing symbols in a file or workspace, checking diagnostics/errors, and formatting
-- Never grep for a symbol definition when lsp can resolve it semantically
-- Never shell out to a formatter when lsp format is available`,
-		);
-	}
+	// Priority-ordered compact guidelines
+	addGuideline("Be concise. Prefer short, direct answers over preamble.");
+	addGuideline("For conceptual, product, or UX questions, answer first; inspect code only if implementation detail is needed.");
 
-	// If the request is primarily conceptual or product/design oriented, answer the design or strategy question first and inspect the codebase only after confirming implementation detail is needed.
-	addGuideline(
-		"If the request is primarily conceptual, product, or UX/design oriented, answer the question first with concise recommendations and inspect the codebase only after confirming implementation detail is needed",
-	);
-
-	// Use subagents for broad reconnaissance before spending expensive-model tokens on discovery
-	if (tools.includes("subagent")) {
+	if (hasLsp) {
 		addGuideline(
-			"Use a scout subagent for broad repo reconnaissance when file ownership or architecture is unclear; keep the scout read-only, use a cheaper model when available, and ask it to return a high-signal handoff with exact files/symbols to inspect next",
+			"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.",
 		);
+	} else {
+		addGuideline("Use grep/find/ls for code search and file exploration (faster than bash, respects .gitignore)");
 	}
 
-	addGuideline(
-		"Do not deep-dive backend schemas, migrations, or infrastructure for a conceptual/product request until you confirm that implementation constraints actually matter",
-	);
-
-	// File exploration guidelines (only for tasks lsp cannot do: raw text search, non-code files, etc.)
-	if (hasBash && !hasGrep && !hasFind && !hasLs) {
-		addGuideline("Use bash for file operations like ls, rg, find");
-	} else if (hasBash && (hasGrep || hasFind || hasLs)) {
-		if (hasLsp) {
-			addGuideline("Prefer grep/find/ls tools over bash for file exploration (faster, respects .gitignore) — but prefer lsp over grep/find when navigating typed code");
-		} else {
-			addGuideline("Prefer grep/find/ls tools over bash for file exploration (faster, respects .gitignore)");
-		}
-	}
-
-	// Read before edit guideline
 	if (hasRead && hasEdit) {
-		addGuideline("Use read to examine files before editing. You must use this tool instead of cat or sed.");
+		addGuideline("Read files before editing them. Never use cat or sed to inspect or modify files.");
 	}
 
-	// Edit guideline
 	if (hasEdit) {
-		addGuideline("Use edit for precise changes (old text must match exactly)");
+		addGuideline("edit requires exact text match; write is for new files or full rewrites.");
+	}
+
+	if (hasWrite && !hasEdit) {
+		addGuideline("write is for new files or full rewrites.");
 	}
 
-	// Write guideline
-	if (hasWrite) {
-		addGuideline("Use write only for new files or complete rewrites");
+	if (hasLsp && hasEdit) {
+		addGuideline("Run lsp diagnostics after edits to catch type errors.");
 	}
 
-	// Output guideline (only when actually writing or executing)
 	if (hasEdit || hasWrite) {
-		addGuideline(
-			"When summarizing your actions, output plain text directly - do NOT use cat or bash to display what you did",
-		);
+		addGuideline("Output plain text directly when summarizing your work — do not cat or echo to display what you did.");
 	}
 
+	addGuideline("Show file paths clearly when referencing files.");
+
 	for (const guideline of promptGuidelines ?? []) {
 		const normalized = guideline.trim();
 		if (normalized.length > 0) {
@@ -228,13 +189,17 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		}
 	}
 
-	// Always include these
-	addGuideline("Be concise in your responses");
-	addGuideline("Show file paths clearly when working with files");
-
 	const guidelines = guidelinesList.map((g) => `- ${g}`).join("\n");
 
-	let prompt = `You are an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
+	const piDocsBlock = existsSync(readmePath)
+		? `\n\nPi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):
+- Main documentation: ${readmePath}
+- Additional docs: ${docsPath}
+- Examples: ${examplesPath} (extensions, custom tools, SDK)
+- When working on pi topics, read the docs and follow .md cross-references before implementing`
+		: "";
+
+	let prompt = `You are an expert coding assistant operating inside pi, a coding agent harness.
 
 Available tools:
 ${toolsList}
@@ -242,15 +207,7 @@ ${toolsList}
 In addition to the tools above, you may have access to other custom tools depending on the project.
 
 Guidelines:
-${guidelines}
-
-Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):
-- Main documentation: ${readmePath}
-- Additional docs: ${docsPath}
-- Examples: ${examplesPath} (extensions, custom tools, SDK)
-- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md)
-- When working on pi topics, read the docs and examples, and follow .md cross-references before implementing
-- Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)`;
+${guidelines}${piDocsBlock}`;
 
 	if (appendSection) {
 		prompt += appendSection;

package/packages/pi-coding-agent/src/core/tools/bash-interceptor.test.ts

@@ -145,6 +145,12 @@ describe("checkBashInterception", () => {
 			assert.ok(r.message?.includes("cat README.md"), "message should contain original command");
 		});
 
+		it("uses 'Tool routing:' prefix to distinguish from permission blocks", () => {
+			const r = checkBashInterception("cat README.md", ALL_TOOLS);
+			assert.ok(r.message?.startsWith("Tool routing:"), "message should start with 'Tool routing:'");
+			assert.ok(r.message?.includes("not a permission block"), "message should clarify it's not a permission block");
+		});
+
 		it("returns block:false with no message when not blocked", () => {
 			const r = checkBashInterception("npm install", ALL_TOOLS);
 			assert.equal(r.block, false);

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

@@ -86,7 +86,7 @@ export function compileInterceptor(rules: BashInterceptorRule[]): CompiledInterc
 				if (regex.test(trimmed) && availableTools.includes(rule.tool)) {
 					return {
 						block: true,
-						message: `Blocked: ${rule.message}\n\nOriginal command: ${command}`,
+						message: `Tool routing: ${rule.message}\n\nThis is a routing suggestion, not a permission block. Use the suggested tool to perform this action.\n\nOriginal command: ${command}`,
 						suggestedTool: rule.tool,
 					};
 				}

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

@@ -17,6 +17,25 @@ import { truncateToVisualLines } from "./visual-truncate.js";
 // Preview line limit when not expanded (matches tool execution behavior)
 const PREVIEW_LINES = 20;
 
+/**
+ * Returns true if the command failure looks like a privilege/sudo escalation
+ * error that the agent cannot resolve — distinct from an OS sandbox policy block.
+ */
+function isPrivilegeError(output: string, command: string): boolean {
+	// Already handled by sandbox-policy path
+	if (/sandbox blocked this operation/i.test(output)) return false;
+	// sudo explicitly rejected
+	if (/sudo.*operation not permitted/i.test(output)) return true;
+	if (/command exited with code 126/i.test(output) && /sudo/i.test(output)) return true;
+	// Agent process itself hit EPERM (e.g. npm cache owned by root)
+	if (/EPERM|operation not permitted/i.test(output) && /sudo/i.test(command)) return true;
+	// npm cache root-owned files pattern
+	if (/cache folder contains root-owned files/i.test(output)) return true;
+	// Generic privilege denial patterns
+	if (/permission denied/i.test(output) && /sudo/i.test(command)) return true;
+	return false;
+}
+
 type ToolOutputMode = "minimal" | "normal";
 
 export class BashExecutionComponent extends Container {
@@ -217,6 +236,13 @@ export class BashExecutionComponent extends Container {
 							"Sandbox blocked this operation. Run /sandbox to inspect the active policy and allowed paths.",
 						),
 					);
+				} else if (!this.sandboxed && isPrivilegeError(fullOutput, this.command)) {
+					statusParts.push(
+						theme.fg("warning", "⚠ This command requires elevated privileges the agent cannot use."),
+					);
+					statusParts.push(
+						theme.fg("muted", `Run it manually in your terminal:\n  ${this.command}`),
+					);
 				}
 			}
 

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

@@ -16,6 +16,7 @@ import { DynamicBorder } from "./dynamic-border.js";
 
 export const THINKING_DESCRIPTIONS: Record<ThinkingLevel, string> = {
 	off: "No reasoning",
+	adaptive: "Claude decides when and how much to think (Claude 4.6+ only)",
 	minimal: "Very brief reasoning (~1k tokens)",
 	low: "Light reasoning (~2k tokens)",
 	medium: "Moderate reasoning (~8k tokens)",
@@ -32,10 +33,13 @@ export interface SettingsConfig {
 	planModeReasoningModel: string;
 	planModeReviewModel: string;
 	planModeCodingModel: string;
+	autoSuggestPlanMode: boolean;
+	autoSwitchPlanModel: boolean;
 	showImages: boolean;
 	autoResizeImages: boolean;
 	blockImages: boolean;
 	enableSkillCommands: boolean;
+	toolProfile: "balanced" | "full";
 	codexRotate: boolean;
 	cacheTimer: boolean;
 	pinLastPrompt: boolean;
@@ -43,6 +47,7 @@ export interface SettingsConfig {
 	followUpMode: "all" | "one-at-a-time";
 	transport: Transport;
 	thinkingLevel: ThinkingLevel;
+	anthropicAdaptiveByDefault: boolean;
 	availableThinkingLevels: ThinkingLevel[];
 	currentTheme: string;
 	availableThemes: string[];
@@ -84,6 +89,8 @@ export interface SettingsCallbacks {
 	onPlanModeReasoningModelChange: (modelRef: string) => void;
 	onPlanModeReviewModelChange: (modelRef: string) => void;
 	onPlanModeCodingModelChange: (modelRef: string) => void;
+	onAutoSuggestPlanModeChange: (enabled: boolean) => void;
+	onAutoSwitchPlanModelChange: (enabled: boolean) => void;
 	onAutoDreamChange: (enabled: boolean) => void;
 	onAutoMemoryChange: (enabled: boolean) => void;
 	onTelegramLiveRelayAutoConnectChange: (enabled: boolean) => void;
@@ -93,6 +100,7 @@ export interface SettingsCallbacks {
 	onAutoResizeImagesChange: (enabled: boolean) => void;
 	onBlockImagesChange: (blocked: boolean) => void;
 	onEnableSkillCommandsChange: (enabled: boolean) => void;
+	onToolProfileChange: (profile: "balanced" | "full") => void;
 	onCodexRotateChange: (enabled: boolean) => void;
 	onCacheTimerChange: (enabled: boolean) => void;
 	onPinLastPromptChange: (enabled: boolean) => void;
@@ -100,6 +108,7 @@ export interface SettingsCallbacks {
 	onFollowUpModeChange: (mode: "all" | "one-at-a-time") => void;
 	onTransportChange: (transport: Transport) => void;
 	onThinkingLevelChange: (level: ThinkingLevel) => void;
+	onAnthropicAdaptiveByDefaultChange: (enabled: boolean) => void;
 	onThemeChange: (theme: string) => void;
 	onThemePreview?: (theme: string) => void;
 	onThemeAccentChange: (accent: string) => void;
@@ -250,6 +259,20 @@ export class SettingsSelectorComponent extends Container {
 				currentValue: config.planModeCodingModel,
 				submenu: config.planModeCodingModelSubmenu,
 			},
+			{
+				id: "auto-suggest-plan-mode",
+				label: "Auto-suggest plan mode",
+				description: "Ask the LLM to suggest plan mode for large/complex tasks",
+				currentValue: config.autoSuggestPlanMode ? "true" : "false",
+				values: ["true", "false"],
+			},
+			{
+				id: "auto-switch-plan-model",
+				label: "OpusPlan mode",
+				description: "On plan entry: auto-switch to Plan reasoning model (must be set). On approval: offer new session with Plan coding model + worker agent",
+				currentValue: config.autoSwitchPlanModel ? "true" : "false",
+				values: ["true", "false"],
+			},
 			{
 				id: "steering-mode",
 				label: "Steering mode",
@@ -351,6 +374,13 @@ export class SettingsSelectorComponent extends Container {
 						() => done(),
 					),
 			},
+			{
+				id: "anthropic-adaptive-default",
+				label: "Anthropic adaptive",
+				description: "Default to adaptive thinking for supported Anthropic models",
+				currentValue: config.anthropicAdaptiveByDefault ? "true" : "false",
+				values: ["true", "false"],
+			},
 			{
 				id: "theme",
 				label: "Theme",
@@ -445,9 +475,19 @@ export class SettingsSelectorComponent extends Container {
 			values: ["true", "false"],
 		});
 
-		// Hardware cursor toggle (insert after skill-commands)
+		// Tool profile selector (insert after skill-commands)
 		const skillCommandsIndex = items.findIndex((item) => item.id === "skill-commands");
 		items.splice(skillCommandsIndex + 1, 0, {
+			id: "tool-profile",
+			label: "Tool profile",
+			description: "Choose the default active tool set: balanced for day-to-day coding, full to enable all available tools",
+			currentValue: config.toolProfile,
+			values: ["balanced", "full"],
+		});
+
+		// Codex rotate toggle (insert after tool-profile)
+		const toolProfileIndex = items.findIndex((item) => item.id === "tool-profile");
+		items.splice(toolProfileIndex + 1, 0, {
 			id: "codex-rotate",
 			label: "Codex rotate",
 			description: "Enable automatic Codex account rotation extension",
@@ -618,6 +658,12 @@ export class SettingsSelectorComponent extends Container {
 					case "plan-mode-coding-model":
 						callbacks.onPlanModeCodingModelChange(newValue);
 						break;
+					case "auto-suggest-plan-mode":
+						callbacks.onAutoSuggestPlanModeChange(newValue === "true");
+						break;
+					case "auto-switch-plan-model":
+						callbacks.onAutoSwitchPlanModelChange(newValue === "true");
+						break;
 					case "show-images":
 						callbacks.onShowImagesChange(newValue === "true");
 						break;
@@ -630,6 +676,9 @@ export class SettingsSelectorComponent extends Container {
 					case "skill-commands":
 						callbacks.onEnableSkillCommandsChange(newValue === "true");
 						break;
+					case "tool-profile":
+						callbacks.onToolProfileChange(newValue as "balanced" | "full");
+						break;
 					case "codex-rotate":
 						callbacks.onCodexRotateChange(newValue === "true");
 						break;
@@ -660,6 +709,9 @@ export class SettingsSelectorComponent extends Container {
 					case "transport":
 						callbacks.onTransportChange(newValue as Transport);
 						break;
+					case "anthropic-adaptive-default":
+						callbacks.onAnthropicAdaptiveByDefaultChange(newValue === "true");
+						break;
 					case "hide-thinking":
 						callbacks.onHideThinkingBlockChange(newValue === "true");
 						break;

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

@@ -5,6 +5,7 @@ import { DynamicBorder } from "./dynamic-border.js";
 
 const LEVEL_DESCRIPTIONS: Record<ThinkingLevel, string> = {
 	off: "No reasoning",
+	adaptive: "Claude decides when and how much to think (Claude 4.6+ only)",
 	minimal: "Very brief reasoning (~1k tokens)",
 	low: "Light reasoning (~2k tokens)",
 	medium: "Moderate reasoning (~8k tokens)",

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

@@ -59,6 +59,25 @@ function str(value: unknown): string | null {
 	return null; // Invalid type
 }
 
+/**
+ * Returns true if the bash output indicates a privilege escalation failure
+ * that the agent process cannot resolve (sudo blocked, EPERM on root-owned files, etc.).
+ */
+function isBashPrivilegeError(output: string, command: string): boolean {
+	// Already handled by OS sandbox-policy path
+	if (/sandbox blocked this operation/i.test(output)) return false;
+	// sudo explicitly rejected by OS
+	if (/sudo.*operation not permitted/i.test(output)) return true;
+	if (/command exited with code 126/i.test(output) && /sudo/i.test(output)) return true;
+	// npm / other tools hitting root-owned cache files
+	if (/cache folder contains root-owned files/i.test(output)) return true;
+	// Generic EPERM when command involves sudo
+	if (/EPERM|operation not permitted/i.test(output) && /sudo/i.test(command)) return true;
+	// Permission denied when command involves sudo
+	if (/permission denied/i.test(output) && /sudo/i.test(command)) return true;
+	return false;
+}
+
 export interface ToolExecutionOptions {
 	showImages?: boolean; // default: true (only used if terminal supports images)
 	renderMode?: "minimal" | "normal";
@@ -489,6 +508,17 @@ export class ToolExecutionComponent extends Container {
 						if (resultComponent !== undefined) {
 							this.contentBox.addChild(resultComponent);
 							customRendererHasContent = true;
+							// bg_shell: show /bg hint after start/list/digest actions
+							if (this.toolName === 'bg_shell' && this.result && !this.isPartial) {
+								const details = this.result.details as Record<string, unknown> | undefined;
+								const action = details?.action as string | undefined;
+								if (action === 'start' || action === 'list' || action === 'digest') {
+									this.contentBox.addChild(new Text(
+										'\n' + theme.fg('muted', 'Tip: run /bg to manage background processes'),
+										0, 0,
+									));
+								}
+							}
 						}
 					}
 				} catch {
@@ -673,6 +703,17 @@ export class ToolExecutionComponent extends Container {
 				}
 				body.addChild(new Text(`\n${theme.fg("warning", `[${warnings.join(". ")}]`)}`, 0, 0));
 			}
+
+			// Privilege escalation error — agent cannot sudo, show manual step callout
+			if (this.result.isError && command !== null && isBashPrivilegeError(output, command)) {
+				body.addChild(
+					new Text(
+						`\n${theme.fg("warning", "⚠ This command requires elevated privileges the agent cannot use.")}\n${theme.fg("muted", `Run it manually in your terminal:\n  ${command}`)}`,
+						0,
+						0,
+					),
+				);
+			}
 		}
 	}