@shanepadgett/tau-agent 0.32.0 → 0.33.1

package/extensions/effort/README.md

@@ -0,0 +1,7 @@
+# Effort Extension
+
+Switches active chat model and thinking level as one effort tier. Available providers come from current logins, and each provider can fall back through its ranked models.
+
+Run `/effort` to choose a tier and provider. `/effort low`, `/effort medium`, and `/effort high` skip the tier prompt. Press `Ctrl+Shift+E` to cycle tiers on current provider.
+
+If selected provider has no usable model for tier, current model stays active. Footer shows an effort label whenever current provider, model, and thinking level match a configured tier; otherwise it shows no label.

package/extensions/effort/index.ts

@@ -0,0 +1,134 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Key, type AutocompleteItem } from "@earendil-works/pi-tui";
+import { emitTauEvent, onTauEvent } from "../../shared/events.ts";
+import {
+	effortForSelection,
+	type EffortProviderCandidates,
+	type ModelEffort,
+	resolveEffortProviders,
+} from "../../shared/model-effort.ts";
+import { EFFORT_STATE_TYPE, effortState, nextEffort } from "./state.ts";
+
+const EFFORTS: readonly ModelEffort[] = ["low", "medium", "high"];
+
+export default function effortExtension(pi: ExtensionAPI): void {
+	let activeEffort: ModelEffort | undefined;
+	let applying = false;
+
+	function publish(): void {
+		emitTauEvent(pi, "tau:model-effort.changed", { effort: activeEffort });
+	}
+
+	function setEffort(effort: ModelEffort | undefined): void {
+		if (activeEffort === effort) return;
+		activeEffort = effort;
+		pi.appendEntry(EFFORT_STATE_TYPE, effortState(effort));
+		publish();
+	}
+
+	async function apply(
+		ctx: ExtensionContext,
+		effort: ModelEffort,
+		provider: EffortProviderCandidates,
+	): Promise<boolean> {
+		applying = true;
+		try {
+			for (const candidate of provider.candidates) {
+				if (!(await pi.setModel(candidate.model))) continue;
+				pi.setThinkingLevel(candidate.reasoning);
+				setEffort(effortForSelection(provider.provider, candidate.model.id, pi.getThinkingLevel()));
+				ctx.ui.notify(`Effort: ${effort} · ${provider.label}/${candidate.model.id}`, "info");
+				return true;
+			}
+			return false;
+		} finally {
+			applying = false;
+		}
+	}
+
+	async function chooseProvider(ctx: ExtensionContext, effort: ModelEffort): Promise<void> {
+		const providers = resolveEffortProviders(ctx, effort);
+		if (providers.length === 0) {
+			ctx.ui.notify(`No logged-in provider has a ${effort} effort model. Current model kept.`, "warning");
+			return;
+		}
+		const labels = providers.map((provider) => `${provider.label} · ${provider.provider}`);
+		const selected = await ctx.ui.select(`Provider for ${effort} effort`, labels);
+		if (!selected) return;
+		const provider = providers[labels.indexOf(selected)];
+		if (!provider) return;
+		if (!(await apply(ctx, effort, provider))) {
+			ctx.ui.notify(`Could not select a ${effort} model from ${provider.label}. Current model kept.`, "warning");
+		}
+	}
+
+	pi.registerCommand("effort", {
+		description: "Select effort tier and logged-in provider",
+		getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
+			const value = prefix.trimStart();
+			if (/\s/.test(value)) return null;
+			const items = EFFORTS.filter((effort) => effort.startsWith(value)).map((effort) => ({
+				value: effort,
+				label: effort,
+			}));
+			return items.length ? items : null;
+		},
+		handler: async (args, ctx) => {
+			await ctx.waitForIdle();
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/effort requires interactive UI.", "error");
+				return;
+			}
+			const arg = args.trim().toLowerCase();
+			if (arg && !isModelEffort(arg)) {
+				ctx.ui.notify("Usage: /effort [low|medium|high]", "error");
+				return;
+			}
+			let effort: ModelEffort | undefined = isModelEffort(arg) ? arg : undefined;
+			if (!arg) {
+				const selected = await ctx.ui.select("Effort", [...EFFORTS]);
+				if (selected && isModelEffort(selected)) effort = selected;
+			}
+			if (!effort) return;
+			await chooseProvider(ctx, effort);
+		},
+	});
+
+	pi.registerShortcut(Key.ctrlShift("e"), {
+		description: "Cycle effort for current provider",
+		handler: async (ctx) => {
+			if (!ctx.isIdle()) {
+				ctx.ui.notify("Wait for the current run before changing effort.", "warning");
+				return;
+			}
+			const effort = nextEffort(activeEffort);
+			const provider = resolveEffortProviders(ctx, effort).find((item) => item.provider === ctx.model?.provider);
+			if (!provider || !(await apply(ctx, effort, provider))) {
+				ctx.ui.notify(`Current provider has no available ${effort} effort model. Current model kept.`, "warning");
+			}
+		},
+	});
+
+	onTauEvent(pi, "model-effort.snapshot", "tau:model-effort.snapshot.requested", publish);
+
+	pi.on("session_start", (_event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
+		publish();
+	});
+	pi.on("session_tree", (_event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
+		publish();
+	});
+	pi.on("model_select", (event) => {
+		if (!applying) setEffort(effortForSelection(event.model.provider, event.model.id, pi.getThinkingLevel()));
+	});
+	pi.on("thinking_level_select", (event, ctx) => {
+		if (!applying) {
+			setEffort(effortForSelection(ctx.model?.provider, ctx.model?.id, event.level));
+		}
+	});
+}
+
+function isModelEffort(value: string): value is ModelEffort {
+	return value === "low" || value === "medium" || value === "high";
+}

package/extensions/effort/state.ts

@@ -0,0 +1,33 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { ModelEffort } from "../../shared/model-effort.ts";
+
+export const EFFORT_STATE_TYPE = "tau.model-effort.state";
+
+export interface EffortStateV1 {
+	v: 1;
+	effort: ModelEffort | null;
+}
+
+export function effortState(effort: ModelEffort | undefined): EffortStateV1 {
+	return { v: 1, effort: effort ?? null };
+}
+
+export function replayEffortState(branch: readonly SessionEntry[]): ModelEffort | undefined {
+	for (let index = branch.length - 1; index >= 0; index -= 1) {
+		const entry = branch[index];
+		if (entry?.type !== "custom" || entry.customType !== EFFORT_STATE_TYPE) continue;
+		const data = entry.data;
+		if (!data || typeof data !== "object") continue;
+		const value = data as Record<string, unknown>;
+		if (value.v !== 1) continue;
+		if (value.effort === null) return undefined;
+		if (value.effort === "low" || value.effort === "medium" || value.effort === "high") return value.effort;
+	}
+	return undefined;
+}
+
+export function nextEffort(effort: ModelEffort | undefined): ModelEffort {
+	if (effort === "low") return "medium";
+	if (effort === "medium") return "high";
+	return "low";
+}

package/extensions/footer/README.md

@@ -14,7 +14,7 @@ Replaces Pi’s default footer with Tau’s compact two-line footer.
 ## Layout
 
 ```text
-git • model • thinking                         S $0.18 · D $2.43
+git • EFFORT • provider/model (thinking)       S $0.18 · D $2.43
 cwd • session                                  footer items
 ```
 

package/extensions/footer/index.ts

@@ -6,7 +6,8 @@ import { homedir } from "node:os";
 import { join, relative } from "node:path";
 import type { ExtensionAPI, ExtensionContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
 import { type Component, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { onTauEvent } from "../../shared/events.ts";
+import { emitTauEvent, onTauEvent } from "../../shared/events.ts";
+import { effortForSelection, type ModelEffort } from "../../shared/model-effort.ts";
 import { loadTauExtensionSettings, updateTauExtensionSettings } from "../../shared/settings/load.ts";
 import footerSettings from "./settings.ts";
 
@@ -39,6 +40,8 @@ export default function footerExtension(pi: ExtensionAPI): void {
 	let footerInstalled = false;
 	let requestRender: (() => void) | undefined;
 	let unsubscribeFooterItems: (() => void) | undefined;
+	let unsubscribeModelEffort: (() => void) | undefined;
+	let activeEffort: ModelEffort | undefined;
 	const gitByCwd = new Map<string, GitSummary | undefined>();
 	let gitRefresh: Promise<void> | undefined;
 	let dailyCost: number | undefined;
@@ -76,7 +79,11 @@ export default function footerExtension(pi: ExtensionAPI): void {
 					const git = gitByCwd.get(currentCtx.cwd);
 					const model = currentCtx.model ? `${currentCtx.model.provider}/${currentCtx.model.id}` : "no-model";
 					const thinking = pi.getThinkingLevel();
-					const topLeft = [gitText(git), `${model} (${thinking})`].filter(Boolean).join(" • ");
+					const separator = theme.fg("dim", " • ");
+					const effort = effortText(theme, activeEffort);
+					const topLeft = [theme.fg("dim", gitText(git)), effort, theme.fg("dim", `${model} (${thinking})`)]
+						.filter(Boolean)
+						.join(separator);
 					const sessionUsage = sessionCost(currentCtx);
 					const session = formatCost(sessionUsage.cost);
 					const daily = dailyCost === undefined ? "$?" : formatCost(dailyCost);
@@ -87,7 +94,7 @@ export default function footerExtension(pi: ExtensionAPI): void {
 						.join(" • ");
 
 					return [
-						renderSplit(width, theme.fg("dim", topLeft), topRight),
+						renderSplit(width, topLeft, topRight),
 						renderSplit(width, theme.fg("dim", bottomLeft), theme.fg("dim", bottomRight)),
 					];
 				},
@@ -165,6 +172,10 @@ export default function footerExtension(pi: ExtensionAPI): void {
 		items.set(item.id, next);
 		render();
 	});
+	unsubscribeModelEffort = onTauEvent(pi, "footer.model-effort", "tau:model-effort.changed", (state) => {
+		activeEffort = state.effort;
+		render();
+	});
 
 	pi.registerCommand(COMMAND, {
 		description: "Toggle Tau footer",
@@ -202,11 +213,22 @@ export default function footerExtension(pi: ExtensionAPI): void {
 	pi.on("session_start", async (_event, ctx) => {
 		const settings = await loadTauExtensionSettings(ctx, footerSettings);
 		setEnabled(ctx, settings.enabled);
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
 		onStateChange(ctx);
+		emitTauEvent(pi, "tau:model-effort.snapshot.requested", {});
+	});
+	pi.on("session_tree", (_event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
+		onStateChange(ctx, false);
+	});
+	pi.on("model_select", (_event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, pi.getThinkingLevel());
+		rerender(ctx);
+	});
+	pi.on("thinking_level_select", (event, ctx) => {
+		activeEffort = effortForSelection(ctx.model?.provider, ctx.model?.id, event.level);
+		rerender(ctx);
 	});
-	pi.on("session_tree", (_event, ctx) => onStateChange(ctx, false));
-	pi.on("model_select", (_event, ctx) => rerender(ctx));
-	pi.on("thinking_level_select", (_event, ctx) => rerender(ctx));
 	pi.on("agent_start", (_event, ctx) => onStateChange(ctx, false));
 	pi.on("turn_end", (_event, ctx) => onStateChange(ctx));
 	pi.on("agent_end", (_event, ctx) => onStateChange(ctx));
@@ -214,6 +236,9 @@ export default function footerExtension(pi: ExtensionAPI): void {
 	pi.on("session_shutdown", (_event, ctx) => {
 		unsubscribeFooterItems?.();
 		unsubscribeFooterItems = undefined;
+		unsubscribeModelEffort?.();
+		unsubscribeModelEffort = undefined;
+		activeEffort = undefined;
 		requestRender = undefined;
 		activeCtx = undefined;
 		footerInstalled = false;
@@ -226,6 +251,11 @@ export default function footerExtension(pi: ExtensionAPI): void {
 	}
 }
 
+function effortText(theme: Theme, effort: ModelEffort | undefined): string {
+	if (!effort) return "";
+	return theme.fg("dim", theme.bold(effort.toUpperCase()));
+}
+
 async function saveEnabled(ctx: ExtensionContext, enabled: boolean): Promise<void> {
 	await updateTauExtensionSettings("global", ctx, footerSettings, (current) => ({ ...current, enabled }));
 }

package/extensions/script-runner/README.md

@@ -1,7 +1,7 @@
 # Script Runner
 
-Gives the agent a first-class `script_runner` tool for running Python and TypeScript instead of falling back to bash. The agent picks whichever language is more efficient for the task.
+Gives the agent a first-class `script_runner` tool for running Python 3 and TypeScript instead of falling back to bash. The agent picks whichever language is more efficient for the task.
 
 When a run fails, the tool keeps the script and returns a `scriptId`. The agent retries with targeted `{oldText, newText}` edits against what it just wrote instead of resending the whole script, saving output tokens and keeping duplicate scripts out of context. Only the source the agent already sent is referenced; no file path is exposed.
 
-Languages are detected from the environment: Python via `python3`/`python`, TypeScript via Node with `--experimental-strip-types` (Node 22.6 or newer). The tool registers only the languages actually available and is hidden from the prompt entirely when neither is present.
+Languages are detected from the environment: Python 3 via `python3`, TypeScript via Node with `--experimental-strip-types` (Node 22.6 or newer). The tool registers only the languages actually available and is hidden from the prompt entirely when neither is present.

package/extensions/script-runner/index.ts

@@ -16,10 +16,10 @@ import {
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
-type Language = "python" | "typescript";
+type Language = "python3" | "typescript";
 
 interface Runtimes {
-	python: string | undefined;
+	python3: string | undefined;
 	typescript: string | undefined;
 }
 
@@ -32,26 +32,23 @@ const TIMEOUT_MS = 120_000;
 const MAX_STORED = 8;
 
 function detectRuntimes(): Runtimes {
-	let python: string | undefined;
-	for (const cmd of ["python3", "python"] as const) {
-		try {
-			execFileSync(cmd, ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
-			python = cmd;
-			break;
-		} catch {
-			// runtime not installed
-		}
+	let python3: string | undefined;
+	try {
+		execFileSync("python3", ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
+		python3 = "python3";
+	} catch {
+		// runtime not installed
 	}
 	const [major, minor] = process.versions.node.split(".").map(Number);
 	let typescript: string | undefined;
 	if (major > 22 || (major === 22 && minor >= 6)) {
 		typescript = process.execPath;
 	}
-	return { python, typescript };
+	return { python3, typescript };
 }
 
 function capitalize(lang: Language): string {
-	return lang === "python" ? "Python" : "TypeScript";
+	return lang === "python3" ? "Python 3" : "TypeScript";
 }
 
 function newScriptId(): string {
@@ -95,8 +92,8 @@ function renderEditsPreview(edits: ReadonlyArray<{ oldText: string; newText: str
 
 export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 	const runtimes = detectRuntimes();
-	const detected = (["python", "typescript"] as const).filter(
-		(lang): lang is Language => (lang === "python" ? runtimes.python : runtimes.typescript) !== undefined,
+	const detected = (["python3", "typescript"] as const).filter(
+		(lang): lang is Language => (lang === "python3" ? runtimes.python3 : runtimes.typescript) !== undefined,
 	);
 	if (detected.length === 0) return;
 
@@ -115,9 +112,9 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 	}
 
 	function resolveCommand(language: Language): string {
-		if (language === "python") {
-			const cmd = runtimes.python;
-			if (!cmd) throw new Error("Python is not available on this machine.");
+		if (language === "python3") {
+			const cmd = runtimes.python3;
+			if (!cmd) throw new Error("Python 3 is not available on this machine.");
 			return cmd;
 		}
 		const cmd = runtimes.typescript;
@@ -139,9 +136,9 @@ export default function scriptRunnerExtension(pi: ExtensionAPI): void {
 		signal: AbortSignal | undefined,
 	): Promise<ExecResult> {
 		const dir = await ensureTempDir();
-		const file = join(dir, language === "python" ? "_run.py" : "_run.ts");
+		const file = join(dir, language === "python3" ? "_run.py" : "_run.ts");
 		await writeFile(file, source, "utf8");
-		const args = language === "python" ? [file] : ["--experimental-strip-types", file];
+		const args = language === "python3" ? [file] : ["--experimental-strip-types", file];
 		const result = await pi.exec(command, args, { cwd, signal, timeout: TIMEOUT_MS });
 		return {
 			...result,

package/extensions/tau-help/help.md

@@ -36,7 +36,11 @@ Adds `/context` to set branch-local reusable repository work scopes from `.pi/co
 
 ## working-memory
 
-Gives agent `working_memory` for selective hard checkpoints. Model-only references identify useful user messages and visible assistant text. Requested source files return as structural outlines, deferred files remain cheap conditional reminders, and a continuation note carries conclusions extracted from exploration. Tool history and full file reads leave future model input without changing saved session. Advisory reminders begin at 40k active-context tokens. Run `/prune` to request reassessment manually.
+Gives agent `working_memory` for selective hard checkpoints. Every checkpoint retains at least one useful user message or visible assistant text. Requested source files return as structural outlines, deferred files remain cheap conditional reminders, and a continuation note carries conclusions extracted from exploration. Tool history and full file reads leave future model input without changing saved session. Advisory reminders begin at 40k active-context tokens. Run `/prune` to request reassessment manually.
+
+## effort
+
+Adds `/effort [low|medium|high]` to select effort and a provider from current logins. Tau selects provider’s best available model for tier, then tries its configured model fallback. `Ctrl+Shift+E` cycles tiers on current provider. Footer derives effort from current provider, model, and thinking level, and hides it when no configured tier matches.
 
 ## explore
 
@@ -88,7 +92,7 @@ Supplies the agent with the current local date and an initial root directory sna
 
 ## script-runner
 
-Gives the agent a first-class `script_runner` tool to execute Python and TypeScript instead of bash. On failure it returns a `scriptId`; the agent retries with targeted `{oldText,newText}` edits against the script it already wrote rather than resending the whole script. Languages are detected from the environment (Python via `python3`/`python`; TypeScript via Node `--experimental-strip-types`, Node 22.6+). The tool registers only available languages and is hidden from the prompt if neither is present.
+Gives the agent a first-class `script_runner` tool to execute Python 3 and TypeScript instead of bash. On failure it returns a `scriptId`; the agent retries with targeted `{oldText,newText}` edits against the script it already wrote rather than resending the whole script. Languages are detected from the environment (Python 3 via `python3`; TypeScript via Node `--experimental-strip-types`, Node 22.6+). The tool registers only available languages and is hidden from the prompt if neither is present.
 
 ## silent-command-runner
 

package/extensions/working-memory/README.md

@@ -2,7 +2,7 @@
 
 Working Memory gives agent selective checkpoints without changing saved conversation.
 
-`working_memory` keeps referenced user messages and visible assistant text. It has three file tiers:
+`working_memory` retains at least one referenced user message or visible assistant text. Keep task framing, constraints, decisions, and active work chain; continuation and file tiers support that conversation context. It has three file tiers:
 
 - Auto-read full source into next turn when agent needs its body to decide, edit, or debug.
 - Carry a structural outline when symbols and locations will support a later scoped read.

package/extensions/working-memory/checkpoint.ts

@@ -23,7 +23,7 @@ export const workingMemoryParameters = Type.Object(
 			description:
 				"Working note for resuming mid-task. Carry durable decisions, concrete findings, live reasoning, unresolved questions, remaining work, and next action; include enough detail to continue without rereading discarded results.",
 		}),
-		keep: Type.Array(Type.String({ minLength: 3, maxLength: 100 }), { maxItems: 100 }),
+		keep: Type.Array(Type.String({ minLength: 3, maxLength: 100 }), { minItems: 1, maxItems: 100 }),
 		readFiles: Type.Array(PATH, {
 			maxItems: 12,
 			description:
@@ -91,6 +91,9 @@ export async function executeWorkingMemory(options: ExecuteWorkingMemoryOptions)
 		})
 		.sort((left, right) => left.order - right.order);
 	const retainedRefs = retained.map((unit) => unit.ref);
+	if (retained.length === 0) {
+		throw new Error("working_memory requires at least one valid keep reference");
+	}
 	const warnings = requestedRefs
 		.filter((ref) => !catalog.has(ref))
 		.map((ref) => `${ref}: memory reference is unavailable and was not retained`);

package/extensions/working-memory/index.ts

@@ -22,7 +22,7 @@ import { replayWorkingMemoryState, WORKING_MEMORY_TOOL, type WorkingMemoryCheckp
 const NUDGE_TYPE = "tau.working-memory.nudge";
 const BASELINE_TYPE = "tau.working-memory.nudge-baseline";
 const TOOL_DESCRIPTION =
-	"Create a selective hard checkpoint for future model context. Keep valuable user and visible assistant messages, auto-read full source or carry file structure as needed, defer conditionally relevant files, and distill exploration findings into one compact continuation note.";
+	"Create a selective hard checkpoint for future model context. Retain one or more valuable user or visible assistant messages, auto-read full source or carry file structure as needed, defer conditionally relevant files, and distill exploration findings into one compact continuation note.";
 
 interface NudgeState {
 	anchorToolCallId: string | undefined;
@@ -99,6 +99,7 @@ export default function workingMemoryExtension(pi: ExtensionAPI): void {
 					promptGuidelines: [
 						"Use working_memory when stale evidence has accumulated or a memory reminder asks for reassessment; continue coherent exploration when current evidence remains useful.",
 						"A hidden working-memory reference catalog provides keep refs only for user messages and visible assistant text. Tool calls, tool results, hidden reasoning, and framework messages cannot be retained.",
+						"Every checkpoint must retain at least one relevant referenced message. Keep task framing, constraints, decisions, and immediate work chain when needed; continuation and file tiers supplement retained conversation and cannot replace it.",
 						"Choose one file tier: readFiles auto-reads source into the next turn when its body is needed; outlineFiles carries symbols and locations for later scoped inspection; deferFiles records inactive conditional paths. Do not read a file merely to decide whether to outline it.",
 						"Choose readFiles instead of outlineFiles when next work will require the complete file. Do not list a path in more than one file tier.",
 						"Use continuation as a working note for resuming mid-task. Carry durable decisions, concrete findings, live reasoning, unresolved questions, remaining work, and next action in as much detail as needed to continue without rereading discarded results. Do not make it a user-facing status update or narrate the checkpoint.",

package/extensions/working-memory/state.ts

@@ -57,6 +57,7 @@ export function parseWorkingMemoryDetails(value: unknown): WorkingMemoryCheckpoi
 	const deferredFiles = parseDeferredFiles(value.deferredFiles);
 	if (
 		!retainedRefs ||
+		retainedRefs.length === 0 ||
 		!prunedRowIds ||
 		!readFiles ||
 		!warnings ||

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.32.0",
+	"version": "0.33.1",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -35,7 +35,7 @@
 	],
 	"dependencies": {
 		"@ast-grep/wasm": "0.45.0",
-		"@shanepadgett/tau-tui": "0.32.0",
+		"@shanepadgett/tau-tui": "0.33.1",
 		"@vscode/tree-sitter-wasm": "0.3.1",
 		"image-size": "2.0.2",
 		"smol-toml": "1.7.0",

package/shared/events.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ModelEffort } from "./model-effort.ts";
 import type { OutlineInjectionRequest, OutlineInjectionResponse } from "./outline-injection.js";
 import type { ToolRowVisualState } from "./tool-row-state.js";
 
@@ -46,6 +47,10 @@ export type TauAgentEvents = {
 		text?: string;
 		priority?: number;
 	};
+	"tau:model-effort.changed": {
+		effort: ModelEffort | undefined;
+	};
+	"tau:model-effort.snapshot.requested": Record<string, never>;
 	"tau:tool-row-state.set": {
 		rowId: string;
 		state?: ToolRowVisualState;

package/shared/model-effort.ts

@@ -1,4 +1,4 @@
-import type { ThinkingLevel } from "@earendil-works/pi-ai";
+import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { resolveCandidates } from "./model-fallback/index.ts";
 import type { ModelCandidate } from "./model-fallback/types.ts";
@@ -6,33 +6,111 @@ import type { ModelCandidate } from "./model-fallback/types.ts";
 export type ModelEffort = "low" | "medium" | "high";
 
 interface ModelPreference {
-	provider: string;
 	model: string;
 	reasoning: ThinkingLevel;
 }
 
-const MODEL_PREFERENCES: Record<ModelEffort, readonly ModelPreference[]> = {
+interface ProviderPreference {
+	provider: string;
+	models: readonly ModelPreference[];
+}
+
+export interface EffortProviderCandidates {
+	provider: string;
+	label: string;
+	candidates: ReadonlyArray<{
+		model: Model<Api>;
+		reasoning: ThinkingLevel;
+	}>;
+}
+
+const MODEL_PREFERENCES: Record<ModelEffort, readonly ProviderPreference[]> = {
 	low: [
-		{ provider: "openai-codex", model: "gpt-5.6-luna", reasoning: "high" },
-		{ provider: "xai", model: "grok-4.5", reasoning: "medium" },
-		{ provider: "anthropic", model: "claude-haiku-4-5", reasoning: "high" },
+		{
+			provider: "openai-codex",
+			models: [
+				{ model: "gpt-5.6-luna", reasoning: "high" },
+				{ model: "gpt-5.5", reasoning: "low" },
+			],
+		},
+		{ provider: "xai", models: [{ model: "grok-4.5", reasoning: "medium" }] },
+		{ provider: "anthropic", models: [{ model: "claude-haiku-4-5", reasoning: "high" }] },
 	],
 	medium: [
-		{ provider: "openai-codex", model: "gpt-5.6-terra", reasoning: "high" },
-		{ provider: "xai", model: "grok-4.5", reasoning: "high" },
-		{ provider: "anthropic", model: "claude-sonnet-5", reasoning: "high" },
+		{
+			provider: "openai-codex",
+			models: [
+				{ model: "gpt-5.6-terra", reasoning: "high" },
+				{ model: "gpt-5.5", reasoning: "medium" },
+			],
+		},
+		{ provider: "xai", models: [{ model: "grok-4.5", reasoning: "high" }] },
+		{ provider: "anthropic", models: [{ model: "claude-sonnet-5", reasoning: "high" }] },
 	],
 	high: [
-		{ provider: "openai-codex", model: "gpt-5.6-sol", reasoning: "high" },
-		{ provider: "xai", model: "grok-4.5", reasoning: "high" },
-		{ provider: "anthropic", model: "claude-opus-5", reasoning: "high" },
+		{
+			provider: "openai-codex",
+			models: [
+				{ model: "gpt-5.6-sol", reasoning: "high" },
+				{ model: "gpt-5.5", reasoning: "high" },
+			],
+		},
+		{ provider: "xai", models: [{ model: "grok-4.5", reasoning: "high" }] },
+		{
+			provider: "anthropic",
+			models: [
+				{ model: "claude-opus-5", reasoning: "high" },
+				{ model: "claude-opus-4-8", reasoning: "high" },
+			],
+		},
 	],
 };
 
+export function effortForSelection(
+	provider: string | undefined,
+	model: string | undefined,
+	reasoning: string | undefined,
+): ModelEffort | undefined {
+	if (!provider || !model || !reasoning) return undefined;
+	for (const effort of ["high", "medium", "low"] as const) {
+		const preference = MODEL_PREFERENCES[effort].find((item) => item.provider === provider);
+		if (preference?.models.some((item) => item.model === model && item.reasoning === reasoning)) return effort;
+	}
+	return undefined;
+}
+
+export function resolveEffortProviders(
+	ctx: Pick<ExtensionContext, "modelRegistry">,
+	effort: ModelEffort,
+): EffortProviderCandidates[] {
+	const available = new Map(ctx.modelRegistry.getAvailable().map((model) => [`${model.provider}/${model.id}`, model]));
+	return MODEL_PREFERENCES[effort].flatMap((preference) => {
+		const candidates = preference.models.flatMap(({ model, reasoning }) => {
+			const availableModel = available.get(`${preference.provider}/${model}`);
+			return availableModel ? [{ model: availableModel, reasoning }] : [];
+		});
+		return candidates.length
+			? [
+					{
+						provider: preference.provider,
+						label: ctx.modelRegistry.getProviderDisplayName(preference.provider),
+						candidates,
+					},
+				]
+			: [];
+	});
+}
+
 export function resolveEffortCandidates(
 	ctx: Pick<ExtensionContext, "modelRegistry" | "model" | "cwd" | "isProjectTrusted">,
 	effort: ModelEffort,
 	includeParentModel: boolean,
 ): Promise<ModelCandidate[]> {
-	return resolveCandidates(ctx, MODEL_PREFERENCES[effort], includeParentModel);
+	return resolveCandidates(
+		ctx,
+		MODEL_PREFERENCES[effort].flatMap((preference) =>
+			preference.models.map((model) => ({ provider: preference.provider, ...model })),
+		),
+		includeParentModel,
+	);
 }