@oh-my-pi/pi-coding-agent 16.0.8 → 16.0.10

package/src/main.ts

@@ -72,7 +72,7 @@ import { shouldShowStartupSplash } from "./startup-splash";
 import { discoverTitleSystemPromptFile, resolvePromptInput } from "./system-prompt";
 import { createPersistedSubagentReviverFactory } from "./task/persisted-revive";
 import { initTelemetryExport, isTelemetryExportEnabled } from "./telemetry-export";
-import { AUTO_THINKING } from "./thinking";
+import { AUTO_THINKING, parseConfiguredThinkingLevel } from "./thinking";
 import type { LspStartupServerInfo } from "./tools";
 import {
 	getChangelogPath,
@@ -857,7 +857,7 @@ async function buildSessionOptions(
 	if (scopedModels.length > 0) {
 		// `auto` is a session-level concept only; per-scoped-model (Ctrl+P) thinking
 		// overrides stay concrete, so coerce the auto default to "unset" here.
-		const defaultThinkingLevelSetting = activeSettings.get("defaultThinkingLevel");
+		const defaultThinkingLevelSetting = parseConfiguredThinkingLevel(activeSettings.get("defaultThinkingLevel"));
 		const defaultThinkingLevel =
 			defaultThinkingLevelSetting === AUTO_THINKING ? undefined : defaultThinkingLevelSetting;
 		options.scopedModels = scopedModels.map(scopedModel => ({
@@ -1039,6 +1039,13 @@ export async function runRootCommand(
 		});
 	}
 
+	// --print-thoughts (single-shot print mode) must surface reasoning, so un-hide
+	// thinking before the session is built — otherwise a passive hideThinkingBlock
+	// setting makes the provider omit summaries and the flag prints nothing. An
+	// explicit --hide-thinking below still wins.
+	if (parsedArgs.printThoughts && !isProtocolMode && !isInteractive) {
+		settingsInstance.override("hideThinkingBlock", false);
+	}
 	// Apply --hide-thinking CLI flag (ephemeral, not persisted)
 	if (parsedArgs.hideThinking) {
 		settingsInstance.override("hideThinkingBlock", true);
@@ -1373,6 +1380,7 @@ export async function runRootCommand(
 				messages: initialArgs.messages,
 				initialMessage,
 				initialImages,
+				printThoughts: initialArgs.printThoughts,
 			});
 			if ($env.PI_TIMING) {
 				logger.printTimings();

package/src/modes/components/oauth-selector.ts

@@ -10,6 +10,7 @@ import {
 	Spacer,
 	TruncatedText,
 } from "@oh-my-pi/pi-tui";
+import { settings } from "../../config/settings";
 import { theme } from "../../modes/theme/theme";
 import { matchesSelectCancel, matchesSelectDown, matchesSelectUp } from "../../modes/utils/keybinding-matchers";
 import type { AuthStorage, CredentialOriginKind } from "../../session/auth-storage";
@@ -17,6 +18,20 @@ import { DynamicBorder } from "./dynamic-border";
 
 const OAUTH_SELECTOR_MAX_VISIBLE = 10;
 
+/**
+ * Provider ids the user has disabled via settings. `/login` (login mode) hides
+ * these so a disabled provider's models stay out of reach end-to-end, mirroring
+ * the model picker's `disabledProviders` filtering. Reads the settings singleton
+ * defensively: it throws before `Settings.init()`, in which case nothing is disabled.
+ */
+function getDisabledProviderIds(): ReadonlySet<string> {
+	try {
+		return new Set(settings.get("disabledProviders"));
+	} catch {
+		return new Set();
+	}
+}
+
 /**
  * Rendered lines before the provider rows: top border, spacer, title, spacer
  * (must mirror the constructor's addChild order).
@@ -102,8 +117,22 @@ export class OAuthSelectorComponent extends Container {
 
 	#loadProviders(): void {
 		const providers = getOAuthProviders();
-		this.#allProviders =
-			this.#mode === "logout" ? providers.filter(provider => this.#hasSelectableAuth(provider.id)) : providers;
+		if (this.#mode === "logout") {
+			// Logout stays unfiltered by `disabledProviders`: a now-disabled
+			// provider may still hold stored credentials worth removing.
+			this.#allProviders = providers.filter(provider => this.#hasSelectableAuth(provider.id));
+		} else {
+			const disabled = getDisabledProviderIds();
+			// Hide a login entry when either its own id or the provider id it
+			// stores credentials under is disabled, so alias logins (e.g.
+			// `openai-codex-device` ⇒ `openai-codex`) disappear alongside the
+			// model provider they authenticate.
+			this.#allProviders = providers.filter(
+				provider =>
+					!disabled.has(provider.id) &&
+					!(provider.storeCredentialsAs && disabled.has(provider.storeCredentialsAs)),
+			);
+		}
 		this.#filteredProviders = this.#allProviders;
 	}
 

package/src/modes/interactive-mode.ts

@@ -797,7 +797,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		await this.initHooksAndCustomTools();
 
 		// Restore mode from session (e.g. plan mode on resume)
-		this.session.setSessionSwitchReconciler?.(() => this.#reconcileModeFromSession());
+		this.session.setSessionSwitchReconciler?.(() => this.#reconcileModeFromSession({ preserveActiveGoal: true }));
 		await this.#reconcileModeFromSession();
 
 		// Brand-new sessions optionally start in plan mode when the user has made it
@@ -1783,11 +1783,12 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	/** Reconcile mode state from session entries on resume/switch. */
-	async #reconcileModeFromSession(): Promise<void> {
+	async #reconcileModeFromSession(options?: { preserveActiveGoal?: boolean }): Promise<void> {
 		await this.#clearTransientModeState();
 		const sessionContext = this.sessionManager.buildSessionContext();
 		const goalEnabled = this.session.settings.get("goal.enabled");
 		if (!goalEnabled && (sessionContext.mode === "goal" || sessionContext.mode === "goal_paused")) {
+			this.session.goalRuntime.clearAccounting();
 			this.sessionManager.appendModeChange("none");
 			return;
 		}
@@ -1802,7 +1803,9 @@ export class InteractiveMode implements InteractiveModeContext {
 				mode: "active",
 				goal,
 			});
-			const restored = await this.session.goalRuntime.onThreadResumed();
+			const restored = await this.session.goalRuntime.onThreadResumed({
+				preserveActiveGoal: options?.preserveActiveGoal,
+			});
 			this.goalModeEnabled = restored?.enabled === true;
 			this.goalModePaused = restored?.enabled !== true && restored?.goal.status === "paused";
 			// sdk.ts excludes "goal" from the initial active tool set unconditionally.
@@ -1815,6 +1818,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#updateGoalModeStatus();
 			return;
 		}
+		this.session.goalRuntime.clearAccounting();
 		if (!this.session.settings.get("plan.enabled")) {
 			// Clear stale plan/plan_paused mode so re-enabling the setting
 			// later doesn't unexpectedly restore an old plan session.

package/src/modes/print-mode.ts

@@ -24,6 +24,8 @@ export interface PrintModeOptions {
 	initialMessage?: string;
 	/** Images to attach to the initial message */
 	initialImages?: ImageContent[];
+	/** If true, include thinking blocks in text output */
+	printThoughts?: boolean;
 }
 
 /**
@@ -31,7 +33,7 @@ export interface PrintModeOptions {
  * Sends prompts to the agent and outputs the result.
  */
 export async function runPrintMode(session: AgentSession, options: PrintModeOptions): Promise<void> {
-	const { mode, messages = [], initialMessage, initialImages } = options;
+	const { mode, messages = [], initialMessage, initialImages, printThoughts } = options;
 
 	// Emit session header for JSON mode
 	if (mode === "json") {
@@ -108,6 +110,8 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 			for (const content of assistantMsg.content) {
 				if (content.type === "text") {
 					process.stdout.write(`${sanitizeText(content.text)}\n`);
+				} else if (printThoughts && content.type === "thinking" && content.thinking.trim().length > 0) {
+					process.stdout.write(`${sanitizeText(content.thinking)}\n`);
 				}
 			}
 		}

package/src/prompts/advisor/advise-tool.md

@@ -1 +1,3 @@
-Send one concrete, terse piece of advice to the agent you are watching. Use sparingly; stay silent when nothing matters.
+Send one concrete, terse piece of advice to the agent you are watching.
+- Use sparingly; stay silent when nothing matters.
+- Call it to head off likely-wrong or materially wasteful work.

package/src/prompts/advisor/system.md

@@ -1,32 +1,75 @@
 <system-conventions>
 RFC 2119 applies to MUST, REQUIRED, SHOULD, RECOMMENDED, MAY, OPTIONAL. `NEVER` and `AVOID` are aliases for `MUST NOT` and `SHOULD NOT`.
-You can explore the workspace; budget is 2–3 tool calls per advise (exception: critical bugs warrant deeper verification before raising a blocker).
 </system-conventions>
 
-You bring a different angle.
-The agent might not have thought about an edge case, spotted a hallucinated API, or realized a simpler approach exists.
+You bring a different angle, and advocate for the user and the code-quality & robustness.
+You're watching over the main agent as a peer-programmer:
+- They might not have thought about an edge case, or realized a more elegant approach exists.
+- They might be sinking deeper into a hole that will not get the user's request accomplished.
+
 Your job is to offer that view before they sink work into the wrong direction.
 
 <workflow>
-You receive the agent's transcript incrementally, including private thinking.
+You receive the agent's transcript incrementally, including their thoughts.
 You have read-only access through `read`, `search`, `find` to verify your suspicions.
-Keep exploration lean — 2–3 calls per advise unless you've spotted a critical bug and need to be absolutely certain before raising a blocker.
+Keep exploration lean:
+- 2–3 tool calls per advise.
+- Exception: critical bugs may need deeper verification before raising a blocker.
 </workflow>
 
 <communication>
-At most one `advise` per update. Prefer silence when the agent is on track. Address the agent directly. Offer alternatives, not lectures. Never restate what they know; never explain how to use the advisor.
-Do not comment merely to add insight, context, or a second opinion. NEVER restate information the agent already has, including tool or CLI errors returned directly to it. NEVER flag a problem that will surface on its own — type errors, LSP diagnostics, failed builds, failing tests, lint — the agent's own tooling catches those. NEVER repeat advice you already gave.
+- You call `advise` to surface your commentary to the driving agent; at most one `advise` per update.
+- Prefer silence when the agent is on track.
+- Address the agent directly.
+- Offer alternatives, not lectures.
+- NEVER restate information the agent already has, including errors they have seen.
+- Examples: type errors, LSP diagnostics, failed builds, failing tests, lint.
+- NEVER repeat advice you already gave.
+- NEVER nitpick about things user stated they are okay with. You are the advocate for the user.
 </communication>
 
 <critical>
-You SHOULD call `advise` when: agent might be heading the wrong way, missed an edge case, about to call a hallucinated API, going in circles, picking brittle approach over better one. Low confidence bar — "this might be wrong" is worth noting if they didn't think about it.
+A low-confidence bar applies ONLY to concrete technical risk:
+- Generic uncertainty, vague unease, or user-intent ambiguity → stay SILENT.
+
 NEVER advise just to second-guess decisions the agent understands and is committed to, if you are not certain.
+
+NEVER advise on intent or process:
+- Do not push the agent to ask for clarification, confirm scope, or summarize input before acting.
+- Do not question whether the user's ask is clear enough.
+- Intent is the agent's domain; it defaults to informed action.
+- Your lane: correctness, edge cases, design, process.
+
+Cite the exact instruction or risk.
 </critical>
 
 <completeness>
-**`nit`** — Non-urgent cleanup, refactor, style, missed opportunity. Folded at next step boundary; agent keeps working. Examples: edge cases that don't break correctness, simplifications, better approach the agent can consider.
-**`concern`** — Agent might be heading wrong or missed something material. Offers your view; agent decides. Use when: exploring wrong code path, picking fragile approach when better exists, missing constraint, hallucinated API, going in circles, edge case about to be baked in.
-**`blocker`** — Stop and reconsider. Use ONLY when: continuing will clearly waste the turn, produce broken output, or the path is fundamentally unsound. Verify thoroughly before raising.
+**`nit`**
+- Non-urgent cleanup, refactor, style, missed opportunity.
+- Folded at next step boundary; agent keeps working.
+- Examples:
+  - Edge cases that don't break correctness.
+  - Simplifications.
+  - Better approach the agent can consider.
+
+**`concern`**
+- Agent might be heading wrong or missed something material.
+- Offers your view; agent decides.
+- Use when:
+  - Exploring wrong code path.
+  - Picking fragile approach when better exists.
+  - Not parallelizing when user request is obviously parallelizable.
+  - Missing constraint.
+  - Edge case about to be baked in.
+
+**`blocker`**
+- Stop and reconsider.
+- Use ONLY when the agent making progress will clearly:
+  - Waste the users time with a larger refactor.
+  - Will require the user to interrupt the agent later on, due to them going in circles without a solution.
+  - Be fundamentally unsound.
+- Verify thoroughly before raising.
 </completeness>
 
-You MAY suggest an approach or fix if you've explored enough to be confident. Your job is pair programming, not just bugs — offer the better designs, not just the warning.
+You MAY suggest an approach or fix if you've explored enough to be confident.
+Offer the better designs, not just the warning.

package/src/prompts/tools/inspect-image.md

@@ -2,7 +2,7 @@ Inspects an image file with a vision-capable model and returns compact text anal
 
 <instruction>
 - Use this for image understanding tasks (OCR, UI/screenshot debugging, scene/object questions)
-- Provide `path` to the local image file
+- Provide `path` as a local image file path, `Image #N` attachment label, or `attachment://N` URI
 - Write a specific `question`:
   - what to inspect
   - constraints (for example: "quote visible text verbatim", "only report confirmed findings")

package/src/sdk.ts

@@ -144,6 +144,7 @@ import { AgentOutputManager } from "./task/output-manager";
 import {
 	AUTO_THINKING,
 	type ConfiguredThinkingLevel,
+	parseConfiguredThinkingLevel,
 	parseThinkingLevel,
 	resolveProvisionalAutoLevel,
 	resolveThinkingLevelForModel,
@@ -1266,12 +1267,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			? getRestorableSessionModels(existingSession.models, sessionManager.getLastModelChangeRole())
 			: [];
 	let restoredSessionModelIndex = -1;
+	let restoredSessionThinkingLevel: ThinkingLevel | undefined;
 	if (!hasExplicitModel && !model && sessionModelStrings.length > 0) {
 		logger.time("restoreSessionModel", () => {
 			let failedSessionModel: string | undefined;
 			for (let i = 0; i < sessionModelStrings.length; i++) {
 				const sessionModelStr = sessionModelStrings[i];
-				const parsedModel = parseModelString(sessionModelStr);
+				const parsedModel = parseModelString(sessionModelStr, {
+					allowMaxAlias: true,
+					isLiteralModelId: (provider, id) => modelRegistry.find(provider, id) !== undefined,
+				});
 				if (!parsedModel) {
 					failedSessionModel ??= sessionModelStr;
 					continue;
@@ -1281,6 +1286,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				if (restoredModel && hasModelAuth(restoredModel)) {
 					model = restoredModel;
 					restoredSessionModelIndex = i;
+					restoredSessionThinkingLevel = parsedModel.thinkingLevel;
 					break;
 				}
 				failedSessionModel ??= sessionModelStr;
@@ -1305,15 +1311,19 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const taskDepth = options.taskDepth ?? 0;
 
 	// Resolves the session/agent thinking level using the same precedence we
-	// apply at startup: explicit option → persisted session entry → default
-	// role's explicit selector → selected model's defaultLevel → global
-	// settings default. Run again after extension role reclaim so the final
-	// model's own defaults aren't masked by an earlier fallback model's.
+	// apply at startup: explicit option → persisted session entry → restored
+	// model selector suffix → default role's explicit selector → selected
+	// model's defaultLevel → global settings default. Run again after extension
+	// role reclaim so the final model's own defaults aren't masked by an earlier
+	// fallback model's.
 	const pickInitialThinkingLevel = (selectedModel: Model | undefined): ConfiguredThinkingLevel | undefined => {
 		let level = options.thinkingLevel;
 		if (level === undefined && hasExistingSession && hasThinkingEntry) {
 			level = parseThinkingLevel(existingSession.thinkingLevel);
 		}
+		if (level === undefined && !hasThinkingEntry && restoredSessionThinkingLevel !== undefined) {
+			level = restoredSessionThinkingLevel;
+		}
 		if (level === undefined && !hasExplicitModel && !hasThinkingEntry && defaultRoleSpec.explicitThinkingLevel) {
 			level = defaultRoleSpec.thinkingLevel;
 		}
@@ -1321,7 +1331,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			level = selectedModel.thinking.defaultLevel;
 		}
 		if (level === undefined) {
-			level = settings.get("defaultThinkingLevel");
+			level = parseConfiguredThinkingLevel(settings.get("defaultThinkingLevel"));
 		}
 		return level;
 	};
@@ -1533,6 +1543,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			getModelString: () => (hasExplicitModel && model ? formatModelString(model) : undefined),
 			getActiveModelString,
 			getActiveModel: () => agent?.state.model ?? model,
+			getImageAttachments: () => session?.getImageAttachments() ?? [],
 			getPlanModeState: () => session?.getPlanModeState(),
 			getPlanReferencePath: () => session?.getPlanReferencePath() ?? "local://PLAN.md",
 			getGoalModeState: () => session?.getGoalModeState(),
@@ -1905,13 +1916,17 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		if (!hasExplicitModel && sessionRetryLimit > 0) {
 			for (let i = 0; i < sessionRetryLimit; i++) {
 				const sessionModelStr = sessionModelStrings[i];
-				const parsedModel = parseModelString(sessionModelStr);
+				const parsedModel = parseModelString(sessionModelStr, {
+					allowMaxAlias: true,
+					isLiteralModelId: (provider, id) => modelRegistry.find(provider, id) !== undefined,
+				});
 				if (!parsedModel) continue;
 				const restoredModel = modelRegistry.find(parsedModel.provider, parsedModel.id);
 				if (restoredModel && hasModelAuth(restoredModel)) {
 					model = restoredModel;
 					modelFallbackMessage = undefined;
 					restoredSessionModelIndex = i;
+					restoredSessionThinkingLevel = parsedModel.thinkingLevel;
 					// Recompute thinking-level from scratch against the reclaimed
 					// model: any value derived from the earlier fallback model's
 					// `thinking.defaultLevel` must not become sticky.
@@ -2585,6 +2600,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		if (watchdogFiles && watchdogFiles.length > 0) {
 			advisorWatchdogPrompt = watchdogFiles.join("\n\n");
 		}
+		// Owned only when this session created the manager; subagents receive a
+		// parent's manager via `options.mcpManager` and MUST NOT disconnect it.
+		const ownedMcpManager = options.mcpManager ? undefined : mcpManager;
 		session = new AgentSession({
 			advisorWatchdogPrompt,
 			agent,
@@ -2630,6 +2648,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 						return out;
 					}
 				: undefined,
+			disconnectOwnedMcpManager: ownedMcpManager ? () => ownedMcpManager.disconnectAll() : undefined,
 			mcpDiscoveryEnabled,
 			initialSelectedMCPToolNames,
 			defaultSelectedMCPToolNames,