agent-work-loop 0.0.0 → 0.6.23

package/dist/chunk-C7BR2DCS.js

@@ -0,0 +1,96 @@
+import {
+  checkVersions,
+  getLatestVersionCached,
+  name,
+  version
+} from "./chunk-YTAHVR4P.js";
+import {
+  resolveProjectRoot
+} from "./chunk-UOPWVM2H.js";
+import {
+  packageEngineDir,
+  skillsVersionPath
+} from "./chunk-BUWGQVHT.js";
+import {
+  caps,
+  card,
+  installedEngineVersion,
+  makeColors,
+  makeSymbols,
+  makeTokens,
+  signal
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/version-check.ts
+import fs from "fs";
+import path from "path";
+function readJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readVersionField(p, field) {
+  const raw = readJson(p);
+  if (raw && typeof raw === "object") {
+    const v = raw[field];
+    if (typeof v === "string") {
+      return v;
+    }
+  }
+  return null;
+}
+function gatherVersionInputs(projectRoot, npmLatestVersion = null) {
+  const engineSourceVersion = readVersionField(
+    path.join(packageEngineDir(), "version.json"),
+    "engineVersion"
+  );
+  const installed = installedEngineVersion();
+  const projectEngineVersion = projectRoot ? readVersionField(path.join(projectRoot, ".awl", "config.json"), "engineVersion") : null;
+  const skillsRaw = projectRoot ? readJson(skillsVersionPath(projectRoot)) : null;
+  const installedSkillVersions = {
+    claude: skillsRaw && typeof skillsRaw === "object" ? typeof skillsRaw.claude === "string" ? skillsRaw.claude : null : null,
+    codex: skillsRaw && typeof skillsRaw === "object" ? typeof skillsRaw.codex === "string" ? skillsRaw.codex : null : null
+  };
+  return {
+    packageVersion: version,
+    engineSourceVersion,
+    installedEngineVersion: installed,
+    projectEngineVersion,
+    installedSkillVersions,
+    npmLatestVersion
+  };
+}
+function renderVersionCheck(result, c) {
+  const color = makeColors(c.color);
+  const s = makeSymbols(c);
+  const t = makeTokens(c);
+  if (result.ok) {
+    return card("\uBC84\uC804 \uD655\uC778", [`${signal(c, "ok")} \uBC84\uC804\uC774 \uC804\uBD80 \uC77C\uCE58\uD569\uB2C8\uB2E4.`], c);
+  }
+  const out = [];
+  for (const m of result.mismatches) {
+    out.push(`${signal(c, "warn")} ${m.kind}: ${t.emphasis(m.a)} / ${t.emphasis(m.b)}`);
+    out.push(`${s.lastBranch} ${color.dim(m.hint)}`);
+  }
+  return card(`\uBC84\uC804 \uBD88\uC77C\uCE58 ${result.mismatches.length}\uAC74`, out, c);
+}
+async function runVersionCheck(opts) {
+  const projectRoot = resolveProjectRoot();
+  const npmLatestVersion = await getLatestVersionCached(name);
+  const inputs = gatherVersionInputs(projectRoot, npmLatestVersion);
+  const result = checkVersions(inputs);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  } else {
+    process.stdout.write(renderVersionCheck(result, caps()));
+  }
+}
+
+export {
+  gatherVersionInputs,
+  renderVersionCheck,
+  runVersionCheck
+};

package/dist/chunk-D5OINC3G.js

@@ -0,0 +1,52 @@
+// src/core/usage.ts
+import fs from "fs";
+var DEFAULT_USAGE_PATH = "/tmp/cc-usage.json";
+function readCostSnapshot(file = DEFAULT_USAGE_PATH) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  const num = (v) => typeof v === "number" ? v : void 0;
+  const snap = {};
+  const cost = num(raw.cost);
+  if (cost !== void 0) {
+    snap.cost = cost;
+  }
+  const fiveH = num(raw.five_h_pct);
+  if (fiveH !== void 0) {
+    snap.five_h_pct = fiveH;
+  }
+  const sevenD = num(raw.seven_d_pct);
+  if (sevenD !== void 0) {
+    snap.seven_d_pct = sevenD;
+  }
+  const ts = num(raw.ts);
+  if (ts !== void 0) {
+    snap.ts = ts;
+  }
+  return snap;
+}
+function computeCostDelta(start, end) {
+  if (!start || !end || typeof start.cost !== "number" || typeof end.cost !== "number") {
+    return void 0;
+  }
+  const d = end.cost - start.cost;
+  if (d < 0) {
+    return void 0;
+  }
+  return Math.round(d * 100) / 100;
+}
+
+export {
+  DEFAULT_USAGE_PATH,
+  readCostSnapshot,
+  computeCostDelta
+};

package/dist/chunk-DP4O5ME2.js

@@ -0,0 +1,307 @@
+import {
+  mergeIsolatedHome,
+  removeGitWorktree,
+  removeWorkitemFromState,
+  runWorkNew,
+  sanitizeForGit,
+  worktreeDirtyTracked
+} from "./chunk-ZE6HXOYG.js";
+import {
+  loadState,
+  writeState
+} from "./chunk-4OCSYHYB.js";
+import {
+  resolveProjectRoot,
+  run
+} from "./chunk-UOPWVM2H.js";
+import {
+  caps,
+  card,
+  feedback,
+  makeColors,
+  signal
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/lane.ts
+import fs from "fs";
+import path from "path";
+var WORKTREES_DIR = ".awl-worktrees";
+var PIPELINE_TRIGGERS = ["/awl-pipeline-plan", "/awl-pipeline-exec", "/awl-pipeline-review"];
+function requireRoot() {
+  const root = resolveProjectRoot();
+  if (!root) {
+    process.stderr.write("\n  \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. awl init \uC744 \uC2E4\uD589\uD558\uC138\uC694.\n");
+    process.exit(1);
+  }
+  return root;
+}
+async function isGitWorkTree(root) {
+  const r = await run({
+    cmd: "git",
+    args: ["rev-parse", "--is-inside-work-tree"],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  return r.exitCode === 0 && r.stdout.trim() === "true";
+}
+async function runLaneNew(name, description) {
+  const root = requireRoot();
+  const c = caps();
+  const color = makeColors(c.color);
+  if (!await isGitWorkTree(root)) {
+    process.stderr.write(
+      `
+${feedback(c, "error", "\uB808\uC778\uC744 \uB9CC\uB4E4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4", "\uD604\uC7AC \uC704\uCE58\uAC00 git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4 \u2014 awl lane \uC740 git worktree \uB97C \uC501\uB2C8\uB2E4")}
+`
+    );
+    process.exit(1);
+  }
+  const laneName = sanitizeForGit(name);
+  if (!laneName) {
+    process.stderr.write(`
+${feedback(c, "error", "\uB808\uC778 \uC774\uB984\uC744 \uC785\uB825\uD558\uC138\uC694")}
+`);
+    process.exit(1);
+  }
+  const lanePath = path.join(root, WORKTREES_DIR, laneName);
+  if (fs.existsSync(lanePath)) {
+    process.stderr.write(
+      `
+${feedback(c, "error", `\uC774\uBBF8 \uC874\uC7AC\uD558\uB294 \uB808\uC778\uC785\uB2C8\uB2E4: ${laneName}`, `awl lane rm ${laneName} \uB85C \uBA3C\uC800 \uC815\uB9AC\uD558\uC138\uC694`)}
+`
+    );
+    process.exit(1);
+  }
+  await runWorkNew(name, description, { worktree: true, isolated: true });
+  process.stdout.write(`
+${feedback(c, "ok", `\uB808\uC778 \uC900\uBE44  ${color.bold(laneName)}`)}
+`);
+  process.stdout.write(`    ${color.dim("\uC774 \uB808\uC778\uC758 \uC5ED\uD560 \uC138\uC158\uC5D0\uC11C \uC2A4\uD0AC \uD2B8\uB9AC\uAC70\uB97C \uC2E4\uD589\uD558\uC138\uC694:")}
+`);
+  for (const t of PIPELINE_TRIGGERS) {
+    process.stdout.write(`      ${color.dim(t)}
+`);
+  }
+}
+function parseWorktreeBranches(porcelain) {
+  const map = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const raw of porcelain.split("\n")) {
+    const line = raw.trim();
+    if (line.startsWith("worktree ")) {
+      current = line.slice("worktree ".length);
+    } else if (line.startsWith("branch ") && current) {
+      map.set(current, line.slice("branch ".length).replace(/^refs\/heads\//, ""));
+    } else if (line === "") {
+      current = null;
+    }
+  }
+  return map;
+}
+async function laneBranchMap(root) {
+  const r = await run({
+    cmd: "git",
+    args: ["worktree", "list", "--porcelain"],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  if (r.exitCode !== 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  return parseWorktreeBranches(r.stdout);
+}
+async function unmergedCommitCount(root, branch) {
+  const r = await run({
+    cmd: "git",
+    args: ["rev-list", "--count", `HEAD..${branch}`],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  if (r.exitCode !== 0) {
+    return null;
+  }
+  const n = Number.parseInt(r.stdout.trim(), 10);
+  return Number.isNaN(n) ? null : n;
+}
+var AWL_INTERNAL_DIRS = /* @__PURE__ */ new Set([".awl", ".awl-worktrees", ".claude"]);
+async function worktreeUntracked(root, targetPath) {
+  const r = await run({
+    cmd: "git",
+    args: ["-C", targetPath, "ls-files", "--others", "--exclude-standard"],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  const files = r.stdout.split("\n").map((l) => l.trim()).filter(Boolean).filter((f) => !AWL_INTERNAL_DIRS.has(f.split("/")[0] ?? ""));
+  return { untracked: files.length > 0, count: files.length, first: files[0] };
+}
+function branchOf(branches, lanePath) {
+  const direct = branches.get(lanePath);
+  if (direct) {
+    return direct;
+  }
+  try {
+    return branches.get(fs.realpathSync(lanePath));
+  } catch {
+    return void 0;
+  }
+}
+async function collectLanes(root) {
+  const base = path.join(root, WORKTREES_DIR);
+  let entries;
+  try {
+    entries = fs.readdirSync(base, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const branches = await laneBranchMap(root);
+  const lanes = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) {
+      continue;
+    }
+    const p = path.join(base, e.name);
+    lanes.push({ name: e.name, path: p, branch: branchOf(branches, p) ?? "(detached)" });
+  }
+  lanes.sort((a, b) => a.name.localeCompare(b.name));
+  return lanes;
+}
+function renderLaneList(lanes, c) {
+  const color = makeColors(c.color);
+  if (lanes.length === 0) {
+    return card(
+      "\uB808\uC778",
+      [
+        `${signal(c, "info")} \uB808\uC778\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.`,
+        "",
+        color.dim("awl lane new <name> \uB85C \uACA9\uB9AC \uB808\uC778\uC744 \uB9CC\uB4DC\uC138\uC694.")
+      ],
+      c
+    );
+  }
+  const nameWidth = Math.max(...lanes.map((l) => l.name.length), 4) + 2;
+  const out = [];
+  for (const l of lanes) {
+    out.push(`${color.bold(l.name.padEnd(nameWidth, " "))}${color.dim(l.branch)}`);
+    out.push(`  ${color.dim(l.path)}`);
+  }
+  return card("\uB808\uC778", out, c);
+}
+async function runLaneList(opts) {
+  const root = requireRoot();
+  const lanes = await collectLanes(root);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(lanes, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${renderLaneList(lanes, caps())}
+`);
+  }
+}
+async function runLaneRemove(name, opts = {}) {
+  const root = requireRoot();
+  const c = caps();
+  const color = makeColors(c.color);
+  const laneName = sanitizeForGit(name);
+  if (!laneName) {
+    process.stderr.write(`
+${feedback(c, "error", "\uB808\uC778 \uC774\uB984\uC744 \uC785\uB825\uD558\uC138\uC694")}
+`);
+    process.exit(1);
+  }
+  const lanePath = path.join(root, WORKTREES_DIR, laneName);
+  if (!fs.existsSync(lanePath)) {
+    process.stderr.write(
+      `
+${feedback(c, "error", `\uB808\uC778\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${laneName}`, "awl lane ls \uB85C \uD604\uC874 \uB808\uC778\uC744 \uD655\uC778\uD558\uC138\uC694")}
+`
+    );
+    process.exit(1);
+  }
+  const branches = await laneBranchMap(root);
+  const branch = branchOf(branches, lanePath) ?? `work/${laneName}`;
+  if (!opts.force) {
+    const d = await worktreeDirtyTracked(root, lanePath);
+    if (d.dirty) {
+      process.stderr.write(
+        `
+${feedback(c, "error", `\uB808\uC778\uC5D0 \uCEE4\uBC0B\uB418\uC9C0 \uC54A\uC740 \uBCC0\uACBD ${d.count}\uAC74 (\uC608: ${d.first})`, "--force \uB85C \uAC15\uC81C \uC81C\uAC70\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4")}
+`
+      );
+      process.exit(1);
+    }
+    const u = await worktreeUntracked(root, lanePath);
+    if (u.untracked) {
+      process.stderr.write(
+        `
+${feedback(c, "error", `\uB808\uC778\uC5D0 \uCEE4\uBC0B\uB418\uC9C0 \uC54A\uC740 \uC0C8 \uD30C\uC77C ${u.count}\uAC74 (\uC608: ${u.first})`, "git add\xB7\uCEE4\uBC0B\uD558\uAC70\uB098 --force \uB85C \uAC15\uC81C \uC81C\uAC70\uD558\uC138\uC694")}
+`
+      );
+      process.exit(1);
+    }
+    const unmerged = await unmergedCommitCount(root, branch);
+    if (unmerged === null) {
+      process.stderr.write(
+        `
+${feedback(c, "error", `\uB808\uC778 \uBE0C\uB79C\uCE58 ${branch} \uC758 \uBBF8\uBA38\uC9C0 \uCEE4\uBC0B \uC218\uB97C \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 (rm \uD558\uBA74 \uCEE4\uBC0B\uC774 \uD30C\uAE30\uB420 \uC218 \uC788\uC2B5\uB2C8\uB2E4)`, "\uBA3C\uC800 \uBE0C\uB79C\uCE58\uB97C \uD655\uC778\uD558\uAC70\uB098 --force \uB85C \uAC15\uC81C \uC81C\uAC70\uD558\uC138\uC694")}
+`
+      );
+      process.exit(1);
+    }
+    if (unmerged > 0) {
+      process.stderr.write(
+        `
+${feedback(c, "error", `\uB808\uC778 \uBE0C\uB79C\uCE58 ${branch} \uC5D0 \uBCD1\uD569\uB418\uC9C0 \uC54A\uC740 \uCEE4\uBC0B ${unmerged}\uAC1C (rm \uD558\uBA74 \uD30C\uAE30\uB429\uB2C8\uB2E4)`, "\uBA3C\uC800 \uBCD1\uD569\xB7\uD478\uC2DC\uD558\uAC70\uB098 --force \uB85C \uAC15\uC81C \uC81C\uAC70\uD558\uC138\uC694")}
+`
+      );
+      process.exit(1);
+    }
+  }
+  let merged = null;
+  try {
+    merged = mergeIsolatedHome(path.join(lanePath, ".awl", "home"));
+  } catch (e) {
+    process.stderr.write(
+      `
+${feedback(c, "error", "\uACA9\uB9AC \uD559\uC2B5 \uC804\uC5ED \uBCD1\uD569 \uC2E4\uD328 \u2014 \uB808\uC778\uC744 \uBCF4\uC874\uD569\uB2C8\uB2E4", e instanceof Error ? e.message : String(e))}
+`
+    );
+    process.exit(1);
+  }
+  const removed = await removeGitWorktree(root, lanePath, branch);
+  if (!removed.ok) {
+    process.stderr.write(`
+${feedback(c, "error", "\uB808\uC778 \uC81C\uAC70 \uC2E4\uD328", removed.error ?? "")}
+`);
+    process.exit(1);
+  }
+  if (fs.existsSync(lanePath)) {
+    fs.rmSync(lanePath, { recursive: true, force: true });
+  }
+  const cleaned = removeWorkitemFromState(loadState(root), [name.trim(), laneName]);
+  if (cleaned.removed) {
+    writeState(root, cleaned.state);
+  }
+  process.stdout.write(`
+${feedback(c, "ok", `\uB808\uC778 \uC81C\uAC70  ${color.bold(laneName)}`, branch)}
+`);
+  if (merged && (merged.gotchasAdded > 0 || merged.rulesAdded > 0 || merged.generationsAdded > 0)) {
+    process.stdout.write(
+      `    ${color.dim(`\uD559\uC2B5 \uC804\uC5ED \uBCD1\uD569  gotcha ${merged.gotchasAdded} \xB7 rule ${merged.rulesAdded} \xB7 generation ${merged.generationsAdded}`)}
+`
+    );
+  }
+}
+
+export {
+  WORKTREES_DIR,
+  runLaneNew,
+  parseWorktreeBranches,
+  laneBranchMap,
+  unmergedCommitCount,
+  worktreeUntracked,
+  branchOf,
+  collectLanes,
+  renderLaneList,
+  runLaneList,
+  runLaneRemove
+};

package/dist/chunk-F5LHXBH7.js

@@ -0,0 +1,209 @@
+import {
+  requireConfig
+} from "./chunk-UOPWVM2H.js";
+import {
+  caps,
+  card,
+  generationsDir,
+  makeColors,
+  padEndDisplay,
+  stringWidth
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/metrics.ts
+import fs from "fs";
+import path from "path";
+function computeDurationMs(startedAt, closeAt) {
+  const s = Date.parse(String(startedAt));
+  const e = Date.parse(String(closeAt));
+  if (Number.isNaN(s) || Number.isNaN(e)) {
+    return void 0;
+  }
+  const d = e - s;
+  return d >= 0 ? d : void 0;
+}
+function renderMetricsCaveat() {
+  return "\uC6CC\uD06C\uC544\uC774\uD15C\uB9C8\uB2E4 \uB09C\uC774\uB3C4\uAC00 \uB2E4\uB985\uB2C8\uB2E4 \u2014 \uC138\uB300 \uAC04 \uC808\uB300 \uBE44\uAD50\uBCF4\uB2E4\uB294 \uACBD\uD5A5(\uCD94\uC138)\uB9CC \uCC38\uACE0\uD558\uC138\uC694.";
+}
+function readCoverage(raw) {
+  const c = raw ?? {};
+  const num = (v) => typeof v === "number" ? v : 0;
+  return {
+    auditFindingsTotal: num(c.auditFindingsTotal),
+    addressed: num(c.addressed),
+    excluded: num(c.excluded),
+    excludedApprovedByHuman: c.excludedApprovedByHuman === true
+  };
+}
+function loadGenerations(project) {
+  const dir = generationsDir(project);
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const num = (v) => typeof v === "number" ? v : 0;
+  const generations = [];
+  for (const f of files) {
+    let raw;
+    try {
+      raw = JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"));
+    } catch {
+      continue;
+    }
+    generations.push({
+      workitem: typeof raw.workitem === "string" ? raw.workitem : f.replace(/\.json$/, ""),
+      at: typeof raw.at === "string" ? raw.at : "",
+      criteriaTotal: num(raw.criteriaTotal),
+      avgAttempts: num(raw.avgAttempts),
+      blockedRatio: num(raw.blockedRatio),
+      reviewRejects: num(raw.reviewRejects),
+      proceduralErrors: num(raw.proceduralErrors),
+      gotchaApplied: num(raw.gotchaApplied),
+      gotchaMissed: num(raw.gotchaMissed),
+      refactorCount: num(raw.refactorCount),
+      coverage: readCoverage(raw.coverage),
+      // 배열은 experiment 로 인정하지 않는다 — 쓰기 경로(program.ts)가 Array.isArray 로
+      // 거부하는 것과 대칭. 손상/수기편집된 스냅샷의 배열이 유사 케이스로 오염되는 걸 막는다.
+      ...raw.experiment !== null && typeof raw.experiment === "object" && !Array.isArray(raw.experiment) ? { experiment: raw.experiment } : {},
+      ...typeof raw.startedAt === "string" ? { startedAt: raw.startedAt } : {},
+      ...typeof raw.durationMs === "number" ? { durationMs: raw.durationMs } : {}
+    });
+  }
+  generations.sort((a, b) => a.at.localeCompare(b.at));
+  return generations;
+}
+function renderMetrics(generations, c) {
+  const color = makeColors(c.color);
+  const caveat = color.dim(renderMetricsCaveat());
+  if (generations.length === 0) {
+    return card("\uC138\uB300 \uC9C0\uD45C", ["\uC138\uB300 \uAE30\uB85D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", "", caveat], c);
+  }
+  const idWidth = Math.max(...generations.map((g) => g.workitem.length), 9) + 2;
+  const out = [];
+  out.push(
+    `${padEndDisplay("\uC6CC\uD06C\uC544\uC774\uD15C", idWidth)}\uC644\uB8CC\uC870\uAC74  \uC2DC\uB3C4\uD3C9\uADE0  \uB9C9\uD798\uBE44\uC728  \uB9AC\uBDF0\uC9C0\uC801  \uC808\uCC28\uC2E4\uC218  gotcha\uC801\uC6A9  gotcha\uB204\uB77D  \uB9AC\uD329\uD1A0\uB9C1  \uCEE4\uBC84\uB9AC\uC9C0`
+  );
+  for (const g of generations) {
+    const coverage = `${g.coverage.addressed}/${g.coverage.auditFindingsTotal}`;
+    out.push(
+      `${padEndDisplay(g.workitem, idWidth)}${padEndDisplay(String(g.criteriaTotal), 10)}${padEndDisplay(String(g.avgAttempts), 10)}${padEndDisplay(String(g.blockedRatio), 10)}${padEndDisplay(String(g.reviewRejects), 10)}${padEndDisplay(String(g.proceduralErrors), 10)}${padEndDisplay(String(g.gotchaApplied), 12)}${padEndDisplay(String(g.gotchaMissed), 12)}${padEndDisplay(String(g.refactorCount), 10)}${coverage}`
+    );
+  }
+  out.push("");
+  out.push(caveat);
+  return card(`\uC138\uB300 ${generations.length}\uAC1C \xB7 \uC2DC\uAC04\uC21C`, out, c);
+}
+var str = (v) => typeof v === "string" && v !== "" ? v : "?";
+var round2 = (n) => Math.round(n * 100) / 100;
+function experimentKey(exp) {
+  return `${str(exp?.model)}/${str(exp?.mode)}/${str(exp?.taskType)}`;
+}
+function groupByExperiment(generations) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const g of generations) {
+    if (g.experiment === void 0) {
+      continue;
+    }
+    const key = experimentKey(g.experiment);
+    const arr = buckets.get(key) ?? [];
+    arr.push(g);
+    buckets.set(key, arr);
+  }
+  const groups = [];
+  for (const [key, gens] of buckets) {
+    const n = gens.length;
+    const exp = gens[0]?.experiment ?? {};
+    const durs = gens.map((g) => g.durationMs).filter((d) => typeof d === "number");
+    groups.push({
+      key,
+      model: str(exp.model),
+      mode: str(exp.mode),
+      taskType: str(exp.taskType),
+      count: n,
+      avgAttempts: round2(gens.reduce((s, g) => s + g.avgAttempts, 0) / n),
+      blockedRatio: round2(gens.reduce((s, g) => s + g.blockedRatio, 0) / n),
+      reviewRejects: gens.reduce((s, g) => s + g.reviewRejects, 0),
+      ...durs.length > 0 ? { avgDurationMs: Math.round(durs.reduce((s, d) => s + d, 0) / durs.length) } : {},
+      workitems: gens.map((g) => g.workitem)
+    });
+  }
+  groups.sort((a, b) => a.key.localeCompare(b.key));
+  return groups;
+}
+function fmtDuration(ms) {
+  if (ms === void 0) {
+    return "-";
+  }
+  const min = Math.round(ms / 6e4);
+  const h = Math.floor(min / 60);
+  const m = min % 60;
+  return h > 0 ? `${h}h ${m}m` : `${m}m`;
+}
+function renderCompare(groups, untagged, c) {
+  const color = makeColors(c.color);
+  const caveat = color.dim(renderMetricsCaveat());
+  if (groups.length === 0) {
+    return card(
+      "\uCF00\uC774\uC2A4 \uBE44\uAD50",
+      [`experiment \uD0DC\uADF8\uAC00 \uC788\uB294 \uC138\uB300\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4(\uD0DC\uADF8 \uC5C6\uB294 \uC138\uB300 ${untagged}\uAC1C).`, "", caveat],
+      c
+    );
+  }
+  const keyWidth = Math.max(stringWidth("\uCF00\uC774\uC2A4(model/mode/task)"), ...groups.map((g) => stringWidth(g.key))) + 2;
+  const out = [
+    `${padEndDisplay("\uCF00\uC774\uC2A4(model/mode/task)", keyWidth)}n   \uC2DC\uB3C4\uD3C9\uADE0  \uB9C9\uD798\uBE44\uC728  \uB9AC\uBDF0\uC9C0\uC801  \uC18C\uC694\uD3C9\uADE0`
+  ];
+  for (const g of groups) {
+    out.push(
+      `${padEndDisplay(g.key, keyWidth)}${padEndDisplay(String(g.count), 4)}${padEndDisplay(String(g.avgAttempts), 10)}${padEndDisplay(String(g.blockedRatio), 10)}${padEndDisplay(String(g.reviewRejects), 10)}${fmtDuration(g.avgDurationMs)}`
+    );
+  }
+  if (untagged > 0) {
+    out.push("");
+    out.push(color.dim(`(\uD0DC\uADF8 \uC5C6\uB294 \uC138\uB300 ${untagged}\uAC1C\uB294 \uBE44\uAD50\uC5D0\uC11C \uC81C\uC678)`));
+  }
+  out.push("");
+  out.push(caveat);
+  return card(`\uCF00\uC774\uC2A4 ${groups.length}\uAC1C \uBE44\uAD50`, out, c);
+}
+function runMetrics(opts) {
+  const { config } = requireConfig();
+  const generations = loadGenerations(config.project);
+  if (opts.compare === true) {
+    const groups = groupByExperiment(generations);
+    const untagged = generations.filter((g) => g.experiment === void 0).length;
+    if (opts.json) {
+      process.stdout.write(
+        `${JSON.stringify({ cases: groups, untagged, caveat: renderMetricsCaveat() }, null, 2)}
+`
+      );
+      return;
+    }
+    process.stdout.write(`${renderCompare(groups, untagged, caps())}
+`);
+    return;
+  }
+  if (opts.json) {
+    process.stdout.write(
+      `${JSON.stringify({ generations, caveat: renderMetricsCaveat() }, null, 2)}
+`
+    );
+    return;
+  }
+  process.stdout.write(`${renderMetrics(generations, caps())}
+`);
+}
+
+export {
+  computeDurationMs,
+  renderMetricsCaveat,
+  loadGenerations,
+  renderMetrics,
+  experimentKey,
+  groupByExperiment,
+  fmtDuration,
+  renderCompare,
+  runMetrics
+};