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

package/src/index.ts

@@ -12,7 +12,7 @@ import {
 } from "./moa/implementationRetry.ts";
 import { modelRefLabel, TRIGGER_TURN } from "./shared/modelRefs.ts";
 import { loadMoaConfig } from "./config/settings.ts";
-import { getPlanFilePath, getRepoPlanDirectory, isValidPlanSlug, readRepoPlanFile, saveRepoPlanFile } from "./planning/planFile.ts";
+import { getPlanFilePath, getRepoPlanDirectory, isApprovedRepoPlanFilename, isValidPlanSlug, readRepoPlanFile, saveRepoPlanFile } from "./planning/planFile.ts";
 import { showImplementingModelPicker } from "./ui/moaModelPicker.ts";
 import { showPlanReview } from "./ui/planReviewOverlay.ts";
 import { showMoaSetup } from "./ui/moaSetupOverlay.ts";
@@ -20,6 +20,7 @@ import { runCriteriaGeneration } from "./moa/verificationCriteria.ts";
 import { stripSynthSections } from "./moa/verdicts.ts";
 import { runInteractiveOpinion, type OpinionHost } from "./opinion/runOpinion.ts";
 import { runInteractiveDebate } from "./debate/runDebate.ts";
+import { createSpecRunner } from "./spec/runSpec.ts";
 import { createPlanModeController } from "./planning/planMode.ts";
 import { registerEnterPlanModeTool, runInteractivePlanMode } from "./planning/tools/enterPlanMode.ts";
 import { registerExitPlanModeTool } from "./planning/tools/exitPlanMode.ts";
@@ -38,6 +39,7 @@ export default function mfPlanExtension(pi: ExtensionAPI): void {
 		setRunningProgressWidget: controller.moaRunHost.setRunningProgressWidget,
 	};
 	const debateHost = opinionHost;
+	const runSpec = createSpecRunner(controller);
 	const togglePlanMode = async (ctx: Parameters<typeof controller.exitPlanMode>[0], prompt?: string): Promise<void> => {
 		if (controller.questionnaireBusy(ctx)) return;
 		if (controller.getActiveCancelSession()?.run) {
@@ -69,12 +71,16 @@ export default function mfPlanExtension(pi: ExtensionAPI): void {
 		description: "Run a read-only multi-round debate between up to 5 models — append a topic (e.g. /mf-debate is X sound?) to skip the editor",
 		handler: async (args, ctx) => { if (controller.questionnaireBusy(ctx)) return; await runInteractiveDebate(pi, debateHost, ctx, args.trim() || undefined); },
 	});
+	pi.registerCommand("mf-spec", {
+		description: "Clarify a rough request into an approved planning brief for /mf-plan — append the request (e.g. /mf-spec add dark mode) to skip the editor",
+		handler: async (args, ctx) => runSpec(ctx, args.trim() || undefined),
+	});
 	pi.registerCommand("mf-plan-clear", {
 		description: "Clear the completed plan state so /mf-plan starts a fresh planning round (approved plans stay in .pi/mf-plan/)",
 		handler: async (_args, ctx) => { if (controller.questionnaireBusy(ctx)) return; await controller.clearCompletedPlan(ctx); },
 	});
 	pi.registerCommand("mf-plan-settings", {
-		description: "Configure the explore and cheap/fast agents, agent rosters for MoA roles, and plan options",
+		description: "Configure the explore and cheap/fast agents, agent rosters for MoA roles, plan options, and max concurrent agents",
 		handler: async (_args, ctx) => {
 			if (controller.questionnaireBusy(ctx)) return;
 			installShippedAgents();
@@ -104,7 +110,7 @@ export default function mfPlanExtension(pi: ExtensionAPI): void {
 					if (fs.existsSync(repoDir)) {
 						const entries = fs.readdirSync(repoDir);
 						planFiles = entries
-							.filter((file) => file.endsWith("__plan.md") && !file.endsWith("__plan-prompt.md"))
+							.filter(isApprovedRepoPlanFilename)
 							.map((file) => {
 								const slug = file.slice(0, -"__plan.md".length);
 								const fullPath = path.join(repoDir, file);
@@ -270,6 +276,10 @@ export default function mfPlanExtension(pi: ExtensionAPI): void {
 	registerMfPlanSubagentTool(pi, controller);
 	registerExitPlanModeTool(pi, controller);
 
+	// Deliberately not context_with_system (pi 0.87.0): its result is sent
+	// verbatim, so a filtering mistake could drop pi's prompt and tool declarations.
+	// Keep injection in before_agent_start, filtering in context, and durable
+	// omissions in agent_before_settle so pi continues to own prompt/tool state.
 	pi.on("context", controller.onContext);
 	pi.on("before_agent_start", controller.onBeforeAgentStart);
 	pi.on("agent_start", controller.onAgentStart);
@@ -277,6 +287,7 @@ export default function mfPlanExtension(pi: ExtensionAPI): void {
 	pi.on("message_update", controller.onMessageUpdate);
 	pi.on("tool_execution_start", controller.onToolExecutionStart);
 	pi.on("message_end", controller.onMessageEnd);
+	pi.on("agent_before_settle", controller.onAgentBeforeSettle);
 	pi.on("agent_settled", controller.onAgentSettled);
 	pi.on("session_start", controller.onSessionStart);
 	pi.on("session_shutdown", controller.onSessionShutdown);

package/src/moa/conflictContract.ts

@@ -24,7 +24,7 @@ export const CONFLICT_CONTRACT_EXAMPLE = [
 	"",
 	"- **Decision:** Choose where sign-in information is stored; this affects both security and how much of the existing sign-in flow can stay unchanged.",
 	"- **Recommended:** Keep the current sign-in experience",
-	"- **Details:** Store session IDs in `Secure`, `HttpOnly` cookies so the existing middleware stays compatible and page scripts cannot read them.",
+	"- **Details:** Store session IDs in `Secure`, `HttpOnly` cookies so the existing middleware stays compatible and page scripts cannot read them; backed by 2 of 3 proposals (2 distinct models).",
 	"- **Alternative** (Proposer 2): Make sign-in data available to browser code",
 	"- **Details:** Store JWTs in `localStorage`; this can simplify cross-service access but lets an injected page script read the token.",
 ].join("\n");
@@ -42,6 +42,7 @@ export function buildConflictContract(labels: string[]): string {
 		"- Exactly one `**Decision:**` line per conflict, placed before its options. Exactly one `**Recommended:**` line per conflict, immediately followed by exactly one `**Details:**` line. One `**Alternative** (Proposer N)` line per other distinct approach worth surfacing, each immediately followed by its own `**Details:**` line.",
 		`- Attribute alternatives only to blinded slot labels already present in your input. Blinded proposer slots in this run: ${labels.join(", ")}. Never invent or rename labels, and never output any model name, family, provider, or version anywhere.`,
 		"- Write each Recommended/Alternative summary as an outcome the person can choose, understandable without code syntax, type names, or file paths; put technical specifics and tradeoffs in `**Details:**`, kept to one line.",
+		"- The `**Recommended:**` pick must be justified on the merits — repo evidence, engineering judgment, or a direct match with the user's request — and a majority of proposers is not by itself a reason, especially when that majority sits inside one same-model cluster named in the Panel dependence note. The recommended option's `**Details:**` line must end with `backed by K of N proposals (M distinct models)`, where K = proposals backing that option, N = proposals received, and M = distinct models among the K (slots in one cluster count once).",
 		"- Supersession rule: if your input contains user conflict resolutions (a \"User reviewed your conflict recommendations\" block) or post-review user feedback, those directives override this requirement — honor every selection, resolve any free-form chat feedback, drop the `## Conflicts` section entirely from your revised output, and emit the complete final plan without it.",
 		"",
 		"Clarifying-question option: only when a disagreement is a genuine ambiguity in user intent that you cannot resolve from the plans alone, output a section titled exactly `## Open Question` containing only that one question, as your ENTIRE output — write nothing else in that reply, and none of the sections above. You will be re-invoked with the user's answer appended. Prefer resolving ambiguities yourself and noting the resolution in the final plan; if your input already contains an answer to an earlier question, incorporate it and do not emit `## Open Question` again.",

package/src/moa/contextContract.ts

@@ -27,7 +27,7 @@ export function buildContextSubsectionsContract(): string {
 		...CONTEXT_SUBSECTION_HEADINGS.map((heading) => `- \`### ${heading}\``),
 		"",
 		"- `### Evaluation dimensions` — reason separately about correctness, completeness, feasibility & effort, risk, and simplicity; never collapse them into one impression.",
-		"- `### Proposer alignment` — where proposers unanimously agreed, what they unanimously rejected, and where they differed, with shared assumptions sanity-checked.",
+		"- `### Proposer alignment` — where proposers unanimously agreed, what they unanimously rejected, and where they differed; tag every unanimous point as evidence-backed (two or more proposers cite a concrete repo location) or asserted (no citation, or all citations identical and unverified); sanity-check every asserted point against the repo with read/grep/find/ls before relying on it, stating what you checked and what you found; note when a unanimous point rests inside a single same-model cluster from the Panel dependence note; treat each same-model cluster as one vote.",
 		"- `### Synthesis decisions` — what you recombined, added, or dropped, and one-line decisions for each disagreement using blinded slot labels.",
 		"",
 		"All MoA reconciliation commentary belongs inside `## Context` — nowhere else. A plan missing any of these three subsections will be rejected and sent back to you. They are required in every full-plan output, including revisions after conflict resolutions or user feedback.",

package/src/moa/fanout.ts

@@ -7,8 +7,10 @@ import { getFinalOutput, isFailedResult } from "../runtime/results.ts";
 import type { ModelParallelAgentTask } from "../runtime/runner.ts";
 import { modelRefLabel, TRIGGER_TURN, type ModelRef, type ThinkingLevel } from "../shared/modelRefs.ts";
 import { activityLoopCount } from "../ui/agentStatus.ts";
+import { showModelThinkingPicker } from "../ui/moaModelPicker.ts";
 import type { MoaProgressWidget } from "../ui/moaProgressWidget.ts";
 import type { ObserveSession } from "../ui/observeOverlay.ts";
+import { duplicateModelSlotCount, proposerDiversityWarning } from "./panelDependence.ts";
 import { runWidgetFanout } from "./fanoutWiring.ts";
 import { buildProposerRetryTask, buildProposerTask, looksLikePlan } from "./planlessRetry.ts";
 import { modelExtensionOptions, resolveContextWindow } from "./modelRuntime.ts";
@@ -29,11 +31,12 @@ export interface FanoutPhaseOptions {
 	widget: MoaProgressWidget;
 	agents: AgentConfig[];
 	warnIfMutated(phase: string): Promise<void>;
+	maxConcurrency: number;
 }
 
 export async function runFanoutPhase(options: FanoutPhaseOptions): Promise<FanoutPhaseResult> {
-	const { host, runContext, ctx, prompt, proposers, proposerThinking, session, widget, agents, warnIfMutated } = options;
-	widget.startFanout(proposers, proposerThinking);
+	const { host, runContext, ctx, prompt, proposers, proposerThinking, session, widget, agents, warnIfMutated, maxConcurrency } = options;
+	widget.startFanout(proposers, proposerThinking, maxConcurrency);
 	const observe: ObserveSession = {
 		title: "MoA fan-out",
 		phase: "fanout",
@@ -64,7 +67,7 @@ export async function runFanoutPhase(options: FanoutPhaseOptions): Promise<Fanou
 		};
 	};
 	const runFanout = (tasks: ModelParallelAgentTask[], indexMap: (index: number) => number, currentRun: CancelRun) =>
-		runWidgetFanout({ ctx, agents, tasks, run: currentRun, session, widget, observe, models: proposers, indexMap });
+		runWidgetFanout({ ctx, agents, tasks, run: currentRun, session, widget, observe, models: proposers, indexMap, maxConcurrency });
 
 	// The planning contract travels inside the task text — the only channel
 	// guaranteed to survive a bridge's system-prompt override. The observer keeps
@@ -89,6 +92,114 @@ export async function runFanoutPhase(options: FanoutPhaseOptions): Promise<Fanou
 		return { status: "cancelled", observe, previousObserveSession };
 	}
 
+	// A proposer cancelled from the cancel overlay must not silently drop out of
+	// the run: the user who killed it decides what replaces it, mirroring the
+	// synthesizer-failure precedent. A slot dropped here stays `cancelled` in
+	// results, so it is already excluded from `succeeded` — "continue without"
+	// needs no other handling. This runs after the cancel-all check and before
+	// the planless-retry pass, so a replacement that returns no plan then gets
+	// that retry for free.
+	const cancelledSlots = results.flatMap((r, i) => r.cancelled ? [i] : []);
+	if (cancelledSlots.length > 0 && ctx.hasUI) {
+		// Stop the stacked overlays and the sticky widget before the modal so the
+		// select/picker are not fighting them. session.run is already undefined
+		// (cleared in runWidgetFanout's finally), so ESC reaches the modal, not a
+		// reopened cancel overlay.
+		session.closeOverlay?.();
+		widget.stopWidget();
+		for (const index of cancelledSlots) {
+			while (true) {
+				const label = modelRefLabel(proposers[index]);
+				const choice = await ctx.ui.select(
+					`Proposer ${index + 1} (${label}) was cancelled — what next?`,
+					["Select a different model", "Continue without this proposer"],
+				);
+				if (choice !== "Select a different model") break;
+				const picked = await showModelThinkingPicker(
+					ctx,
+					host.currentThinkingLevel(),
+					`Replacement for Proposer ${index + 1}`,
+					proposers[index],
+					proposerThinking[index],
+				);
+				if (!picked) continue;
+				// Rewrite the shared phase/synthesis/observe arrays in place: the
+				// same object is held by the widget band, the cost resolution,
+				// synthesis, and the persisted activeRunMoaInfo.
+				proposers[index] = picked.ref;
+				proposerThinking[index] = picked.thinking;
+				host.persistState();
+				if (duplicateModelSlotCount(proposers, picked.ref) >= 2) {
+					const warning = proposerDiversityWarning(proposers);
+					if (warning) ctx.ui.notify(warning, "warning");
+				}
+				widget.replaceProposerModel(index, picked.ref, picked.thinking);
+				// Rewrite the observe row's identity, not just its messages, so F3
+				// shows the replacement and not the cancelled agent's corpse.
+				const observed = observe.agents[index];
+				if (observed) {
+					observed.label = picked.ref.id;
+					observed.model = picked.ref.id;
+					observed.task = proposerTask;
+					observed.messages = [];
+					observed.partial = undefined;
+					observed.state = "working";
+				}
+				const replaceRun = new CancelRun();
+				session.title = "MoA fan-out (replacement)";
+				session.getExtras = () => {
+					const status = widget.getStatus(index);
+					if (!status) return undefined;
+					return {
+						contextTokens: status.contextTokens,
+						contextWindow: resolveContextWindow(ctx, status.ref),
+						activity: status.activity,
+						loopCount: activityLoopCount(status.activity, status.activityHistory),
+					};
+				};
+				// The slot was killed, not planless — rerun the fresh proposer task.
+				const [replacement] = await runFanout(
+					[
+						{
+							agent: "moa-proposer",
+							task: proposerTask,
+							model: modelRefLabel(picked.ref),
+							thinking: picked.thinking,
+							...modelExtensionOptions(ctx, picked.ref),
+							signal: replaceRun.add(modelRefLabel(picked.ref)).signal,
+						},
+					],
+					() => index,
+					replaceRun,
+				);
+				results[index] = replacement;
+				await warnIfMutated("MoA proposer replacement");
+				// Cancel ALL during a replacement ends the run, like the other exits.
+				if (replaceRun.cancelAllRequested) {
+					widget.stopWidget();
+					ctx.ui.notify("MoA run cancelled.");
+					return { status: "cancelled", observe, previousObserveSession };
+				}
+				// A cancelled or planless replacement re-asks the same two options
+				// until the user chooses to move on.
+				if (replacement.cancelled || isFailedResult(replacement)) {
+					session.closeOverlay?.();
+					widget.stopWidget();
+					ctx.ui.notify(
+						`Replacement proposer ${modelRefLabel(picked.ref)} did not produce a plan.`,
+						"warning",
+					);
+					continue;
+				}
+				break;
+			}
+		}
+		// A prompt stopped the widget; re-show the table so the planless-retry pass
+		// and synthesis render into a mounted table even when the user dropped
+		// every cancelled slot.
+		widget.resumeTable();
+	}
+
 	const retryIndices: number[] = [];
 	for (let index = 0; index < results.length; index++) {
 		const result = results[index];
@@ -112,7 +223,7 @@ export async function runFanoutPhase(options: FanoutPhaseOptions): Promise<Fanou
 			const ref = proposers[proposerIndex];
 			const label = modelRefLabel(ref);
 			const retryTask = buildProposerRetryTask(proposerTask, getFinalOutput(results[proposerIndex].messages));
-			widget.update(proposerIndex, "working", "retrying: no plan produced");
+			widget.update(proposerIndex, "queued", "retrying: no plan produced");
 			const observed = observe.agents[proposerIndex];
 			if (observed) {
 				observed.state = "working";

package/src/moa/fanoutWiring.ts

@@ -2,7 +2,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import type { AgentConfig } from "../agents/discovery.ts";
 import type { CancelRun, CancelSession } from "../runtime/cancelRun.ts";
-import { getResultOutput, isFailedResult, type SingleResult } from "../runtime/results.ts";
+import { getResultOutput, isFailedResult, statusDetail, type SingleResult } from "../runtime/results.ts";
 import { runParallelAgentsWithModels, type ModelParallelAgentTask } from "../runtime/runner.ts";
 import type { ModelRef } from "../shared/modelRefs.ts";
 import type { MoaProgressWidget } from "../ui/moaProgressWidget.ts";
@@ -19,6 +19,7 @@ export interface WidgetFanoutOptions {
 	observe: ObserveSession;
 	models: ModelRef[];
 	indexMap: (index: number) => number;
+	maxConcurrency: number;
 }
 
 /**
@@ -27,7 +28,7 @@ export interface WidgetFanoutOptions {
  * settle/onProgress plumbing shared by every MoA fan-out variant.
  */
 export async function runWidgetFanout(options: WidgetFanoutOptions): Promise<SingleResult[]> {
-	const { ctx, agents, tasks, run, session, widget, observe, models, indexMap } = options;
+	const { ctx, agents, tasks, run, session, widget, observe, models, indexMap, maxConcurrency } = options;
 	const unsubscribe = run.onChange(() => {
 		run.agents.forEach((agent, index) => {
 			if (agent.state === "cancelling") widget.update(indexMap(index), "cancelling");
@@ -54,7 +55,7 @@ export async function runWidgetFanout(options: WidgetFanoutOptions): Promise<Sin
 					if (observed) observed.state = "cancelled";
 				} else if (isFailedResult(result)) {
 					run.settle(index, "error");
-					widget.update(widgetIndex, "error", getResultOutput(result).slice(0, 80));
+					widget.update(widgetIndex, "error", statusDetail(getResultOutput(result)));
 					if (observed) observed.state = "error";
 				} else {
 					run.settle(index, "done");
@@ -80,6 +81,15 @@ export async function runWidgetFanout(options: WidgetFanoutOptions): Promise<Sin
 					observed.partial = result.partialAssistant;
 				}
 			},
+			{
+				maxConcurrency,
+				onStart: (index) => {
+					const widgetIndex = indexMap(index);
+					widget.update(widgetIndex, "working");
+					const observed = observe.agents[widgetIndex];
+					if (observed) observed.state = "working";
+				},
+			},
 		);
 	} finally {
 		unsubscribe();

package/src/moa/implementationRetry.ts

@@ -234,7 +234,7 @@ export async function runImplementationRetryFlow(
 
 	if (selection.startsWith("Retry with")) {
 		host.markImplementationPending(ctx);
-		if (handoff.model) host.getActiveProgressWidget()?.switchToImplementing(handoff.model, "retrying implementation…", handoff.thinking);
+		if (handoff.model) host.getActiveProgressWidget()?.switchToImplementing(handoff.model, "retrying implementation", handoff.thinking);
 		const note = failureReason
 			? `The previous implementation attempt failed with: ${failureReason}. Review the current state of the code and continue implementing the approved plan.`
 			: "The previous implementation attempt failed. Review the current state of the code and continue implementing the approved plan.";
@@ -280,7 +280,7 @@ export async function runImplementationRetryFlow(
 				Implement: newSelection.ref,
 				Verify: updatedHandoff.verifier,
 			});
-			widget.switchToImplementing(newSelection.ref, "retrying implementation…", newSelection.thinking);
+			widget.switchToImplementing(newSelection.ref, "retrying implementation", newSelection.thinking);
 		}
 
 		const note = `Switched implementation model to ${modelRefLabel(newSelection.ref)}. Review the current state of the code and continue implementing the approved plan.`;

package/src/moa/orchestration.ts

@@ -1,6 +1,7 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { installShippedAgents, shippedAgentsDir, withAuthoritativeMoaAgents } from "../agents/authoritative.ts";
+import { loadMoaConfig } from "../config/settings.ts";
 import { discoverAgents } from "../agents/discovery.ts";
 import { cleanupProposalFiles, sweepStaleProposalFiles } from "../planning/planFile.ts";
 import type { CancelSession } from "../runtime/cancelRun.ts";
@@ -59,6 +60,7 @@ export async function runMoaOrchestration(
 	try {
 		installShippedAgents();
 		sweepStaleProposalFiles();
+		const maxConcurrency = loadMoaConfig().maxConcurrentAgents;
 		const discovery = discoverAgents(ctx.cwd, "user");
 		const agents = withAuthoritativeMoaAgents(discovery.agents, shippedAgentsDir());
 		const tripwire = new MutationTripwire();
@@ -78,6 +80,7 @@ export async function runMoaOrchestration(
 			widget,
 			agents,
 			warnIfMutated,
+			maxConcurrency,
 		});
 		if (fanout.status !== "continue") return fanout.status;
 		const synthesis = await runSynthesisPhase(runContext, {

package/src/moa/panelDependence.ts

@@ -0,0 +1,87 @@
+/**
+ * Dependence structure for the MoA proposer panel.
+ *
+ * Blinding invariant: nothing derived from a ModelRef (provider, id, label,
+ * family) may appear in synthesizer-facing output — only integers and
+ * proposerBlindedLabel slot numbers. Family-level clusters are excluded
+ * because they risk de-blinding a lopsided roster.
+ */
+
+import { modelRefLabel, proposerBlindedLabel, type ModelRef } from "../shared/modelRefs.ts";
+
+function pluralize(count: number, singular: string, plural = `${singular}s`): string {
+	return count === 1 ? singular : plural;
+}
+
+function formatClusterSentence(slots: number[]): string {
+	const numbers = slots.map((index) => proposerBlindedLabel(index).replace("Proposer ", ""));
+	if (numbers.length === 2) {
+		return `Proposers ${numbers[0]} and ${numbers[1]} share one model.`;
+	}
+	const last = numbers.pop();
+	return `Proposers ${numbers.join(", ")}, and ${last} share one model.`;
+}
+
+/** Blinded one-paragraph note describing panel dependence for the synthesizer. */
+export function buildPanelDependenceNote(fed: readonly { ref: ModelRef; originalIndex: number }[]): string {
+	const proposalCount = fed.length;
+	const clusters = new Map<string, number[]>();
+	const providers = new Set<string>();
+
+	for (const { ref, originalIndex } of fed) {
+		providers.add(ref.provider);
+		const key = modelRefLabel(ref);
+		const slots = clusters.get(key);
+		if (slots) slots.push(originalIndex);
+		else clusters.set(key, [originalIndex]);
+	}
+
+	const distinctModels = clusters.size;
+	const distinctProviders = providers.size;
+
+	const countsLine = [
+		`Panel dependence: ${proposalCount} ${pluralize(proposalCount, "proposal")}`,
+		`from ${distinctModels} distinct ${pluralize(distinctModels, "model")}`,
+		`across ${distinctProviders} ${pluralize(distinctProviders, "provider")}.`,
+	].join(" ");
+
+	const clusterSentences = [...clusters.values()]
+		.filter((slots) => slots.length >= 2)
+		.sort((a, b) => a[0] - b[0])
+		.map((slots) => formatClusterSentence([...slots].sort((a, b) => a - b)));
+
+	const caveat = "Every proposer ran from the same prompt template, so even distinct models are not fully independent; treat agreement inside a same-model cluster as one vote, not as separate confirmation.";
+
+	return [countsLine, ...clusterSentences, caveat].join(" ");
+}
+
+function duplicateModelSlotTotal(refs: readonly ModelRef[]): number {
+	const labelCounts = new Map<string, number>();
+	for (const ref of refs) {
+		const label = modelRefLabel(ref);
+		labelCounts.set(label, (labelCounts.get(label) ?? 0) + 1);
+	}
+	let total = 0;
+	for (const count of labelCounts.values()) {
+		if (count >= 2) total += count;
+	}
+	return total;
+}
+
+/** Non-blocking warning for the pre-flight picker or replacement notify. */
+export function proposerDiversityWarning(refs: readonly ModelRef[]): string | undefined {
+	const duplicateTotal = duplicateModelSlotTotal(refs);
+	if (duplicateTotal >= 2) {
+		return `${duplicateTotal} proposer slots share a model; agreement between them is not independent evidence.`;
+	}
+	if (refs.length >= 2 && new Set(refs.map((ref) => ref.provider)).size === 1) {
+		return `All ${refs.length} proposer slots share one provider; agreement between them is not independent evidence.`;
+	}
+	return undefined;
+}
+
+/** Slots in `refs` whose model matches `ref` (including `ref`'s own slot). */
+export function duplicateModelSlotCount(refs: readonly ModelRef[], ref: ModelRef): number {
+	const target = modelRefLabel(ref);
+	return refs.reduce((count, candidate) => count + (modelRefLabel(candidate) === target ? 1 : 0), 0);
+}

package/src/moa/reviewLoop.ts

@@ -73,7 +73,7 @@ export async function runReviewLoop(options: ReviewLoopOptions): Promise<"done">
 			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.`);
 			rebuildSynthTask();
-			widget.switchToSynthesizing(getSynthesizer(), "synthesizing plan…", getSynthesizerThinking());
+			widget.switchToSynthesizing(getSynthesizer(), "synthesizing plan", getSynthesizerThinking());
 			const synthRound = await runSynthWithRecovery(getSynthTask());
 			widget.stopWidget();
 			await warnIfMutated("MoA synthesis");
@@ -156,7 +156,7 @@ export async function runReviewLoop(options: ReviewLoopOptions): Promise<"done">
 					Implement: handoff.model,
 					Verify: roles?.verifier,
 				});
-				widget.switchToImplementing(handoff.model, "implementing plan…", handoff.thinking);
+				widget.switchToImplementing(handoff.model, "implementing plan", handoff.thinking);
 				host.adoptProgressWidget(widget);
 			}
 			host.markImplementationPending(ctx);

package/src/moa/synthesis.ts

@@ -18,6 +18,7 @@ import { buildContextRetryHeader, buildContextSubsectionsContract, missingContex
 import { modelExtensionOptions, resolveContextWindow, resolveModelCost } from "./modelRuntime.ts";
 import { runCriteriaGeneration } from "./verificationCriteria.ts";
 import type { MoaRunContext, ReviewLoopOptions, SucceededProposal } from "./runContext.ts";
+import { buildPanelDependenceNote } from "./panelDependence.ts";
 import { buildVerdictContract, buildVerdictRetryHeader, missingVerdictSlots, parseProposerVerdicts, stripSynthSections } from "./verdicts.ts";
 
 export interface SynthesisPhaseOptions {
@@ -40,7 +41,7 @@ export async function runSynthesisPhase(
 ): Promise<SynthesisPhaseResult> {
 	const { host, session, widget } = runContext;
 	const { ctx, prompt, proposers, succeeded, observe, agents, warnIfMutated } = options;
-	widget.switchToSynthesizing(runContext.synthesizer, "adjudicating proposed plans…", runContext.synthesizerThinking);
+	widget.switchToSynthesizing(runContext.synthesizer, "adjudicating proposed plans", runContext.synthesizerThinking);
 
 	// Proposals are both inlined and staged on disk. Inlining is what
 	// guarantees the synthesizer actually weighs every proposal — behind a
@@ -71,7 +72,10 @@ export async function runSynthesisPhase(
 	// reason: a bridged synthesizer that loses the agent prompt never learns
 	// the ## Conflicts markup and silently resolves every disagreement solo.
 	const fedLabels = succeeded.map(({ originalIndex }) => proposerBlindedLabel(originalIndex));
-	const baseSynthTask = `${SYNTHESIZER_TASK_PREAMBLE}\n\nOriginal user request:\n${prompt}\n\n---\n\nIndependent proposer plans:\n\n${proposals}\n\n---\n\n${buildVerdictContract(fedLabels)}\n\n---\n\n${buildContextSubsectionsContract()}\n\n---\n\n${buildConflictContract(fedLabels)}`;
+	// Correlated-judge guard: the note exposes dependence structure (counts and
+	// same-model clusters) without unblinding — only slot numbers and integers.
+	const dependenceNote = buildPanelDependenceNote(succeeded);
+	const baseSynthTask = `${SYNTHESIZER_TASK_PREAMBLE}\n\nOriginal user request:\n${prompt}\n\n---\n\n${dependenceNote}\n\nIndependent proposer plans:\n\n${proposals}\n\n---\n\n${buildVerdictContract(fedLabels)}\n\n---\n\n${buildContextSubsectionsContract()}\n\n---\n\n${buildConflictContract(fedLabels)}`;
 	const rebuildSynthTask = () => {
 		synthTask = [baseSynthTask, ...runContext.synthConversation.slice(-2)].join("\n\n---\n\n");
 	};
@@ -162,7 +166,7 @@ export async function runSynthesisPhase(
 			widget.stopWidget();
 			const action = await resolveSynthesizerFailure(getResultOutput(round.result));
 			if (action === "abandon") break;
-			widget.switchToSynthesizing(runContext.synthesizer, action === "switch" ? "retrying with a new model…" : "retrying…", runContext.synthesizerThinking);
+			widget.switchToSynthesizing(runContext.synthesizer, action === "switch" ? "retrying with a new model" : "retrying", runContext.synthesizerThinking);
 			round = await runSynthesizerRound(task);
 		}
 		return round;
@@ -237,7 +241,7 @@ export async function runSynthesisPhase(
 			}
 			runContext.synthConversation.push(`Synthesizer asked: ${question}\nUser answered: ${answer.trim()}\n\nNow produce the full plan.`);
 			rebuildSynthTask();
-			widget.switchToSynthesizing(runContext.synthesizer, "adjudicating proposed plans…", runContext.synthesizerThinking);
+			widget.switchToSynthesizing(runContext.synthesizer, "adjudicating proposed plans", runContext.synthesizerThinking);
 			continue;
 		}
 
@@ -251,7 +255,7 @@ export async function runSynthesisPhase(
 			const synthRetryCorr = buildRetryCorrection(SYNTHESIZER_RETRY_HEADER, synthOutput);
 			runContext.synthConversation.push(synthRetryCorr);
 			rebuildSynthTask();
-			widget.switchToSynthesizing(runContext.synthesizer, "retrying: no plan produced…", runContext.synthesizerThinking);
+			widget.switchToSynthesizing(runContext.synthesizer, "retrying: no plan produced", runContext.synthesizerThinking);
 			continue;
 		}
 
@@ -268,7 +272,7 @@ export async function runSynthesisPhase(
 			const verdictRetryCorr = buildRetryCorrection(buildVerdictRetryHeader(missingVerdicts), synthOutput);
 			runContext.synthConversation.push(verdictRetryCorr);
 			rebuildSynthTask();
-			widget.switchToSynthesizing(runContext.synthesizer, "retrying: missing proposer verdicts…", runContext.synthesizerThinking);
+			widget.switchToSynthesizing(runContext.synthesizer, "retrying: missing proposer verdicts", runContext.synthesizerThinking);
 			continue;
 		}
 
@@ -283,7 +287,7 @@ export async function runSynthesisPhase(
 			const contextRetryCorr = buildRetryCorrection(buildContextRetryHeader(missingContext), synthOutput);
 			runContext.synthConversation.push(contextRetryCorr);
 			rebuildSynthTask();
-			widget.switchToSynthesizing(runContext.synthesizer, "retrying: missing context sections…", runContext.synthesizerThinking);
+			widget.switchToSynthesizing(runContext.synthesizer, "retrying: missing context sections", runContext.synthesizerThinking);
 			continue;
 		}
 		if (!questionMatch && missingContext.length === 0) contextSubsectionsSeen = true;
@@ -341,7 +345,7 @@ export async function runSynthesisPhase(
 
 				runContext.synthConversation.push(feedback);
 				rebuildSynthTask();
-				widget.switchToSynthesizing(runContext.synthesizer, "synthesizing plan…", runContext.synthesizerThinking);
+				widget.switchToSynthesizing(runContext.synthesizer, "synthesizing plan", runContext.synthesizerThinking);
 				if (isLastRound) {
 					const finalRound = await runSynthWithRecovery(synthTask);
 					if (finalRound.cancelled) {