@underactive/pi-topping-moa-fusion 0.1.0

package/src/moa/fanout.ts

@@ -0,0 +1,152 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import type { AgentConfig } from "../agents/discovery.ts";
+import type { CancelSession } from "../runtime/cancelRun.ts";
+import { CancelRun } from "../runtime/cancelRun.ts";
+import { getFinalOutput, isFailedResult } from "../runtime/results.ts";
+import type { ModelParallelAgentTask } from "../runtime/runner.ts";
+import { modelRefLabel, TRIGGER_TURN, type ModelRef, type ThinkingLevel } from "../shared/modelRefs.ts";
+import { activityLoopCount } from "../ui/agentStatus.ts";
+import type { MoaProgressWidget } from "../ui/moaProgressWidget.ts";
+import type { ObserveSession } from "../ui/observeOverlay.ts";
+import { runWidgetFanout } from "./fanoutWiring.ts";
+import { buildProposerRetryTask, buildProposerTask, looksLikePlan } from "./planlessRetry.ts";
+import { modelExtensionOptions, resolveContextWindow } from "./modelRuntime.ts";
+import type { MoaRunContext, MoaRunHost, SucceededProposal } from "./runContext.ts";
+
+export type FanoutPhaseResult =
+	| { status: "continue"; succeeded: SucceededProposal[]; observe: ObserveSession; previousObserveSession: ObserveSession | undefined }
+	| { status: "done" | "cancelled"; observe: ObserveSession; previousObserveSession: ObserveSession | undefined };
+
+export interface FanoutPhaseOptions {
+	host: MoaRunHost;
+	runContext: Pick<MoaRunContext, "observeSession" | "previousObserveSession">;
+	ctx: ExtensionContext;
+	prompt: string;
+	proposers: ModelRef[];
+	proposerThinking: (ThinkingLevel | undefined)[];
+	session: CancelSession;
+	widget: MoaProgressWidget;
+	agents: AgentConfig[];
+	warnIfMutated(phase: string): Promise<void>;
+}
+
+export async function runFanoutPhase(options: FanoutPhaseOptions): Promise<FanoutPhaseResult> {
+	const { host, runContext, ctx, prompt, proposers, proposerThinking, session, widget, agents, warnIfMutated } = options;
+	widget.startFanout(proposers, proposerThinking);
+	const observe: ObserveSession = {
+		title: "MoA fan-out",
+		phase: "fanout",
+		agents: proposers.map((ref) => {
+			// The observer is display-only: omit the provider while task routing
+			// continues to use modelRefLabel(ref) below.
+			return { label: ref.id, model: ref.id, task: prompt, messages: [], state: "working" };
+		}),
+		overlayOpen: false,
+	};
+	const previousObserveSession = host.getActiveObserveSession();
+	// Publish ownership before fan-out can await or throw so runMoaPhases' outer
+	// finally always restores the predecessor and closes this observer.
+	runContext.previousObserveSession = previousObserveSession;
+	runContext.observeSession = observe;
+	host.setActiveObserveSession(observe);
+
+	const run = new CancelRun();
+	session.title = "MoA fan-out";
+	session.getExtras = (i) => {
+		const status = widget.getStatus(i);
+		if (!status) return undefined;
+		return {
+			contextTokens: status.contextTokens,
+			contextWindow: resolveContextWindow(ctx, status.ref),
+			activity: status.activity,
+			loopCount: activityLoopCount(status.activity, status.activityHistory),
+		};
+	};
+	const runFanout = (tasks: ModelParallelAgentTask[], indexMap: (index: number) => number, currentRun: CancelRun) =>
+		runWidgetFanout({ ctx, agents, tasks, run: currentRun, session, widget, observe, models: proposers, indexMap });
+
+	// The planning contract travels inside the task text — the only channel
+	// guaranteed to survive a bridge's system-prompt override. The observer keeps
+	// the raw prompt so its 120-char header stays readable.
+	const proposerTask = buildProposerTask(prompt);
+	const tasks = proposers.map((ref, index) => {
+		const label = modelRefLabel(ref);
+		return {
+			agent: "moa-proposer",
+			task: proposerTask,
+			model: label,
+			thinking: proposerThinking[index],
+			...modelExtensionOptions(ctx, ref),
+			signal: run.add(label).signal,
+		};
+	});
+	const results = await runFanout(tasks, (index) => index, run);
+	await warnIfMutated("MoA proposer fan-out");
+	if (run.cancelAllRequested) {
+		widget.stopWidget();
+		ctx.ui.notify("MoA run cancelled.");
+		return { status: "cancelled", observe, previousObserveSession };
+	}
+
+	const retryIndices: number[] = [];
+	for (let index = 0; index < results.length; index++) {
+		const result = results[index];
+		if (!isFailedResult(result) && !result.cancelled && !looksLikePlan(getFinalOutput(result.messages))) retryIndices.push(index);
+	}
+	if (retryIndices.length > 0) {
+		ctx.ui.notify(`MoA: retrying ${retryIndices.length} proposer(s) — no plan produced.`);
+		const retryRun = new CancelRun();
+		session.title = "MoA fan-out (retry)";
+		session.getExtras = (index) => {
+			const status = widget.getStatus(retryIndices[index]);
+			if (!status) return undefined;
+			return {
+				contextTokens: status.contextTokens,
+				contextWindow: resolveContextWindow(ctx, status.ref),
+				activity: status.activity,
+				loopCount: activityLoopCount(status.activity, status.activityHistory),
+			};
+		};
+		const retryTasks = retryIndices.map((proposerIndex) => {
+			const ref = proposers[proposerIndex];
+			const label = modelRefLabel(ref);
+			const retryTask = buildProposerRetryTask(proposerTask, getFinalOutput(results[proposerIndex].messages));
+			widget.update(proposerIndex, "working", "retrying: no plan produced");
+			const observed = observe.agents[proposerIndex];
+			if (observed) {
+				observed.state = "working";
+				observed.task = retryTask;
+			}
+			return {
+				agent: "moa-proposer",
+				task: retryTask,
+				model: label,
+				thinking: proposerThinking[proposerIndex],
+				...modelExtensionOptions(ctx, ref),
+				signal: retryRun.add(label).signal,
+			};
+		});
+		const retryResults = await runFanout(retryTasks, (index) => retryIndices[index], retryRun);
+		for (let index = 0; index < retryResults.length; index++) results[retryIndices[index]] = retryResults[index];
+		await warnIfMutated("MoA proposer retry");
+		if (retryRun.cancelAllRequested) {
+			widget.stopWidget();
+			ctx.ui.notify("MoA run cancelled.");
+			return { status: "cancelled", observe, previousObserveSession };
+		}
+	}
+
+	const succeeded: SucceededProposal[] = [];
+	for (let index = 0; index < results.length; index++) {
+		const result = results[index];
+		if (!isFailedResult(result)) succeeded.push({ ref: proposers[index], plan: getFinalOutput(result.messages), originalIndex: index });
+	}
+	if (succeeded.length === 0) {
+		widget.stopWidget();
+		ctx.ui.notify("All MoA proposer models failed. Falling back to single-model planning.", "error");
+		host.pi.sendUserMessage(prompt, TRIGGER_TURN);
+		return { status: "done", observe, previousObserveSession };
+	}
+	return { status: "continue", succeeded, observe, previousObserveSession };
+}

package/src/moa/fanoutWiring.ts

@@ -0,0 +1,88 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import type { AgentConfig } from "../agents/discovery.ts";
+import type { CancelRun, CancelSession } from "../runtime/cancelRun.ts";
+import { getResultOutput, isFailedResult, type SingleResult } from "../runtime/results.ts";
+import { runParallelAgentsWithModels, type ModelParallelAgentTask } from "../runtime/runner.ts";
+import type { ModelRef } from "../shared/modelRefs.ts";
+import type { MoaProgressWidget } from "../ui/moaProgressWidget.ts";
+import type { ObserveSession } from "../ui/observeOverlay.ts";
+import { resolveModelCost } from "./modelRuntime.ts";
+
+export interface WidgetFanoutOptions {
+	ctx: ExtensionContext;
+	agents: AgentConfig[];
+	tasks: ModelParallelAgentTask[];
+	run: CancelRun;
+	session: CancelSession;
+	widget: MoaProgressWidget;
+	observe: ObserveSession;
+	models: ModelRef[];
+	indexMap: (index: number) => number;
+}
+
+/**
+ * Runs a batch through runParallelAgentsWithModels wired to settle the
+ * CancelRun and mirror progress into the widget and observe session — the
+ * settle/onProgress plumbing shared by every MoA fan-out variant.
+ */
+export async function runWidgetFanout(options: WidgetFanoutOptions): Promise<SingleResult[]> {
+	const { ctx, agents, tasks, run, session, widget, observe, models, indexMap } = options;
+	const unsubscribe = run.onChange(() => {
+		run.agents.forEach((agent, index) => {
+			if (agent.state === "cancelling") widget.update(indexMap(index), "cancelling");
+		});
+	});
+	session.run = run;
+	try {
+		return await runParallelAgentsWithModels(
+			ctx.cwd,
+			agents,
+			tasks,
+			undefined,
+			(index, result) => {
+				const widgetIndex = indexMap(index);
+				widget.updateTranscript(widgetIndex, result.messages);
+				const observed = observe.agents[widgetIndex];
+				if (observed) {
+					observed.messages = result.messages;
+					observed.partial = undefined;
+				}
+				if (result.cancelled) {
+					run.settle(index, "cancelled");
+					widget.update(widgetIndex, "cancelled");
+					if (observed) observed.state = "cancelled";
+				} else if (isFailedResult(result)) {
+					run.settle(index, "error");
+					widget.update(widgetIndex, "error", getResultOutput(result).slice(0, 80));
+					if (observed) observed.state = "error";
+				} else {
+					run.settle(index, "done");
+					widget.update(widgetIndex, "done");
+					if (observed) observed.state = "done";
+				}
+			},
+			(index, result) => {
+				const widgetIndex = indexMap(index);
+				widget.updateUsage(
+					widgetIndex,
+					result.usage.contextTokens,
+					result.usage.turns,
+					result.usage.toolCalls,
+					resolveModelCost(ctx, models[widgetIndex], result.usage),
+				);
+				if (result.activity) widget.updateActivity(widgetIndex, result.activity);
+				if (result.outputActivity) widget.updateOutput(widgetIndex, result.outputActivity.tokens, result.outputActivity.revision);
+				widget.updateTranscript(widgetIndex, result.messages, result.partialAssistant);
+				const observed = observe.agents[widgetIndex];
+				if (observed) {
+					observed.messages = result.messages;
+					observed.partial = result.partialAssistant;
+				}
+			},
+		);
+	} finally {
+		unsubscribe();
+		session.run = undefined;
+	}
+}

package/src/moa/implementationRetry.ts

@@ -0,0 +1,292 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	type ModelRef,
+	type ThinkingLevel,
+	isModelRef,
+	isThinkingLevel,
+	modelRefLabel,
+	TRIGGER_TURN,
+} from "../shared/modelRefs.ts";
+import { getPlan, getPlansDirectory, getRepoPlanDirectory, isValidPlanSlug } from "../planning/planFile.ts";
+import { showImplementingModelPicker } from "../ui/moaModelPicker.ts";
+import type { MoaRunHost } from "./runContext.js";
+
+export interface ImplementationHandoff {
+	plan: string;
+	planFilePath: string;
+	repoPlanSlug?: string;
+	model?: ModelRef;
+	thinking?: ThinkingLevel;
+	/** Model that verifies the implementation against the plan once the turn settles. */
+	verifier?: ModelRef;
+	verifierThinking?: ThinkingLevel;
+	/** Frozen markdown checklist generated at approval time for criteria-mode verification. */
+	verificationCriteria?: string;
+	/** How many verifier-driven repair rounds this handoff has already consumed. */
+	verificationRepairs?: number;
+	timestamp: number;
+}
+
+export function validateImplementationHandoff(value: unknown): ImplementationHandoff | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+
+	const candidate = value as Partial<ImplementationHandoff>;
+	if (typeof candidate.plan !== "string") {
+		return undefined;
+	}
+	if (typeof candidate.planFilePath !== "string" || candidate.planFilePath.trim().length === 0) {
+		return undefined;
+	}
+	if (typeof candidate.timestamp !== "number" || !Number.isFinite(candidate.timestamp) || candidate.timestamp <= 0) {
+		return undefined;
+	}
+
+	let repoPlanSlug: string | undefined;
+	if (candidate.repoPlanSlug !== undefined) {
+		if (typeof candidate.repoPlanSlug !== "string" || !isValidPlanSlug(candidate.repoPlanSlug)) {
+			return undefined;
+		}
+		repoPlanSlug = candidate.repoPlanSlug;
+	}
+
+	let model: ModelRef | undefined;
+	if (candidate.model !== undefined) {
+		if (!isModelRef(candidate.model)) {
+			return undefined;
+		}
+		model = candidate.model;
+	}
+
+	let thinking: ThinkingLevel | undefined;
+	if (candidate.thinking !== undefined) {
+		if (!isThinkingLevel(candidate.thinking)) {
+			return undefined;
+		}
+		thinking = candidate.thinking;
+	}
+
+	let verifier: ModelRef | undefined;
+	if (candidate.verifier !== undefined) {
+		if (!isModelRef(candidate.verifier)) {
+			return undefined;
+		}
+		verifier = candidate.verifier;
+	}
+
+	let verifierThinking: ThinkingLevel | undefined;
+	if (candidate.verifierThinking !== undefined) {
+		if (!isThinkingLevel(candidate.verifierThinking)) {
+			return undefined;
+		}
+		verifierThinking = candidate.verifierThinking;
+	}
+
+	let verificationCriteria: string | undefined;
+	if (candidate.verificationCriteria !== undefined) {
+		if (typeof candidate.verificationCriteria !== "string" || candidate.verificationCriteria.trim().length === 0) {
+			return undefined;
+		}
+		verificationCriteria = candidate.verificationCriteria;
+	}
+
+	let verificationRepairs: number | undefined;
+	if (candidate.verificationRepairs !== undefined) {
+		if (typeof candidate.verificationRepairs !== "number"
+			|| !Number.isInteger(candidate.verificationRepairs)
+			|| candidate.verificationRepairs < 0) {
+			return undefined;
+		}
+		verificationRepairs = candidate.verificationRepairs;
+	}
+
+	return {
+		plan: candidate.plan,
+		planFilePath: candidate.planFilePath,
+		repoPlanSlug,
+		model,
+		thinking,
+		verifier,
+		verifierThinking,
+		verificationCriteria,
+		verificationRepairs,
+		timestamp: candidate.timestamp,
+	};
+}
+
+export function implementationTurnFailed(stopReason: string | undefined): boolean {
+	return stopReason === undefined || stopReason === "error";
+}
+
+export function resolveHandoffPlan(handoff: ImplementationHandoff, repoCwd?: string): string | null {
+	if (handoff.plan && handoff.plan.trim().length > 0) {
+		return handoff.plan;
+	}
+
+	if (handoff.planFilePath) {
+		try {
+			const resolvedPath = path.resolve(handoff.planFilePath);
+			const plansDir = path.resolve(getPlansDirectory());
+			const repoPlanDir = repoCwd ? path.resolve(getRepoPlanDirectory(repoCwd)) : undefined;
+			const withinPlansDir = resolvedPath.startsWith(`${plansDir}${path.sep}`);
+			const withinRepoPlanDir = repoPlanDir !== undefined && resolvedPath.startsWith(`${repoPlanDir}${path.sep}`);
+			if ((withinPlansDir || withinRepoPlanDir) && fs.existsSync(resolvedPath)) {
+				const content = fs.readFileSync(resolvedPath, "utf8");
+				if (content.trim().length > 0) {
+					return content;
+				}
+			}
+		} catch {
+			// Fall through to repo slug fallback
+		}
+	}
+
+	if (handoff.repoPlanSlug) {
+		const currentSlugPlan = getPlan();
+		if (currentSlugPlan && currentSlugPlan.trim().length > 0) {
+			return currentSlugPlan;
+		}
+		if (repoCwd) {
+			const repoPlanDir = getRepoPlanDirectory(repoCwd);
+			const repoFilePath = path.join(repoPlanDir, `${handoff.repoPlanSlug}__plan.md`);
+			try {
+				if (fs.existsSync(repoFilePath)) {
+					const content = fs.readFileSync(repoFilePath, "utf8");
+					if (content.trim().length > 0) {
+						return content;
+					}
+				}
+			} catch {
+				// No fallback plan content found
+			}
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Delegation directive appended to every implementation kickoff (initial,
+ * retry, /mf-plan-implement, and verifier repair, since all reuse this
+ * builder). Phrased to degrade gracefully when no subagent/task tool is
+ * available, so no per-call capability flag has to be threaded through.
+ */
+const SUBAGENT_DELEGATION_DIRECTIVE =
+	"Where your environment provides a subagent/task tool, delegate independent, well-scoped pieces of this plan — codebase exploration, edits confined to disjoint files, running a test suite — launching independent ones in parallel; keep ownership of integration and of any file two steps touch, and never rely on a delegated result you have not read back. If no such tool is available, proceed directly.";
+
+export function buildImplementationKickoffMessage(
+	plan: string,
+	planFilePath: string,
+	note?: string,
+): string {
+	const noteParagraph = note ? `${note}\n\n` : "";
+	return `${noteParagraph}User has approved your plan. You can now start coding. Start with updating your todo list if applicable.
+
+${SUBAGENT_DELEGATION_DIRECTIVE}
+
+Your plan has been saved to: ${planFilePath}
+You can refer back to it if needed during implementation.
+
+## Approved Plan:
+${plan}`;
+}
+
+export async function runImplementationRetryFlow(
+	ctx: ExtensionContext,
+	host: MoaRunHost,
+	handoff: ImplementationHandoff,
+	failureReason?: string,
+): Promise<void> {
+	const plan = resolveHandoffPlan(handoff, ctx.cwd);
+	if (!plan) {
+		host.noteRunError(ctx, "Implementation failed and the approved plan content could not be retrieved.");
+		ctx.ui.notify("Implementation failed and approved plan content could not be retrieved from disk.", "error");
+		return;
+	}
+
+	if (!ctx.hasUI) {
+		host.noteRunError(ctx, "Implementation failed with no interactive retry available.");
+		const reasonStr = failureReason ? `: ${failureReason}` : "";
+		ctx.ui.notify(`Implementation failed${reasonStr}. Run /mf-plan-implement to retry with the same or a different model.`, "error");
+		return;
+	}
+
+	const currentLabel = ctx.model ? modelRefLabel(ctx.model) : "current model";
+	const options = [
+		`Retry with ${currentLabel}`,
+		"Choose a different model",
+		"Continue manually",
+	];
+
+	const selection = await ctx.ui.select(
+		"Implementation failed — the plan is still available. What next?",
+		options,
+	);
+
+	if (!selection || selection === "Continue manually") {
+		host.stopActiveProgressWidget();
+		ctx.ui.notify(`Implementation paused. The approved plan is saved at ${handoff.planFilePath}. Run /mf-plan-implement anytime to resume.`, "info");
+		return;
+	}
+
+	if (selection.startsWith("Retry with")) {
+		host.markImplementationPending(ctx);
+		if (handoff.model) host.getActiveProgressWidget()?.switchToImplementing(handoff.model, "retrying implementation…", handoff.thinking);
+		const note = failureReason
+			? `The previous implementation attempt failed with: ${failureReason}. Review the current state of the code and continue implementing the approved plan.`
+			: "The previous implementation attempt failed. Review the current state of the code and continue implementing the approved plan.";
+		await host.pi.sendUserMessage(
+			buildImplementationKickoffMessage(plan, handoff.planFilePath, note),
+			TRIGGER_TURN,
+		);
+		return;
+	}
+
+	if (selection === "Choose a different model") {
+		const newSelection = await showImplementingModelPicker(
+			ctx,
+			host.currentThinkingLevel(),
+			"Implementation failed — choose a different model",
+		);
+
+		if (!newSelection) {
+			// User cancelled model picker; re-run retry flow
+			return runImplementationRetryFlow(ctx, host, handoff, failureReason);
+		}
+
+		await host.applyImplementingSelection(
+			ctx,
+			newSelection,
+			`Switched to ${modelRefLabel(newSelection.ref)} for implementation.`,
+		);
+		const updatedHandoff: ImplementationHandoff = {
+			...handoff,
+			model: newSelection.ref,
+			thinking: newSelection.thinking,
+			timestamp: Date.now(),
+		};
+		host.setImplementationHandoff(updatedHandoff);
+		host.markImplementationPending(ctx);
+
+		const widget = host.getActiveProgressWidget();
+		if (widget) {
+			const moaInfo = host.getActiveRunMoaInfo();
+			widget.setPhaseModels({
+				Plan: moaInfo?.proposers,
+				Synthesize: moaInfo?.synthesizer,
+				Implement: newSelection.ref,
+				Verify: updatedHandoff.verifier,
+			});
+			widget.switchToImplementing(newSelection.ref, "retrying implementation…", newSelection.thinking);
+		}
+
+		const note = `Switched implementation model to ${modelRefLabel(newSelection.ref)}. Review the current state of the code and continue implementing the approved plan.`;
+		await host.pi.sendUserMessage(
+			buildImplementationKickoffMessage(plan, handoff.planFilePath, note),
+			TRIGGER_TURN,
+		);
+	}
+}

package/src/moa/modelRuntime.ts

@@ -0,0 +1,87 @@
+import { calculateCost } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import { loadMoaConfig, saveMoaConfig } from "../config/settings.ts";
+import type { UsageStats } from "../runtime/results.ts";
+import { modelRefLabel, type ModelRef, type ThinkingLevel } from "../shared/modelRefs.ts";
+
+export function modelUsesExtensionRegisteredProvider(ctx: ExtensionContext, ref: ModelRef): boolean {
+	return ctx.modelRegistry.getRegisteredProviderIds().includes(ref.provider);
+}
+
+export function cursorBridgeExtensionPath(): string | undefined {
+	const packageDir = path.join(getAgentDir(), "extensions", "cursor-bridge");
+	try {
+		const packageJson = JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf-8")) as {
+			pi?: { extensions?: unknown };
+		};
+		const entries = packageJson.pi?.extensions;
+		if (!Array.isArray(entries)) return undefined;
+		for (const entry of entries) {
+			if (typeof entry !== "string") continue;
+			const entryPath = path.resolve(packageDir, entry);
+			if (fs.existsSync(entryPath)) return entryPath;
+		}
+	} catch {
+		// Fall back to normal extension discovery below when cursor-bridge is
+		// installed outside the conventional global-extension package layout.
+	}
+	return undefined;
+}
+
+export function modelExtensionOptions(ctx: ExtensionContext, ref: ModelRef): { loadExtensions?: boolean; extensionPath?: string } {
+	if (ref.provider === "cursor-bridge") {
+		const extensionPath = cursorBridgeExtensionPath();
+		if (extensionPath) return { extensionPath };
+	}
+	return modelUsesExtensionRegisteredProvider(ctx, ref) ? { loadExtensions: true } : {};
+}
+
+export function resolveContextWindow(ctx: ExtensionContext, ref: ModelRef): number | undefined {
+	return ctx.modelRegistry.find(ref.provider, ref.id)?.contextWindow;
+}
+
+/** Calculate cumulative cost from the registry rates and the runner's token totals. */
+export function resolveModelCost(ctx: ExtensionContext, ref: ModelRef, usage: UsageStats): number | undefined {
+	const model = ctx.modelRegistry.find(ref.provider, ref.id);
+	if (!model) return undefined;
+	const cost = calculateCost(model, {
+		input: usage.input,
+		output: usage.output,
+		cacheRead: usage.cacheRead,
+		cacheWrite: usage.cacheWrite,
+		cacheWrite1h: usage.cacheWrite1h,
+		totalTokens: usage.input + usage.output + usage.cacheRead + usage.cacheWrite,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	});
+	return Number.isFinite(cost.total) && cost.total >= 0 ? cost.total : undefined;
+}
+
+export async function applyImplementingSelection(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	selection: { ref: ModelRef; thinking: ThinkingLevel },
+	successNotice: string,
+): Promise<void> {
+	const model = ctx.modelRegistry.find(selection.ref.provider, selection.ref.id);
+	if (!model) {
+		ctx.ui.notify(`Model ${modelRefLabel(selection.ref)} not in registry; keeping current model.`, "warning");
+		return;
+	}
+	const ok = await pi.setModel(model);
+	if (!ok) {
+		ctx.ui.notify(`No API key for ${modelRefLabel(selection.ref)}; keeping current model.`, "warning");
+		return;
+	}
+	const settings = loadMoaConfig();
+	saveMoaConfig({
+		...settings,
+		implementer: selection.ref,
+		thinkingOverrides: { ...settings.thinkingOverrides, [modelRefLabel(selection.ref)]: selection.thinking },
+	});
+	pi.setThinkingLevel(selection.thinking);
+	ctx.ui.notify(successNotice);
+}