agent-work-loop 0.0.0 → 0.6.23

package/dist/chunk-46HZN6UB.js

@@ -0,0 +1,446 @@
+import {
+  WORKTREES_DIR
+} from "./chunk-DP4O5ME2.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
+};

package/dist/chunk-4OCSYHYB.js

@@ -0,0 +1,274 @@
+import {
+  resolveProjectRoot
+} from "./chunk-UOPWVM2H.js";
+import {
+  caps,
+  card,
+  makeColors
+} from "./chunk-7SYRDDTX.js";
+
+// src/commands/state.ts
+import fs from "fs";
+import path from "path";
+function statePath(projectRoot) {
+  return path.join(projectRoot, ".awl", "state.json");
+}
+function migrateState(raw) {
+  if ("workitems" in raw) {
+    return raw;
+  }
+  return { ...raw, workitems: {} };
+}
+function loadState(projectRoot) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(statePath(projectRoot), "utf8"));
+    return migrateState(raw);
+  } catch {
+    return {};
+  }
+}
+function mergeState(current, patch) {
+  const merged = { ...current, ...patch };
+  if (Array.isArray(patch.criteria)) {
+    let acc = { ...current };
+    for (const c of patch.criteria) {
+      if (c && typeof c.id === "string") {
+        acc = setCriterion(acc, c.id, c);
+      }
+    }
+    merged.criteria = acc.criteria;
+  }
+  return merged;
+}
+function getCriterion(state, id) {
+  const criteria = Array.isArray(state.criteria) ? state.criteria : [];
+  return criteria.find((c) => c.id === id);
+}
+function setCriterion(state, id, patch) {
+  const criteria = Array.isArray(state.criteria) ? [...state.criteria] : [];
+  const idx = criteria.findIndex((c) => c.id === id);
+  if (idx >= 0) {
+    criteria[idx] = { ...criteria[idx], ...patch };
+  } else {
+    criteria.push({ id, ...patch });
+  }
+  return { ...state, criteria };
+}
+function writeState(projectRoot, state) {
+  const p = statePath(projectRoot);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const tmp = `${p}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(state, null, 2)}
+`);
+  fs.renameSync(tmp, p);
+}
+var STATE_LOCK_STALE_MS = 1e4;
+function stateLockFile(projectRoot) {
+  return path.join(projectRoot, ".awl", "state.lock");
+}
+function sessionToken() {
+  return `proc-${process.pid}`;
+}
+function lockAgeAt(p) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+    const at = typeof raw.at === "string" ? Date.parse(raw.at) : Number.NaN;
+    if (!Number.isNaN(at)) {
+      return at;
+    }
+  } catch {
+  }
+  try {
+    return fs.statSync(p).mtimeMs;
+  } catch {
+    return Date.now();
+  }
+}
+function acquireStateLock(projectRoot, token) {
+  const p = stateLockFile(projectRoot);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const tryCreate = () => {
+    const tmp = `${p}.${process.pid}.acq`;
+    try {
+      fs.writeFileSync(tmp, JSON.stringify({ token, at: (/* @__PURE__ */ new Date()).toISOString() }));
+      fs.linkSync(tmp, p);
+      return true;
+    } catch (e) {
+      if (e.code === "EEXIST") {
+        return false;
+      }
+      throw e;
+    } finally {
+      try {
+        fs.unlinkSync(tmp);
+      } catch {
+      }
+    }
+  };
+  if (tryCreate()) {
+    return true;
+  }
+  if (Date.now() - lockAgeAt(p) > STATE_LOCK_STALE_MS) {
+    const claimed = `${p}.${process.pid}.steal`;
+    try {
+      fs.renameSync(p, claimed);
+    } catch {
+      return false;
+    }
+    try {
+      fs.unlinkSync(claimed);
+    } catch {
+    }
+    return tryCreate();
+  }
+  return false;
+}
+function releaseStateLock(projectRoot, token) {
+  const p = stateLockFile(projectRoot);
+  if (token !== void 0) {
+    const held = readRawLockToken(p);
+    if (held !== null && held !== token) {
+      return;
+    }
+  }
+  try {
+    fs.unlinkSync(p);
+  } catch {
+  }
+}
+function readRawLockToken(p) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+    return typeof raw.token === "string" ? raw.token : null;
+  } catch {
+    return null;
+  }
+}
+function readStateLock(projectRoot) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(stateLockFile(projectRoot), "utf8"));
+    const at = typeof raw.at === "string" ? raw.at : "";
+    const atMs = at ? Date.parse(at) : Number.NaN;
+    if (Number.isNaN(atMs) || Date.now() - atMs > STATE_LOCK_STALE_MS) {
+      return null;
+    }
+    return { token: typeof raw.token === "string" ? raw.token : "", at };
+  } catch {
+    return null;
+  }
+}
+function applyVerificationAttempts(state, passed) {
+  const criteria = Array.isArray(state.criteria) ? state.criteria : [];
+  const focus = typeof state.currentFocus === "string" ? state.currentFocus : void 0;
+  const targets = focus ? criteria.filter((c) => c.id === focus) : criteria.filter((c) => c.status === "in_progress");
+  if (targets.length === 0) return { state, blocked: [] };
+  const blocked = [];
+  const next = criteria.map((criterion) => {
+    if (!targets.includes(criterion)) return criterion;
+    if (passed) return { ...criterion, attempts: 0 };
+    const attempts = typeof criterion.attempts === "number" ? criterion.attempts + 1 : 1;
+    if (attempts >= 3) {
+      blocked.push(String(criterion.id));
+      return { ...criterion, attempts, status: "blocked", autoBlocked: true };
+    }
+    return { ...criterion, attempts };
+  });
+  return {
+    state: blocked.length ? { ...state, criteria: next, phase: "blocked", loop: "blocked" } : { ...state, criteria: next },
+    blocked
+  };
+}
+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 renderState(state, c) {
+  const color = makeColors(c.color);
+  if (Object.keys(state).length === 0) {
+    return card("\uD604\uC7AC \uC0C1\uD0DC", ["\uC0C1\uD0DC\uAC00 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4."], c);
+  }
+  const out = [];
+  for (const [k, v] of Object.entries(state)) {
+    const val = typeof v === "object" ? JSON.stringify(v) : String(v);
+    out.push(`${k.padEnd(14, " ")}${color.dim(val)}`);
+  }
+  return card("\uD604\uC7AC \uC0C1\uD0DC", out, c);
+}
+function runStateGet(opts) {
+  const state = loadState(requireRoot());
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(state, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${renderState(state, caps())}
+`);
+  }
+}
+function runStateSet(jsonPatch, opts = {}) {
+  const root = requireRoot();
+  let patch;
+  try {
+    patch = JSON.parse(jsonPatch);
+  } catch (e) {
+    process.stderr.write(`
+  \uAC31\uC2E0 JSON \uC744 \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${String(e)}
+`);
+    process.exit(1);
+  }
+  if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
+    process.stderr.write("\n  \uAC31\uC2E0\uC740 JSON \uAC1D\uCCB4\uC5EC\uC57C \uD569\uB2C8\uB2E4.\n");
+    process.exit(1);
+  }
+  const p = patch;
+  const token = sessionToken();
+  if (!acquireStateLock(root, token)) {
+    process.stderr.write(
+      "\n  \uB2E4\uB978 \uC138\uC158\uC774 \uC9C0\uAE08 state \uB97C \uC4F0\uB294 \uC911\uC785\uB2C8\uB2E4(.awl/state.lock). \uC7A0\uC2DC \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694.\n"
+    );
+    process.exit(1);
+  }
+  let gateRejected = false;
+  try {
+    const current = loadState(root);
+    if (p.phase === "loop" && opts.requireGateForLoop) {
+      const workitem = typeof current.workitem === "string" ? current.workitem : void 0;
+      gateRejected = !opts.requireGateForLoop(workitem);
+    }
+    if (!gateRejected) {
+      const merged = mergeState(current, p);
+      writeState(root, merged);
+      process.stdout.write(`${JSON.stringify(merged, null, 2)}
+`);
+    }
+  } finally {
+    releaseStateLock(root, token);
+  }
+  if (gateRejected) {
+    process.stderr.write(
+      "\n  \uAC8C\uC774\uD2B8 1 \uC2B9\uC778 \uAE30\uB85D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. awl record gate \uB85C \uACC4\uD68D\uC744 \uC2B9\uC778(approved)\uD55C \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694.\n"
+    );
+    process.exit(1);
+  }
+}
+
+export {
+  statePath,
+  migrateState,
+  loadState,
+  mergeState,
+  getCriterion,
+  setCriterion,
+  writeState,
+  stateLockFile,
+  sessionToken,
+  acquireStateLock,
+  releaseStateLock,
+  readStateLock,
+  applyVerificationAttempts,
+  runStateGet,
+  runStateSet
+};