Skip to content
TypeScript
28.5 KB
Raw Blame
/**
 * 리포트 (PRD §14, §22.3) — self-contained 결정 대시보드(외부 JS/CDN 0, script 0, 모든 입력 escape).
 * 인터랙션은 전부 CSS 로만: 라디오 :checked 탭 · :hover 하이라이트 · <details> 토글.
 *
 * 탭 구성:
 *   Decide — 한눈에 보는 답: 관점별 승자 스트립 · 파레토 결정 평면 · 평행좌표(전 축 트레이드오프) · 축별 순위막대
 *   Detail — 표(정확도·효율·종합점수·과제 매트릭스·실패 원인·미수집·제외) 드릴다운
 *   Flow   — 서브에이전트 흐름 그래프
 */
import { writeFileSync } from "node:fs";
import { THEME, philosophy, svgWordmark } from "./brand";
import { DETAILS_CSS, esc, graphSection } from "./flow";
import { tr } from "./i18n";
import type { ComboMetrics } from "./metrics";
import { bestByPerspectiveDetailed, compositeScore, sortCombos } from "./metrics";
import type { Combo, FlowGraph, Lang, RunResult } from "./models";

export interface ReportInput {
  metrics: ComboMetrics[];
  graphs: FlowGraph[];
  results: RunResult[];
  excluded: Combo[];
  tasks: string[];
  bench: string;
  language: Lang;
  judge: boolean;
  score: boolean;
  mock: boolean;
  goal?: string;
}

const COST_MARK = { actual: "✓", estimated: "~", none: "" } as const;

/** 조합별 안정적 색 — sortCombos 순서로 결정적 배정(모든 차트 동일).
 *  Olympus 알파인: 다크 위에서 읽히는 절제된(desaturated) 테크니컬 톤. */
const PALETTE = [
  "#cdd2d8", // silver (snow)
  "#7fa8c0", // glacier blue
  "#8fb8a6", // sage
  "#c8a87a", // sand
  "#b98a8a", // clay
  "#9aa0c8", // periwinkle steel
  "#a9b2ba", // ash
  "#7d93a8", // slate
  "#b3a98c", // stone
  "#8c9e8f", // lichen
  "#a88fb0", // heather
  "#6f8f95", // teal slate
];
function comboColorMap(metrics: ComboMetrics[]): Map<string, string> {
  const order = sortCombos(metrics);
  const map = new Map<string, string>();
  order.forEach((m, i) => map.set(m.comboId, PALETTE[i % PALETTE.length]!));
  return map;
}

// ── 포맷터 ───────────────────────────────────────────────
function fmtMetric(metric: keyof ComboMetrics, v: number): string {
  switch (metric) {
    case "accuracy":
    case "accuracyAtK":
      return `${v.toFixed(1)}%`;
    case "costUsd":
    case "estimatedCostUsd":
      return `$${v.toFixed(4)}`;
    case "effectiveCostUsd":
      return `$${v.toFixed(4)}`;
    case "wallTimeMs":
      return `${(v / 1000).toFixed(1)}s`;
    case "totalTokens":
      return v.toLocaleString("en-US");
    case "consistency":
      return `${v.toFixed(0)}%`;
    case "qualityScore":
      return `${v.toFixed(1)}/10`;
    default:
      return String(Math.round(v * 100) / 100);
  }
}

function th(cells: string[]): string {
  return `<tr>${cells.map((c) => `<th>${esc(c)}</th>`).join("")}</tr>`;
}
function td(cells: string[], cls: (i: number) => string = () => ""): string {
  return `<tr>${cells.map((c, i) => `<td class="${cls(i)}">${c}</td>`).join("")}</tr>`;
}
function section(title: string, body: string, sub?: string): string {
  const s = sub ? `<p class="sub">${esc(sub)}</p>` : "";
  return `<section><h2>${esc(title)}</h2>${s}${body}</section>`;
}
function swatch(color: string): string {
  return `<span class="sw" style="background:${color}"></span>`;
}

// ── 축 정의(공통) ─────────────────────────────────────────
type Dir = "max" | "min";
interface Axis {
  key: keyof ComboMetrics;
  label: string;
  dir: Dir;
  nullable?: boolean;
  fmt: (v: number) => string;
}
/**
 * 결정 축(사용자가 실제로 고르는 기준). 진단 지표(토큰·툴콜·서브에이전트)는 Detail 표로 강등.
 * 데이터가 없는 축(예: judge off → quality, 비용 미수집 → $/solved)은 호출부에서 자동 제외.
 */
function axes(lang: Lang): Axis[] {
  return [
    { key: "accuracy", label: tr(lang, "col_acc"), dir: "max", fmt: (v) => `${v.toFixed(0)}%` },
    {
      key: "consistency",
      label: tr(lang, "col_consistency"),
      dir: "max",
      fmt: (v) => `${v.toFixed(0)}%`,
    },
    {
      key: "effectiveCostUsd",
      label: tr(lang, "col_effcost"),
      dir: "min",
      nullable: true,
      fmt: (v) => `$${v.toFixed(4)}`,
    },
    {
      key: "wallTimeMs",
      label: tr(lang, "col_wall"),
      dir: "min",
      fmt: (v) => `${(v / 1000).toFixed(1)}s`,
    },
    {
      key: "qualityScore",
      label: tr(lang, "persp_quality"),
      dir: "max",
      nullable: true,
      fmt: (v) => `${v.toFixed(1)}/10`,
    },
  ];
}
/** 데이터가 있는(범위가 잡히는) 축만. quality(judge off)·$/solved(비용 미수집)는 자동 탈락. */
function liveAxes(metrics: ComboMetrics[], lang: Lang): Axis[] {
  return axes(lang).filter((a) => axisRange(metrics, a) !== null);
}
/** 한 축의 유한값 범위. */
function axisRange(metrics: ComboMetrics[], a: Axis): { min: number; max: number } | null {
  const vs = metrics
    .map((m) => m[a.key])
    .filter((v): v is number => typeof v === "number" && Number.isFinite(v));
  if (!vs.length) return null;
  return { min: Math.min(...vs), max: Math.max(...vs) };
}
/** 0(나쁨)–1(좋음) 정규화. 동률 범위는 0.5. */
function norm(v: number, r: { min: number; max: number }, dir: Dir): number {
  const span = r.max - r.min;
  if (span === 0) return 0.5;
  return dir === "max" ? (v - r.min) / span : (r.max - v) / span;
}

// ── 0. 관점별 승자 스트립 ─────────────────────────────────
function verdictStrip(input: ReportInput, colors: Map<string, string>): string {
  const lang = input.language;
  const best = bestByPerspectiveDetailed(input.metrics, lang, {
    judge: input.judge,
    tier: "decision",
  });
  const cards = best
    .map((b) => {
      const c = colors.get(b.comboId) ?? THEME.mist;
      return `<div class="vcard" style="--c:${c}">
<div class="vlabel">${esc(b.label)}</div>
<div class="vval">${esc(fmtMetric(b.metric, b.value))}</div>
<div class="vcombo">${swatch(c)}<code>${esc(b.comboId)}</code></div>
</div>`;
    })
    .join("");
  return `<div class="verdict">${cards}</div>`;
}

// ── 범례(조합 색) ─────────────────────────────────────────
function legend(metrics: ComboMetrics[], colors: Map<string, string>, lang: Lang): string {
  const items = sortCombos(metrics)
    .map(
      (m) =>
        `<span class="lg"><span class="sw" style="background:${colors.get(m.comboId)}"></span><code>${esc(m.comboId)}</code></span>`,
    )
    .join("");
  return `<div class="legend"><span class="lg-title">${esc(tr(lang, "legend_combos"))}</span>${items}</div>`;
}

// ── 파레토 결정 평면 ──────────────────────────────────────
function paretoFrontier(pts: ComboMetrics[]): ComboMetrics[] {
  return pts.filter(
    (a) =>
      !pts.some(
        (b) =>
          b.comboId !== a.comboId &&
          b.costUsd! <= a.costUsd! &&
          b.accuracy >= a.accuracy &&
          (b.costUsd! < a.costUsd! || b.accuracy > a.accuracy),
      ),
  );
}

function renderScatter(metrics: ComboMetrics[], colors: Map<string, string>, lang: Lang): string {
  const pts = metrics.filter((m) => m.costUsd !== null && Number.isFinite(m.costUsd));
  if (!pts.length) return `<p class="muted">${esc(tr(lang, "uncollected_note"))}</p>`;
  const W = 640;
  const H = 380;
  const padL = 58;
  const padR = 24;
  const padT = 24;
  const padB = 46;
  const costs = pts.map((m) => m.costUsd!);
  const maxCost = Math.max(...costs, 0.0001);
  const xf = (c: number) => padL + (c / maxCost) * (W - padL - padR);
  const yf = (a: number) => H - padB - (a / 100) * (H - padT - padB);
  const p: string[] = [];
  p.push(
    `<svg viewBox="0 0 ${W} ${H}" width="100%" preserveAspectRatio="xMidYMid meet" xmlns="http://www.w3.org/2000/svg" font-family="ui-sans-serif,system-ui,sans-serif" class="pareto">`,
  );
  // gridlines + ticks (accuracy 0..100 by 25; cost 0..max by quarters)
  for (let g = 0; g <= 100; g += 25) {
    const y = yf(g);
    p.push(
      `<line x1="${padL}" y1="${y}" x2="${W - padR}" y2="${y}" stroke="${THEME.grid}" stroke-width="1"/>`,
    );
    p.push(
      `<text x="${padL - 8}" y="${y + 3}" font-size="10" text-anchor="end" fill="${THEME.mist}">${g}</text>`,
    );
  }
  for (let q = 0; q <= 4; q++) {
    const c = (maxCost * q) / 4;
    const x = xf(c);
    p.push(
      `<line x1="${x}" y1="${padT}" x2="${x}" y2="${H - padB}" stroke="${THEME.grid}" stroke-width="1" opacity="0.6"/>`,
    );
    p.push(
      `<text x="${x}" y="${H - padB + 16}" font-size="10" text-anchor="middle" fill="${THEME.mist}">$${c.toFixed(4)}</text>`,
    );
  }
  // axis titles
  p.push(
    `<text x="${(padL + W - padR) / 2}" y="${H - 6}" font-size="11" text-anchor="middle" fill="${THEME.ink}">${esc(tr(lang, "col_cost"))} ($) →</text>`,
  );
  p.push(
    `<text x="14" y="${(padT + H - padB) / 2}" font-size="11" text-anchor="middle" fill="${THEME.ink}" transform="rotate(-90 14 ${(padT + H - padB) / 2})">${esc(tr(lang, "col_acc"))} (%) ↑</text>`,
  );

  // Pareto frontier: 더 싸면서 더 정확 — 비지배 집합.
  const frontier = paretoFrontier(pts);
  const fset = new Set(frontier.map((m) => m.comboId));
  const fpath = frontier
    .slice()
    .sort((a, b) => a.costUsd! - b.costUsd!)
    .map(
      (m, i) => `${i === 0 ? "M" : "L"}${xf(m.costUsd!).toFixed(1)},${yf(m.accuracy).toFixed(1)}`,
    )
    .join(" ");
  if (frontier.length > 1) {
    p.push(
      `<path d="${fpath}" fill="none" stroke="${THEME.rope}" stroke-width="2.5" stroke-dasharray="6 4" opacity="0.9"/>`,
    );
  }
  p.push(
    `<text x="${padL + 6}" y="${padT + 4}" font-size="11" fill="${THEME.rope}" font-weight="600">— ${esc(tr(lang, "pareto_frontier"))} ★</text>`,
  );

  // dominated 먼저(흐리게), frontier 나중(선명·고리)
  const draw = (m: ComboMetrics, onFront: boolean) => {
    const color = colors.get(m.comboId) ?? THEME.mist;
    const cx = xf(m.costUsd!).toFixed(1);
    const cy = yf(m.accuracy).toFixed(1);
    if (onFront) {
      p.push(
        `<g class="pt front"><circle cx="${cx}" cy="${cy}" r="11" fill="none" stroke="${THEME.rope}" stroke-width="2"/><circle cx="${cx}" cy="${cy}" r="6.5" fill="${color}"/><title>★ ${esc(m.comboId)} — ${m.accuracy.toFixed(1)}% · $${m.costUsd!.toFixed(4)}</title></g>`,
      );
    } else {
      p.push(
        `<g class="pt"><circle cx="${cx}" cy="${cy}" r="5" fill="${color}" opacity="0.5"/><title>${esc(m.comboId)} — ${m.accuracy.toFixed(1)}% · $${m.costUsd!.toFixed(4)}</title></g>`,
      );
    }
  };
  for (const m of pts) if (!fset.has(m.comboId)) draw(m, false);
  for (const m of pts) if (fset.has(m.comboId)) draw(m, true);
  p.push("</svg>");
  return `<div class="chart">${p.join("")}</div>`;
}

// ── 평행좌표(전 축 트레이드오프) ──────────────────────────
function parallelCoords(metrics: ComboMetrics[], colors: Map<string, string>, lang: Lang): string {
  const sorted = sortCombos(metrics);
  if (sorted.length < 2) return `<p class="muted">—</p>`;
  const ax = liveAxes(metrics, lang);
  const ranges = ax.map((a) => axisRange(metrics, a));
  const W = 720;
  const H = 320;
  const padL = 40;
  const padR = 40;
  const padT = 46;
  const padB = 40;
  const yTop = padT;
  const yBot = H - padB;
  const n = ax.length;
  const xAt = (i: number) => padL + (n === 1 ? 0 : (i * (W - padL - padR)) / (n - 1));
  const yAt = (norm01: number) => yBot - norm01 * (yBot - yTop);

  const p: string[] = [];
  p.push(
    `<svg viewBox="0 0 ${W} ${H}" width="100%" preserveAspectRatio="xMidYMid meet" xmlns="http://www.w3.org/2000/svg" font-family="ui-sans-serif,system-ui,sans-serif" class="pc">`,
  );
  // axes
  ax.forEach((a, i) => {
    const x = xAt(i);
    const r = ranges[i];
    p.push(
      `<line x1="${x}" y1="${yTop}" x2="${x}" y2="${yBot}" stroke="${THEME.grid}" stroke-width="1.5"/>`,
    );
    p.push(
      `<text x="${x}" y="${yTop - 22}" font-size="11" font-weight="600" text-anchor="middle" fill="${THEME.ink}">${esc(a.label)}</text>`,
    );
    p.push(
      `<text x="${x}" y="${yTop - 9}" font-size="9" text-anchor="middle" fill="${THEME.rope}">↑ ${esc(tr(lang, "axis_better"))}</text>`,
    );
    if (r) {
      // top = better extreme, bottom = worse extreme
      const topVal = a.dir === "max" ? r.max : r.min;
      const botVal = a.dir === "max" ? r.min : r.max;
      p.push(
        `<text x="${x}" y="${yTop - 1}" font-size="9" text-anchor="middle" fill="${THEME.mist}">${esc(a.fmt(topVal))}</text>`,
      );
      p.push(
        `<text x="${x}" y="${yBot + 14}" font-size="9" text-anchor="middle" fill="${THEME.mist}">${esc(a.fmt(botVal))}</text>`,
      );
    }
  });
  // one polyline per combo
  for (const m of sorted) {
    const color = colors.get(m.comboId) ?? THEME.mist;
    const verts: { x: number; y: number; label: string }[] = [];
    const titleParts: string[] = [];
    ax.forEach((a, i) => {
      const v = m[a.key];
      const r = ranges[i];
      if (typeof v !== "number" || !Number.isFinite(v) || !r) {
        titleParts.push(`${a.label}: ${tr(lang, "uncollected_note")}`);
        return; // nullable(cost) 미수집 → 정점 생략(선이 그 축을 건너뜀)
      }
      const x = xAt(i);
      const y = yAt(norm(v, r, a.dir));
      verts.push({ x, y, label: a.fmt(v) });
      titleParts.push(`${a.label}: ${a.fmt(v)}`);
    });
    if (verts.length < 2) continue;
    const pts = verts.map((d) => `${d.x.toFixed(1)},${d.y.toFixed(1)}`).join(" ");
    p.push(
      `<g class="pcg"><polyline class="pcline" points="${pts}" fill="none" stroke="${color}" stroke-width="2"/>`,
    );
    for (const d of verts)
      p.push(
        `<circle class="pcdot" cx="${d.x.toFixed(1)}" cy="${d.y.toFixed(1)}" r="3.2" fill="${color}"/>`,
      );
    p.push(`<title>${esc(m.comboId)} · ${esc(titleParts.join(" · "))}</title></g>`);
  }
  p.push("</svg>");
  return `<div class="chart">${p.join("")}</div>`;
}

// ── 축별 순위막대(스몰 멀티플) ────────────────────────────
function rankBars(metrics: ComboMetrics[], colors: Map<string, string>, lang: Lang): string {
  const ax = liveAxes(metrics, lang);
  const blocks = ax
    .map((a) => {
      const r = axisRange(metrics, a);
      if (!r) return "";
      const ranked = metrics
        .filter((m) => typeof m[a.key] === "number" && Number.isFinite(m[a.key] as number))
        .map((m) => ({ m, v: m[a.key] as number, n: norm(m[a.key] as number, r, a.dir) }))
        .sort((x, y) => y.n - x.n);
      const rows = ranked
        .map((d, i) => {
          const color = colors.get(d.m.comboId) ?? THEME.mist;
          const w = Math.max(4, d.n * 100);
          return `<div class="rb-row${i === 0 ? " rb-best" : ""}">
<span class="rb-name">${swatch(color)}<code>${esc(d.m.comboId)}</code></span>
<span class="rb-bar"><i style="width:${w.toFixed(1)}%;background:${color}"></i></span>
<span class="rb-val">${esc(a.fmt(d.v))}${i === 0 ? " <b>★</b>" : ""}</span>
</div>`;
        })
        .join("");
      return `<div class="rb-block"><div class="rb-title">${esc(a.label)} <span class="rb-dir">↑ ${esc(tr(lang, "axis_better"))}</span></div>${rows}</div>`;
    })
    .join("");
  return `<div class="rankings">${blocks}</div>`;
}

// ── Detail 탭의 표들 ──────────────────────────────────────
function tableBlocks(input: ReportInput): string[] {
  const lang = input.language;
  const sorted = sortCombos(input.metrics);
  const blocks: string[] = [];

  // 0. 관점별 최적(표 형태도 유지 — 접근성/복붙)
  {
    const best = bestByPerspectiveDetailed(input.metrics, lang, { judge: input.judge });
    const rows = best
      .map((b) =>
        td([esc(b.label), `<code>${esc(b.comboId)}</code>`, fmtMetric(b.metric, b.value)]),
      )
      .join("");
    blocks.push(
      section(
        tr(lang, "sec_best"),
        `<table>${th([tr(lang, "col_perspective"), tr(lang, "col_combo"), tr(lang, "col_value")])}${rows}</table>`,
      ),
    );
  }

  // 0.5 종합점수 (opt-in)
  if (input.score) {
    const scores = compositeScore(input.metrics);
    const rows = Object.entries(scores)
      .sort((a, b) => b[1] - a[1])
      .map(([id, s]) => td([`<code>${esc(id)}</code>`, s.toFixed(4)]))
      .join("");
    blocks.push(
      section(
        tr(lang, "sec_score"),
        `<table>${th([tr(lang, "col_combo"), "score"])}${rows}</table>`,
      ),
    );
  }

  // 1. 정확도 (+ 일관성 k/n — 다수결 정확도가 가리는 플레이키니스)
  {
    const rows = sorted
      .map((m) =>
        td([
          `<code>${esc(m.comboId)}</code>`,
          `${m.accuracy.toFixed(1)}%`,
          `${m.accuracyAtK.toFixed(1)}%`,
          `${m.runsPassed ?? 0}/${m.runCount} (${(m.consistency ?? 0).toFixed(0)}%)`,
        ]),
      )
      .join("");
    blocks.push(
      section(
        tr(lang, "sec_accuracy"),
        `<table>${th([tr(lang, "col_combo"), "accuracy", "accuracy@k", tr(lang, "col_consistency")])}${rows}</table>`,
      ),
    );
  }

  // 2. 효율
  {
    const minSub = Math.min(...sorted.map((m) => m.subagentCount));
    const minTok = Math.min(...sorted.map((m) => m.totalTokens));
    const minWall = Math.min(...sorted.map((m) => m.wallTimeMs));
    const rows = sorted
      .map((m) => {
        const cost =
          m.costUsd === null
            ? `<span class="muted">${esc(tr(lang, "uncollected_note"))}</span>`
            : `${COST_MARK[m.costSource]}$${m.costUsd.toFixed(4)}`;
        const est = m.estimatedCostUsd === null ? "—" : `$${m.estimatedCostUsd.toFixed(4)}`;
        const delta =
          m.costUsd !== null && m.estimatedCostUsd !== null
            ? `$${(m.costUsd - m.estimatedCostUsd).toFixed(4)}`
            : "—";
        const eff =
          m.effectiveCostUsd === null || m.effectiveCostUsd === undefined
            ? "—"
            : `$${m.effectiveCostUsd.toFixed(4)}`;
        return td(
          [
            `<code>${esc(m.comboId)}</code>`,
            String(m.subagentCount),
            m.totalTokens.toLocaleString("en-US"),
            cost,
            eff,
            est,
            delta,
            `${(m.wallTimeMs / 1000).toFixed(1)}s`,
            String(m.numTurns),
            String(m.toolCalls),
          ],
          (i) => {
            if (i === 1 && m.subagentCount === minSub) return "best";
            if (i === 2 && m.totalTokens === minTok) return "best";
            if (i === 7 && m.wallTimeMs === minWall) return "best";
            return "";
          },
        );
      })
      .join("");
    blocks.push(
      section(
        tr(lang, "sec_efficiency"),
        `<table>${th(["combo-id", "subagents", "total tok", "cost", tr(lang, "col_effcost"), "est.cost", "Δcost", "wall", "turns", "tool calls"])}${rows}</table>`,
        tr(lang, "effcost_note"),
      ),
    );
  }

  // 4. task 매트릭스
  {
    const head = th([tr(lang, "col_combo"), ...input.tasks]);
    const rows = sorted
      .map((m) => {
        const cells = input.tasks.map((t) => {
          const pt = m.perTask[t];
          if (!pt) return `<td class="na">·</td>`;
          return pt.resolved ? `<td class="pass">✓</td>` : `<td class="failc">✗</td>`;
        });
        return `<tr><td><code>${esc(m.comboId)}</code></td>${cells.join("")}</tr>`;
      })
      .join("");
    blocks.push(section(tr(lang, "sec_matrix"), `<table class="matrix">${head}${rows}</table>`));
  }

  // 6. 실패 task & 원인
  {
    const fails = input.results.filter((r) => !r.success || r.resolved === false);
    const rows = fails
      .slice(0, 200)
      .map((r) =>
        td([
          `<code>${esc(r.comboId)}</code>`,
          esc(r.taskId),
          r.success ? "resolved=false" : "success=false",
          esc(r.error ?? ""),
        ]),
      )
      .join("");
    blocks.push(
      section(
        tr(lang, "sec_failures"),
        fails.length
          ? `<table>${th([tr(lang, "col_combo"), "task", "kind", "error"])}${rows}</table>`
          : "<p>—</p>",
      ),
    );
  }

  // 7. 미수집 지표
  {
    const rows = sorted
      .filter((m) => m.costUsd === null || m.qualityScore === null)
      .map((m) =>
        td([
          `<code>${esc(m.comboId)}</code>`,
          m.costUsd === null ? "cost" : "",
          m.qualityScore === null ? "quality" : "",
        ]),
      )
      .join("");
    blocks.push(
      section(
        tr(lang, "sec_uncollected"),
        `<p>${esc(tr(lang, "uncollected_note"))}</p>${
          rows
            ? `<table>${th([tr(lang, "col_combo"), "null#1", "null#2"])}${rows}</table>`
            : "<p>—</p>"
        }`,
      ),
    );
  }

  // 제외 조합
  if (input.excluded.length) {
    const rows = input.excluded
      .map((c) => td([`<code>${esc(c.comboId)}</code>`, esc(c.excludeReason ?? "")]))
      .join("");
    blocks.push(
      section(
        tr(lang, "excluded_combos"),
        `<table>${th([tr(lang, "col_combo"), "reason"])}${rows}</table>`,
      ),
    );
  }
  return blocks;
}

// ── 셸(탭 + 디자인 시스템) ────────────────────────────────
export function renderReportHtml(input: ReportInput): string {
  const lang = input.language;
  const colors = comboColorMap(input.metrics);

  const mockBanner = input.mock
    ? `<div class="banner mock">${esc(tr(lang, "mock_banner"))}</div>`
    : "";

  // Decide 탭
  const decide = [
    `<p class="lead">${esc(tr(lang, "decide_lead"))}</p>`,
    verdictStrip(input, colors),
    legend(input.metrics, colors, lang),
    section(tr(lang, "sec_scatter"), renderScatter(input.metrics, colors, lang)),
    section(
      tr(lang, "sec_parallel"),
      parallelCoords(input.metrics, colors, lang),
      tr(lang, "parallel_note"),
    ),
    section(tr(lang, "sec_rankings"), rankBars(input.metrics, colors, lang)),
  ].join("\n");

  // Detail 탭
  const detail = tableBlocks(input).join("\n");

  // Flow 탭
  const flow = section(
    tr(lang, "sec_flow"),
    input.graphs.map((gr) => graphSection(gr, lang)).join("\n") || "<p>—</p>",
  );

  return `<!doctype html><html lang="${lang}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>theseus — ${esc(tr(lang, "results_table"))}</title>
<style>
:root{--sea:${THEME.sea};--seaDeep:${THEME.seaDeep};--hull:${THEME.hull};--sail:${THEME.sail};--rope:${THEME.rope};--foam:${THEME.foam};--ink:${THEME.ink};--mist:${THEME.mist};--grid:${THEME.grid};--best:${THEME.best}}
*{box-sizing:border-box}
body{font-family:ui-sans-serif,system-ui,sans-serif;background:var(--sea);color:var(--ink);margin:0;padding:0;line-height:1.45}
.wrap{max-width:980px;margin:0 auto;padding:20px}
h2{font-size:14px;letter-spacing:.06em;text-transform:uppercase;color:var(--sail);margin:26px 0 6px;padding-bottom:5px;border-bottom:1px solid var(--rope)}
.sub{color:var(--mist);font-size:12px;margin:0 0 10px}
.lead{font-size:15px;color:var(--sail);font-weight:600;margin:18px 0 14px}
code{font-family:ui-monospace,monospace;font-size:12px;color:var(--sail)}
table{border-collapse:collapse;margin:8px 0;font-size:13px;background:var(--hull);width:100%}
th,td{border:1px solid var(--grid);padding:5px 9px;text-align:left}
th{background:#1c1f24;color:var(--foam);font-weight:600;letter-spacing:.03em}
.best{background:var(--best);font-weight:600;color:var(--sail)}
.pass{background:rgba(121,181,155,.16);text-align:center;color:#9fceb8}
.failc{background:rgba(210,112,95,.16);text-align:center;color:#e0917f}
.na{text-align:center;color:#4a4f57}
.muted{color:var(--mist)}
.sw{display:inline-block;width:10px;height:10px;border-radius:2px;margin-right:5px;vertical-align:middle}
.banner.mock{background:rgba(205,159,90,.12);border:1px solid #8a6a3a;color:#d9b98a;padding:9px 13px;border-radius:8px;margin:12px 0;font-weight:600}
/* hero */
.hero{background:linear-gradient(135deg,var(--hull),var(--seaDeep));color:var(--sail);padding:22px 24px;display:flex;align-items:center;gap:18px;flex-wrap:wrap;border-bottom:1px solid var(--grid)}
.hero .meta{display:flex;flex-direction:column;gap:3px}
.hero .tag{font-size:13px;color:var(--mist)}
.hero .bench{color:var(--foam);font-family:ui-monospace,monospace;font-size:12px}
.hero .goal{color:var(--rope);font-size:12px}
/* tabs (CSS-only via radio :checked) */
.tabs input{position:absolute;opacity:0;pointer-events:none}
.tabnav{display:flex;gap:4px;background:var(--seaDeep);padding:0 24px;border-bottom:1px solid var(--grid)}
.tabnav label{cursor:pointer;color:var(--mist);padding:11px 18px;font-size:12px;font-weight:600;letter-spacing:.06em;text-transform:uppercase;border-bottom:2px solid transparent}
.tabnav label:hover{color:var(--sail)}
#t-decide:checked~.tabnav label[for=t-decide],
#t-detail:checked~.tabnav label[for=t-detail],
#t-flow:checked~.tabnav label[for=t-flow]{color:var(--sail);border-bottom-color:var(--rope)}
.panel{display:none}
#t-decide:checked~.wrap .p-decide,
#t-detail:checked~.wrap .p-detail,
#t-flow:checked~.wrap .p-flow{display:block}
/* verdict strip */
.verdict{display:grid;grid-template-columns:repeat(auto-fit,minmax(155px,1fr));gap:10px;margin:8px 0 4px}
.vcard{background:var(--hull);border:1px solid var(--grid);border-left:3px solid var(--c);border-radius:8px;padding:11px 13px}
.vlabel{font-size:10px;color:var(--mist);text-transform:uppercase;letter-spacing:.08em}
.vval{font-size:22px;font-weight:700;color:var(--sail);margin:3px 0}
.vcombo code{color:var(--ink)}
/* legend */
.legend{display:flex;flex-wrap:wrap;gap:4px 14px;align-items:center;margin:14px 0 4px;font-size:12px;color:var(--mist)}
.legend .lg-title{font-weight:600;color:var(--sail);margin-right:4px;text-transform:uppercase;letter-spacing:.06em;font-size:11px}
.legend .lg{display:inline-flex;align-items:center}
/* charts */
.chart{background:var(--hull);border:1px solid var(--grid);border-radius:10px;padding:14px;margin:8px 0;overflow:hidden}
.pareto .pt circle{transition:r .1s}
.pareto .pt:hover circle{r:9}
.pc .pcline{opacity:.6;transition:opacity .1s,stroke-width .1s}
.pc .pcdot{opacity:.6;transition:opacity .1s}
.pc:hover .pcline,.pc:hover .pcdot{opacity:.15}
.pc .pcg:hover .pcline{opacity:1;stroke-width:3.4}
.pc .pcg:hover .pcdot{opacity:1}
/* rankings small-multiples */
.rankings{display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:14px;margin:8px 0}
.rb-block{background:var(--hull);border:1px solid var(--grid);border-radius:8px;padding:10px 12px}
.rb-title{font-size:11px;font-weight:700;color:var(--sail);margin-bottom:7px;text-transform:uppercase;letter-spacing:.05em}
.rb-dir{font-weight:400;color:var(--rope);font-size:10px}
.rb-row{display:grid;grid-template-columns:1fr 90px auto;align-items:center;gap:8px;font-size:11px;padding:1.5px 0}
.rb-best{font-weight:600}
.rb-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
.rb-bar{background:#23272d;border-radius:3px;height:9px;overflow:hidden}
.rb-bar i{display:block;height:100%;border-radius:3px}
.rb-val{color:var(--ink);white-space:nowrap;font-variant-numeric:tabular-nums}
.rb-val b{color:var(--rope)}
/* flow */
.theseus-graph{background:var(--hull);border:1px solid var(--grid);border-radius:10px;padding:14px;margin:12px 0;overflow:auto}
.theseus-graph h3{font-size:13px;margin:0 0 8px;color:var(--sail)}
.svg-wrap{overflow:auto}
.foot{margin:34px 0 8px;padding-top:14px;border-top:1px solid var(--grid);color:var(--mist);font-size:12px;font-style:italic}
${DETAILS_CSS}
</style></head><body>
<header class="hero">${svgWordmark()}<div class="meta"><span class="tag">${esc(tr(lang, "app_tagline"))}</span><span class="bench">bench: ${esc(input.bench)}</span>${
    input.goal
      ? `<span class="goal">◈ ${esc(tr(lang, "goal_label"))}: ${esc(input.goal)}</span>`
      : ""
  }</div></header>
<form class="tabs">
<input type="radio" name="tab" id="t-decide" checked>
<input type="radio" name="tab" id="t-detail">
<input type="radio" name="tab" id="t-flow">
<nav class="tabnav">
<label for="t-decide">${esc(tr(lang, "tab_decide"))}</label>
<label for="t-detail">${esc(tr(lang, "tab_detail"))}</label>
<label for="t-flow">${esc(tr(lang, "tab_flow"))}</label>
</nav>
<div class="wrap">
${mockBanner}
<div class="panel p-decide">${decide}</div>
<div class="panel p-detail">${detail}</div>
<div class="panel p-flow">${flow}</div>
<footer class="foot">⚓ ${esc(tr(lang, "philosophy_label"))} — ${esc(philosophy(lang))}</footer>
</div>
</form>
</body></html>`;
}

export function renderReport(input: ReportInput, path: string): void {
  writeFileSync(path, renderReportHtml(input));
}