agent-work-loop 0.0.0 → 0.6.22

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-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
+};

package/dist/chunk-FBEUJR2P.js

@@ -0,0 +1,446 @@
+import {
+  WORKTREES_DIR
+} from "./chunk-X5LMP5J7.js";
+import {
+  readRecords
+} from "./chunk-I77CXOEX.js";
+import {
+  loadState
+} from "./chunk-4OCSYHYB.js";
+import {
+  resolveProjectRoot,
+  run
+} from "./chunk-UOPWVM2H.js";
+import {
+  caps,
+  card,
+  makeColors,
+  makeSymbols,
+  makeTokens,
+  padEndDisplay,
+  signal,
+  statusBadge,
+  stringWidth
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/status.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/commands/pipeline-archive.ts
+import fs from "fs";
+import path from "path";
+var ARCHIVE_GRACE_MS = 3 * 24 * 60 * 60 * 1e3;
+function execTakenPath(tasksDir, name) {
+  return path.join(tasksDir, "exec", `${name}.taken.md`);
+}
+function selectArchiveCandidates(tasksDir, now = Date.now(), graceMs = ARCHIVE_GRACE_MS) {
+  const lanes = pipelineLanes(
+    readDirNames(path.join(tasksDir, "plan")),
+    readDirNames(path.join(tasksDir, "exec")),
+    readDirNames(path.join(tasksDir, "review"))
+  );
+  const candidates = [];
+  for (const lane of lanes) {
+    if (lane.status !== "complete") {
+      continue;
+    }
+    let stat;
+    try {
+      stat = fs.statSync(execTakenPath(tasksDir, lane.name));
+    } catch {
+      continue;
+    }
+    if (now - stat.mtimeMs >= graceMs) {
+      candidates.push(lane.name);
+    }
+  }
+  return candidates;
+}
+function ownedFiles(dir, name) {
+  return readDirNames(dir).filter((f) => f.endsWith(".md") && markerBaseName(f) === name);
+}
+function moveWorkitemFiles(tasksDir, name) {
+  let movedAny = false;
+  for (const sub of ["plan", "exec", "review"]) {
+    const dir = path.join(tasksDir, sub);
+    const files = ownedFiles(dir, name);
+    if (files.length === 0) {
+      continue;
+    }
+    const destDir = path.join(tasksDir, "archive", name, sub);
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const f of files) {
+      fs.renameSync(path.join(dir, f), path.join(destDir, f));
+      movedAny = true;
+    }
+  }
+  return movedAny;
+}
+function archiveCompletedWorkitems(tasksDir, now = Date.now(), graceMs = ARCHIVE_GRACE_MS) {
+  const candidates = selectArchiveCandidates(tasksDir, now, graceMs);
+  const archived = [];
+  for (const name of candidates) {
+    if (moveWorkitemFiles(tasksDir, name)) {
+      archived.push(name);
+    }
+  }
+  return archived;
+}
+function archiveAllLanes(root, now = Date.now(), graceMs = ARCHIVE_GRACE_MS) {
+  const result = {
+    main: archiveCompletedWorkitems(path.join(root, ".tasks"), now, graceMs)
+  };
+  const base = path.join(root, WORKTREES_DIR);
+  let entries;
+  try {
+    entries = fs.readdirSync(base, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const e of entries) {
+    if (!e.isDirectory()) {
+      continue;
+    }
+    result[e.name] = archiveCompletedWorkitems(path.join(base, e.name, ".tasks"), now, graceMs);
+  }
+  return result;
+}
+
+// src/commands/status.ts
+function buildGateStatus(records) {
+  const gateRecords = records.filter((r) => r.type === "gate");
+  return [1, 2].map((gate) => {
+    const rec = gateRecords.find((r) => r.gate === gate);
+    if (!rec) {
+      return { gate, recorded: false };
+    }
+    const presentedCriteria = Array.isArray(rec.presentedCriteria) ? rec.presentedCriteria : [];
+    const presentedExclusions = Array.isArray(rec.presentedExclusions) ? rec.presentedExclusions : [];
+    return {
+      gate,
+      recorded: true,
+      decision: typeof rec.decision === "string" ? rec.decision : void 0,
+      at: typeof rec.at === "string" ? rec.at : void 0,
+      presentedCriteriaCount: presentedCriteria.length,
+      presentedExclusionsCount: presentedExclusions.length,
+      auto: typeof rec.auto === "boolean" ? rec.auto : void 0
+    };
+  });
+}
+function computeBlockedByDeps(criteria) {
+  const passedIds = new Set(criteria.filter((c) => c.status === "passed").map((c) => String(c.id)));
+  const blocked = [];
+  for (const c of criteria) {
+    if (c.status === "passed") {
+      continue;
+    }
+    const dependsOn = Array.isArray(c.dependsOn) ? c.dependsOn : [];
+    const waitingOn = dependsOn.map(String).filter((d) => !passedIds.has(d));
+    if (waitingOn.length > 0) {
+      blocked.push({ id: String(c.id), waitingOn });
+    }
+  }
+  return blocked;
+}
+function buildStatus(projectRoot) {
+  const state = loadState(projectRoot);
+  const criteria = Array.isArray(state.criteria) ? state.criteria : [];
+  const count = (s) => criteria.filter((c) => c.status === s).length;
+  const records = readRecords();
+  const byType = {};
+  for (const r of records) {
+    const t = String(r.type);
+    byType[t] = (byType[t] ?? 0) + 1;
+  }
+  const latestAttempt = records.find((r) => r.type === "attempt");
+  const lastAttempt = latestAttempt && typeof latestAttempt.result === "string" ? latestAttempt.result : null;
+  const workitem = typeof state.workitem === "string" ? state.workitem : null;
+  const gates = buildGateStatus(records.filter((r) => r.workitem === workitem));
+  return {
+    generation: typeof state.generation === "number" ? state.generation : 1,
+    phase: typeof state.phase === "string" ? state.phase : null,
+    workitem,
+    gates,
+    criteria: {
+      total: criteria.length,
+      passed: count("passed"),
+      blocked: count("blocked"),
+      inProgress: count("in_progress"),
+      pending: count("pending"),
+      blockedByDeps: computeBlockedByDeps(criteria)
+    },
+    records: { total: records.length, byType },
+    lastAttempt
+  };
+}
+function classifyAncestorExit(exitCode) {
+  if (exitCode === 0) {
+    return "present";
+  }
+  if (exitCode === 1) {
+    return "diverged";
+  }
+  if (exitCode === 128) {
+    return "not-found";
+  }
+  return "unknown";
+}
+async function checkMissingAcCommits(projectRoot) {
+  const state = loadState(projectRoot);
+  const criteria = Array.isArray(state.criteria) ? state.criteria : [];
+  const withCommit = criteria.filter(
+    (c) => typeof c.commit === "string" && c.commit.length > 0
+  );
+  if (withCommit.length === 0) {
+    return [];
+  }
+  try {
+    const head = await run({
+      cmd: "git",
+      args: ["rev-parse", "--verify", "--quiet", "HEAD"],
+      cwd: projectRoot,
+      timeoutMs: 1e4
+    });
+    if (head.exitCode !== 0) {
+      return [];
+    }
+    const out = [];
+    for (const c of withCommit) {
+      const r = await run({
+        cmd: "git",
+        args: ["merge-base", "--is-ancestor", c.commit, "HEAD"],
+        cwd: projectRoot,
+        timeoutMs: 1e4
+      });
+      const kind = classifyAncestorExit(r.exitCode);
+      if (kind === "diverged" || kind === "not-found") {
+        out.push({ id: String(c.id), commit: c.commit, reason: kind });
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function decisionColored(t, decision) {
+  if (decision === "approved") {
+    return t.success(decision);
+  }
+  if (decision === "rejected" || decision === "abandoned") {
+    return t.danger(decision);
+  }
+  if (decision === "modified" || decision === "more-work" || decision === "split") {
+    return t.warning(decision);
+  }
+  return decision;
+}
+function renderStatus(report, c) {
+  const color = makeColors(c.color);
+  const t = makeTokens(c);
+  const s = makeSymbols(c);
+  if (report.phase === null && report.criteria.total === 0 && report.records.total === 0) {
+    return card(
+      "\uC9C4\uD589 \uC0C1\uD669",
+      [
+        `${signal(c, "info")} \uC544\uC9C1 \uC2DC\uC791 \uC804\uC785\uB2C8\uB2E4.`,
+        `${s.lastBranch} \uBAA9\uD45C\uB97C \uC8FC\uACE0 awl-loop \uB97C \uC2E4\uD589\uD558\uC138\uC694.`
+      ],
+      c
+    );
+  }
+  const cr = report.criteria;
+  const typeSummary = Object.entries(report.records.byType).map(([t2, n]) => `${t2} ${n}`).join(" \xB7 ");
+  const out = [];
+  out.push(
+    `\uB2E8\uACC4  ${report.phase ?? "(\uC5C6\uC74C)"}${report.workitem ? `  ${color.dim(report.workitem)}` : ""}`
+  );
+  out.push(
+    `${s.branch} \uC644\uB8CC \uC870\uAC74  ${color.bold(`${cr.passed}/${cr.total}`)} \uD1B5\uACFC  ${color.dim(`(\uB9C9\uD798 ${cr.blocked}, \uC9C4\uD589 ${cr.inProgress}, \uB300\uAE30 ${cr.pending})`)}`
+  );
+  for (const b of cr.blockedByDeps) {
+    out.push(
+      `${s.vGuide}   ${s.lastBranch} ${signal(c, "warn")} ${color.yellow(b.id)} \uBE14\uB85D\uB428  ${color.dim(`(\uB300\uAE30: ${b.waitingOn.join(", ")})`)}`
+    );
+  }
+  for (const m of report.missingAcCommits ?? []) {
+    const why = m.reason === "diverged" ? "\uB2E4\uB978 \uACC4\uBCF4" : "\uCEE4\uBC0B \uC5C6\uC74C";
+    out.push(
+      `${s.vGuide}   ${s.lastBranch} ${signal(c, "warn")} ${color.yellow(m.id)} \uCEE4\uBC0B\uC774 HEAD\uC5D0 \uC5C6\uC74C  ${color.dim(`(${m.commit.slice(0, 10)}, ${why})`)}`
+    );
+  }
+  out.push(
+    `${s.branch} \uAE30\uB85D       ${report.records.total}\uAC1C  ${color.dim(typeSummary ? `(${typeSummary})` : "")}`
+  );
+  out.push(`${s.lastBranch} \uCD5C\uADFC \uAC80\uC99D  ${report.lastAttempt ?? color.dim("(\uC5C6\uC74C)")}`);
+  for (const g of report.gates) {
+    if (!g.recorded) {
+      out.push(`    ${s.lastBranch} ${signal(c, "info")} \uAC8C\uC774\uD2B8 ${g.gate}  ${color.dim("\uB300\uAE30\uC911")}`);
+      continue;
+    }
+    const when = g.at ? g.at.slice(0, 16).replace("T", " ") : "";
+    const summary = `\uC644\uB8CC\uC870\uAC74 ${g.presentedCriteriaCount ?? 0}\uAC1C, \uC81C\uC678 ${g.presentedExclusionsCount ?? 0}\uAC74`;
+    const autoTag = g.auto ? color.dim(" (\uC790\uB3D9)") : "";
+    out.push(
+      `    ${s.lastBranch} \uAC8C\uC774\uD2B8 ${g.gate}  ${decisionColored(t, g.decision ?? "")}${autoTag}   ${when}   ${color.dim(summary)}`
+    );
+  }
+  return card(`\uC9C4\uD589 \uC0C1\uD669 \xB7 ${report.generation}\uC138\uB300`, out, c);
+}
+function markerBaseName(f) {
+  return f.replace(/\.md$/, "").replace(/\.(taken|hold|pass)$/, "");
+}
+function pipelineLanes(planFiles, execFiles, reviewFiles) {
+  const isMd = (f) => f.endsWith(".md");
+  const names = /* @__PURE__ */ new Set();
+  for (const f of [...planFiles, ...execFiles, ...reviewFiles]) {
+    if (isMd(f)) {
+      names.add(markerBaseName(f));
+    }
+  }
+  const lanes = [];
+  for (const name of names) {
+    let status;
+    if (reviewFiles.includes(`${name}.md`)) {
+      status = "blocked";
+    } else if (planFiles.includes(`${name}.hold.md`)) {
+      status = "blocked";
+    } else if (execFiles.includes(`${name}.taken.md`)) {
+      status = "complete";
+    } else if (execFiles.includes(`${name}.md`)) {
+      status = "reviewing";
+    } else if (planFiles.includes(`${name}.taken.md`)) {
+      status = "executing";
+    } else {
+      status = "pending";
+    }
+    lanes.push({ name, status });
+  }
+  lanes.sort((a, b) => a.name.localeCompare(b.name));
+  return lanes;
+}
+function nameColWidth(names) {
+  return Math.max(...names.map(stringWidth), 4) + 2;
+}
+function readDirNames(dir) {
+  try {
+    return fs2.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function collectPipelineLaneGroups(root) {
+  const base = path2.join(root, WORKTREES_DIR);
+  let entries;
+  try {
+    entries = fs2.readdirSync(base, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const groups = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) {
+      continue;
+    }
+    const tasks = path2.join(base, e.name, ".tasks");
+    const workitems = pipelineLanes(
+      readDirNames(path2.join(tasks, "plan")),
+      readDirNames(path2.join(tasks, "exec")),
+      readDirNames(path2.join(tasks, "review"))
+    );
+    groups.push({ name: e.name, workitems });
+  }
+  groups.sort((a, b) => a.name.localeCompare(b.name));
+  return groups;
+}
+function mainTreeGroup(root) {
+  const tasks = path2.join(root, ".tasks");
+  return {
+    name: "main",
+    workitems: pipelineLanes(
+      readDirNames(path2.join(tasks, "plan")),
+      readDirNames(path2.join(tasks, "exec")),
+      readDirNames(path2.join(tasks, "review"))
+    )
+  };
+}
+function renderPipelineGroups(groups, c) {
+  const color = makeColors(c.color);
+  const allNames = groups.flatMap((g) => g.workitems.map((w) => w.name));
+  const nameWidth = nameColWidth(allNames);
+  const out = [];
+  groups.forEach((g, i) => {
+    if (i > 0) {
+      out.push("");
+    }
+    out.push(color.bold(g.name));
+    if (g.workitems.length === 0) {
+      out.push(`  ${color.dim("(workitem \uC5C6\uC74C)")}`);
+      return;
+    }
+    for (const w of g.workitems) {
+      out.push(`  ${statusBadge(c, w.status)}  ${padEndDisplay(w.name, nameWidth)}${w.status}`);
+    }
+  });
+  return card(`\uD30C\uC774\uD504\uB77C\uC778 ${groups.length}\uAC1C \uB808\uC778`, out, c);
+}
+async function runStatus(opts) {
+  const root = resolveProjectRoot();
+  if (!root) {
+    const cc = caps();
+    process.stderr.write(
+      `
+  ${signal(cc, "error")} \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.
+      ${makeSymbols(cc).lastBranch} awl init \uC744 \uC2E4\uD589\uD558\uC138\uC694.
+`
+    );
+    process.exit(1);
+  }
+  if (opts.pipeline === true) {
+    let archived;
+    if (opts.archive === true) {
+      archived = archiveAllLanes(root);
+    }
+    const groups = [mainTreeGroup(root), ...collectPipelineLaneGroups(root)];
+    if (opts.json) {
+      process.stdout.write(
+        `${JSON.stringify({ lanes: groups, ...archived ? { archived } : {} }, null, 2)}
+`
+      );
+    } else {
+      if (archived) {
+        const total = Object.values(archived).reduce((n, names) => n + names.length, 0);
+        const color = makeColors(caps().color);
+        process.stdout.write(`  \uBCF4\uAD00 ${color.bold(String(total))}\uAC74
+`);
+      }
+      process.stdout.write(`${renderPipelineGroups(groups, caps())}
+`);
+    }
+    return;
+  }
+  const report = {
+    ...buildStatus(root),
+    missingAcCommits: await checkMissingAcCommits(root)
+  };
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${renderStatus(report, caps())}
+`);
+  }
+}
+
+export {
+  buildStatus,
+  classifyAncestorExit,
+  checkMissingAcCommits,
+  renderStatus,
+  markerBaseName,
+  pipelineLanes,
+  readDirNames,
+  collectPipelineLaneGroups,
+  renderPipelineGroups,
+  runStatus
+};