pi-prompt-template-model-enhanced 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [0.14.0](https://github.com/Nabsku/pi-prompt-template-model-enhanced/compare/v0.13.1...v0.14.0) (2026-06-22)
+
+
+### Features
+
+* add best-of-n preset resolution ([e0f45e6](https://github.com/Nabsku/pi-prompt-template-model-enhanced/commit/e0f45e64490e6874e6693e7b6450954d7f9dde64))
+
+
+### Bug Fixes
+
+* address best-of-n preset review comments ([0dfdf80](https://github.com/Nabsku/pi-prompt-template-model-enhanced/commit/0dfdf8065c0a241f0786f7271800b1c877b117cc))
+* close preset review edge cases ([df85bf3](https://github.com/Nabsku/pi-prompt-template-model-enhanced/commit/df85bf3d86c2f43bcbec8d9fdb150e2fde37e61f))
+* close preset validation review gaps ([1822061](https://github.com/Nabsku/pi-prompt-template-model-enhanced/commit/1822061ae90ee9b5ee2d7ea222ce9cabc9698e79))
+* harden best-of-n preset overrides ([caa0981](https://github.com/Nabsku/pi-prompt-template-model-enhanced/commit/caa0981936d5e264f5e2dd334d9f0e1abe59aa59))
+* harden project preset resolution ([04cddc9](https://github.com/Nabsku/pi-prompt-template-model-enhanced/commit/04cddc919256b0c40b28a51b67c185a592f899fb))
+* prevent invalid project presets from falling through ([8b0f589](https://github.com/Nabsku/pi-prompt-template-model-enhanced/commit/8b0f5899ca5ebd1350218cd0d87d24af891a9656))
+* validate presets from prompt cwd ([ce97729](https://github.com/Nabsku/pi-prompt-template-model-enhanced/commit/ce9772947bf31abbc1fc4481bdc13bf51385da62))
+
+## [0.13.1](https://github.com/Nabsku/pi-prompt-template-model-enhanced/compare/v0.13.0...v0.13.1) (2026-06-21)
+
+
+### Bug Fixes
+
+* harden prompt-library parity coverage ([1666691](https://github.com/Nabsku/pi-prompt-template-model-enhanced/commit/16666916eff1757cefa4b743cdbb18ea704b95a5))
+
 ## [0.13.0](https://github.com/Nabsku/pi-prompt-template-model-enhanced/compare/v0.12.0...v0.13.0) (2026-06-21)
 
 ### Prompt library

package/README.md

@@ -32,6 +32,41 @@ No more manually switching models, copying standard instructions between prompts
 - **Pi-native TUI**: browse templates and inspect dry-run output interactively in Pi TUI mode without typing template names.
 - **Execution control**: loops, model rotation, fresh context, boomerang collapse, delegated subagents, chains, and best-of-N compare prompts.
 
+## Differences from upstream
+
+This package is an enhanced fork of [`pi-prompt-template-model`](https://github.com/nicobailon/pi-prompt-template-model), with compatibility preserved where practical and new workflow features kept opt-in where possible.
+
+### Additions
+
+- Prompt includes from shared Markdown partials and prompt-library roots.
+- Multiple skill injection via `skills`, plus constrained wildcard skill selectors.
+- Dry-run previews and a Pi-native TUI picker/inspector for prompt templates.
+- Loop controls, model rotation, fresh context, and boomerang context collapse.
+- Chain templates, deterministic prompt steps, delegated subagents, and parallel delegation helpers.
+- Best-of-N compare prompts with reusable preset catalogs.
+- Richer `/validate-prompts` diagnostics, include graphs, and source summaries.
+
+### Behavior changes and stricter validation
+
+- Invalid prompt config is reported and skipped more consistently instead of running with silently degraded behavior.
+- Prompt-library commands have extra trust checks because they can come from project-local reusable libraries.
+- Duplicate prompt and prompt-library precedence is deterministic and reported with diagnostics.
+- Runtime flags are scoped to prompt types that support them; for example, `--preset` only affects compare prompts.
+- Project best-of-N presets require session approval and invalid project presets fail closed instead of falling back to same-named user presets.
+
+### Breaking or migration notes
+
+- Compare prompt templates must use nested `bestOfN:` frontmatter. Top-level `workers`, `reviewers`, and `finalApplier` fields are rejected with migration diagnostics.
+- `skills:` must be a list. Use `skill: name` for a single skill.
+- Some fields that upstream accepted loosely are now type-checked before registration, including prompt includes, chain declarations, loop values, cwd paths, compare lineups, and preset catalogs.
+- Best-of-N presets intentionally cannot set execution-policy fields such as `task`, `taskSuffix`, `cwd`, `finalApplier`, `worktree`, dirty/report/commit policy, or other prompt-owned behavior.
+
+### Small tweaks
+
+- Better command descriptions and runtime warnings for ignored or unsupported flags.
+- More deterministic model/thinking fallback behavior in dry-run and execution paths.
+- Packaged examples, authoring skill docs, and validation output are kept aligned with shipped behavior.
+
 ## Installation
 
 ```bash
@@ -182,7 +217,8 @@ All fields are optional. Templates that don't use any extension features (no `mo
 | `subagent` | — | Delegate execution to a subagent instead of running in the current session. `true` uses the default `delegate` agent; a string value like `reviewer` targets that specific agent. Requires [pi-subagents](https://github.com/nicobailon/pi-subagents/). |
 | `inheritContext` | `false` | Only meaningful with `subagent`. When `true`, the subagent receives a fork of the current conversation context instead of starting fresh. |
 | `parallel` | — | Delegated prompts only. Repeats the same subagent in parallel `N` times. Each copy gets a slot header like `[Parallel subagent 2/3]` prepended to the task. Must be an integer greater than or equal to 2. |
-| `bestOfN` | — | Compare templates only. Nested compare authoring block with `workers`, `reviewers`, optional `finalApplier`, and optional `worktree`. Top-level compare fields are not supported in templates. |
+| `bestOfN` | — | Compare templates only. Nested compare authoring block with `workers`, `reviewers`, optional `preset`, optional `finalApplier`, and optional `worktree`. Top-level compare fields are not supported in templates. |
+| `bestOfN.preset` | — | Name of a best-of-N preset from `~/.pi/agent/best-of-n-presets.json` or `<compare-cwd>/.pi/best-of-n-presets.json`. Presets can supply worker/reviewer agents, models, counts, `defaultModel`, and `maxModelCalls`; prompt templates still own task text, `cwd`, final apply, dirty/report/commit policy, and other execution policy. |
 | `bestOfN.workers` | — | Ordered worker lineup used for the worker phase. Each slot object supports optional `agent`/`subagent`, optional `model`, optional `task`, optional `taskSuffix`, optional `cwd`, and optional `count`. If both `agent` and `subagent` are omitted, the default agent is `delegate`. |
 | `bestOfN.reviewers` | — | Ordered reviewer lineup used after worker aggregation. Slot shape matches workers. If both `agent` and `subagent` are omitted, the default agent is `reviewer`. |
 | `bestOfN.finalApplier` | — | Optional single-slot final apply phase that edits the real branch after reviewers. Supports optional `agent`/`subagent`, optional `model`, optional `task`, and optional `taskSuffix`. If both `agent` and `subagent` are omitted, the default agent is `delegate`. `count` and `cwd` are not supported. Requires `bestOfN.worktree: true` at runtime. |
@@ -588,6 +624,7 @@ Prompt-template frontmatter authoring uses `bestOfN:`. Runtime overrides stay on
 - `--workers=<json-array>` / `--reviewers=<json-array>` replace the corresponding frontmatter lineup.
 - `--workers-append=<json-array>` / `--reviewers-append=<json-array>` append to the corresponding lineup.
 - `--final-applier=<json-object-or-one-element-array>` replaces the optional final apply slot.
+- `--preset=<name>` / `--preset <name>` selects a best-of-N preset for compare prompts only; it is ignored on non-compare prompts.
 
 Each worker/reviewer JSON array entry must be an object with either `subagent` or `agent`, plus optional `model`, `task`, `taskSuffix`, `cwd`, and `count`. In worker slots, `"subagent": true` maps to `delegate`. In reviewer slots, `"subagent": true` maps to `reviewer`. `--final-applier=` accepts one slot object (or a one-element array) with `subagent`/`agent`, optional `model`, optional `task`, and optional `taskSuffix`; for this final slot, `"subagent": true` maps to `delegate`, and both `count` and `cwd` are not supported.
 
@@ -615,7 +652,45 @@ Compare prompt templates are authored under `bestOfN:`. Top-level `workers`, `re
 3. Optional final apply phase: if `finalApplier` is configured, run one delegated apply step on the real compare repo (`compareCwd`) to pick a winner or synthesize/cherry-pick and apply the final patch.
 4. If all reviewers fail but `finalApplier` exists, the final apply step still runs with fallback context from workers plus reviewer failure summaries.
 
-Worker/reviewer lineups are fully configurable from `bestOfN` frontmatter or runtime overrides, so there is no fixed three-model worker assumption. If a compare prompt omits `bestOfN.workers`, it falls back to one `delegate` worker using the current/main model. If it omits `bestOfN.reviewers`, it falls back to one `reviewer` slot. `bestOfN.finalApplier` is optional, and compare runs reject an effective final applier unless `bestOfN.worktree: true` is set.
+Worker/reviewer lineups are fully configurable from `bestOfN` frontmatter, presets, or runtime overrides, so there is no fixed three-model worker assumption. If a compare prompt omits `bestOfN.workers`, it falls back to one `delegate` worker using the current/main model. If it omits `bestOfN.reviewers`, it falls back to one `reviewer` slot. `bestOfN.finalApplier` is optional, and compare runs reject an effective final applier unless `bestOfN.worktree: true` is set.
+
+### Best-of-N presets
+
+Presets keep expensive lineup choices reusable without letting project config own prompt policy. Define them in either place:
+
+- User presets: `~/.pi/agent/best-of-n-presets.json`
+- Project presets: `<compare-cwd>/.pi/best-of-n-presets.json`
+
+Project presets override user presets of the same name, but running a project preset asks for session approval. Compare prompts that set `cwd`, runtime `--cwd`, or use `parallel-patch-compare-at-path` resolve project presets from the effective compare cwd. `/validate-prompts` mirrors prompt `cwd` where it can be known statically.
+
+```json
+{
+  "presets": {
+    "quick": {
+      "description": "Two cheap workers, one reviewer",
+      "defaultModel": "openai-codex/gpt-5.4-mini:low",
+      "maxModelCalls": 3,
+      "workers": [{ "agent": "delegate", "count": 2 }],
+      "reviewers": [{ "agent": "reviewer" }]
+    }
+  }
+}
+```
+
+Use from a prompt:
+
+```yaml
+bestOfN:
+  preset: quick
+```
+
+Or at runtime:
+
+```bash
+/best-of-n --preset quick refactor the parser
+```
+
+Preset slot fields are intentionally limited to `agent`/`subagent`, `model`, and `count`. Presets cannot set `task`, `taskSuffix`, `cwd`, `finalApplier`, `worktree`, dirty/report/commit behavior, or other execution policy. Invalid selected presets fail closed instead of falling back to same-named user presets, and `maxModelCalls` caps the expanded worker + reviewer calls before any subagents start.
 
 For same-model best-of-N, use `count: N` on one worker slot:
 

package/args.ts

@@ -21,6 +21,7 @@ export interface SubagentOverrideExtraction {
 	override?: SubagentOverride;
 	cwd?: string;
 	model?: string;
+	preset?: string;
 	fork?: boolean;
 }
 
@@ -240,10 +241,65 @@ export function extractWorktreeFlag(argsString: string): { args: string; worktre
 	return { args, worktree: found };
 }
 
+const LINEUP_OVERRIDE_VALUE_PREFIXES = [
+	"--workers=",
+	"--workers-append=",
+	"--reviewers=",
+	"--reviewers-append=",
+	"--final-applier=",
+] as const;
+
+function readJsonLikeFlagTokenEnd(argsString: string, tokenStart: number): number {
+	const plainEnd = () => {
+		let end = tokenStart;
+		while (end < argsString.length && !/\s/.test(argsString[end])) end++;
+		return end;
+	};
+	const prefix = LINEUP_OVERRIDE_VALUE_PREFIXES.find((candidate) => argsString.startsWith(candidate, tokenStart));
+	if (!prefix) return plainEnd();
+	let i = tokenStart + prefix.length;
+	if (argsString[i] === '"' || argsString[i] === "'") {
+		const quote = argsString[i++];
+		while (i < argsString.length) {
+			if (argsString[i] === "\\") {
+				i += 2;
+				continue;
+			}
+			if (argsString[i] === quote) return i + 1;
+			i++;
+		}
+		return i;
+	}
+	const opener = argsString[i];
+	const closer = opener === "[" ? "]" : opener === "{" ? "}" : undefined;
+	if (!closer) return plainEnd();
+	let depth = 0;
+	let inString = false;
+	for (; i < argsString.length; i++) {
+		const char = argsString[i];
+		if (inString) {
+			if (char === "\\") i++;
+			else if (char === '"') inString = false;
+			continue;
+		}
+		if (char === '"') {
+			inString = true;
+			continue;
+		}
+		if (char === opener) depth++;
+		else if (char === closer) {
+			depth--;
+			if (depth === 0) return i + 1;
+		}
+	}
+	return i;
+}
+
 export function extractSubagentOverride(argsString: string): SubagentOverrideExtraction {
 	let override: SubagentOverride | undefined;
 	let cwdRaw: string | undefined;
 	let modelRaw: string | undefined;
+	let presetRaw: string | undefined;
 	let fork = false;
 	const tokensToRemove: Array<{ start: number; end: number }> = [];
 
@@ -265,7 +321,7 @@ export function extractSubagentOverride(argsString: string): SubagentOverrideExt
 		}
 
 		const tokenStart = i;
-		while (i < argsString.length && !/\s/.test(argsString[i])) i++;
+		i = readJsonLikeFlagTokenEnd(argsString, tokenStart);
 		const token = argsString.slice(tokenStart, i);
 
 		if (token === "--subagent") {
@@ -295,6 +351,31 @@ export function extractSubagentOverride(argsString: string): SubagentOverrideExt
 			continue;
 		}
 
+		if (token.startsWith("--preset=")) {
+			tokensToRemove.push({ start: tokenStart, end: i });
+			const value = token.slice("--preset=".length);
+			presetRaw = value || undefined;
+			continue;
+		}
+
+		if (token === "--preset") {
+			let lookahead = i;
+			while (lookahead < argsString.length && /\s/.test(argsString[lookahead])) lookahead++;
+			if (lookahead < argsString.length && argsString[lookahead] !== '"' && argsString[lookahead] !== "'") {
+				const valueStart = lookahead;
+				while (lookahead < argsString.length && !/\s/.test(argsString[lookahead])) lookahead++;
+				const value = argsString.slice(valueStart, lookahead);
+				if (value && !value.startsWith("--")) {
+					tokensToRemove.push({ start: tokenStart, end: i }, { start: valueStart, end: lookahead });
+					presetRaw = value;
+					i = lookahead;
+					continue;
+				}
+			}
+			tokensToRemove.push({ start: tokenStart, end: i });
+			continue;
+		}
+
 		if (token === "--fork") {
 			tokensToRemove.push({ start: tokenStart, end: i });
 			fork = true;
@@ -317,6 +398,7 @@ export function extractSubagentOverride(argsString: string): SubagentOverrideExt
 		...(override ? { override } : {}),
 		...(cwdRaw !== undefined ? { cwd: cwdRaw } : {}),
 		...(modelRaw !== undefined ? { model: modelRaw } : {}),
+		...(presetRaw !== undefined ? { preset: presetRaw } : {}),
 		...(fork ? { fork: true } : {}),
 	};
 }

package/best-of-n-presets.ts

@@ -0,0 +1,256 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import type { DelegationLineupSlot, PromptLoaderDiagnostic, PromptSource } from "./prompt-loader.js";
+
+export interface BestOfNPreset {
+	description?: string;
+	defaultModel?: string;
+	maxModelCalls?: number;
+	workers?: DelegationLineupSlot[];
+	reviewers?: DelegationLineupSlot[];
+}
+
+export interface ResolvedBestOfNPreset extends BestOfNPreset {
+	name: string;
+	source: PromptSource;
+	filePath: string;
+}
+
+export interface BestOfNPresetCatalog {
+	presets: Map<string, ResolvedBestOfNPreset>;
+	invalidPresetNames: Set<string>;
+	diagnostics: PromptLoaderDiagnostic[];
+	projectFileInvalid: boolean;
+}
+
+function createPresetDiagnostic(code: string, filePath: string, source: PromptSource, message: string): PromptLoaderDiagnostic {
+	return {
+		code,
+		filePath,
+		source,
+		message,
+		key: `${code}:${filePath}:${message}`,
+	};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isValidModelSelectionSpec(spec: string): boolean {
+	if (!spec || spec.includes("*") || /\s/.test(spec)) return false;
+	const slashIndex = spec.indexOf("/");
+	if (slashIndex === -1) return true;
+	if (slashIndex === 0) return false;
+	const modelId = spec.slice(slashIndex + 1);
+	if (modelId.length === 0) return false;
+	if (modelId.split("/").some((segment) => segment.length === 0)) return false;
+	return true;
+}
+
+function rejectUnsupportedKeys(
+	value: Record<string, unknown>,
+	allowedKeys: Set<string>,
+	presetName: string,
+	filePath: string,
+	source: PromptSource,
+	diagnostics: PromptLoaderDiagnostic[],
+	context: string,
+): boolean {
+	const unsupportedKeys = Object.keys(value).filter((key) => !allowedKeys.has(key));
+	if (unsupportedKeys.length === 0) return false;
+	diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(presetName)} in ${filePath}: ${context} has unsupported field(s): ${unsupportedKeys.join(", ")}.`));
+	return true;
+}
+
+const PRESET_KEYS = new Set(["description", "defaultModel", "maxModelCalls", "workers", "reviewers"]);
+const PRESET_SLOT_KEYS = new Set(["agent", "subagent", "model", "count"]);
+
+function normalizePresetSlot(
+	value: unknown,
+	field: "workers" | "reviewers",
+	presetName: string,
+	filePath: string,
+	source: PromptSource,
+	diagnostics: PromptLoaderDiagnostic[],
+	index: number,
+): DelegationLineupSlot | undefined {
+	if (!isRecord(value)) {
+		diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(presetName)} in ${filePath}: ${field} slot ${index + 1} must be an object.`));
+		return undefined;
+	}
+	if (rejectUnsupportedKeys(value, PRESET_SLOT_KEYS, presetName, filePath, source, diagnostics, `${field} slot ${index + 1}`)) {
+		return undefined;
+	}
+	if (value.agent !== undefined && value.subagent !== undefined) {
+		diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(presetName)} in ${filePath}: ${field} slot ${index + 1} cannot combine "agent" and "subagent".`));
+		return undefined;
+	}
+
+	let agent: string | undefined;
+	if (typeof value.agent === "string" && value.agent.trim()) {
+		agent = value.agent.trim();
+	} else if (value.agent !== undefined) {
+		diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(presetName)} in ${filePath}: ${field} slot ${index + 1} requires a non-empty string "agent".`));
+		return undefined;
+	}
+	if (!agent && value.subagent !== undefined) {
+		if (value.subagent === true) {
+			agent = field === "reviewers" ? "reviewer" : "delegate";
+		} else if (typeof value.subagent === "string" && value.subagent.trim()) {
+			agent = value.subagent.trim();
+		} else {
+			diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(presetName)} in ${filePath}: ${field} slot ${index + 1} requires "subagent" to be true or a non-empty string.`));
+			return undefined;
+		}
+	}
+	if (!agent) agent = field === "reviewers" ? "reviewer" : "delegate";
+
+	const slot: DelegationLineupSlot = { agent };
+	if (value.model !== undefined) {
+		if (typeof value.model !== "string" || !value.model.trim() || !isValidModelSelectionSpec(value.model.trim())) {
+			diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(presetName)} in ${filePath}: ${field} slot ${index + 1} has an invalid "model".`));
+			return undefined;
+		}
+		slot.model = value.model.trim();
+	}
+	if (value.count !== undefined) {
+		let count: number | undefined;
+		if (typeof value.count === "number") count = value.count;
+		else if (typeof value.count === "string" && /^\d+$/.test(value.count.trim())) count = parseInt(value.count.trim(), 10);
+		if (count === undefined || !Number.isInteger(count) || count < 1) {
+			diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(presetName)} in ${filePath}: ${field} slot ${index + 1} "count" must be an integer greater than or equal to 1.`));
+			return undefined;
+		}
+		slot.count = count;
+	}
+	return slot;
+}
+
+function normalizePresetLineup(
+	value: unknown,
+	field: "workers" | "reviewers",
+	presetName: string,
+	filePath: string,
+	source: PromptSource,
+	diagnostics: PromptLoaderDiagnostic[],
+): DelegationLineupSlot[] | undefined {
+	if (value === undefined) return undefined;
+	if (!Array.isArray(value) || value.length === 0) {
+		diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(presetName)} in ${filePath}: ${field} must be a non-empty array.`));
+		return undefined;
+	}
+	const slots: DelegationLineupSlot[] = [];
+	for (let i = 0; i < value.length; i++) {
+		const slot = normalizePresetSlot(value[i], field, presetName, filePath, source, diagnostics, i);
+		if (!slot) return undefined;
+		slots.push(slot);
+	}
+	return slots;
+}
+
+function normalizePreset(name: string, value: unknown, filePath: string, source: PromptSource, diagnostics: PromptLoaderDiagnostic[]): BestOfNPreset | undefined {
+	if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) {
+		diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring invalid best-of-N preset name ${JSON.stringify(name)} in ${filePath}.`));
+		return undefined;
+	}
+	if (!isRecord(value)) {
+		diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(name)} in ${filePath}: preset must be an object.`));
+		return undefined;
+	}
+	if (rejectUnsupportedKeys(value, PRESET_KEYS, name, filePath, source, diagnostics, "preset")) {
+		return undefined;
+	}
+	const preset: BestOfNPreset = {};
+	if (value.description !== undefined) {
+		if (typeof value.description !== "string") {
+			diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(name)} in ${filePath}: description must be a string.`));
+			return undefined;
+		}
+		const description = value.description.trim();
+		if (description) preset.description = description;
+	}
+	if (value.defaultModel !== undefined) {
+		if (typeof value.defaultModel !== "string" || !value.defaultModel.trim() || !isValidModelSelectionSpec(value.defaultModel.trim())) {
+			diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(name)} in ${filePath}: defaultModel must be a valid model spec string.`));
+			return undefined;
+		}
+		preset.defaultModel = value.defaultModel.trim();
+	}
+	if (value.maxModelCalls !== undefined) {
+		if (typeof value.maxModelCalls !== "number" || !Number.isInteger(value.maxModelCalls) || value.maxModelCalls < 1) {
+			diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(name)} in ${filePath}: maxModelCalls must be an integer greater than or equal to 1.`));
+			return undefined;
+		}
+		preset.maxModelCalls = value.maxModelCalls;
+	}
+	const workers = normalizePresetLineup(value.workers, "workers", name, filePath, source, diagnostics);
+	if (value.workers !== undefined && !workers) return undefined;
+	const reviewers = normalizePresetLineup(value.reviewers, "reviewers", name, filePath, source, diagnostics);
+	if (value.reviewers !== undefined && !reviewers) return undefined;
+	if (workers) preset.workers = workers;
+	if (reviewers) preset.reviewers = reviewers;
+	if (!preset.workers && !preset.reviewers && value.workers === undefined && value.reviewers === undefined) {
+		diagnostics.push(createPresetDiagnostic("invalid-best-of-n-preset", filePath, source, `Ignoring preset ${JSON.stringify(name)} in ${filePath}: expected workers or reviewers.`));
+		return undefined;
+	}
+	if (!preset.workers && !preset.reviewers) return undefined;
+	return preset;
+}
+
+function readPresetFile(filePath: string, source: PromptSource): BestOfNPresetCatalog {
+	const presets = new Map<string, ResolvedBestOfNPreset>();
+	const invalidPresetNames = new Set<string>();
+	const diagnostics: PromptLoaderDiagnostic[] = [];
+	if (!existsSync(filePath)) return { presets, invalidPresetNames, diagnostics, projectFileInvalid: false };
+	let projectFileInvalid = false;
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+	} catch (error) {
+		projectFileInvalid = source === "project";
+		diagnostics.push(createPresetDiagnostic("invalid-best-of-n-presets-file", filePath, source, `Skipping best-of-N presets file ${filePath}: ${error instanceof Error ? error.message : String(error)}.`));
+		return { presets, invalidPresetNames, diagnostics, projectFileInvalid };
+	}
+	if (!isRecord(parsed) || !isRecord(parsed.presets)) {
+		projectFileInvalid = source === "project";
+		diagnostics.push(createPresetDiagnostic("invalid-best-of-n-presets-file", filePath, source, `Skipping best-of-N presets file ${filePath}: expected top-level object with a "presets" object.`));
+		return { presets, invalidPresetNames, diagnostics, projectFileInvalid };
+	}
+	for (const [name, rawPreset] of Object.entries(parsed.presets)) {
+		const preset = normalizePreset(name, rawPreset, filePath, source, diagnostics);
+		if (!preset) {
+			invalidPresetNames.add(name);
+			continue;
+		}
+		presets.set(name, { name, source, filePath, ...preset });
+	}
+	return { presets, invalidPresetNames, diagnostics, projectFileInvalid };
+}
+
+export function getBestOfNPresetPaths(cwd: string): { user: string; project: string } {
+	return {
+		user: join(homedir(), ".pi", "agent", "best-of-n-presets.json"),
+		project: resolve(cwd, ".pi", "best-of-n-presets.json"),
+	};
+}
+
+export function loadBestOfNPresetCatalog(cwd: string): BestOfNPresetCatalog {
+	const paths = getBestOfNPresetPaths(cwd);
+	const user = readPresetFile(paths.user, "user");
+	const project = readPresetFile(paths.project, "project");
+	const presets = project.projectFileInvalid ? new Map(project.presets) : new Map([...user.presets, ...project.presets]);
+	for (const name of project.invalidPresetNames) presets.delete(name);
+	return {
+		presets,
+		invalidPresetNames: new Set([...user.invalidPresetNames, ...project.invalidPresetNames]),
+		diagnostics: [...user.diagnostics, ...project.diagnostics],
+		projectFileInvalid: project.projectFileInvalid,
+	};
+}
+
+export function applyPresetDefaultModel(slots: DelegationLineupSlot[] | undefined, defaultModel: string | undefined): DelegationLineupSlot[] | undefined {
+	if (!slots || !defaultModel) return slots?.map((slot) => ({ ...slot }));
+	return slots.map((slot) => ({ ...slot, model: slot.model ?? defaultModel }));
+}

package/index.ts

@@ -15,6 +15,7 @@ import {
 	type LineupOverrideAction,
 	type SubagentOverride,
 } from "./args.js";
+import { loadBestOfNPresetCatalog, applyPresetDefaultModel, type ResolvedBestOfNPreset } from "./best-of-n-presets.js";
 import { parseChainSteps, parseChainDeclaration, type ChainStep, type ChainStepOrParallel, type ParallelChainStep } from "./chain-parser.js";
 import { generateBoomerangSummary, generateChainStepSummary, generateIterationSummary, didIterationMakeChanges, getIterationEntries, wasIterationAborted } from "./loop-utils.js";
 import { selectModelCandidate } from "./model-selection.js";
@@ -130,6 +131,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 	let lastDiagnostics = "";
 	let storedCommandCtx: ExtensionCommandContext | null = null;
 	const approvedProjectPromptLibraryCwds = new Set<string>();
+	const approvedProjectPresetCwds = new Set<string>();
 	const UNLIMITED_LOOP_CAP = 999;
 
 	const toolManager = createToolManager(pi, {
@@ -194,6 +196,49 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		return true;
 	}
 
+	async function ensureProjectPresetApproved(preset: ResolvedBestOfNPreset, ctx: ExtensionCommandContext, catalogCwd: string): Promise<boolean> {
+		if (preset.source !== "project") return true;
+		const cwdKey = resolvePath(catalogCwd);
+		if (approvedProjectPresetCwds.has(cwdKey)) return true;
+		const message = `Best-of-N preset \`${preset.name}\` is loaded from ${preset.filePath}. Approve project best-of-N presets for this session?`;
+		if (!ctx.hasUI || typeof (ctx.ui as { confirm?: unknown }).confirm !== "function") {
+			notify(ctx, `${message} Run in an interactive UI session and approve it, or move trusted presets to ~/.pi/agent/best-of-n-presets.json.`, "error");
+			return false;
+		}
+		const approved = await ctx.ui.confirm("Approve project best-of-N preset", message, { timeout: 30_000 });
+		if (!approved) {
+			notify(ctx, `Project best-of-N preset \`${preset.name}\` was not approved.`, "warning");
+			return false;
+		}
+		approvedProjectPresetCwds.add(cwdKey);
+		return true;
+	}
+
+	async function resolveBestOfNPresetLineup(
+		prompt: PromptWithModel,
+		runtimePreset: string | undefined,
+		ctx: ExtensionCommandContext,
+		catalogCwd: string,
+	): Promise<{ workers?: DelegationLineupSlot[]; reviewers?: DelegationLineupSlot[]; maxModelCalls?: number } | undefined> {
+		const presetName = runtimePreset ?? prompt.preset;
+		if (!presetName) return {};
+		const catalog = loadBestOfNPresetCatalog(catalogCwd);
+		for (const diagnostic of catalog.diagnostics) {
+			notify(ctx, diagnostic.message, "warning");
+		}
+		const preset = catalog.presets.get(presetName);
+		if (!preset) {
+			notify(ctx, `Best-of-N preset \`${presetName}\` was not found. Define it in ~/.pi/agent/best-of-n-presets.json or .pi/best-of-n-presets.json.`, "error");
+			return undefined;
+		}
+		if (!(await ensureProjectPresetApproved(preset, ctx, catalogCwd))) return undefined;
+		return {
+			workers: applyPresetDefaultModel(preset.workers, preset.defaultModel),
+			reviewers: applyPresetDefaultModel(preset.reviewers, preset.defaultModel),
+			maxModelCalls: preset.maxModelCalls,
+		};
+	}
+
 	pi.registerMessageRenderer<SkillLoadedDetails>("skill-loaded", renderSkillLoaded);
 	pi.registerMessageRenderer(PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE, renderDelegatedSubagentResult);
 	pi.registerMessageRenderer(PROMPT_TEMPLATE_DETERMINISTIC_MESSAGE_TYPE, renderDeterministicResult);
@@ -519,6 +564,12 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		return slots?.map((slot) => ({ ...slot }));
 	}
 
+	function expandedLineupCallCount(slots: DelegationLineupSlot[]): number {
+		let total = 0;
+		for (const slot of slots) total += slot.count ?? 1;
+		return total;
+	}
+
 	function expandLineupCounts(slots: DelegationLineupSlot[]): DelegationLineupSlot[] {
 		const expanded: DelegationLineupSlot[] = [];
 		for (const slot of slots) {
@@ -729,7 +780,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		args: string,
 		ctx: ExtensionCommandContext,
 		currentModel: Model<any> | undefined,
-		runtime: { cwd?: string; model?: string; subagentOverride?: SubagentOverride; fork?: boolean },
+		runtime: { cwd?: string; model?: string; preset?: string; subagentOverride?: SubagentOverride; fork?: boolean },
 	) {
 		if (!(await ensureProjectPromptLibraryApproved(prompt, ctx))) return;
 
@@ -782,24 +833,30 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		}
 		const sharedTask = rendered.content;
 
-		const requestedWorkers = applyLineupActions(prompt.workers, lineupExtraction.actions, "workers") ?? [];
-		const requestedReviewers = applyLineupActions(prompt.reviewers, lineupExtraction.actions, "reviewers") ?? [];
+		const presetLineup = await resolveBestOfNPresetLineup(prompt, runtime.preset, ctx, compareCwd);
+		if (!presetLineup) return;
+		const requestedWorkers = applyLineupActions(presetLineup.workers ?? prompt.workers, lineupExtraction.actions, "workers") ?? [];
+		const requestedReviewers = applyLineupActions(presetLineup.reviewers ?? prompt.reviewers, lineupExtraction.actions, "reviewers") ?? [];
 		const requestedFinalApplier = applyFinalApplierAction(prompt.finalApplier, lineupExtraction.actions);
 		if (requestedFinalApplier && prompt.worktree !== true) {
 			notify(ctx, "Compare prompts with finalApplier require worktree: true.", "error");
 			return;
 		}
 
-		const workerSlots = expandLineupCounts(
-			requestedWorkers.length > 0
-				? requestedWorkers
-				: [{ agent: DEFAULT_SUBAGENT_NAME }],
-		);
-		const reviewerSlots = expandLineupCounts(
-			requestedReviewers.length > 0
-				? requestedReviewers
-				: [{ agent: "reviewer" }],
-		);
+		const effectiveWorkerSlots = requestedWorkers.length > 0
+			? requestedWorkers
+			: [{ agent: DEFAULT_SUBAGENT_NAME }];
+		const effectiveReviewerSlots = requestedReviewers.length > 0
+			? requestedReviewers
+			: [{ agent: "reviewer" }];
+		const presetModelCalls = expandedLineupCallCount(effectiveWorkerSlots) + expandedLineupCallCount(effectiveReviewerSlots);
+		if (presetLineup.maxModelCalls !== undefined && presetModelCalls > presetLineup.maxModelCalls) {
+			notify(ctx, `Best-of-N preset model-call cap exceeded: requested ${presetModelCalls} worker/reviewer call(s), but preset allows ${presetLineup.maxModelCalls}.`, "error");
+			return;
+		}
+
+		const workerSlots = expandLineupCounts(effectiveWorkerSlots);
+		const reviewerSlots = expandLineupCounts(effectiveReviewerSlots);
 
 		const normalizedWorkers = normalizeLineupCwds(workerSlots, compareCwd, ctx);
 		if (!normalizedWorkers) return;
@@ -1499,7 +1556,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 
 	function getDryRunUnsupportedReason(prompt: PromptWithModel): string | undefined {
 		if (prompt.chain) return DRY_RUN_CHAIN_UNSUPPORTED;
-		if (prompt.workers !== undefined || prompt.reviewers !== undefined || prompt.finalApplier !== undefined) return DRY_RUN_COMPARE_UNSUPPORTED;
+		if (prompt.workers !== undefined || prompt.reviewers !== undefined || prompt.finalApplier !== undefined || prompt.preset !== undefined) return DRY_RUN_COMPARE_UNSUPPORTED;
 		if (prompt.deterministic) return DRY_RUN_DETERMINISTIC_UNSUPPORTED;
 		return undefined;
 	}
@@ -1659,7 +1716,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			}
 		}
 
-		const hasCompareLineup = prompt.workers !== undefined || prompt.reviewers !== undefined || prompt.finalApplier !== undefined;
+		const hasCompareLineup = prompt.workers !== undefined || prompt.reviewers !== undefined || prompt.finalApplier !== undefined || prompt.preset !== undefined;
 		if (hasCompareLineup) {
 			await runComparePrompt(
 				name,
@@ -1670,6 +1727,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				{
 					cwd: runtimeCwd,
 					model: subagent.model,
+					preset: subagent.preset,
 					subagentOverride: subagent.override,
 					fork: subagent.fork,
 				},
@@ -1677,6 +1735,10 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			return;
 		}
 
+		if (subagent.preset) {
+			notify(ctx, `--preset is only supported on compare prompts (ignored)`, "warning");
+		}
+
 		if (prompt.chain) {
 			if (subagent.model) notify(ctx, `--model is not supported on chain prompts (ignored)`, "warning");
 			if (subagent.fork) notify(ctx, `--fork is not supported on chain prompts (ignored)`, "warning");
@@ -1791,6 +1853,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 	function resetSessionScopedState(ctx: ExtensionContext) {
 		storedCommandCtx = null;
 		approvedProjectPromptLibraryCwds.clear();
+		approvedProjectPresetCwds.clear();
 		pendingSkillMessage = undefined;
 		previousModel = undefined;
 		previousThinking = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-prompt-template-model-enhanced",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "description": "Prompt template model selector extension for pi coding agent",
   "author": "Nico Bailon",
@@ -27,6 +27,7 @@
   "files": [
     "index.ts",
     "args.ts",
+    "best-of-n-presets.ts",
     "chain-parser.ts",
     "loop-utils.ts",
     "model-selection.ts",

package/prompt-dry-run.ts

@@ -209,7 +209,7 @@ function errorResult(
 }
 
 function hasCompareLineup(prompt: PromptWithModel): boolean {
-	return prompt.workers !== undefined || prompt.reviewers !== undefined || prompt.finalApplier !== undefined;
+	return prompt.workers !== undefined || prompt.reviewers !== undefined || prompt.finalApplier !== undefined || prompt.preset !== undefined;
 }
 
 function shouldDelegatePrompt(prompt: Pick<PromptWithModel, "subagent">, override?: SubagentOverride): boolean {

package/prompt-loader.ts

@@ -104,6 +104,7 @@ export interface PromptWithModel {
 	workers?: DelegationLineupSlot[];
 	reviewers?: DelegationLineupSlot[];
 	finalApplier?: DelegationLineupSlot;
+	preset?: string;
 	source: PromptSource;
 	rootKind: PromptRootKind;
 	subdir?: string;
@@ -1884,9 +1885,11 @@ function loadPromptsWithModelFromDir(
 				const workers = normalizeLineup(hasBestOfN ? bestOfN?.workers : undefined, "workers", fullPath, source, diagnostics);
 				const reviewers = normalizeLineup(hasBestOfN ? bestOfN?.reviewers : undefined, "reviewers", fullPath, source, diagnostics);
 				const finalApplier = normalizeFinalApplier(hasBestOfN ? bestOfN?.finalApplier : undefined, fullPath, source, diagnostics);
+				const preset = normalizeStringField("best-of-n-preset", hasBestOfN ? bestOfN?.preset : undefined, fullPath, source, diagnostics);
 				let safeWorkers = workers;
 				let safeReviewers = reviewers;
 				let safeFinalApplier = finalApplier;
+				let safePreset = preset;
 				if (chain && subagent !== undefined) {
 					diagnostics.push(
 						createDiagnostic(
@@ -1909,7 +1912,7 @@ function loadPromptsWithModelFromDir(
 					);
 					deterministic = undefined;
 				}
-				if (chain && (safeWorkers !== undefined || safeReviewers !== undefined || safeFinalApplier !== undefined)) {
+				if (chain && (safeWorkers !== undefined || safeReviewers !== undefined || safeFinalApplier !== undefined || safePreset !== undefined)) {
 					diagnostics.push(
 						createDiagnostic(
 							"invalid-lineup-chain",
@@ -1921,8 +1924,9 @@ function loadPromptsWithModelFromDir(
 					safeWorkers = undefined;
 					safeReviewers = undefined;
 					safeFinalApplier = undefined;
+					safePreset = undefined;
 				}
-				if (subagent !== undefined && (safeWorkers !== undefined || safeReviewers !== undefined || safeFinalApplier !== undefined)) {
+				if (subagent !== undefined && (safeWorkers !== undefined || safeReviewers !== undefined || safeFinalApplier !== undefined || safePreset !== undefined)) {
 					diagnostics.push(
 						createDiagnostic(
 							"invalid-lineup-subagent",
@@ -1934,6 +1938,7 @@ function loadPromptsWithModelFromDir(
 					safeWorkers = undefined;
 					safeReviewers = undefined;
 					safeFinalApplier = undefined;
+					safePreset = undefined;
 				}
 				if (subagent !== undefined && deterministic !== undefined) {
 					diagnostics.push(
@@ -1979,7 +1984,7 @@ function loadPromptsWithModelFromDir(
 					);
 					safeParallel = undefined;
 				}
-				if (safeParallel !== undefined && (safeWorkers !== undefined || safeReviewers !== undefined || safeFinalApplier !== undefined)) {
+				if (safeParallel !== undefined && (safeWorkers !== undefined || safeReviewers !== undefined || safeFinalApplier !== undefined || safePreset !== undefined)) {
 					diagnostics.push(
 						createDiagnostic(
 							"invalid-lineup-parallel",
@@ -1991,6 +1996,7 @@ function loadPromptsWithModelFromDir(
 					safeWorkers = undefined;
 					safeReviewers = undefined;
 					safeFinalApplier = undefined;
+					safePreset = undefined;
 				}
 				if (safeParallel !== undefined && deterministic !== undefined) {
 					diagnostics.push(
@@ -2003,7 +2009,7 @@ function loadPromptsWithModelFromDir(
 					);
 					deterministic = undefined;
 				}
-				const hasLineup = safeWorkers !== undefined || safeReviewers !== undefined || safeFinalApplier !== undefined;
+				const hasLineup = safeWorkers !== undefined || safeReviewers !== undefined || safeFinalApplier !== undefined || safePreset !== undefined;
 				if (!hasBestOfN && hasLegacyCompareFields) {
 					diagnostics.push(
 						createDiagnostic(
@@ -2223,6 +2229,7 @@ function loadPromptsWithModelFromDir(
 					workers: safeWorkers,
 					reviewers: safeReviewers,
 					finalApplier: safeFinalApplier,
+					preset: safePreset,
 					source,
 					rootKind,
 					subdir: subdir || undefined,

package/prompt-validation.ts

@@ -1,6 +1,8 @@
+import { resolve as resolvePath } from "node:path";
+import { loadBestOfNPresetCatalog, type ResolvedBestOfNPreset } from "./best-of-n-presets.js";
 import { parseChainDeclaration, type ChainStep, type ChainStepOrParallel } from "./chain-parser.js";
 import { collectPromptIncludeGraphs, type PromptIncludeGraph, type PromptIncludeGraphEdge, type PromptIncludeGraphNode } from "./prompt-includes.js";
-import { collectPromptSourceRecords, discoverFilesystemSkills, loadPromptsWithModel, readSkillContent, resolveSkillPath, type PromptLoaderDiagnostic, type PromptSource, type PromptSourceRecord } from "./prompt-loader.js";
+import { collectPromptSourceRecords, discoverFilesystemSkills, loadPromptsWithModel, readSkillContent, resolveSkillPath, type PromptLoaderDiagnostic, type PromptSource, type PromptSourceRecord, type PromptWithModel } from "./prompt-loader.js";
 
 export interface RegisteredPromptSkill {
 	skillName: string;
@@ -314,8 +316,57 @@ function validatePromptChains(cwd: string, result: PromptValidationResult, promp
 	}
 }
 
+function expandedSlotCount(slots: Array<{ count?: number }> | undefined): number {
+	return (slots ?? []).reduce((total, slot) => total + (slot.count ?? 1), 0);
+}
+
+function presetExpandedCallCount(preset: ResolvedBestOfNPreset, prompt: PromptWithModel): number {
+	const workerSlots = preset.workers ?? prompt.workers;
+	const reviewerSlots = preset.reviewers ?? prompt.reviewers;
+	return (workerSlots && workerSlots.length > 0 ? expandedSlotCount(workerSlots) : 1)
+		+ (reviewerSlots && reviewerSlots.length > 0 ? expandedSlotCount(reviewerSlots) : 1);
+}
+
 function validateComparePrompts(cwd: string, result: PromptValidationResult, prompts: ReturnType<typeof loadPromptsWithModel>["prompts"]) {
+	const catalogByCwd = new Map<string, ReturnType<typeof loadBestOfNPresetCatalog>>();
+	function catalogFor(catalogCwd: string) {
+		const key = resolvePath(catalogCwd);
+		let catalog = catalogByCwd.get(key);
+		if (!catalog) {
+			catalog = loadBestOfNPresetCatalog(catalogCwd);
+			catalogByCwd.set(key, catalog);
+			result.diagnostics.push(...catalog.diagnostics);
+		}
+		return catalog;
+	}
 	for (const prompt of prompts.values()) {
+		if (prompt.preset) {
+			const presetCatalog = catalogFor(prompt.cwd ?? cwd);
+			const preset = presetCatalog.presets.get(prompt.preset);
+			if (!preset) {
+				result.diagnostics.push(
+					createValidationDiagnostic(
+						"best-of-n-preset-not-found",
+						prompt.filePath,
+						prompt.source,
+						`Prompt template ${prompt.filePath} references missing best-of-N preset ${JSON.stringify(prompt.preset)}.`,
+					),
+				);
+			} else if (preset.maxModelCalls !== undefined) {
+				const modelCalls = presetExpandedCallCount(preset, prompt);
+				if (modelCalls > preset.maxModelCalls) {
+					result.diagnostics.push(
+						createValidationDiagnostic(
+							"best-of-n-preset-cap-exceeded",
+							prompt.filePath,
+							prompt.source,
+							`Prompt template ${prompt.filePath} references best-of-N preset ${JSON.stringify(prompt.preset)}, but its expanded worker/reviewer calls (${modelCalls}) exceed maxModelCalls (${preset.maxModelCalls}).`,
+						),
+					);
+				}
+			}
+		}
+
 		if (prompt.finalApplier && prompt.worktree !== true) {
 			result.diagnostics.push(
 				createValidationDiagnostic(

package/skills/prompt-template-authoring/SKILL.md

@@ -153,18 +153,29 @@ Supports exact IDs, `provider/model-id` pairs, wildcards (`anthropic/*`), and co
 
 ## Best-of-N Compare
 
-Run multiple workers, aggregate with reviewers, optionally apply final changes:
+Run multiple workers, aggregate with reviewers, optionally apply final changes. Put workflow policy in the prompt and reusable lineup choices in optional presets:
+
+```json
+{
+  "presets": {
+    "quick": {
+      "defaultModel": "openai-codex/gpt-5.4-mini:low",
+      "maxModelCalls": 3,
+      "workers": [{ "agent": "delegate", "count": 2 }],
+      "reviewers": [{ "agent": "reviewer" }]
+    }
+  }
+}
+```
+
+Preset files live at `~/.pi/agent/best-of-n-presets.json` and `<compare-cwd>/.pi/best-of-n-presets.json`. Project presets override user presets after approval. Preset slots only support `agent`/`subagent`, `model`, and `count`; keep `task`, `taskSuffix`, `cwd`, `finalApplier`, `worktree`, and dirty/report/commit policy in prompt templates.
 
 ```yaml
 ---
 description: Best-of-N code review
 bestOfN:
+  preset: quick
   worktree: true            # required if using finalApplier
-  workers:
-    - model: openai-codex/gpt-5.4-mini:low
-      count: 2
-  reviewers:
-    - model: anthropic/claude-sonnet-4-20250514:medium
   finalApplier:
     agent: delegate
     model: anthropic/claude-sonnet-4-20250514:high
@@ -185,5 +196,6 @@ Override frontmatter at invocation:
 - `--cwd=/absolute/path` — working directory override when the prompt supports `cwd`
 - `--chain-context` — pass summaries to later delegated chain steps
 - `--worktree` — use git worktrees for parallel delegated work
+- `--preset=<name>` / `--preset <name>` — select a best-of-N preset for compare prompts only
 
 When stuck, check `README.md` and `examples/best-of-n.md` in this extension.