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

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [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
+
+- `write_plan`, `enter_plan_mode`, `exit_plan_mode`, and `mf_plan_subagent` now declare a pi 0.99 `outputSchema` and return matching `structuredContent` for RPC/JSON consumers, `tool_result` handlers, and codemode scripts: per-agent status, exit code, stop reason, usage, and capped output for subagent runs, and the approval outcome and kickoff route for plan exit. Model-facing text is unchanged.
+- The same four tools now declare MCP-style `annotations`, so permission extensions see accurate destructive and idempotent hints. None claims to be read-only.
+
+### Changed
+
+- Updated all four pi development dependencies from 0.87.0 to 0.99.2.
+- Plan-only tools stay out of normal mode by being removed from the active tool set, not through pi 0.99's `prepareLoadout`, which leaves hidden tools active and callable.
+
+### Fixed
+
+- Plan-only tools are now also removed on the first turn after leaving plan mode. Previously the exit-reminder turn skipped the leak repair, so a leaked `write_plan`, `exit_plan_mode`, or `mf_plan_subagent` stayed declared for that turn.
+
 ## [0.3.0]
 
 ### 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
 
@@ -230,9 +230,11 @@ Outside plan mode, one additional tool is exposed:
 |------|-------------|
 | `enter_plan_mode` | Lets the agent enter plan mode itself when asked for a design or plan. Takes the single-model path on the current session model — no pickers, no MoA. Exit and approval work exactly as if the user had invoked `/mf-plan`. |
 
+All four tools declare pi 0.99 `annotations`, and none claims to be read-only: `write_plan` is `destructiveHint: true, idempotentHint: true`, `exit_plan_mode` is `destructiveHint: true, idempotentHint: false`, `mf_plan_subagent` is `idempotentHint: false`, and `enter_plan_mode` sets only `readOnlyHint: false`. Under the example permission policy in pi's extension docs they are confirmed exactly as before. Each also declares an `outputSchema` and returns matching `structuredContent` for programmatic consumers (RPC/JSON `tool_execution_end` events, `tool_result` handlers, and codemode scripts); for `mf_plan_subagent` that is each agent's status, exit code, stop reason, usage, and output capped at 50 KB. The model-facing text is unchanged, and pi does not save structured values in the session.
+
 ## 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.3.0",
+  "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.87.0",
-    "@earendil-works/pi-ai": "0.87.0",
-    "@earendil-works/pi-coding-agent": "0.87.0",
-    "@earendil-works/pi-tui": "0.87.0",
+    "@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
@@ -286,6 +289,32 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		applyReadOnlyProviderEnv();
 		pi.setActiveTools(getPlanModeTools(toolsBeforePlanMode));
 	};
+	/**
+	 * Plan-only tools are kept out of normal mode by removing them from the
+	 * active set, not with pi 0.99's `prepareLoadout` / `hiddenDeclarations`:
+	 * - Hidden tools stay active. `getActiveTools()` would always list
+	 *   write_plan, exit_plan_mode, and mf_plan_subagent, so the contamination
+	 *   checks in `enablePlanModeTools` and `validateToolLoadoutSnapshot` would
+	 *   treat every loadout as poisoned and swap the user's real one for
+	 *   `fullLoadoutFallback()` on every entry and resume, contradicting
+	 *   plan-tool-leak and plan-resume-tool-restore.
+	 * - Hidden tools stay callable. pi rejects calls to inactive tools; a hidden
+	 *   one would run with only its `isEnabled` guard in the way. It cannot
+	 *   replace the plan-mode read-only narrowing either: hidden bash/edit/write
+	 *   would still run.
+	 * - The hook runs only while its host tool is active. Outside plan mode that
+	 *   is enter_plan_mode alone; drop it via --tools or the tool picker and all
+	 *   three declarations leak.
+	 * - After resume or /tree, 0.99.2 strips the hidden declarations only while
+	 *   the host tool is active. The model still sees the plan-only tools when
+	 *   the host is inactive, on pre-0.99 hosts (peerDependencies are "*" and
+	 *   they ignore the hook), and through earlier tool calls in history, which
+	 *   the projection does not filter.
+	 * - A capability gate would only add surface: older hosts still need this
+	 *   path, so both mechanisms would ship.
+	 * - The saving is two tool-change deltas per planning round, and this is
+	 *   already a no-op when the set is clean.
+	 */
 	const deactivatePlanOnlyTools = (): void => {
 		const active = pi.getActiveTools();
 		const filtered = active.filter((name) => !PLAN_ONLY_REGISTERED_TOOLS.includes(name));
@@ -696,6 +725,9 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		onBeforeAgentStart: async () => {
 			if (needsExitReminder) {
 				needsExitReminder = false;
+				// The reminder turn is also the first normal-mode turn: repair a
+				// leaked plan-only loadout here too, not from the next turn on.
+				if (!planModeEnabled) deactivatePlanOnlyTools();
 				persistState();
 				return { message: { customType: PLAN_EXIT_CONTEXT_TYPE, content: buildPlanModeExitInstructions(), display: false } };
 			}

package/src/planning/tools/enterPlanMode.ts

@@ -12,9 +12,10 @@ import { modelRefLabel, TRIGGER_TURN, type ModelRef, type ThinkingLevel } from "
 import { showMoaModelPicker, showImplementingModelPicker } from "../../ui/moaModelPicker.ts";
 import { showMoaSetup } from "../../ui/moaSetupOverlay.ts";
 import { showPromptEditor } from "../../ui/promptEditor.ts";
-import { getPlan } from "../planFile.ts";
+import { getPlan, getPlanFilePath } from "../planFile.ts";
 import { isAskUserQuestionInstalled } from "../askUserQuestion.ts";
 import { buildPlanModeInstructions, buildPlanModeReentryInstructions } from "../instructions.ts";
+import { ENTER_PLAN_MODE_OUTPUT_SCHEMA } from "./structuredResults.ts";
 
 export interface InteractivePlanModeHost {
 	beginInteractive(ctx: ExtensionContext): void;
@@ -136,6 +137,11 @@ export function registerEnterPlanModeTool(pi: ExtensionAPI, host: EnterPlanModeH
 				Type.String({ description: "Short description of what is being planned (used to name the plan file)" }),
 			),
 		}),
+		outputSchema: ENTER_PLAN_MODE_OUTPUT_SCHEMA,
+		// Swaps the active tools and provider env, persists state, and with a
+		// plan_prompt writes the prompt record under .pi/mf-plan/. Not read-only;
+		// destructive is left at the default because that write can overwrite.
+		annotations: { readOnlyHint: false },
 		// enter_plan_mode is paired with a same-message ask_user_question only in
 		// the single-model path; marking it sequential means the questionnaire
 		// resolves first, so mf-plan's own overlays never draw over it.
@@ -159,6 +165,7 @@ export function registerEnterPlanModeTool(pi: ExtensionAPI, host: EnterPlanModeH
 					type: "text",
 					text: `Plan mode enabled (single model — the current session model). Mutating tools are disabled until your plan is approved via exit_plan_mode.\n\n${instructions}`,
 				}],
+				structuredContent: { status: "entered", mode: "single", reentry, planFilePath: getPlanFilePath() },
 			};
 		},
 	});

package/src/planning/tools/exitPlanMode.ts

@@ -10,6 +10,7 @@ import { showPlanReview } from "../../ui/planReviewOverlay.ts";
 import { planNamingOverlay, withWorkingOverlay } from "../../ui/workingOverlay.ts";
 import { ASK_USER_QUESTION_PENDING_MESSAGE } from "../askUserQuestion.ts";
 import { getPlan, getPlanFilePath, saveRepoPlanFile, slugifyPlanName, writePlan } from "../planFile.ts";
+import { EXIT_PLAN_MODE_OUTPUT_SCHEMA, type ExitPlanModeStructuredResult } from "./structuredResults.ts";
 
 import type { ImplementationHandoff } from "../../moa/implementationRetry.ts";
 
@@ -35,6 +36,10 @@ export function registerExitPlanModeTool(pi: ExtensionAPI, host: ExitPlanModeHos
 		label: "Exit Plan Mode",
 		description: "Use when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval. Reads the plan from the plan file — does NOT take plan content as a parameter. Only use for tasks that require writing code; not for pure research.",
 		parameters: Type.Object({}),
+		outputSchema: EXIT_PLAN_MODE_OUTPUT_SCHEMA,
+		// Restores tools and env and queues implementation; the edit branch and the
+		// non-TUI approve overwrite plan files, and every call reopens approval.
+		annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false },
 		// exit_plan_mode opens a model/UI surface the model may not have asked
 		// the user about yet; marking it sequential means a same-message
 		// ask_user_question resolves first, so approval never lands on unread
@@ -52,6 +57,14 @@ export function registerExitPlanModeTool(pi: ExtensionAPI, host: ExitPlanModeHos
 
 			const plan = getPlan();
 			const filePath = getPlanFilePath();
+			// Read at return time: the slug may be named during this call.
+			const structuredResult = (
+				status: ExitPlanModeStructuredResult["status"],
+				kickoff: ExitPlanModeStructuredResult["kickoff"],
+			): ExitPlanModeStructuredResult => {
+				const repoPlanSlug = host.getPlanRepoSlug();
+				return { status, planFilePath: filePath, headless: !ctx.hasUI, kickoff, ...(repoPlanSlug ? { repoPlanSlug } : {}) };
+			};
 
 			if (!plan || plan.trim() === "") {
 				return {
@@ -95,6 +108,7 @@ export function registerExitPlanModeTool(pi: ExtensionAPI, host: ExitPlanModeHos
 							text: buildImplementationKickoffMessage(plan, filePath),
 						},
 					],
+					structuredContent: structuredResult("approved", "inline"),
 				};
 			}
 
@@ -154,10 +168,15 @@ export function registerExitPlanModeTool(pi: ExtensionAPI, host: ExitPlanModeHos
 					return {
 						details: undefined,
 						content: [{ type: "text", text: "Plan approved and saved. Plan mode has exited. Stop here — do not write files, run commands, or call any tools in this turn. A follow-up message will tell you to begin implementation." }],
+						structuredContent: structuredResult("approved", "follow_up"),
 					};
 				}
 
-				return { content: [{ type: "text", text: "User wants to keep refining the plan. Continue working on the plan file and call exit_plan_mode when ready." }], details: undefined };
+				return {
+					content: [{ type: "text", text: "User wants to keep refining the plan. Continue working on the plan file and call exit_plan_mode when ready." }],
+					details: undefined,
+					structuredContent: structuredResult("keep_planning", "none"),
+				};
 			}
 		},
 	});

package/src/planning/tools/mfPlanSubagent.ts

@@ -17,6 +17,7 @@ import { parseRef as parseModelRefLabel, type ThinkingLevel } from "../../shared
 import { activityLoopCount } from "../../ui/agentStatus.ts";
 import { showCancelOverlay } from "../../ui/cancelOverlay.ts";
 import { PLAN_SUBAGENT_NAMES } from "./shared.ts";
+import { buildSubagentStructuredResult, MF_PLAN_SUBAGENT_OUTPUT_SCHEMA } from "./structuredResults.ts";
 
 const CANCEL_HINT_WIDGET_KEY = "mf-plan-cancel";
 
@@ -38,7 +39,18 @@ export interface MfPlanSubagentHost {
 	setActiveCancelSession(session: CancelSession | undefined): void;
 }
 
-export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagentHost): void {
+/**
+ * Test-only runner seam. The defaults are the real subprocess runners, which
+ * apply the read-only --tools allowlist and the provider env handshake.
+ */
+export type MfPlanSubagentDeps = {
+	runSingleAgent?: typeof runSingleAgent;
+	runParallelAgents?: typeof runParallelAgents;
+};
+
+export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagentHost, deps: MfPlanSubagentDeps = {}): void {
+	const runSingle = deps.runSingleAgent ?? runSingleAgent;
+	const runParallel = deps.runParallelAgents ?? runParallelAgents;
 	pi.registerTool({
 		name: "mf_plan_subagent",
 		label: "Moa Plan Subagent",
@@ -49,8 +61,14 @@ 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,
+		// Installs agent files, writes temp prompts, and spawns paid subprocesses
+		// whose read-only boundary is cooperative (hence the tripwire), so no
+		// read-only claim; every call starts new, nondeterministic runs.
+		annotations: { readOnlyHint: false, idempotentHint: false },
 		// mf_plan_subagent can share a message with ask_user_question; marking it
 		// sequential means the questionnaire resolves first so its overlay never
 		// draws over a live questionnaire.
@@ -184,7 +202,7 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 						...agentExtensionOptions(t.agent),
 						signal: run.add(`${t.agent} #${i + 1}`, signal).signal,
 					}));
-					const results = await runParallelAgents(
+					const results = await runParallel(
 						ctx.cwd,
 						agents,
 						taskList,
@@ -208,7 +226,9 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 					);
 
 					// resolveOnAbort makes the runner resolve on abort; rethrow so a
-					// whole-turn abort (pi's ESC) keeps its original semantics.
+					// whole-turn abort (pi's ESC) keeps its original semantics, which also
+					// means it carries no structured result. A child abort the user did not
+					// ask for is reported per agent as "aborted".
 					if (signal?.aborted) throw new Error("Subagent was aborted");
 
 					const successCount = results.filter((r) => !isFailedResult(r)).length;
@@ -223,6 +243,8 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 					});
 
 					const header = `Parallel: ${successCount}/${results.length} succeeded${cancelledCount > 0 ? `, ${cancelledCount} cancelled by user` : ""}`;
+					// Subagent usage stays out of the tool result's `usage` so session
+					// token accounting is unchanged; it is reported per agent instead.
 					return {
 						details: undefined,
 						content: [
@@ -231,6 +253,7 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 								text: `${header}\n\n${summaries.join("\n\n---\n\n")}`,
 							},
 						],
+						structuredContent: buildSubagentStructuredResult("parallel", results),
 					};
 				} finally {
 					unsubscribeF4?.();
@@ -261,7 +284,7 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 					: undefined;
 				setCancelHint(ctx, "f4: cancel mf-plan agent");
 				try {
-					const result = await runSingleAgent(
+					const result = await runSingle(
 						ctx.cwd,
 						agents,
 						params.agent!,
@@ -277,22 +300,26 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 
 					if (signal?.aborted) throw new Error("Subagent was aborted");
 
+					const structuredContent = buildSubagentStructuredResult("single", [result]);
 					if (result.cancelled) {
 						return {
 							details: undefined,
 							content: [{ type: "text", text: "The user cancelled this subagent. Do not retry; continue planning with the information you already have." }],
+							structuredContent,
 						};
 					}
 					if (isFailedResult(result)) {
 						return {
 							details: undefined,
 							content: [{ type: "text", text: `Agent failed: ${getResultOutput(result)}` }],
+							structuredContent,
 							isError: true,
 						};
 					}
 					return {
 						details: undefined,
 						content: [{ type: "text", text: getFinalOutput(result.messages) || "(no output)" }],
+						structuredContent,
 					};
 				} finally {
 					unsubscribeF4?.();

package/src/planning/tools/structuredResults.ts

@@ -0,0 +1,161 @@
+/**
+ * Output schemas and structured results for the plan-mode tools (pi 0.99
+ * `outputSchema` / `structuredContent`).
+ *
+ * These values are not model-facing and are not saved in the session: pi sends
+ * only `content` to the model and leaves `structuredContent` out of the
+ * persisted tool-result message. They reach live programmatic consumers only —
+ * `tool_execution_end` events (RPC/JSON harnesses), `tool_result` handlers, and
+ * codemode scripts. Each tool's text `content` is unchanged and comes from the
+ * same `isFailedResult` / `getResultOutput` / `truncateOutput` calls as the
+ * values here, so the two cannot disagree.
+ *
+ * `classifySubagentResult` is the one status derivation over `SingleResult`;
+ * any other consumer of runner results can import it.
+ */
+
+import { Type, type Static } from "typebox";
+
+import { getResultOutput, isFailedResult, truncateOutput, type SingleResult } from "../../runtime/results.ts";
+
+const SubagentUsageSchema = Type.Object({
+	input: Type.Number({ description: "Input tokens" }),
+	output: Type.Number({ description: "Output tokens" }),
+	cacheRead: Type.Number({ description: "Cache-read tokens" }),
+	cacheWrite: Type.Number({ description: "Cache-write tokens" }),
+	cacheWrite1h: Type.Number({ description: "One-hour cache-write tokens" }),
+	cost: Type.Number({ description: "Total cost reported by the provider" }),
+	turns: Type.Number({ description: "Assistant turns" }),
+	toolCalls: Type.Number({ description: "Tool calls the agent made" }),
+	contextTokens: Type.Optional(Type.Number({ description: "Context size of the latest turn, when reported" })),
+}, { additionalProperties: false, description: "Token usage and cost the runner recorded for the agent" });
+
+const SubagentAgentResultSchema = Type.Object({
+	agent: Type.String({ description: "Agent name" }),
+	status: Type.Union([
+		Type.Literal("completed"),
+		Type.Literal("failed"),
+		Type.Literal("cancelled"),
+		Type.Literal("aborted"),
+	], { description: "cancelled: stopped by the user; aborted: the child stopped without a user cancel; failed: nonzero exit, provider error, or no messages" }),
+	exitCode: Type.Number({ description: "Child process exit code" }),
+	stopReason: Type.Optional(Type.String({ description: "Stop reason of the agent's last assistant message" })),
+	model: Type.Optional(Type.String({ description: "Model the agent ran on" })),
+	output: Type.String({ description: "Final answer, or the error for an agent that did not complete, capped at 50 KB" }),
+	truncated: Type.Boolean({ description: "Whether `output` was cut at the 50 KB cap" }),
+	usage: SubagentUsageSchema,
+}, { additionalProperties: false });
+
+export const MF_PLAN_SUBAGENT_OUTPUT_SCHEMA = Type.Object({
+	mode: Type.Union([Type.Literal("single"), Type.Literal("parallel")], { description: "single: one agent from agent + task; parallel: the tasks array" }),
+	status: Type.Union([
+		Type.Literal("completed"),
+		Type.Literal("partial"),
+		Type.Literal("failed"),
+		Type.Literal("cancelled"),
+		Type.Literal("aborted"),
+	], { description: "completed: every agent completed; partial: some did; otherwise failed, aborted, or cancelled, in that order of precedence" }),
+	total: Type.Number({ description: "Agents requested" }),
+	succeeded: Type.Number({ description: "Agents that completed" }),
+	failed: Type.Number({ description: "Agents that failed" }),
+	cancelled: Type.Number({ description: "Agents the user cancelled" }),
+	aborted: Type.Number({ description: "Agents that stopped without a user cancel" }),
+	results: Type.Array(SubagentAgentResultSchema, { description: "One entry per requested agent, in request order" }),
+}, { additionalProperties: false });
+
+export const WRITE_PLAN_OUTPUT_SCHEMA = Type.Object({
+	status: Type.Literal("written", { description: "The plan file was written" }),
+	filePath: Type.String({ description: "Plan file whose content was replaced" }),
+	length: Type.Number({ description: "Length of the written plan in characters" }),
+}, { additionalProperties: false });
+
+export const ENTER_PLAN_MODE_OUTPUT_SCHEMA = Type.Object({
+	status: Type.Literal("entered", { description: "Plan mode is now on" }),
+	mode: Type.Literal("single", { description: "The tool always starts single-model planning; MoA planning starts from /mf-plan" }),
+	reentry: Type.Boolean({ description: "Whether a plan file already existed, so planning continues it" }),
+	planFilePath: Type.String({ description: "Plan file write_plan writes to" }),
+}, { additionalProperties: false });
+
+export const EXIT_PLAN_MODE_OUTPUT_SCHEMA = Type.Object({
+	status: Type.Union([Type.Literal("approved"), Type.Literal("keep_planning")], { description: "approved: plan mode has exited; keep_planning: the user sent the plan back and plan mode is still on" }),
+	planFilePath: Type.String({ description: "Plan file that was reviewed" }),
+	headless: Type.Boolean({ description: "Whether the plan was auto-approved without a UI (MOA_PLAN_AUTO_APPROVE=1)" }),
+	kickoff: Type.Union([
+		Type.Literal("inline"),
+		Type.Literal("follow_up"),
+		Type.Literal("none"),
+	], { description: "inline: this result is the implementation kickoff; follow_up: the kickoff is queued as the next user message; none: no implementation was started" }),
+	repoPlanSlug: Type.Optional(Type.String({ description: "Name of the plan's copies under .pi/mf-plan/" })),
+}, { additionalProperties: false });
+
+export type MfPlanSubagentStructuredResult = Static<typeof MF_PLAN_SUBAGENT_OUTPUT_SCHEMA>;
+export type SubagentAgentResult = Static<typeof SubagentAgentResultSchema>;
+export type SubagentAgentStatus = SubagentAgentResult["status"];
+export type WritePlanStructuredResult = Static<typeof WRITE_PLAN_OUTPUT_SCHEMA>;
+export type EnterPlanModeStructuredResult = Static<typeof ENTER_PLAN_MODE_OUTPUT_SCHEMA>;
+export type ExitPlanModeStructuredResult = Static<typeof EXIT_PLAN_MODE_OUTPUT_SCHEMA>;
+
+/**
+ * A user cancel wins over the stop reason it produces; an `aborted` stop
+ * without one is a child abort nobody asked for. The runner marks every
+ * cancelled result failed, so `completed` is exactly `!isFailedResult`.
+ */
+export function classifySubagentResult(result: SingleResult): SubagentAgentStatus {
+	if (result.cancelled) return "cancelled";
+	if (result.stopReason === "aborted") return "aborted";
+	return isFailedResult(result) ? "failed" : "completed";
+}
+
+function aggregateStatus(statuses: readonly SubagentAgentStatus[]): MfPlanSubagentStructuredResult["status"] {
+	const completed = statuses.filter((status) => status === "completed").length;
+	if (completed === statuses.length) return "completed";
+	if (completed > 0) return "partial";
+	if (statuses.includes("failed")) return "failed";
+	if (statuses.includes("aborted")) return "aborted";
+	return "cancelled";
+}
+
+function toAgentResult(result: SingleResult): SubagentAgentResult {
+	const fullOutput = getResultOutput(result);
+	const output = truncateOutput(fullOutput);
+	const { usage } = result;
+	return {
+		agent: result.agent,
+		status: classifySubagentResult(result),
+		exitCode: result.exitCode,
+		...(result.stopReason ? { stopReason: result.stopReason } : {}),
+		...(result.model ? { model: result.model } : {}),
+		output,
+		truncated: output !== fullOutput,
+		usage: {
+			input: usage.input,
+			output: usage.output,
+			cacheRead: usage.cacheRead,
+			cacheWrite: usage.cacheWrite,
+			cacheWrite1h: usage.cacheWrite1h,
+			cost: usage.cost,
+			turns: usage.turns,
+			toolCalls: usage.toolCalls,
+			...(usage.contextTokens !== undefined ? { contextTokens: usage.contextTokens } : {}),
+		},
+	};
+}
+
+/** Results stay in request order; a single-mode run's status is its agent's status. */
+export function buildSubagentStructuredResult(
+	mode: MfPlanSubagentStructuredResult["mode"],
+	results: readonly SingleResult[],
+): MfPlanSubagentStructuredResult {
+	const entries = results.map(toAgentResult);
+	const count = (status: SubagentAgentStatus): number => entries.filter((entry) => entry.status === status).length;
+	return {
+		mode,
+		status: aggregateStatus(entries.map((entry) => entry.status)),
+		total: entries.length,
+		succeeded: count("completed"),
+		failed: count("failed"),
+		cancelled: count("cancelled"),
+		aborted: count("aborted"),
+		results: entries,
+	};
+}

package/src/planning/tools/writePlan.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
 import { getPlanFilePath, writePlan } from "../planFile.ts";
+import { WRITE_PLAN_OUTPUT_SCHEMA } from "./structuredResults.ts";
 
 export function registerWritePlanTool(pi: ExtensionAPI, isEnabled: () => boolean): void {
 	pi.registerTool({
@@ -11,6 +12,9 @@ export function registerWritePlanTool(pi: ExtensionAPI, isEnabled: () => boolean
 		parameters: Type.Object({
 			content: Type.String({ description: "The full content to write to the plan file (replaces existing content)" }),
 		}),
+		outputSchema: WRITE_PLAN_OUTPUT_SCHEMA,
+		// Replaces the whole plan file; the same content yields a byte-identical file.
+		annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
 
 		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
 			if (!isEnabled()) {
@@ -27,6 +31,7 @@ export function registerWritePlanTool(pi: ExtensionAPI, isEnabled: () => boolean
 			return {
 				content: [{ type: "text", text: `Plan written to ${filePath} (${params.content.length} chars)` }],
 				details: { filePath, length: params.content.length },
+				structuredContent: { status: "written", filePath, length: params.content.length },
 			};
 		},
 	});

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)));