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

package/src/ui/moaModelPicker.ts

@@ -8,7 +8,8 @@
  * starting unassigned at `(none)`, plus a Load Roster row that applies a saved
  * roster to every slot wholesale, and a Start fan-out action. Enter on a slot
  * opens its two-pane model/thinking picker; confirming writes only that slot
- * and returns to the overview, cancelling returns without changing it. The
+ * and returns to the overview, cancelling returns without changing it.
+ * Backspace or Delete on a slot clears it back to `(none)`. The
  * overview's "Start fan-out" action stays visually disabled until at least two
  * proposer slots and all three required roles are assigned, then it finishes
  * the picker.
@@ -44,6 +45,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,
@@ -212,7 +214,7 @@ class MoaModelPickerComponent implements Component {
 		return undefined;
 	}
 
-	private setRole(role: "synthesizer" | "implementer" | "verifier", ref: ModelRef, thinking: ThinkingLevel): void {
+	private setRole(role: "synthesizer" | "implementer" | "verifier", ref: ModelRef | undefined, thinking: ThinkingLevel | undefined): void {
 		if (role === "synthesizer") { this.synthesizerRef = ref; this.synthesizerThinking = thinking; }
 		else if (role === "implementer") { this.implementerRef = ref; this.implementerThinking = thinking; }
 		else { this.verifierRef = ref; this.verifierThinking = thinking; }
@@ -239,11 +241,28 @@ class MoaModelPickerComponent implements Component {
 		this.tui.requestRender();
 	}
 
+	/** Return a slot to `(none)`; the overview cursor stays on its row. */
+	private clearSlot(screen: number): void {
+		const role = this.nonProposerRole(screen);
+		if (role) {
+			this.setRole(role, undefined, undefined);
+		} else {
+			this.proposerRefs[screen - 1] = undefined;
+			this.proposerThinking[screen - 1] = undefined;
+		}
+		this.tui.requestRender();
+	}
+
 	/** Count of proposer slots holding an explicit assignment. */
 	private assignedProposerCount(): number {
 		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
@@ -423,6 +442,11 @@ class MoaModelPickerComponent implements Component {
 				// A disabled Start swallows Enter with no state change.
 				return;
 			}
+			if (matchesKey(data, Key.backspace) || matchesKey(data, Key.delete)) {
+				// Load Roster and Start have nothing to clear; every other row is a slot.
+				if (this.confirmIndex !== LOAD_ROW && this.confirmIndex !== START_ROW) this.clearSlot(this.confirmIndex);
+				return;
+			}
 			if (matchesKey(data, Key.escape)) {
 				// Back to the mode chooser; assignments are preserved.
 				this.screen = 0;
@@ -587,14 +611,18 @@ 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")),
 				sepBorder,
 				...reviewRows,
 				sepBorder,
-				row(th.fg("dim", "\u2191\u2193 navigate \u2022 enter select \u2022 esc back")),
+				row(th.fg("dim", "\u2191\u2193 navigate \u2022 enter select \u2022 \u232B clear \u2022 esc back")),
 				botBorder,
 			];
 			if (lines.length <= viewport) return lines;

package/src/ui/moaProgressWidget.ts

@@ -27,7 +27,7 @@
 
 import type { Message } from "@earendil-works/pi-ai";
 import type { ExtensionContext, ThemeColor } from "@earendil-works/pi-coding-agent";
-import { visibleWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { visibleWidth, wrapTextWithAnsi, type Component, type TUI } from "@earendil-works/pi-tui";
 import { ACTIVITY_METER_WIDTH, ActivityMeter, rateToLevel, TokRateTracker } from "../activityMeter.ts";
 import { modelRefLabel, shortModelName, type ModelRef, type ThinkingLevel } from "../shared/modelRefs.ts";
 import { contextPercent, CTX_COL_WIDTH, formatCost, formatElapsed, formatTokens } from "./agentStatus.ts";
@@ -122,6 +122,14 @@ const AGENT_COL_MIN = 8;
 /** Agent width below which a model ref stops being distinguishable from its siblings. */
 const AGENT_COL_READABLE = 24;
 const ACTIVITY_COL_MIN = 10;
+/** Gutter marking a sub-row as belonging to the agent row above it. */
+const SUB_ROW_GUTTER = "↳ ";
+/**
+ * Most wrapped lines one failed row may spend on its error detail. A provider
+ * error fits well inside this at any usable width; the cap only bites on a
+ * pathological message, which must not swallow the whole table.
+ */
+const ERROR_DETAIL_LINES = 8;
 const PREVIEW_LINES = 4;
 const PREVIEW_INDENT = STATUS_COL_WIDTH + 2;
 const PREVIEW_GUTTER = "│ ";
@@ -297,12 +305,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 +357,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 +405,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 +598,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"
@@ -768,10 +827,24 @@ export class MoaProgressTableComponent implements Component {
 			0,
 			this.rowBudget() - TABLE_CHROME_ROWS - rows.length - phaseSectionRows(rows) - (band.length > 0 ? PHASE_BAND_ROWS : 0),
 		);
+		// A failed row's message is the one status a reader has to act on, and it
+		// routinely outruns the ACTIVITY cell, so its wrapped detail claims budget
+		// ahead of live activity and previews. Failed rows are settled, so they
+		// compete for nothing else.
+		const subRowWidth = Math.max(0, bodyWidth - STATUS_COL_WIDTH - visibleWidth(SUB_ROW_GUTTER));
+		const errorDetails = new Map<number, string[]>();
+		let remaining = free;
+		for (let i = 0; i < rows.length && remaining > 0; i++) {
+			const detail = this.errorDetailLines(rows[i], cols.activity, subRowWidth, Math.min(ERROR_DETAIL_LINES, remaining));
+			if (detail.length === 0) continue;
+			errorDetails.set(i, detail);
+			remaining -= detail.length;
+		}
+
 		const activeIndices = rows.flatMap((r, index) => isActive(r.state) ? [index] : []);
 		const activityIndices = activeIndices.filter((index) => rows[index]?.activity);
-		const renderedActivityIndices = new Set(activityIndices.slice(0, free));
-		let remaining = Math.max(0, free - renderedActivityIndices.size);
+		const renderedActivityIndices = new Set(activityIndices.slice(0, remaining));
+		remaining = Math.max(0, remaining - renderedActivityIndices.size);
 
 		const previewWidth = Math.max(0, leftTableWidth - PREVIEW_INDENT - visibleWidth(PREVIEW_GUTTER));
 		const previewIndices = this.view.previewVisible && previewWidth >= PREVIEW_MIN_WIDTH
@@ -844,6 +917,9 @@ export class MoaProgressTableComponent implements Component {
 				),
 			);
 
+			const errorDetail = errorDetails.get(i) ?? [];
+			for (const [offset, text] of errorDetail.entries()) lines.push(row(this.errorDetailRow(text, offset === 0, subRowWidth)));
+
 			if (renderedActivityIndices.has(i)) lines.push(row(this.activitySubRow(r, bodyWidth)));
 			else if (reservedActivityIndices.has(i)) lines.push(row(""));
 
@@ -881,11 +957,37 @@ export class MoaProgressTableComponent implements Component {
 	/** Merged-cell tool activity line, spanning everything right of the status icon. */
 	private activitySubRow(r: ProgressRow, bodyWidth: number): string {
 		const room = Math.max(0, bodyWidth - STATUS_COL_WIDTH);
-		const gutter = this.theme.fg("dim", "↳ ");
+		const gutter = this.theme.fg("dim", SUB_ROW_GUTTER);
 		const activity = highlightActivity(this.theme, r.activity ?? "");
 		return `${" ".repeat(STATUS_COL_WIDTH)}${cell(`${gutter}${activity}`, room)}`;
 	}
 
+	/**
+	 * A failed row's message re-laid across the table body, or nothing when the
+	 * ACTIVITY cell already shows it whole. Provider failures arrive as one long
+	 * JSON payload whose cause sits well past the column edge, so the text is
+	 * wrapped — breaking the payload mid-token when it has no spaces to break on
+	 * — rather than cut off at a width the reader cannot change.
+	 */
+	private errorDetailLines(row: ProgressRow, activityWidth: number, width: number, maxLines: number): string[] {
+		if (row.state !== "error" || !row.statusText) return [];
+		if (width <= 0 || maxLines <= 0) return [];
+		if (visibleWidth(row.statusText) <= activityWidth) return [];
+		const wrapped = wrapTextWithAnsi(row.statusText, width);
+		if (wrapped.length <= maxLines) return wrapped;
+		// Mark the cut, so a clipped payload never reads as the whole message.
+		const shown = wrapped.slice(0, maxLines);
+		shown[maxLines - 1] = fitVisible(`${shown[maxLines - 1]}…`, width, { truncationMark: "…", padToWidth: false });
+		return shown;
+	}
+
+	/** One wrapped error line: the gutter carries the first, the rest hang under it. */
+	private errorDetailRow(text: string, first: boolean, width: number): string {
+		const gutter = first ? this.theme.fg("dim", SUB_ROW_GUTTER) : " ".repeat(visibleWidth(SUB_ROW_GUTTER));
+		const detail = fitVisible(text, width, { truncationMark: "…", padToWidth: false });
+		return `${" ".repeat(STATUS_COL_WIDTH)}${gutter}${this.theme.fg("error", detail)}`;
+	}
+
 	private topBorder(innerWidth: number, border: (s: string) => string): string {
 		const title = ` ${this.view.title} `;
 		const head = `${border("══")}${this.theme.fg("accent", title)}`;

package/src/ui/moaSetupOverlay.ts

@@ -8,8 +8,8 @@
  *
  * Two kinds of slot are configured here. Planning-subagent slots persist into
  * the frontmatter of the installed agent files; MoA fan-out roles are no
- * longer set per role here — they live in named rosters, edited by the staged
- * roster manager and persisted only when this overlay's Save is chosen.
+ * longer set per role here — they live in named rosters whose completed edits
+ * are persisted immediately by the roster manager.
  */
 
 import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
@@ -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,7 +357,17 @@ export async function showMoaSetup(
 		);
 		if (result === undefined) return false;
 		if (result.action === "rosters") {
-			draft.rosters = await showRosterManager(ctx, draft.rosters, { currentThinking });
+			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,
+				onChange: (rosters) => {
+					const current = loadMoaConfig();
+					saveMoaConfig({ ...current, rosters });
+				},
+			});
 			continue;
 		}
 		break;
@@ -360,6 +402,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/planReviewOverlay.ts

@@ -71,16 +71,15 @@ function formatProposersList(proposers: ModelRef[]): string {
 }
 
 function formatSplitRow(left: string, right: string | undefined, bodyWidth: number): string {
-	const leftText = left ?? "";
 	if (!right) {
-		return padRow(leftText, bodyWidth);
+		return padRow(left, bodyWidth);
 	}
 
-	const minLeft = Math.min(visibleWidth(leftText), 18);
+	const minLeft = Math.min(visibleWidth(left), 18);
 	const maxRight = Math.max(1, bodyWidth - minLeft);
 	const rightPart = truncateToWidth(right, maxRight, "…", false);
 	const rightVis = visibleWidth(rightPart);
-	const leftPart = truncateToWidth(leftText, Math.max(1, bodyWidth - rightVis), "…", false);
+	const leftPart = truncateToWidth(left, Math.max(1, bodyWidth - rightVis), "…", false);
 	const gap = bodyWidth - visibleWidth(leftPart) - visibleWidth(rightPart);
 	const row = gap > 0 ? leftPart + " ".repeat(gap) + rightPart : leftPart + rightPart;
 	return padRow(row, bodyWidth);
@@ -92,15 +91,23 @@ function formatRightRow(content: string, bodyWidth: number): string {
 	return padRow(gap > 0 ? " ".repeat(gap) + truncated : truncated, bodyWidth);
 }
 
+export interface PlanReviewLabels {
+	title?: string;
+	approveHint?: string;
+	keepHint?: string;
+	chatHint?: string;
+}
+
 export async function showPlanReview(
 	ctx: ExtensionContext,
 	planMarkdown: string,
 	moaInfo?: MfPlanInfo,
 	planName?: string,
 	allowChat = false,
+	labels?: PlanReviewLabels,
 ): Promise<PlanReviewDecision> {
 	const result = await ctx.ui.custom<PlanReviewDecision>(
-		(tui, theme, _keybindings, done) => new PlanReviewOverlay(tui, theme, planMarkdown, moaInfo, ctx.cwd, planName, allowChat, done),
+		(tui, theme, _keybindings, done) => new PlanReviewOverlay(tui, theme, planMarkdown, moaInfo, ctx.cwd, planName, allowChat, labels, done),
 		{
 			overlay: true,
 			overlayOptions: {
@@ -136,6 +143,7 @@ class PlanReviewOverlay implements Component {
 		private readonly repoCwd: string,
 		private readonly planName: string | undefined,
 		private readonly allowChat: boolean,
+		private readonly labels: PlanReviewLabels | undefined,
 		private readonly done: (decision: PlanReviewDecision) => void,
 	) {
 		this.markdown = new Markdown(stripTerminalSequences(planMarkdown), 0, 0, getMarkdownTheme());
@@ -234,9 +242,9 @@ class PlanReviewOverlay implements Component {
 			.join(",");
 		const proposalHelp = helpParts ? ` · ${helpParts} proposer plans · \`/0 synthesized` : "";
 		const verdictsHelp = this.verdictsMarkdown ? " · v verdicts" : "";
-		const chatHelp = this.allowChat ? " · c chat" : "";
+		const chatHelp = this.allowChat ? ` · c ${this.labels?.chatHint ?? "chat"}` : "";
 		const helpLines = wrapDimLine(
-			`↑/↓ or j/k scroll · u/d page${proposalHelp}${verdictsHelp} · e edit${chatHelp} · a/Enter approve · q/Esc keep planning`,
+			`↑/↓ or j/k scroll · u/d page${proposalHelp}${verdictsHelp} · e edit${chatHelp} · a/Enter ${this.labels?.approveHint ?? "approve"} · q/Esc ${this.labels?.keepHint ?? "keep planning"}`,
 			bodyWidth,
 		);
 		this.helpLineCount = helpLines.length;
@@ -261,7 +269,7 @@ class PlanReviewOverlay implements Component {
 		const planTitle = showingVerdicts
 			? "Proposer Verdicts"
 			: this.activeProposerIndex === undefined
-				? "Proposed Plan"
+				? this.labels?.title ?? "Proposed Plan"
 				: `Proposer ${this.activeProposerIndex + 1} Plan`;
 		const proposerModel = this.activeProposerIndex === undefined
 			? undefined

package/src/ui/rosterEditor.ts

@@ -3,9 +3,9 @@
  *
  * A staged CRUD surface over the saved `PlanRoster` list: list → name prompt →
  * slot editor → per-slot model/thinking picker, ported from persona-audit's
- * RosterEditor. Every mutation happens on in-memory copies; persistence stays
- * with the settings overlay's Save button, so closing without saving (or the
- * overlay's Cancel) leaves settings.json untouched.
+ * RosterEditor. Draft slot changes remain in memory until Save roster is
+ * chosen; completed roster saves and confirmed deletions are then persisted
+ * immediately through the manager's onChange callback.
  *
  * Each roster carries one model + thinking level for every fan-out role —
  * 2–5 proposers plus synthesizer, implementer, and verifier. A roster must be
@@ -31,8 +31,6 @@ import { ratioViewport } from "./chrome.ts";
 import { MenuComponent, showOverlayPrompt, type ActionMenuItem } from "./menu.ts";
 import { showModelThinkingPicker } from "./moaModelPicker.ts";
 
-const BACKSPACE = "\x7f";
-
 type SlotRole = "synthesizer" | "implementer" | "verifier";
 type SlotTarget = { kind: "proposer"; index: number } | { kind: "role"; role: SlotRole };
 type ListResult = { action: "create" } | { action: "edit"; index: number } | { action: "back" };
@@ -198,7 +196,7 @@ function showSlotEditor(ctx: ExtensionContext, draft: DraftRoster, focusItemId:
 					{ title: "roles", items: roleItems },
 				],
 				onItemKey: (item, data) => {
-					if (data !== BACKSPACE && data !== "\b" && !matchesKey(data, Key.delete)) return false;
+					if (!matchesKey(data, Key.backspace) && !matchesKey(data, Key.delete)) return false;
 					const target = parseTargetItemId(item.id);
 					if (!target) return true;
 					if (target.kind === "proposer") working.proposers[target.index] = undefined;
@@ -245,7 +243,7 @@ async function editRoster(
 		if (result.action === "cancel") return undefined;
 		if (result.action === "save") return fromDraft(result.draft);
 		if (result.action === "delete") {
-			if (await ctx.ui.confirm("Delete agent roster?", `Delete ${draft.name}? This is staged until settings are saved.`)) return "delete";
+			if (await ctx.ui.confirm("Delete agent roster?", `Delete ${draft.name}? This takes effect immediately.`)) return "delete";
 			continue;
 		}
 		if (result.action === "rename") {
@@ -272,11 +270,11 @@ async function editRoster(
 	}
 }
 
-/** Manage a staged roster collection; persistence remains the settings overlay's Save action's responsibility. */
+/** Manage roster drafts and publish completed saves immediately through onChange. */
 export async function showRosterManager(
 	ctx: ExtensionContext,
 	initial: PlanRoster[],
-	deps: { currentThinking: ThinkingLevel },
+	deps: { currentThinking: ThinkingLevel; onChange?: (rosters: PlanRoster[]) => void },
 ): Promise<PlanRoster[]> {
 	const rosters = initial.map((roster) => ({ ...roster, proposers: [...roster.proposers] }));
 	for (;;) {
@@ -298,13 +296,21 @@ export async function showRosterManager(
 				undefined,
 				deps.currentThinking,
 			);
-			if (created && created !== "delete") rosters.push(created);
+			if (created && created !== "delete") {
+				rosters.push(created);
+				deps.onChange?.(rosters);
+			}
 			continue;
 		}
 		const current = rosters[action.index];
 		if (!current) continue;
 		const edited = await editRoster(ctx, rosters, toDraft(current), action.index, deps.currentThinking);
-		if (edited === "delete") rosters.splice(action.index, 1);
-		else if (edited) rosters[action.index] = edited;
+		if (edited === "delete") {
+			rosters.splice(action.index, 1);
+			deps.onChange?.(rosters);
+		} else if (edited) {
+			rosters[action.index] = edited;
+			deps.onChange?.(rosters);
+		}
 	}
 }