@event4u/agent-config 14.21.0 → 14.23.0

package/dist/cli-delegate/roadmap_gates.js

@@ -0,0 +1,638 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  execute
+} from "./chunk-LTYVIY76.js";
+import {
+  blocker_class,
+  blocker_needs_user,
+  collect
+} from "./chunk-QAJS5YWY.js";
+import "./chunk-ULET4BYS.js";
+import {
+  isCliEntry
+} from "./chunk-5EK5WQN6.js";
+import "./chunk-YWVXLR44.js";
+import "./chunk-7XGD2OEU.js";
+import "./chunk-DBH4AHDK.js";
+import "./chunk-YDQSHTD7.js";
+import {
+  probeLater
+} from "./chunk-ZZQBUHFK.js";
+import "./chunk-JO25G5H7.js";
+
+// src/agent-src/scripts/roadmap_gates.ts
+import * as path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import * as fs2 from "node:fs";
+import { spawnSync } from "node:child_process";
+
+// src/agent-src/templates/scripts/work_engine/hooks/builtin/staged_confirmation_store.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/agent-src/templates/scripts/work_engine/hooks/builtin/staged_confirmation.ts
+var STAGE_TTL_MS = 15 * 60 * 1e3;
+function stageStatus(stage, now) {
+  if (stage.state === "pending" && Date.parse(stage.expires_at) <= now) {
+    return "expired";
+  }
+  return stage.state;
+}
+
+// src/agent-src/templates/scripts/work_engine/hooks/builtin/staged_confirmation_store.ts
+var STORE_REL = path.join("agents", "runtime", "staged-confirmations");
+function storeDir(root) {
+  return path.join(root, STORE_REL);
+}
+function pendingDir(root) {
+  return path.join(storeDir(root), "pending");
+}
+var _TOKEN_RE = /^[0-9a-f]{8,64}$/;
+function isSafeToken(token) {
+  return _TOKEN_RE.test(token);
+}
+function isStage(v) {
+  if (typeof v !== "object" || v === null) {
+    return false;
+  }
+  const s = v;
+  return typeof s.token === "string" && isSafeToken(s.token) && typeof s.action === "string" && typeof s.object === "string" && typeof s.staged_at === "string" && typeof s.expires_at === "string";
+}
+function readStageFile(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+    return isStage(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function listPending(root, now) {
+  let names;
+  try {
+    names = fs.readdirSync(pendingDir(root));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const n of names.sort()) {
+    if (!n.endsWith(".json")) {
+      continue;
+    }
+    const stage = readStageFile(path.join(pendingDir(root), n));
+    if (stage !== null) {
+      out.push({ stage, status: stageStatus(stage, now) });
+    }
+  }
+  out.sort(
+    (a, b) => a.stage.staged_at.localeCompare(b.stage.staged_at) || a.stage.token.localeCompare(b.stage.token)
+  );
+  return out;
+}
+
+// src/agent-src/scripts/roadmap_gates.ts
+var _HERE = fileURLToPath(import.meta.url);
+var WIDTH = 78;
+function regroupTodo(todo) {
+  const steps = [];
+  for (const line of todo) {
+    const startsStep = /^(\d+[.)]|[-*+])\s/.test(line);
+    if (startsStep || steps.length === 0) {
+      steps.push(line);
+    } else {
+      steps[steps.length - 1] = `${steps[steps.length - 1]} ${line}`;
+    }
+  }
+  return steps;
+}
+function wrap(text, width, indent) {
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length === 0) {
+    return [];
+  }
+  const lines = [];
+  let cur = "";
+  for (const w of words) {
+    const candidate = cur === "" ? w : `${cur} ${w}`;
+    if (candidate.length > width && cur !== "") {
+      lines.push(cur);
+      cur = w;
+    } else {
+      cur = candidate;
+    }
+  }
+  if (cur !== "") {
+    lines.push(cur);
+  }
+  return lines.map((l, i) => i === 0 ? l : indent + l);
+}
+var LABEL_W = 19;
+function field(label, value) {
+  const pad = "  " + label.padEnd(LABEL_W);
+  const indent = " ".repeat(pad.length);
+  const lines = wrap(value, WIDTH - pad.length, indent);
+  if (lines.length === 0) {
+    return [];
+  }
+  return [pad + lines[0], ...lines.slice(1)];
+}
+function collectEntries(roadmapRoot) {
+  const entries = [];
+  for (const r of collect(roadmapRoot)) {
+    for (const b of r.open_blockers) {
+      entries.push({ blocker: b, roadmapRel: r.rel, openSteps: r.open_ });
+    }
+  }
+  entries.sort(
+    (a, b) => b.openSteps - a.openSteps || a.roadmapRel.localeCompare(b.roadmapRel) || a.blocker.id.localeCompare(b.blocker.id)
+  );
+  return entries;
+}
+function isLegacy(b) {
+  return b.id === "legacy";
+}
+function renderEntry(e, index) {
+  const head = `${index} \xB7 ${isLegacy(e.blocker) ? "blocked-until note" : e.blocker.id}`;
+  const tail = e.openSteps > 0 ? `unblocks: ${e.openSteps} step${e.openSteps !== 1 ? "s" : ""}` : "";
+  const dashes = Math.max(3, WIDTH - head.length - tail.length - 6);
+  const out = [
+    "",
+    `\u2500\u2500 ${head} ${"\u2500".repeat(dashes)} ${tail}`.trimEnd(),
+    ...field("Roadmap:", e.roadmapRel),
+    ...field("Blocks:", e.blocker.blocks)
+  ];
+  if (e.blocker.question) {
+    out.push(...field("The question:", e.blocker.question));
+  }
+  out.push(
+    ...field(
+      "Recommendation:",
+      e.blocker.recommendation || "(none recorded \u2014 this entry predates the field; ask for one before deciding)"
+    )
+  );
+  const doLabel = isLegacy(e.blocker) ? "Blocked until:" : "Do this:";
+  const steps = regroupTodo(e.blocker.todo);
+  if (steps.length === 0) {
+    out.push(
+      ...field(
+        doLabel,
+        "(no steps recorded \u2014 the blocker entry in the roadmap needs a **What to do:** list)"
+      )
+    );
+  } else {
+    out.push(...field(doLabel, steps[0]));
+    for (const s of steps.slice(1)) {
+      const indent = " ".repeat(LABEL_W + 2);
+      const lines = wrap(s, WIDTH - LABEL_W - 2, indent);
+      out.push(...lines.map((l, i) => i === 0 ? indent + l : l));
+    }
+  }
+  if (e.blocker.ifNothing) {
+    out.push(...field("If you do nothing:", e.blocker.ifNothing));
+  }
+  out.push(...field("Done when:", e.blocker.resolvedWhen));
+  return out;
+}
+function renderResumed(findings) {
+  const fired = findings.filter((f) => f.verdict === "fired");
+  const undecidable = findings.filter((f) => f.verdict === "undecidable").length;
+  if (findings.length === 0) {
+    return [];
+  }
+  const out = [];
+  if (fired.length > 0) {
+    out.push("");
+    const head = `FIRED \xB7 ${fired.length} parked roadmap${fired.length !== 1 ? "s" : ""} can resume`;
+    out.push(`\u2500\u2500 ${head} ${"\u2500".repeat(Math.max(3, WIDTH - head.length - 4))}`);
+    for (const f of fired) {
+      out.push(...field("Roadmap:", f.file));
+      out.push(...field("Condition:", f.condition));
+      out.push(...field("Fired because:", f.why));
+    }
+    out.push("");
+    out.push("Resume one with: `git mv agents/roadmaps/later/<file> agents/roadmaps/`");
+    out.push("then `agent-config roadmap:progress`.");
+  }
+  out.push("");
+  out.push(
+    `Resume-probe coverage: ${findings.length - undecidable} of ${findings.length} park note${findings.length !== 1 ? "s" : ""} carry a machine-decidable condition` + (undecidable > 0 ? ` \xB7 ${undecidable} undecidable` : "")
+  );
+  return out;
+}
+function render(entries, all, resumed = []) {
+  const mine = entries.filter((e) => blocker_needs_user(e.blocker.owner));
+  const others = entries.filter((e) => !blocker_needs_user(e.blocker.owner));
+  const shown = all ? entries : mine;
+  const lines = [];
+  if (mine.length === 0) {
+    lines.push(
+      others.length === 0 ? "No open blockers at all." : `Nothing is waiting on you. ${others.length} open blocker${others.length !== 1 ? "s" : ""} sit with maintainer/external${all ? "" : " \u2014 see --all"}.`
+    );
+  } else {
+    const head = `${mine.length} decision${mine.length !== 1 ? "s" : ""} need${mine.length === 1 ? "s" : ""} you`;
+    const rest = others.length > 0 ? ` \xB7 ${others.length} more with maintainer/external${all ? "" : " (--all)"}` : "";
+    lines.push(head + rest);
+  }
+  let n = 0;
+  for (const e of shown) {
+    n += 1;
+    lines.push(...renderEntry(e, n));
+  }
+  if (shown.length > 0) {
+    lines.push("");
+    lines.push("Not sure about one of these? Ask your agent:");
+    lines.push('  "guide me through <id>"   \u2014 one decision, step by step');
+    lines.push("");
+  }
+  lines.push(...renderResumed(resumed));
+  return lines.join("\n") + "\n";
+}
+function isAgentDrafted(recommendation) {
+  return /\(agent-drafted\b/i.test(recommendation);
+}
+function sheetLabel(b) {
+  return isLegacy(b) ? "blocked-until note" : `\`${b.id}\``;
+}
+function firstSentence(text) {
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return "";
+  }
+  const m = /^(.+?[.!?])(\s|$)/.exec(trimmed.replace(/\s+/g, " "));
+  return m === null ? trimmed.replace(/\s+/g, " ") : m[1];
+}
+function sheetQuestion(b) {
+  if (b.question.trim() !== "") {
+    return { text: firstSentence(b.question), source: "question" };
+  }
+  const steps = regroupTodo(b.todo);
+  if (steps.length > 0 && steps[0].trim() !== "") {
+    return { text: firstSentence(steps[0]), source: "todo" };
+  }
+  return { text: firstSentence(b.blocks), source: "blocks" };
+}
+var SHEET_ANSWER_REL = path2.join("agents", "decisions", "consolidated-decision-sheet-answer.md");
+var SHEET_ANSWER_RE = /<!--\s*sheet-answer:\s*(.+?)\s*\|\s*answered:\s*(\d{4}-\d{2}-\d{2})\s*\|\s*authority:\s*(\S+)\s*-->/;
+function readSheetAnswer(repoRoot) {
+  const file = path2.join(repoRoot, SHEET_ANSWER_REL);
+  let text;
+  try {
+    text = fs2.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  const m = SHEET_ANSWER_RE.exec(text);
+  if (m === null) {
+    return null;
+  }
+  return {
+    option: m[1].trim(),
+    answered: m[2].trim(),
+    authority: m[3].trim()
+  };
+}
+function answerBanner(answer) {
+  if (answer === null) {
+    return [];
+  }
+  return [
+    ">",
+    `> **ANSWERED ${answer.answered} \u2014 ${answer.option}.**`,
+    `> Recorded in \`${SHEET_ANSWER_REL}\` (not derived);`,
+    `> authority \`${answer.authority}\`.`,
+    "> The rows below are the ones still OPEN: an answered",
+    "> row stays here until the work its own entry names is done, so this is a work",
+    "> queue and not a count of unanswered questions."
+  ];
+}
+function renderSheet(entries, now, answer = null) {
+  const mine = entries.filter((e) => blocker_needs_user(e.blocker.owner));
+  const stamp = now.toISOString().slice(0, 10);
+  if (mine.length === 0) {
+    const banner = answerBanner(answer);
+    return `# Consolidated decision sheet \u2014 nothing owned by you (${stamp})
+
+No open blocker in the active roadmap tree carries \`Owner: user\`. Nothing to answer.
+` + (banner.length === 0 ? "" : "\n" + banner.slice(1).join("\n") + "\n");
+  }
+  const noRec = mine.filter((e) => e.blocker.recommendation.trim() === "");
+  const legacyNotes = noRec.filter((e) => isLegacy(e.blocker)).length;
+  const missing = noRec.length - legacyNotes;
+  const drafted = mine.filter((e) => isAgentDrafted(e.blocker.recommendation)).length;
+  const maintainerRecorded = mine.length - noRec.length - drafted;
+  const out = [
+    `# Consolidated decision sheet \u2014 ${String(mine.length)} decisions owned by you`,
+    "",
+    `> Generated ${stamp} by \`agent-config gates --sheet\` over \`agents/roadmaps/\`.`,
+    "> Sorted by unblock count, descending. **Accept-all-defaults is a valid answer**",
+    "> (`road-to-estate-drawdown` blocker `b-consolidated-decision-sheet`, option (a));",
+    "> answering only the two largest-unblock items and deferring the rest is option (c),",
+    "> which the roadmap itself recommends. Whichever you pick, the agent writes the answers",
+    "> back into each roadmap at its own blocker \u2014 that is not your work.",
+    ">",
+    `> **Provenance of the ${String(mine.length)} defaults: ${String(maintainerRecorded)} maintainer-recorded \xB7`,
+    `> ${String(drafted)} \`agent-drafted\` \xB7 ${String(missing)} with no recommendation at all \xB7`,
+    `> ${String(legacyNotes)} legacy \`> Blocked until \u2026\` note(s) that have no field to carry one.**`,
+    "> The distinction is in every row on purpose: an agent-drafted default is the",
+    "> least-examined thing on this sheet, and accept-all-defaults would accept those too.",
+    ">",
+    "> This file is DERIVED \u2014 every line above and below comes from the roadmaps themselves,",
+    "> so regenerating is deterministic and an answer written into this file would be lost.",
+    "> Answers go back into each roadmap at its own blocker; the agent does that.",
+    ...answerBanner(answer),
+    "",
+    "| # | Decision | Roadmap | Unblocks | Default source |",
+    "|---:|---|---|---:|---|"
+  ];
+  mine.forEach((e, i) => {
+    const source = e.blocker.recommendation.trim() !== "" ? isAgentDrafted(e.blocker.recommendation) ? "`agent-drafted`" : "maintainer-recorded" : isLegacy(e.blocker) ? "none \u2014 legacy note" : "none recorded";
+    out.push(
+      `| ${String(i + 1)} | ${sheetLabel(e.blocker)} | ${e.roadmapRel} | ${String(e.openSteps)} | ${source} |`
+    );
+  });
+  mine.forEach((e, i) => {
+    const q = sheetQuestion(e.blocker);
+    const qLabel = q.source === "question" ? "recorded `Question:`" : q.source === "todo" ? "derived from the first `What to do:` step" : "derived from `Blocks:`";
+    const recorded = e.blocker.recommendation.trim();
+    out.push(
+      "",
+      `## ${String(i + 1)} \xB7 ${sheetLabel(e.blocker)}`,
+      "",
+      `- **Roadmap:** ${e.roadmapRel}`,
+      `- **Unblocks:** ${String(e.openSteps)} open step(s) \u2014 ${e.blocker.blocks || "(not recorded)"}`,
+      `- **Question** (${qLabel})**:** ${q.text || "(the blocker records no question, no steps and no Blocks: field)"}`
+    );
+    if (recorded === "" && isLegacy(e.blocker)) {
+      out.push(
+        "- **Default:** _this is a legacy `> Blocked until \u2026` note, not a `### blocker:` entry, so it has no `Recommendation:` field to read. Converting it into a real blocker entry is what gives it a default._",
+        "- **Default source:** none \u2014 legacy note"
+      );
+    } else if (recorded === "") {
+      out.push(
+        "- **Default:** _none recorded \u2014 needs an agent-drafted default before this row can be answered by accepting it._",
+        "- **Default source:** `agent-drafted` (to be written in below, and marked as such)"
+      );
+    } else {
+      const drafted2 = isAgentDrafted(recorded);
+      out.push(
+        `- **Default:** ${firstSentence(recorded)}`,
+        drafted2 ? "- **Default source:** `agent-drafted` \u2014 written into the roadmap\u2019s `Recommendation:` field and marked there, NOT a maintainer decision" : "- **Default source:** maintainer-recorded `Recommendation:` in the roadmap",
+        `- **Recommendation (full):** ${recorded.replace(/\s+/g, " ")}`
+      );
+    }
+    if (e.blocker.ifNothing.trim() !== "") {
+      out.push(`- **If you do nothing:** ${e.blocker.ifNothing.replace(/\s+/g, " ")}`);
+    }
+    out.push(
+      `- **Done when:** ${e.blocker.resolvedWhen.replace(/\s+/g, " ") || "(not recorded)"}`,
+      "- **Your answer:** _(accept default \xB7 override \xB7 defer)_"
+    );
+  });
+  out.push("");
+  return out.join("\n");
+}
+function renderReply(entries) {
+  const mine = entries.filter((e) => blocker_needs_user(e.blocker.owner));
+  if (mine.length === 0) {
+    return "";
+  }
+  const lead = mine[0];
+  const rest = mine.slice(1);
+  const lines = [];
+  lines.push(`Blocked: ${lead.blocker.blocks} \u2014 ${lead.roadmapRel}`);
+  const steps = regroupTodo(lead.blocker.todo);
+  const doLabel = isLegacy(lead.blocker) ? "Blocked until:" : "Do:";
+  if (steps.length === 0) {
+    lines.push(
+      `${doLabel} (no steps recorded \u2014 the blocker entry needs a **What to do:** list)`
+    );
+  } else if (steps.length === 1) {
+    lines.push(...wrap(`${doLabel} ${steps[0]}`, WIDTH, "    "));
+  } else {
+    lines.push(`${doLabel}`);
+    for (const s of steps) {
+      lines.push(...wrap(`  ${s}`, WIDTH, "     "));
+    }
+  }
+  lines.push(...wrap(`Done when: ${lead.blocker.resolvedWhen}`, WIDTH, "    "));
+  if (rest.length > 0) {
+    lines.push("");
+    lines.push(
+      ...wrap(
+        `${rest.length} other decision${rest.length !== 1 ? "s" : ""} also wait${rest.length === 1 ? "s" : ""} on you, none blocking this \u2014 \`agent-config gates\`.`,
+        WIDTH,
+        "    "
+      )
+    );
+  }
+  return lines.join("\n") + "\n";
+}
+function renderJson(entries, all, resumed = []) {
+  const pick = all ? entries : entries.filter((e) => blocker_needs_user(e.blocker.owner));
+  return JSON.stringify(
+    {
+      needsYou: entries.filter((e) => blocker_needs_user(e.blocker.owner)).length,
+      other: entries.filter((e) => !blocker_needs_user(e.blocker.owner)).length,
+      resumeFired: resumed.filter((f) => f.verdict === "fired").length,
+      resumeUndecidable: resumed.filter((f) => f.verdict === "undecidable").length,
+      resumed: resumed.filter((f) => f.verdict === "fired"),
+      blockers: pick.map((e) => ({
+        id: e.blocker.id,
+        roadmap: e.roadmapRel,
+        owner: e.blocker.owner,
+        needsYou: blocker_needs_user(e.blocker.owner),
+        // Resolved through the same absent-field default every
+        // other consumer applies, so a synthesised `legacy` note
+        // reads as class 3 rather than as a hole. `class` ships and
+        // the sibling `run` does not, and the asymmetry is the
+        // roadmap's, not a preference: `road-to-gate-autonomy` step
+        // 1.3 names this field as its acceptance condition, while
+        // nothing asks for the command here — `--execute` reads it
+        // off the entry via `locate()`. Emitting `run` would also
+        // need a call on the authored-vs-`commandOf()`-stripped
+        // form, which no consumer exists to settle.
+        class: blocker_class(e.blocker),
+        blocks: e.blocker.blocks,
+        unblocksSteps: e.openSteps,
+        todo: regroupTodo(e.blocker.todo),
+        resolvedWhen: e.blocker.resolvedWhen
+      }))
+    },
+    null,
+    2
+  ) + "\n";
+}
+function renderPending(root, now) {
+  const rows = listPending(root, now);
+  const live = rows.filter((r) => r.status === "pending");
+  const expired = rows.filter((r) => r.status === "expired");
+  const lines = [];
+  if (live.length === 0) {
+    lines.push(
+      expired.length === 0 ? "No staged actions awaiting confirmation." : `Nothing awaits your confirmation. ${expired.length} stage${expired.length !== 1 ? "s" : ""} expired unconfirmed \u2014 the action never fired.`
+    );
+    return lines.join("\n") + "\n";
+  }
+  lines.push(
+    `${live.length} staged action${live.length !== 1 ? "s" : ""} await${live.length === 1 ? "s" : ""} your confirmation` + (expired.length > 0 ? ` \xB7 ${expired.length} expired unconfirmed` : "")
+  );
+  let n = 0;
+  for (const { stage } of live) {
+    n += 1;
+    lines.push(...renderStage(stage, n));
+  }
+  lines.push("");
+  return lines.join("\n") + "\n";
+}
+function renderStage(stage, index) {
+  const head = `${index} \xB7 ${stage.action}`;
+  const tail = `token: ${stage.token}`;
+  const dashes = Math.max(3, WIDTH - head.length - tail.length - 6);
+  return [
+    "",
+    `\u2500\u2500 ${head} ${"\u2500".repeat(dashes)} ${tail}`.trimEnd(),
+    // The object is the first field on purpose: an approval that does not
+    // name the exact object is the thing non-destructive-by-default forbids,
+    // so it is what the reader must see before anything else.
+    ...field("Object:", stage.object),
+    ...field("Staged by:", stage.source),
+    ...field("Expires:", stage.expires_at)
+  ];
+}
+function renderPendingJson(root, now) {
+  const rows = listPending(root, now);
+  return JSON.stringify(
+    {
+      awaitingYou: rows.filter((r) => r.status === "pending").length,
+      expired: rows.filter((r) => r.status === "expired").length,
+      staged: rows.map(({ stage, status }) => ({
+        token: stage.token,
+        action: stage.action,
+        object: stage.object,
+        source: stage.source,
+        stagedAt: stage.staged_at,
+        expiresAt: stage.expires_at,
+        status
+      }))
+    },
+    null,
+    2
+  ) + "\n";
+}
+function _isDir(p) {
+  try {
+    return fs2.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _resolveRepoRoot(start, marker = path2.join("agents", "roadmaps")) {
+  if (_isDir(path2.join(start, marker))) {
+    return start;
+  }
+  try {
+    const r = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: start,
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    const top = (r.stdout || "").trim();
+    if (r.status === 0 && top !== "" && _isDir(path2.join(top, marker))) {
+      return top;
+    }
+  } catch {
+  }
+  return start;
+}
+function main(argv) {
+  const args = argv ?? process.argv.slice(2);
+  const all = args.includes("--all");
+  const json = args.includes("--json");
+  const reply = args.includes("--reply");
+  const pending = args.includes("--pending");
+  const sheet = args.includes("--sheet");
+  const execIdx = args.indexOf("--execute");
+  if (execIdx !== -1) {
+    const id = args[execIdx + 1];
+    if (id === void 0 || id.startsWith("--")) {
+      process.stderr.write(
+        "usage: gates --execute <blocker-id> [--confirm]\n  Without --confirm the command is echoed and nothing runs.\n"
+      );
+      return 1;
+    }
+    if (pending) {
+      process.stderr.write("gates: --execute and --pending are different sources; pick one.\n");
+      return 1;
+    }
+    if (json) {
+      process.stderr.write("gates --execute has no JSON form; its output is a report.\n");
+      return 1;
+    }
+    const root = _resolveRepoRoot(process.cwd());
+    const dir = path2.join(root, "agents", "roadmaps");
+    if (!_isDir(dir)) {
+      process.stderr.write("No roadmaps directory \u2014 nothing to execute.\n");
+      return 1;
+    }
+    const r = execute(dir, id, /* @__PURE__ */ new Date(), { confirm: args.includes("--confirm") });
+    process.stdout.write(r.report);
+    return r.code;
+  }
+  if (pending) {
+    const root = _resolveRepoRoot(process.cwd(), path2.join("agents", "runtime"));
+    const now = Date.now();
+    process.stdout.write(json ? renderPendingJson(root, now) : renderPending(root, now));
+    return 0;
+  }
+  const repoRoot = _resolveRepoRoot(process.cwd());
+  const roadmapRoot = path2.join(repoRoot, "agents", "roadmaps");
+  if (!_isDir(roadmapRoot)) {
+    process.stdout.write(
+      reply ? "" : json ? (
+        // Every key `renderJson` emits, so a consumer reading the
+        // resume fields gets 0 rather than `undefined` on the
+        // branch where there is no roadmap tree to probe.
+        JSON.stringify(
+          {
+            needsYou: 0,
+            other: 0,
+            resumeFired: 0,
+            resumeUndecidable: 0,
+            resumed: [],
+            blockers: []
+          },
+          null,
+          2
+        ) + "\n"
+      ) : "No roadmaps directory \u2014 nothing to report.\n"
+    );
+    return 0;
+  }
+  const entries = collectEntries(roadmapRoot);
+  const resumed = reply || sheet ? [] : probeLater(roadmapRoot, repoRoot);
+  process.stdout.write(
+    sheet ? renderSheet(entries, /* @__PURE__ */ new Date(), readSheetAnswer(repoRoot)) : reply ? renderReply(entries) : json ? renderJson(entries, all, resumed) : render(entries, all, resumed)
+  );
+  return 0;
+}
+if (isCliEntry(import.meta.url, "roadmap_gates")) {
+  process.exitCode = main();
+}
+export {
+  collectEntries,
+  isAgentDrafted,
+  main,
+  blocker_needs_user as needsUser,
+  readSheetAnswer,
+  regroupTodo,
+  render,
+  renderJson,
+  renderPending,
+  renderPendingJson,
+  renderReply,
+  renderResumed,
+  renderSheet,
+  sheetLabel,
+  sheetQuestion,
+  wrap
+};