agent-work-loop 0.0.0 → 0.6.23

package/dist/chunk-ZE6HXOYG.js

@@ -0,0 +1,904 @@
+import {
+  DEFAULT_USAGE_PATH,
+  readCostSnapshot
+} from "./chunk-D5OINC3G.js";
+import {
+  buildVerifyBaseline,
+  isCheckPassed,
+  runVerifyChecks,
+  writeVerifyBaseline
+} from "./chunk-QE2CLNBG.js";
+import {
+  gitBranch
+} from "./chunk-IXMAFR4Y.js";
+import {
+  parseRuleFile
+} from "./chunk-IMB46O6S.js";
+import {
+  nextGotchaId
+} from "./chunk-G5LAJ5TV.js";
+import {
+  loadState,
+  migrateState,
+  writeState
+} from "./chunk-4OCSYHYB.js";
+import {
+  loadConfig,
+  resolveProjectRoot,
+  run
+} from "./chunk-UOPWVM2H.js";
+import {
+  installClaudeSkill
+} from "./chunk-BUWGQVHT.js";
+import {
+  caps,
+  card,
+  feedback,
+  globalRoot,
+  makeColors,
+  makeSymbols,
+  makeTokens,
+  signal
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/work.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/commands/learning-merge.ts
+import fs from "fs";
+import path from "path";
+var PARENT_MARKER = ".awl-parent";
+function lessonKey(g) {
+  return (g.lesson ?? "").trim();
+}
+function mergeGotchaLists(from, to) {
+  const merged = [...to];
+  const added = [];
+  const idMap = {};
+  const byLesson = /* @__PURE__ */ new Map();
+  for (const g of to) {
+    const k = lessonKey(g);
+    if (k !== "") {
+      byLesson.set(k, g);
+    }
+  }
+  const fromSorted = [...from].sort((a, b) => a.id.localeCompare(b.id));
+  for (const g of fromSorted) {
+    const key = lessonKey(g);
+    const dup = key !== "" ? byLesson.get(key) : void 0;
+    if (dup) {
+      idMap[g.id] = dup.id;
+      continue;
+    }
+    const newId = nextGotchaId(merged);
+    idMap[g.id] = newId;
+    const shell = { ...g, id: newId };
+    merged.push(shell);
+    if (key !== "") {
+      byLesson.set(key, shell);
+    }
+    added.push(shell);
+  }
+  for (const g of added) {
+    if (g.relations) {
+      g.relations = g.relations.map((r) => ({ ...r, target: idMap[r.target] ?? r.target }));
+    }
+    if (g.sameAs) {
+      g.sameAs = idMap[g.sameAs] ?? g.sameAs;
+    }
+  }
+  return { merged, added, idMap };
+}
+function readGotchasFrom(root) {
+  const dir = path.join(root, "gotchas");
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const f of files.sort()) {
+    try {
+      out.push(JSON.parse(fs.readFileSync(path.join(dir, f), "utf8")));
+    } catch {
+    }
+  }
+  return out;
+}
+function readRulesFrom(root) {
+  const dir = path.join(root, "rules", "active");
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const f of files.sort()) {
+    let text;
+    try {
+      text = fs.readFileSync(path.join(dir, f), "utf8");
+    } catch {
+      continue;
+    }
+    const parsed = parseRuleFile(text, f);
+    if (parsed.rule) {
+      out.push({ text, body: parsed.rule.body });
+    }
+  }
+  return out;
+}
+function nextRuleNum(fileNames) {
+  let max = 0;
+  for (const f of fileNames) {
+    const m = /^R-(\d+)\.md$/.exec(f);
+    if (m?.[1]) {
+      max = Math.max(max, Number(m[1]));
+    }
+  }
+  return max + 1;
+}
+function mergeRules(fromRoot, toRoot, idMap) {
+  const fromRules = readRulesFrom(fromRoot);
+  if (fromRules.length === 0) {
+    return 0;
+  }
+  const toActive = path.join(toRoot, "rules", "active");
+  const toRules = readRulesFrom(toRoot);
+  const toBodies = new Set(toRules.map((r) => r.body.trim()));
+  let toFiles = [];
+  try {
+    toFiles = fs.readdirSync(toActive).filter((f) => f.endsWith(".md"));
+  } catch {
+  }
+  let ruleNum = nextRuleNum(toFiles);
+  let added = 0;
+  for (const r of fromRules) {
+    if (toBodies.has(r.body.trim())) {
+      continue;
+    }
+    const newId = `R-${String(ruleNum).padStart(3, "0")}`;
+    ruleNum += 1;
+    const rewritten = r.text.replace(/^id:[ \t]*.*$/m, `id: ${newId}`).replace(
+      /^source:[ \t]*(\S+)(.*)$/m,
+      (_m, src, rest) => `source: ${idMap[src] ?? src}${rest}`
+    );
+    fs.mkdirSync(toActive, { recursive: true });
+    fs.writeFileSync(path.join(toActive, `${newId}.md`), rewritten);
+    toBodies.add(r.body.trim());
+    added += 1;
+  }
+  return added;
+}
+function copyGenerations(fromRoot, toRoot) {
+  const fromGen = path.join(fromRoot, "generations");
+  if (!fs.existsSync(fromGen)) {
+    return 0;
+  }
+  let copied = 0;
+  const walk = (rel) => {
+    const abs = path.join(fromGen, rel);
+    for (const entry of fs.readdirSync(abs, { withFileTypes: true })) {
+      const childRel = path.join(rel, entry.name);
+      if (entry.isDirectory()) {
+        walk(childRel);
+      } else if (entry.isFile()) {
+        const dest = path.join(toRoot, "generations", childRel);
+        if (!fs.existsSync(dest)) {
+          fs.mkdirSync(path.dirname(dest), { recursive: true });
+          fs.copyFileSync(path.join(fromGen, childRel), dest);
+          copied += 1;
+        }
+      }
+    }
+  };
+  walk(".");
+  return copied;
+}
+function mergeIsolatedLearning(fromRoot, toRoot) {
+  const fromGotchas = readGotchasFrom(fromRoot);
+  const toGotchas = readGotchasFrom(toRoot);
+  const { added, idMap } = mergeGotchaLists(fromGotchas, toGotchas);
+  if (added.length > 0) {
+    const dir = path.join(toRoot, "gotchas");
+    fs.mkdirSync(dir, { recursive: true });
+    for (const g of added) {
+      fs.writeFileSync(path.join(dir, `${g.id}.json`), `${JSON.stringify(g, null, 2)}
+`);
+    }
+  }
+  const rulesAdded = mergeRules(fromRoot, toRoot, idMap);
+  const generationsAdded = copyGenerations(fromRoot, toRoot);
+  return { gotchasAdded: added.length, rulesAdded, generationsAdded };
+}
+function writeParentMarker(isolatedHome) {
+  try {
+    fs.writeFileSync(path.join(isolatedHome, PARENT_MARKER), `${globalRoot()}
+`);
+  } catch {
+  }
+}
+function resolveParentGlobal(isolatedHome) {
+  try {
+    const raw = fs.readFileSync(path.join(isolatedHome, PARENT_MARKER), "utf8").trim();
+    if (raw !== "") {
+      return path.resolve(raw);
+    }
+  } catch {
+  }
+  return globalRoot();
+}
+function mergeIsolatedHome(isolatedHome) {
+  if (!fs.existsSync(isolatedHome)) {
+    return null;
+  }
+  const toRoot = resolveParentGlobal(isolatedHome);
+  if (path.resolve(isolatedHome) === path.resolve(toRoot)) {
+    return null;
+  }
+  return mergeIsolatedLearning(isolatedHome, toRoot);
+}
+
+// src/commands/work.ts
+function countCriteria(criteria) {
+  const arr = Array.isArray(criteria) ? criteria : [];
+  return { passed: arr.filter((c) => c.status === "passed").length, total: arr.length };
+}
+function summarizeWorkitems(state) {
+  const out = [];
+  const currentId = typeof state.workitem === "string" ? state.workitem : null;
+  if (currentId) {
+    const { passed, total } = countCriteria(state.criteria);
+    out.push({
+      id: currentId,
+      status: "active",
+      passed,
+      total,
+      current: true,
+      branch: typeof state.workitemBranch === "string" ? state.workitemBranch : void 0,
+      createdAt: typeof state.workitemCreatedAt === "string" ? state.workitemCreatedAt : void 0,
+      worktreePath: typeof state.workitemWorktreePath === "string" ? state.workitemWorktreePath : void 0
+    });
+  }
+  const registry = state.workitems && typeof state.workitems === "object" ? state.workitems : {};
+  for (const [id, raw] of Object.entries(registry)) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const entry = raw;
+    const { passed, total } = countCriteria(entry.criteria);
+    out.push({
+      id,
+      status: typeof entry.status === "string" ? entry.status : "paused",
+      passed,
+      total,
+      current: false,
+      branch: typeof entry.branch === "string" ? entry.branch : void 0,
+      createdAt: typeof entry.createdAt === "string" ? entry.createdAt : void 0,
+      worktreePath: typeof entry.worktreePath === "string" ? entry.worktreePath : void 0
+    });
+  }
+  return out;
+}
+function statusColored(t, status) {
+  if (status === "active" || status === "done") {
+    return t.success(status);
+  }
+  if (status === "paused") {
+    return t.warning(status);
+  }
+  if (status === "abandoned") {
+    return t.muted(status);
+  }
+  return status;
+}
+function renderWorkList(list, c) {
+  const color = makeColors(c.color);
+  const t = makeTokens(c);
+  const s = makeSymbols(c);
+  if (list.length === 0) {
+    return card(
+      "\uC6CC\uD06C\uC544\uC774\uD15C",
+      [
+        `${signal(c, "info")} \uB4F1\uB85D\uB41C \uC6CC\uD06C\uC544\uC774\uD15C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.`,
+        "",
+        `${s.lastBranch} ${color.dim("awl work new <ID> \uB85C \uC2DC\uC791\uD558\uC138\uC694.")}`
+      ],
+      c
+    );
+  }
+  const idWidth = Math.max(...list.map((w) => w.id.length), 2) + 2;
+  const statusWidth = Math.max(...list.map((w) => w.status.length), 6) + 2;
+  const out = [];
+  for (const w of list) {
+    const marker = w.current ? color.green("*") : " ";
+    const statusPad = " ".repeat(Math.max(0, statusWidth - w.status.length));
+    let line = `${marker} ${w.id.padEnd(idWidth, " ")}${statusColored(t, w.status)}${statusPad}${t.emphasis(`${w.passed}/${w.total}`)} \uD1B5\uACFC`;
+    if (w.branch) {
+      line += `  ${color.dim(w.branch)}`;
+    }
+    out.push(line);
+    if (w.worktreePath) {
+      out.push(`  ${s.lastBranch} ${color.dim(`worktree: ${w.worktreePath}`)}`);
+    }
+  }
+  return card("\uC6CC\uD06C\uC544\uC774\uD15C", out, c);
+}
+function registryOf(state) {
+  return state.workitems && typeof state.workitems === "object" ? state.workitems : {};
+}
+function archiveCurrent(state, status, now) {
+  const migrated = migrateState(state);
+  const currentId = typeof migrated.workitem === "string" ? migrated.workitem : null;
+  if (!currentId) {
+    return migrated;
+  }
+  const entry = {
+    status,
+    createdAt: typeof migrated.workitemCreatedAt === "string" ? migrated.workitemCreatedAt : now,
+    ...typeof migrated.workitemBranch === "string" ? { branch: migrated.workitemBranch } : {},
+    ...typeof migrated.workitemDescription === "string" ? { description: migrated.workitemDescription } : {},
+    ...typeof migrated.raw_request === "string" ? { raw_request: migrated.raw_request } : {},
+    phase: migrated.phase ?? null,
+    loop: migrated.loop ?? null,
+    criteria: Array.isArray(migrated.criteria) ? migrated.criteria : [],
+    ...typeof migrated.currentFocus === "string" ? { currentFocus: migrated.currentFocus } : {},
+    ...typeof migrated.workitemWorktreePath === "string" ? { worktreePath: migrated.workitemWorktreePath } : {}
+  };
+  const {
+    workitem: _w,
+    phase: _p,
+    loop: _l,
+    criteria: _c,
+    workitemBranch: _b,
+    workitemCreatedAt: _ca,
+    workitemDescription: _d,
+    raw_request: _rr,
+    // currentFocus/worktreePath 는 워크아이템별 상태다(리뷰 지적 AC-09, 같은 실수를
+    // worktreePath 에서 반복하지 않는다) — rest 로 흘려보내면 다음(새) 워크아이템의
+    // 최상위로 그대로 새어 들어간다. entry 스냅샷에만 담고 여기선 제거한다.
+    currentFocus: _cf,
+    workitemWorktreePath: _wtp,
+    ...rest
+  } = migrated;
+  return {
+    ...rest,
+    workitem: null,
+    phase: null,
+    loop: null,
+    criteria: [],
+    workitems: { ...registryOf(migrated), [currentId]: entry }
+  };
+}
+function createWorkitem(state, id, now, branch, description, worktreePath, experiment) {
+  const trimmed = id.trim();
+  if (!trimmed) {
+    return { state, error: "\uC6CC\uD06C\uC544\uC774\uD15C ID \uB97C \uC785\uB825\uD558\uC138\uC694." };
+  }
+  const currentId = typeof state.workitem === "string" ? state.workitem : null;
+  if (currentId && trimmed.toLowerCase() === currentId.toLowerCase()) {
+    return { state, error: `\uC774\uBBF8 \uD604\uC7AC \uC6CC\uD06C\uC544\uC774\uD15C\uC785\uB2C8\uB2E4: ${currentId}` };
+  }
+  const existingKey = Object.keys(registryOf(state)).find(
+    (k) => k.toLowerCase() === trimmed.toLowerCase()
+  );
+  if (existingKey) {
+    return {
+      state,
+      error: `\uC774\uBBF8 \uC874\uC7AC\uD558\uB294 \uC6CC\uD06C\uC544\uC774\uD15C\uC785\uB2C8\uB2E4: ${existingKey} (awl work switch ${existingKey} \uB97C \uC4F0\uC138\uC694)`
+    };
+  }
+  const archived = archiveCurrent(state, "paused", now);
+  return {
+    state: {
+      ...archived,
+      workitem: trimmed,
+      phase: "awaiting-gate1",
+      loop: null,
+      criteria: [],
+      workitemCreatedAt: now,
+      ...branch ? { workitemBranch: branch } : {},
+      ...description ? { workitemDescription: description } : {},
+      raw_request: description ?? "",
+      ...worktreePath ? { workitemWorktreePath: worktreePath } : {},
+      // 실험 케이스 메타(model/mode/taskType). D-15 자유 필드로 보존 —
+      // evolve 가 세대 스냅샷에 실어 metrics --compare 가 케이스별로 비교한다.
+      ...experiment ? { workitemExperiment: experiment } : {}
+    }
+  };
+}
+function restoreWorkitem(state, id, now, branch) {
+  const trimmed = id.trim();
+  const migrated = migrateState(state);
+  const registry = registryOf(migrated);
+  const key = Object.keys(registry).find((k) => k.toLowerCase() === trimmed.toLowerCase());
+  const currentId = typeof migrated.workitem === "string" ? migrated.workitem : null;
+  if (currentId && trimmed.toLowerCase() === currentId.toLowerCase()) {
+    return { state, error: `\uC774\uBBF8 \uD604\uC7AC \uC6CC\uD06C\uC544\uC774\uD15C\uC785\uB2C8\uB2E4: ${currentId}` };
+  }
+  if (!key) {
+    return {
+      state,
+      error: `\uADF8\uB7F0 \uC6CC\uD06C\uC544\uC774\uD15C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4: ${trimmed} (awl work new ${trimmed} \uB85C \uC0C8\uB85C \uB9CC\uB4DC\uC138\uC694)`
+    };
+  }
+  const entry = registry[key];
+  const archived = archiveCurrent(migrated, "paused", now);
+  const remainingRegistry = { ...registryOf(archived) };
+  delete remainingRegistry[key];
+  const nextState = {
+    ...archived,
+    workitem: key,
+    phase: entry.phase ?? null,
+    loop: entry.loop ?? null,
+    criteria: entry.criteria,
+    workitemCreatedAt: entry.createdAt,
+    ...entry.branch ? { workitemBranch: entry.branch } : {},
+    ...entry.description ? { workitemDescription: entry.description } : {},
+    ...typeof entry.raw_request === "string" ? { raw_request: entry.raw_request } : {},
+    ...entry.currentFocus ? { currentFocus: entry.currentFocus } : {},
+    ...entry.worktreePath ? { workitemWorktreePath: entry.worktreePath } : {},
+    workitems: remainingRegistry
+  };
+  const warnings = [];
+  if (entry.branch && branch && entry.branch !== branch) {
+    warnings.push(
+      `\uACBD\uACE0: ${key} \uB294 \uBE0C\uB79C\uCE58 ${entry.branch} \uC5D0\uC11C \uB9CC\uB4E4\uC5B4\uC84C\uB294\uB370 \uC9C0\uAE08\uC740 ${branch} \uBE0C\uB79C\uCE58\uC785\uB2C8\uB2E4.`
+    );
+  }
+  if (entry.status === "abandoned") {
+    warnings.push(`\uACBD\uACE0: ${key} \uB294 \uC911\uB2E8(abandoned) \uCC98\uB9AC\uB41C \uC6CC\uD06C\uC544\uC774\uD15C\uC785\uB2C8\uB2E4.`);
+  }
+  return { state: nextState, warning: warnings.length > 0 ? warnings.join(" ") : void 0 };
+}
+function abandonWorkitem(state, id, now) {
+  const trimmed = id.trim();
+  const migrated = migrateState(state);
+  const currentId = typeof migrated.workitem === "string" ? migrated.workitem : null;
+  if (currentId && trimmed.toLowerCase() === currentId.toLowerCase()) {
+    return { state: archiveCurrent(migrated, "abandoned", now) };
+  }
+  const registry = registryOf(migrated);
+  const key = Object.keys(registry).find((k) => k.toLowerCase() === trimmed.toLowerCase());
+  if (!key) {
+    return { state, error: `\uADF8\uB7F0 \uC6CC\uD06C\uC544\uC774\uD15C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4: ${trimmed}` };
+  }
+  const entry = registry[key];
+  return {
+    state: {
+      ...migrated,
+      workitems: { ...registry, [key]: { ...entry, status: "abandoned" } }
+    }
+  };
+}
+function stripCriteriaSnapshots(criteria) {
+  return criteria.map((c) => {
+    const { untrackedAtStart: _u, snapshot: _s, ...rest } = c;
+    return rest;
+  });
+}
+function markWorkitemDone(state, id, now) {
+  const trimmed = id.trim();
+  const migrated = migrateState(state);
+  const currentId = typeof migrated.workitem === "string" ? migrated.workitem : null;
+  if (currentId && trimmed.toLowerCase() === currentId.toLowerCase()) {
+    const wtPath2 = typeof migrated.workitemWorktreePath === "string" ? migrated.workitemWorktreePath : void 0;
+    const archived = archiveCurrent(migrated, "done", now);
+    const reg = registryOf(archived);
+    const entry2 = reg[currentId];
+    const next2 = {
+      ...archived,
+      workitems: {
+        ...reg,
+        [currentId]: { ...entry2, criteria: stripCriteriaSnapshots(entry2.criteria ?? []) }
+      }
+    };
+    return { state: next2, ...wtPath2 ? { worktree: { path: wtPath2 } } : {} };
+  }
+  const registry = registryOf(migrated);
+  const key = Object.keys(registry).find((k) => k.toLowerCase() === trimmed.toLowerCase());
+  if (!key) {
+    return { state, error: `\uADF8\uB7F0 \uC6CC\uD06C\uC544\uC774\uD15C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4: ${trimmed}` };
+  }
+  const entry = registry[key];
+  const wtPath = typeof entry.worktreePath === "string" ? entry.worktreePath : void 0;
+  const next = {
+    ...migrated,
+    workitems: {
+      ...registry,
+      [key]: { ...entry, status: "done", criteria: stripCriteriaSnapshots(entry.criteria ?? []) }
+    }
+  };
+  return { state: next, ...wtPath ? { worktree: { path: wtPath } } : {} };
+}
+function removeWorkitemFromState(state, ids) {
+  const migrated = migrateState(state);
+  const wanted = new Set(ids.map((s) => s.trim().toLowerCase()).filter(Boolean));
+  if (wanted.size === 0) {
+    return { state: migrated, removed: false };
+  }
+  let next = migrated;
+  let removed = false;
+  const currentId = typeof migrated.workitem === "string" ? migrated.workitem : null;
+  if (currentId && wanted.has(currentId.toLowerCase())) {
+    const {
+      workitem: _w,
+      phase: _p,
+      loop: _l,
+      criteria: _c,
+      workitemBranch: _b,
+      workitemCreatedAt: _ca,
+      workitemDescription: _d,
+      raw_request: _rr,
+      currentFocus: _cf,
+      workitemWorktreePath: _wtp,
+      workitemExperiment: _we,
+      ...rest
+    } = next;
+    next = { ...rest, workitem: null, phase: null, loop: null, criteria: [] };
+    removed = true;
+  }
+  const registry = registryOf(next);
+  const hitKeys = Object.keys(registry).filter((k) => wanted.has(k.toLowerCase()));
+  if (hitKeys.length > 0) {
+    const nextRegistry = { ...registry };
+    for (const k of hitKeys) {
+      delete nextRegistry[k];
+    }
+    next = { ...next, workitems: nextRegistry };
+    removed = true;
+  }
+  return { state: next, removed };
+}
+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;
+}
+function runWorkList(opts) {
+  const root = requireRoot();
+  const list = summarizeWorkitems(loadState(root));
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(list, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${renderWorkList(list, caps())}
+`);
+  }
+}
+function sanitizeForGit(s) {
+  return s.trim().replace(/[^A-Za-z0-9._-]/g, "_").replace(/\.{2,}/g, "_");
+}
+async function createGitWorktree(root, targetPath, branchName) {
+  const r = await run({
+    cmd: "git",
+    args: ["worktree", "add", targetPath, "-b", branchName],
+    cwd: root,
+    timeoutMs: 3e4
+  });
+  if (r.exitCode !== 0) {
+    return { ok: false, error: (r.stderr || r.stdout).trim() };
+  }
+  return { ok: true };
+}
+async function removeGitWorktree(root, targetPath, branchName) {
+  const rm = await run({
+    cmd: "git",
+    args: ["worktree", "remove", "--force", targetPath],
+    cwd: root,
+    timeoutMs: 3e4
+  });
+  if (rm.exitCode !== 0) {
+    return { ok: false, error: (rm.stderr || rm.stdout).trim() };
+  }
+  const br = await run({
+    cmd: "git",
+    args: ["branch", "-D", branchName],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  if (br.exitCode !== 0) {
+    return { ok: false, error: (br.stderr || br.stdout).trim() };
+  }
+  return { ok: true };
+}
+function ensureGitignored(root, target) {
+  const gi = path2.join(root, ".gitignore");
+  const content = fs2.existsSync(gi) ? fs2.readFileSync(gi, "utf8") : "";
+  if (content.split(/\r?\n/).some((line) => line.trim() === target)) {
+    return;
+  }
+  const prefix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+  fs2.writeFileSync(gi, `${content}${prefix}${target}
+`);
+}
+function withCostAtStart(state, usagePath = DEFAULT_USAGE_PATH) {
+  const costAtStart = readCostSnapshot(usagePath);
+  return costAtStart ? { ...state, costAtStart } : state;
+}
+async function runWorkNew(id, description, opts = {}) {
+  const root = requireRoot();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const branch = await gitBranch(root);
+  let worktreePath;
+  let branchName;
+  if (opts.worktree) {
+    branchName = typeof opts.worktree === "string" ? opts.worktree : `work/${sanitizeForGit(id)}`;
+    worktreePath = path2.join(root, ".awl-worktrees", sanitizeForGit(id));
+  }
+  const stateRoot = opts.isolated && worktreePath ? worktreePath : root;
+  const precheck = createWorkitem(loadState(stateRoot), id, now, branch, description);
+  if (precheck.error) {
+    process.stderr.write(`
+  ${precheck.error}
+`);
+    process.exit(1);
+  }
+  if (opts.worktree && worktreePath && branchName) {
+    const created = await createGitWorktree(root, worktreePath, branchName);
+    if (!created.ok) {
+      process.stderr.write(`
+  \uC6CC\uD06C\uD2B8\uB9AC\uB97C \uB9CC\uB4E4\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${created.error}
+`);
+      process.exit(1);
+    }
+    ensureGitignored(root, ".awl-worktrees/");
+  }
+  let isolatedHome;
+  if (opts.isolated) {
+    isolatedHome = path2.join(worktreePath ?? root, ".awl", "home");
+    fs2.mkdirSync(isolatedHome, { recursive: true });
+    writeParentMarker(isolatedHome);
+    ensureGitignored(root, ".awl/home/");
+  }
+  const result = createWorkitem(
+    loadState(stateRoot),
+    id,
+    now,
+    branch,
+    description,
+    worktreePath,
+    opts.experiment
+  );
+  if (result.error) {
+    if (worktreePath && branchName) {
+      const cleaned = await removeGitWorktree(root, worktreePath, branchName);
+      if (!cleaned.ok) {
+        process.stderr.write(
+          `
+  \uC6CC\uD06C\uD2B8\uB9AC \uC815\uB9AC\uC5D0\uB3C4 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4 \u2014 \uC218\uB3D9\uC73C\uB85C \uD655\uC778\uD558\uC138\uC694: ${cleaned.error}
+`
+        );
+      }
+    }
+    process.stderr.write(`
+  ${result.error}
+`);
+    process.exit(1);
+  }
+  const stateToWrite = withCostAtStart(result.state);
+  writeState(stateRoot, stateToWrite);
+  const c = caps();
+  const color = makeColors(c.color);
+  process.stdout.write(`
+${feedback(c, "ok", `\uC6CC\uD06C\uC544\uC774\uD15C \uC0DD\uC131  ${color.bold(id)}`)}
+`);
+  if (worktreePath) {
+    process.stdout.write(`    ${color.dim(`\uC6CC\uD06C\uD2B8\uB9AC  ${worktreePath}`)}
+`);
+    try {
+      if (installClaudeSkill(worktreePath)) {
+        process.stdout.write(`    ${color.dim("\uC2A4\uD0AC \uC7AC\uC124\uCE58  .claude/skills/ (engine)")}
+`);
+      } else {
+        process.stderr.write(
+          `
+${feedback(c, "warn", "\uC6CC\uD06C\uD2B8\uB9AC \uC2A4\uD0AC \uC7AC\uC124\uCE58 \uC0DD\uB7B5", "engine \uC2A4\uD0AC \uC6D0\uBCF8\uC744 \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4 \u2014 \uC774 \uC6CC\uD06C\uD2B8\uB9AC\uC5D0\uC11C awl init \uB85C \uC218\uB3D9 \uC124\uCE58\uD558\uC138\uC694")}
+`
+        );
+      }
+    } catch (e) {
+      process.stderr.write(
+        `
+${feedback(c, "warn", "\uC6CC\uD06C\uD2B8\uB9AC \uC2A4\uD0AC \uC7AC\uC124\uCE58 \uC2E4\uD328", `${String(e)} \u2014 \uC774 \uC6CC\uD06C\uD2B8\uB9AC\uC5D0\uC11C awl init \uB85C \uC218\uB3D9 \uC124\uCE58\uD558\uC138\uC694`)}
+`
+      );
+    }
+  }
+  const verifyRoot = worktreePath ?? root;
+  if (opts.skipBaseline) {
+    process.stdout.write(
+      `    ${color.dim("--skip-baseline: \uAC80\uC99D \uBCA0\uC774\uC2A4\uB77C\uC778 \uC0DD\uB7B5 (\uB098\uC911\uC5D0 awl verify --since-baseline \uC744 \uBABB \uC501\uB2C8\uB2E4)")}
+`
+    );
+  } else {
+    const loaded = loadConfig(verifyRoot);
+    if (loaded.config) {
+      const report = await runVerifyChecks(loaded.config.verify, verifyRoot, { bail: false });
+      try {
+        writeVerifyBaseline(verifyRoot, buildVerifyBaseline(report, now, id.trim()));
+        process.stdout.write(
+          `    ${color.dim(`\uAC80\uC99D \uBCA0\uC774\uC2A4\uB77C\uC778 \uC800\uC7A5  ${report.results.map((r) => `${r.name}:${isCheckPassed(r) ? "\uD1B5\uACFC" : "\uC2E4\uD328"}`).join(", ")}`)}
+`
+        );
+      } catch (e) {
+        process.stderr.write(
+          `
+${feedback(c, "warn", "\uAC80\uC99D \uBCA0\uC774\uC2A4\uB77C\uC778 \uC800\uC7A5 \uC2E4\uD328", `${String(e)} \u2014 \uB098\uC911\uC5D0 awl verify --since-baseline \uC744 \uBABB \uC501\uB2C8\uB2E4`)}
+`
+        );
+      }
+    } else {
+      process.stdout.write(
+        `    ${color.dim("config \uC5C6\uC74C \u2014 \uAC80\uC99D \uBCA0\uC774\uC2A4\uB77C\uC778 \uC0DD\uB7B5 (\uB098\uC911\uC5D0 awl verify --since-baseline \uC744 \uBABB \uC501\uB2C8\uB2E4)")}
+`
+      );
+    }
+  }
+  process.stdout.write(
+    `    ${color.dim(worktreePath ? `\uB2E4\uC74C \u2192 cd ${worktreePath} \uD6C4 awl-loop \uC2DC\uC791` : "\uB2E4\uC74C \u2192 awl-loop \uC2DC\uC791")}
+`
+  );
+  if (isolatedHome) {
+    process.stdout.write(`    ${color.dim(`export AWL_HOME=${isolatedHome}`)}
+`);
+    process.stdout.write(
+      `    ${color.dim("(records \uB97C \uC774 \uC6CC\uD06C\uC544\uC774\uD15C \uC804\uC6A9\uC73C\uB85C \uACA9\uB9AC \u2014 \uC2E4\uC81C \uACA9\uB9AC\uB294 \uC774 export \uB97C \uC801\uC6A9\uD574\uC57C \uBC1C\uC0DD\uD569\uB2C8\uB2E4)")}
+`
+    );
+  } else if (worktreePath) {
+    process.stdout.write(
+      `    ${color.dim("\uCC38\uACE0 \u2192 worktree \uB294 git \uB9CC \uACA9\uB9AC\uD569\uB2C8\uB2E4. records(~/.awl)\uB294 \uC804\uC5ED \uACF5\uC720\uC774\uB2C8, \uBCD1\uB82C \uC138\uC158\uC774\uBA74 AWL_HOME \uC744 \uB530\uB85C \uB450\uAC70\uB098 --isolated \uB97C \uC4F0\uC138\uC694.")}
+`
+    );
+  }
+}
+async function runWorkSwitch(id) {
+  const root = requireRoot();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const branch = await gitBranch(root);
+  const result = restoreWorkitem(loadState(root), id, now, branch);
+  if (result.error) {
+    process.stderr.write(`
+  ${result.error}
+`);
+    process.exit(1);
+  }
+  writeState(root, result.state);
+  const c = caps();
+  process.stdout.write(`
+${feedback(c, "ok", `\uC804\uD658  ${id}`)}
+`);
+  if (result.warning) {
+    process.stderr.write(`  ${result.warning}
+`);
+  }
+}
+function runWorkAbandon(id) {
+  const root = requireRoot();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = abandonWorkitem(loadState(root), id, now);
+  if (result.error) {
+    process.stderr.write(`
+  ${result.error}
+`);
+    process.exit(1);
+  }
+  writeState(root, result.state);
+  const c = caps();
+  process.stdout.write(
+    `
+${feedback(c, "ok", `\uC911\uB2E8 \uCC98\uB9AC  ${id}`, "\uAE30\uB85D\uC740 \uB0A8\uC544 \uC788\uC2B5\uB2C8\uB2E4 (\uC0AD\uC81C\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4)")}
+`
+  );
+}
+async function worktreeDirtyTracked(root, targetPath) {
+  const status = await run({
+    cmd: "git",
+    args: ["-C", targetPath, "status", "--porcelain", "--untracked-files=no"],
+    cwd: root,
+    timeoutMs: 1e4
+  });
+  const lines = status.stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+  return { dirty: lines.length > 0, count: lines.length, first: lines[0] };
+}
+async function removeWorktreeDir(root, targetPath, force) {
+  if (!force) {
+    const d = await worktreeDirtyTracked(root, targetPath);
+    if (d.dirty) {
+      return { ok: false, error: `\uCEE4\uBC0B\uB418\uC9C0 \uC54A\uC740 \uBCC0\uACBD ${d.count}\uAC74 (\uC608: ${d.first})` };
+    }
+  }
+  const r = await run({
+    cmd: "git",
+    args: ["worktree", "remove", "--force", targetPath],
+    cwd: root,
+    timeoutMs: 3e4
+  });
+  if (r.exitCode !== 0) {
+    return { ok: false, error: (r.stderr || r.stdout).trim() };
+  }
+  return { ok: true };
+}
+async function runWorkDone(id, opts = {}) {
+  const root = requireRoot();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = markWorkitemDone(loadState(root), id, now);
+  if (result.error) {
+    process.stderr.write(`
+  ${result.error}
+`);
+    process.exit(1);
+  }
+  const c = caps();
+  const color = makeColors(c.color);
+  let worktreeNote = null;
+  let mergeNote = null;
+  const isolatedHome = result.worktree ? path2.join(result.worktree.path, ".awl", "home") : path2.join(root, ".awl", "home");
+  try {
+    const merged = mergeIsolatedHome(isolatedHome);
+    if (merged && (merged.gotchasAdded > 0 || merged.rulesAdded > 0 || merged.generationsAdded > 0)) {
+      mergeNote = `\uD559\uC2B5 \uC804\uC5ED \uBCD1\uD569  gotcha ${merged.gotchasAdded} \xB7 rule ${merged.rulesAdded} \xB7 generation ${merged.generationsAdded}`;
+    }
+  } catch (e) {
+    process.stderr.write(
+      `
+${feedback(c, "error", "\uACA9\uB9AC \uD559\uC2B5 \uC804\uC5ED \uBCD1\uD569 \uC2E4\uD328 \u2014 \uC644\uB8CC\uB97C \uC911\uB2E8\uD569\uB2C8\uB2E4", e instanceof Error ? e.message : String(e))}
+`
+    );
+    process.exit(1);
+  }
+  if (result.worktree && fs2.existsSync(result.worktree.path)) {
+    const removed = await removeWorktreeDir(root, result.worktree.path, opts.force ?? false);
+    if (!removed.ok) {
+      process.stderr.write(
+        `
+${feedback(c, "warn", "\uC6CC\uD06C\uD2B8\uB9AC\uB97C \uC815\uB9AC\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4", removed.error)}
+  \uC815\uB9AC\uB418\uC9C0 \uC54A\uC740 \uBCC0\uACBD\uC744 \uD655\uC778\uD558\uAC70\uB098 awl work done ${id} --force \uB85C \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694.
+  (\uBE0C\uB79C\uCE58\uB294 \uC9C0\uC6B0\uC9C0 \uC54A\uC73C\uBBC0\uB85C \uCEE4\uBC0B\uB41C \uC791\uC5C5\uC740 \uC548\uC804\uD569\uB2C8\uB2E4.)
+`
+      );
+      process.exit(1);
+    }
+    worktreeNote = `\uC6CC\uD06C\uD2B8\uB9AC \uC81C\uAC70  ${result.worktree.path}`;
+  }
+  writeState(root, result.state);
+  process.stdout.write(
+    `
+${feedback(c, "ok", `\uC644\uB8CC \uCC98\uB9AC  ${color.bold(id)}`, "\uC0C1\uD0DC \uC2A4\uB0C5\uC0F7\uC744 \uD68C\uC218\uD588\uC2B5\uB2C8\uB2E4 (\uAE30\uB85D\uC740 \uB0A8\uC2B5\uB2C8\uB2E4)")}
+`
+  );
+  if (worktreeNote) {
+    process.stdout.write(`    ${color.dim(worktreeNote)}
+`);
+  }
+  if (mergeNote) {
+    process.stdout.write(`    ${color.dim(mergeNote)}
+`);
+  }
+}
+
+export {
+  mergeIsolatedHome,
+  summarizeWorkitems,
+  renderWorkList,
+  createWorkitem,
+  restoreWorkitem,
+  abandonWorkitem,
+  markWorkitemDone,
+  removeWorkitemFromState,
+  runWorkList,
+  sanitizeForGit,
+  removeGitWorktree,
+  withCostAtStart,
+  runWorkNew,
+  runWorkSwitch,
+  runWorkAbandon,
+  worktreeDirtyTracked,
+  runWorkDone
+};