複数案を出させたあと、どれを採用するか — 検証で裁定する Best-of-N の設計

type Candidate = {
  id: string;
  apply: () => Promise<void>;   // 候補をワークツリーに反映
  revert: () => Promise<void>;  // 反映を巻き戻す
};
 
type GateResult = { passed: boolean; penalty: number; note: string };
type Gate = {
  name: string;
  run: () => Promise<GateResult>;
  fatal: boolean; // true: 失敗で即脱落 / false: 減点のみ
};
 
type Verdict =
  | { kind: "adopt"; id: string; score: number; trail: string[] }
  | { kind: "all_failed"; trail: string[] }
  | { kind: "budget_exhausted"; trail: string[] };
 
async function arbitrate(
  candidates: Candidate[],
  gates: Gate[],
  opts: { maxVerifyMs: number },
): Promise<Verdict> {
  const trail: string[] = [];
  const start = Date.now();
  let best: { id: string; score: number } | null = null;
 
  for (const c of candidates) {
    if (Date.now() - start > opts.maxVerifyMs) {
      trail.push(`budget: ${c.id} 未検証で打ち切り`);
      return best
        ? { kind: "adopt", id: best.id, score: best.score, trail }
        : { kind: "budget_exhausted", trail };
    }
 
    await c.apply();
    let score = 100;
    let eliminated = false;
 
    for (const g of gates) {
      const r = await g.run();
      trail.push(`${c.id}/${g.name}: ${r.passed ? "ok" : "ng"} ${r.note}`);
      if (!r.passed && g.fatal) { eliminated = true; break; }
      if (!r.passed) score -= r.penalty;
    }
 
    await c.revert();
    if (eliminated) continue;
 
    // 同点は先着優先（決定性を保つため候補は安定順で渡す）
    if (!best || score > best.score) best = { id: c.id, score };
  }
 
  if (!best) return { kind: "all_failed", trail };
  return { kind: "adopt", id: best.id, score: best.score, trail };
}