@bastani/atomic 0.9.9 → 0.9.10

package/dist/builtin/workflows/builtin/loop-until-done-prompts.ts

@@ -0,0 +1,79 @@
+type PromptSection = readonly [tag: string, content: string];
+
+function taggedPrompt(sections: readonly PromptSection[]): string {
+  return sections
+    .map(([tag, content]) => `<${tag}>\n${content.trim()}\n</${tag}>`)
+    .join("\n\n");
+}
+
+export function renderIterationPrompt(options: {
+  readonly task: string;
+  readonly iteration: number;
+  readonly maxIterations: number;
+  readonly ledgerPath: string;
+}): string {
+  return taggedPrompt([
+    ["role", "You are the active worker in a bounded evidence-driven completion loop."],
+    ["objective", options.task],
+    ["iteration", `${options.iteration} of ${options.maxIterations}`],
+    ["progress_ledger", `Read ${options.ledgerPath} first. It is the durable source of truth for attempted work, findings, failures, validation evidence, and remaining work.`],
+    ["requirements", [
+      "Select the highest-value unfinished item supported by the ledger and current state.",
+      "Perform concrete work; do not merely restate the objective or ledger.",
+      "Avoid repeating failed approaches unless new evidence justifies the retry.",
+      "Run the strongest practical validation for the work completed in this iteration.",
+      "Report exactly what changed, evidence gathered, failures encountered, and what remains.",
+    ].join("\n")],
+    ["success_criteria", "This iteration makes measurable progress or supplies decisive evidence that the explicit objective is complete."],
+    ["output_format", "Markdown with Work performed, Changes, Validation evidence, New findings, Failures, and Remaining work."],
+  ]);
+}
+
+export function renderEvaluationPrompt(options: {
+  readonly task: string;
+  readonly iteration: number;
+  readonly ledgerPath: string;
+  readonly iterationPath: string;
+}): string {
+  return taggedPrompt([
+    ["role", "You are an independent completion evaluator. Judge evidence, not the worker's confidence."],
+    ["objective", options.task],
+    ["artifacts", [
+      `Durable progress ledger: ${options.ledgerPath}`,
+      `Current iteration artifact: ${options.iterationPath}`,
+      "Read both files before deciding.",
+    ].join("\n")],
+    ["stop_condition", [
+      "Set done=true only when the objective is fully satisfied and current validation evidence proves it.",
+      "Set done=false when any required behavior, validation, cleanup, or evidence remains missing or uncertain.",
+      "Do not invent requirements beyond the objective.",
+    ].join("\n")],
+    ["evidence_rules", [
+      "List concrete validation evidence supporting the decision.",
+      "Record new findings and failures distinctly.",
+      "When incomplete, state actionable remaining work for the next iteration.",
+      "Return the required structured decision.",
+    ].join("\n")],
+    ["success_criteria", `The iteration ${options.iteration} decision is reproducible from cited artifact evidence.`],
+  ]);
+}
+
+export function renderCompletionPrompt(options: {
+  readonly task: string;
+  readonly ledgerPath: string;
+  readonly iterationPath: string;
+}): string {
+  return taggedPrompt([
+    ["role", "You are the final completion reporter."],
+    ["objective", options.task],
+    ["artifacts", `Read the complete ledger at ${options.ledgerPath} and final iteration artifact at ${options.iterationPath}.`],
+    ["requirements", [
+      "Summarize the delivered outcome without adding unsupported claims.",
+      "Cite the validation evidence that satisfied the stop condition.",
+      "List artifact paths needed to audit the work.",
+      "Report residual risks even when no work remains.",
+    ].join("\n")],
+    ["success_criteria", "The final report is concise, evidence-backed, and independently auditable from the ledger."],
+    ["output_format", "Markdown with Outcome, Evidence, Artifacts, Residual risks, and Remaining work (None)."],
+  ]);
+}

package/dist/builtin/workflows/builtin/loop-until-done-runner.ts

@@ -0,0 +1,189 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "typebox";
+import type {
+  WorkflowRunContext,
+  WorkflowSerializableObject,
+  WorkflowSerializableValue,
+  WorkflowTaskResult,
+} from "../src/shared/types.js";
+import {
+  renderCompletionPrompt,
+  renderEvaluationPrompt,
+  renderIterationPrompt,
+} from "./loop-until-done-prompts.js";
+import { stableArtifactRoot } from "./pattern-artifact-root.js";
+
+const evaluationSchema = Type.Object({
+  done: Type.Boolean(),
+  summary: Type.String(),
+  new_findings: Type.Array(Type.String()),
+  failures: Type.Array(Type.String()),
+  validation_evidence: Type.Array(Type.String()),
+  remaining_work: Type.String(),
+}, { additionalProperties: false });
+
+type LoopInputs = {
+  readonly prompt: string;
+  readonly max_iterations: number;
+} & Record<string, WorkflowSerializableValue>;
+
+type Evaluation = {
+  readonly done: boolean;
+  readonly summary: string;
+  readonly newFindings: readonly string[];
+  readonly failures: readonly string[];
+  readonly validationEvidence: readonly string[];
+  readonly remainingWork: string;
+};
+type LedgerEntry = {
+  readonly iteration: number;
+  readonly artifact_path: string;
+  readonly evaluation_artifact_path: string;
+  readonly summary: string;
+  readonly findings: readonly string[];
+  readonly failures: readonly string[];
+  readonly validation_evidence: readonly string[];
+  readonly done: boolean;
+  readonly remaining_work: string;
+};
+function serializableObject(
+  value: WorkflowSerializableValue | undefined,
+): WorkflowSerializableObject | undefined {
+  if (value === null || Array.isArray(value) || typeof value !== "object") return undefined;
+  return value as WorkflowSerializableObject;
+}
+
+function stringArray(value: WorkflowSerializableValue | undefined): readonly string[] | undefined {
+  return Array.isArray(value) && value.every((item) => typeof item === "string")
+    ? value
+    : undefined;
+}
+
+function evaluationFrom(result: WorkflowTaskResult): Evaluation {
+  const value = serializableObject(result.structured);
+  if (value === undefined) {
+    throw new Error(`loop-until-done: evaluator ${result.stageName} did not return a structured decision`);
+  }
+  const done = value.done;
+  const summary = value.summary;
+  const newFindings = stringArray(value.new_findings);
+  const failures = stringArray(value.failures);
+  const validationEvidence = stringArray(value.validation_evidence);
+  const remainingWork = value.remaining_work;
+  if (typeof done !== "boolean" || typeof summary !== "string" ||
+      newFindings === undefined || failures === undefined || validationEvidence === undefined ||
+      typeof remainingWork !== "string") {
+    throw new Error(`loop-until-done: evaluator ${result.stageName} returned an invalid decision`);
+  }
+  return { done, summary, newFindings, failures, validationEvidence, remainingWork };
+}
+
+async function writeLedger(path: string, task: string, maxIterations: number, status: string,
+  entries: readonly LedgerEntry[]): Promise<void> {
+  await writeFile(path, `${JSON.stringify({
+    task,
+    max_iterations: maxIterations,
+    status,
+    iterations_completed: entries.length,
+    entries,
+  }, null, 2)}\n`);
+}
+
+export async function runLoopUntilDone(ctx: WorkflowRunContext<LoopInputs>) {
+  const artifactDir = await stableArtifactRoot(ctx, "loop-until-done");
+  const iterationsDir = join(artifactDir, "iterations");
+  const evaluationsDir = join(artifactDir, "evaluations");
+  await mkdir(iterationsDir, { recursive: true });
+  await mkdir(evaluationsDir, { recursive: true });
+  const ledgerPath = join(artifactDir, "progress-ledger.json");
+  const entries: LedgerEntry[] = [];
+  const iterationArtifactPaths: string[] = [];
+  const evaluationArtifactPaths: string[] = [];
+  await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, "active", entries);
+
+  for (let iteration = 1; iteration <= ctx.inputs.max_iterations; iteration += 1) {
+    const iterationPath = join(iterationsDir, `iteration-${iteration}.md`);
+    const evaluationPath = join(evaluationsDir, `evaluation-${iteration}.json`);
+    iterationArtifactPaths.push(iterationPath);
+    evaluationArtifactPaths.push(evaluationPath);
+    await ctx.task(`iteration-${iteration}`, {
+      prompt: renderIterationPrompt({
+        task: ctx.inputs.prompt,
+        iteration,
+        maxIterations: ctx.inputs.max_iterations,
+        ledgerPath,
+      }),
+      context: "fresh",
+      reads: [ledgerPath, ...(iteration > 1 ? [iterationArtifactPaths[iteration - 2]!] : [])],
+      output: iterationPath,
+      outputMode: "file-only",
+    });
+    const evaluator = await ctx.task(`evaluate-${iteration}`, {
+      prompt: renderEvaluationPrompt({
+        task: ctx.inputs.prompt,
+        iteration,
+        ledgerPath,
+        iterationPath,
+      }),
+      context: "fresh",
+      reads: [ledgerPath, iterationPath],
+      schema: evaluationSchema,
+      output: evaluationPath,
+      outputMode: "file-only",
+    });
+    const decision = evaluationFrom(evaluator);
+    entries.push({
+      iteration,
+      artifact_path: iterationPath,
+      evaluation_artifact_path: evaluationPath,
+      summary: decision.summary,
+      findings: decision.newFindings,
+      failures: decision.failures,
+      validation_evidence: decision.validationEvidence,
+      done: decision.done,
+      remaining_work: decision.remainingWork,
+    });
+    await writeLedger(
+      ledgerPath,
+      ctx.inputs.prompt,
+      ctx.inputs.max_iterations,
+      decision.done ? "complete" : "active",
+      entries,
+    );
+    if (decision.done) {
+      const resultPath = join(artifactDir, "result.md");
+      const final = await ctx.task("completion-summary", {
+        prompt: renderCompletionPrompt({ task: ctx.inputs.prompt, ledgerPath, iterationPath }),
+        context: "fresh",
+        reads: [ledgerPath, iterationPath],
+        output: resultPath,
+      });
+      return {
+        result: final.text,
+        status: "complete" as const,
+        iterations_completed: iteration,
+        ledger_path: ledgerPath,
+        iteration_artifact_paths: iterationArtifactPaths,
+        evaluation_artifact_paths: evaluationArtifactPaths,
+        result_path: resultPath,
+        remaining_work: "",
+        artifact_dir: artifactDir,
+      };
+    }
+  }
+
+  const last = entries.at(-1)!;
+  await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, "failed", entries);
+  return {
+    result: `Iteration limit exhausted after ${ctx.inputs.max_iterations} iterations. Inspect ${ledgerPath}.`,
+    status: "failed" as const,
+    iterations_completed: ctx.inputs.max_iterations,
+    ledger_path: ledgerPath,
+    iteration_artifact_paths: iterationArtifactPaths,
+    evaluation_artifact_paths: evaluationArtifactPaths,
+    result_path: ledgerPath,
+    remaining_work: last.remaining_work,
+    artifact_dir: artifactDir,
+  };
+}

package/dist/builtin/workflows/builtin/loop-until-done.d.ts

@@ -0,0 +1,34 @@
+import type { WorkflowDefinition, WorkflowInputValues, WorkflowOutputValues } from "../src/authoring.js";
+
+export type LoopUntilDoneWorkflowStatus = "complete" | "failed";
+
+export type LoopUntilDoneWorkflowInputs = WorkflowInputValues & {
+  readonly prompt: string;
+  readonly max_iterations: number;
+};
+
+export type LoopUntilDoneWorkflowRunInputs = WorkflowInputValues & {
+  readonly prompt: string;
+  readonly max_iterations?: number;
+};
+
+export type LoopUntilDoneWorkflowOutputs = WorkflowOutputValues & {
+  readonly result: string;
+  readonly status: LoopUntilDoneWorkflowStatus;
+  readonly iterations_completed: number;
+  readonly ledger_path: string;
+  readonly iteration_artifact_paths: string[];
+  readonly evaluation_artifact_paths: string[];
+  readonly result_path: string;
+  readonly remaining_work: string;
+  readonly artifact_dir: string;
+};
+
+export type LoopUntilDoneWorkflowDefinition = WorkflowDefinition<
+  LoopUntilDoneWorkflowInputs,
+  LoopUntilDoneWorkflowOutputs,
+  LoopUntilDoneWorkflowRunInputs
+>;
+
+declare const workflow: LoopUntilDoneWorkflowDefinition;
+export default workflow;

package/dist/builtin/workflows/builtin/loop-until-done.ts

@@ -0,0 +1,31 @@
+import { Type } from "typebox";
+import { workflow } from "../src/authoring/workflow.js";
+import { runLoopUntilDone } from "./loop-until-done-runner.js";
+
+export default workflow({
+  name: "loop-until-done",
+  description: "Repeat evidence-producing work and independent completion evaluation against a durable ledger until done or an inspectable iteration-limit failure.",
+  inputs: {
+    prompt: Type.String({ description: "Objective whose explicit completion condition controls the bounded loop." }),
+    max_iterations: Type.Integer({
+      minimum: 1,
+      maximum: 20,
+      default: 5,
+      description: "Maximum work/evaluation iterations before returning an inspectable failed status (1-20).",
+    }),
+  },
+  outputs: {
+    result: Type.String({ description: "Evidence-backed completion report or deterministic exhaustion report." }),
+    status: Type.Union([Type.Literal("complete"), Type.Literal("failed")], {
+      description: "Complete when evidence satisfies the stop condition; failed when max_iterations is exhausted.",
+    }),
+    iterations_completed: Type.Integer({ description: "Number of completed work/evaluation iterations." }),
+    ledger_path: Type.String({ description: "Path to the durable JSON progress ledger." }),
+    iteration_artifact_paths: Type.Array(Type.String(), { description: "Ordered paths to per-iteration work artifacts." }),
+    evaluation_artifact_paths: Type.Array(Type.String(), { description: "Ordered paths to structured evaluation artifacts." }),
+    result_path: Type.String({ description: "Path to the final report, or the ledger on exhausted failure." }),
+    remaining_work: Type.String({ description: "Actionable remaining work; empty only after proven completion." }),
+    artifact_dir: Type.String({ description: "Run-specific directory containing loop artifacts." }),
+  },
+  run: async (ctx) => await runLoopUntilDone(ctx),
+});

package/dist/builtin/workflows/builtin/open-claude-design-runner.ts

@@ -84,16 +84,21 @@ export async function runOpenClaudeDesignWorkflow(ctx: OpenClaudeDesignContext):
       "anthropic/claude-opus-4-8:high",
       "cursor/claude-fable-5:high",
       "cursor/claude-opus-4-8-thinking:high",
+      "kimi-coding/k3:max",
+      "moonshotai/kimi-k3:max",
+      "moonshotai-cn/kimi-k3:max",
       "openai-codex/gpt-5.6-sol:xhigh",
       "github-copilot/gpt-5.6-sol:xhigh",
       "openai/gpt-5.6-sol:xhigh",
       "cursor/gpt-5.6-sol:xhigh",
-      "cursor/grok-4.5",
+      "xai/grok-4.5:high",
+      "cursor/grok-4.5:high",
       "zai/glm-5.2:xhigh",
       "zai-coding-cn/glm-5.2:xhigh",
       "cursor/glm-5.2",
       "openrouter/anthropic/claude-fable-5:high",
       "openrouter/anthropic/claude-opus-4-8:high",
+      "openrouter/moonshotai/kimi-k3:max",
       "openrouter/openai/gpt-5.6-sol:xhigh",
       "openrouter/sakana/fugu-ultra:high",
       "openrouter/x-ai/grok-4.5",

package/dist/builtin/workflows/builtin/pattern-artifact-root.ts

@@ -0,0 +1,28 @@
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { WorkflowRunContext } from "../src/shared/types.js";
+
+/**
+ * Durable per-run artifact root under `<cwd>/.atomic/workflows/runs`.
+ *
+ * The random directory name is generated exactly once through `ctx.tool`, so
+ * a durable resume replays the original path instead of computing a fresh
+ * per-process root. Replayed stages therefore keep reading artifacts written
+ * before the interruption. The `mkdir` stays outside the durable checkpoint
+ * and is idempotent, so both fresh runs and resumes converge on an existing
+ * directory.
+ */
+export async function stableArtifactRoot(
+  ctx: Pick<WorkflowRunContext, "cwd" | "tool">,
+  workflowName: string,
+): Promise<string> {
+  const cwd = ctx.cwd ?? process.cwd();
+  const artifactDir = await ctx.tool(
+    "artifact-root",
+    { workflow: workflowName },
+    async () => join(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID()}`),
+  );
+  await mkdir(artifactDir, { recursive: true });
+  return artifactDir;
+}

package/dist/builtin/workflows/builtin/ralph-models.ts

@@ -20,6 +20,9 @@ export const promptEngineerModelConfig = {
       "openai-codex/gpt-5.6-sol:xhigh",
       "github-copilot/gpt-5.6-sol:xhigh",
       "openai/gpt-5.6-sol:xhigh",
+      "kimi-coding/k3:max",
+      "moonshotai/kimi-k3:max",
+      "moonshotai-cn/kimi-k3:max",
       "openai-codex/gpt-5.5:xhigh",
       "github-copilot/gpt-5.5:xhigh",
       "openai/gpt-5.5:xhigh",
@@ -29,12 +32,14 @@ export const promptEngineerModelConfig = {
       "cursor/gpt-5.6-sol:xhigh",
       "cursor/gpt-5.5:high",
       "cursor/claude-opus-4-8-thinking:high",
-      "cursor/grok-4.5",
+      "xai/grok-4.5:high",
+      "cursor/grok-4.5:high",
       "zai/glm-5.2:xhigh",
       "zai-coding-cn/glm-5.2:xhigh",
       "cursor/glm-5.2",
       "openrouter/anthropic/claude-fable-5:high",
       "openrouter/openai/gpt-5.6-sol:xhigh",
+      "openrouter/moonshotai/kimi-k3:max",
       "openrouter/sakana/fugu-ultra:high",
       "openrouter/openai/gpt-5.5:xhigh",
       "openrouter/anthropic/claude-opus-4-8:high",
@@ -59,7 +64,8 @@ export const researchModelConfig = {
       "cursor/gpt-5.5:medium",
       "cursor/claude-fable-5:low",
       "cursor/claude-opus-4-8-thinking:medium",
-      "cursor/grok-4.5",
+      "xai/grok-4.5:high",
+      "cursor/grok-4.5:high",
       "zai/glm-5.2:high",
       "zai-coding-cn/glm-5.2:high",
       "cursor/glm-5.2",
@@ -78,6 +84,9 @@ export const orchestratorModelConfig = {
     fallbackModels: [
       "github-copilot/gpt-5.6-sol:xhigh",
       "openai/gpt-5.6-sol:xhigh",
+      "kimi-coding/k3:max",
+      "moonshotai/kimi-k3:max",
+      "moonshotai-cn/kimi-k3:max",
       "anthropic/claude-fable-5:high",
       "openai-codex/gpt-5.5:xhigh",
       "github-copilot/gpt-5.5:xhigh",
@@ -88,11 +97,13 @@ export const orchestratorModelConfig = {
       "cursor/claude-fable-5:high",
       "cursor/gpt-5.5:high",
       "cursor/claude-opus-4-8-thinking:high",
-      "cursor/grok-4.5",
+      "xai/grok-4.5:high",
+      "cursor/grok-4.5:high",
       "zai/glm-5.2:xhigh",
       "zai-coding-cn/glm-5.2:xhigh",
       "cursor/glm-5.2",
       "openrouter/openai/gpt-5.6-sol:xhigh",
+      "openrouter/moonshotai/kimi-k3:max",
       "openrouter/anthropic/claude-fable-5:high",
       "openrouter/sakana/fugu-ultra:high",
       "openrouter/openai/gpt-5.5:xhigh",
@@ -106,6 +117,9 @@ export const orchestratorModelConfig = {
 export const reviewerAModelConfig = {
     model: "anthropic/claude-fable-5:high",
     fallbackModels: [
+      "kimi-coding/k3:max",
+      "moonshotai/kimi-k3:max",
+      "moonshotai-cn/kimi-k3:max",
       "openai-codex/gpt-5.6-sol:xhigh",
       "github-copilot/gpt-5.6-sol:xhigh",
       "openai/gpt-5.6-sol:xhigh",
@@ -118,11 +132,13 @@ export const reviewerAModelConfig = {
       "cursor/gpt-5.6-sol:xhigh",
       "cursor/gpt-5.5:high",
       "cursor/claude-opus-4-8-thinking:high",
-      "cursor/grok-4.5",
+      "xai/grok-4.5:high",
+      "cursor/grok-4.5:high",
       "zai/glm-5.2:xhigh",
       "zai-coding-cn/glm-5.2:xhigh",
       "cursor/glm-5.2",
       "openrouter/anthropic/claude-fable-5:high",
+      "openrouter/moonshotai/kimi-k3:max",
       "openrouter/openai/gpt-5.6-sol:xhigh",
       "openrouter/sakana/fugu-ultra:high",
       "openrouter/openai/gpt-5.5:xhigh",
@@ -139,6 +155,9 @@ export const reviewerBModelConfig = {
     fallbackModels: [
       "github-copilot/gpt-5.6-sol:xhigh",
       "openai/gpt-5.6-sol:xhigh",
+      "kimi-coding/k3:max",
+      "moonshotai/kimi-k3:max",
+      "moonshotai-cn/kimi-k3:max",
       "openai-codex/gpt-5.5:xhigh",
       "github-copilot/gpt-5.5:xhigh",
       "openai/gpt-5.5:xhigh",
@@ -149,11 +168,13 @@ export const reviewerBModelConfig = {
       "cursor/gpt-5.5:high",
       "cursor/claude-fable-5:high",
       "cursor/claude-opus-4-8-thinking:high",
-      "cursor/grok-4.5",
+      "xai/grok-4.5:high",
+      "cursor/grok-4.5:high",
       "zai/glm-5.2:xhigh",
       "zai-coding-cn/glm-5.2:xhigh",
       "cursor/glm-5.2",
       "openrouter/openai/gpt-5.6-sol:xhigh",
+      "openrouter/moonshotai/kimi-k3:max",
       "openrouter/openai/gpt-5.5:xhigh",
       "openrouter/anthropic/claude-fable-5:high",
       "openrouter/sakana/fugu-ultra:high",

package/dist/builtin/workflows/builtin/ralph-runner.ts

@@ -271,6 +271,7 @@ export async function runRalphWorkflow(
         {
           task: workflowPrompt,
           failFast: false,
+          group: `ralph-reviewers-iter-${iteration}`,
         },
       );
     } catch (err) {

package/dist/builtin/workflows/builtin/tournament-prompts.ts

@@ -0,0 +1,79 @@
+type PromptSection = readonly [tag: string, content: string];
+
+function taggedPrompt(sections: readonly PromptSection[]): string {
+  return sections
+    .map(([tag, content]) => `<${tag}>\n${content.trim()}\n</${tag}>`)
+    .join("\n\n");
+}
+
+export function renderTournamentAttemptPrompt(task: string, attempt: number): string {
+  return taggedPrompt([
+    ["role", "You are an independent solution author competing on solution quality."],
+    ["objective", task],
+    ["attempt", `Produce attempt ${attempt} without assuming another attempt's approach or conclusions.`],
+    ["requirements", [
+      "Deliver a complete, self-contained solution rather than commentary about how to solve it.",
+      "Ground important claims in observable evidence, concrete reasoning, or executable checks.",
+      "State assumptions, limitations, and validation performed.",
+      "Optimize for correctness and usefulness, not length.",
+    ].join("\n")],
+    ["success_criteria", "A judge can evaluate this artifact directly against correctness, completeness, evidence, and task fit."],
+    ["output_format", "Markdown with Solution, Evidence and validation, Assumptions, and Residual risks."],
+  ]);
+}
+
+export function renderPairwiseJudgePrompt(options: {
+  readonly task: string;
+  readonly firstLabel: string;
+  readonly secondLabel: string;
+  readonly firstPath: string;
+  readonly secondPath: string;
+}): string {
+  return taggedPrompt([
+    ["role", "You are an impartial pairwise judge. Evaluate only the supplied artifacts."],
+    ["objective", options.task],
+    ["candidates", [
+      `First presentation: ${options.firstLabel} at ${options.firstPath}`,
+      `Second presentation: ${options.secondLabel} at ${options.secondPath}`,
+      "Read both files completely before deciding.",
+    ].join("\n")],
+    ["rubric", [
+      "1. Correctness: satisfies the task without material errors.",
+      "2. Completeness: covers required outcomes and important edge cases.",
+      "3. Evidence: supports claims with concrete reasoning or checks.",
+      "4. Task fit: is directly usable and avoids irrelevant work.",
+    ].join("\n")],
+    ["decision_rules", [
+      "Choose exactly one presented candidate; do not merge or rewrite them.",
+      "Ignore presentation order, writing length, and stylistic polish unless they affect the rubric.",
+      "Cite observable evidence from both artifacts and give a concise rationale.",
+      "Return the required structured decision.",
+    ].join("\n")],
+    ["success_criteria", "The selected winner is traceable to short rubric-grounded evidence from both candidates."],
+  ]);
+}
+
+export function renderBracketReducerPrompt(options: {
+  readonly task: string;
+  readonly bracketPath: string;
+  readonly winnerLabel: string;
+  readonly winnerPath: string;
+}): string {
+  return taggedPrompt([
+    ["role", "You are the tournament bracket reducer and final reporter."],
+    ["objective", options.task],
+    ["artifacts", [
+      `Bracket ledger: ${options.bracketPath}`,
+      `Winning artifact (${options.winnerLabel}): ${options.winnerPath}`,
+      "Read both files before reporting.",
+    ].join("\n")],
+    ["requirements", [
+      "Return the winning solution faithfully; do not silently combine losing material into it.",
+      "Summarize why it advanced using the recorded pairwise rationale and evidence.",
+      "Call out bracket byes and any limitations recorded by judges.",
+      "Cite the bracket ledger and winning artifact paths.",
+    ].join("\n")],
+    ["success_criteria", "A reader can use the winning solution and audit every comparison that selected it."],
+    ["output_format", "Markdown with Winner, Winning solution, Decision trail, Evidence, and Residual risks."],
+  ]);
+}