自己修復ループに「諦める条件」を設計する — エラーを4分類して再試行予算を割り当てる

type ErrorClass = "transient" | "repairable" | "semantic-invalid" | "hard-fail";
 
interface Classified {
  cls: ErrorClass;
  reason: string;
}
 
// API例外・検証結果を4クラスへ写像する
function classify(err: unknown, validation?: { ok: boolean; kind?: string }): Classified {
  // 1) 検証由来の不合格を先に判定する
  if (validation && !validation.ok) {
    if (validation.kind === "schema" || validation.kind === "json")
      return { cls: "repairable", reason: `形式不正: ${validation.kind}` };
    // 事実誤り・品質ゲート不合格など、形ではなく中身の問題
    return { cls: "semantic-invalid", reason: "内容が要件を満たさない" };
  }
 
  // 2) HTTPステータスで分類する
  const status = (err as { status?: number })?.status;
  if (status === 429 || status === 529) return { cls: "transient", reason: `過負荷 ${status}` };
  if (status === 408 || status === 500 || status === 503)
    return { cls: "transient", reason: `一時障害 ${status}` };
  if (status === 401 || status === 403) return { cls: "hard-fail", reason: `認証 ${status}` };
  if (status === 400) return { cls: "hard-fail", reason: "入力不正(400)" };
  if (status === 404) return { cls: "hard-fail", reason: "モデル/リソース未存在(404)" };
 
  // 3) ネットワーク系の例外
  const code = (err as { code?: string })?.code;
  if (code === "ETIMEDOUT" || code === "ECONNRESET" || code === "ENOTFOUND")
    return { cls: "transient", reason: `ネットワーク ${code}` };
 
  // 4) 判別できないものは安全側（即中断）に倒す
  return { cls: "hard-fail", reason: "未分類のため安全側で中断" };
}

interface Budget {
  transient: number;       // 例: 6
  repairable: number;      // 例: 2
  semanticInvalid: number; // 例: 1（別戦略で）
  hardCostCeilingUsd: number; // 例: 0.50（このタスクのコスト天井）
}
 
interface Attempt { n: number; cls?: ErrorClass; reason: string; costUsd: number; }
 
async function repairLoop(
  task: { build: (hint?: string) => string; altBuild?: () => string },
  validateFn: (out: string) => { ok: boolean; kind?: string; detail?: string },
  budget: Budget
): Promise<{ ok: boolean; out?: string; attempts: Attempt[] }> {
  const left = { ...budget };
  const attempts: Attempt[] = [];
  let spent = 0;
  let prompt = task.build();
  let usedAlt = false;
 
  for (let n = 1; ; n++) {
    // コスト天井は全クラス共通の最終ストッパー
    if (spent >= budget.hardCostCeilingUsd) {
      attempts.push({ n, reason: `コスト天井 $${budget.hardCostCeilingUsd} 到達`, costUsd: 0 });
      return { ok: false, attempts };
    }
 
    let out: string, cost: number;
    try {
      const res = await callClaude(prompt);     // { text, costUsd } を返す想定
      out = res.text; cost = res.costUsd; spent += cost;
    } catch (e) {
      const c = classify(e);
      attempts.push({ n, cls: c.cls, reason: c.reason, costUsd: 0 });
      if (c.cls === "transient" && left.transient-- > 0) {
        await sleep(backoff(n)); continue;       // 待って同じプロンプトで再送
      }
      return { ok: false, attempts };            // transient以外は即中断
    }
 
    const v = validateFn(out);
    if (v.ok) { attempts.push({ n, reason: "成功", costUsd: cost }); return { ok: true, out, attempts }; }
 
    const c = classify(undefined, v);
    attempts.push({ n, cls: c.cls, reason: `${c.reason}: ${v.detail ?? ""}`, costUsd: cost });
 
    if (c.cls === "repairable" && left.repairable-- > 0) {
      prompt = task.build(`前回は ${v.kind} で失敗しました（${v.detail}）。その点だけ直してください。`);
      continue;
    }
    if (c.cls === "semantic-invalid" && left.semanticInvalid-- > 0 && task.altBuild && !usedAlt) {
      usedAlt = true; prompt = task.altBuild();  // 同じ頼み方を繰り返さず戦略を替える
      continue;
    }
    return { ok: false, attempts };              // 予算切れ・別戦略なし → 諦める
  }
}
 
const backoff = (n: number) => Math.min(1000 * 2 ** (n - 1), 30_000) + Math.random() * 250;
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

// 成功してもクラス内訳が異常なら警告する（無音の劣化を捕まえる）
function inspect(attempts: Attempt[]) {
  const count = (c: ErrorClass) => attempts.filter((a) => a.cls === c).length;
  const total = attempts.reduce((s, a) => s + a.costUsd, 0);
  if (count("repairable") >= 3)
    log.warn("repairable過多: プロンプトか検証に構造的問題の疑い", { attempts });
  if (count("semantic-invalid") >= 1)
    log.warn("semantic-invalid発生: 題材かアプローチの見直しを推奨", { attempts });
  return { total, repaired: count("repairable") };
}