@bastani/atomic 0.9.16-alpha.6 → 0.9.16-alpha.8

package/dist/builtin/workflows/builtin/chunk-2dqb5s2q.js

@@ -0,0 +1,602 @@
+import {
+  fold_usage
+} from "./chunk-7at6dnkr.js";
+import {
+  build_scoring_prompt,
+  scoring_prompt_reads,
+  warm_first_fan_out
+} from "./chunk-7430zyas.js";
+import {
+  stableArtifactRoot
+} from "./chunk-wpckd35c.js";
+import {
+  VERIFICATION_SCALE,
+  normalize_criteria,
+  parse_rubric
+} from "./chunk-cg9tmks0.js";
+import {
+  workflow
+} from "./chunk-bfkmzv9h.js";
+import {
+  withSteeringPropagationContext
+} from "./chunk-0x6e303p.js";
+
+// dist/builtin/workflows/builtin/tournament.ts
+import { Type as Type2 } from "typebox";
+
+// dist/builtin/workflows/builtin/tournament-runner.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, isAbsolute, relative, resolve } from "node:path";
+import { Type } from "typebox";
+
+// dist/builtin/workflows/builtin/selection-math.ts
+var UINT32_RANGE = 4294967296;
+var MULBERRY_INCREMENT = 1831565813;
+function seeded_rng(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + MULBERRY_INCREMENT >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / UINT32_RANGE;
+  };
+}
+function ring_cycle(n, rng) {
+  const permutation = Array.from({ length: n }, (_, index) => index);
+  for (let index = n - 1;index > 0; index -= 1) {
+    const other = Math.floor(rng() * (index + 1));
+    [permutation[index], permutation[other]] = [permutation[other], permutation[index]];
+  }
+  return permutation.map((a, index) => ({ a, b: permutation[(index + 1) % n] }));
+}
+function pair_key(a, b) {
+  return a < b ? `${a}:${b}` : `${b}:${a}`;
+}
+function plan_comparisons(input) {
+  const { n, pivots: pivotCount, repeats, seed } = input;
+  if (n < 2)
+    throw new RangeError("n must be at least 2");
+  if (pivotCount < 1)
+    throw new RangeError("pivots must be at least 1");
+  if (repeats < 1)
+    throw new RangeError("repeats must be at least 1");
+  const ring = ring_cycle(n, seeded_rng(seed));
+  return {
+    ring,
+    pivotRounds: (pivots) => {
+      const scheduled = new Set(ring.map(({ a, b }) => pair_key(a, b)));
+      const pivotSet = new Set(pivots);
+      const pairs = [];
+      const add = (a, b) => {
+        if (a === b)
+          return;
+        const key = pair_key(a, b);
+        if (scheduled.has(key))
+          return;
+        scheduled.add(key);
+        pairs.push({ a, b });
+      };
+      for (let candidate = 0;candidate < n; candidate += 1) {
+        if (pivotSet.has(candidate))
+          continue;
+        for (const pivot of pivots)
+          add(candidate, pivot);
+      }
+      for (let first = 0;first < pivots.length; first += 1) {
+        for (let second = first + 1;second < pivots.length; second += 1) {
+          add(pivots[first], pivots[second]);
+        }
+      }
+      return pairs;
+    },
+    jobs: (pairs, criterionIds) => {
+      const jobs = [];
+      for (const pair of pairs) {
+        for (const criterionId of criterionIds) {
+          for (let rep = 0;rep < repeats; rep += 1) {
+            jobs.push({ a: pair.a, b: pair.b, criterionId, rep, swapped: rep % 2 === 1 });
+          }
+        }
+      }
+      return jobs;
+    }
+  };
+}
+function normalize_score(score) {
+  return (score - VERIFICATION_SCALE.min) / (VERIFICATION_SCALE.max - VERIFICATION_SCALE.min);
+}
+function soft_win(scoreA, scoreB) {
+  const difference = normalize_score(scoreA) - normalize_score(scoreB);
+  return 1 / (1 + Math.exp(-difference));
+}
+function accumulate(prefs, w, c) {
+  for (const { a, b, p } of prefs) {
+    w[a] += p;
+    c[a] += 1;
+    w[b] += 1 - p;
+    c[b] += 1;
+  }
+}
+function mean_preference(w, c, index) {
+  return c[index] === 0 ? 0 : w[index] / c[index];
+}
+function candidate_order(w, c) {
+  return Array.from({ length: w.length }, (_, index) => index).sort((left, right) => {
+    const difference = mean_preference(w, c, right) - mean_preference(w, c, left);
+    return difference === 0 ? left - right : difference;
+  });
+}
+function select_pivots(w, c, k) {
+  return candidate_order(w, c).slice(0, k);
+}
+function rank_candidates(w, c) {
+  return candidate_order(w, c).map((index) => ({ index, meanPreference: mean_preference(w, c, index) }));
+}
+
+// dist/builtin/workflows/builtin/tournament-prompts.ts
+var GROUNDED_REPORTING = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
+var READABLE_REPORT = "Lead with the outcome. Keep facts, decisions, caveats, and next steps; drop background and repetition. Use complete, readable sentences rather than compressed fragments.";
+var DEFAULT_TOURNAMENT_CRITERIA = [
+  { name: "Correctness", description: "Satisfies the task without material errors." },
+  { name: "Completeness", description: "Covers required outcomes and important edge cases." },
+  {
+    name: "Evidence and task fit",
+    description: "Supports claims with observable evidence or checks and is directly usable without irrelevant work."
+  }
+];
+function taggedPrompt(sections) {
+  return sections.map(([tag, content]) => `<${tag}>
+${content.trim()}
+</${tag}>`).join(`
+
+`);
+}
+function renderTournamentAttemptPrompt(task, attempt) {
+  return taggedPrompt([
+    ["role", "You are an independent solution author competing on solution quality."],
+    ["attempt", `Produce attempt ${attempt} without assuming another attempt's approach or conclusions.`],
+    ["success_criteria", "A judge can evaluate this artifact directly against correctness, completeness, evidence, and task fit."],
+    ["requirements", [
+      "Deliver a complete, self-contained solution rather than commentary about how to solve it.",
+      "Ground important claims in observable evidence or executable checks.",
+      "State assumptions, limitations, and validation performed.",
+      "Optimize for correctness and usefulness, not length.",
+      GROUNDED_REPORTING
+    ].join(`
+`)],
+    ["stop_rules", "Stop when the solution is complete, supported, validated where practical, and its residual risks are stated."],
+    ["output_format", `Markdown with Solution, Evidence and validation, Assumptions, and Residual risks. ${READABLE_REPORT}`],
+    ["objective", task]
+  ]);
+}
+function renderComparisonsReducerPrompt(options) {
+  const rankingText = options.ranking.map((entry, index) => `${index + 1}. ${entry.label} (mean preference ${entry.meanPreference})`).join(`
+`);
+  return taggedPrompt([
+    ["artifacts", [
+      `Comparisons ledger: ${options.comparisonsPath}`,
+      `Winning artifact (${options.winnerLabel}): ${options.winnerPath}`,
+      "Read the ledger and winning artifact before reporting."
+    ].join(`
+`)],
+    ["role", "You are the soft-scored tournament reducer and final reporter."],
+    ["ranking", rankingText],
+    ["requirements", [
+      "Return the winning solution faithfully; do not silently combine losing material into it.",
+      "Report the full ranking exactly as recorded in the comparisons ledger.",
+      "Identify notable score disagreements, invalid reports, or other limitations recorded by judges.",
+      "Cite the comparisons ledger and winning artifact paths.",
+      GROUNDED_REPORTING
+    ].join(`
+`)],
+    ["success_criteria", "A reader can use the winning solution and recompute the ranking from the durable comparisons ledger."],
+    ["stop_rules", "Stop after faithfully presenting the winner, full ranking, decision evidence, and residual risks."],
+    ["output_format", `Markdown with Winner, Full ranking, Decision trail, Evidence, Notable disagreements, and Residual risks. ${READABLE_REPORT}`],
+    ["objective", options.task]
+  ]);
+}
+
+// dist/builtin/workflows/builtin/tournament-runner.ts
+var judgeScoreSchema = Type.Object({
+  criterion_id: Type.String(),
+  score_a: Type.Integer({ minimum: VERIFICATION_SCALE.min, maximum: VERIFICATION_SCALE.max }),
+  score_b: Type.Integer({ minimum: VERIFICATION_SCALE.min, maximum: VERIFICATION_SCALE.max }),
+  evidence: Type.Array(Type.String())
+}, { additionalProperties: false });
+var JUDGE_GROUND_TRUTH_NOTE = "No external ground truth is supplied; score each presented solution against the task and criterion.";
+var JUDGE_OUTPUT_FORMAT = "Return only JSON with criterion_id (string), score_a (integer 1–20 for presented slot 1), score_b (integer 1–20 for presented slot 2), and evidence (array of strings).";
+function serializableObject(value) {
+  if (value === null || Array.isArray(value) || typeof value !== "object")
+    return;
+  return value;
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function judgeReport(value) {
+  const object = serializableObject(value);
+  if (object === undefined)
+    return;
+  const criterionId = object.criterion_id;
+  const scoreA = object.score_a;
+  const scoreB = object.score_b;
+  const evidence = object.evidence;
+  if (typeof criterionId !== "string" || typeof scoreA !== "number" || !Number.isInteger(scoreA) || scoreA < VERIFICATION_SCALE.min || scoreA > VERIFICATION_SCALE.max || typeof scoreB !== "number" || !Number.isInteger(scoreB) || scoreB < VERIFICATION_SCALE.min || scoreB > VERIFICATION_SCALE.max || !stringArray(evidence))
+    return;
+  return { criterion_id: criterionId, score_a: scoreA, score_b: scoreB, evidence };
+}
+function resultFor(results, stageName) {
+  return results.find((result) => result.stageName === stageName || result.name === stageName);
+}
+function scoredComparison(record) {
+  return typeof record.score_a === "number" && typeof record.score_b === "number" && record.invalid !== true;
+}
+function stageName(job) {
+  return `judge-${job.a}-${job.b}-${job.criterionId}-r${job.rep}`;
+}
+function criterionSlug(id) {
+  const slug = id.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40).replace(/_+$/g, "");
+  return slug || "criterion";
+}
+function judgeArtifactPath(judgesDir, job, criterionIndex) {
+  const filename = `judge-${job.a}-${job.b}-c${criterionIndex}-${criterionSlug(job.criterionId)}-r${job.rep}.json`;
+  const root = resolve(judgesDir);
+  const path = resolve(judgesDir, filename);
+  const fromRoot = relative(root, path);
+  if (fromRoot.startsWith("..") || isAbsolute(fromRoot)) {
+    throw new Error(`tournament: judge artifact escaped its directory: ${path}`);
+  }
+  return path;
+}
+function tournamentCriteria(input) {
+  if (input === undefined)
+    return normalize_criteria(DEFAULT_TOURNAMENT_CRITERIA);
+  if (typeof input === "string")
+    return parse_rubric(input).criteria;
+  return normalize_criteria(input);
+}
+function modelAssignment(entrants, models) {
+  if (models === undefined)
+    return;
+  const assignment = {};
+  if (models.length === 0)
+    return assignment;
+  for (const [index, entrant] of entrants.entries())
+    assignment[entrant.label] = models[index % models.length];
+  return assignment;
+}
+function combineUsage(totals) {
+  const combined = {
+    calls: 0,
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0,
+    turns: 0
+  };
+  for (const total of totals) {
+    combined.calls += total.calls;
+    combined.input += total.input;
+    combined.output += total.output;
+    combined.cacheRead += total.cacheRead;
+    combined.cacheWrite += total.cacheWrite;
+    combined.cost += total.cost;
+    combined.turns += total.turns;
+  }
+  const cacheDenominator = combined.input + combined.cacheRead;
+  return {
+    ...combined,
+    cacheHitRate: cacheDenominator === 0 ? 0 : combined.cacheRead / cacheDenominator
+  };
+}
+async function runTournament(ctx) {
+  const artifactDir = await stableArtifactRoot(ctx, "tournament");
+  const attemptsDir = join(artifactDir, "attempts");
+  const numAttempts = ctx.inputs.num_attempts ?? 4;
+  const maxConcurrency = ctx.inputs.max_concurrency ?? 4;
+  const nEvaluations = ctx.inputs.n_evaluations ?? 2;
+  const pivotCount = ctx.inputs.pivots ?? 1;
+  const seed = ctx.inputs.seed ?? 0;
+  const judgesDir = join(artifactDir, "judges");
+  await mkdir(attemptsDir, { recursive: true });
+  await mkdir(judgesDir, { recursive: true });
+  const attemptArtifactPaths = Array.from({ length: numAttempts }, (_, index) => join(attemptsDir, `attempt-${index + 1}.md`));
+  const models = ctx.inputs.models;
+  const attemptResults = await ctx.parallel(attemptArtifactPaths.map((path, index) => ({
+    name: `attempt-${index + 1}`,
+    prompt: renderTournamentAttemptPrompt(ctx.inputs.prompt, index + 1),
+    context: "fresh",
+    output: path,
+    outputMode: "file-only",
+    ...models !== undefined && models.length > 0 ? { model: models[index % models.length] } : {}
+  })), { concurrency: maxConcurrency, failFast: true });
+  const entrants = await Promise.all(attemptArtifactPaths.map(async (path, index) => ({
+    label: `attempt-${index + 1}`,
+    path,
+    body: await readFile(path, "utf8")
+  })));
+  const criteria = tournamentCriteria(ctx.inputs.criteria);
+  const criterionIds = criteria.map((criterion) => criterion.id);
+  const plan = plan_comparisons({
+    n: entrants.length,
+    pivots: pivotCount,
+    repeats: nEvaluations,
+    seed
+  });
+  const weights = Array.from({ length: entrants.length }, () => 0);
+  const counts = Array.from({ length: entrants.length }, () => 0);
+  const comparisons = [];
+  const pairs = [];
+  const judgeArtifactPaths = [];
+  let executed = 0;
+  const runPhase = async (phase, jobs) => {
+    const stages = jobs.map((job) => {
+      const slot1 = job.swapped ? job.b : job.a;
+      const slot2 = job.swapped ? job.a : job.b;
+      const first = entrants[slot1];
+      const second = entrants[slot2];
+      const head = {
+        task: ctx.inputs.prompt,
+        groundTruthNote: JUDGE_GROUND_TRUTH_NOTE,
+        candidates: [
+          { path: first.path, body: first.body },
+          { path: second.path, body: second.body }
+        ],
+        scaleAnchors: VERIFICATION_SCALE.anchors,
+        outputFormat: JUDGE_OUTPUT_FORMAT
+      };
+      const name = stageName(job);
+      const criterionIndex = criterionIds.indexOf(job.criterionId);
+      const path = judgeArtifactPath(judgesDir, job, criterionIndex);
+      judgeArtifactPaths.push(path);
+      return {
+        job,
+        name,
+        path,
+        slot1,
+        slot2,
+        step: {
+          name,
+          prompt: build_scoring_prompt(head, criteria.find((criterion) => criterion.id === job.criterionId)),
+          context: "fresh",
+          reads: scoring_prompt_reads(head),
+          schema: judgeScoreSchema
+        }
+      };
+    });
+    if (stages.length === 0)
+      return { preferences: [], results: [] };
+    executed += stages.length;
+    const results = await warm_first_fan_out(ctx, stages.map((stage) => stage.step), (_step, index) => `${stages[index].slot1}:${stages[index].slot2}`, { concurrency: maxConcurrency, failFast: false });
+    const phaseResults = [...results];
+    for (const stage of stages) {
+      let report = judgeReport(resultFor(results, stage.name)?.structured);
+      if (report === undefined) {
+        executed += 1;
+        const retried = await ctx.task(`${stage.name}-reask`, {
+          prompt: `${stage.step.prompt}
+The previous report was invalid. Return the required JSON schema exactly once.`,
+          context: "fresh",
+          reads: stage.step.reads,
+          schema: judgeScoreSchema
+        });
+        phaseResults.push(retried);
+        report = judgeReport(retried.structured);
+      }
+      if (report === undefined) {
+        await writeFile(stage.path, `${JSON.stringify({ invalid: true }, null, 2)}
+`);
+        comparisons.push({
+          a: stage.job.a,
+          b: stage.job.b,
+          phase,
+          criterion_id: stage.job.criterionId,
+          rep: stage.job.rep,
+          swapped: stage.job.swapped,
+          invalid: true,
+          judge_artifact_path: stage.path
+        });
+        continue;
+      }
+      await writeFile(stage.path, `${JSON.stringify(report, null, 2)}
+`);
+      const scoreA = stage.job.swapped ? report.score_b : report.score_a;
+      const scoreB = stage.job.swapped ? report.score_a : report.score_b;
+      comparisons.push({
+        a: stage.job.a,
+        b: stage.job.b,
+        phase,
+        criterion_id: stage.job.criterionId,
+        rep: stage.job.rep,
+        swapped: stage.job.swapped,
+        score_a: scoreA,
+        score_b: scoreB,
+        p_ab: soft_win(scoreA, scoreB),
+        judge_artifact_path: stage.path
+      });
+    }
+    const phaseRecords = comparisons.filter((record) => record.phase === phase);
+    const grouped = new Map;
+    for (const record of phaseRecords) {
+      const key = `${record.a}:${record.b}`;
+      const group = grouped.get(key);
+      if (group === undefined)
+        grouped.set(key, [record]);
+      else
+        group.push(record);
+    }
+    const preferences = [];
+    for (const records of grouped.values()) {
+      const first = records[0];
+      const valid = records.filter(scoredComparison);
+      if (valid.length === 0) {
+        pairs.push({ a: first.a, b: first.b, phase, valid_reports: 0, p_ab: 0.5, invalid: true });
+        preferences.push({ a: first.a, b: first.b, p: 0.5 });
+        continue;
+      }
+      const meanScoreA = valid.reduce((sum, record) => sum + record.score_a, 0) / valid.length;
+      const meanScoreB = valid.reduce((sum, record) => sum + record.score_b, 0) / valid.length;
+      const p = soft_win(meanScoreA, meanScoreB);
+      pairs.push({
+        a: first.a,
+        b: first.b,
+        phase,
+        valid_reports: valid.length,
+        mean_score_a: meanScoreA,
+        mean_score_b: meanScoreB,
+        p_ab: p
+      });
+      preferences.push({ a: first.a, b: first.b, p });
+    }
+    return { preferences, results: phaseResults };
+  };
+  const ringJobs = plan.jobs(plan.ring, criterionIds);
+  const ringPhase = await runPhase("ring", ringJobs);
+  accumulate(ringPhase.preferences, weights, counts);
+  const pivotIndices = select_pivots(weights, counts, pivotCount);
+  const pivotJobs = plan.jobs(plan.pivotRounds(pivotIndices), criterionIds);
+  const pivotPhase = await runPhase("pivot", pivotJobs);
+  accumulate(pivotPhase.preferences, weights, counts);
+  const ranking = rank_candidates(weights, counts).map((entry) => ({
+    label: entrants[entry.index].label,
+    index: entry.index,
+    meanPreference: entry.meanPreference
+  }));
+  const outputRanking = ranking.map(({ label, meanPreference }) => ({ label, meanPreference }));
+  const budgetPivots = Math.min(pivotCount, entrants.length);
+  const comparisonBudget = (entrants.length + budgetPivots * (entrants.length - budgetPivots) + budgetPivots * (budgetPivots - 1) / 2) * criteria.length * nEvaluations;
+  const comparisonPath = join(artifactDir, "comparisons.json");
+  const assignment = modelAssignment(entrants, models);
+  const phaseUsage = {
+    attempts: fold_usage(attemptResults),
+    ring: fold_usage(ringPhase.results),
+    pivots: fold_usage(pivotPhase.results)
+  };
+  const baseLedger = {
+    task: ctx.inputs.prompt,
+    seed,
+    params: {
+      n: entrants.length,
+      pivots: pivotCount,
+      n_evaluations: nEvaluations,
+      criteria
+    },
+    comparisons,
+    pairs,
+    w: weights,
+    c: counts,
+    ranking,
+    budget: { planned: comparisonBudget, executed },
+    ...assignment === undefined ? {} : { model_assignment: assignment }
+  };
+  const writeLedger = async (reducerUsage) => {
+    const usage = {
+      ...phaseUsage,
+      reducer: reducerUsage,
+      total: combineUsage([phaseUsage.attempts, phaseUsage.ring, phaseUsage.pivots, reducerUsage])
+    };
+    await writeFile(comparisonPath, `${JSON.stringify({ ...baseLedger, usage }, null, 2)}
+`);
+  };
+  await writeLedger(fold_usage([]));
+  const winner = ranking[0];
+  const winnerEntrant = entrants[winner.index];
+  const resultPath = join(artifactDir, "winner.md");
+  const reducer = await ctx.task("comparisons-reducer", {
+    prompt: renderComparisonsReducerPrompt({
+      task: ctx.inputs.prompt,
+      comparisonsPath: comparisonPath,
+      ranking: outputRanking,
+      winnerLabel: winner.label,
+      winnerPath: winnerEntrant.path
+    }),
+    context: "fresh",
+    reads: [comparisonPath, winnerEntrant.path, ...judgeArtifactPaths],
+    output: resultPath,
+    outputMode: "file-only"
+  });
+  await writeLedger(fold_usage([reducer]));
+  return {
+    result: reducer.text,
+    winner: winner.label,
+    winner_artifact_path: winnerEntrant.path,
+    result_path: resultPath,
+    attempt_artifact_paths: attemptArtifactPaths,
+    judge_artifact_paths: judgeArtifactPaths,
+    comparisons_path: comparisonPath,
+    ranking: outputRanking,
+    seed,
+    artifact_dir: artifactDir
+  };
+}
+
+// dist/builtin/workflows/builtin/tournament.ts
+var tournament_default = workflow({
+  name: "tournament",
+  description: "Run independent whole-task attempts through a soft-scored pivot-pairing schedule and return an auditable ranking.",
+  heartbeatIntervalMinutes: 15,
+  inputs: {
+    prompt: Type2.String({ description: "Task every competing agent must attempt independently." }),
+    num_attempts: Type2.Integer({
+      minimum: 2,
+      maximum: 8,
+      default: 4,
+      description: "Number of independent whole-task attempts (2-8)."
+    }),
+    max_concurrency: Type2.Integer({
+      minimum: 1,
+      maximum: 8,
+      default: 4,
+      description: "Maximum simultaneously active attempts or pairwise judges (1-8)."
+    }),
+    n_evaluations: Type2.Integer({
+      minimum: 1,
+      default: 2,
+      description: "Number of repeated evaluations per criterion and directed pair."
+    }),
+    pivots: Type2.Integer({
+      minimum: 1,
+      default: 1,
+      description: "Number of pivot candidates used for the second comparison phase."
+    }),
+    seed: Type2.Integer({
+      default: 0,
+      description: "Seed for the deterministic comparison schedule."
+    }),
+    criteria: Type2.Optional(Type2.Union([
+      Type2.String(),
+      Type2.Record(Type2.String(), Type2.String()),
+      Type2.Array(Type2.String()),
+      Type2.Array(Type2.Object({
+        id: Type2.Optional(Type2.String()),
+        name: Type2.Optional(Type2.String()),
+        description: Type2.String()
+      }, { additionalProperties: true }))
+    ], {
+      description: "Optional V1 judge criteria; accepts a markdown rubric, record, string list, or CriterionInput list; omitted uses the default three-criterion rubric."
+    })),
+    models: Type2.Optional(Type2.Array(Type2.String(), {
+      description: "Optional ordered model ids assigned round-robin to attempt slots."
+    }))
+  },
+  outputs: {
+    result: Type2.String({ description: "Compact reference to the final reducer report; read `result_path` for the full report." }),
+    winner: Type2.String({ description: "Stable attempt label selected as the top-ranked tournament winner." }),
+    winner_artifact_path: Type2.String({ description: "Path to the original winning attempt artifact." }),
+    result_path: Type2.String({ description: "Path to the final reducer report artifact." }),
+    attempt_artifact_paths: Type2.Array(Type2.String(), { description: "Paths to every independent attempt artifact." }),
+    judge_artifact_paths: Type2.Array(Type2.String(), { description: "Paths to all per-job structured judge artifacts." }),
+    comparisons_path: Type2.String({ description: "Path to the durable JSON soft-scored comparisons ledger." }),
+    ranking: Type2.Array(Type2.Object({
+      label: Type2.String(),
+      meanPreference: Type2.Number()
+    }, { additionalProperties: false }), { description: "All attempts ordered by mean preference." }),
+    seed: Type2.Integer({ description: "Seed used for the deterministic comparison schedule." }),
+    artifact_dir: Type2.String({ description: "Run-specific directory containing tournament artifacts." })
+  },
+  run: async (ctx) => await runTournament(withSteeringPropagationContext(ctx))
+});
+
+export { tournament_default };