@underactive/pi-topping-moa-fusion 0.1.0

package/src/debate/debateContract.ts

@@ -0,0 +1,89 @@
+import { buildRetryCorrection } from "../moa/planlessRetry.ts";
+
+export const DEBATE_TASK_PREAMBLE =
+	"You are a read-only DEBATER in a multi-round debate between several models. Your output is shown verbatim to the user and reaches your peer debaters — there is no judge, and no agent will merge or verify anything — so argue to convince your peers. You may keep or change your stance in any round. Do not implement anything, edit files, or run commands, builds, or tests; read-only tools are expected and never a blocker. You are running headless: resolve open questions with stated assumptions rather than asking the user or waiting. The required output sections (including the `## Position` argument and the `## Stance` declaration with its `**Stance:**` value) are spelled out in the agent instructions.";
+
+/** Matches the required position argument heading, tolerating renamed sections. */
+export const DEBATE_POSITION_HEADING = /^#{1,6}\s.*\b(position)\b/im;
+
+/** Matches the stance declaration, e.g. `**Stance:** kept`. */
+export const DEBATE_STANCE_LINE = /\*\*Stance:\*\*\s*(initial|kept|switched|refined)/i;
+
+export function looksLikeDebatePosition(output: string): boolean {
+	return DEBATE_POSITION_HEADING.test(output) && DEBATE_STANCE_LINE.test(output);
+}
+
+export type DebateStance = "initial" | "kept" | "switched" | "refined" | "unknown";
+
+export interface ParsedStance {
+	stance: DebateStance;
+	/** Raw `Debater N` value from the `**Sides with:**` line, when present. */
+	sidesWith: string | undefined;
+}
+
+export function parseStance(output: string): ParsedStance {
+	const stanceMatch = output.match(DEBATE_STANCE_LINE);
+	const sidesMatch = output.match(/\*\*Sides with:\*\*\s*(.+)/i);
+	const stance = (stanceMatch?.[1]?.toLowerCase() ?? "unknown") as DebateStance;
+	const sidesWith = sidesMatch?.[1]?.trim();
+	return { stance, sidesWith: sidesWith && sidesWith.length > 0 ? sidesWith : undefined };
+}
+
+/** Anonymous slot label — debaters never see each other's real model names. */
+export function debaterLabel(index: number): string {
+	return `Debater ${index + 1}`;
+}
+
+/** Per-prior cap so five priors of long positions stay well under the runner's task-size warning. */
+const MAX_PRIOR_CHARS = 16_000;
+
+function quotePrior(text: string): string {
+	const trimmed = text.trim();
+	const prior = trimmed.length > MAX_PRIOR_CHARS
+		? `${trimmed.slice(0, MAX_PRIOR_CHARS)}\n[prior position truncated]`
+		: trimmed;
+	return `"""\n${prior.replaceAll('"""', "''")}\n"""`;
+}
+
+export function buildOpeningTask(topic: string, index: number, totalDebaters: number): string {
+	return [
+		DEBATE_TASK_PREAMBLE,
+		"",
+		`Topic: ${topic}`,
+		`You are ${debaterLabel(index)} of ${totalDebaters} debaters. This is round 1: no other debater has spoken yet, so form your own independent, repo-grounded position.`,
+	].join("\n");
+}
+
+export function buildRoundTask(
+	topic: string,
+	index: number,
+	round: number,
+	totalRounds: number,
+	ownPrior: string,
+	others: { label: string; text: string }[],
+): string {
+	const parts = [
+		DEBATE_TASK_PREAMBLE,
+		"",
+		`Topic: ${topic}`,
+		`You are ${debaterLabel(index)}. This is round ${round} of ${totalRounds}.`,
+		"",
+		`Your prior position (round ${round - 1}):`,
+		quotePrior(ownPrior),
+	];
+	for (const other of others) {
+		parts.push("", `${other.label} (round ${round - 1}):`, quotePrior(other.text));
+	}
+	parts.push(
+		"",
+		"Respond to every other debater's position, revise your argument as warranted, and declare your stance explicitly. You may keep or change your stance.",
+	);
+	return parts.join("\n");
+}
+
+export const DEBATE_RETRY_HEADER =
+	"IMPORTANT: You already attempted this debate task once and stopped without emitting a complete position. You are running headless: do not ask questions, wait for clarification, or refuse because only read-only tools are available. Re-emit the COMPLETE position now, including the required `## Position` argument and the `## Stance` declaration with its `**Stance:**` value.";
+
+export function buildDebateRetryTask(originalTask: string, previousOutput: string): string {
+	return [originalTask, "", "---", "", buildRetryCorrection(DEBATE_RETRY_HEADER, previousOutput)].join("\n");
+}

package/src/debate/debateFanout.ts

@@ -0,0 +1,285 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import type { AgentConfig } from "../agents/discovery.ts";
+import { modelExtensionOptions, resolveContextWindow, resolveModelCost } from "../moa/modelRuntime.ts";
+import type { CancelSession } from "../runtime/cancelRun.ts";
+import { CancelRun } from "../runtime/cancelRun.ts";
+import { getFinalOutput, getResultOutput, isFailedResult, type SingleResult } from "../runtime/results.ts";
+import { runParallelAgentsWithModels, type ModelParallelAgentTask } from "../runtime/runner.ts";
+import { modelRefLabel, type ModelRef, type ThinkingLevel } from "../shared/modelRefs.ts";
+import { activityLoopCount } from "../ui/agentStatus.ts";
+import type { MoaProgressWidget } from "../ui/moaProgressWidget.ts";
+import type { ObserveSession } from "../ui/observeOverlay.ts";
+import {
+	buildDebateRetryTask,
+	buildOpeningTask,
+	looksLikeDebatePosition,
+	parseStance,
+} from "./debateContract.ts";
+import type { DebateRound } from "./debateRounds.ts";
+import { buildNextRoundInputs, shouldStopEarly } from "./debateRounds.ts";
+
+export interface DebateFanoutHost {
+	getActiveObserveSession(): ObserveSession | undefined;
+	setActiveObserveSession(session: ObserveSession | undefined): void;
+}
+
+export interface DebateFanoutOptions {
+	host: DebateFanoutHost;
+	ctx: ExtensionContext;
+	topic: string;
+	models: ModelRef[];
+	thinking: (ThinkingLevel | undefined)[];
+	rounds: number;
+	session: CancelSession;
+	widget: MoaProgressWidget;
+	agents: AgentConfig[];
+}
+
+export type DebateFanoutResult =
+	| { status: "done"; rounds: DebateRound[]; stoppedEarly?: string }
+	| { status: "cancelled" };
+
+interface CumulativeUsage {
+	turns: number;
+	toolCalls: number;
+	costUsd: number | undefined;
+}
+
+/**
+ * Runs the debate's round loop: every round, each surviving debater gets a
+ * fresh subprocess fed every other survivor's labeled prior position. Each
+ * round's subprocess replaces the widget row, so TURNS/TOOLS/COST readings
+ * accumulate across rounds per slot.
+ */
+export async function runDebateRounds(options: DebateFanoutOptions): Promise<DebateFanoutResult> {
+	const { host, ctx, topic, models, thinking, rounds: totalRounds, session, widget, agents } = options;
+	const alive = models.map(() => true);
+	const positions: (string | undefined)[] = models.map(() => undefined);
+	const completedRounds: DebateRound[] = [];
+	const cumulative: CumulativeUsage[] = models.map(() => ({ turns: 0, toolCalls: 0, costUsd: undefined }));
+
+	const observe: ObserveSession = {
+		title: "MoA debate",
+		phase: "fanout",
+		agents: models.map((ref) => ({
+			label: ref.id,
+			model: ref.id,
+			task: "",
+			messages: [],
+			state: "working",
+		})),
+		overlayOpen: false,
+	};
+	const previousObserveSession = host.getActiveObserveSession();
+	host.setActiveObserveSession(observe);
+
+	try {
+		const runBatch = async (
+			entries: { index: number; task: string }[],
+			currentRun: CancelRun,
+		): Promise<SingleResult[]> => {
+			const unsubscribe = currentRun.onChange(() => {
+				currentRun.agents.forEach((agent, batchIndex) => {
+					if (agent.state === "cancelling") widget.update(entries[batchIndex].index, "cancelling");
+				});
+			});
+			session.run = currentRun;
+			try {
+				const tasks: ModelParallelAgentTask[] = entries.map((entry) => {
+					const ref = models[entry.index];
+					return {
+						agent: "moa-debater",
+						task: entry.task,
+						model: modelRefLabel(ref),
+						thinking: thinking[entry.index],
+						...modelExtensionOptions(ctx, ref),
+						signal: currentRun.add(modelRefLabel(ref)).signal,
+					};
+				});
+				return await runParallelAgentsWithModels(
+					ctx.cwd,
+					agents,
+					tasks,
+					undefined,
+					(batchIndex, result) => {
+						const debateIndex = entries[batchIndex].index;
+						widget.updateTranscript(debateIndex, result.messages);
+						const observed = observe.agents[debateIndex];
+						if (observed) {
+							observed.messages = result.messages;
+							observed.partial = undefined;
+						}
+						if (result.cancelled) {
+							currentRun.settle(batchIndex, "cancelled");
+							widget.update(debateIndex, "cancelled");
+							if (observed) observed.state = "cancelled";
+						} else if (isFailedResult(result)) {
+							currentRun.settle(batchIndex, "error");
+							widget.update(debateIndex, "error", getResultOutput(result).slice(0, 80));
+							if (observed) observed.state = "error";
+						} else {
+							currentRun.settle(batchIndex, "done");
+							widget.update(debateIndex, "done");
+							if (observed) observed.state = "done";
+						}
+					},
+					(batchIndex, result) => {
+						const debateIndex = entries[batchIndex].index;
+						const base = cumulative[debateIndex];
+						const roundCost = resolveModelCost(ctx, models[debateIndex], result.usage);
+						widget.updateUsage(
+							debateIndex,
+							result.usage.contextTokens,
+							base.turns + result.usage.turns,
+							base.toolCalls + result.usage.toolCalls,
+							base.costUsd === undefined && roundCost === undefined
+								? undefined
+								: (base.costUsd ?? 0) + (roundCost ?? 0),
+						);
+						if (result.activity) widget.updateActivity(debateIndex, result.activity);
+						if (result.outputActivity) widget.updateOutput(debateIndex, result.outputActivity.tokens, result.outputActivity.revision);
+						widget.updateTranscript(debateIndex, result.messages, result.partialAssistant);
+						const observed = observe.agents[debateIndex];
+						if (observed) {
+							observed.messages = result.messages;
+							observed.partial = result.partialAssistant;
+						}
+					},
+				);
+			} finally {
+				unsubscribe();
+				session.run = undefined;
+			}
+		};
+
+		const makeGetExtras = (entries: { index: number }[]) => (batchIndex: number) => {
+			const debateIndex = entries[batchIndex].index;
+			const status = widget.getStatus(debateIndex);
+			if (!status) return undefined;
+			return {
+				contextTokens: status.contextTokens,
+				contextWindow: resolveContextWindow(ctx, status.ref),
+				activity: status.activity,
+				loopCount: activityLoopCount(status.activity, status.activityHistory),
+			};
+		};
+
+		const foldUsage = (entries: { index: number }[], results: SingleResult[]): void => {
+			for (let batchIndex = 0; batchIndex < results.length; batchIndex++) {
+				const debateIndex = entries[batchIndex].index;
+				const base = cumulative[debateIndex];
+				const usage = results[batchIndex].usage;
+				const cost = resolveModelCost(ctx, models[debateIndex], usage);
+				cumulative[debateIndex] = {
+					turns: base.turns + usage.turns,
+					toolCalls: base.toolCalls + usage.toolCalls,
+					costUsd: base.costUsd === undefined && cost === undefined ? undefined : (base.costUsd ?? 0) + (cost ?? 0),
+				};
+			}
+		};
+
+		widget.startFanout(models, thinking);
+
+		let stoppedEarly: string | undefined;
+		for (let round = 1; round <= totalRounds; round++) {
+			const entries: { index: number; task: string }[] = round === 1
+				? models.map((_, index) => ({
+					index,
+					task: buildOpeningTask(topic, index, models.length),
+				}))
+				: buildNextRoundInputs(topic, completedRounds[completedRounds.length - 1], round, totalRounds);
+
+			if (round > 1) {
+				for (const entry of entries) {
+					// Re-activates the settled row and resets its transcript.
+					widget.update(entry.index, "working", `round ${round}/${totalRounds} · responding`);
+					const observed = observe.agents[entry.index];
+					if (observed) {
+						observed.state = "working";
+						observed.task = entry.task;
+					}
+				}
+			} else {
+				for (const entry of entries) observe.agents[entry.index].task = entry.task;
+			}
+
+			const run = new CancelRun();
+			session.title = `Debate agents — round ${round}/${totalRounds}`;
+			session.getExtras = makeGetExtras(entries);
+			let results = await runBatch(entries, run);
+			if (run.cancelAllRequested) return { status: "cancelled" };
+
+			// One-shot retry for survivors whose output lacks the position/stance contract.
+			const retryEntries: { index: number; task: string }[] = [];
+			const retriedEntries: { index: number }[] = [];
+			const retriedResults: SingleResult[] = [];
+			for (let batchIndex = 0; batchIndex < results.length; batchIndex++) {
+				const result = results[batchIndex];
+				if (result.cancelled || isFailedResult(result)) continue;
+				if (looksLikeDebatePosition(getFinalOutput(result.messages))) continue;
+				const entry = entries[batchIndex];
+				retryEntries.push({
+					index: entry.index,
+					task: buildDebateRetryTask(entry.task, getFinalOutput(result.messages)),
+				});
+				retriedEntries.push(entry);
+				retriedResults.push(result);
+			}
+			if (retryEntries.length > 0) {
+				// The first attempt genuinely spent tokens; fold it in before the retry overwrites it.
+				foldUsage(retriedEntries, retriedResults);
+				const retryRun = new CancelRun();
+				session.title = `Debate agents — round ${round}/${totalRounds} (retry)`;
+				session.getExtras = makeGetExtras(retryEntries);
+				for (const entry of retryEntries) {
+					widget.update(entry.index, "working", "retrying: no position produced");
+					const observed = observe.agents[entry.index];
+					if (observed) {
+						observed.state = "working";
+						observed.task = entry.task;
+					}
+				}
+				const retryResults = await runBatch(retryEntries, retryRun);
+				for (let batchIndex = 0; batchIndex < retryResults.length; batchIndex++) {
+					const slot = entries.findIndex((entry) => entry.index === retryEntries[batchIndex].index);
+					results[slot] = retryResults[batchIndex];
+				}
+				if (retryRun.cancelAllRequested) return { status: "cancelled" };
+			}
+
+			foldUsage(entries, results);
+
+			const outcomes = entries
+				.map((entry, batchIndex) => ({ entry, result: results[batchIndex] }))
+				.sort((a, b) => a.entry.index - b.entry.index)
+				.map(({ entry, result }) => {
+					if (result.cancelled) {
+						alive[entry.index] = false;
+						return { index: entry.index, status: "cancelled" as const, text: getResultOutput(result) };
+					}
+					if (isFailedResult(result)) {
+						alive[entry.index] = false;
+						return { index: entry.index, status: "error" as const, text: getResultOutput(result) };
+					}
+					const text = getFinalOutput(result.messages).trim() || "(no output)";
+					positions[entry.index] = text;
+					return { index: entry.index, status: "done" as const, text, stance: parseStance(text) };
+				});
+
+			const roundRecord: DebateRound = { round, outcomes };
+			completedRounds.push(roundRecord);
+
+			const stop = shouldStopEarly(roundRecord);
+			if (stop.stop) {
+				stoppedEarly = stop.reason;
+				break;
+			}
+		}
+
+		return { status: "done", rounds: completedRounds, stoppedEarly };
+	} finally {
+		observe.closeOverlay?.();
+		host.setActiveObserveSession(previousObserveSession);
+	}
+}

package/src/debate/debateFile.ts

@@ -0,0 +1,38 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+import { isValidPlanSlug } from "../planning/planFile.ts";
+
+export type RepoDebateFileKind = "debate-prompt" | "debate";
+
+function repoDebateSuffix(kind: RepoDebateFileKind): string {
+	return kind === "debate-prompt" ? "__debate-prompt" : "__debate";
+}
+
+export function getRepoDebateDirectory(repoCwd: string): string {
+	const debateDir = path.join(repoCwd, CONFIG_DIR_NAME, "mf-debate");
+	try {
+		fs.mkdirSync(debateDir, { recursive: true });
+	} catch {
+		// Best effort; the write will report a useful error if this failed.
+	}
+	return debateDir;
+}
+
+export function saveRepoDebateFile(
+	content: string,
+	repoCwd: string,
+	baseSlug: string,
+	kind: RepoDebateFileKind,
+): string {
+	if (!isValidPlanSlug(baseSlug)) throw new Error("Invalid repository debate slug");
+	const debateDir = getRepoDebateDirectory(repoCwd);
+	const filePath = path.join(debateDir, `${baseSlug}${repoDebateSuffix(kind)}.md`);
+	fs.writeFileSync(filePath, content, { encoding: "utf-8" });
+	return filePath;
+}
+
+export function repoDebateDisplayPath(baseSlug: string, kind: RepoDebateFileKind): string {
+	if (!isValidPlanSlug(baseSlug)) throw new Error("Invalid repository debate slug");
+	return `${CONFIG_DIR_NAME}/mf-debate/${baseSlug}${repoDebateSuffix(kind)}.md`;
+}

package/src/debate/debateResults.ts

@@ -0,0 +1,115 @@
+import type { ModelRef, ThinkingLevel } from "../shared/modelRefs.ts";
+import { modelRefLabel } from "../shared/modelRefs.ts";
+import { debaterLabel, type ParsedStance } from "./debateContract.ts";
+import { demoteHeadings } from "../opinion/opinionResults.ts";
+import type { DebateRound } from "./debateRounds.ts";
+import { parseStance } from "./debateContract.ts";
+
+export interface DebateOutcome {
+	ref: ModelRef;
+	thinking: ThinkingLevel | undefined;
+	/** State at debate close: still standing, or how it left. */
+	finalStatus: "active-at-close" | "error" | "cancelled";
+	finalStance?: ParsedStance;
+	/** Last round this debater produced output, 0 if never. */
+	lastRoundActive: number;
+}
+
+export function collectDebateOutcomes(
+	models: ModelRef[],
+	thinking: (ThinkingLevel | undefined)[],
+	rounds: DebateRound[],
+): DebateOutcome[] {
+	return models.map((ref, index) => {
+		let finalStatus: DebateOutcome["finalStatus"] = "active-at-close";
+		let lastRoundActive = 0;
+		let finalStance: ParsedStance | undefined;
+		for (const round of rounds) {
+			const outcome = round.outcomes.find((entry) => entry.index === index);
+			if (!outcome) continue;
+			if (outcome.status === "done") {
+				lastRoundActive = round.round;
+				finalStance = outcome.stance;
+			} else {
+				finalStatus = outcome.status;
+			}
+		}
+		return { ref, thinking: thinking[index], finalStatus, finalStance, lastRoundActive };
+	});
+}
+
+function firstLine(text: string): string {
+	return text.trim().split(/\r?\n/, 1)[0] || "Unknown error";
+}
+
+function extractPositionParagraph(output: string): string {
+	const match = output.match(/^#{1,6}\s.*\bposition\b.*$/im);
+	if (!match || match.index === undefined) return output.trim();
+	const rest = output.slice(match.index + match[0].length);
+	const nextHeading = rest.search(/^#{1,6}\s/m);
+	return (nextHeading >= 0 ? rest.slice(0, nextHeading) : rest).trim();
+}
+
+const STANCE_LABELS: Record<string, string> = {
+	initial: "initial position",
+	kept: "kept position",
+	switched: "switched stance",
+	refined: "refined position",
+};
+
+export function formatDebateMarkdown(
+	topic: string,
+	outcomes: DebateOutcome[],
+	rounds: DebateRound[],
+	slug: string,
+	closingReason: string | undefined,
+	totalRoundsRequested: number,
+): string {
+	const roster = outcomes.map((outcome, index) => {
+		const thinking = outcome.thinking ?? "default";
+		return `${debaterLabel(index)} = ${modelRefLabel(outcome.ref)} (thinking: ${thinking})`;
+	}).join(" · ");
+
+	const roundSections = rounds.map((round) => {
+		const contributions = round.outcomes.map((outcome) => {
+			const label = debaterLabel(outcome.index);
+			const ref = outcomes[outcome.index]?.ref;
+			const thinking = outcomes[outcome.index]?.thinking ?? "default";
+			const heading = `### ${label} — ${ref ? modelRefLabel(ref) : "unknown"} (thinking: ${thinking})`;
+			if (outcome.status === "cancelled") return `${heading}\n\n_Cancelled by user._`;
+			if (outcome.status === "error") return `${heading}\n\n_Failed: ${firstLine(outcome.text)}_`;
+			return `${heading}\n\n${demoteHeadings(outcome.text)}`;
+		});
+		return [`## Round ${round.round}`, contributions.join("\n\n")].join("\n\n");
+	});
+
+	const finalPositions = outcomes
+		.map((outcome, index) => {
+			if (outcome.finalStatus !== "active-at-close" || outcome.lastRoundActive === 0) return undefined;
+			const prior = rounds[outcome.lastRoundActive - 1]?.outcomes.find((entry) => entry.index === index);
+			if (!prior || prior.status !== "done") return undefined;
+			const label = debaterLabel(index);
+			const stance = outcome.finalStance?.stance ?? parseStance(prior.text).stance;
+			const stanceLabel = STANCE_LABELS[stance] ?? stance;
+			const position = extractPositionParagraph(prior.text);
+			return `- **${label}** (${stanceLabel}): ${position}`;
+		})
+		.filter((line) => line !== undefined);
+
+	const closedLine = closingReason
+		? `Closed early after ${rounds.length} of ${totalRoundsRequested} rounds — ${closingReason}`
+		: `Completed all ${totalRoundsRequested} rounds`;
+
+	const parts = [
+		`# MoA Debate — ${slug}`,
+		"",
+		`**Topic:** ${topic}`,
+		"",
+		`**Roster:** ${roster}`,
+		"",
+		`**Closed:** ${closedLine} · no judge — positions below are the debaters' own`,
+		roundSections.join("\n\n"),
+	];
+	if (finalPositions.length > 0) parts.push("", "## Final Positions", finalPositions.join("\n"));
+	return parts.join("\n").trimEnd();
+}

package/src/debate/debateRounds.ts

@@ -0,0 +1,61 @@
+import { buildRoundTask, parseStance, type ParsedStance } from "./debateContract.ts";
+
+/** What one debater produced (or failed to produce) in one round. */
+export interface DebaterRoundOutcome {
+	index: number;
+	status: "done" | "error" | "cancelled";
+	text: string;
+	stance?: ParsedStance;
+}
+
+export interface DebateRound {
+	round: number;
+	outcomes: DebaterRoundOutcome[];
+}
+
+/** Slots whose last round completed — the only ones carried into the next round. */
+export function survivingIndices(round: DebateRound): number[] {
+	return round.outcomes.filter((outcome) => outcome.status === "done").map((outcome) => outcome.index);
+}
+
+/**
+ * Stop conditions checked after every round: fewer than two survivors means
+ * no debate is possible, and (from round 2 on, since nobody has moved yet in
+ * round 1) a unanimous "kept" round means nobody moved.
+ */
+export function shouldStopEarly(round: DebateRound): { stop: boolean; reason?: string } {
+	const survivors = round.outcomes.filter((outcome) => outcome.status === "done");
+	if (survivors.length < 2) return { stop: true, reason: "fewer than two debaters remain" };
+	if (round.round >= 2 && survivors.every((outcome) => outcome.stance?.stance === "kept")) {
+		return { stop: true, reason: "all debaters held their positions" };
+	}
+	return { stop: false };
+}
+
+/**
+ * Per-survivor task text for the next round: each survivor receives its own
+ * prior plus every other survivor's labeled text. Settled (errored/cancelled)
+ * agents that never produced text contribute nothing.
+ */
+export function buildNextRoundInputs(
+	topic: string,
+	previousRound: DebateRound,
+	round: number,
+	totalRounds: number,
+): { index: number; task: string }[] {
+	const survivors = survivingIndices(previousRound);
+	const priorOf = new Map<number, string>();
+	for (const outcome of previousRound.outcomes) {
+		if (outcome.status === "done" && outcome.text.trim().length > 0) priorOf.set(outcome.index, outcome.text);
+	}
+	return survivors.map((index) => {
+		const ownPrior = priorOf.get(index) ?? "";
+		const others = survivors
+			.filter((other) => other !== index)
+			.filter((other) => priorOf.has(other))
+			.map((other) => ({ label: `Debater ${other + 1}`, text: priorOf.get(other)! }));
+		return { index, task: buildRoundTask(topic, index, round, totalRounds, ownPrior, others) };
+	});
+}
+
+export { parseStance };