@underactive/pi-topping-moa-fusion 0.1.0 → 0.2.0

package/src/opinion/opinionFanout.ts

@@ -27,6 +27,7 @@ export interface OpinionFanoutOptions {
 	session: CancelSession;
 	widget: MoaProgressWidget;
 	agents: AgentConfig[];
+	maxConcurrency: number;
 }
 
 export type OpinionFanoutResult =
@@ -34,9 +35,9 @@ export type OpinionFanoutResult =
 	| { status: "cancelled" };
 
 export async function runOpinionFanout(options: OpinionFanoutOptions): Promise<OpinionFanoutResult> {
-	const { host, ctx, question, models, thinking, session, widget, agents } = options;
+	const { host, ctx, question, models, thinking, session, widget, agents, maxConcurrency } = options;
 	const originalTask = buildOpinionTask(question);
-	widget.startFanout(models, thinking);
+	widget.startFanout(models, thinking, maxConcurrency);
 	const observe: ObserveSession = {
 		title: "MoA opinions",
 		phase: "fanout",
@@ -57,7 +58,7 @@ export async function runOpinionFanout(options: OpinionFanoutOptions): Promise<O
 			tasks: ModelParallelAgentTask[],
 			indexMap: (index: number) => number,
 			currentRun: CancelRun,
-		): Promise<SingleResult[]> => runWidgetFanout({ ctx, agents, tasks, run: currentRun, session, widget, observe, models, indexMap });
+		): Promise<SingleResult[]> => runWidgetFanout({ ctx, agents, tasks, run: currentRun, session, widget, observe, models, indexMap, maxConcurrency });
 
 		const run = new CancelRun();
 		session.title = "Opinion agents";
@@ -107,7 +108,7 @@ export async function runOpinionFanout(options: OpinionFanoutOptions): Promise<O
 				const ref = models[opinionIndex];
 				const label = modelRefLabel(ref);
 				const retryTask = buildOpinionRetryTask(originalTask, getFinalOutput(results[opinionIndex].messages));
-				widget.update(opinionIndex, "working", "retrying: no opinion produced");
+				widget.update(opinionIndex, "queued", "retrying: no opinion produced");
 				const observed = observe.agents[opinionIndex];
 				if (observed) {
 					observed.state = "working";

package/src/opinion/runOpinion.ts

@@ -1,18 +1,19 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { isKeyRelease, Key, matchesKey } from "@earendil-works/pi-tui";
 
 import { installShippedAgents, shippedAgentsDir, withAuthoritativeMoaAgents } from "../agents/authoritative.ts";
 import { discoverAgents } from "../agents/discovery.ts";
 import { summarizePlanPromptName } from "../config/planName.ts";
+import { slugifyPlanName } from "../planning/planFile.ts";
 import { loadMoaConfig, saveMoaConfig } from "../config/settings.ts";
 import { resolveContextWindow } from "../moa/modelRuntime.ts";
-import type { CancelSession } from "../runtime/cancelRun.ts";
+import { type CancelSession, subscribeCancelOverlayOnEsc } from "../runtime/cancelRun.ts";
 import { formatMutationWarning, MutationTripwire } from "../runtime/mutationTripwire.ts";
 import { type SendUserMessageOptions, type ThinkingLevel } from "../shared/modelRefs.ts";
 import { MoaProgressWidget } from "../ui/moaProgressWidget.ts";
 import type { ObserveSession } from "../ui/observeOverlay.ts";
 import { showOpinionModelPicker } from "../ui/opinionModelPicker.ts";
 import { showPromptEditor } from "../ui/promptEditor.ts";
+import { planNamingOverlay, withWorkingOverlay } from "../ui/workingOverlay.ts";
 import { runOpinionFanout } from "./opinionFanout.ts";
 import { repoOpinionDisplayPath, saveRepoOpinionFile } from "./opinionFile.ts";
 import { collectOpinionOutcomes, formatOpinionsMarkdown } from "./opinionResults.ts";
@@ -45,15 +46,7 @@ export async function runInteractiveOpinion(
 	installShippedAgents();
 	const session: CancelSession = { title: "Opinion agents", run: undefined, overlayOpen: false };
 	host.setActiveCancelSession(session);
-	const unsubscribeEsc = ctx.mode === "tui"
-		? ctx.ui.onTerminalInput((data) => {
-			if (isKeyRelease(data) || !matchesKey(data, Key.escape)) return undefined;
-			if (host.getActiveObserveSession()?.overlayOpen) return undefined;
-			if (session.overlayOpen) return undefined;
-			if (!session.run) return undefined;
-			return host.openCancelOverlayIfActive(ctx) ? { consume: true } : undefined;
-		})
-		: undefined;
+	const unsubscribeEsc = subscribeCancelOverlayOnEsc(ctx, host, session);
 
 	try {
 		let prefill = initialPrompt?.trim() ?? "";
@@ -83,7 +76,11 @@ export async function runInteractiveOpinion(
 				thinkingOverrides: { ...settings.thinkingOverrides, ...thinkingSelections },
 			});
 
-			const slug = await summarizePlanPromptName(ctx, question);
+			const slug = await withWorkingOverlay(
+				ctx,
+				planNamingOverlay("opinion", () => slugifyPlanName(question)),
+				(signal) => summarizePlanPromptName(ctx, question, { signal }),
+			);
 			try {
 				saveRepoOpinionFile(question, ctx.cwd, slug, "opinion-prompt");
 			} catch {
@@ -114,7 +111,7 @@ export async function runInteractiveOpinion(
 			host.setRunningProgressWidget(widget);
 			let outcome;
 			try {
-				outcome = await runOpinionFanout({ host, ctx, question, models, thinking, session, widget, agents });
+				outcome = await runOpinionFanout({ host, ctx, question, models, thinking, session, widget, agents, maxConcurrency: settings.maxConcurrentAgents });
 			} finally {
 				host.setRunningProgressWidget(undefined);
 				widget.stopWidget();
@@ -139,6 +136,10 @@ export async function runInteractiveOpinion(
 			} catch {
 				saved = false;
 			}
+			// `sendUserMessage` routes to prompt() and ignores triggerTurn (only
+			// sendCustomMessage honors it), so this report does start a model turn.
+			// Genuinely append-only delivery needs pi.sendMessage({ customType, … },
+			// { triggerTurn: false }) plus a message renderer — a UX change, not made here.
 			const appendOnly: SendUserMessageOptions = { triggerTurn: false };
 			await pi.sendUserMessage(markdown, appendOnly);
 			const completed = outcomes.filter((item) => item.status === "done").length;

package/src/planning/modeState.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import type { MfPlanInfo } from "../moa/planInfo.ts";
 import type { ImplementationHandoff } from "../moa/implementationRetry.ts";
+import { PLAN_ONLY_REGISTERED_TOOLS } from "./tools/shared.ts";
 
 export interface PlanModeState {
 	enabled: boolean;
@@ -10,10 +11,26 @@ export interface PlanModeState {
 	needsExitReminder?: boolean;
 	moaInfo?: MfPlanInfo;
 	implementationHandoff?: ImplementationHandoff;
+	/** Active loadout captured when plan mode was entered, so exit restores it. */
+	toolsBeforePlanMode?: string[];
 }
 
 export const MAX_PERSISTED_STATE_BYTES = 512 * 1024;
 
+/**
+ * A snapshot containing plan-only tools was taken while plan mode was already
+ * live (pre-fix sessions, or a transcript-restored loadout). Restoring it would
+ * re-apply the read-only set after approval, so reject it and let the caller
+ * fall back to the registered loadout.
+ */
+export function validateToolLoadoutSnapshot(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const names = value.filter((name): name is string => typeof name === "string" && name.length > 0);
+	if (names.length === 0) return undefined;
+	if (names.some((name) => PLAN_ONLY_REGISTERED_TOOLS.includes(name))) return undefined;
+	return [...new Set(names)];
+}
+
 export function serializePlanModeState(state: PlanModeState): { state: PlanModeState; serialized: string } {
 	let persisted = state.moaInfo?.proposerPlans
 		? { ...state, moaInfo: { ...state.moaInfo, proposerPlans: undefined } }

package/src/planning/planFile.ts

@@ -136,7 +136,7 @@ export function fallbackPlanName(): string {
 	return generateWordSlug();
 }
 
-export type RepoPlanFileKind = "plan-prompt" | "plan" | "verification" | "criteria";
+export type RepoPlanFileKind = "plan-prompt" | "plan" | "verification" | "criteria" | "verification-handoff";
 
 function repoPlanSuffix(kind: RepoPlanFileKind): string {
 	// `__verification` and `__criteria` never collide with the `/mf-plan-implement`
@@ -144,6 +144,7 @@ function repoPlanSuffix(kind: RepoPlanFileKind): string {
 	if (kind === "plan-prompt") return "__plan-prompt";
 	if (kind === "verification") return "__verification";
 	if (kind === "criteria") return "__criteria";
+	if (kind === "verification-handoff") return "__verification-handoff";
 	return "__plan";
 }
 

package/src/planning/planMode.ts

@@ -37,10 +37,11 @@ import { showCancelOverlay } from "../ui/cancelOverlay.ts";
 import { UI_TICK_MS } from "../ui/chrome.ts";
 import { MoaProgressWidget } from "../ui/moaProgressWidget.ts";
 import { showObserveOverlay, type ObserveSession } from "../ui/observeOverlay.ts";
+import { planNamingOverlay, withWorkingOverlay } from "../ui/workingOverlay.ts";
 import { ASK_USER_QUESTION_TOOL_NAME, createAskUserQuestionTracker, isAskUserQuestionInstalled } from "./askUserQuestion.ts";
 import { buildPlanModeExitInstructions, buildPlanModeInstructions, buildPlanModeReentryInstructions } from "./instructions.ts";
-import { latestPlanModeStateEntry, PlanModeStatePersistence } from "./modeState.ts";
-import { getPlan, getPlanSlug, isValidPlanSlug, resetPlanSlug, saveRepoPlanFile, setPlanSlug } from "./planFile.ts";
+import { latestPlanModeStateEntry, PlanModeStatePersistence, validateToolLoadoutSnapshot } from "./modeState.ts";
+import { getPlan, getPlanSlug, isValidPlanSlug, resetPlanSlug, saveRepoPlanFile, setPlanSlug, slugifyPlanName } from "./planFile.ts";
 import { PLAN_EXIT_CONTEXT_TYPE, PLAN_MODE_CONTEXT_TYPE, PLAN_MODE_CUSTOM_TOOLS, PLAN_MODE_READ_ONLY_TOOLS, PLAN_ONLY_REGISTERED_TOOLS } from "./tools/shared.ts";
 
 /** Trailing chars of the implementer report kept for the verifier's evidence. */
@@ -168,6 +169,7 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		needsExitReminder,
 		moaInfo: activeRunMoaInfo,
 		implementationHandoff,
+		toolsBeforePlanMode,
 	});
 	const footerState = (ctx: ExtensionContext): MoaFooterState => {
 		if (footerError) return "error";
@@ -218,6 +220,21 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		const customTools = PLAN_MODE_CUSTOM_TOOLS.filter((name) => name !== ASK_USER_QUESTION_TOOL_NAME || isAskUserQuestionInstalled(pi));
 		return [...new Set([...filtered, ...customTools])];
 	};
+	/**
+	 * Every registered tool except the plan-only ones — the safe fallback when no
+	 * trustworthy snapshot exists. Note this can restore a tool the user had
+	 * deliberately deactivated; that is strictly better than leaving the
+	 * implementer read-only, and only affects sessions saved before this field
+	 * existed. Deduped because registration re-adds already-present tools.
+	 */
+	const fullLoadoutFallback = (): string[] => {
+		const registered = [...new Set(
+			pi.getAllTools().map((tool) => tool.name).filter((name) => !PLAN_ONLY_REGISTERED_TOOLS.includes(name)),
+		)];
+		// An empty registered list would strip every tool; prefer the active set.
+		if (registered.length > 0) return registered;
+		return [...new Set(pi.getActiveTools().filter((name) => !PLAN_ONLY_REGISTERED_TOOLS.includes(name)))];
+	};
 	const applyReadOnlyProviderEnv = (): void => {
 		if (providerEnvBeforePlanMode === undefined) {
 			providerEnvBeforePlanMode = {};
@@ -234,7 +251,15 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		providerEnvBeforePlanMode = undefined;
 	};
 	const enablePlanModeTools = (): void => {
-		if (toolsBeforePlanMode === undefined) toolsBeforePlanMode = pi.getActiveTools();
+		if (toolsBeforePlanMode === undefined) {
+			// 0.86.0 restores tools from the transcript before session_start, and a
+			// leaked plan-only set is possible mid-session, so an "active" set that
+			// contains plan-only tools is the plan loadout, not the user's.
+			const active = pi.getActiveTools();
+			toolsBeforePlanMode = active.some((name) => PLAN_ONLY_REGISTERED_TOOLS.includes(name))
+				? fullLoadoutFallback()
+				: active;
+		}
 		applyReadOnlyProviderEnv();
 		pi.setActiveTools(getPlanModeTools(toolsBeforePlanMode));
 	};
@@ -356,7 +381,11 @@ export function createPlanModeController(pi: ExtensionAPI) {
 		return lastReentryState;
 	};
 	async function saveSubmittedPlanPrompt(ctx: ExtensionContext, prompt: string): Promise<void> {
-		planRepoSlug = await summarizePlanPromptName(ctx, prompt);
+		planRepoSlug = await withWorkingOverlay(
+			ctx,
+			planNamingOverlay("plan", () => slugifyPlanName(prompt)),
+			(signal) => summarizePlanPromptName(ctx, prompt, { signal }),
+		);
 		persistState();
 		saveRepoPlanFile(prompt, ctx.cwd, planRepoSlug, "plan-prompt");
 	}
@@ -397,7 +426,7 @@ export function createPlanModeController(pi: ExtensionAPI) {
 					Implement: implementationHandoff.model,
 					Verify: implementationHandoff.verifier,
 				});
-				widget.switchToImplementing(implementationHandoff.model, "implementing plan…", implementationHandoff.thinking);
+				widget.switchToImplementing(implementationHandoff.model, "implementing plan", implementationHandoff.thinking);
 				activeProgressWidget = widget;
 			}
 			if (ctx) updateStatus(ctx);
@@ -625,6 +654,7 @@ export function createPlanModeController(pi: ExtensionAPI) {
 			resetPlanSlug();
 			if (pi.getFlag("mf-plan") === true) planModeEnabled = true;
 			const restored = latestPlanModeStateEntry(ctx.sessionManager.getEntries());
+			const restoredPlanModeWasEnabled = restored?.enabled === true;
 			if (restored) {
 				planModeEnabled = restored.enabled ?? planModeEnabled;
 				needsExitReminder = restored.needsExitReminder ?? false;
@@ -632,10 +662,21 @@ export function createPlanModeController(pi: ExtensionAPI) {
 				planRepoSlug = isValidPlanSlug(restored.repoPlanSlug) ? restored.repoPlanSlug : undefined;
 				activeRunMoaInfo = validateMfPlanInfo(restored.moaInfo);
 				implementationHandoff = validateImplementationHandoff(restored.implementationHandoff);
+				toolsBeforePlanMode = validateToolLoadoutSnapshot(restored.toolsBeforePlanMode);
 			}
 			if (planModeEnabled) {
 				lastReentryState = getPlan() !== null;
+				// A persisted plan-mode session had its loadout restored from the transcript
+				// before this handler ran (#9548), so the active set is the plan loadout, not
+				// the user's. Only the persisted snapshot or the registered loadout can be
+				// trusted here. The flag-only path (no entry) is excluded: there plan mode
+				// never ran, so the active set really is the user's.
+				const repairedLoadoutSnapshot = restoredPlanModeWasEnabled && toolsBeforePlanMode === undefined;
+				if (repairedLoadoutSnapshot) toolsBeforePlanMode = fullLoadoutFallback();
 				enablePlanModeTools();
+				// Re-persist the restored (and, if needed, repaired) snapshot so later
+				// resumes of this session see the same trustworthy loadout.
+				if (restoredPlanModeWasEnabled) persistState();
 			} else {
 				deactivatePlanOnlyTools();
 			}

package/src/planning/tools/exitPlanMode.ts

@@ -7,8 +7,9 @@ import { stripSynthSections } from "../../moa/verdicts.ts";
 import { FOLLOW_UP } from "../../shared/modelRefs.ts";
 import type { MfPlanInfo, PlanReviewDecision } from "../../moa/planInfo.ts";
 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, writePlan } from "../planFile.ts";
+import { getPlan, getPlanFilePath, saveRepoPlanFile, slugifyPlanName, writePlan } from "../planFile.ts";
 
 import type { ImplementationHandoff } from "../../moa/implementationRetry.ts";
 
@@ -98,7 +99,11 @@ export function registerExitPlanModeTool(pi: ExtensionAPI, host: ExitPlanModeHos
 			}
 
 			if (!host.getPlanRepoSlug()) {
-				host.setPlanRepoSlug(await summarizePlanPromptName(ctx, plan));
+				host.setPlanRepoSlug(await withWorkingOverlay(
+					ctx,
+					planNamingOverlay("plan", () => slugifyPlanName(plan)),
+					(signal) => summarizePlanPromptName(ctx, plan, { signal }),
+				));
 				host.persistState();
 			}
 

package/src/planning/tools/mfPlanSubagent.ts

@@ -6,6 +6,7 @@ import { Type } from "typebox";
 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 { CancelRun, type CancelRowExtras, type CancelSession } from "../../runtime/cancelRun.ts";
@@ -150,6 +151,7 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 				// Parallel mode — each task gets its own abort signal (combined
 				// with pi's turn signal) so F4 can kill one stuck agent
 				// while its siblings keep working.
+				const maxConcurrency = loadMoaConfig().maxConcurrentAgents;
 				const tasks = params.tasks!;
 				const run = new CancelRun();
 				const extras: CancelRowExtras[] = tasks.map(() => ({}));
@@ -202,6 +204,7 @@ export function registerMfPlanSubagentTool(pi: ExtensionAPI, host: MfPlanSubagen
 								loopCount: activityLoopCount(result.activity, histories[index]),
 							};
 						},
+						{ maxConcurrency },
 					);
 
 					// resolveOnAbort makes the runner resolve on abort; rethrow so a

package/src/runtime/activityTracking.ts

@@ -1,8 +1,8 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { AssistantMessage, Message } from "@earendil-works/pi-ai";
+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, type WireAssistantMessageEvent } from "./wire.ts";
+import { isNonnegativeFiniteNumber, isValidContentIndex } from "./wire.ts";
 
 /** Max length of a one-line tool-activity description surfaced for progress UIs. */
 const ACTIVITY_MAX = 80;
@@ -94,6 +94,19 @@ export class OutputActivityTracker {
 
 type AssistantContentPart = AssistantMessage["content"][number];
 
+/**
+ * The only fields `apply` reads. Declared structurally rather than as the wire
+ * union so both the JSON-protocol delta and the in-process
+ * `MessageUpdateEvent["assistantMessageEvent"]` are assignable — those two
+ * diverged when JSON `toolcall_start` gained required `id`/`toolName` (#7953).
+ */
+export interface PartialAssistantDelta {
+	type: string;
+	contentIndex?: number;
+	delta?: string;
+	toolCall?: ToolCall;
+}
+
 /**
  * Rebuilds the in-flight assistant message from streamed deltas.
  *
@@ -111,19 +124,22 @@ export class PartialAssistantAssembler {
 		this.#parts = [];
 	}
 
-	apply(assistantEvent: WireAssistantMessageEvent | undefined): void {
+	apply(assistantEvent: PartialAssistantDelta | undefined): void {
 		if (!assistantEvent) return;
-		if (("contentIndex" in assistantEvent && !isValidContentIndex(assistantEvent.contentIndex))) return;
-		if (assistantEvent.type === "text_delta") {
-			const part = this.#parts[assistantEvent.contentIndex];
+		const contentIndex = assistantEvent.contentIndex;
+		// Every handled delta kind is content-indexed, so an absent or out-of-range
+		// index is a no-op — same net effect as the previous `in` check.
+		if (!isValidContentIndex(contentIndex)) return;
+		if (assistantEvent.type === "text_delta" && typeof assistantEvent.delta === "string") {
+			const part = this.#parts[contentIndex];
 			if (part?.type === "text") part.text += assistantEvent.delta;
-			else this.#parts[assistantEvent.contentIndex] = { type: "text", text: assistantEvent.delta };
-		} else if (assistantEvent.type === "thinking_delta") {
-			const part = this.#parts[assistantEvent.contentIndex];
+			else this.#parts[contentIndex] = { type: "text", text: assistantEvent.delta };
+		} else if (assistantEvent.type === "thinking_delta" && typeof assistantEvent.delta === "string") {
+			const part = this.#parts[contentIndex];
 			if (part?.type === "thinking") part.thinking += assistantEvent.delta;
-			else this.#parts[assistantEvent.contentIndex] = { type: "thinking", thinking: assistantEvent.delta };
-		} else if (assistantEvent.type === "toolcall_end") {
-			this.#parts[assistantEvent.contentIndex] = assistantEvent.toolCall;
+			else this.#parts[contentIndex] = { type: "thinking", thinking: assistantEvent.delta };
+		} else if (assistantEvent.type === "toolcall_end" && assistantEvent.toolCall) {
+			this.#parts[contentIndex] = assistantEvent.toolCall;
 		}
 	}
 

package/src/runtime/processPool.ts

@@ -38,6 +38,7 @@ 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));
@@ -47,6 +48,7 @@ export async function mapWithConcurrencyLimit<TIn, TOut>(
 		while (true) {
 			const current = nextIndex++;
 			if (current >= items.length) return;
+			onStart?.(current);
 			results[current] = await fn(items[current], current);
 		}
 	});

package/src/runtime/runner.ts

@@ -10,6 +10,7 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 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 { escalateKill, mapWithConcurrencyLimit, trackedProcesses } from "./processPool.ts";
@@ -24,7 +25,6 @@ import {
 } from "./wire.ts";
 
 const MAX_PARALLEL_TASKS = 8;
-const MAX_CONCURRENCY = 5;
 const CHILD_IDLE_TIMEOUT_MS = 15 * 60 * 1000;
 const MAX_DIAGNOSTIC_CHARS = 65_536;
 const READ_ONLY_AGENT_TOOLS = ["read", "grep", "find", "ls"] as const;
@@ -94,8 +94,9 @@ export interface RunSingleAgentOptions {
 	 * Called on every streamed turn boundary (each `message_end`) with the live,
 	 * in-progress result. Lets callers observe running usage — notably
 	 * `usage.contextTokens` (the latest turn's total context size) — so a progress
-	 * widget can show a growing context-usage bar while the agent works. Providers
-	 * that run a whole task as one turn only report at the end; see
+	 * widget can show a growing context-usage bar while the agent works.
+	 * `contextTokens` advances from `message_update` usage, authoritative
+	 * `message_end` usage, and the stderr beacon; see
 	 * docs/handoff-bridge-live-context.md.
 	 */
 	onProgress?: (result: SingleResult) => void;
@@ -249,6 +250,23 @@ export async function runSingleAgent(
 					outputActivity.messageUpdate(event.assistantMessageEvent);
 					partialMessage.apply(event.assistantMessageEvent);
 					currentResult.partialAssistant = partialMessage.snapshot();
+					// Interim context reading. Providers that run a whole task as one turn emit a
+					// single message_end, so without this the CTX bar sits at 0% for the run.
+					// A malformed or absent reading is ignored rather than rejected upstream, so a
+					// bad number never costs the run its text deltas.
+					// "beacon" source: never lowers a value and never overrides an authoritative
+					// message_end reading for the same turn.
+					const liveTotal = event.usage?.totalTokens;
+					if (isValidContextTokens(liveTotal)) {
+						const reconciled = reconcileContextTokens(
+							currentResult.usage.contextTokens,
+							contextUsageIsAuthoritative,
+							liveTotal,
+							"beacon",
+						);
+						currentResult.usage.contextTokens = reconciled.contextTokens;
+						contextUsageIsAuthoritative = reconciled.authoritative;
+					}
 					emitUpdate();
 				}
 
@@ -413,6 +431,13 @@ export interface ModelParallelAgentTask extends ParallelAgentTask {
 	model: string;
 }
 
+export interface ParallelRunOptions {
+	/** Max child processes in flight. Normalized here, so an omitted or malformed value falls back to the safe default. */
+	maxConcurrency?: number;
+	/** Called once a queued task acquires a process-pool slot, immediately before it begins. */
+	onStart?: (index: number) => void;
+}
+
 /** Run multiple agents in parallel with concurrency limit. */
 export async function runParallelAgents(
 	defaultCwd: string,
@@ -422,11 +447,14 @@ export async function runParallelAgents(
 	onUpdate: ((partial: AgentToolResult<unknown>) => void) | undefined,
 	onEach?: (index: number, result: SingleResult) => void,
 	onProgress?: (index: number, result: SingleResult) => void,
+	options: ParallelRunOptions = {},
 ): Promise<SingleResult[]> {
 	if (tasks.length > MAX_PARALLEL_TASKS) {
 		throw new Error(`Too many parallel tasks (${tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`);
 	}
 
+	const maxConcurrency = normalizeMaxConcurrentAgents(options.maxConcurrency);
+
 	const allResults: SingleResult[] = new Array(tasks.length);
 
 	for (let i = 0; i < tasks.length; i++) {
@@ -441,10 +469,12 @@ export async function runParallelAgents(
 		};
 	}
 
+	const startedIndices = new Set<number>();
+
 	const emitParallelUpdate = () => {
 		if (onUpdate) {
-			const running = allResults.filter((r) => r.exitCode === -1).length;
 			const done = allResults.filter((r) => r.exitCode !== -1).length;
+			const running = startedIndices.size - done;
 			onUpdate({
 				details: undefined,
 				content: [{ type: "text", text: `Parallel: ${done}/${allResults.length} done, ${running} running...` }],
@@ -452,10 +482,10 @@ export async function runParallelAgents(
 		}
 	};
 
-	const results = await mapWithConcurrencyLimit(tasks, MAX_CONCURRENCY, async (t, index) => {
+	const results = await mapWithConcurrencyLimit(tasks, maxConcurrency, async (t, index) => {
 		const taskSignal = t.signal ?? signal;
 		if (taskSignal?.aborted) {
-			// Cancelled while queued behind MAX_CONCURRENCY — never spawn.
+			// Cancelled while queued behind the configured concurrency limit — never spawn.
 			const placeholder = cancelledPlaceholderResult(t.agent, t.task);
 			allResults[index] = placeholder;
 			emitParallelUpdate();
@@ -483,6 +513,9 @@ export async function runParallelAgents(
 		emitParallelUpdate();
 		onEach?.(index, result);
 		return result;
+	}, (index) => {
+		startedIndices.add(index);
+		options.onStart?.(index);
 	});
 
 	return results;
@@ -500,15 +533,18 @@ export async function runParallelAgentsWithModels(
 	signal: AbortSignal | undefined,
 	onEach: ((index: number, result: SingleResult) => void) | undefined,
 	onProgress?: (index: number, result: SingleResult) => void,
+	options: ParallelRunOptions = {},
 ): Promise<SingleResult[]> {
 	if (tasks.length > MAX_PARALLEL_TASKS) {
 		throw new Error(`Too many parallel tasks (${tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`);
 	}
 
-	const results = await mapWithConcurrencyLimit(tasks, MAX_CONCURRENCY, async (t, index) => {
+	const maxConcurrency = normalizeMaxConcurrentAgents(options.maxConcurrency);
+
+	const results = await mapWithConcurrencyLimit(tasks, maxConcurrency, async (t, index) => {
 		const taskSignal = t.signal ?? signal;
 		if (taskSignal?.aborted) {
-			// Cancelled while queued behind MAX_CONCURRENCY — never spawn.
+			// Cancelled while queued behind the configured concurrency limit — never spawn.
 			const placeholder = cancelledPlaceholderResult(t.agent, t.task);
 			onEach?.(index, placeholder);
 			return placeholder;
@@ -532,7 +568,7 @@ export async function runParallelAgentsWithModels(
 		);
 		onEach?.(index, result);
 		return result;
-	});
+	}, options.onStart);
 
 	return results;
 }

package/src/runtime/wire.ts

@@ -71,6 +71,17 @@ function isWireMessage(value: unknown): boolean {
 		return typeof value.content === "string"
 			|| (Array.isArray(value.content) && value.content.every((part) => isTextContent(part) || isImageContent(part)));
 	}
+	// 0.86.0 children emit a system message_start/message_end pair carrying the
+	// prompt and tool-loadout declaration. It never reaches `messages` (isLlmMessage
+	// filters it) and both trackers ignore non-assistant roles, but rejecting it
+	// here put two spurious parse errors at the head of every failure report.
+	// The pair arrives before any assistant stream, so `partialMessage.start()`
+	// clearing the in-flight partial on a non-assistant message_start loses
+	// nothing today — worth re-checking if a future protocol interleaves them.
+	if (value.role === "system") {
+		return typeof value.content === "string"
+			|| (Array.isArray(value.content) && value.content.every((part) => isTextContent(part)));
+	}
 	if (value.role === "assistant") {
 		return Array.isArray(value.content)
 			&& value.content.every((part) => isTextContent(part) || isThinkingContent(part) || isToolCall(part));

package/src/ui/cancelOverlay.ts

@@ -150,7 +150,7 @@ class CancelOverlayComponent implements Component {
 				: spin;
 			const stateText =
 				agent.state === "running" ? "running"
-				: agent.state === "cancelling" ? "cancelling…"
+				: agent.state === "cancelling" ? "cancelling"
 				: agent.state;
 			const extras = this.session.getExtras?.(i);
 			const bar = extras && (extras.contextTokens !== undefined || extras.contextWindow !== undefined)

package/src/ui/moaModelPicker.ts

@@ -44,6 +44,7 @@ import {
 import { PLAN_OVERLAY_OPTIONS } from "./menu.ts";
 import { TwoPaneModelThinking } from "./twoPaneModelThinking.ts";
 import { smartTruncateModelLabel } from "./modelLabel.ts";
+import { proposerDiversityWarning } from "../moa/panelDependence.ts";
 import { getModelCatalogue } from "../config/modelCatalogue.ts";
 import {
 	loadMoaConfig,
@@ -244,6 +245,11 @@ class MoaModelPickerComponent implements Component {
 		return this.proposerRefs.reduce((n, ref) => (ref ? n + 1 : n), 0);
 	}
 
+	private diversityWarning(): string | undefined {
+		const assigned = this.proposerRefs.filter((ref): ref is ModelRef => ref !== undefined);
+		return proposerDiversityWarning(assigned);
+	}
+
 	/**
 	 * Ready to start once at least MIN_PROPOSERS proposer slots plus all three
 	 * required roles hold explicit assignments. Counts assigned slots, not
@@ -587,7 +593,11 @@ class MoaModelPickerComponent implements Component {
 				slotRow("Verifier", detail("Verifier", this.verifierRef, this.verifierThinking), VERIFIER_ROW),
 				startRow,
 			];
-			const reviewRows = [loadRow, row(""), ...slotRows.slice(1, -1), row(""), startRow];
+			const warning = this.diversityWarning();
+			const warningRows = warning
+				? wrapWords(warning, bodyWidth - 1).map((line) => row(th.fg("dim", line)))
+				: [];
+			const reviewRows = [loadRow, row(""), ...slotRows.slice(1, -1), row(""), ...warningRows, startRow];
 			const lines = [
 				topBorder,
 				row(th.fg("accent", "MoA Fusion Pre-flight")),