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

package/src/config/settings-schema.ts

@@ -1,4 +1,4 @@
-import { getAvailableThinkingLevels } from "@oh-my-pi/pi-ai";
+import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 
 /** Unified settings schema - single source of truth for all settings.
  * Unified settings schema - single source of truth for all settings.
@@ -192,7 +192,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	defaultThinkingLevel: {
 		type: "enum",
-		values: getAvailableThinkingLevels(),
+		values: THINKING_EFFORTS,
 		default: "high",
 		ui: {
 			tab: "agent",
@@ -345,9 +345,48 @@ export const SETTINGS_SCHEMA = {
 			description: "Automatically compact context when it gets too large",
 		},
 	},
+	"compaction.strategy": {
+		type: "enum",
+		values: ["context-full", "handoff", "off"] as const,
+		default: "context-full",
+		ui: {
+			tab: "agent",
+			label: "Context-full strategy",
+			description: "Choose in-place context-full maintenance, auto-handoff, or disable auto maintenance (off)",
+			submenu: true,
+		},
+	},
+	"compaction.thresholdPercent": {
+		type: "number",
+		default: -1,
+		ui: {
+			tab: "agent",
+			label: "Context threshold",
+			description: "Percent threshold for context maintenance; set to Default to use legacy reserve-based behavior",
+			submenu: true,
+		},
+	},
+	"compaction.handoffSaveToDisk": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "agent",
+			label: "Save auto-handoff docs",
+			description: "Save generated handoff documents to markdown files for the auto-handoff flow",
+		},
+	},
 	"compaction.reserveTokens": { type: "number", default: 16384 },
 	"compaction.keepRecentTokens": { type: "number", default: 20000 },
 	"compaction.autoContinue": { type: "boolean", default: true },
+	"compaction.remoteEnabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "agent",
+			label: "Remote compaction",
+			description: "Use remote compaction endpoints when available instead of local summarization",
+		},
+	},
 	"compaction.remoteEndpoint": { type: "string", default: undefined },
 
 	// ─────────────────────────────────────────────────────────────────────────
@@ -1186,6 +1225,17 @@ export const SETTINGS_SCHEMA = {
 			submenu: true,
 		},
 	},
+	serviceTier: {
+		type: "enum",
+		values: ["none", "auto", "default", "flex", "scale", "priority"] as const,
+		default: "none",
+		ui: {
+			tab: "agent",
+			label: "Service tier",
+			description: "OpenAI processing priority (none = omit parameter)",
+			submenu: true,
+		},
+	},
 } as const;
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1265,9 +1315,13 @@ export type StatusLineSeparatorStyle = SettingValue<"statusLine.separator">;
 
 export interface CompactionSettings {
 	enabled: boolean;
+	strategy: "context-full" | "handoff" | "off";
+	thresholdPercent: number;
 	reserveTokens: number;
 	keepRecentTokens: number;
+	handoffSaveToDisk: boolean;
 	autoContinue: boolean;
+	remoteEnabled: boolean;
 	remoteEndpoint: string | undefined;
 }
 

package/src/discovery/helpers.ts

@@ -1,13 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ThinkingLevel } from "@oh-my-pi/pi-ai";
-import { parseThinkingLevel } from "@oh-my-pi/pi-ai";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
 import { CONFIG_DIR_NAME, tryParseJson } from "@oh-my-pi/pi-utils";
 import { readFile } from "../capability/fs";
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import { parseThinkingLevel } from "../thinking";
 import { parseFrontmatter } from "../utils/frontmatter";
 
 /**

package/src/extensibility/custom-tools/types.ts

@@ -90,9 +90,11 @@ export type CustomToolSessionEvent =
 	| {
 			reason: "auto_compaction_start";
 			trigger: "threshold" | "overflow";
+			action: "context-full" | "handoff";
 	  }
 	| {
 			reason: "auto_compaction_end";
+			action: "context-full" | "handoff";
 			result: CompactionResult | undefined;
 			aborted: boolean;
 			willRetry: boolean;

package/src/extensibility/extensions/loader.ts

@@ -4,7 +4,8 @@
 import type * as fs1 from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ImageContent, Model, TextContent, ThinkingLevel } from "@oh-my-pi/pi-ai";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, Model, TextContent } from "@oh-my-pi/pi-ai";
 import * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@oh-my-pi/pi-utils";
@@ -214,7 +215,7 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 		return this.runtime.setModel(model);
 	}
 
-	getThinkingLevel(): ThinkingLevel {
+	getThinkingLevel(): ThinkingLevel | undefined {
 		return this.runtime.getThinkingLevel();
 	}
 

package/src/extensibility/extensions/types.ts

@@ -7,7 +7,7 @@
  * - Register commands, keyboard shortcuts, and CLI flags
  * - Interact with the user via UI primitives
  */
-import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type {
 	Api,
 	AssistantMessageEvent,
@@ -19,7 +19,6 @@ import type {
 	OAuthLoginCallbacks,
 	SimpleStreamOptions,
 	TextContent,
-	ThinkingLevel,
 	ToolResultMessage,
 } from "@oh-my-pi/pi-ai";
 import type * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
@@ -538,11 +537,13 @@ export interface ToolExecutionEndEvent {
 export interface AutoCompactionStartEvent {
 	type: "auto_compaction_start";
 	reason: "threshold" | "overflow";
+	action: "context-full" | "handoff";
 }
 
 /** Fired when auto-compaction ends */
 export interface AutoCompactionEndEvent {
 	type: "auto_compaction_end";
+	action: "context-full" | "handoff";
 	result: CompactionResult | undefined;
 	aborted: boolean;
 	willRetry: boolean;
@@ -1056,9 +1057,9 @@ export interface ExtensionAPI {
 	setModel(model: Model): Promise<boolean>;
 
 	/** Get current thinking level. */
-	getThinkingLevel(): ThinkingLevel;
+	getThinkingLevel(): ThinkingLevel | undefined;
 
-	/** Set thinking level (clamped to model capabilities). */
+	/** Set thinking level for the current session. */
 	setThinkingLevel(level: ThinkingLevel): void;
 
 	// =========================================================================
@@ -1084,11 +1085,11 @@ export interface ExtensionAPI {
 	 *       id: "claude-sonnet-4@20250514",
 	 *       name: "Claude Sonnet 4 (Vertex)",
 	 *       reasoning: true,
+	 *       thinking: { mode: "anthropic-adaptive", minLevel: "minimal", maxLevel: "high" },
 	 *       input: ["text", "image"],
 	 *       cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
 	 *       contextWindow: 200000,
 	 *       maxTokens: 64000,
-	 *     }
 	 *   ]
 	 * });
 	 *
@@ -1147,8 +1148,10 @@ export interface ProviderModelConfig {
 	name: string;
 	/** API type override for this model. */
 	api?: Api;
-	/** Whether the model supports extended thinking. */
+	/** Whether the model supports extended thinking at all. */
 	reasoning: boolean;
+	/** Optional canonical thinking capability metadata for per-model effort support. */
+	thinking?: Model["thinking"];
 	/** Supported input types. */
 	input: ("text" | "image")[];
 	/** Cost per million tokens. */
@@ -1216,7 +1219,7 @@ export type SetActiveToolsHandler = (toolNames: string[]) => Promise<void>;
 
 export type SetModelHandler = (model: Model) => Promise<boolean>;
 
-export type GetThinkingLevelHandler = () => ThinkingLevel;
+export type GetThinkingLevelHandler = () => ThinkingLevel | undefined;
 
 export type SetThinkingLevelHandler = (level: ThinkingLevel, persist?: boolean) => void;
 

package/src/extensibility/hooks/types.ts

@@ -395,11 +395,13 @@ export interface TurnEndEvent {
 export interface AutoCompactionStartEvent {
 	type: "auto_compaction_start";
 	reason: "threshold" | "overflow";
+	action: "context-full" | "handoff";
 }
 
 /** Event data for auto_compaction_end event. */
 export interface AutoCompactionEndEvent {
 	type: "auto_compaction_end";
+	action: "context-full" | "handoff";
 	result: CompactionResult | undefined;
 	aborted: boolean;
 	willRetry: boolean;

package/src/main.ts

@@ -10,7 +10,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { type ImageContent, supportsXhigh } from "@oh-my-pi/pi-ai";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { $env, getProjectDir, logger, postmortem, setProjectDir, VERSION } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import type { Args } from "./cli/args";
@@ -334,11 +334,10 @@ async function buildSessionOptions(
 	scopedModels: ScopedModel[],
 	sessionManager: SessionManager | undefined,
 	modelRegistry: ModelRegistry,
-): Promise<{ options: CreateAgentSessionOptions; cliThinkingFromModel: boolean }> {
+): Promise<{ options: CreateAgentSessionOptions }> {
 	const options: CreateAgentSessionOptions = {
 		cwd: parsed.cwd ?? getProjectDir(),
 	};
-	let cliThinkingFromModel = false;
 
 	// Auto-discover SYSTEM.md if no CLI system prompt provided
 	const systemPromptSource = parsed.systemPrompt ?? discoverSystemPromptFile();
@@ -380,7 +379,6 @@ async function buildSessionOptions(
 			settings.overrideModelRoles({ default: `${resolved.model.provider}/${resolved.model.id}` });
 			if (!parsed.thinking && resolved.thinkingLevel) {
 				options.thinkingLevel = resolved.thinkingLevel;
-				cliThinkingFromModel = true;
 			}
 		}
 	} else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
@@ -483,7 +481,7 @@ async function buildSessionOptions(
 		options.additionalExtensionPaths = [];
 	}
 
-	return { options, cliThinkingFromModel };
+	return { options };
 }
 
 export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<void> {
@@ -618,7 +616,7 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		sessionManager = await SessionManager.open(selectedPath);
 	}
 
-	const { options: sessionOptions, cliThinkingFromModel } = await logger.timeAsync("buildSessionOptions", () =>
+	const { options: sessionOptions } = await logger.timeAsync("buildSessionOptions", () =>
 		buildSessionOptions(parsedArgs, scopedModels, sessionManager, modelRegistry),
 	);
 	sessionOptions.authStorage = authStorage;
@@ -692,21 +690,6 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		process.exit(1);
 	}
 
-	// Clamp thinking level to model capabilities for CLI-provided thinking levels.
-	// This covers both --thinking <level> and --model <pattern>:<thinking>.
-	const cliThinkingOverride = parsedArgs.thinking !== undefined || cliThinkingFromModel;
-	if (session.model && cliThinkingOverride) {
-		let effectiveThinking = session.thinkingLevel;
-		if (!session.model.reasoning) {
-			effectiveThinking = "off";
-		} else if (effectiveThinking === "xhigh" && !supportsXhigh(session.model)) {
-			effectiveThinking = "high";
-		}
-		if (effectiveThinking !== session.thinkingLevel) {
-			session.setThinkingLevel(effectiveThinking);
-		}
-	}
-
 	if (mode === "rpc") {
 		await runRpcMode(session);
 	} else if (isInteractive) {
@@ -717,7 +700,7 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		if (scopedModelsForDisplay.length > 0) {
 			const modelList = scopedModelsForDisplay
 				.map(scopedModel => {
-					const thinkingStr = scopedModel.thinkingLevel !== "off" ? `:${scopedModel.thinkingLevel}` : "";
+					const thinkingStr = !scopedModel.thinkingLevel ? `:${scopedModel.thinkingLevel}` : "";
 					return `${scopedModel.model.id}${thinkingStr}`;
 				})
 				.join(", ");

package/src/memories/index.ts

@@ -3,7 +3,7 @@ import type * as fsNode from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import { completeSimple, type Model } from "@oh-my-pi/pi-ai";
+import { completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
 import { getAgentDbPath, logger, parseJsonlLenient } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { parseModelString } from "../config/model-resolver";
@@ -583,7 +583,11 @@ async function runStage1Job(options: {
 				systemPrompt: stageOneSystemTemplate,
 				messages: [{ role: "user", content: [{ type: "text", text: inputPrompt }], timestamp: Date.now() }],
 			},
-			{ apiKey, maxTokens: Math.max(1024, Math.min(4096, Math.floor(modelMaxTokens * 0.2))), reasoning: "low" },
+			{
+				apiKey,
+				maxTokens: Math.max(1024, Math.min(4096, Math.floor(modelMaxTokens * 0.2))),
+				reasoning: Effort.Low,
+			},
 		);
 
 		if (response.stopReason === "error") {
@@ -709,7 +713,7 @@ async function runConsolidationModel(options: { memoryRoot: string; model: Model
 		{
 			messages: [{ role: "user", content: [{ type: "text", text: input }], timestamp: Date.now() }],
 		},
-		{ apiKey, maxTokens: 8192, reasoning: "medium" },
+		{ apiKey, maxTokens: 8192, reasoning: Effort.Medium },
 	);
 	if (response.stopReason === "error") {
 		throw new Error(response.errorMessage || "phase2 model error");

package/src/modes/components/footer.ts

@@ -1,10 +1,12 @@
 import * as fs from "node:fs";
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { type Component, padding, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { formatNumber, getProjectDir } from "@oh-my-pi/pi-utils";
 import { theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
 import { shortenPath } from "../../tools/render-utils";
 import { findGitHeadPathAsync, sanitizeStatusText } from "../shared";
+import { getContextUsageLevel, getContextUsageThemeColor } from "./status-line/context-thresholds";
 
 /**
  * Footer component that shows pwd, token stats, and context usage
@@ -197,10 +199,10 @@ export class FooterComponent implements Component {
 			contextPercent === "?"
 				? `?/${formatNumber(contextWindow)}${autoIndicator}`
 				: `${contextPercent}%/${formatNumber(contextWindow)}${autoIndicator}`;
-		if (contextPercentValue > 90) {
-			contextPercentStr = theme.fg("error", contextPercentDisplay);
-		} else if (contextPercentValue > 70) {
-			contextPercentStr = theme.fg("warning", contextPercentDisplay);
+		if (contextUsage?.percent !== null && contextUsage?.percent !== undefined) {
+			const color = getContextUsageThemeColor(getContextUsageLevel(contextPercentValue, contextWindow));
+			contextPercentStr =
+				color === "statusLineContext" ? contextPercentDisplay : theme.fg(color, contextPercentDisplay);
 		} else {
 			contextPercentStr = contextPercentDisplay;
 		}
@@ -211,11 +213,11 @@ export class FooterComponent implements Component {
 		// Add model name on the right side, plus thinking level if model supports it
 		const modelName = state.model?.id || "no-model";
 
-		// Add thinking level hint if model supports reasoning and thinking is enabled
+		// Add thinking level hint when the current model advertises supported efforts
 		let rightSide = modelName;
-		if (state.model?.reasoning) {
-			const thinkingLevel = state.thinkingLevel || "off";
-			if (thinkingLevel !== "off") {
+		if (state.model?.thinking) {
+			const thinkingLevel = state.thinkingLevel ?? ThinkingLevel.Off;
+			if (thinkingLevel !== ThinkingLevel.Off) {
 				rightSide = `${modelName} • ${thinkingLevel}`;
 			}
 		}

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

@@ -1,16 +1,11 @@
-import {
-	getAvailableThinkingLevels,
-	getThinkingMetadata,
-	type Model,
-	modelsAreEqual,
-	supportsXhigh,
-	type ThinkingMode,
-} from "@oh-my-pi/pi-ai";
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { getSupportedEfforts, type Model, modelsAreEqual } from "@oh-my-pi/pi-ai";
 import { Container, Input, matchesKey, Spacer, type Tab, TabBar, Text, type TUI, visibleWidth } from "@oh-my-pi/pi-tui";
 import { MODEL_ROLE_IDS, MODEL_ROLES, type ModelRegistry, type ModelRole } from "../../config/model-registry";
 import { resolveModelRoleValue } from "../../config/model-resolver";
 import type { Settings } from "../../config/settings";
 import { type ThemeColor, theme } from "../../modes/theme/theme";
+import { getThinkingLevelMetadata } from "../../thinking";
 import { fuzzyFilter } from "../../utils/fuzzy";
 import { getTabBarTheme } from "../shared";
 import { DynamicBorder } from "./dynamic-border";
@@ -29,15 +24,15 @@ interface ModelItem {
 
 interface ScopedModelItem {
 	model: Model;
-	thinkingLevel: string;
+	thinkingLevel?: string;
 }
 
 interface RoleAssignment {
 	model: Model;
-	thinkingMode: ThinkingMode;
+	thinkingLevel: ThinkingLevel;
 }
 
-type RoleSelectCallback = (model: Model, role: ModelRole | null, thinkingMode?: ThinkingMode) => void;
+type RoleSelectCallback = (model: Model, role: ModelRole | null, thinkingLevel?: ThinkingLevel) => void;
 type CancelCallback = () => void;
 interface MenuRoleAction {
 	label: string;
@@ -97,7 +92,7 @@ export class ModelSelectorComponent extends Container {
 		settings: Settings,
 		modelRegistry: ModelRegistry,
 		scopedModels: ReadonlyArray<ScopedModelItem>,
-		onSelect: (model: Model, role: ModelRole | null, thinkingMode?: ThinkingMode) => void,
+		onSelect: (model: Model, role: ModelRole | null, thinkingLevel?: ThinkingLevel) => void,
 		onCancel: () => void,
 		options?: { temporaryOnly?: boolean; initialSearchInput?: string },
 	) {
@@ -192,7 +187,8 @@ export class ModelSelectorComponent extends Container {
 			if (model) {
 				this.#roles[role] = {
 					model,
-					thinkingMode: explicitThinkingLevel && thinkingLevel !== undefined ? thinkingLevel : "inherit",
+					thinkingLevel:
+						explicitThinkingLevel && thinkingLevel !== undefined ? thinkingLevel : ThinkingLevel.Inherit,
 				};
 			}
 		}
@@ -409,7 +405,7 @@ export class ModelSelectorComponent extends Container {
 				if (!tag || !assigned || !modelsAreEqual(assigned.model, item.model)) continue;
 
 				const badge = makeInvertedBadge(tag, color ?? "success");
-				const thinkingLabel = getThinkingMetadata(assigned.thinkingMode).label;
+				const thinkingLabel = getThinkingLevelMetadata(assigned.thinkingLevel).label;
 				roleBadgeTokens.push(`${badge} ${theme.fg("dim", `(${thinkingLabel})`)}`);
 			}
 			const badgeText = roleBadgeTokens.length > 0 ? ` ${roleBadgeTokens.join(" ")}` : "";
@@ -456,19 +452,18 @@ export class ModelSelectorComponent extends Container {
 			this.#listContainer.addChild(new Text(theme.fg("muted", `  Model Name: ${selected.model.name}`), 0, 0));
 		}
 	}
-	#getThinkingModesForModel(model: Model): ReadonlyArray<ThinkingMode> {
-		return ["inherit", ...getAvailableThinkingLevels(supportsXhigh(model))];
+	#getThinkingLevelsForModel(model: Model): ReadonlyArray<ThinkingLevel> {
+		return [ThinkingLevel.Inherit, ThinkingLevel.Off, ...getSupportedEfforts(model)];
 	}
 
-	#getCurrentRoleThinkingMode(role: ModelRole): ThinkingMode {
-		return this.#roles[role]?.thinkingMode ?? "inherit";
+	#getCurrentRoleThinkingLevel(role: ModelRole): ThinkingLevel {
+		return this.#roles[role]?.thinkingLevel ?? ThinkingLevel.Inherit;
 	}
 
 	#getThinkingPreselectIndex(role: ModelRole, model: Model): number {
-		const options = this.#getThinkingModesForModel(model);
-		const currentMode = this.#getCurrentRoleThinkingMode(role);
-		const preferredMode = currentMode === "xhigh" && !options.includes("xhigh") ? "high" : currentMode;
-		const foundIndex = options.indexOf(preferredMode);
+		const options = this.#getThinkingLevelsForModel(model);
+		const currentLevel = this.#getCurrentRoleThinkingLevel(role);
+		const foundIndex = options.indexOf(currentLevel);
 		return foundIndex >= 0 ? foundIndex : 0;
 	}
 
@@ -496,11 +491,11 @@ export class ModelSelectorComponent extends Container {
 		if (!selectedModel) return;
 
 		const showingThinking = this.#menuStep === "thinking" && this.#menuSelectedRole !== null;
-		const thinkingOptions = showingThinking ? this.#getThinkingModesForModel(selectedModel.model) : [];
+		const thinkingOptions = showingThinking ? this.#getThinkingLevelsForModel(selectedModel.model) : [];
 		const optionLines = showingThinking
-			? thinkingOptions.map((thinkingMode, index) => {
+			? thinkingOptions.map((thinkingLevel, index) => {
 					const prefix = index === this.#menuSelectedIndex ? `  ${theme.nav.cursor} ` : "    ";
-					const label = getThinkingMetadata(thinkingMode).label;
+					const label = getThinkingLevelMetadata(thinkingLevel).label;
 					return `${prefix}${label}`;
 				})
 			: MENU_ROLE_ACTIONS.map((action, index) => {
@@ -607,7 +602,7 @@ export class ModelSelectorComponent extends Container {
 
 		const optionCount =
 			this.#menuStep === "thinking" && this.#menuSelectedRole !== null
-				? this.#getThinkingModesForModel(selectedModel.model).length
+				? this.#getThinkingLevelsForModel(selectedModel.model).length
 				: MENU_ROLE_ACTIONS.length;
 		if (optionCount === 0) return;
 
@@ -635,10 +630,10 @@ export class ModelSelectorComponent extends Container {
 			}
 
 			if (!this.#menuSelectedRole) return;
-			const thinkingOptions = this.#getThinkingModesForModel(selectedModel.model);
-			const thinkingMode = thinkingOptions[this.#menuSelectedIndex];
-			if (!thinkingMode) return;
-			this.#handleSelect(selectedModel.model, this.#menuSelectedRole, thinkingMode);
+			const thinkingOptions = this.#getThinkingLevelsForModel(selectedModel.model);
+			const thinkingLevel = thinkingOptions[this.#menuSelectedIndex];
+			if (!thinkingLevel) return;
+			this.#handleSelect(selectedModel.model, this.#menuSelectedRole, thinkingLevel);
 			this.#closeMenu();
 			return;
 		}
@@ -657,28 +652,28 @@ export class ModelSelectorComponent extends Container {
 		}
 	}
 
-	#formatRoleModelValue(model: Model, thinkingMode: ThinkingMode): string {
+	#formatRoleModelValue(model: Model, thinkingLevel: ThinkingLevel): string {
 		const modelKey = `${model.provider}/${model.id}`;
-		if (thinkingMode === "inherit") return modelKey;
-		return `${modelKey}:${thinkingMode}`;
+		if (thinkingLevel === ThinkingLevel.Inherit) return modelKey;
+		return `${modelKey}:${thinkingLevel}`;
 	}
-	#handleSelect(model: Model, role: ModelRole | null, thinkingMode?: ThinkingMode): void {
+	#handleSelect(model: Model, role: ModelRole | null, thinkingLevel?: ThinkingLevel): void {
 		// For temporary role, don't save to settings - just notify caller
 		if (role === null) {
 			this.#onSelectCallback(model, null);
 			return;
 		}
 
-		const selectedThinkingMode = thinkingMode ?? this.#getCurrentRoleThinkingMode(role);
+		const selectedThinkingLevel = thinkingLevel ?? this.#getCurrentRoleThinkingLevel(role);
 
 		// Save to settings
-		this.#settings.setModelRole(role, this.#formatRoleModelValue(model, selectedThinkingMode));
+		this.#settings.setModelRole(role, this.#formatRoleModelValue(model, selectedThinkingLevel));
 
 		// Update local state for UI
-		this.#roles[role] = { model, thinkingMode: selectedThinkingMode };
+		this.#roles[role] = { model, thinkingLevel: selectedThinkingLevel };
 
 		// Notify caller (for updating agent state if needed)
-		this.#onSelectCallback(model, role, selectedThinkingMode);
+		this.#onSelectCallback(model, role, selectedThinkingLevel);
 
 		// Update list to show new badges
 		this.#updateList();

package/src/modes/components/settings-defs.ts

@@ -7,7 +7,7 @@
  * 2. That's it - it appears in the UI automatically
  */
 
-import { getAvailableThinkingLevels, getThinkingMetadata } from "@oh-my-pi/pi-ai";
+import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 import { TERMINAL } from "@oh-my-pi/pi-tui";
 import {
 	getDefault,
@@ -19,6 +19,7 @@ import {
 	type SettingPath,
 	type SettingTab,
 } from "../../config/settings-schema";
+import { getThinkingLevelMetadata } from "../../thinking";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // UI Definition Types
@@ -68,6 +69,26 @@ type OptionList = ReadonlyArray<{ value: string; label: string; description?: st
 type OptionProvider = (() => OptionList) | OptionList;
 
 const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
+	// Context maintenance strategy
+	"compaction.strategy": [
+		{ value: "context-full", label: "Context-full", description: "Summarize in-place and keep the current session" },
+		{ value: "handoff", label: "Handoff", description: "Generate handoff and continue in a new session" },
+		{
+			value: "off",
+			label: "Off",
+			description: "Disable automatic context maintenance (same behavior as Auto-compact off)",
+		},
+	],
+	// Context maintenance threshold
+	"compaction.thresholdPercent": [
+		{ value: "default", label: "Default", description: "Legacy reserve-based threshold" },
+		{ value: "70", label: "70%", description: "Very early maintenance" },
+		{ value: "75", label: "75%", description: "Early maintenance" },
+		{ value: "80", label: "80%", description: "Balanced" },
+		{ value: "85", label: "85%", description: "Typical threshold" },
+		{ value: "90", label: "90%", description: "Aggressive context usage" },
+		{ value: "95", label: "95%", description: "Near context limit" },
+	],
 	// Retry max retries
 	"retry.maxRetries": [
 		{ value: "1", label: "1 retry" },
@@ -231,7 +252,7 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "on", label: "On", description: "Force websockets for OpenAI Codex models" },
 	],
 	// Default thinking level
-	defaultThinkingLevel: [...getAvailableThinkingLevels().map(getThinkingMetadata)],
+	defaultThinkingLevel: [...THINKING_EFFORTS.map(getThinkingLevelMetadata)],
 	// Temperature
 	temperature: [
 		{ value: "-1", label: "Default", description: "Use provider default" },
@@ -277,6 +298,14 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "1.2", label: "1.2", description: "Balanced" },
 		{ value: "1.5", label: "1.5", description: "Strong penalty" },
 	],
+	serviceTier: [
+		{ value: "none", label: "None", description: "Omit service_tier parameter" },
+		{ value: "auto", label: "Auto", description: "Use provider default tier selection" },
+		{ value: "default", label: "Default", description: "Standard priority processing" },
+		{ value: "flex", label: "Flex", description: "Use flexible capacity tier when available" },
+		{ value: "scale", label: "Scale", description: "Use Scale Tier credits when available" },
+		{ value: "priority", label: "Priority", description: "Use Priority processing" },
+	],
 	// Symbol preset
 	symbolPreset: [
 		{ value: "unicode", label: "Unicode", description: "Standard symbols (default)" },