lsd-pi 1.1.9 → 1.2.0

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

@@ -25,7 +25,7 @@ import type {
 	ThinkingLevel,
 } from "@gsd/pi-agent-core";
 import type { AssistantMessage, ImageContent, Message, Model, TextContent } from "@gsd/pi-ai";
-import { modelsAreEqual, resetApiProviders, supportsXhigh } from "@gsd/pi-ai";
+import { modelsAreEqual, resetApiProviders, supportsAdaptiveThinking, supportsXhigh } from "@gsd/pi-ai";
 import { Type } from "@sinclair/typebox";
 import { getDocsPath } from "../config.js";
 import { getErrorMessage } from "../utils/error.js";
@@ -237,6 +237,12 @@ const THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "hi
 /** Thinking levels including xhigh (for supported models) */
 const THINKING_LEVELS_WITH_XHIGH: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
 
+/** Thinking levels for models supporting adaptive thinking (Claude Opus/Sonnet 4.6+) */
+const THINKING_LEVELS_WITH_ADAPTIVE: ThinkingLevel[] = ["off", "adaptive", "minimal", "low", "medium", "high"];
+
+/** Thinking levels for models supporting both adaptive and xhigh */
+const THINKING_LEVELS_WITH_ADAPTIVE_AND_XHIGH: ThinkingLevel[] = ["off", "adaptive", "minimal", "low", "medium", "high", "xhigh"];
+
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -257,6 +263,8 @@ export class AgentSession {
 	private _steeringMessages: string[] = [];
 	/** Tracks pending follow-up messages for UI display. Removed when delivered. */
 	private _followUpMessages: string[] = [];
+	/** Tracks texts of extension-injected steer messages that should be hidden from UI. */
+	private _hiddenSteeringTexts = new Set<string>();
 	/** Messages queued to be included with the next user prompt as context ("asides"). */
 	private _pendingNextTurnMessages: CustomMessage[] = [];
 
@@ -367,10 +375,16 @@ export class AgentSession {
 
 		this._buildRuntime({
 			activeToolNames: this._initialActiveToolNames,
-			includeAllExtensionTools: true,
+			includeAllExtensionTools: this._shouldIncludeAllExtensionTools(),
 		});
 	}
 
+	private _shouldIncludeAllExtensionTools(): boolean {
+		// Tool profiles now provide curated active sets. Do not auto-activate every
+		// extension tool at startup, or the saved profile gets effectively ignored.
+		return false;
+	}
+
 	private async _waitForAutomatedFollowUps(): Promise<void> {
 		while (this._retryHandler.isRetrying || this._compactionOrchestrator.hasPendingAutoCompaction) {
 			await this._retryHandler.waitForRetry();
@@ -1118,10 +1132,11 @@ export class AgentSession {
 					"Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.",
 				);
 			}
+			const isExtensionSteer = options.streamingBehavior === "steer" && options.source === "extension";
 			if (options.streamingBehavior === "followUp") {
 				await this._queueFollowUp(expandedText, currentImages);
 			} else {
-				await this._queueSteer(expandedText, currentImages);
+				await this._queueSteer(expandedText, currentImages, isExtensionSteer);
 			}
 			return;
 		}
@@ -1181,6 +1196,10 @@ export class AgentSession {
 		if (currentImages) {
 			userContent.push(...currentImages);
 		}
+		// Track extension-injected messages so the UI can hide them
+		if (options?.source === "extension") {
+			this._hiddenSteeringTexts.add(expandedText);
+		}
 		messages.push({
 			role: "user",
 			content: userContent,
@@ -1422,9 +1441,13 @@ export class AgentSession {
 
 	/**
 	 * Internal: Queue a steering message (already expanded, no extension command check).
+	 * @param hidden If true, the message will be hidden from the UI (used for extension-injected steers).
 	 */
-	private async _queueSteer(text: string, images?: ImageContent[]): Promise<void> {
+	private async _queueSteer(text: string, images?: ImageContent[], hidden?: boolean): Promise<void> {
 		this._steeringMessages.push(text);
+		if (hidden) {
+			this._hiddenSteeringTexts.add(text);
+		}
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
 		if (images) {
 			content.push(...images);
@@ -1617,6 +1640,11 @@ export class AgentSession {
 		return this._steeringMessages.length + this._followUpMessages.length;
 	}
 
+	/** Returns true if the given message text was injected by an extension and should be hidden from the UI. */
+	isHiddenSteeringMessage(text: string): boolean {
+		return this._hiddenSteeringTexts.has(text);
+	}
+
 	/** Get pending steering messages (read-only) */
 	getSteeringMessages(): readonly string[] {
 		return this._steeringMessages;
@@ -1687,6 +1715,7 @@ export class AgentSession {
 		this._steeringMessages = [];
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
+		this._hiddenSteeringTexts = new Set();
 
 		this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
 
@@ -1697,7 +1726,7 @@ export class AgentSession {
 		if (this._cwd !== previousCwd) {
 			this._buildRuntime({
 				activeToolNames: this.getActiveToolNames(),
-				includeAllExtensionTools: true,
+				includeAllExtensionTools: this._shouldIncludeAllExtensionTools(),
 			});
 		}
 
@@ -1775,7 +1804,7 @@ export class AgentSession {
 			throw new Error(`No API key for ${model.provider}/${model.id}`);
 		}
 
-		const thinkingLevel = this._getThinkingLevelForModelSwitch();
+		const thinkingLevel = this._getThinkingLevelForModelSwitch(model);
 		await this._applyModelChange(model, thinkingLevel, "set", options);
 	}
 
@@ -1812,7 +1841,7 @@ export class AgentSession {
 
 		// Explicit scoped model thinking level overrides current session level;
 		// undefined scoped model thinking level inherits the current session preference.
-		const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
+		const thinkingLevel = this._getThinkingLevelForModelSwitch(next.model, next.thinkingLevel);
 		await this._applyModelChange(next.model, thinkingLevel, "cycle", options);
 
 		return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
@@ -1830,7 +1859,7 @@ export class AgentSession {
 		const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
 		const nextModel = availableModels[nextIndex];
 
-		const thinkingLevel = this._getThinkingLevelForModelSwitch();
+		const thinkingLevel = this._getThinkingLevelForModelSwitch(nextModel);
 		await this._applyModelChange(nextModel, thinkingLevel, "cycle", options);
 
 		return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: false };
@@ -1885,7 +1914,18 @@ export class AgentSession {
 	 */
 	getAvailableThinkingLevels(): ThinkingLevel[] {
 		if (!this.supportsThinking()) return ["off"];
-		return this.supportsXhighThinking() ? THINKING_LEVELS_WITH_XHIGH : THINKING_LEVELS;
+		const adaptive = this.supportsAdaptiveThinking();
+		const xhigh = this.supportsXhighThinking();
+		if (adaptive && xhigh) return THINKING_LEVELS_WITH_ADAPTIVE_AND_XHIGH;
+		if (adaptive) return THINKING_LEVELS_WITH_ADAPTIVE;
+		return xhigh ? THINKING_LEVELS_WITH_XHIGH : THINKING_LEVELS;
+	}
+
+	/**
+	 * Check if current model supports adaptive thinking (Claude Opus/Sonnet 4.6+).
+	 */
+	supportsAdaptiveThinking(): boolean {
+		return this.model ? supportsAdaptiveThinking(this.model.id) : false;
 	}
 
 	/**
@@ -1902,18 +1942,26 @@ export class AgentSession {
 		return !!this.model?.reasoning;
 	}
 
-	private _getThinkingLevelForModelSwitch(explicitLevel?: ThinkingLevel): ThinkingLevel {
+	private _getThinkingLevelForModelSwitch(targetModel: Model<any>, explicitLevel?: ThinkingLevel): ThinkingLevel {
 		if (explicitLevel !== undefined) {
 			return explicitLevel;
 		}
-		if (!this.supportsThinking()) {
+		if (
+			targetModel.provider === "anthropic" &&
+			targetModel.reasoning === true &&
+			this.settingsManager.getAnthropicAdaptiveByDefault() &&
+			supportsAdaptiveThinking(targetModel.id)
+		) {
+			return "adaptive";
+		}
+		if (!targetModel.reasoning) {
 			return this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
 		}
 		return this.thinkingLevel;
 	}
 
 	private _clampThinkingLevel(level: ThinkingLevel, availableLevels: ThinkingLevel[]): ThinkingLevel {
-		const ordered = THINKING_LEVELS_WITH_XHIGH;
+		const ordered = THINKING_LEVELS_WITH_ADAPTIVE_AND_XHIGH;
 		const available = new Set(availableLevels);
 		const requestedIndex = ordered.indexOf(level);
 		if (requestedIndex === -1) {
@@ -2294,12 +2342,6 @@ export class AgentSession {
 			for (const tool of wrappedExtensionTools) {
 				nextActiveToolNames.push(tool.name);
 			}
-		} else if (!options?.activeToolNames) {
-			for (const toolName of this._toolRegistry.keys()) {
-				if (!previousRegistryNames.has(toolName)) {
-					nextActiveToolNames.push(toolName);
-				}
-			}
 		}
 
 		this.setActiveToolsByName([...new Set(nextActiveToolNames)]);
@@ -2375,7 +2417,7 @@ export class AgentSession {
 		this._buildRuntime({
 			activeToolNames: this.getActiveToolNames(),
 			flagValues: previousFlagValues,
-			includeAllExtensionTools: true,
+			includeAllExtensionTools: this._shouldIncludeAllExtensionTools(),
 		});
 
 		const hasBindings =
@@ -2585,6 +2627,7 @@ export class AgentSession {
 		this._steeringMessages = [];
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
+		this._hiddenSteeringTexts = new Set();
 
 		// Set new session
 		this.sessionManager.setSessionFile(sessionPath);

package/packages/pi-coding-agent/src/core/classifier-service.ts

@@ -110,6 +110,39 @@ const BUILT_IN_BASH_ALLOW_PATTERNS = [
 	"more *",
 ] as const;
 
+const CLASSIFIER_SYSTEM_PROMPT = `You are a security classifier for an autonomous coding agent. Your job is to decide ALLOW or DENY for a pending tool call.
+
+DEFAULT: ALLOW. The user enabled auto mode because they trust the agent. Only deny clear security violations.
+
+ALWAYS ALLOW:
+- Read-only commands: find, grep, ls, cat, head, tail, wc, stat, file, du, df, echo, pwd, env, which, sort, awk, sed -n
+- Git read operations: status, log, diff, show, branch, blame, remote
+- Build/test/lint: npm run *, npx *, tsc, eslint, jest, vitest, cargo, make
+- Writing or editing files inside the project directory
+- Installing packages: npm install, pip install, cargo add
+- Operations clearly implied by the user's recent messages
+
+DENY only these specific violations:
+- Deleting files with rm, unlink, rmdir (unless user explicitly asked to delete/remove)
+- Commands targeting system paths outside the project (/etc, /usr, /bin, /System, ~/.ssh)
+- sudo, su, chmod, chown on system paths
+- curl/wget piped directly to sh/bash/zsh
+- curl/wget sending local files or env vars to external hosts (e.g. -d @~/.ssh/id_rsa, -d "$(env)")
+- ssh, scp, sftp — remote shell/file access is out of scope
+- nc/ncat in listen/server mode (-l flag)
+- kill -9, killall
+- crontab modifications
+- dd, mkfs — disk/filesystem writes
+- sed -i — in-place editing that can silently corrupt files
+- npm publish, pip publish, twine upload
+- git push --force / git push -f
+- Accessing credential files unrelated to the task (~/.aws, ~/.ssh/id_rsa, /etc/passwd)
+- Commands that clearly contradict the user's stated intent
+
+Use the user's recent messages to judge intent. If the user asked for something and the tool call implements it, ALLOW.
+
+Output exactly one word: ALLOW or DENY.`;
+
 export interface ClassifierContext {
 	userMessages: string[];
 	projectInstructions?: string;
@@ -259,46 +292,13 @@ export class ClassifierService {
 		argsJson: string,
 		context: ClassifierContext,
 	): Promise<boolean> {
-		const systemPrompt = `You are a security classifier for an autonomous coding agent. Your job is to decide ALLOW or DENY for a pending tool call.
-
-DEFAULT: ALLOW. The user enabled auto mode because they trust the agent. Only deny clear security violations.
-
-ALWAYS ALLOW:
-- Any read-only operation: find, grep, ls, cat, head, tail, wc, stat, file, du, df, echo, pwd, env, which, sort, awk, sed -n
-- Any git read operation: git status, git log, git diff, git show, git branch, git blame, git remote
-- Build/test/lint: npm run *, npx *, tsc, eslint, jest, vitest, cargo, make
-- Writing or editing files inside the project directory
-- Installing packages: npm install, pip install, cargo add
-- Operations clearly implied by the user's recent messages
-
-DENY only these specific violations:
-- Deleting files with rm, unlink, rmdir (unless user explicitly said "delete" or "remove" that file)
-- Commands outside the project directory targeting system paths (/etc, /usr, /bin, /System, ~/.ssh)
-- sudo, su, chmod/chown on system paths
-- curl/wget piped directly to sh/bash (arbitrary code execution)
-- curl/wget sending local files or env vars to external hosts (e.g. -d @~/.ssh/id_rsa, -d "$(env)")
-- ssh, scp, sftp — remote shell/file access is out of scope for a coding agent
-- nc/ncat in listen/server mode (-l flag) — reverse shell risk
-- kill -9, killall — terminating arbitrary processes
-- crontab — modifying scheduled jobs
-- dd, mkfs — disk/filesystem writes
-- sed -i — in-place file editing that can silently corrupt files; agent should use proper edit tools
-- npm publish, pip publish, twine upload — publishing packages requires explicit user action
-- git push --force / git push -f — destructive remote history rewrite
-- Accessing credential files unrelated to the current task (~/.aws, ~/.ssh/id_rsa, /etc/passwd)
-- Commands that clearly contradict the user's stated intent
-
-Use the user's recent messages to judge intent. If the user asked for something and the tool call implements it, ALLOW.
-
-Output exactly one word: ALLOW or DENY.`;
-
 		const userPrompt = this.buildUserPrompt(toolName, argsJson, context);
 
 		return new Promise<boolean>((resolve, reject) => {
 			const data = JSON.stringify({
 				model: modelId,
 				max_tokens: 10,
-				system: systemPrompt,
+				system: CLASSIFIER_SYSTEM_PROMPT,
 				messages: [{ role: "user", content: userPrompt }],
 			});
 			const headers: Record<string, string | number> = {
@@ -349,39 +349,11 @@ Output exactly one word: ALLOW or DENY.`;
 		argsJson: string,
 		context: ClassifierContext,
 	): Promise<boolean> {
-		const systemPrompt = `You are a security classifier for an autonomous coding agent. Decide ALLOW or DENY for a pending tool call.
-
-DEFAULT: ALLOW. The user enabled auto mode because they trust the agent. Only deny clear security violations.
-
-ALLOW:
-- Read-only commands
-- Git read commands
-- Build/test/lint commands
-- Writing/editing files inside the project
-- Commands clearly requested by the user
-
-DENY:
-- rm/unlink/rmdir unless the user explicitly asked to delete/remove that file
-- system-path modifications (/etc, /usr, /bin, /System, ~/.ssh)
-- sudo/su
-- curl/wget piped to shell
-- exfiltrating local secrets/files
-- ssh/scp/sftp
-- nc/ncat -l
-- kill -9 / killall
-- crontab
-- dd / mkfs
-- sed -i
-- npm/pip/twine publish
-- git push --force / -f
-
-Output exactly one word: ALLOW or DENY.`;
-
 		const userPrompt = this.buildUserPrompt(toolName, argsJson, context);
 
 		return new Promise<boolean>((resolve, reject) => {
 			const data = JSON.stringify({
-				system_instruction: { parts: [{ text: systemPrompt }] },
+				system_instruction: { parts: [{ text: CLASSIFIER_SYSTEM_PROMPT }] },
 				contents: [{ role: "user", parts: [{ text: userPrompt }] }],
 				generationConfig: { temperature: 0, maxOutputTokens: 8 },
 			});

package/packages/pi-coding-agent/src/core/compaction/utils.ts

@@ -267,4 +267,6 @@ export function serializeConversation(messages: Message[]): string {
 
 export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.
 
-Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;
+Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.
+
+CRITICAL: Never reproduce secrets, API keys, tokens, passwords, or credentials in the summary. If you encounter any, redact them as [REDACTED].`;

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

@@ -7,7 +7,7 @@ import test from "node:test";
 import { DefaultResourceLoader } from "./resource-loader.js";
 import { SettingsManager } from "./settings-manager.js";
 
-test("resource loader reads global lsd.md from the app root", async (t) => {
+test("resource loader reads global LSD.md from the app root", async (t) => {
 	const tmp = mkdtempSync(join(tmpdir(), "resource-loader-lsd-md-"));
 	t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
@@ -16,7 +16,7 @@ test("resource loader reads global lsd.md from the app root", async (t) => {
 	const cwd = join(tmp, "project");
 	mkdirSync(agentDir, { recursive: true });
 	mkdirSync(cwd, { recursive: true });
-	writeFileSync(join(appRoot, "lsd.md"), "# global lsd\n", "utf-8");
+	writeFileSync(join(appRoot, "LSD.md"), "# global lsd\n", "utf-8");
 
 	const loader = new DefaultResourceLoader({
 		cwd,
@@ -31,11 +31,11 @@ test("resource loader reads global lsd.md from the app root", async (t) => {
 
 	const contextFiles = loader.getAgentsFiles().agentsFiles;
 	assert.equal(contextFiles.length, 1);
-	assert.equal(contextFiles[0]?.path, join(appRoot, "lsd.md"));
+	assert.equal(contextFiles[0]?.path, join(appRoot, "LSD.md"));
 	assert.equal(contextFiles[0]?.content, "# global lsd\n");
 });
 
-test("resource loader reads ancestor .lsd/lsd.md before AGENTS.md in the same directory", async (t) => {
+test("resource loader uses project LSD.md before CLAUDE.md or AGENTS.md in the same directory", async (t) => {
 	const tmp = mkdtempSync(join(tmpdir(), "resource-loader-lsd-md-"));
 	t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
@@ -44,9 +44,9 @@ test("resource loader reads ancestor .lsd/lsd.md before AGENTS.md in the same di
 	const projectRoot = join(tmp, "project");
 	const cwd = join(projectRoot, "src", "feature");
 	mkdirSync(agentDir, { recursive: true });
-	mkdirSync(join(projectRoot, ".lsd"), { recursive: true });
 	mkdirSync(cwd, { recursive: true });
-	writeFileSync(join(projectRoot, ".lsd", "lsd.md"), "# project lsd\n", "utf-8");
+	writeFileSync(join(projectRoot, "LSD.md"), "# project lsd\n", "utf-8");
+	writeFileSync(join(projectRoot, "CLAUDE.md"), "# claude fallback\n", "utf-8");
 	writeFileSync(join(projectRoot, "AGENTS.md"), "# agents fallback\n", "utf-8");
 
 	const loader = new DefaultResourceLoader({
@@ -62,6 +62,66 @@ test("resource loader reads ancestor .lsd/lsd.md before AGENTS.md in the same di
 
 	const contextFiles = loader.getAgentsFiles().agentsFiles;
 	assert.equal(contextFiles.length, 1);
-	assert.equal(contextFiles[0]?.path, join(projectRoot, ".lsd", "lsd.md"));
+	assert.equal(contextFiles[0]?.path, join(projectRoot, "LSD.md"));
 	assert.equal(contextFiles[0]?.content, "# project lsd\n");
 });
+
+test("resource loader loads both global and project LSD.md files", async (t) => {
+	const tmp = mkdtempSync(join(tmpdir(), "resource-loader-lsd-md-"));
+	t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+	const appRoot = join(tmp, ".lsd");
+	const agentDir = join(appRoot, "agent");
+	const projectRoot = join(tmp, "project");
+	const cwd = join(projectRoot, "src", "feature");
+	mkdirSync(agentDir, { recursive: true });
+	mkdirSync(cwd, { recursive: true });
+	writeFileSync(join(appRoot, "LSD.md"), "# global lsd\n", "utf-8");
+	writeFileSync(join(projectRoot, "LSD.md"), "# project lsd\n", "utf-8");
+
+	const loader = new DefaultResourceLoader({
+		cwd,
+		agentDir,
+		settingsManager: SettingsManager.inMemory(),
+		noExtensions: true,
+		noSkills: true,
+		noPromptTemplates: true,
+		noThemes: true,
+	});
+	await loader.reload();
+
+	const contextFiles = loader.getAgentsFiles().agentsFiles;
+	assert.equal(contextFiles.length, 2);
+	assert.equal(contextFiles[0]?.path, join(appRoot, "LSD.md"));
+	assert.equal(contextFiles[1]?.path, join(projectRoot, "LSD.md"));
+});
+
+test("resource loader falls back to CLAUDE.md when no LSD.md exists", async (t) => {
+	const tmp = mkdtempSync(join(tmpdir(), "resource-loader-lsd-md-"));
+	t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+	const appRoot = join(tmp, ".lsd");
+	const agentDir = join(appRoot, "agent");
+	const projectRoot = join(tmp, "project");
+	const cwd = join(projectRoot, "src", "feature");
+	mkdirSync(agentDir, { recursive: true });
+	mkdirSync(cwd, { recursive: true });
+	writeFileSync(join(projectRoot, "CLAUDE.md"), "# claude fallback\n", "utf-8");
+	writeFileSync(join(projectRoot, "AGENTS.md"), "# agents fallback\n", "utf-8");
+
+	const loader = new DefaultResourceLoader({
+		cwd,
+		agentDir,
+		settingsManager: SettingsManager.inMemory(),
+		noExtensions: true,
+		noSkills: true,
+		noPromptTemplates: true,
+		noThemes: true,
+	});
+	await loader.reload();
+
+	const contextFiles = loader.getAgentsFiles().agentsFiles;
+	assert.equal(contextFiles.length, 1);
+	assert.equal(contextFiles[0]?.path, join(projectRoot, "CLAUDE.md"));
+	assert.equal(contextFiles[0]?.content, "# claude fallback\n");
+});

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

@@ -71,14 +71,14 @@ function tryReadContextFile(filePath: string): { path: string; content: string }
 
 function loadContextFileFromDir(dir: string): { path: string; content: string } | null {
 	const candidates = [
-		join(dir, "lsd.md"),
-		join(dir, ".lsd", "lsd.md"),
-		join(dir, CONFIG_DIR_NAME, "lsd.md"),
 		join(dir, "LSD.md"),
 		join(dir, ".lsd", "LSD.md"),
 		join(dir, CONFIG_DIR_NAME, "LSD.md"),
-		join(dir, "AGENTS.md"),
+		join(dir, "lsd.md"),
+		join(dir, ".lsd", "lsd.md"),
+		join(dir, CONFIG_DIR_NAME, "lsd.md"),
 		join(dir, "CLAUDE.md"),
+		join(dir, "AGENTS.md"),
 	];
 	for (const filePath of new Set(candidates)) {
 		const loaded = tryReadContextFile(filePath);

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

@@ -80,3 +80,103 @@ test("createAgentSession restores last session model even when API key cannot be
 		}
 	}
 });
+
+test("createAgentSession defaults to adaptive for supported Anthropic models when enabled", async () => {
+	const tempDir = join(
+		process.cwd(),
+		".tmp-tests",
+		`sdk-anthropic-adaptive-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(tempDir, { recursive: true });
+	tempDirs.push(tempDir);
+
+	const authStorage = AuthStorage.inMemory({
+		anthropic: { type: "api_key", key: "test-anthropic-key" },
+	});
+	const modelRegistry = new ModelRegistry(authStorage, join(tempDir, "models.json"));
+	const settingsManager = SettingsManager.inMemory();
+	settingsManager.setDefaultModelAndProvider("anthropic", "claude-sonnet-4-6");
+	settingsManager.setDefaultThinkingLevel("high");
+	settingsManager.setAnthropicAdaptiveByDefault(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, "anthropic");
+	assert.equal(session.model?.id, "claude-sonnet-4-6");
+	assert.equal(session.thinkingLevel, "adaptive");
+	assert.equal(settingsManager.getDefaultThinkingLevel(), "high");
+	session.dispose();
+});
+
+test("AgentSession switches supported Anthropic models to adaptive when the setting is enabled", async () => {
+	const tempDir = join(
+		process.cwd(),
+		".tmp-tests",
+		`sdk-anthropic-switch-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(tempDir, { recursive: true });
+	tempDirs.push(tempDir);
+
+	const authStorage = AuthStorage.inMemory({
+		anthropic: { type: "api_key", key: "test-anthropic-key" },
+		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.setAnthropicAdaptiveByDefault(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.thinkingLevel, "high");
+
+	const anthropicModel = modelRegistry.getAvailable().find((model) =>
+		model.provider === "anthropic" && model.id === "claude-sonnet-4-6"
+	);
+	if (!anthropicModel) throw new Error("expected claude-sonnet-4-6 to be available");
+
+	await session.setModel(anthropicModel);
+
+	assert.equal(session.model?.provider, "anthropic");
+	assert.equal(session.model?.id, "claude-sonnet-4-6");
+	assert.equal(session.thinkingLevel, "adaptive");
+	session.dispose();
+});

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

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { Agent, type AgentMessage, type ThinkingLevel } from "@gsd/pi-agent-core";
-import type { Message, Model } from "@gsd/pi-ai";
+import { supportsAdaptiveThinking, type Message, type Model } from "@gsd/pi-ai";
 import { getAgentDir, getDocsPath } from "../config.js";
 import { AgentSession } from "./agent-session.js";
 import { AuthStorage } from "./auth-storage.js";
@@ -140,6 +140,17 @@ function getDefaultAgentDir(): string {
     return getAgentDir();
 }
 
+function shouldPreferAdaptiveThinkingByDefault(
+    model: Model<any> | undefined,
+    settingsManager: SettingsManager,
+): boolean {
+    return !!model &&
+        model.provider === "anthropic" &&
+        model.reasoning === true &&
+        settingsManager.getAnthropicAdaptiveByDefault() &&
+        supportsAdaptiveThinking(model.id);
+}
+
 /**
  * Create an AgentSession with the specified options.
  *
@@ -252,32 +263,24 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
         thinkingLevel = settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
     }
 
+    const preferAdaptiveByDefault = shouldPreferAdaptiveThinkingByDefault(model, settingsManager);
+    if (preferAdaptiveByDefault) {
+        thinkingLevel = "adaptive";
+    }
+
     // Clamp to model capabilities
     if (!model || !model.reasoning) {
         thinkingLevel = "off";
     }
 
     const editMode = settingsManager.getEditMode();
-    const toolSearchEnabled = settingsManager.getToolSearch();
-    const defaultActiveToolNames: string[] = toolSearchEnabled
-        ? (editMode === "hashline"
-            ? ["hashline_read", "bash", "lsp", "tool_search", "tool_enable"]
-            : ["read", "bash", "lsp", "tool_search", "tool_enable"])
-        : editMode === "hashline"
-            ? [
-                "hashline_read",
-                "bash",
-                "hashline_edit",
-                "write",
-                "lsp",
-                "pty_start",
-                "pty_send",
-                "pty_read",
-                "pty_wait",
-                "pty_resize",
-                "pty_kill",
-            ]
-            : ["read", "bash", "edit", "write", "lsp", "pty_start", "pty_send", "pty_read", "pty_wait", "pty_resize", "pty_kill"];
+    const toolProfile = settingsManager.getToolProfile();
+    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 defaultActiveToolNames: string[] = toolProfile === "full"
+        ? Object.keys(allTools)
+        : balancedToolNames;
     const initialActiveToolNames: string[] = options.tools
         ? options.tools.map((t) => t.name).filter((n): n is string => typeof n === "string" && n in allTools)
         : defaultActiveToolNames;