@underactive/pi-topping-moa-fusion 0.4.5 → 0.5.0

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [0.5.0]
+
+### Changed
+
+- Depend on `@underactive/pi-topping-primitives` `^0.10.0` (was `^0.8.0`). Nothing it imports changed in between: 0.9.0 added `./env` and `./abort`, which it does not use, and 0.10.0 removed only the `pi-topping-compact` entry names from `./contracts`, which it never referenced. Every topping now asks for the same range, so an install of several shares one copy of the library. No visible change.
+- Model references, registry catalogues, label truncation and the unframed model/thinking picker now use `@underactive/pi-topping-primitives` 0.5.0. MoA framing, saved/current thinking preferences and the registry's `off` fallback remain local.
+- Saved model references with an empty provider or id are now treated as unset rather than accepted as valid references.
+- Enter on Select with no matching model is now inert instead of returning to the overview; Cancel and Escape still go back.
+- Model filters now accept printable pasted text and kitty-encoded characters, including while the action buttons are focused. Backspace edits one Unicode code point and returns focus to models.
+- Picker list colours now follow the injected host theme (accent selection and muted descriptions, scroll indicators and no-match text) rather than pi's global select-list theme. Footer hints start at the body edge instead of a two-column inset and can use that extra wrapping space; action buttons keep their alignment.
+- Use `PI_VIRTUAL_MODEL_API` from the shared primitives contracts for virtual-model detection.
+- MoA settings now go through the shared `@underactive/pi-topping-primitives` 0.2.0 settings store. Every read-modify-write (debate, opinion, implementer, planning, roster changes and the setup overlay) is a locked update, which closes the lost-update race between concurrent sessions. The file keeps its path and tab format; writes are atomic, and the file is created 0600 (and its directory 0700 when new).
+- A settings file that is not valid JSON is no longer silently overwritten: it reads as defaults without console output, and saves are refused with `Could not save MoA settings: …` until the file is fixed or removed.
+- A failed settings save now shows that warning and the run continues; only the setup overlay still aborts, returning without reporting success.
+- The vendored activity meter, shimmer, tool-activity labels and output-token tracker now come from `@underactive/pi-topping-primitives` 0.3.0 (`./activity` and `./activity-tui`).
+- The MoA progress table's activity meters now saturate at an inclusive 80 tokens/s instead of a strict 40 (the shared `rateToLevel` default).
+- The shimmer now matches a colour carried inside a compound SGR.
+- Cost formatting (`formatCost`) and the braille and quadrant spinner frames now come from `@underactive/pi-topping-primitives` 0.6.0 (`./text`, `./glyphs`); rendered output is unchanged. The progress table's joined box glyphs stay local.
+- Finding the pi to spawn, the SIGTERM-to-SIGKILL escalation, the tracked-process registry, the concurrency map, the pi version helpers and the agent `.md` loader now come from `@underactive/pi-topping-primitives` 0.8.0 (`./process`). The registry is still this extension's own (`trackedProcesses`), made by the shared `createProcessTracker()`, so `/reload` kills only what moa-fusion started. The `--no-mcp` probe and its cache stay local.
+- An agent file that is malformed (bad YAML, or a non-string `name`, `description`, `tools`, `model` or `thinking`) is now skipped, and the rest of the directory still loads; before, one bad file aborted discovery. A YAML `null` for `tools`, `model` or `thinking` now counts as absent.
+- A Debian-style `nodejs` binary is treated as a generic runtime, like `node` and `bun`, when moa-fusion looks for the pi to spawn.
+- Verified compatibility with pi 1.4.0: no pi export this extension imports was removed or changed, no package entry point moved, and typecheck and the full test suite pass against 1.4.0.
+- Updated all four pi development dependencies from 1.3.0 to 1.4.0.
+
+### Fixed
+
+- Tool-activity labels are cleaned (terminal sequences and stray control characters removed) before they are truncated, so an escape sequence is never cut in half.
+- A subagent reply cut off at the model's output-token limit was passed on as if complete. `mf_plan_subagent` output (single and parallel) and `/mf-opinion` answers now start with `[Response was truncated: the model reached its output token limit.]`. The reply still counts as a success: children run in pi's JSON mode, which exits 0 on a truncated response.
+
 ## [0.4.5]
 
 ### Changed

package/README.md

@@ -367,7 +367,6 @@ In non-interactive modes (`pi -p`, `--mode json`), `exit_plan_mode` is rejected
 index.ts                     # Package entry point (re-exports src/index.ts)
 src/
 ├── index.ts                 # Thin composition entry
-├── activityMeter.ts         # Dependency-free output-rate meter
 ├── shared/
 │   ├── modelRefs.ts         # Model refs, thinking levels, display labels
 │   ├── controlChars.ts      # Control-character stripping for argv and display
@@ -457,8 +456,6 @@ src/
     ├── observeOverlay.ts
     ├── cancelOverlay.ts
     ├── promptEditor.ts         # File-path/@name completion editor
-    ├── shimmer.ts
-    ├── toolActivity.ts
     ├── verificationFindingsOverlay.ts
     └── workingOverlay.ts      # Blocking-work overlay (plan/opinion/debate naming)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@underactive/pi-topping-moa-fusion",
-  "version": "0.4.5",
+  "version": "0.5.0",
   "description": "Pi extension implementing /mf-plan — Claude Code-style 5-phase plan mode with a Mixture-of-Agents proposer/synthesizer pipeline.",
   "keywords": [
     "pi-package",
@@ -40,7 +40,7 @@
   "scripts": {
     "check": "tsc --noEmit",
     "typecheck": "tsc --noEmit",
-    "test": "node --test 'test/*.test.mjs'"
+    "test": "node -C compiled --experimental-transform-types --test 'test/*.test.mjs'"
   },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
@@ -50,12 +50,15 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "1.3.0",
-    "@earendil-works/pi-ai": "1.3.0",
-    "@earendil-works/pi-coding-agent": "1.3.0",
-    "@earendil-works/pi-tui": "1.3.0",
+    "@earendil-works/pi-agent-core": "1.4.0",
+    "@earendil-works/pi-ai": "1.4.0",
+    "@earendil-works/pi-coding-agent": "1.4.0",
+    "@earendil-works/pi-tui": "1.4.0",
     "@types/node": "^24.0.0",
     "typebox": "^1.3.3",
     "typescript": "^5.8.0"
+  },
+  "dependencies": {
+    "@underactive/pi-topping-primitives": "^0.10.0"
   }
 }

package/src/agents/discovery.ts

@@ -1,114 +1,50 @@
 /**
  * Agent discovery and configuration.
- * Ported from pi's subagent example agents.ts.
+ * The per-file and per-directory loading and the upward `.pi/agents` walk live in
+ * `@underactive/pi-topping-primitives/process` (ported from pi's subagent example); this module
+ * keeps moa-fusion's user-then-project layering and its thinking-level check.
  */
 
-import * as fs from "node:fs";
 import * as path from "node:path";
-import { CONFIG_DIR_NAME, getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import {
+	type AgentDefinition,
+	type AgentFileOptions,
+	findNearestProjectAgentsDir,
+	loadAgentsFromDir,
+	parseAgentFile as parsePackageAgentFile,
+} from "@underactive/pi-topping-primitives/process";
 import { isThinkingLevel, type ThinkingLevel } from "../shared/modelRefs.ts";
 
 export type AgentScope = "user" | "project" | "both";
 
-export interface AgentConfig {
-	name: string;
-	description: string;
-	tools?: string[];
-	model?: string;
-	thinking?: ThinkingLevel;
-	systemPrompt: string;
-	source: "user" | "project";
-	filePath: string;
-}
+export type AgentConfig = AgentDefinition<"user" | "project", ThinkingLevel>;
 
 export interface AgentDiscoveryResult {
 	agents: AgentConfig[];
 	projectAgentsDir: string | null;
 }
 
+/**
+ * An unrecognized level is dropped rather than forwarded: `--thinking` on the child process
+ * would reject it and fail the whole agent run.
+ */
+const AGENT_FILE_OPTIONS: AgentFileOptions<ThinkingLevel> = Object.freeze({
+	parseThinking: (raw: string) => (isThinkingLevel(raw) ? raw : undefined),
+});
+
 /** Parse a single agent markdown file into an `AgentConfig`, or `undefined` if malformed/unreadable. */
 export function parseAgentFile(filePath: string, source: "user" | "project"): AgentConfig | undefined {
-	let content: string;
-	try {
-		content = fs.readFileSync(filePath, "utf-8");
-	} catch {
-		return undefined;
-	}
-
-	const { frontmatter, body } = parseFrontmatter<Record<string, string>>(content);
-
-	if (!frontmatter.name || !frontmatter.description) return undefined;
-
-	const tools = frontmatter.tools
-		?.split(",")
-		.map((t: string) => t.trim())
-		.filter(Boolean);
-
-	// An unrecognized level is dropped rather than forwarded: `--thinking` on the
-	// child process would reject it and fail the whole agent run.
-	const thinking = frontmatter.thinking?.trim();
-
-	return {
-		name: frontmatter.name,
-		description: frontmatter.description,
-		tools: tools && tools.length > 0 ? tools : undefined,
-		model: frontmatter.model,
-		thinking: thinking && isThinkingLevel(thinking) ? thinking : undefined,
-		systemPrompt: body,
-		source,
-		filePath,
-	};
-}
-
-function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig[] {
-	const agents: AgentConfig[] = [];
-
-	if (!fs.existsSync(dir)) return agents;
-
-	let entries: fs.Dirent[];
-	try {
-		entries = fs.readdirSync(dir, { withFileTypes: true });
-	} catch {
-		return agents;
-	}
-
-	for (const entry of entries) {
-		if (!entry.name.endsWith(".md")) continue;
-		if (!entry.isFile() && !entry.isSymbolicLink()) continue;
-
-		const agent = parseAgentFile(path.join(dir, entry.name), source);
-		if (agent) agents.push(agent);
-	}
-
-	return agents;
-}
-
-function isDirectory(p: string): boolean {
-	try {
-		return fs.statSync(p).isDirectory();
-	} catch {
-		return false;
-	}
-}
-
-function findNearestProjectAgentsDir(cwd: string): string | null {
-	let currentDir = cwd;
-	while (true) {
-		const candidate = path.join(currentDir, CONFIG_DIR_NAME, "agents");
-		if (isDirectory(candidate)) return candidate;
-
-		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) return null;
-		currentDir = parentDir;
-	}
+	return parsePackageAgentFile(filePath, source, AGENT_FILE_OPTIONS);
 }
 
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
 	const userDir = path.join(getAgentDir(), "agents");
 	const projectAgentsDir = findNearestProjectAgentsDir(cwd);
 
-	const userAgents = scope === "project" ? [] : loadAgentsFromDir(userDir, "user");
-	const projectAgents = scope === "user" || !projectAgentsDir ? [] : loadAgentsFromDir(projectAgentsDir, "project");
+	const userAgents = scope === "project" ? [] : loadAgentsFromDir(userDir, "user", AGENT_FILE_OPTIONS);
+	const projectAgents =
+		scope === "user" || !projectAgentsDir ? [] : loadAgentsFromDir(projectAgentsDir, "project", AGENT_FILE_OPTIONS);
 
 	const agentMap = new Map<string, AgentConfig>();
 

package/src/config/settings.ts

@@ -7,11 +7,18 @@
  * causes it to be skipped.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { defaultThinkingForModel as sharedDefaultThinkingForModel } from "@underactive/pi-topping-primitives/models";
+import {
+	createSettingsStore,
+	sanitize,
+	type SettingsChange,
+	type SettingsWriteFailure,
+	type SettingsWriteResult,
+} from "@underactive/pi-topping-primitives/settings";
 import {
-	THINKING_LEVELS,
 	isModelRef,
 	isThinkingLevel,
 	type ModelRef,
@@ -19,6 +26,8 @@ import {
 } from "../shared/modelRefs.ts";
 import { parseRosters, type PlanRoster } from "./rosters.ts";
 
+export { thinkingOptionsForModel } from "@underactive/pi-topping-primitives/models";
+
 export type MoaMode = "single" | "moa";
 
 export const MIN_CONCURRENT_AGENTS = 1;
@@ -111,80 +120,86 @@ export function moaSettingsPath(): string {
 	return join(getAgentDir(), "mf-plan", "settings.json");
 }
 
-function parseSettingsFile(path: string): MoaConfig {
-	try {
-		const raw = readFileSync(path, "utf-8");
-		const parsed = JSON.parse(raw) as Partial<MoaConfig>;
-		const proposers = Array.isArray(parsed.proposers)
-			? parsed.proposers.filter(isModelRef)
-			: [];
-		const opinionModels = Array.isArray(parsed.opinionModels)
-			? parsed.opinionModels.filter(isModelRef)
-			: [];
-		const debateModels = Array.isArray(parsed.debateModels)
-			? parsed.debateModels.filter(isModelRef)
-			: [];
-		const debateRounds = typeof parsed.debateRounds === "number" && Number.isFinite(parsed.debateRounds)
-			? Math.min(5, Math.max(2, Math.round(parsed.debateRounds)))
-			: 3;
-		const maxConcurrentAgents = normalizeMaxConcurrentAgents(parsed.maxConcurrentAgents);
-		const maxVerificationRepairs = normalizeMaxVerificationRepairs(parsed.maxVerificationRepairs);
-		const synthesizer = isModelRef(parsed.synthesizer) ? parsed.synthesizer : undefined;
-		const implementer = isModelRef(parsed.implementer) ? parsed.implementer : undefined;
-		const verifier = isModelRef(parsed.verifier) ? parsed.verifier : undefined;
-		const cheap = isModelRef(parsed.cheap) ? parsed.cheap : undefined;
-		const mode: MoaMode = parsed.mode === "moa" ? "moa" : "single";
-
-		const thinkingOverrides: Record<string, ThinkingLevel> = {};
-		if (parsed.thinkingOverrides && typeof parsed.thinkingOverrides === "object") {
-			for (const [key, value] of Object.entries(parsed.thinkingOverrides)) {
-				if (typeof value === "string" && isThinkingLevel(value)) thinkingOverrides[key] = value;
-			}
+/** Field-by-field validation; a missing or non-object file reads as the defaults. */
+function sanitizeMoaConfig(raw: unknown): MoaConfig {
+	if (raw === undefined || !sanitize.isRecord(raw)) return emptyConfig();
+	const parsed = raw as Partial<MoaConfig>;
+	const proposers = Array.isArray(parsed.proposers)
+		? parsed.proposers.filter(isModelRef)
+		: [];
+	const opinionModels = Array.isArray(parsed.opinionModels)
+		? parsed.opinionModels.filter(isModelRef)
+		: [];
+	const debateModels = Array.isArray(parsed.debateModels)
+		? parsed.debateModels.filter(isModelRef)
+		: [];
+	const debateRounds = typeof parsed.debateRounds === "number" && Number.isFinite(parsed.debateRounds)
+		? Math.min(5, Math.max(2, Math.round(parsed.debateRounds)))
+		: 3;
+	const maxConcurrentAgents = normalizeMaxConcurrentAgents(parsed.maxConcurrentAgents);
+	const maxVerificationRepairs = normalizeMaxVerificationRepairs(parsed.maxVerificationRepairs);
+	const synthesizer = isModelRef(parsed.synthesizer) ? parsed.synthesizer : undefined;
+	const implementer = isModelRef(parsed.implementer) ? parsed.implementer : undefined;
+	const verifier = isModelRef(parsed.verifier) ? parsed.verifier : undefined;
+	const cheap = isModelRef(parsed.cheap) ? parsed.cheap : undefined;
+	const mode: MoaMode = parsed.mode === "moa" ? "moa" : "single";
+
+	const thinkingOverrides: Record<string, ThinkingLevel> = {};
+	if (parsed.thinkingOverrides && typeof parsed.thinkingOverrides === "object") {
+		for (const [key, value] of Object.entries(parsed.thinkingOverrides)) {
+			if (typeof value === "string" && isThinkingLevel(value)) thinkingOverrides[key] = value;
 		}
+	}
 
-		const autoResolveConflicts = typeof parsed.autoResolveConflicts === "boolean"
-			? parsed.autoResolveConflicts
-			: false;
+	const autoResolveConflicts = typeof parsed.autoResolveConflicts === "boolean"
+		? parsed.autoResolveConflicts
+		: false;
 
-		const useSummaryName = typeof parsed.useSummaryName === "boolean"
-			? parsed.useSummaryName
-			: true;
+	const useSummaryName = typeof parsed.useSummaryName === "boolean"
+		? parsed.useSummaryName
+		: true;
 
-		const minimalFanoutHeader = parsed.minimalFanoutHeader === true;
+	const minimalFanoutHeader = parsed.minimalFanoutHeader === true;
 
-		const agentDefaultsConfigured = parsed.agentDefaultsConfigured === true;
-		const rosters = parseRosters(parsed.rosters);
+	const agentDefaultsConfigured = parsed.agentDefaultsConfigured === true;
+	const rosters = parseRosters(parsed.rosters);
 
-		return { mode, proposers, opinionModels, debateModels, debateRounds, maxConcurrentAgents, maxVerificationRepairs, synthesizer, implementer, verifier, cheap, thinkingOverrides, rosters, autoResolveConflicts, useSummaryName, minimalFanoutHeader, agentDefaultsConfigured };
-	} catch (err) {
-		console.error("mf-plan: failed to parse settings, using defaults:", err);
-		return emptyConfig();
-	}
+	return { mode, proposers, opinionModels, debateModels, debateRounds, maxConcurrentAgents, maxVerificationRepairs, synthesizer, implementer, verifier, cheap, thinkingOverrides, rosters, autoResolveConflicts, useSummaryName, minimalFanoutHeader, agentDefaultsConfigured };
 }
 
+const moaStore = createSettingsStore<MoaConfig>({
+	path: moaSettingsPath,
+	codec: {
+		sanitize: sanitizeMoaConfig,
+		serialize: (config) => `${JSON.stringify(config, null, "\t")}\n`,
+	},
+});
+
+/** A missing, unreadable or corrupt file reads as the defaults. Never throws, never prints. */
 export function loadMoaConfig(): MoaConfig {
-	const settingsPath = moaSettingsPath();
-	if (existsSync(settingsPath)) return parseSettingsFile(settingsPath);
-	return emptyConfig();
+	return moaStore.read();
 }
 
-export function saveMoaConfig(config: MoaConfig): void {
-	const path = moaSettingsPath();
-	mkdirSync(dirname(path), { recursive: true });
-	writeFileSync(path, `${JSON.stringify(config, null, "\t")}\n`, "utf-8");
-}
-
-export function moaSettingsExist(): boolean {
-	return existsSync(moaSettingsPath());
+/** Whole-config write. Prefer `updateMoaConfig` for anything that starts from a loaded config. */
+export function saveMoaConfig(config: MoaConfig): SettingsWriteResult<MoaConfig> {
+	return moaStore.write(config);
 }
 
 /**
- * The levels to offer for a model, in pi's canonical thinking-level order.
- * The registry's declared range is the whole answer — a level it does not list
- * is one the backend will refuse.
+ * Locked read-modify-write: `change` sees the file as it is now, so two sessions saving
+ * different fields both land. Refuses to overwrite a file that is not valid JSON.
  */
-export function thinkingOptionsForModel(registryLevels: ThinkingLevel[]): ThinkingLevel[] {
-	return THINKING_LEVELS.filter((level) => registryLevels.includes(level));
+export function updateMoaConfig(change: SettingsChange<MoaConfig>): SettingsWriteResult<MoaConfig> {
+	return moaStore.update(change);
+}
+
+/** Notification text for a failed save. */
+export function moaSaveFailureMessage(result: SettingsWriteFailure): string {
+	return `Could not save MoA settings: ${result.message}`;
+}
+
+export function moaSettingsExist(): boolean {
+	return existsSync(moaSettingsPath());
 }
 
 /** Selects a model's saved level, the current level, or a sensible default in that order. */
@@ -192,12 +207,7 @@ export function defaultThinkingForModel(
 	key: string,
 	config: MoaConfig,
 	currentLevel: ThinkingLevel,
-	registryLevels: ThinkingLevel[],
+	registryLevels: readonly ThinkingLevel[],
 ): ThinkingLevel {
-	const options = thinkingOptionsForModel(registryLevels);
-	const saved = config.thinkingOverrides[key];
-	if (saved && options.includes(saved)) return saved;
-	if (options.includes(currentLevel)) return currentLevel;
-	if (options.includes("medium")) return "medium";
-	return options[0] ?? "medium";
+	return sharedDefaultThinkingForModel(key, config.thinkingOverrides, currentLevel, registryLevels);
 }

package/src/debate/runDebate.ts

@@ -4,7 +4,7 @@ import { installShippedAgents, shippedAgentsDir, withAuthoritativeMoaAgents } fr
 import { discoverAgents } from "../agents/discovery.ts";
 import { summarizePlanPromptName } from "../config/planName.ts";
 import { slugifyPlanName } from "../planning/planFile.ts";
-import { loadMoaConfig, saveMoaConfig } from "../config/settings.ts";
+import { loadMoaConfig, moaSaveFailureMessage, updateMoaConfig } from "../config/settings.ts";
 import type { OpinionHost } from "../opinion/runOpinion.ts";
 import { resolveContextWindow } from "../moa/modelRuntime.ts";
 import { type CancelSession, subscribeCancelOverlayOnEsc } from "../runtime/cancelRun.ts";
@@ -63,12 +63,13 @@ export async function runInteractiveDebate(
 			if (!selection) return;
 			const { models, thinking, thinkingSelections, rounds } = selection;
 			const settings = loadMoaConfig();
-			saveMoaConfig({
-				...settings,
+			const persisted = updateMoaConfig((current) => ({
+				...current,
 				debateModels: models,
 				debateRounds: rounds,
-				thinkingOverrides: { ...settings.thinkingOverrides, ...thinkingSelections },
-			});
+				thinkingOverrides: { ...current.thinkingOverrides, ...thinkingSelections },
+			}));
+			if (!persisted.ok) ctx.ui.notify(moaSaveFailureMessage(persisted), "warning");
 
 			const slug = await withWorkingOverlay(
 				ctx,

package/src/moa/modelRuntime.ts

@@ -1,34 +1,18 @@
 import { calculateCost, type Api, type Model } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { PI_VIRTUAL_MODEL_API } from "@underactive/pi-topping-primitives/contracts";
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-import { loadMoaConfig, saveMoaConfig } from "../config/settings.ts";
+import { moaSaveFailureMessage, updateMoaConfig } from "../config/settings.ts";
 import type { UsageStats } from "../runtime/results.ts";
 import { modelRefLabel, type ModelRef, type ThinkingLevel } from "../shared/modelRefs.ts";
 
-/**
- * pi's internal `api` id for extension-registered virtual models (the autorouter's
- * `litellm-auto/*`). pi does not export the constant, so mirror the value the
- * autorouter extension pins in its own catalog.ts.
- */
-const VIRTUAL_MODEL_API = "pi-virtual";
-
-/**
- * Whether routing this model in a child subprocess requires loading the extension that
- * registered its provider. True for native extension providers (claude-bridge) — surfaced by
- * getRegisteredProviderIds() — and for virtual models registered via registerVirtualModel
- * (litellm-auto/*). A virtual model's provider never reaches getRegisteredProviderIds():
- * registerVirtualModel keeps it in a separate virtual-model map, so a child spawned with a plain
- * --no-extensions cannot resolve `litellm-auto/auto` and dies with "Model not found". External
- * extensions can register virtual models too, so this keys off pi's virtual-model api id rather
- * than a hardcoded provider name.
- */
 export function modelUsesExtensionRegisteredProvider(ctx: ExtensionContext, ref: ModelRef): boolean {
 	if (ctx.modelRegistry.getRegisteredProviderIds().includes(ref.provider)) return true;
-	// Only an extension can register a virtual (api === "pi-virtual") model, so one mandates loadExtensions in the child.
-	return ctx.modelRegistry.find(ref.provider, ref.id)?.api === VIRTUAL_MODEL_API;
+	// Only an extension can register a virtual model, so one mandates loadExtensions in the child.
+	return ctx.modelRegistry.find(ref.provider, ref.id)?.api === PI_VIRTUAL_MODEL_API;
 }
 
 export function cursorBridgeExtensionPath(): string | undefined {
@@ -130,12 +114,12 @@ export async function applyImplementingSelection(
 		ctx.ui.notify(`No API key for ${modelRefLabel(selection.ref)}; keeping current model.`, "warning");
 		return;
 	}
-	const settings = loadMoaConfig();
-	saveMoaConfig({
+	const saved = updateMoaConfig((settings) => ({
 		...settings,
 		implementer: selection.ref,
 		thinkingOverrides: { ...settings.thinkingOverrides, [modelRefLabel(selection.ref)]: selection.thinking },
-	});
+	}));
+	if (!saved.ok) ctx.ui.notify(moaSaveFailureMessage(saved), "warning");
 	pi.setThinkingLevel(selection.thinking);
 	ctx.ui.notify(successNotice);
 }

package/src/opinion/opinionResults.ts

@@ -1,7 +1,7 @@
 import type { ModelRef, ThinkingLevel } from "../shared/modelRefs.ts";
 import { modelRefLabel } from "../shared/modelRefs.ts";
 import type { SingleResult } from "../runtime/results.ts";
-import { getFinalOutput, getResultOutput, isFailedResult } from "../runtime/results.ts";
+import { getResultOutput, isFailedResult } from "../runtime/results.ts";
 
 export interface OpinionOutcome {
 	ref: ModelRef;
@@ -30,7 +30,7 @@ export function collectOpinionOutcomes(
 			ref,
 			thinking: thinking[index],
 			status: "done",
-			text: getFinalOutput(result.messages).trim() || "(no output)",
+			text: getResultOutput(result).trim() || "(no output)",
 		};
 	});
 }

package/src/opinion/runOpinion.ts

@@ -4,7 +4,7 @@ import { installShippedAgents, shippedAgentsDir, withAuthoritativeMoaAgents } fr
 import { discoverAgents } from "../agents/discovery.ts";
 import { summarizePlanPromptName } from "../config/planName.ts";
 import { slugifyPlanName } from "../planning/planFile.ts";
-import { loadMoaConfig, saveMoaConfig } from "../config/settings.ts";
+import { loadMoaConfig, moaSaveFailureMessage, updateMoaConfig } from "../config/settings.ts";
 import { resolveContextWindow } from "../moa/modelRuntime.ts";
 import { type CancelSession, subscribeCancelOverlayOnEsc } from "../runtime/cancelRun.ts";
 import { formatMutationWarning, MutationTripwire } from "../runtime/mutationTripwire.ts";
@@ -70,11 +70,12 @@ export async function runInteractiveOpinion(
 			if (!selection) return;
 			const { models, thinking, thinkingSelections } = selection;
 			const settings = loadMoaConfig();
-			saveMoaConfig({
-				...settings,
+			const persisted = updateMoaConfig((current) => ({
+				...current,
 				opinionModels: models,
-				thinkingOverrides: { ...settings.thinkingOverrides, ...thinkingSelections },
-			});
+				thinkingOverrides: { ...current.thinkingOverrides, ...thinkingSelections },
+			}));
+			if (!persisted.ok) ctx.ui.notify(moaSaveFailureMessage(persisted), "warning");
 
 			const slug = await withWorkingOverlay(
 				ctx,

package/src/planning/planMode.ts

@@ -15,6 +15,8 @@ import type {
 	ThemeColor,
 	ToolExecutionStartEvent,
 } from "@earendil-works/pi-coding-agent";
+import { OutputTokenAccount } from "@underactive/pi-topping-primitives/activity";
+import { formatToolActivity } from "@underactive/pi-topping-primitives/activity-tui";
 
 import { installShippedAgents } from "../agents/authoritative.ts";
 import { summarizePlanPromptName } from "../config/planName.ts";
@@ -29,7 +31,7 @@ import { runImplementationVerification } from "../moa/verification.ts";
 import { applyImplementingSelection, resolveContextWindow, resolveModelCost } from "../moa/modelRuntime.ts";
 import { validateMfPlanInfo, type MfPlanInfo } from "../moa/planInfo.ts";
 import type { MoaRunHost } from "../moa/runContext.ts";
-import { formatToolActivity, OutputActivityTracker, PartialAssistantAssembler } from "../runtime/activityTracking.ts";
+import { PartialAssistantAssembler } from "../runtime/activityTracking.ts";
 import type { CancelSession } from "../runtime/cancelRun.ts";
 import { cleanupTrackedProcesses } from "../runtime/processPool.ts";
 import type { UsageStats } from "../runtime/results.ts";
@@ -141,7 +143,7 @@ export function createPlanModeController(pi: ExtensionAPI) {
 	// synthesis and review still own the table.
 	let runningProgressWidget: MoaProgressWidget | undefined;
 	// In-session implementer telemetry, reset each time implementation starts.
-	let implementationOutputTracker: OutputActivityTracker | undefined;
+	let implementationOutputTracker: OutputTokenAccount | undefined;
 	let implementationMessages: Message[] = [];
 	const implementationPartial = new PartialAssistantAssembler();
 	let implementationUsage: UsageStats | undefined;
@@ -470,7 +472,7 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		markImplementationPending: (ctx) => {
 			footerError = undefined;
 			implementationPending = true;
-			implementationOutputTracker = new OutputActivityTracker();
+			implementationOutputTracker = new OutputTokenAccount();
 			resetImplementationCounters();
 			// Reconstruct the table for a resumed run that never adopted one (e.g.
 			// /mf-plan-implement after a restart). In-run paths already hold the

package/src/planning/tools/enterPlanMode.ts

@@ -3,7 +3,7 @@ import { isKeyRelease, Key, matchesKey } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
 import { installShippedAgents } from "../../agents/authoritative.ts";
-import { loadMoaConfig, saveMoaConfig } from "../../config/settings.ts";
+import { loadMoaConfig, moaSaveFailureMessage, updateMoaConfig } from "../../config/settings.ts";
 import { runMoaOrchestration } from "../../moa/orchestration.ts";
 import type { MfPlanInfo } from "../../moa/planInfo.ts";
 import type { MoaRunHost } from "../../moa/runContext.ts";
@@ -102,9 +102,9 @@ export async function runInteractivePlanMode(
 				pi.sendUserMessage(trimmedPrompt, TRIGGER_TURN);
 				return;
 			}
-			const settings = loadMoaConfig();
 			const { proposers, synthesizer, implementer, verifier, proposerThinking, synthesizerThinking, implementerThinking, verifierThinking, thinkingSelections } = pickerResult;
-			saveMoaConfig({ ...settings, mode: "moa", proposers, synthesizer, implementer, verifier, thinkingOverrides: { ...settings.thinkingOverrides, ...thinkingSelections } });
+			const saved = updateMoaConfig((settings) => ({ ...settings, mode: "moa", proposers, synthesizer, implementer, verifier, thinkingOverrides: { ...settings.thinkingOverrides, ...thinkingSelections } }));
+			if (!saved.ok) ctx.ui.notify(moaSaveFailureMessage(saved), "warning");
 			host.setActiveRunMoaInfo({ proposers, synthesizer });
 			const outcome = await runMoaOrchestration(host.moaRunHost, ctx, trimmedPrompt, proposers, synthesizer, proposerThinking, synthesizerThinking, session, { implementer, implementerThinking, verifier, verifierThinking });
 			if (outcome === "cancelled") { session.closeOverlay?.(); continue; }

package/src/planning/tools/mfPlanSubagent.ts

@@ -11,7 +11,7 @@ import { discoverAgents, parseAgentFile } from "../../agents/discovery.ts";
 import { modelExtensionOptions, qualifyBareModelId } from "../../moa/modelRuntime.ts";
 import { CancelRun, type CancelRowExtras, type CancelSession } from "../../runtime/cancelRun.ts";
 import { MutationTripwire, formatMutationWarning } from "../../runtime/mutationTripwire.ts";
-import { getFinalOutput, getResultOutput, isFailedResult, truncateOutput } from "../../runtime/results.ts";
+import { getResultOutput, isFailedResult, truncateOutput } from "../../runtime/results.ts";
 import { runParallelAgents, runSingleAgent } from "../../runtime/runner.ts";
 import { parseRef as parseModelRefLabel, type ThinkingLevel } from "../../shared/modelRefs.ts";
 import { activityLoopCount } from "../../ui/agentStatus.ts";
@@ -328,7 +328,7 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 					}
 					return {
 						details: undefined,
-						content: [{ type: "text", text: getFinalOutput(result.messages) || "(no output)" }],
+						content: [{ type: "text", text: getResultOutput(result) }],
 						structuredContent,
 					};
 				} finally {