@underactive/pi-topping-moa-fusion 0.4.1 → 0.4.2

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [0.4.2]
+
+### Changed
+
+- Verified compatibility with pi 1.0.0: no pi export this extension imports was removed or changed, and typecheck and the full test suite pass against 1.0.0.
+- Updated all four pi development dependencies from 0.99.2 to 1.0.0.
+
+### Fixed
+
+- The MoA progress footer now keeps one cumulative elapsed time across fan-out, synthesis, implementation, verification, and verifier-driven repair rounds, while excluding time spent waiting for user input.
+- Other sessions no longer run `moa-verifier` as a general-purpose subagent. Earlier versions installed `moa-proposer`, `moa-synthesizer`, and `moa-verifier` into `~/.pi/agent/agents/`, which subagent tools such as pi-subagents' `Agent` scan in every session, so a session outside `/mf-plan` could hand the verifier unrelated work. These three agents are no longer installed, and copies left by earlier versions are removed at session start. MoA runs already loaded them from the extension package, so edits to those copies never took effect.
+- The `mf_plan_subagent` tool description now states its structured result shape, including the fields of each `results` entry. pi 1.0.0 codemode shortens each tool's declared output to one line of top-level field names, which left `results` as a bare name; the tool description is the one part of that summary kept verbatim, so script authors see the nested shape without calling `describeTool()`. The structured result itself is unchanged.
+
 ## [0.4.1]
 
 ### Added

package/README.md

@@ -99,7 +99,7 @@ Several safeguards target known LLM judging biases:
 - **Auditable reasoning** — the plan opens with a Context section recording dimension reasoning, proposer alignment, and synthesis decisions, so recombination choices are inspectable. `### Proposer alignment` labels support as evidence-backed or asserted, and conflict recommendation Details lines include distinct-model support counts. Reconciliation commentary is confined there; the rest reads as one coherent plan. The orchestrator verifies all three subsections are present and rejects a first plan that omits them (one corrective retry, then a warning), the same way it enforces `## Proposer Verdicts`.
 - **Disagreements go to the user** — every substantive disagreement must be emitted as a `## Conflicts` block, even when the synthesizer is confident, so its judgment is a default you can override rather than a decision made for you. Genuine ambiguity about *your intent* instead produces a single `## Open Question`, and the synthesizer is re-run with your answer.
 
-**Protocol-internal, always current at runtime.** The proposer, synthesizer, and verifier prompts are tightly coupled to this extension's parsers and UI (e.g. the `## Conflicts` markup, and the verifier's `**Verdict:**`/`### Gaps` markup). A hand-edited copy under `~/.pi/agent/agents/` is still written for inspection, but MoA runs always use the bundled definition from the installed extension, so a protocol update can never desync from what the subprocess runs. `moa-explore` and `mf-plan` remain fully user-customizable.
+**Protocol-internal, always current at runtime.** The proposer, synthesizer, and verifier prompts are tightly coupled to this extension's parsers and UI (e.g. the `## Conflicts` markup, and the verifier's `**Verdict:**`/`### Gaps` markup). MoA runs always load them from the installed extension's bundled `agents/` directory, so a protocol update can never desync from what the subprocess runs. They are never installed into `~/.pi/agent/agents/`: subagent tools in every session scan that directory and would offer them as general-purpose agents outside `/mf-plan`. Copies left there by earlier versions are removed at session start. `moa-explore` and `mf-plan` remain fully user-customizable.
 
 ### Implementation failures
 
@@ -234,7 +234,7 @@ All four tools declare pi 0.99 `annotations`, and none claims to be read-only: `
 
 ## Subagents
 
-Seven agent definitions are auto-installed to `~/.pi/agent/agents/` on first run (won't overwrite existing files). Two belong to the single-model workflow, three to MoA planning, one to the independent opinion flow, and one to the debate flow:
+Seven agent definitions ship with the extension. Two belong to the single-model workflow, three to MoA planning, one to the independent opinion flow, and one to the debate flow. The four outside MoA planning (`moa-explore`, `mf-plan`, `moa-opinion`, `moa-debater`) are auto-installed to `~/.pi/agent/agents/` on first run (won't overwrite existing files). The three MoA agents always load from the extension itself and are never installed (see [How the synthesizer works](#how-the-synthesizer-works)):
 
 | Agent | Workflow | Role | Model & thinking come from |
 |-------|----------|------|----------------------------|

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@underactive/pi-topping-moa-fusion",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Pi extension implementing /mf-plan — Claude Code-style 5-phase plan mode with a Mixture-of-Agents proposer/synthesizer pipeline.",
   "keywords": [
     "pi-package",
@@ -50,10 +50,10 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "0.99.2",
-    "@earendil-works/pi-ai": "0.99.2",
-    "@earendil-works/pi-coding-agent": "0.99.2",
-    "@earendil-works/pi-tui": "0.99.2",
+    "@earendil-works/pi-agent-core": "1.0.0",
+    "@earendil-works/pi-ai": "1.0.0",
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
     "@types/node": "^24.0.0",
     "typebox": "^1.3.3",
     "typescript": "^5.8.0"

package/src/agents/authoritative.ts

@@ -15,6 +15,14 @@ import { parseAgentFile, type AgentConfig } from "./discovery.ts";
  */
 export const AUTHORITATIVE_MOA_AGENT_NAMES = Object.freeze(["moa-proposer", "moa-synthesizer", "moa-verifier"]);
 
+/**
+ * The user-facing agents seeded into `~/.pi/agent/agents/` for customization.
+ * That directory is shared: every subagent tool scans it in every session
+ * (e.g. pi-subagents' `Agent`), so anything installed there is offered as a
+ * general-purpose agent outside `/mf-plan`.
+ */
+const INSTALLED_AGENT_NAMES = Object.freeze(["moa-explore", "mf-plan", "moa-opinion", "moa-debater"]);
+
 const MAX_WALK_UP_LEVELS = 5;
 
 /**
@@ -67,19 +75,22 @@ export function withAuthoritativeMoaAgents(agents: AgentConfig[], shippedDir: st
 	return result;
 }
 
+/**
+ * Seed the user-facing agents (no-clobber) and remove the protocol-internal
+ * copies earlier versions installed alongside them. MoA runs load the
+ * protocol agents from the bundled `agents/` directory instead — see
+ * withAuthoritativeMoaAgents.
+ */
 export function installShippedAgents(): void {
 	const agentsDir = path.join(getAgentDir(), "agents");
 	fs.mkdirSync(agentsDir, { recursive: true });
 
-	// This still writes user-visible files for direct inspection/customization,
-	// but note `moa-proposer`/`moa-synthesizer` are no longer authoritative at
-	// runtime once written here — see withAuthoritativeMoaAgents.
 	const sourceDir = shippedAgentsDir();
-	for (const name of ["moa-explore.md", "mf-plan.md", "moa-opinion.md", "moa-debater.md", "moa-proposer.md", "moa-synthesizer.md", "moa-verifier.md"]) {
-		const targetPath = path.join(agentsDir, name);
+	for (const name of INSTALLED_AGENT_NAMES) {
+		const targetPath = path.join(agentsDir, `${name}.md`);
 		if (fs.existsSync(targetPath)) continue; // don't clobber
 
-		const sourcePath = path.join(sourceDir, name);
+		const sourcePath = path.join(sourceDir, `${name}.md`);
 		if (fs.existsSync(sourcePath)) {
 			try {
 				fs.copyFileSync(sourcePath, targetPath);
@@ -88,4 +99,35 @@ export function installShippedAgents(): void {
 			}
 		}
 	}
+
+	removeInstalledAuthoritativeAgents(agentsDir, sourceDir);
+}
+
+/**
+ * Delete installed copies of the protocol-internal agents from `agentsDir`.
+ * Other sessions' subagent tools picked them up there (`moa-verifier` ran for
+ * unrelated verification work), and MoA runs never read them. Only a file that
+ * still declares the agent's own name is removed, and nothing is removed when
+ * `agentsDir` resolves to `shippedDir`, whose files are the bundled definitions.
+ */
+export function removeInstalledAuthoritativeAgents(agentsDir: string, shippedDir: string): void {
+	if (isSameDirectory(agentsDir, shippedDir)) return;
+
+	for (const name of AUTHORITATIVE_MOA_AGENT_NAMES) {
+		const targetPath = path.join(agentsDir, `${name}.md`);
+		try {
+			if (parseAgentFile(targetPath, "user")?.name !== name) continue;
+			fs.unlinkSync(targetPath);
+		} catch {
+			// Malformed frontmatter, or another session removed it first.
+		}
+	}
+}
+
+function isSameDirectory(a: string, b: string): boolean {
+	try {
+		return fs.realpathSync(a) === fs.realpathSync(b);
+	} catch {
+		return false;
+	}
 }

package/src/agents/defaults.ts

@@ -22,8 +22,8 @@ export interface ConfigurableAgent {
 /**
  * The shipped agents whose model the user may choose. `moa-proposer` and
  * `moa-synthesizer` are excluded: their model is assigned per slot at runtime,
- * and withAuthoritativeMoaAgents replaces their on-disk copies wholesale, so
- * any frontmatter written to them would be ignored. `mf-plan` is excluded
+ * and they load from the bundled definitions without ever being installed, so
+ * there is no on-disk frontmatter to write. `mf-plan` is excluded
  * too: it follows the session model chosen when entering plan mode, so a
  * configured default would never be read.
  */

package/src/moa/implementationRetry.ts

@@ -221,10 +221,14 @@ export async function runImplementationRetryFlow(
 		"Continue manually",
 	];
 
-	const selection = await ctx.ui.select(
+	const widget = host.getActiveProgressWidget();
+	const selection = await (widget?.whileWaitingForUser?.(() => ctx.ui.select(
 		"Implementation failed — the plan is still available. What next?",
 		options,
-	);
+	)) ?? ctx.ui.select(
+		"Implementation failed — the plan is still available. What next?",
+		options,
+	));
 
 	if (!selection || selection === "Continue manually") {
 		host.stopActiveProgressWidget();
@@ -246,11 +250,15 @@ export async function runImplementationRetryFlow(
 	}
 
 	if (selection === "Choose a different model") {
-		const newSelection = await showImplementingModelPicker(
+		const newSelection = await (widget?.whileWaitingForUser?.(() => showImplementingModelPicker(
 			ctx,
 			host.currentThinkingLevel(),
 			"Implementation failed — choose a different model",
-		);
+		)) ?? showImplementingModelPicker(
+			ctx,
+			host.currentThinkingLevel(),
+			"Implementation failed — choose a different model",
+		));
 
 		if (!newSelection) {
 			// User cancelled model picker; re-run retry flow
@@ -271,7 +279,6 @@ export async function runImplementationRetryFlow(
 		host.setImplementationHandoff(updatedHandoff);
 		host.markImplementationPending(ctx);
 
-		const widget = host.getActiveProgressWidget();
 		if (widget) {
 			const moaInfo = host.getActiveRunMoaInfo();
 			widget.setPhaseModels({

package/src/moa/reviewLoop.ts

@@ -32,27 +32,28 @@ export async function runReviewLoop(options: ReviewLoopOptions): Promise<"done">
 	});
 	host.persistState();
 	let chatRounds = 0;
+	const waitForUser = <T>(task: () => Promise<T>): Promise<T> => widget.whileWaitingForUser?.(task) ?? task();
 
 	while (true) {
 		session.closeOverlay?.();
 		const synthesizer = getSynthesizer();
 		let decision: PlanReviewDecision;
 		if (ctx.mode === "tui") {
-			decision = await showPlanReview(
+			decision = await waitForUser(() => showPlanReview(
 				ctx,
 				currentPlan,
 				{ proposers, synthesizer, proposerPlans, verdictsMarkdown: getLatestVerdicts() ?? undefined },
 				host.getPlanRepoSlug(),
 				chatRounds < MAX_REVIEW_CHAT_ROUNDS,
-			);
+			));
 		} else {
-			const choice = await ctx.ui.select("Exit plan mode?", ["Approve — start implementing", "Keep planning", "Edit plan", "Chat with synthesizer"]);
+			const choice = await waitForUser(() => ctx.ui.select("Exit plan mode?", ["Approve — start implementing", "Keep planning", "Edit plan", "Chat with synthesizer"]));
 			decision = choice?.startsWith("Approve") ? "approve" : choice?.startsWith("Edit") ? "edit" : choice?.startsWith("Chat") ? "chat" : "keep";
 		}
 
 		if (decision === "edit") {
 			session.closeOverlay?.();
-			const edited = await ctx.ui.editor("Edit Plan", currentPlan);
+			const edited = await waitForUser(() => ctx.ui.editor("Edit Plan", currentPlan));
 			if (edited?.trim()) {
 				currentPlan = stripSynthSections(edited.trim());
 				writePlan(currentPlan);
@@ -68,7 +69,7 @@ export async function runReviewLoop(options: ReviewLoopOptions): Promise<"done">
 				continue;
 			}
 			session.closeOverlay?.();
-			const feedback = await ctx.ui.editor("Describe the changes you want:");
+			const feedback = await waitForUser(() => ctx.ui.editor("Describe the changes you want:"));
 			if (!feedback?.trim()) continue;
 			chatRounds++;
 			synthConversation.push(`The user reviewed your synthesized plan and gave this feedback:\n${feedback.trim()}\n\nRevise the plan accordingly and re-emit the complete final plan. Drop any ## Conflicts or ## Open Question sections.`);
@@ -121,7 +122,7 @@ export async function runReviewLoop(options: ReviewLoopOptions): Promise<"done">
 			if (roles?.implementer) {
 				implementationSelection = { ref: roles.implementer, thinking: roles.implementerThinking ?? host.currentThinkingLevel() };
 			} else {
-				implementationSelection = await showImplementingModelPicker(ctx, host.currentThinkingLevel());
+				implementationSelection = await waitForUser(() => showImplementingModelPicker(ctx, host.currentThinkingLevel()));
 			}
 			if (implementationSelection) {
 				await host.applyImplementingSelection(

package/src/moa/verification.ts

@@ -471,12 +471,13 @@ export async function runVerificationDecision(deps: {
 		? ["View full findings", "Send verifier findings to the implementer", "Accept implementation as-is"]
 		: ["Send verifier findings to the implementer", "Accept implementation as-is"];
 	while (true) {
-		const choice = await ctx.ui.select(
+		const selectDecision = () => ctx.ui.select(
 			buildVerificationDecisionPrompt(parsed, scriptResults, reportPath, promptWidth),
 			options,
 		);
+		const choice = await (widget?.whileWaitingForUser?.(selectDecision) ?? selectDecision());
 		if (choice === "View full findings") {
-			await showFindings(ctx, report);
+			await (widget?.whileWaitingForUser?.(() => showFindings(ctx, report)) ?? showFindings(ctx, report));
 			continue;
 		}
 		if (choice === "Send verifier findings to the implementer") {
@@ -691,10 +692,13 @@ export async function runImplementationVerification(
 		}
 
 		if (outcome.cancelled) {
-			const choice = await ctx.ui.select(
+			const choice = await (widget?.whileWaitingForUser?.(() => ctx.ui.select(
 				"Verification was cancelled — what next?",
 				["Retry verification", "Skip verification"],
-			);
+			)) ?? ctx.ui.select(
+				"Verification was cancelled — what next?",
+				["Retry verification", "Skip verification"],
+			));
 			if (choice === "Retry verification") return "retry";
 			ctx.ui.notify("Verification skipped. Implementation left as-is.", "warning");
 			finish("cancelled");
@@ -715,10 +719,13 @@ export async function runImplementationVerification(
 		const options = fallbackOption
 			? [fallbackOption, "Retry verification", "Skip verification"]
 			: ["Retry verification", "Skip verification"];
-		const choice = await ctx.ui.select(
+		const choice = await (widget?.whileWaitingForUser?.(() => ctx.ui.select(
 			`Verification could not complete (${verifierLabel}): ${titleReason}`,
 			options,
-		);
+		)) ?? ctx.ui.select(
+			`Verification could not complete (${verifierLabel}): ${titleReason}`,
+			options,
+		));
 		if (fallbackOption && choice === fallbackOption) return "fallback";
 		if (choice === "Retry verification") return "retry";
 		ctx.ui.notify("Verification skipped. Implementation left as-is.", "warning");
@@ -788,10 +795,13 @@ export async function runImplementationVerification(
 				finish("error");
 				return;
 			}
-			const choice = await ctx.ui.select(
+			const choice = await (widget?.whileWaitingForUser?.(() => ctx.ui.select(
 				"The verifier produced no parseable verdict — what next?",
 				["Retry verification", "Skip verification"],
-			);
+			)) ?? ctx.ui.select(
+				"The verifier produced no parseable verdict — what next?",
+				["Retry verification", "Skip verification"],
+			));
 			if (choice === "Retry verification") continue;
 			ctx.ui.notify("Verification inconclusive — implementation left as-is.", "warning");
 			finish("error");

package/src/planning/planMode.ts

@@ -154,6 +154,9 @@ export function createPlanModeController(pi: ExtensionAPI) {
 	// than a module singleton so the fake-`pi` tests stay self-contained and no
 	// state leaks across sessions.
 	const askUserQuestionTracker = createAskUserQuestionTracker(pi, () => {
+		const widget = runningProgressWidget ?? activeProgressWidget;
+		if (askUserQuestionTracker.isActive()) widget?.pauseElapsed();
+		else widget?.resumeElapsed();
 		if (lastFooterCtx) updateStatus(lastFooterCtx);
 	});
 	// Subscribe immediately so the blocked flag is live from extension load, not

package/src/planning/tools/mfPlanSubagent.ts

@@ -61,6 +61,7 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 			"Modes: single (agent + task), parallel (tasks array).",
 			"Agents: moa-explore (fast codebase recon), mf-plan (implementation planning).",
 			`Default scope is "user" (from ${path.join(getAgentDir(), "agents")}).`,
+			"Returns { mode, status, total, succeeded, failed, cancelled, aborted, results }; results is an array of { agent, status, exitCode, stopReason?, model?, output, truncated, usage }.",
 		].join(" "),
 
 		outputSchema: MF_PLAN_SUBAGENT_OUTPUT_SCHEMA,

package/src/ui/moaProgressWidget.ts

@@ -215,6 +215,8 @@ export interface MoaProgressView {
 	phaseModels(): PhaseModels;
 	/** The phase currently highlighted in the band; undefined highlights none. */
 	activePhase(): MoaPhase | undefined;
+	/** Total active run time, excluding periods paused for user input. */
+	totalElapsedMs(now?: number): number;
 }
 
 export interface MoaProgressCallbacks {
@@ -258,6 +260,12 @@ export class MoaProgressWidget implements MoaProgressView {
 	private tableMounted = false;
 	private showPreview = true;
 	private requestRender: (() => void) | undefined;
+	/** Accumulated active run time before the current active interval. */
+	private elapsedActiveMs = 0;
+	/** Start of the current active interval; undefined while waiting for user input. */
+	private elapsedActiveSince: number | undefined;
+	/** Nested pause ownership (table unmount plus an explicit prompt may overlap). */
+	private elapsedPauseDepth = 0;
 
 	constructor(
 		ctx: ExtensionContext,
@@ -288,6 +296,8 @@ export class MoaProgressWidget implements MoaProgressView {
 
 	private mountTable(): void {
 		if (this.tableMounted) return;
+		if (this.elapsedActiveSince === undefined && this.elapsedPauseDepth === 0) this.elapsedActiveSince = Date.now();
+		else this.resumeElapsed();
 		this.tableMounted = true;
 		this.ui.setWidget(WIDGET_KEY, (tui, theme) => {
 			this.requestRender = () => tui.requestRender();
@@ -297,6 +307,7 @@ export class MoaProgressWidget implements MoaProgressView {
 
 	private unmount(): void {
 		if (this.tableMounted) {
+			this.pauseElapsed();
 			this.tableMounted = false;
 			this.callbacks.closeStacked?.();
 		}
@@ -311,6 +322,9 @@ export class MoaProgressWidget implements MoaProgressView {
 	 */
 	startFanout(refs: ModelRef[], thinking: (ThinkingLevel | undefined)[] = [], maxConcurrency = refs.length): void {
 		const startedAt = Date.now();
+		this.elapsedActiveMs = 0;
+		this.elapsedActiveSince = startedAt;
+		this.elapsedPauseDepth = 0;
 		const activeCount = Number.isFinite(maxConcurrency) ? Math.max(1, Math.floor(maxConcurrency)) : refs.length;
 		this.statuses = refs.map((ref, index) => ({
 			ref,
@@ -341,6 +355,35 @@ export class MoaProgressWidget implements MoaProgressView {
 		return this.active;
 	}
 
+	/** Pause the run clock while a prompt, picker, or questionnaire waits on the user. */
+	pauseElapsed(now = Date.now()): void {
+		this.elapsedPauseDepth++;
+		if (this.elapsedPauseDepth !== 1 || this.elapsedActiveSince === undefined) return;
+		this.elapsedActiveMs += Math.max(0, now - this.elapsedActiveSince);
+		this.elapsedActiveSince = undefined;
+	}
+
+	/** Resume one pause owner; the clock restarts after the outermost wait ends. */
+	resumeElapsed(now = Date.now()): void {
+		if (this.elapsedPauseDepth === 0) return;
+		this.elapsedPauseDepth--;
+		if (this.elapsedPauseDepth === 0) this.elapsedActiveSince = now;
+	}
+
+	/** Run one user interaction without charging its wall time to the run total. */
+	async whileWaitingForUser<T>(task: () => Promise<T>): Promise<T> {
+		this.pauseElapsed();
+		try {
+			return await task();
+		} finally {
+			this.resumeElapsed();
+		}
+	}
+
+	totalElapsedMs(now = Date.now()): number {
+		return this.elapsedActiveMs + (this.elapsedActiveSince === undefined ? 0 : Math.max(0, now - this.elapsedActiveSince));
+	}
+
 	phaseLabel(phase: MoaPhase): string {
 		return this.callbacks.phaseLabels?.[phase] ?? phase;
 	}
@@ -671,7 +714,7 @@ export class MoaProgressTableComponent implements Component {
 	private readonly timer: ReturnType<typeof setInterval>;
 	private readonly meters: RowMeter[] = [];
 	private readonly previewCache = new Map<number, { revision: number; width: number; lines: string[] }>();
-	private readonly createdAt = Date.now();
+	private readonly animationStartedAt = Date.now();
 	private spinFrame = 0;
 
 	constructor(tui: TUI, theme: ProgressTheme, view: MoaProgressView) {
@@ -760,7 +803,7 @@ export class MoaProgressTableComponent implements Component {
 		const paint = (lit: boolean, text: string): string => {
 			if (!lit) return th.fg("dim", text);
 			return th.getFgAnsi
-				? shimmerString(text, now - this.createdAt, th as ShimmerTheme, "ltr", "normal", true)
+				? shimmerString(text, now - this.animationStartedAt, th as ShimmerTheme, "ltr", "normal", true)
 				: th.fg("text", text);
 		};
 		// Each boundary carries a two-row powerline chevron: the "\" half on the name
@@ -933,7 +976,7 @@ export class MoaProgressTableComponent implements Component {
 		}
 
 		const totalCost = rows.reduce((sum, r) => sum + (r.costUsd ?? 0), 0);
-		const totals = `total ${formatCost(totalCost)} · ${formatElapsed(now - this.createdAt)}`;
+		const totals = `total ${formatCost(totalCost)} · ${formatElapsed(this.view.totalElapsedMs(now))}`;
 		lines.push(border("─".repeat(innerWidth)));
 		lines.push(row(`${th.fg("dim", TABLE_FOOTER)}${" ".repeat(Math.max(1, bodyWidth - visibleWidth(TABLE_FOOTER) - visibleWidth(totals)))}${th.fg("dim", totals)}`));
 		lines.push(border("═".repeat(innerWidth)));