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

package/src/planning/planMode.ts

@@ -5,6 +5,7 @@ import type {
 	AgentBeforeSettleEvent,
 	AgentSettledEvent,
 	AgentStartEvent,
+	BeforeAgentStartEvent,
 	ExtensionAPI,
 	ExtensionContext,
 	MessageEndEvent,
@@ -14,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";
@@ -28,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";
@@ -140,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;
@@ -469,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
@@ -739,7 +742,15 @@ export function createPlanModeController(pi: ExtensionAPI) {
 				return !isPlanModeInstructionText(msg.content);
 			}) };
 		},
-		onBeforeAgentStart: async () => {
+		onBeforeAgentStart: async (event?: Partial<Pick<BeforeAgentStartEvent, "messageType">>) => {
+			// pi >= 1.2 also fires this for runs another extension starts with
+			// sendMessage(..., { triggerTurn: true }). Those must neither receive plan
+			// instructions nor consume the one-shot exit reminder meant for the user's
+			// next prompt. Older hosts omit messageType and only fire for user runs.
+			if (event?.messageType === "custom") {
+				if (!planModeEnabled) deactivatePlanOnlyTools();
+				return;
+			}
 			if (needsExitReminder) {
 				needsExitReminder = false;
 				// The reminder turn is also the first normal-mode turn: repair a

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

@@ -8,10 +8,10 @@ import * as path from "node:path";
 import { installShippedAgents, shippedAgentsDir, withAuthoritativeMoaAgents } from "../../agents/authoritative.ts";
 import { loadMoaConfig } from "../../config/settings.ts";
 import { discoverAgents, parseAgentFile } from "../../agents/discovery.ts";
-import { modelExtensionOptions } from "../../moa/modelRuntime.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";
@@ -141,7 +141,16 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 			const planOverride = sessionModel
 				? { model: `${sessionModel.provider}/${sessionModel.id}`, thinking: host.currentThinkingLevel() }
 				: undefined;
-			const overrideFor = (agentName: string) => (agentName === "mf-plan" ? planOverride : undefined);
+			// Shipped and hand-edited frontmatter can carry a bare id, which pi >= 1.3.0
+			// rejects as ambiguous when several authenticated providers offer it. Qualify
+			// it here; thinking stays undefined so the frontmatter level still applies.
+			const frontmatterOverrideFor = (agentName: string): { model: string; thinking?: ThinkingLevel } | undefined => {
+				const model = agents.find((agent) => agent.name === agentName)?.model;
+				if (!model) return undefined;
+				const qualified = qualifyBareModelId(ctx.modelRegistry, model);
+				return qualified === model ? undefined : { model: qualified };
+			};
+			const overrideFor = (agentName: string) => (agentName === "mf-plan" && planOverride ? planOverride : frontmatterOverrideFor(agentName));
 
 			// An agent whose effective model belongs to an extension-registered
 			// provider (claude-bridge, cursor-bridge) or is an extension-registered virtual model
@@ -319,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 {

package/src/runtime/activityTracking.ts

@@ -1,96 +1,6 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type { AssistantMessage, Message, ToolCall } from "@earendil-works/pi-ai";
-import { stripTerminalSequences } from "@earendil-works/pi-tui";
-import { StreamingWordCounter } from "../activityMeter.ts";
-import { isNonnegativeFiniteNumber, isValidContentIndex } from "./wire.ts";
-
-/** Max length of a one-line tool-activity description surfaced for progress UIs. */
-const ACTIVITY_MAX = 80;
-
-/** Collapse all whitespace/newlines to single spaces and trim. */
-function collapseWhitespace(text: string): string {
-	return text.replace(/\s+/g, " ").trim();
-}
-
-/**
- * Pick the most informative string argument for a one-line activity label.
- * Prefers well-known tool arg names (command, pattern, path, …); falls back to
- * the first non-empty string value.
- */
-function summarizeToolArgs(args: unknown): string {
-	if (!args || typeof args !== "object") return "";
-	const record = args as Record<string, unknown>;
-	const preferred = ["command", "pattern", "query", "path", "file", "glob", "dir", "url", "name"];
-	for (const key of preferred) {
-		const value = record[key];
-		if (typeof value === "string" && value.trim()) return collapseWhitespace(value);
-	}
-	for (const value of Object.values(record)) {
-		if (typeof value === "string" && value.trim()) return collapseWhitespace(value);
-	}
-	return "";
-}
-
-/** Format a `tool_execution_start` event into a single-line "toolName  arg" label. */
-export function formatToolActivity(toolName: string, args: unknown): string {
-	const detail = summarizeToolArgs(args);
-	const label = detail ? `${toolName}  ${detail}` : String(toolName);
-	return stripTerminalSequences(collapseWhitespace(label).slice(0, ACTIVITY_MAX));
-}
-
-/** Cumulative generated-output reading for the fan-out activity monitor. */
-export interface OutputActivity {
-	/** Tokens generated so far this run: confirmed turns plus the in-flight turn. */
-	tokens: number;
-	/**
-	 * Bumped whenever exact provider usage replaces a differing estimate.
-	 * Consumers reset their rate tracker on a change so the correction doesn't
-	 * register as a burst of generation that never happened.
-	 */
-	revision: number;
-}
-
-export class OutputActivityTracker {
-	#counter = new StreamingWordCounter();
-	#confirmed = 0;
-	#liveWords = 0;
-	#revision = 0;
-
-	/** Begin a new assistant turn, discarding only the previous turn's live estimate. */
-	messageStart(message: { role?: string } | undefined): void {
-		if (message?.role !== "assistant") return;
-		this.#resetTurn();
-	}
-
-	messageUpdate(assistantEvent: { type?: string; delta?: string } | undefined): void {
-		if (assistantEvent?.type !== "text_delta" && assistantEvent?.type !== "thinking_delta") return;
-		if (typeof assistantEvent.delta !== "string") return;
-		// Counted per stream kind so a word split across deltas isn't double
-		// counted, and interleaved thinking/text streams don't corrupt each other.
-		this.#liveWords += this.#counter.count(assistantEvent.delta, assistantEvent.type);
-	}
-
-	messageEnd(message: { role?: string; usage?: { output?: unknown } } | undefined): void {
-		if (message?.role !== "assistant") return;
-		const exact = message.usage?.output;
-		if (isNonnegativeFiniteNumber(exact)) {
-			this.#confirmed += exact;
-			if (exact !== this.#liveWords) this.#revision++;
-		} else {
-			this.#confirmed += this.#liveWords;
-		}
-		this.#resetTurn();
-	}
-
-	snapshot(): OutputActivity {
-		return { tokens: this.#confirmed + this.#liveWords, revision: this.#revision };
-	}
-
-	#resetTurn(): void {
-		this.#liveWords = 0;
-		this.#counter.reset();
-	}
-}
+import { isValidContentIndex } from "./wire.ts";
 
 type AssistantContentPart = AssistantMessage["content"][number];
 

package/src/runtime/piCapabilities.ts

@@ -2,34 +2,23 @@
  * Capability probing for the pi executable a child process will actually run.
  * The local `@earendil-works/pi-coding-agent` VERSION export describes the
  * package this extension was built against, not the host (or `pi` on PATH)
- * that `getPiInvocation()` spawns, so flag support is probed on the executable.
+ * that `resolvePiInvocation()` spawns, so flag support is probed on the executable.
  */
 
 import { execFile } from "node:child_process";
+import {
+	type PiInvocation,
+	parsePiVersion,
+	versionAtLeast,
+} from "@underactive/pi-topping-primitives/process";
 
-export interface PiInvocation {
-	command: string;
-	args: string[];
-}
+export { parsePiVersion, versionAtLeast };
+export type { PiInvocation };
 
 /** `--no-mcp` first ships in pi 1.0.4; 1.0.3 rejects it as an unknown option. */
 const NO_MCP_MIN_VERSION = [1, 0, 4] as const;
 const VERSION_PROBE_TIMEOUT_MS = 10_000;
 
-export function parsePiVersion(output: string): [number, number, number] | undefined {
-	const match = /(\d+)\.(\d+)\.(\d+)/.exec(output);
-	if (!match) return undefined;
-	return [Number(match[1]), Number(match[2]), Number(match[3])];
-}
-
-export function versionAtLeast(version: readonly number[], minimum: readonly number[]): boolean {
-	for (let i = 0; i < minimum.length; i++) {
-		const diff = (version[i] ?? 0) - minimum[i];
-		if (diff !== 0) return diff > 0;
-	}
-	return true;
-}
-
 export function versionSupportsNoMcp(output: string): boolean {
 	const version = parsePiVersion(output);
 	return version !== undefined && versionAtLeast(version, NO_MCP_MIN_VERSION);

package/src/runtime/processPool.ts

@@ -1,57 +1,19 @@
-import { type ChildProcess } from "node:child_process";
+import {
+	createProcessTracker,
+	escalateKill,
+	mapWithConcurrencyLimit,
+} from "@underactive/pi-topping-primitives/process";
 
-/** Globally tracked spawned processes so /reload can kill them. */
-export const trackedProcesses: Set<ChildProcess> = new Set();
+export { escalateKill, mapWithConcurrencyLimit };
 
-/** Send SIGTERM, then force a still-live child down after the grace period. */
-export function escalateKill(proc: ChildProcess, termTimeoutMs = 5000): void {
-	if (proc.exitCode !== null || proc.signalCode !== null) return;
-	try { proc.kill("SIGTERM"); } catch { return; }
-	setTimeout(() => {
-		if (proc.exitCode !== null || proc.signalCode !== null) return;
-		try { proc.kill("SIGKILL"); } catch { /* ignore */ }
-	}, termTimeoutMs).unref();
-}
+/** This extension's spawned processes, so /reload kills only what moa-fusion started. */
+export const trackedProcesses = createProcessTracker();
 
-/** Kill every tracked process. Safe to call multiple times. */
+/**
+ * Kill every tracked process. Safe to call multiple times. The snapshot-then-clear ordering
+ * (the delayed SIGKILL pass still reaches the processes that were just signalled) lives in the
+ * package's tracker.
+ */
 export function cleanupTrackedProcesses(termTimeoutMs = 5000): void {
-	// Snapshot targets before clearing so the delayed SIGKILL pass still
-	// reaches the same processes that were just signalled.
-	const processes = [...trackedProcesses];
-	for (const proc of processes) {
-		if (proc.exitCode !== null || proc.signalCode !== null) continue;
-		try { proc.kill("SIGTERM"); } catch { /* ignore */ }
-	}
-	trackedProcesses.clear();
-
-	// Give SIGTERM a moment, then SIGKILL any process that has not exited.
-	setTimeout(() => {
-		for (const proc of processes) {
-			if (proc.exitCode !== null || proc.signalCode !== null) continue;
-			try { proc.kill("SIGKILL"); } catch { /* ignore */ }
-		}
-	}, termTimeoutMs).unref();
-}
-
-
-export async function mapWithConcurrencyLimit<TIn, TOut>(
-	items: TIn[],
-	concurrency: number,
-	fn: (item: TIn, index: number) => Promise<TOut>,
-	onStart?: (index: number) => void,
-): Promise<TOut[]> {
-	if (items.length === 0) return [];
-	const limit = Math.max(1, Math.min(concurrency, items.length));
-	const results: TOut[] = new Array(items.length);
-	let nextIndex = 0;
-	const workers = new Array(limit).fill(null).map(async () => {
-		while (true) {
-			const current = nextIndex++;
-			if (current >= items.length) return;
-			onStart?.(current);
-			results[current] = await fn(items[current], current);
-		}
-	});
-	await Promise.all(workers);
-	return results;
+	trackedProcesses.cleanup(termTimeoutMs);
 }

package/src/runtime/results.ts

@@ -1,5 +1,5 @@
 import type { Message } from "@earendil-works/pi-ai";
-import type { OutputActivity } from "./activityTracking.ts";
+import type { OutputTokenSnapshot } from "@underactive/pi-topping-primitives/activity";
 
 export interface UsageStats {
 	input: number;
@@ -41,7 +41,7 @@ export interface SingleResult {
 	 * Distinct from `usage.output`, which only advances at turn boundaries and
 	 * stays at 0 for providers that never report usage.
 	 */
-	outputActivity?: OutputActivity;
+	outputActivity?: OutputTokenSnapshot;
 	/**
 	 * True when this agent was aborted (per-agent/user cancellation) and the
 	 * caller opted into `resolveOnAbort`. Cancelled results still count as
@@ -85,11 +85,21 @@ export function isFailedResult(result: { exitCode: number; stopReason?: string;
 	);
 }
 
+/**
+ * Prefixed to a child's output when its final response stopped at the model's
+ * output-token limit. Children run in `--mode json`, where pi exits 0 on a
+ * `length` stop (only text mode exits 1), so the reply counts as a success and
+ * this is the only sign that it was cut off. It leads rather than trails the
+ * output so `truncateOutput` cannot cut it away.
+ */
+export const RESPONSE_TRUNCATED_WARNING = "[Response was truncated: the model reached its output token limit.]";
+
 export function getResultOutput(result: { exitCode: number; stopReason?: string; errorMessage?: string; stderr?: string; messages: Message[] }): string {
 	if (isFailedResult(result)) {
 		return result.errorMessage || result.stderr || getFinalOutput(result.messages) || "No agent messages were emitted.";
 	}
-	return getFinalOutput(result.messages) || "(no output)";
+	const output = getFinalOutput(result.messages) || "(no output)";
+	return result.stopReason === "length" ? `${RESPONSE_TRUNCATED_WARNING}\n\n${output}` : output;
 }
 
 /**

package/src/runtime/runner.ts

@@ -10,10 +10,13 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { OutputTokenAccount } from "@underactive/pi-topping-primitives/activity";
+import { formatToolActivity } from "@underactive/pi-topping-primitives/activity-tui";
+import { resolvePiInvocation } from "@underactive/pi-topping-primitives/process";
 import type { AgentConfig } from "../agents/discovery.ts";
 import { normalizeMaxConcurrentAgents } from "../config/settings.ts";
 import type { ThinkingLevel } from "../shared/modelRefs.ts";
-import { OutputActivityTracker, PartialAssistantAssembler, formatToolActivity } from "./activityTracking.ts";
+import { PartialAssistantAssembler } from "./activityTracking.ts";
 import { piSupportsNoMcp, type PiInvocation } from "./piCapabilities.ts";
 import { escalateKill, mapWithConcurrencyLimit, trackedProcesses } from "./processPool.ts";
 import { getFinalOutput, type SingleResult } from "./results.ts";
@@ -71,22 +74,6 @@ export function getReadOnlyAgentTools(configuredTools?: string[]): string[] {
 	return configuredTools.filter((tool) => READ_ONLY_AGENT_TOOL_SET.has(tool));
 }
 
-function getPiInvocation(args: string[]): PiInvocation {
-	const currentScript = process.argv[1];
-	const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/");
-	if (currentScript && !isBunVirtualScript && fs.existsSync(currentScript)) {
-		return { command: process.execPath, args: [currentScript, ...args] };
-	}
-
-	const execName = path.basename(process.execPath).toLowerCase();
-	const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
-	if (!isGenericRuntime) {
-		return { command: process.execPath, args };
-	}
-
-	return { command: "pi", args };
-}
-
 export interface RunSingleAgentOptions {
 	/**
 	 * Load all configured pi extensions in the child process. Retained as a
@@ -201,7 +188,7 @@ export async function runSingleAgent(
 		return currentResult;
 	}
 
-	const outputActivity = new OutputActivityTracker();
+	const outputActivity = new OutputTokenAccount();
 	const partialMessage = new PartialAssistantAssembler();
 
 	const emitUpdate = () => {
@@ -230,7 +217,7 @@ export async function runSingleAgent(
 		// will run knows the flag. The default and isolated paths already pass
 		// --no-extensions, which excludes built-in MCP.
 		if (options.loadExtensions && !options.extensionPath) {
-			const probe = options.piInvocation ?? getPiInvocation([]);
+			const probe = options.piInvocation ?? resolvePiInvocation([]);
 			if (await piSupportsNoMcp(probe)) args.push("--no-mcp");
 		}
 
@@ -240,7 +227,7 @@ export async function runSingleAgent(
 		const exitCode = await new Promise<number>((resolve) => {
 			const invocation = options.piInvocation
 				? { command: options.piInvocation.command, args: [...options.piInvocation.args, ...args] }
-				: getPiInvocation(args);
+				: resolvePiInvocation(args);
 
 			const appendDiagnostics = (diagnostics: string) => {
 				currentResult.stderr = (currentResult.stderr + diagnostics).slice(-MAX_DIAGNOSTIC_CHARS);

package/src/shared/modelRefs.ts

@@ -1,42 +1,18 @@
-export interface ModelRef {
-	provider: string;
-	id: string;
-}
+export {
+	isModelRef,
+	isThinkingLevel,
+	modelRefLabel,
+	parseRef,
+	shortModelName,
+	THINKING_LEVELS,
+	type ModelRef,
+	type ThinkingLevel,
+} from "@underactive/pi-topping-primitives/models";
 
 export type SendUserMessageOptions = { deliverAs?: "steer" | "followUp"; triggerTurn?: boolean };
 export const TRIGGER_TURN: SendUserMessageOptions = { triggerTurn: true };
 export const FOLLOW_UP: SendUserMessageOptions = { deliverAs: "followUp" };
 
-/**
- * pi's thinking-level vocabulary, in pi's canonical order (see
- * `pi.getThinkingLevel()` / `--thinking <level>`). `xhigh` and `max` are
- * distinct levels a model may expose independently, so neither is folded
- * into the other.
- */
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
-export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
-
-export function isThinkingLevel(value: string): value is ThinkingLevel {
-	return (THINKING_LEVELS as readonly string[]).includes(value);
-}
-
-export function isModelRef(value: unknown): value is ModelRef {
-	return !!value
-		&& typeof value === "object"
-		&& typeof (value as ModelRef).provider === "string"
-		&& typeof (value as ModelRef).id === "string";
-}
-
-export function modelRefLabel(ref: ModelRef): string {
-	return `${ref.provider}/${ref.id}`;
-}
-
-export function parseRef(value: string): ModelRef {
-	const idx = value.indexOf("/");
-	if (idx === -1) return { provider: value, id: "" };
-	return { provider: value.slice(0, idx), id: value.slice(idx + 1) };
-}
-
 /**
  * Anonymous slot label substituted for the real `modelRefLabel(ref)` in the
  * synthesizer's input ONLY. Blinding prevents the synthesizer from favoring a
@@ -52,40 +28,3 @@ export function parseRef(value: string): ModelRef {
 export function proposerBlindedLabel(slotIndex: number): string {
 	return `Proposer ${slotIndex + 1}`;
 }
-
-const MODEL_ATTR_SEGMENTS = new Set([
-	"pro", "plus", "max", "ultra", "mini", "flash", "turbo", "coder", "instruct",
-	"preview", "lite", "base", "sonnet", "opus", "haiku", "thinking", "reasoning",
-]);
-const CLAUDE_FAMILY_SEGMENTS = new Set(["sonnet", "opus", "haiku"]);
-
-function isVersionOrAttrSegment(segment: string): boolean {
-	const seg = segment.toLowerCase();
-	if (MODEL_ATTR_SEGMENTS.has(seg)) return true;
-	if (/^v\d/.test(seg)) return true;
-	if (/^k\d/.test(seg)) return true;
-	if (/^[a-z]\d+(\.\d+)*$/i.test(seg)) return true;
-	if (/^\d+(\.\d+)*$/.test(seg)) return true;
-	return false;
-}
-
-function modelIdBase(ref: ModelRef): string {
-	const slashIdx = ref.id.lastIndexOf("/");
-	return slashIdx >= 0 ? ref.id.slice(slashIdx + 1) : ref.id;
-}
-
-/** Short display name for MoA overlay (e.g. "claude-opus-4-6" → "opus", "deepseek-v4-pro" → "deepseek"). */
-export function shortModelName(ref: ModelRef): string {
-	const base = modelIdBase(ref);
-	const segments = base.split("-").filter(Boolean);
-	// Claude's family is its useful compact identifier; "claude" only names
-	// the product and does not distinguish Opus, Sonnet, and Haiku.
-	if (segments[0]?.toLowerCase() === "claude") {
-		const family = segments.find((segment) => CLAUDE_FAMILY_SEGMENTS.has(segment.toLowerCase()));
-		if (family) return family.toLowerCase();
-	}
-	const kept = segments.filter((s) => !isVersionOrAttrSegment(s));
-	let name = kept.length > 0 ? kept.join("-") : base;
-	name = name.replace(/\d+(\.\d+)*$/, "");
-	return name.toLowerCase() || base;
-}

package/src/ui/agentStatus.ts

@@ -71,14 +71,8 @@ export function contextPercent(contextTokens: number | undefined, contextWindow:
 	return `${(ratio * 100).toFixed(1)}%/${formatWindowLabel(contextWindow)}`.padStart(CTX_COL_WIDTH);
 }
 
-/** Format cumulative model cost in the same precision as pi's usage footer. */
-export function formatCost(costUsd: number | undefined): string {
-	if (costUsd === undefined || !Number.isFinite(costUsd)) return "—";
-	return `$${Math.max(0, costUsd).toFixed(3)}`;
-}
+/** Cumulative model cost in the same precision as pi's usage footer; `—` when unknown. Shared from the primitives package. */
+export { formatCostUsd as formatCost } from "@underactive/pi-topping-primitives/text";
 
 /** Elapsed time as `M:SS`. Minutes keep counting past 60 rather than rolling into an hours field. */
-export function formatElapsed(ms: number): string {
-	const totalSeconds = Math.max(0, Math.floor(ms / 1000));
-	return `${Math.floor(totalSeconds / 60)}:${String(totalSeconds % 60).padStart(2, "0")}`;
-}
+export { formatElapsedClock as formatElapsed } from "@underactive/pi-topping-primitives/activity";

package/src/ui/cancelOverlay.ts

@@ -15,6 +15,7 @@
 
 import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey, type Component, type TUI } from "@earendil-works/pi-tui";
+import { highlightActivity } from "@underactive/pi-topping-primitives/activity-tui";
 import type { CancelSession } from "../runtime/cancelRun.ts";
 import { LOOP_THRESHOLD, usageBar } from "./agentStatus.ts";
 import {
@@ -24,7 +25,6 @@ import {
 	UI_TICK_MS,
 	createFrame,
 } from "./chrome.ts";
-import { highlightActivity } from "./toolActivity.ts";
 
 const OVERLAY_MARGIN = 1;
 

package/src/ui/chrome.ts

@@ -3,8 +3,7 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
 export const UI_TICK_MS = 100;
 
-export const BRAILLE_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
-export const QUADRANT_SPINNER_FRAMES = ["◐", "◓", "◑", "◒"] as const;
+export { SPINNER_FRAMES as BRAILLE_SPINNER_FRAMES, QUADRANT_SPINNER_FRAMES } from "@underactive/pi-topping-primitives/glyphs";
 
 export interface BoxGlyphs {
 	topLeft: string;

package/src/ui/debateModelPicker.ts

@@ -10,8 +10,8 @@ import {
 	ratioViewport,
 } from "./chrome.ts";
 import { getAvailableModelRefs } from "./moaModelPicker.ts";
-import { smartTruncateModelLabel } from "./modelLabel.ts";
-import { TwoPaneModelThinking } from "./twoPaneModelThinking.ts";
+import { smartTruncateModelLabel } from "@underactive/pi-topping-primitives/models";
+import { createMoaModelPicker, type TwoPaneModelThinking } from "./twoPaneModelThinking.ts";
 
 const HINT_BASE = "type filters models • ↑↓ navigate pane • tab panes/buttons • ←→ switch/select • enter select";
 
@@ -60,7 +60,7 @@ export class DebateModelPickerComponent implements Component {
 		this.defaults = defaults;
 		this.done = done;
 		this.rounds = Math.min(MAX_DEBATE_ROUNDS, Math.max(MIN_DEBATE_ROUNDS, config.debateRounds));
-		this.twoPane = new TwoPaneModelThinking(tui, theme, availableRefs, config, currentThinking, ctx);
+		this.twoPane = createMoaModelPicker(tui, theme, availableRefs, config, currentThinking, ctx);
 	}
 
 	private assignedCount(): number {

package/src/ui/moaModelPicker.ts

@@ -26,9 +26,9 @@
  * while that slot is still empty — they never count as assignments, so
  * readiness always reflects explicit selections.
  *
- * Models and thinking levels both come from the model registry (see
- * modelCatalogue.ts), so a confirmed selection is usable by construction and
- * nothing verifies it after the picker closes. Whether a model actually answers
+ * Models and thinking levels both come from the shared registry catalogue,
+ * so a confirmed selection is usable by construction and nothing verifies
+ * it after the picker closes. Whether a model actually answers
  * is decided when it runs.
  */
 
@@ -43,10 +43,9 @@ import {
 	wrapWords,
 } from "./chrome.ts";
 import { PLAN_OVERLAY_OPTIONS } from "./menu.ts";
-import { TwoPaneModelThinking } from "./twoPaneModelThinking.ts";
-import { smartTruncateModelLabel } from "./modelLabel.ts";
+import { createMoaModelPicker, type TwoPaneModelThinking } from "./twoPaneModelThinking.ts";
+import { getModelCatalogue, smartTruncateModelLabel } from "@underactive/pi-topping-primitives/models";
 import { proposerDiversityWarning } from "../moa/panelDependence.ts";
-import { getModelCatalogue } from "../config/modelCatalogue.ts";
 import {
 	loadMoaConfig,
 	moaSettingsExist,
@@ -171,7 +170,7 @@ class MoaModelPickerComponent implements Component {
 				].filter((slot) => this.availableLabels.has(modelRefLabel(slot.ref))).length,
 			}))
 			.sort((a, b) => a.roster.name.localeCompare(b.roster.name));
-		this.twoPane = new TwoPaneModelThinking(tui, theme, availableRefs, config, currentThinking, ctx);
+		this.twoPane = createMoaModelPicker(tui, theme, availableRefs, config, currentThinking, ctx);
 	}
 
 	/** The committed model/thinking pair for a slot picker screen, if assigned. */
@@ -811,7 +810,7 @@ class ImplementingModelPickerComponent implements Component {
 		private readonly title: string,
 		private readonly done: (result: { ref: ModelRef; thinking: ThinkingLevel } | undefined) => void,
 	) {
-		this.twoPane = new TwoPaneModelThinking(tui, theme, availableRefs, config, currentThinking, ctx);
+		this.twoPane = createMoaModelPicker(tui, theme, availableRefs, config, currentThinking, ctx);
 		this.twoPane.reset(defaultRef, defaultThinking);
 	}