feat(tournament): per-contestant model selection via --models

The headline use of a tournament is settling which model actually wins on
your codebase, not just which of N identical runs got lucky. --models
a,b,c races one contestant per model id (same provider/proxy as the
parent), and the picker + live status show each contestant's model.

Author: halfaipg

CLAUDE.md

@@ -277,7 +277,10 @@ the available types.
 ## Tournaments (`/tournament`)
 
 `/tournament [n] <task>` (default n=3, max 5) races N agents on the same
-build task and lets you merge the winner. Called mid-build: it snapshots
+build task and lets you merge the winner. `--models opus,sonnet,haiku
+<task>` instead runs one contestant per model id (same provider/proxy as
+the parent, via per-agent model id-cloning) — race models head-to-head on
+your actual codebase. Called mid-build: it snapshots
 the **working tree** — tracked + untracked, via a scratch index so your
 real index is untouched (`src/agent/wip-snapshot.ts`) — and branches
 every contestant from that, so in-progress work is preserved. Each

src/commands/builtins/tournament.test.ts

@@ -4,14 +4,16 @@ import { tournament } from "./tournament.js";
 
 function makeCtx(withRunner: boolean): {
 	ctx: CommandContext;
-	calls: { task: string; count: number }[];
+	calls: { task: string; count: number; models?: string[] }[];
 	emits: string[];
 } {
-	const calls: { task: string; count: number }[] = [];
+	const calls: { task: string; count: number; models?: string[] }[] = [];
 	const emits: string[] = [];
 	const ctx = {
 		emit: (t: string) => emits.push(t),
-		runTournament: withRunner ? (task: string, count: number) => calls.push({ task, count }) : undefined,
+		runTournament: withRunner
+			? (task: string, opts: { count: number; models?: string[] }) => calls.push({ task, ...opts })
+			: undefined,
 	} as unknown as CommandContext;
 	return { ctx, calls, emits };
 }
@@ -20,20 +22,45 @@ describe("/tournament", () => {
 	it("defaults to 3 contestants when no count is given", () => {
 		const { ctx, calls } = makeCtx(true);
 		tournament.handler("add pagination to the list", ctx);
-		expect(calls).toEqual([{ task: "add pagination to the list", count: 3 }]);
+		expect(calls).toEqual([{ task: "add pagination to the list", count: 3, models: undefined }]);
 	});
 
 	it("parses and clamps a leading count to 2..5", () => {
 		const { ctx, calls } = makeCtx(true);
 		tournament.handler("9 refactor the parser", ctx);
-		expect(calls[0]).toEqual({ task: "refactor the parser", count: 5 });
+		expect(calls[0]).toMatchObject({ task: "refactor the parser", count: 5 });
 	});
 
 	it("treats a number-only arg as the task, not a count", () => {
 		const { ctx, calls } = makeCtx(true);
 		tournament.handler("42", ctx);
-		// "42" alone has no task after it, so it stays the task with default count.
-		expect(calls[0]).toEqual({ task: "42", count: 3 });
+		expect(calls[0]).toMatchObject({ task: "42", count: 3 });
+	});
+
+	it("parses --models into one contestant per model", () => {
+		const { ctx, calls } = makeCtx(true);
+		tournament.handler("--models opus,sonnet,haiku fix the parser", ctx);
+		expect(calls[0]).toEqual({ task: "fix the parser", count: 3, models: ["opus", "sonnet", "haiku"] });
+	});
+
+	it("supports --models=a,b syntax and ignores a leading digit as task text", () => {
+		const { ctx, calls } = makeCtx(true);
+		tournament.handler("--models=a,b 2fa support", ctx);
+		expect(calls[0]).toEqual({ task: "2fa support", count: 2, models: ["a", "b"] });
+	});
+
+	it("rejects a single-model list", () => {
+		const { ctx, calls, emits } = makeCtx(true);
+		tournament.handler("--models solo do a thing", ctx);
+		expect(calls).toHaveLength(0);
+		expect(emits[0]).toMatch(/at least 2/);
+	});
+
+	it("caps the model list at 5", () => {
+		const { ctx, calls } = makeCtx(true);
+		tournament.handler("--models a,b,c,d,e,f,g build", ctx);
+		expect(calls[0].models).toHaveLength(5);
+		expect(calls[0].count).toBe(5);
 	});
 
 	it("shows usage when given no task", () => {

src/commands/builtins/tournament.ts

@@ -1,41 +1,72 @@
 import type { Command } from "../types.js";
 
+const MAX_CONTESTANTS = 5;
+
 /**
  * /tournament [n] <task> — race N agents (default 3, max 5) on the same
- * build task in isolated worktrees, then pick the winner to merge. The
- * heavy lifting (snapshot, worktrees, judge, merge UI) lives in the App
- * via ctx.runTournament; here we just parse and hand off.
+ * build task in isolated worktrees, then pick the winner to merge.
+ * `--models a,b,c` runs one contestant per model id instead of N copies
+ * of the current model. The heavy lifting (snapshot, worktrees, judge,
+ * merge UI) lives in the App via ctx.runTournament; here we just parse.
  */
 export const tournament: Command = {
 	name: "tournament",
 	aliases: ["race"],
-	description: "Race N agents on a build task in parallel, then merge the winner. /tournament [n] <task>",
+	description: "Race agents on a build task, then merge the winner. /tournament [n|--models a,b,c] <task>",
 	mutates: true,
 	handler: (args, ctx) => {
 		if (!ctx.runTournament) {
 			ctx.emit("/tournament needs the pi-tui UI (the default). It's not available in the legacy renderer.");
 			return { handled: true };
 		}
-		const trimmed = args.trim();
-		if (!trimmed) {
+		let rest = args.trim();
+		if (!rest) {
 			ctx.emit(
-				"Usage: /tournament [n] <what to build or change>  — e.g. /tournament 3 add pagination to the users list",
+				"Usage: /tournament [n] <task>  or  /tournament --models a,b,c <task>\n" +
+					"e.g. /tournament 3 add pagination · /tournament --models opus,sonnet,haiku fix the parser",
 			);
 			return { handled: true };
 		}
-		// Optional leading contestant count.
-		let count = 3;
-		let task = trimmed;
-		const m = trimmed.match(/^(\d+)\s+(.*)$/s);
-		if (m) {
-			count = Math.min(5, Math.max(2, Number.parseInt(m[1], 10)));
-			task = m[2].trim();
+
+		// Pull out an optional --models / --model flag from anywhere in the args.
+		let models: string[] | undefined;
+		const mm = rest.match(/--models?(?:=|\s+)(\S+)/);
+		if (mm) {
+			models = mm[1]
+				.split(",")
+				.map((s) => s.trim())
+				.filter(Boolean);
+			rest = (rest.slice(0, mm.index) + rest.slice((mm.index ?? 0) + mm[0].length)).replace(/\s+/g, " ").trim();
+			if (models.length < 2) {
+				ctx.emit(
+					"--models needs at least 2 model ids to race (or drop the flag for N copies of the current model).",
+				);
+				return { handled: true };
+			}
+			if (models.length > MAX_CONTESTANTS) {
+				ctx.emit(`capping at ${MAX_CONTESTANTS} contestants; ignoring the extra models.`);
+				models = models.slice(0, MAX_CONTESTANTS);
+			}
 		}
+
+		// A leading count only applies when no explicit model list was given
+		// (otherwise the contestant count is the number of models, and a
+		// leading digit is part of the task — e.g. "2fa support").
+		let count = models ? models.length : 3;
+		let task = rest;
+		if (!models) {
+			const m = rest.match(/^(\d+)\s+(.*)$/s);
+			if (m) {
+				count = Math.min(MAX_CONTESTANTS, Math.max(2, Number.parseInt(m[1], 10)));
+				task = m[2].trim();
+			}
+		}
+
 		if (!task) {
 			ctx.emit("Give the contestants something to build: /tournament <task>.");
 			return { handled: true };
 		}
-		ctx.runTournament(task, count);
+		ctx.runTournament(task, { count, models });
 		return { handled: true };
 	},
 };

src/commands/types.ts

@@ -44,11 +44,13 @@ export interface CommandContext {
 	 */
 	openRewindPicker?: () => void;
 	/**
-	 * Run a /tournament: race `count` agents on `task` in isolated
-	 * worktrees, judge them, and open the merge picker (pi-tui only).
-	 * Undefined on UIs without it.
+	 * Run a /tournament: race agents on `task` in isolated worktrees, judge
+	 * them, and open the merge picker (pi-tui only). `models`, when given,
+	 * runs one contestant per model id (same provider/proxy as the parent);
+	 * otherwise `count` copies of the current model race. Undefined on UIs
+	 * without it.
 	 */
-	runTournament?: (task: string, count: number) => void;
+	runTournament?: (task: string, opts: { count: number; models?: string[] }) => void;
 }
 
 export interface CommandResult {

src/ui-pi/app.ts

@@ -659,12 +659,13 @@ export class App extends Container {
 	}
 
 	/**
-	 * Run a /tournament: snapshot the working tree, race `count` general
-	 * agents on `task` in isolated worktrees, then open the results picker so
-	 * the user can merge a winner. Heavy + long-running, so it's gated
-	 * against the agent being busy or another tournament already going.
+	 * Run a /tournament: snapshot the working tree, race general agents on
+	 * `task` in isolated worktrees, then open the results picker so the user
+	 * can merge a winner. With `opts.models`, one contestant runs per model
+	 * id; otherwise `opts.count` copies of the current model race. Heavy +
+	 * long-running, so it's gated against the agent or another tournament.
 	 */
-	private async startTournament(task: string, count: number): Promise<void> {
+	private async startTournament(task: string, opts: { count: number; models?: string[] }): Promise<void> {
 		if (!this.tui) return;
 		if (this.busy || this.tournamentRunning) {
 			this.statusBar.note("can't start a tournament while the agent (or another tournament) is running.");
@@ -675,12 +676,12 @@ export class App extends Container {
 		const cwd = this.bundle.toolContext.cwd;
 		try {
 			const snap = await snapshotWorkingTree(cwd, this.tournamentAbort.signal);
-			const branches: BranchSpec[] = Array.from({ length: count }, (_, i) => ({
-				id: String.fromCharCode(65 + i), // A, B, C…
-			}));
+			const branches: BranchSpec[] = opts.models
+				? opts.models.map((model, i) => ({ id: String.fromCharCode(65 + i), model }))
+				: Array.from({ length: opts.count }, (_, i) => ({ id: String.fromCharCode(65 + i) }));
 			const status = new Map<string, string>(branches.map((b) => [b.id, "queued"]));
 			const renderStatus = () => {
-				const parts = branches.map((b) => `${b.id}:${status.get(b.id)}`);
+				const parts = branches.map((b) => `${b.id}${b.model ? `(${b.model})` : ""}:${status.get(b.id)}`);
 				this.statusBar.note(`🏁 tournament — ${parts.join("  ")}`);
 				this.tui?.requestRender();
 			};
@@ -1057,8 +1058,8 @@ export class App extends Container {
 			},
 			switchSession: (sessionId) => this.switchSession(sessionId),
 			openRewindPicker: () => this.showRewindOverlay(),
-			runTournament: (task, count) => {
-				void this.startTournament(task, count);
+			runTournament: (task, opts) => {
+				void this.startTournament(task, opts);
 			},
 		});
 		if (!result.handled) {