@oh-my-pi/pi-coding-agent 13.9.1 → 13.9.3

package/CHANGELOG.md

@@ -2,6 +2,83 @@
 
 ## [Unreleased]
 
+## [13.9.3] - 2026-03-07
+
+### Breaking Changes
+
+- Changed `ThinkingLevel` type to be imported from `@oh-my-pi/pi-agent-core` instead of `@oh-my-pi/pi-ai`
+- Changed thinking level representation from string literals to `Effort` enum values (e.g., `Effort.High` instead of `"high"`)
+- Changed `getThinkingLevel()` return type to `ThinkingLevel | undefined` to support models without thinking support
+- Changed model `reasoning` property to `thinking` property with `ThinkingConfig` for explicit effort level configuration
+- Changed `thinkingLevel` in session context to be optional (`ThinkingLevel | undefined`) instead of always present
+
+### Added
+
+- Added `thinking.ts` module with `getThinkingLevelMetadata()` and `resolveThinkingLevelForModel()` utilities for thinking level handling
+- Added `ThinkingConfig` support to model definitions for specifying supported thinking effort levels per model
+- Added `enrichModelThinking()` function to apply thinking configuration to models during registry initialization
+- Added `clampThinkingLevelForModel()` function to constrain thinking levels to model-supported ranges
+- Added `getSupportedEfforts()` function to retrieve available thinking efforts for a model
+- Added `Effort` enum import from `@oh-my-pi/pi-ai` for type-safe thinking level representation
+- Added `/fast` slash command to toggle OpenAI service tier priority mode for faster response processing
+- Added `serviceTier` setting to control OpenAI processing priority (none, auto, default, flex, scale, priority)
+- Added `compaction.remoteEnabled` setting to control use of remote compaction endpoints
+- Added remote compaction support for OpenAI and OpenAI Codex models with encrypted reasoning preservation
+- Added fast mode indicator (⚡) to model segment in status line when priority service tier is active
+- Added context usage threshold levels (normal, warning, purple, error) with token-aware thresholds for better context awareness
+- Added `isFastModeEnabled()`, `setFastMode()`, and `toggleFastMode()` methods to AgentSession for fast mode control
+
+### Changed
+
+- Changed credential deletion to disable credentials with persisted cause instead of permanent deletion
+- Added `disabledCause` parameter to credential deletion methods to track reason for disabling
+- Changed thinking level parsing to use `parseEffort()` from local thinking module instead of `parseThinkingLevel()` from pi-ai
+- Changed model list display to show supported thinking efforts (e.g., "low,medium,high") instead of yes/no reasoning indicator
+- Changed footer and status line to check `model.thinking` instead of `model.reasoning` for thinking level display
+- Changed thinking selector to work with `Effort` type instead of `ThinkingLevel` for available levels
+- Changed model resolver to return `undefined` for thinking level instead of `"off"` when no thinking is specified
+- Changed compaction reasoning parameters to use `Effort` enum values instead of string literals
+- Changed RPC types to use `Effort` for cycling thinking levels and `ThinkingLevel | undefined` for session state
+- Changed theme thinking border color function to accept both `ThinkingLevel` and `Effort` types
+- Changed context usage coloring in footer and status line to use token-aware thresholds instead of fixed percentages
+- Changed compaction to preserve OpenAI remote compaction state and encrypted reasoning across sessions
+- Changed compaction to skip emitting kept messages when using OpenAI remote compaction with preserved history
+- Changed session context to include `serviceTier` field for tracking active service tier across session branches
+- Changed `compact()` function to accept `remoteInstructions` option for custom remote compaction prompts
+- Changed model registry to apply hardcoded policies (gpt-5.4 context window) consistently across all model loading paths
+
+### Fixed
+
+- Fixed OpenAI remote compaction to correctly append incremental responses instead of replacing entire history
+- Fixed thinking level display logic in main.ts to correctly check for undefined instead of "off"
+- Fixed model registry to preserve explicit thinking configuration on runtime-registered models
+- Fixed usage limit reset time calculation to use absolute `resetsAt` timestamps instead of deprecated `resetInMs` field
+- Fixed compaction summary message creation to no longer be automatically added to chat during compaction (now handled by session manager)
+
+## [13.9.2] - 2026-03-05
+
+### Added
+
+- Support for Python code execution messages with output display and error handling
+- Support for mode change entries in session exports
+- Support for TTSR injection and session initialization entries in tree filtering
+
+### Changed
+
+- Updated label lookup to use `targetId` field instead of `parentId` for label references
+- Changed model change entry display to use `model` field instead of separate `provider` and `modelId` fields
+- Simplified model change rendering by removing OpenAI Codex bridge prompt display
+- Updated searchable text extraction to include Python code from `pythonExecution` messages
+
+### Removed
+
+- Removed `codexInjectionInfo` from session data destructuring
+- Removed OpenAI Codex-specific bridge prompt UI from model change entries
+
+### Fixed
+
+- Auto-corrected off-by-one range start errors in hashline edits that would duplicate preceding lines
+
 ## [13.9.0] - 2026-03-05
 ### Added
 

package/examples/sdk/02-custom-model.ts

@@ -3,6 +3,7 @@
  *
  * Shows how to select a specific model and thinking level.
  */
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { getModel } from "@oh-my-pi/pi-ai";
 import { createAgentSession, discoverAuthStorage, discoverModels } from "@oh-my-pi/pi-coding-agent";
 
@@ -32,7 +33,7 @@ console.log(
 if (available.length > 0) {
 	const { session } = await createAgentSession({
 		model: available[0],
-		thinkingLevel: "medium", // off, low, medium, high
+		thinkingLevel: ThinkingLevel.Medium, // off, low, medium, high
 		authStorage,
 		modelRegistry,
 	});

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.9.1",
+	"version": "13.9.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.9.1",
-		"@oh-my-pi/pi-agent-core": "13.9.1",
-		"@oh-my-pi/pi-ai": "13.9.1",
-		"@oh-my-pi/pi-natives": "13.9.1",
-		"@oh-my-pi/pi-tui": "13.9.1",
-		"@oh-my-pi/pi-utils": "13.9.1",
+		"@oh-my-pi/omp-stats": "13.9.3",
+		"@oh-my-pi/pi-agent-core": "13.9.3",
+		"@oh-my-pi/pi-ai": "13.9.3",
+		"@oh-my-pi/pi-natives": "13.9.3",
+		"@oh-my-pi/pi-tui": "13.9.3",
+		"@oh-my-pi/pi-utils": "13.9.3",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/cli/args.ts

@@ -1,9 +1,10 @@
 /**
  * CLI argument parsing and help display
  */
-import { getAvailableThinkingLevels, parseThinkingLevel, type ThinkingLevel } from "@oh-my-pi/pi-ai";
+import { type Effort, THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 import { APP_NAME, CONFIG_DIR_NAME, logger } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { parseEffort } from "../thinking";
 import { BUILTIN_TOOLS } from "../tools";
 
 export type Mode = "text" | "json" | "rpc";
@@ -19,7 +20,7 @@ export interface Args {
 	apiKey?: string;
 	systemPrompt?: string;
 	appendSystemPrompt?: string;
-	thinking?: ThinkingLevel;
+	thinking?: Effort;
 	continue?: boolean;
 	resume?: string | true;
 	help?: boolean;
@@ -122,13 +123,13 @@ export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "
 			result.tools = validTools;
 		} else if (arg === "--thinking" && i + 1 < args.length) {
 			const rawThinking = args[++i];
-			const thinking = parseThinkingLevel(rawThinking);
+			const thinking = parseEffort(rawThinking);
 			if (thinking !== undefined) {
 				result.thinking = thinking;
 			} else {
 				logger.warn("Invalid thinking level passed to --thinking", {
 					level: rawThinking,
-					validThinkingLevels: getAvailableThinkingLevels(),
+					validThinkingLevels: THINKING_EFFORTS,
 				});
 			}
 		} else if (arg === "--print" || arg === "-p") {
@@ -207,7 +208,7 @@ export function getExtraHelpText(): string {
   MISTRAL_API_KEY            - Mistral models
   ZAI_API_KEY                - z.ai models (ZhipuAI/GLM)
   MINIMAX_API_KEY            - MiniMax models
-  OPENCODE_API_KEY           - OpenCode models
+  OPENCODE_API_KEY           - OpenCode Zen/OpenCode Go models
   CURSOR_ACCESS_TOKEN        - Cursor AI models
   AI_GATEWAY_API_KEY         - Vercel AI Gateway
 

package/src/cli/list-models.ts

@@ -1,7 +1,7 @@
 /**
  * List available models with optional fuzzy search
  */
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { type Api, getSupportedEfforts, type Model } from "@oh-my-pi/pi-ai";
 import { formatNumber } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { fuzzyFilter } from "../utils/fuzzy";
@@ -41,7 +41,7 @@ export async function listModels(modelRegistry: ModelRegistry, searchPattern?: s
 		model: m.id,
 		context: formatNumber(m.contextWindow),
 		maxOut: formatNumber(m.maxTokens),
-		thinking: m.reasoning ? "yes" : "no",
+		thinking: m.thinking ? getSupportedEfforts(m).join(",") : m.reasoning ? "yes" : "-",
 		images: m.input.includes("image") ? "yes" : "no",
 	}));
 

package/src/commands/launch.ts

@@ -2,7 +2,7 @@
  * Root command for the coding agent CLI.
  */
 
-import { getAvailableThinkingLevels } from "@oh-my-pi/pi-ai";
+import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 import { APP_NAME } from "@oh-my-pi/pi-utils";
 import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { parseArgs } from "../cli/args";
@@ -86,8 +86,8 @@ export default class Index extends Command {
 			description: "Comma-separated list of tools to enable (default: all)",
 		}),
 		thinking: Flags.string({
-			description: `Set thinking level: ${getAvailableThinkingLevels().join(", ")}`,
-			options: getAvailableThinkingLevels(),
+			description: `Set thinking level: ${THINKING_EFFORTS.join(", ")}`,
+			options: [...THINKING_EFFORTS],
 		}),
 		hook: Flags.string({
 			description: "Load a hook/extension file (can be used multiple times)",

package/src/config/model-registry.ts

@@ -4,6 +4,7 @@ import {
 	type Context,
 	createModelManager,
 	DEFAULT_LOCAL_TOKEN,
+	enrichModelThinking,
 	getBundledModels,
 	getBundledProviders,
 	googleAntigravityModelManagerOptions,
@@ -18,6 +19,7 @@ import {
 	registerCustomApi,
 	registerOAuthProvider,
 	type SimpleStreamOptions,
+	type ThinkingConfig,
 	unregisterCustomApis,
 	unregisterOAuthProviders,
 } from "@oh-my-pi/pi-ai";
@@ -72,6 +74,28 @@ const OpenAICompatSchema = Type.Object({
 	vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
 });
 
+const EffortSchema = Type.Union([
+	Type.Literal("minimal"),
+	Type.Literal("low"),
+	Type.Literal("medium"),
+	Type.Literal("high"),
+	Type.Literal("xhigh"),
+]);
+
+const ThinkingControlModeSchema = Type.Union([
+	Type.Literal("effort"),
+	Type.Literal("budget"),
+	Type.Literal("google-level"),
+	Type.Literal("anthropic-adaptive"),
+	Type.Literal("anthropic-budget-effort"),
+]);
+
+const ModelThinkingSchema = Type.Object({
+	minLevel: EffortSchema,
+	maxLevel: EffortSchema,
+	mode: ThinkingControlModeSchema,
+});
+
 // Schema for custom model definition
 // Most fields are optional with sensible defaults for local models (Ollama, LM Studio, etc.)
 const ModelDefinitionSchema = Type.Object({
@@ -88,7 +112,9 @@ const ModelDefinitionSchema = Type.Object({
 			Type.Literal("google-vertex"),
 		]),
 	),
+	baseUrl: Type.Optional(Type.String({ minLength: 1 })),
 	reasoning: Type.Optional(Type.Boolean()),
+	thinking: Type.Optional(ModelThinkingSchema),
 	input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
 	cost: Type.Optional(
 		Type.Object({
@@ -110,6 +136,7 @@ const ModelDefinitionSchema = Type.Object({
 const ModelOverrideSchema = Type.Object({
 	name: Type.Optional(Type.String({ minLength: 1 })),
 	reasoning: Type.Optional(Type.Boolean()),
+	thinking: Type.Optional(ModelThinkingSchema),
 	input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
 	cost: Type.Optional(
 		Type.Object({
@@ -375,6 +402,7 @@ function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<A
 	const result = { ...model };
 	if (override.name !== undefined) result.name = override.name;
 	if (override.reasoning !== undefined) result.reasoning = override.reasoning;
+	if (override.thinking !== undefined) result.thinking = override.thinking as ThinkingConfig;
 	if (override.input !== undefined) result.input = override.input as ("text" | "image")[];
 	if (override.contextWindow !== undefined) result.contextWindow = override.contextWindow;
 	if (override.maxTokens !== undefined) result.maxTokens = override.maxTokens;
@@ -392,14 +420,16 @@ function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<A
 		result.headers = { ...model.headers, ...override.headers };
 	}
 	result.compat = mergeCompat(model.compat, override.compat);
-	return result;
+	return enrichModelThinking(result);
 }
 
 interface CustomModelDefinitionLike {
 	id: string;
 	name?: string;
 	api?: Api;
+	baseUrl?: string;
 	reasoning?: boolean;
+	thinking?: ThinkingConfig;
 	input?: ("text" | "image")[];
 	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
 	contextWindow?: number;
@@ -445,13 +475,14 @@ function buildCustomModel(
 	const withDefaults = options.useDefaults;
 	const cost = modelDef.cost ?? (withDefaults ? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } : undefined);
 	const input = modelDef.input ?? (withDefaults ? ["text"] : undefined);
-	return {
+	return enrichModelThinking({
 		id: modelDef.id,
 		name: modelDef.name ?? (withDefaults ? modelDef.id : undefined),
 		api,
 		provider: providerName,
-		baseUrl: providerBaseUrl,
+		baseUrl: modelDef.baseUrl ?? providerBaseUrl,
 		reasoning: modelDef.reasoning ?? (withDefaults ? false : undefined),
+		thinking: modelDef.thinking as ThinkingConfig | undefined,
 		input: input as ("text" | "image")[],
 		cost,
 		contextWindow: modelDef.contextWindow ?? (withDefaults ? 128000 : undefined),
@@ -460,7 +491,7 @@ function buildCustomModel(
 		compat: modelDef.compat,
 		contextPromotionTarget: modelDef.contextPromotionTarget,
 		premiumMultiplier: modelDef.premiumMultiplier,
-	} as Model<Api>;
+	} as Model<Api>);
 }
 
 /**
@@ -537,7 +568,7 @@ export class ModelRegistry {
 		const builtInModels = this.#loadBuiltInModels(overrides, modelOverrides);
 		const combined = this.#mergeCustomModels(builtInModels, customModels);
 
-		this.#models = combined;
+		this.#models = this.#applyHardcodedModelPolicies(combined);
 	}
 
 	/** Load built-in models, applying provider and per-model overrides */
@@ -716,7 +747,7 @@ export class ModelRegistry {
 					: model;
 			}),
 		);
-		this.#models = this.#applyModelOverrides(merged, this.#modelOverrides);
+		this.#models = this.#applyHardcodedModelPolicies(this.#applyModelOverrides(merged, this.#modelOverrides));
 	}
 
 	async #discoverProviderModels(providerConfig: DiscoveryProviderConfig): Promise<Model<Api>[]> {
@@ -853,19 +884,21 @@ export class ModelRegistry {
 			for (const item of models) {
 				const id = item.model || item.name;
 				if (!id) continue;
-				discovered.push({
-					id,
-					name: item.name || id,
-					api: providerConfig.api,
-					provider: providerConfig.provider,
-					baseUrl: `${endpoint}/v1`,
-					reasoning: false,
-					input: ["text"],
-					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-					contextWindow: 128000,
-					maxTokens: 8192,
-					headers: providerConfig.headers,
-				});
+				discovered.push(
+					enrichModelThinking({
+						id,
+						name: item.name || id,
+						api: providerConfig.api,
+						provider: providerConfig.provider,
+						baseUrl: `${endpoint}/v1`,
+						reasoning: false,
+						input: ["text"],
+						cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+						contextWindow: 128000,
+						maxTokens: 8192,
+						headers: providerConfig.headers,
+					}),
+				);
 			}
 			return this.#applyProviderModelOverrides(providerConfig.provider, discovered);
 		} catch (error) {
@@ -907,24 +940,26 @@ export class ModelRegistry {
 			for (const item of models) {
 				const id = item.id;
 				if (!id) continue;
-				discovered.push({
-					id,
-					name: id,
-					api: providerConfig.api,
-					provider: providerConfig.provider,
-					baseUrl,
-					reasoning: false,
-					input: ["text"],
-					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-					contextWindow: 128000,
-					maxTokens: 8192,
-					headers,
-					compat: {
-						supportsStore: false,
-						supportsDeveloperRole: false,
-						supportsReasoningEffort: false,
-					},
-				});
+				discovered.push(
+					enrichModelThinking({
+						id,
+						name: id,
+						api: providerConfig.api,
+						provider: providerConfig.provider,
+						baseUrl,
+						reasoning: false,
+						input: ["text"],
+						cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+						contextWindow: 128000,
+						maxTokens: 8192,
+						headers,
+						compat: {
+							supportsStore: false,
+							supportsDeveloperRole: false,
+							supportsReasoningEffort: false,
+						},
+					}),
+				);
 			}
 			return this.#applyProviderModelOverrides(providerConfig.provider, discovered);
 		} catch (error) {
@@ -980,6 +1015,15 @@ export class ModelRegistry {
 		});
 	}
 
+	#applyHardcodedModelPolicies(models: Model<Api>[]): Model<Api>[] {
+		return models.map(model => {
+			if (model.id === "gpt-5.4") {
+				return { ...model, contextWindow: 1_000_000 };
+			}
+			return model;
+		});
+	}
+
 	#parseModels(config: ModelsConfig): Model<Api>[] {
 		const models: Model<Api>[] = [];
 
@@ -997,7 +1041,7 @@ export class ModelRegistry {
 					providerConfig.headers,
 					providerConfig.apiKey,
 					providerConfig.authHeader,
-					modelDef,
+					modelDef as CustomModelDefinitionLike,
 					{ useDefaults: true },
 				);
 				if (!model) continue;
@@ -1150,7 +1194,7 @@ export class ModelRegistry {
 					config.headers,
 					config.apiKey,
 					config.authHeader,
-					modelDef,
+					modelDef as CustomModelDefinitionLike,
 					{ useDefaults: false },
 				);
 				if (!model) {
@@ -1205,7 +1249,9 @@ export interface ProviderConfigInput {
 		id: string;
 		name: string;
 		api?: Api;
+		baseUrl?: string;
 		reasoning: boolean;
+		thinking?: ThinkingConfig;
 		input: ("text" | "image")[];
 		cost: { input: number; output: number; cacheRead: number; cacheWrite: number };
 		contextWindow: number;

package/src/config/model-resolver.ts

@@ -1,17 +1,20 @@
 /**
  * Model resolution, scoping, and initial selection
  */
+
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import {
 	type Api,
+	clampThinkingLevelForModel,
 	DEFAULT_MODEL_PER_PROVIDER,
+	type Effort,
 	type KnownProvider,
 	type Model,
 	modelsAreEqual,
-	parseThinkingLevel,
-	type ThinkingLevel,
 } from "@oh-my-pi/pi-ai";
 import chalk from "chalk";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
+import { parseThinkingLevel, resolveThinkingLevelForModel } from "../thinking";
 import { fuzzyMatch } from "../utils/fuzzy";
 import { MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
 import type { Settings } from "./settings";
@@ -377,7 +380,14 @@ export function resolveModelRoleValue(
 		options?.matchPreferences,
 	);
 
-	return { model, thinkingLevel, explicitThinkingLevel, warning };
+	return {
+		model,
+		thinkingLevel: explicitThinkingLevel
+			? (resolveThinkingLevelForModel(model, thinkingLevel) ?? thinkingLevel)
+			: thinkingLevel,
+		explicitThinkingLevel,
+		warning,
+	};
 }
 
 export function extractExplicitThinkingSelector(
@@ -393,10 +403,10 @@ export function extractExplicitThinkingSelector(
 	while (!visited.has(current)) {
 		visited.add(current);
 		const lastColonIndex = current.lastIndexOf(":");
-		const hasThinkingSuffix =
-			lastColonIndex > PREFIX_MODEL_ROLE.length && parseThinkingLevel(current.slice(lastColonIndex + 1));
-		if (hasThinkingSuffix) {
-			return current.slice(lastColonIndex + 1) as ThinkingLevel;
+		const thinkingSelector =
+			lastColonIndex > PREFIX_MODEL_ROLE.length ? parseThinkingLevel(current.slice(lastColonIndex + 1)) : undefined;
+		if (thinkingSelector) {
+			return thinkingSelector;
 		}
 		const expanded = expandRoleAlias(current, settings).trim();
 		if (!expanded || expanded === current) break;
@@ -520,7 +530,13 @@ export async function resolveModelScope(
 
 			for (const model of matchingModels) {
 				if (!scopedModels.find(sm => modelsAreEqual(sm.model, model))) {
-					scopedModels.push({ model, thinkingLevel, explicitThinkingLevel });
+					scopedModels.push({
+						model,
+						thinkingLevel: explicitThinkingLevel
+							? (resolveThinkingLevelForModel(model, thinkingLevel) ?? thinkingLevel)
+							: thinkingLevel,
+						explicitThinkingLevel,
+					});
 				}
 			}
 			continue;
@@ -543,7 +559,13 @@ export async function resolveModelScope(
 
 		// Avoid duplicates
 		if (!scopedModels.find(sm => modelsAreEqual(sm.model, model))) {
-			scopedModels.push({ model, thinkingLevel, explicitThinkingLevel });
+			scopedModels.push({
+				model,
+				thinkingLevel: explicitThinkingLevel
+					? (resolveThinkingLevelForModel(model, thinkingLevel) ?? thinkingLevel)
+					: thinkingLevel,
+				explicitThinkingLevel,
+			});
 		}
 	}
 
@@ -644,7 +666,7 @@ export function resolveCliModel(options: {
 
 export interface InitialModelResult {
 	model: Model<Api> | undefined;
-	thinkingLevel: ThinkingLevel;
+	thinkingLevel?: ThinkingLevel;
 	fallbackMessage: string | undefined;
 }
 
@@ -663,7 +685,7 @@ export async function findInitialModel(options: {
 	isContinuing: boolean;
 	defaultProvider?: string;
 	defaultModelId?: string;
-	defaultThinkingSelector?: ThinkingLevel;
+	defaultThinkingSelector?: Effort;
 	modelRegistry: ModelRegistry;
 }): Promise<InitialModelResult> {
 	const {
@@ -678,7 +700,7 @@ export async function findInitialModel(options: {
 	} = options;
 
 	let model: Model<Api> | undefined;
-	let thinkingLevel: ThinkingLevel = "off";
+	let thinkingLevel: Effort | undefined;
 
 	// 1. CLI args take priority
 	if (cliProvider && cliModel) {
@@ -687,16 +709,22 @@ export async function findInitialModel(options: {
 			console.error(chalk.red(`Model ${cliProvider}/${cliModel} not found`));
 			process.exit(1);
 		}
-		return { model: found, thinkingLevel: "off", fallbackMessage: undefined };
+		return { model: found, thinkingLevel: undefined, fallbackMessage: undefined };
 	}
 
 	// 2. Use first model from scoped models (skip if continuing/resuming)
 	if (scopedModels.length > 0 && !isContinuing) {
 		const scoped = scopedModels[0];
-		const scopedThinkingSelector = scoped.thinkingLevel ?? defaultThinkingSelector ?? "off";
+		const scopedThinkingSelector =
+			scoped.thinkingLevel === ThinkingLevel.Inherit
+				? defaultThinkingSelector
+				: (scoped.thinkingLevel ?? defaultThinkingSelector);
 		return {
 			model: scoped.model,
-			thinkingLevel: scopedThinkingSelector,
+			thinkingLevel:
+				scopedThinkingSelector === ThinkingLevel.Off
+					? ThinkingLevel.Off
+					: clampThinkingLevelForModel(scoped.model, scopedThinkingSelector),
 			fallbackMessage: undefined,
 		};
 	}
@@ -706,9 +734,7 @@ export async function findInitialModel(options: {
 		const found = modelRegistry.find(defaultProvider, defaultModelId);
 		if (found) {
 			model = found;
-			if (defaultThinkingSelector) {
-				thinkingLevel = defaultThinkingSelector;
-			}
+			thinkingLevel = clampThinkingLevelForModel(found, defaultThinkingSelector);
 			return { model, thinkingLevel, fallbackMessage: undefined };
 		}
 	}
@@ -722,16 +748,16 @@ export async function findInitialModel(options: {
 			const defaultId = defaultModelPerProvider[provider];
 			const match = availableModels.find(m => m.provider === provider && m.id === defaultId);
 			if (match) {
-				return { model: match, thinkingLevel: "off", fallbackMessage: undefined };
+				return { model: match, thinkingLevel: undefined, fallbackMessage: undefined };
 			}
 		}
 
 		// If no default found, use first available
-		return { model: availableModels[0], thinkingLevel: "off", fallbackMessage: undefined };
+		return { model: availableModels[0], thinkingLevel: undefined, fallbackMessage: undefined };
 	}
 
 	// 5. No model found
-	return { model: undefined, thinkingLevel: "off", fallbackMessage: undefined };
+	return { model: undefined, thinkingLevel: undefined, fallbackMessage: undefined };
 }
 
 /**