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

package/src/ui/moaProgressWidget.ts

@@ -297,12 +297,20 @@ export class MoaProgressWidget implements MoaProgressView {
 	}
 
 	/**
-	 * Start the fan-out phase with the initial (working) proposer statuses.
+	 * Start the fan-out phase, marking only the slots that fit the process-pool
+	 * limit as working. The runner promotes queued slots when they acquire one.
 	 * `thinking[i]` tints proposer `i`'s meter; an absent entry falls to accent.
 	 */
-	startFanout(refs: ModelRef[], thinking: (ThinkingLevel | undefined)[] = []): void {
+	startFanout(refs: ModelRef[], thinking: (ThinkingLevel | undefined)[] = [], maxConcurrency = refs.length): void {
 		const startedAt = Date.now();
-		this.statuses = refs.map((ref, index) => ({ ref, phase: "Plan" as const, state: "working" as const, startedAt, thinking: thinking[index] }));
+		const activeCount = Number.isFinite(maxConcurrency) ? Math.max(1, Math.floor(maxConcurrency)) : refs.length;
+		this.statuses = refs.map((ref, index) => ({
+			ref,
+			phase: "Plan" as const,
+			state: index < activeCount ? "working" as const : "queued" as const,
+			startedAt: index < activeCount ? startedAt : undefined,
+			thinking: thinking[index],
+		}));
 		this.active = "Plan";
 		this.mountTable();
 	}
@@ -341,14 +349,17 @@ export class MoaProgressWidget implements MoaProgressView {
 		const wasSettled = s.state === "done" || s.state === "error" || s.state === "cancelled";
 		s.state = state;
 		s.detail = detail;
-		// Re-activation (a settled proposer being retried) un-freezes the clock
-		// and must not show output from the failed attempt.
-		if (state === "working" && wasSettled) {
+		// A settled proposer entering a queued retry/round must clear its preview
+		// before it can be promoted to working, so it never shows stale output.
+		if ((state === "working" || state === "queued") && wasSettled) {
 			s.transcript = undefined;
 			s.transcriptRevision = (s.transcriptRevision ?? 0) + 1;
 		}
 		if (!isActive(state)) s.endedAt ??= Date.now();
-		else s.endedAt = undefined;
+		else {
+			s.startedAt ??= Date.now();
+			s.endedAt = undefined;
+		}
 	}
 
 	/** Update one proposer's live context, turn, tool-call, and cost readings (by index). */
@@ -386,6 +397,46 @@ export class MoaProgressWidget implements MoaProgressView {
 		s.transcriptRevision = (s.transcriptRevision ?? 0) + 1;
 	}
 
+	/**
+	 * Point a settled proposer row at a replacement model and clear every reading
+	 * from the abandoned attempt, so the row reads as freshly queued. The elapsed
+	 * clock is left unstamped: `update(index, "working")` starts it when the slot
+	 * actually runs. Remounts the table, which the replacement prompt stopped —
+	 * `update()` alone clears only the transcript, leaving stale turns/tools/cost/
+	 * context behind, and `stopWidget()` (needed so the select/picker are not
+	 * fighting the sticky widget) unmounts it, so only `mountTable()` remounts.
+	 */
+	replaceProposerModel(index: number, ref: ModelRef, thinking?: ThinkingLevel): void {
+		const s = this.statuses[index];
+		if (!s) return;
+		s.ref = ref;
+		s.phase = "Plan";
+		s.thinking = thinking;
+		s.state = "queued";
+		s.detail = undefined;
+		// Clear every reading from the abandoned attempt, matching the wasSettled
+		// branch of update(): the row must read as freshly queued, and the
+		// transcriptRevision bump invalidates the preview cache.
+		s.contextTokens = undefined;
+		s.activity = undefined;
+		s.activityHistory = [];
+		s.outputTokens = undefined;
+		s.outputRevision = undefined;
+		s.turns = undefined;
+		s.toolCalls = undefined;
+		s.costUsd = undefined;
+		s.transcript = undefined;
+		s.startedAt = undefined;
+		s.endedAt = undefined;
+		s.transcriptRevision = (s.transcriptRevision ?? 0) + 1;
+		this.mountTable();
+	}
+
+	/** Re-show the table after a prompt stopped it, without changing any row. Idempotent. */
+	resumeTable(): void {
+		this.mountTable();
+	}
+
 	/**
 	 * Move a role row into `working`, starting (or keeping) its elapsed clock.
 	 * Each activation replaces the row's thinking level (with `undefined` when the
@@ -539,7 +590,7 @@ export class MoaProgressWidget implements MoaProgressView {
 	private toRow(s: ProposerStatus, phase: MoaPhase, workingText: string, now: number, firstOfPhase: boolean): ProgressRow {
 		const statusText =
 			s.state === "working" ? (s.detail ?? workingText)
-			: s.state === "cancelling" ? "cancelling…"
+			: s.state === "cancelling" ? "cancelling"
 			: s.state === "cancelled" ? "cancelled"
 			: s.state === "error" ? s.detail ?? "error"
 			: s.state === "queued" ? "queued"

package/src/ui/moaSetupOverlay.ts

@@ -17,6 +17,10 @@ import { type Component, type TUI } from "@earendil-works/pi-tui";
 import {
 	defaultThinkingForModel,
 	loadMoaConfig,
+	MAX_CONCURRENT_AGENTS,
+	MAX_VERIFICATION_REPAIRS_LIMIT,
+	MIN_CONCURRENT_AGENTS,
+	MIN_VERIFICATION_REPAIRS,
 	saveMoaConfig,
 	type MoaConfig,
 } from "../config/settings.ts";
@@ -49,8 +53,6 @@ interface SetupSlot {
 	description: string;
 	/** Whether the overview row appends the selected thinking level. */
 	showThinkingValue: boolean;
-	/** Where a confirmed selection is persisted. */
-	target: { kind: "agent"; agentName: string } | { kind: "role" };
 }
 
 const SLOTS: readonly SetupSlot[] = [
@@ -59,14 +61,12 @@ const SLOTS: readonly SetupSlot[] = [
 		title: agent.title,
 		description: agent.description,
 		showThinkingValue: true,
-		target: { kind: "agent", agentName: agent.name },
 	})),
 	{
 		menuLabel: "cheap/fast agent",
 		title: "Cheap / fast agent — plan-file naming",
 		description: "Only summarizes a plan prompt into a short file name. Always called with thinking off and falls back safely if it cannot respond, so pick the cheapest model available.",
 		showThinkingValue: false,
-		target: { kind: "role" },
 	},
 ];
 
@@ -77,6 +77,8 @@ interface SetupDraft {
 	thinkingOverrides: Record<string, ThinkingLevel>;
 	autoResolveConflicts: boolean;
 	useSummaryName: boolean;
+	maxConcurrentAgents: number;
+	maxVerificationRepairs: number;
 	rosters: PlanRoster[];
 }
 
@@ -90,6 +92,8 @@ class MoaSetupComponent implements Component {
 	private readonly menu: MenuComponent;
 	private autoResolveConflicts: boolean;
 	private useSummaryName: boolean;
+	private maxConcurrentAgents: number;
+	private maxVerificationRepairs: number;
 
 	constructor(
 		private readonly tui: TUI,
@@ -105,6 +109,8 @@ class MoaSetupComponent implements Component {
 		this.twoPane = new TwoPaneModelThinking(tui, theme, availableRefs, config, currentThinking, ctx);
 		this.autoResolveConflicts = draft.autoResolveConflicts;
 		this.useSummaryName = draft.useSummaryName;
+		this.maxConcurrentAgents = draft.maxConcurrentAgents;
+		this.maxVerificationRepairs = draft.maxVerificationRepairs;
 		const slotItem = (slotIndex: number): MenuItem => ({
 			id: `role-${slotIndex}`,
 			label: SLOTS[slotIndex]!.menuLabel,
@@ -130,6 +136,28 @@ class MoaSetupComponent implements Component {
 				{ title: "options", items: [
 					{ id: "auto-resolve", label: "auto resolve conflicts", value: this.autoResolveConflicts, onChange: (value: boolean) => { this.autoResolveConflicts = value; } },
 					{ id: "use-summary-name", label: "summarize plan names", value: this.useSummaryName, onChange: (value: boolean) => { this.useSummaryName = value; } },
+					{
+						id: "max-concurrent-agents",
+						label: "max concurrent agents",
+						values: Array.from(
+							{ length: MAX_CONCURRENT_AGENTS - MIN_CONCURRENT_AGENTS + 1 },
+							(_unused, index) => String(MIN_CONCURRENT_AGENTS + index),
+						),
+						valueIndex: this.maxConcurrentAgents - MIN_CONCURRENT_AGENTS,
+						description: "Child agents running at once in MoA, opinion, debate and plan subagent fan-outs. Keep at 1 for local agents.",
+						onChange: (valueIndex: number) => { this.maxConcurrentAgents = MIN_CONCURRENT_AGENTS + valueIndex; },
+					},
+					{
+						id: "max-verification-repairs",
+						label: "max verification repairs",
+						values: Array.from(
+							{ length: MAX_VERIFICATION_REPAIRS_LIMIT - MIN_VERIFICATION_REPAIRS + 1 },
+							(_unused, index) => String(MIN_VERIFICATION_REPAIRS + index),
+						),
+						valueIndex: this.maxVerificationRepairs - MIN_VERIFICATION_REPAIRS,
+						description: "Verifier-driven repair rounds after implementation (0 disables automatic repairs).",
+						onChange: (valueIndex: number) => { this.maxVerificationRepairs = MIN_VERIFICATION_REPAIRS + valueIndex; },
+					},
 				] },
 			],
 			buttons: [
@@ -168,6 +196,8 @@ class MoaSetupComponent implements Component {
 			thinkingOverrides: { ...this.draft.thinkingOverrides },
 			autoResolveConflicts: this.autoResolveConflicts,
 			useSummaryName: this.useSummaryName,
+			maxConcurrentAgents: this.maxConcurrentAgents,
+			maxVerificationRepairs: this.maxVerificationRepairs,
 			rosters: [...this.draft.rosters],
 		};
 	}
@@ -299,6 +329,8 @@ export async function showMoaSetup(
 		thinkingOverrides: {},
 		autoResolveConflicts: saved.autoResolveConflicts,
 		useSummaryName: saved.useSummaryName,
+		maxConcurrentAgents: saved.maxConcurrentAgents,
+		maxVerificationRepairs: saved.maxVerificationRepairs,
 		rosters: [...saved.rosters],
 	};
 
@@ -325,6 +357,10 @@ export async function showMoaSetup(
 		);
 		if (result === undefined) return false;
 		if (result.action === "rosters") {
+			draft.autoResolveConflicts = result.draft.autoResolveConflicts;
+			draft.useSummaryName = result.draft.useSummaryName;
+			draft.maxConcurrentAgents = result.draft.maxConcurrentAgents;
+			draft.maxVerificationRepairs = result.draft.maxVerificationRepairs;
 			draft.rosters = await showRosterManager(ctx, draft.rosters, { currentThinking });
 			continue;
 		}
@@ -360,6 +396,8 @@ export async function showMoaSetup(
 		agentDefaultsConfigured: true,
 		autoResolveConflicts: finalDraft.autoResolveConflicts,
 		useSummaryName: finalDraft.useSummaryName,
+		maxConcurrentAgents: finalDraft.maxConcurrentAgents,
+		maxVerificationRepairs: finalDraft.maxVerificationRepairs,
 		cheap: finalDraft.selections[AGENT_SLOT_COUNT],
 		rosters: finalDraft.rosters,
 		thinkingOverrides: { ...current.thinkingOverrides, ...finalDraft.thinkingOverrides },

package/src/ui/workingOverlay.ts

@@ -0,0 +1,265 @@
+/**
+ * Working overlay — a small "please wait" card for blocking, non-agent work
+ * that has nowhere else to draw while it runs (e.g. summarizing a plan
+ * prompt into a name between the prompt editor closing and the next picker
+ * mounting). This is not the cancel-run surface: there is no agent table
+ * and no subagents to cancel. Esc abandons the wait rather than the flow
+ * that is waiting on it — the calling flow owns the overlay's lifetime
+ * through a session bridge, mirroring `CancelSession.closeOverlay`.
+ */
+
+import type { ExtensionContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { isKeyRelease, Key, matchesKey, visibleWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { setTimeout as sleep } from "node:timers/promises";
+import { formatElapsed } from "./agentStatus.ts";
+import { BRAILLE_SPINNER_FRAMES, ROUNDED_SINGLE_BOX, UI_TICK_MS, createFrame } from "./chrome.ts";
+import { shimmerString, type ShimmerTheme } from "./shimmer.ts";
+
+const OVERLAY_MARGIN = 1;
+/** Grace before mounting: work that settles inside this never flashes a card. */
+const SHOW_DELAY_MS = 200;
+/** Once shown, stay up at least this long so the card is readable, not a blink. */
+const MIN_VISIBLE_MS = 500;
+
+export interface WorkingOverlayOptions<T> {
+	/** Accent title row, e.g. "Naming the plan". */
+	title: string;
+	/** Dim, shimmering body line naming the work. */
+	detail: string;
+	/** Footer hint. Defaults to a plain wait line when `skip` is omitted. */
+	hint?: string;
+	/** Value to resolve with when the user presses esc. Omit to make the wait un-skippable. */
+	skip?: () => T;
+}
+
+/** Bridge an outside owner uses to close an overlay it does not render. Mirrors `CancelSession.closeOverlay`. */
+export interface WorkingOverlaySession {
+	closeOverlay?: () => void;
+	/** Set when close was requested before the component mounted. */
+	closeRequested?: boolean;
+}
+
+/** Ask a (possibly not-yet-mounted) overlay to close. Safe to call before `showWorkingOverlay`'s factory has run. */
+export function requestWorkingOverlayClose(session: WorkingOverlaySession): void {
+	session.closeRequested = true;
+	session.closeOverlay?.();
+}
+
+interface WorkingOverlayRenderOptions {
+	title: string;
+	detail: string;
+	hint?: string;
+	onSkip?: () => void;
+}
+
+/** Show the working overlay. Resolves when closed. Outside TUI mode there is no overlay surface. */
+export async function showWorkingOverlay(
+	ctx: ExtensionContext,
+	options: WorkingOverlayRenderOptions,
+	session: WorkingOverlaySession,
+): Promise<void> {
+	if (ctx.mode !== "tui") return;
+	await ctx.ui.custom<void>(
+		(tui, theme, _keybindings, done) => new WorkingOverlayComponent(tui, theme, options, session, done),
+		{
+			overlay: true,
+			overlayOptions: {
+				anchor: "center",
+				width: "50%",
+				minWidth: 40,
+				margin: OVERLAY_MARGIN,
+			},
+		},
+	);
+}
+
+type Settled<T> = { ok: true; value: T } | { ok: false; error: unknown };
+
+function unwrap<T>(settled: Settled<T>): T {
+	if (settled.ok) return settled.value;
+	throw settled.error;
+}
+
+/**
+ * Run `task` behind the working overlay. The overlay only mounts if `task`
+ * is still pending after `SHOW_DELAY_MS`, and once mounted stays up at
+ * least `MIN_VISIBLE_MS` so it never reads as a flicker. There is no
+ * automatic cutoff: a task that never settles keeps the card up until the
+ * user presses Esc (when `options.skip` is set) — deliberate, not an
+ * oversight, since the hint row is what turns that into a user choice
+ * rather than a hang.
+ */
+export async function withWorkingOverlay<T>(
+	ctx: ExtensionContext,
+	options: WorkingOverlayOptions<T>,
+	task: (signal: AbortSignal) => Promise<T>,
+): Promise<T> {
+	const controller = new AbortController();
+	const work = task(controller.signal);
+	// No terminal surface: the caller still waits, but there is nothing to draw on.
+	if (ctx.mode !== "tui") return work;
+
+	// Reflect instead of letting `work` reject on its own timeline: it is raced
+	// against the grace timer and abandoned outright when the user skips, and an
+	// abandoned rejecting promise would otherwise surface as an unhandled rejection.
+	let pending = true;
+	const settled: Promise<Settled<T>> = work.then(
+		(value): Settled<T> => ({ ok: true, value }),
+		(error): Settled<T> => ({ ok: false, error }),
+	);
+	void settled.then(() => {
+		pending = false;
+	});
+
+	await Promise.race([settled, sleep(SHOW_DELAY_MS)]);
+	if (!pending) return unwrap(await settled);
+
+	const session: WorkingOverlaySession = {};
+	const shownAt = Date.now();
+	let skipped: { value: T } | undefined;
+	void settled.then(async () => {
+		if (skipped) return;
+		await sleep(Math.max(0, MIN_VISIBLE_MS - (Date.now() - shownAt)));
+		requestWorkingOverlayClose(session);
+	});
+
+	const skip = options.skip;
+	try {
+		await showWorkingOverlay(
+			ctx,
+			{
+				title: options.title,
+				detail: options.detail,
+				hint: options.hint,
+				// Esc skips: abort what we can, then leave the rest behind. The flow
+				// must move on even when a provider ignores the abort signal.
+				onSkip: skip
+					? () => {
+						skipped = { value: skip() };
+						controller.abort();
+					}
+					: undefined,
+			},
+			session,
+		);
+	} catch {
+		// A stale ctx (e.g. after /reload) must not break the flow that is waiting.
+	}
+
+	if (skipped) return skipped.value;
+	return unwrap(await settled);
+}
+
+/** Copy for the plan/opinion/debate naming wait. No trailing ellipses — see CHANGELOG 0.2.0. */
+export function planNamingOverlay(subject: "plan" | "opinion" | "debate", skip: () => string): WorkingOverlayOptions<string> {
+	return {
+		title: `Naming the ${subject}`,
+		detail: `summarizing your prompt into a short ${subject} name`,
+		hint: "esc skip naming · a name from your prompt is used instead",
+		skip,
+	};
+}
+
+/** The slice of pi's `Theme` this overlay needs. Structural so tests can stub it without `getFgAnsi`. */
+interface WorkingOverlayTheme {
+	fg(color: ThemeColor, text: string): string;
+	bg(color: Parameters<Theme["bg"]>[0], text: string): string;
+	/** 24-bit ANSI escape for a color. Absent on test stubs, so the detail line falls back to flat text. */
+	getFgAnsi?(color: ThemeColor): string;
+}
+
+class WorkingOverlayComponent implements Component {
+	private readonly tui: TUI;
+	private readonly theme: WorkingOverlayTheme;
+	private readonly options: WorkingOverlayRenderOptions;
+	private readonly session: WorkingOverlaySession;
+	private readonly done: (value: void) => void;
+	private readonly startedAt: number;
+	private readonly timer: ReturnType<typeof setInterval>;
+	private spinFrame = 0;
+	private closed = false;
+
+	constructor(
+		tui: TUI,
+		theme: WorkingOverlayTheme,
+		options: WorkingOverlayRenderOptions,
+		session: WorkingOverlaySession,
+		done: (value: void) => void,
+	) {
+		this.tui = tui;
+		this.theme = theme;
+		this.options = options;
+		this.session = session;
+		this.done = done;
+		this.startedAt = Date.now();
+		this.timer = setInterval(() => {
+			this.spinFrame = (this.spinFrame + 1) % BRAILLE_SPINNER_FRAMES.length;
+			tui.requestRender();
+		}, UI_TICK_MS);
+		this.timer.unref();
+
+		session.closeOverlay = () => this.finish();
+		// The task can settle before `ctx.ui.custom` invokes this factory (only
+		// mounting triggers the factory). Defer so `done` is never called
+		// synchronously from inside the factory that constructs this component.
+		if (session.closeRequested) setTimeout(() => this.finish(), 0);
+	}
+
+	private finish(): void {
+		if (this.closed) return;
+		this.closed = true;
+		this.done(undefined);
+	}
+
+	handleInput(data: string): void {
+		// Under the Kitty keyboard protocol, the *release* of the key that
+		// closed the previous surface (e.g. Enter submitting the prompt editor)
+		// can land on this freshly mounted overlay a tick later. Only a press
+		// may skip. Same bug class as test/cancel-overlay-escape-release.test.mjs.
+		if (isKeyRelease(data)) return;
+		if (matchesKey(data, Key.escape)) {
+			if (this.options.onSkip) {
+				this.options.onSkip();
+				this.finish();
+			}
+			return;
+		}
+		// Everything else is swallowed: this is a blocking wait, not an
+		// interactive list, and stray keystrokes must not queue into whatever
+		// mounts next.
+	}
+
+	render(width: number): string[] {
+		const th = this.theme;
+		const innerWidth = Math.max(20, width - 4);
+		const frame = createFrame(th, innerWidth, {
+			glyphs: ROUNDED_SINGLE_BOX,
+			horizontalPadding: 1,
+			truncationMark: "…",
+			padToWidth: true,
+			minimumBodyWidth: 10,
+		});
+
+		const elapsed = formatElapsed(Date.now() - this.startedAt);
+		const titlePad = Math.max(1, frame.bodyWidth - visibleWidth(this.options.title) - visibleWidth(elapsed));
+		const titleRow = frame.row(`${th.fg("accent", this.options.title)}${" ".repeat(titlePad)}${th.fg("dim", elapsed)}`);
+
+		const spin = th.fg("accent", BRAILLE_SPINNER_FRAMES[this.spinFrame % BRAILLE_SPINNER_FRAMES.length]!);
+		const detailText = th.getFgAnsi
+			? shimmerString(this.options.detail, Date.now() - this.startedAt, th as ShimmerTheme, "ltr", "normal")
+			: th.fg("dim", this.options.detail);
+		const detailRow = frame.row(`${spin} ${detailText}`);
+
+		const hint = this.options.hint ?? (this.options.onSkip ? "esc skip" : "please wait");
+		const hintRow = frame.row(th.fg("dim", hint));
+
+		return [frame.top(), titleRow, frame.separator(), detailRow, frame.separator(), hintRow, frame.bottom()];
+	}
+
+	invalidate(): void {}
+
+	dispose(): void {
+		clearInterval(this.timer);
+		if (this.session.closeOverlay) this.session.closeOverlay = undefined;
+	}
+}