@shanepadgett/tau-agent 0.32.0 → 0.33.0

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/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
 

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.0",
 	"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.0",
 		"@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,
+	);
 }