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

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" },
@@ -213,7 +234,7 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "perplexity", label: "Perplexity", description: "Requires PERPLEXITY_COOKIES or PERPLEXITY_API_KEY" },
 		{ value: "anthropic", label: "Anthropic", description: "Uses Anthropic web search" },
 		{ value: "zai", label: "Z.AI", description: "Calls Z.AI webSearchPrime MCP" },
-		{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY" },
+		{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY and Kagi Search API beta access" },
 		{ value: "synthetic", label: "Synthetic", description: "Requires SYNTHETIC_API_KEY" },
 	],
 	"providers.image": [
@@ -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)" },

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

@@ -1,4 +1,5 @@
-import type { ThinkingLevel } from "@oh-my-pi/pi-ai";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Effort } from "@oh-my-pi/pi-ai";
 import {
 	Container,
 	matchesKey,
@@ -134,9 +135,9 @@ function getSettingsTabs(): Tab[] {
  */
 export interface SettingsRuntimeContext {
 	/** Available thinking levels (from session) */
-	availableThinkingLevels: ThinkingLevel[];
+	availableThinkingLevels: Effort[];
 	/** Current thinking level (from session) */
-	thinkingLevel: ThinkingLevel;
+	thinkingLevel: ThinkingLevel | undefined;
 	/** Available themes */
 	availableThemes: string[];
 	/** Working directory for plugins tab */
@@ -272,7 +273,7 @@ export class SettingsSelectorComponent extends Container {
 					id: def.path,
 					label: def.label,
 					description: def.description,
-					currentValue: String(currentValue ?? ""),
+					currentValue: this.#getSubmenuCurrentValue(def.path, currentValue),
 					submenu: (cv, done) => this.#createSubmenu(def, cv, done),
 				};
 		}
@@ -285,6 +286,14 @@ export class SettingsSelectorComponent extends Container {
 		return settings.get(def.path);
 	}
 
+	#getSubmenuCurrentValue(path: SettingPath, value: unknown): string {
+		const rawValue = String(value ?? "");
+		if (path === "compaction.thresholdPercent" && (rawValue === "-1" || rawValue === "")) {
+			return "default";
+		}
+		return rawValue;
+	}
+
 	/**
 	 * Create a submenu for a submenu-type setting.
 	 */
@@ -382,7 +391,9 @@ export class SettingsSelectorComponent extends Container {
 	#setSettingValue(path: SettingPath, value: string): void {
 		// Handle number conversions
 		const currentValue = settings.get(path);
-		if (typeof currentValue === "number") {
+		if (path === "compaction.thresholdPercent" && value === "default") {
+			settings.set(path, -1 as never);
+		} else if (typeof currentValue === "number") {
 			settings.set(path, Number(value) as never);
 		} else if (typeof currentValue === "boolean") {
 			settings.set(path, (value === "true") as never);

package/src/modes/components/status-line/context-thresholds.ts

@@ -0,0 +1,68 @@
+import type { ThemeColor } from "../../../modes/theme/theme";
+
+export type ContextUsageLevel = "normal" | "warning" | "purple" | "error";
+
+const CONTEXT_WARNING_PERCENT_THRESHOLD = 50;
+const CONTEXT_WARNING_TOKEN_THRESHOLD = 150_000;
+const CONTEXT_PURPLE_PERCENT_THRESHOLD = 70;
+const CONTEXT_PURPLE_TOKEN_THRESHOLD = 270_000;
+const CONTEXT_ERROR_PERCENT_THRESHOLD = 90;
+const CONTEXT_ERROR_TOKEN_THRESHOLD = 500_000;
+
+function reachesThreshold(
+	contextPercent: number,
+	contextWindow: number,
+	percentThreshold: number,
+	tokenThreshold: number,
+): boolean {
+	if (!Number.isFinite(contextPercent) || contextPercent <= 0) {
+		return false;
+	}
+
+	if (!Number.isFinite(contextWindow) || contextWindow <= 0) {
+		return contextPercent >= percentThreshold;
+	}
+
+	const tokenPercentThreshold = (tokenThreshold / contextWindow) * 100;
+	return contextPercent >= Math.min(percentThreshold, tokenPercentThreshold);
+}
+
+export function getContextUsageLevel(contextPercent: number, contextWindow: number): ContextUsageLevel {
+	if (
+		reachesThreshold(contextPercent, contextWindow, CONTEXT_ERROR_PERCENT_THRESHOLD, CONTEXT_ERROR_TOKEN_THRESHOLD)
+	) {
+		return "error";
+	}
+
+	if (
+		reachesThreshold(contextPercent, contextWindow, CONTEXT_PURPLE_PERCENT_THRESHOLD, CONTEXT_PURPLE_TOKEN_THRESHOLD)
+	) {
+		return "purple";
+	}
+
+	if (
+		reachesThreshold(
+			contextPercent,
+			contextWindow,
+			CONTEXT_WARNING_PERCENT_THRESHOLD,
+			CONTEXT_WARNING_TOKEN_THRESHOLD,
+		)
+	) {
+		return "warning";
+	}
+
+	return "normal";
+}
+
+export function getContextUsageThemeColor(level: ContextUsageLevel): ThemeColor {
+	switch (level) {
+		case "error":
+			return "error";
+		case "purple":
+			return "thinkingHigh";
+		case "warning":
+			return "warning";
+		case "normal":
+			return "statusLineContext";
+	}
+}

package/src/modes/components/status-line/segments.ts

@@ -1,8 +1,10 @@
 import * as os from "node:os";
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { TERMINAL } from "@oh-my-pi/pi-tui";
 import { formatDuration, formatNumber, getProjectDir } from "@oh-my-pi/pi-utils";
 import { theme } from "../../../modes/theme/theme";
 import { shortenPath } from "../../../tools/render-utils";
+import { getContextUsageLevel, getContextUsageThemeColor } from "./context-thresholds";
 import type { RenderedSegment, SegmentContext, StatusLineSegment, StatusLineSegmentId } from "./types";
 
 export type { SegmentContext } from "./types";
@@ -44,10 +46,14 @@ const modelSegment: StatusLineSegment = {
 
 		let content = withIcon(theme.icon.model, modelName);
 
+		if (ctx.session.isFastModeEnabled() && theme.icon.fast) {
+			content += ` ${theme.icon.fast}`;
+		}
+
 		// Add thinking level with dot separator
-		if (opts.showThinkingLevel !== false && state.model?.reasoning) {
-			const level = state.thinkingLevel || "off";
-			if (level !== "off") {
+		if (opts.showThinkingLevel !== false && state.model?.thinking) {
+			const level = state.thinkingLevel ?? ThinkingLevel.Off;
+			if (level !== ThinkingLevel.Off) {
 				const thinkingText = theme.thinking[level as keyof typeof theme.thinking];
 				if (thinkingText) {
 					content += `${theme.sep.dot}${thinkingText}`;
@@ -244,15 +250,8 @@ const contextPctSegment: StatusLineSegment = {
 		const autoIcon = ctx.autoCompactEnabled && theme.icon.auto ? ` ${theme.icon.auto}` : "";
 		const text = `${pct.toFixed(1)}%/${formatNumber(window)}${autoIcon}`;
 
-		let content: string;
-		if (pct > 90) {
-			content = withIcon(theme.icon.context, theme.fg("error", text));
-		} else if (pct > 70) {
-			content = withIcon(theme.icon.context, theme.fg("warning", text));
-		} else {
-			const colored = theme.fg("statusLineContext", text);
-			content = withIcon(theme.icon.context, colored);
-		}
+		const color = getContextUsageThemeColor(getContextUsageLevel(pct, window));
+		const content = withIcon(theme.icon.context, theme.fg(color, text));
 
 		return { content, visible: true };
 	},

package/src/modes/components/status-line.ts

@@ -7,6 +7,7 @@ import { settings } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import { theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
+import { calculatePromptTokens } from "../../session/compaction/compaction";
 import { findGitHeadPathSync, sanitizeStatusText } from "../shared";
 import {
 	canReuseCachedPr,
@@ -365,12 +366,7 @@ export class StatusLineComponent implements Component {
 			.reverse()
 			.find(m => m.role === "assistant" && m.stopReason !== "aborted") as AssistantMessage | undefined;
 
-		const contextTokens = lastAssistantMessage
-			? lastAssistantMessage.usage.input +
-				lastAssistantMessage.usage.output +
-				lastAssistantMessage.usage.cacheRead +
-				lastAssistantMessage.usage.cacheWrite
-			: 0;
+		const contextTokens = lastAssistantMessage ? calculatePromptTokens(lastAssistantMessage.usage) : 0;
 		const contextWindow = state.model?.contextWindow || 0;
 		const contextPercent = contextWindow > 0 ? (contextTokens / contextWindow) * 100 : 0;
 

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

@@ -1,7 +1,7 @@
-import { getThinkingMetadata, type ThinkingLevel } from "@oh-my-pi/pi-ai";
-
+import type { Effort } from "@oh-my-pi/pi-ai";
 import { Container, type SelectItem, SelectList } from "@oh-my-pi/pi-tui";
 import { getSelectListTheme } from "../../modes/theme/theme";
+import { getThinkingLevelMetadata } from "../../thinking";
 import { DynamicBorder } from "./dynamic-border";
 
 /**
@@ -11,14 +11,14 @@ export class ThinkingSelectorComponent extends Container {
 	#selectList: SelectList;
 
 	constructor(
-		currentLevel: ThinkingLevel,
-		availableLevels: ThinkingLevel[],
-		onSelect: (level: ThinkingLevel) => void,
+		currentLevel: Effort,
+		availableLevels: Effort[],
+		onSelect: (level: Effort) => void,
 		onCancel: () => void,
 	) {
 		super();
 
-		const thinkingLevels: SelectItem[] = availableLevels.map(getThinkingMetadata);
+		const thinkingLevels: SelectItem[] = availableLevels.map(getThinkingLevelMetadata);
 
 		// Add top border
 		this.addChild(new DynamicBorder());
@@ -33,7 +33,7 @@ export class ThinkingSelectorComponent extends Container {
 		}
 
 		this.#selectList.onSelect = item => {
-			onSelect(item.value as ThinkingLevel);
+			onSelect(item.value as Effort);
 		};
 
 		this.#selectList.onCancel = () => {

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

@@ -1,3 +1,4 @@
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import {
 	type Component,
 	Container,
@@ -382,7 +383,7 @@ class TreeList implements Component {
 				parts.push("model", entry.model);
 				break;
 			case "thinking_level_change":
-				parts.push("thinking", entry.thinkingLevel);
+				parts.push("thinking", entry.thinkingLevel ?? ThinkingLevel.Off);
 				break;
 			case "custom":
 				parts.push("custom", entry.customType);
@@ -585,7 +586,7 @@ class TreeList implements Component {
 				result = theme.fg("dim", `[model: ${entry.model}]`);
 				break;
 			case "thinking_level_change":
-				result = theme.fg("dim", `[thinking: ${entry.thinkingLevel}]`);
+				result = theme.fg("dim", `[thinking: ${entry.thinkingLevel ?? ThinkingLevel.Off}]`);
 				break;
 			case "custom":
 				result = theme.fg("dim", `[custom: ${entry.customType}]`);

package/src/modes/controllers/command-controller.ts

@@ -25,7 +25,6 @@ import { getMarkdownTheme, getSymbolTheme, theme } from "../../modes/theme/theme
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage } from "../../session/auth-storage";
-import { createCompactionSummaryMessage } from "../../session/messages";
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd } from "../../tools/path-utils";
 import { replaceTabs } from "../../tools/render-utils";
@@ -776,18 +775,10 @@ export class CommandController {
 				customInstructionsOrOptions && typeof customInstructionsOrOptions === "object"
 					? customInstructionsOrOptions
 					: undefined;
-			const result = await this.ctx.session.compact(instructions, options);
+			await this.ctx.session.compact(instructions, options);
 
 			this.ctx.rebuildChatFromMessages();
 
-			const msg = createCompactionSummaryMessage(
-				result.summary,
-				result.tokensBefore,
-				new Date().toISOString(),
-				result.shortSummary,
-			);
-			this.ctx.addMessageToChat(msg);
-
 			this.ctx.statusLine.invalidate();
 			this.ctx.updateEditorTopBorder();
 		} catch (error) {
@@ -834,6 +825,9 @@ export class CommandController {
 			this.ctx.chatContainer.addChild(
 				new Text(`${theme.fg("accent", `${theme.status.success} New session started with handoff context`)}`, 1, 1),
 			);
+			if (result.savedPath) {
+				this.ctx.showStatus(`Handoff document saved to: ${result.savedPath}`);
+			}
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			if (message === "Handoff cancelled" || (error instanceof Error && error.name === "AbortError")) {
@@ -959,9 +953,6 @@ function formatAccountLabel(limit: UsageLimit, report: UsageReport, index: numbe
 }
 
 function formatResetShort(limit: UsageLimit, nowMs: number): string | undefined {
-	if (limit.window?.resetInMs !== undefined) {
-		return formatDuration(limit.window.resetInMs);
-	}
 	if (limit.window?.resetsAt !== undefined) {
 		return formatDuration(limit.window.resetsAt - nowMs);
 	}
@@ -1021,19 +1012,13 @@ function formatAggregateAmount(limits: UsageLimit[]): string {
 }
 
 function resolveResetRange(limits: UsageLimit[], nowMs: number): string | null {
-	const resets = limits
-		.map(limit => limit.window?.resetInMs ?? undefined)
-		.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > 0);
-	if (resets.length === 0) {
-		const absolute = limits
-			.map(limit => limit.window?.resetsAt)
-			.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > nowMs);
-		if (absolute.length === 0) return null;
-		const earliest = Math.min(...absolute);
-		return `resets at ${new Date(earliest).toLocaleString()}`;
-	}
-	const minReset = Math.min(...resets);
-	const maxReset = Math.max(...resets);
+	const absolute = limits
+		.map(limit => limit.window?.resetsAt)
+		.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > nowMs);
+	if (absolute.length === 0) return null;
+	const offsets = absolute.map(value => value - nowMs);
+	const minReset = Math.min(...offsets);
+	const maxReset = Math.max(...offsets);
 	if (maxReset - minReset > 60_000) {
 		return `resets in ${formatDuration(minReset)}–${formatDuration(maxReset)}`;
 	}

package/src/modes/controllers/event-controller.ts

@@ -438,11 +438,12 @@ export class EventController {
 				};
 				this.ctx.statusContainer.clear();
 				const reasonText = event.reason === "overflow" ? "Context overflow detected, " : "";
+				const actionLabel = event.action === "handoff" ? "Auto-handoff" : "Auto context-full maintenance";
 				this.ctx.autoCompactionLoader = new Loader(
 					this.ctx.ui,
 					spinner => theme.fg("accent", spinner),
 					text => theme.fg("muted", text),
-					`${reasonText}Auto-compacting… (esc to cancel)`,
+					`${reasonText}${actionLabel}… (esc to cancel)`,
 					getSymbolTheme().spinnerFrames,
 				);
 				this.ctx.statusContainer.addChild(this.ctx.autoCompactionLoader);
@@ -460,8 +461,11 @@ export class EventController {
 					this.ctx.autoCompactionLoader = undefined;
 					this.ctx.statusContainer.clear();
 				}
+				const isHandoffAction = event.action === "handoff";
 				if (event.aborted) {
-					this.ctx.showStatus("Auto-compaction cancelled");
+					this.ctx.showStatus(
+						isHandoffAction ? "Auto-handoff cancelled" : "Auto context-full maintenance cancelled",
+					);
 				} else if (event.result) {
 					this.ctx.chatContainer.clear();
 					this.ctx.rebuildChatFromMessages();
@@ -474,8 +478,17 @@ export class EventController {
 					});
 					this.ctx.statusLine.invalidate();
 					this.ctx.updateEditorTopBorder();
+				} else if (event.errorMessage) {
+					this.ctx.showWarning(event.errorMessage);
+				} else if (isHandoffAction) {
+					this.ctx.chatContainer.clear();
+					this.ctx.rebuildChatFromMessages();
+					this.ctx.statusLine.invalidate();
+					this.ctx.updateEditorTopBorder();
+					await this.ctx.reloadTodos();
+					this.ctx.showStatus("Auto-handoff completed");
 				} else {
-					this.ctx.showWarning("Auto-compaction failed; continuing without compaction");
+					this.ctx.showWarning("Auto context-full maintenance failed; continuing without maintenance");
 				}
 				await this.ctx.flushCompactionQueue({ willRetry: event.willRetry });
 				this.ctx.ui.requestRender();

package/src/modes/controllers/input-controller.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs/promises";
-import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { type AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { copyToClipboard, readImageFromClipboard, sanitizeText } from "@oh-my-pi/pi-natives";
 import { $env } from "@oh-my-pi/pi-utils";
 import { settings } from "../../config/settings";
@@ -544,7 +544,9 @@ export class InputController {
 			const roleLabel = result.role === "default" ? "default" : result.role;
 			const roleLabelStyled = theme.bold(theme.fg("accent", roleLabel));
 			const thinkingStr =
-				result.model.reasoning && result.thinkingLevel !== "off" ? ` (thinking: ${result.thinkingLevel})` : "";
+				result.model.thinking && result.thinkingLevel !== ThinkingLevel.Off
+					? ` (thinking: ${result.thinkingLevel})`
+					: "";
 			const tempLabel = options?.temporary ? " (temporary)" : "";
 			const cycleSeparator = theme.fg("dim", " > ");
 			const cycleLabel = roleOrder

package/src/modes/controllers/selector-controller.ts

@@ -1,4 +1,5 @@
-import { getOAuthProviders, type OAuthProvider, type ThinkingLevel } from "@oh-my-pi/pi-ai";
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { getOAuthProviders, type OAuthProvider } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Input, Loader, Spacer, Text } from "@oh-my-pi/pi-tui";
 import { getAgentDbPath, getProjectDir } from "@oh-my-pi/pi-utils";
@@ -380,7 +381,7 @@ export class SelectorController {
 				this.ctx.settings,
 				this.ctx.session.modelRegistry,
 				this.ctx.session.scopedModels,
-				async (model, role, thinkingMode) => {
+				async (model, role, thinkingLevel) => {
 					try {
 						if (role === null) {
 							// Temporary: update agent state but don't persist to settings
@@ -393,8 +394,8 @@ export class SelectorController {
 						} else if (role === "default") {
 							// Default: update agent state and persist
 							await this.ctx.session.setModel(model, role);
-							if (thinkingMode && thinkingMode !== "inherit") {
-								this.ctx.session.setThinkingLevel(thinkingMode as ThinkingLevel);
+							if (thinkingLevel && thinkingLevel !== ThinkingLevel.Inherit) {
+								this.ctx.session.setThinkingLevel(thinkingLevel);
 							}
 							this.ctx.statusLine.invalidate();
 							this.ctx.updateEditorBorderColor();