@event4u/agent-config 14.21.0 → 14.23.0

package/dist/cli-delegate/chunk-QAJS5YWY.js

@@ -0,0 +1,999 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  headerFragment
+} from "./chunk-ULET4BYS.js";
+import {
+  isCliEntry
+} from "./chunk-5EK5WQN6.js";
+import {
+  run_archival_sweep
+} from "./chunk-YWVXLR44.js";
+import {
+  evaluateDashboardOnDisk,
+  parseModeToken,
+  reportCheckVerdict
+} from "./chunk-7XGD2OEU.js";
+import {
+  reportGuardedBaselines
+} from "./chunk-YDQSHTD7.js";
+
+// src/agent-src/scripts/update_roadmap_progress.ts
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var _HERE = fileURLToPath(import.meta.url);
+var _require = createRequire(import.meta.url);
+var CHECKBOX_RE = /^[ \t\n\r\f\v]*[-*][ \t\n\r\f\v]+\[([ xX~\-])\][ \t\n\r\f\v]/gm;
+var PHASE_RE = /^(#{2,3})[ \t\n\r\f\v]+Phase[ \t\n\r\f\v]+(\d+(?:\.\d+)*[a-z]?|[IVX]+|[A-Z](?:\d+)?)(?:[\s:—\-]+([\s\S]*?))?[ \t\f\v\r]*$/gm;
+var TITLE_RE = /^#[ \t\n\r\f\v]+(?:Roadmap:[ \t\n\r\f\v]*)?(.+?)[ \t\f\v\r]*$/m;
+var EXCLUDE_NAMES = /* @__PURE__ */ new Set([
+  "template.md",
+  "README.md",
+  "progress.md",
+  "roadmaps-progress.md"
+]);
+var EXCLUDE_PREFIXES = ["open-questions"];
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set(["archive", "skipped", "stubs", "later"]);
+var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---[ \t\n\r\f\v]*\n/;
+var UNSCHEDULED_VALUES = /* @__PURE__ */ new Set(["draft"]);
+var MERGE_GATED_RE = /merge-gated/i;
+var PR_NUM_RE = /pr[ \t\n\r\f\v]*[=#:]?[ \t\n\r\f\v]*#?[ \t\n\r\f\v]*(\d+)/gi;
+function _pyRound(x) {
+  const floor = Math.floor(x);
+  const diff = x - floor;
+  if (diff < 0.5) return floor;
+  if (diff > 0.5) return floor + 1;
+  return floor % 2 === 0 ? floor : floor + 1;
+}
+var PhaseStats = class {
+  id;
+  name;
+  done;
+  open_;
+  deferred;
+  cancelled;
+  merge_gated;
+  merge_gated_prs;
+  constructor(id, name, done = 0, open_ = 0, deferred = 0, cancelled = 0, merge_gated = 0, merge_gated_prs = []) {
+    this.id = id;
+    this.name = name;
+    this.done = done;
+    this.open_ = open_;
+    this.deferred = deferred;
+    this.cancelled = cancelled;
+    this.merge_gated = merge_gated;
+    this.merge_gated_prs = merge_gated_prs;
+  }
+  get total_active() {
+    return this.done + this.open_;
+  }
+  get total_all() {
+    return this.done + this.open_ + this.deferred + this.cancelled;
+  }
+  get percent() {
+    return this.total_active ? _pyRound(this.done * 100 / this.total_active) : 0;
+  }
+  get state() {
+    if (this.total_active === 0 && (this.deferred || this.cancelled)) {
+      return "\u23ED\uFE0F skipped";
+    }
+    if (this.total_active === 0) {
+      return "\u2B1C empty";
+    }
+    if (this.done === 0) {
+      return "\u2B1C not started";
+    }
+    if (this.open_ === 0) {
+      return "\u2705 done";
+    }
+    return "\u{1F7E1} in progress";
+  }
+};
+var RoadmapStats = class {
+  path;
+  rel;
+  title;
+  phases;
+  blockers;
+  constructor(p, rel, title, phases = [], blockers = []) {
+    this.path = p;
+    this.rel = rel;
+    this.title = title;
+    this.phases = phases;
+    this.blockers = blockers;
+  }
+  get open_blockers() {
+    return this.blockers.filter((b) => !blocker_is_resolved(b));
+  }
+  get resolved_blockers() {
+    return this.blockers.filter((b) => blocker_is_resolved(b));
+  }
+  get done() {
+    return this.phases.reduce((s, p) => s + p.done, 0);
+  }
+  get open_() {
+    return this.phases.reduce((s, p) => s + p.open_, 0);
+  }
+  get deferred() {
+    return this.phases.reduce((s, p) => s + p.deferred, 0);
+  }
+  get cancelled() {
+    return this.phases.reduce((s, p) => s + p.cancelled, 0);
+  }
+  get merge_gated() {
+    return this.phases.reduce((s, p) => s + p.merge_gated, 0);
+  }
+  get merge_gated_prs() {
+    const seen = [];
+    for (const p of this.phases) {
+      for (const n of p.merge_gated_prs) {
+        if (!seen.includes(n)) {
+          seen.push(n);
+        }
+      }
+    }
+    return seen;
+  }
+  get total_active() {
+    return this.done + this.open_;
+  }
+  get total_all() {
+    return this.done + this.open_ + this.deferred + this.cancelled;
+  }
+  get percent() {
+    return this.total_active ? _pyRound(this.done * 100 / this.total_active) : 0;
+  }
+};
+function _strip(s) {
+  return s.replace(/^[ \t\n\r\f\v]+/, "").replace(/[ \t\n\r\f\v]+$/, "");
+}
+function _splitlines(s) {
+  if (s === "") return [];
+  const parts = s.split(/\r\n|[\n\r\x0b\x0c\x1c\x1d\x1e\x85\u2028\u2029]/);
+  if (parts.length && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+function parse_frontmatter(text) {
+  const m = FRONTMATTER_RE.exec(text);
+  if (!m) {
+    return {};
+  }
+  const fm = {};
+  for (const line of _splitlines(m[1])) {
+    const stripped = _strip(line);
+    if (!stripped || stripped.startsWith("#") || !line.includes(":")) {
+      continue;
+    }
+    const idx = line.indexOf(":");
+    const key = line.slice(0, idx);
+    const value = line.slice(idx + 1);
+    fm[_strip(key)] = _stripQuotes(_strip(value));
+  }
+  return fm;
+}
+function _stripQuotes(s) {
+  let out = s.replace(/^"+/, "").replace(/"+$/, "");
+  out = out.replace(/^'+/, "").replace(/'+$/, "");
+  return out;
+}
+function is_unscheduled(fm) {
+  return UNSCHEDULED_VALUES.has((fm["status"] ?? "").toLowerCase());
+}
+function is_roadmap_name(name) {
+  if (EXCLUDE_NAMES.has(name)) {
+    return false;
+  }
+  return !EXCLUDE_PREFIXES.some((pre) => name.startsWith(pre));
+}
+function is_roadmap_candidate(p) {
+  if (!is_roadmap_name(path.basename(p))) {
+    return false;
+  }
+  const parts = p.split(path.sep).filter((s) => s !== "");
+  if (parts.some((part) => EXCLUDE_DIRS.has(part))) {
+    return false;
+  }
+  return true;
+}
+function count_checkboxes(text) {
+  let done = 0;
+  let open_ = 0;
+  let deferred = 0;
+  let cancelled = 0;
+  let merge_gated = 0;
+  const prs = [];
+  const matches = [];
+  CHECKBOX_RE.lastIndex = 0;
+  let m;
+  while ((m = CHECKBOX_RE.exec(text)) !== null) {
+    matches.push({ start: m.index, group1: m[1] });
+    if (m.index === CHECKBOX_RE.lastIndex) {
+      CHECKBOX_RE.lastIndex++;
+    }
+  }
+  for (let i = 0; i < matches.length; i++) {
+    const c = matches[i].group1.toLowerCase();
+    if (c === "x") {
+      done += 1;
+    } else if (c === " ") {
+      open_ += 1;
+      const span_end = i + 1 < matches.length ? matches[i + 1].start : text.length;
+      const span = text.slice(matches[i].start, span_end);
+      if (MERGE_GATED_RE.test(span)) {
+        merge_gated += 1;
+        PR_NUM_RE.lastIndex = 0;
+        let pm;
+        while ((pm = PR_NUM_RE.exec(span)) !== null) {
+          prs.push(parseInt(pm[1], 10));
+        }
+      }
+    } else if (c === "~") {
+      deferred += 1;
+    } else if (c === "-") {
+      cancelled += 1;
+    }
+  }
+  return [done, open_, deferred, cancelled, merge_gated, prs];
+}
+function blocker_is_resolved(b) {
+  return /^resolved\b/.test(_strip(b.status).toLowerCase());
+}
+function blocker_class(b) {
+  const c = _strip(b.blockerClass).split(/[\s—–-]/)[0];
+  return c === "0" || c === "1" || c === "2" ? c : "3";
+}
+var FENCED_CODE_RE = /^[ \t]*```[^\n]*\n[\s\S]*?^[ \t]*```[ \t]*$/gm;
+var BLOCKERS_SECTION_RE = /^##[ \t]+Blockers[ \t]*$/im;
+var BLOCKER_HEADING_RE = /^###[ \t]+blocker:[ \t]*(.+?)[ \t]*$/gim;
+var NEXT_H2_RE = /^##[ \t]+\S/m;
+var LEGACY_BLOCKED_UNTIL_RE = /^>[ \t]*Blocked until:?[ \t]*(.+)$/im;
+function _stripFencedCode(text) {
+  return text.replace(FENCED_CODE_RE, (m) => "\n".repeat(_splitlines(m).length));
+}
+var BLOCKER_FIELD_RE = /^-[ \t]*\*\*[^*]+:\*\*/;
+function _stripComment(s) {
+  return _strip(s.replace(/<!--[\s\S]*?-->/g, ""));
+}
+function _blockerField(slice, label) {
+  const lines = _splitlines(slice);
+  const re = new RegExp(`^-[ \\t]*\\*\\*${label}:\\*\\*[ \\t]*(.*)$`, "i");
+  const startIdx = lines.findIndex((l) => re.test(_strip(l)));
+  if (startIdx === -1) {
+    return null;
+  }
+  const m = re.exec(_strip(lines[startIdx]));
+  const parts = [];
+  const first = _stripComment(m?.[1] ?? "");
+  if (first) {
+    parts.push(first);
+  }
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const trimmed = _strip(lines[i]);
+    if (trimmed === "" || BLOCKER_FIELD_RE.test(trimmed) || trimmed.startsWith("#")) {
+      break;
+    }
+    parts.push(_stripComment(trimmed));
+  }
+  return parts.length ? parts.join(" ") : null;
+}
+function _blockerTodo(slice) {
+  const lines = _splitlines(slice);
+  const markerRe = /^-[ \t]*\*\*What to do:\*\*[ \t]*(.*)$/i;
+  const startIdx = lines.findIndex((l) => markerRe.test(_strip(l)));
+  if (startIdx === -1) {
+    return [];
+  }
+  const out = [];
+  const inline = _stripComment(
+    markerRe.exec(_strip(lines[startIdx]))?.[1] ?? ""
+  );
+  if (inline) {
+    out.push(inline);
+  }
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const trimmed = _strip(lines[i]);
+    if (BLOCKER_FIELD_RE.test(trimmed) || trimmed.startsWith("#")) {
+      break;
+    }
+    if (trimmed !== "") {
+      out.push(trimmed);
+    }
+  }
+  return out;
+}
+function parse_blockers(raw_text) {
+  const text = _stripFencedCode(raw_text);
+  const blockers = [];
+  const sectionMatch = BLOCKERS_SECTION_RE.exec(text);
+  if (sectionMatch) {
+    const sectionStart = sectionMatch.index + sectionMatch[0].length;
+    const rest = text.slice(sectionStart);
+    const h2 = NEXT_H2_RE.exec(rest);
+    const sectionEnd = h2 ? sectionStart + h2.index : text.length;
+    const section = text.slice(sectionStart, sectionEnd);
+    BLOCKER_HEADING_RE.lastIndex = 0;
+    const heads = [];
+    let hm;
+    while ((hm = BLOCKER_HEADING_RE.exec(section)) !== null) {
+      heads.push({
+        start: hm.index,
+        end: hm.index + hm[0].length,
+        id: _strip(hm[1])
+      });
+      if (hm.index === BLOCKER_HEADING_RE.lastIndex) {
+        BLOCKER_HEADING_RE.lastIndex++;
+      }
+    }
+    for (let i = 0; i < heads.length; i++) {
+      const cur = heads[i];
+      const bodyEnd = i + 1 < heads.length ? heads[i + 1].start : section.length;
+      const body = section.slice(cur.end, bodyEnd);
+      blockers.push({
+        id: cur.id,
+        status: (_blockerField(body, "Status") ?? "open").toLowerCase(),
+        owner: _blockerField(body, "Owner") ?? "user",
+        blocks: _blockerField(body, "Blocks") ?? "(unspecified)",
+        todo: _blockerTodo(body),
+        resolvedWhen: _blockerField(body, "Resolved when") ?? "(unspecified)",
+        recommendation: _blockerField(body, "Recommendation") ?? "",
+        ifNothing: _blockerField(body, "If you do nothing") ?? "",
+        question: _blockerField(body, "Question") ?? "",
+        blockerClass: _blockerField(body, "Class") ?? "",
+        run: _blockerField(body, "Run") ?? "",
+        budget: _blockerField(body, "Budget") ?? ""
+      });
+    }
+  }
+  const legacyMatch = LEGACY_BLOCKED_UNTIL_RE.exec(text);
+  if (legacyMatch) {
+    const parts = [_strip(legacyMatch[1])];
+    const allLines = _splitlines(text);
+    const noteIdx = allLines.findIndex((l) => LEGACY_BLOCKED_UNTIL_RE.test(_strip(l)));
+    for (let i = noteIdx + 1; noteIdx !== -1 && i < allLines.length; i++) {
+      const quoted = /^>[ \t]?(.*)$/.exec(_strip(allLines[i]));
+      if (!quoted) {
+        break;
+      }
+      const cont = _strip(quoted[1]);
+      if (cont === "") {
+        break;
+      }
+      parts.push(cont);
+    }
+    blockers.push({
+      id: "legacy",
+      status: "open",
+      owner: "user",
+      blocks: "entire roadmap",
+      todo: [parts.join(" ")],
+      resolvedWhen: "condition described above clears",
+      recommendation: "",
+      ifNothing: "",
+      question: "",
+      blockerClass: "",
+      run: "",
+      budget: ""
+    });
+  }
+  return blockers;
+}
+function blocker_needs_user(owner) {
+  return /\buser\b/i.test(owner);
+}
+function parse_roadmap(p, roadmap_root) {
+  const text = fs.readFileSync(p, { encoding: "utf-8" });
+  const phase_matches = [];
+  PHASE_RE.lastIndex = 0;
+  let pm;
+  while ((pm = PHASE_RE.exec(text)) !== null) {
+    phase_matches.push({
+      start: pm.index,
+      end: pm.index + pm[0].length,
+      g2: pm[2],
+      g3: pm[3]
+    });
+    if (pm.index === PHASE_RE.lastIndex) {
+      PHASE_RE.lastIndex++;
+    }
+  }
+  if (phase_matches.length === 0) {
+    return null;
+  }
+  const title_match = TITLE_RE.exec(text);
+  const title = title_match ? _strip(title_match[1]) : _stem(p);
+  const rel = _relPosix(roadmap_root, p);
+  const stats = new RoadmapStats(p, rel, title, [], parse_blockers(text));
+  for (let i = 0; i < phase_matches.length; i++) {
+    const cur = phase_matches[i];
+    const start = cur.end;
+    const end = i + 1 < phase_matches.length ? phase_matches[i + 1].start : text.length;
+    const [d, o, df, c, mg, prs] = count_checkboxes(text.slice(start, end));
+    const phase_id = cur.g2;
+    const name = _strip(cur.g3 ?? "") || `Phase ${phase_id}`;
+    stats.phases.push(new PhaseStats(phase_id, name, d, o, df, c, mg, prs));
+  }
+  return stats;
+}
+function _stem(p) {
+  const base = path.basename(p);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(0, dot) : base;
+}
+function _relPosix(root, p) {
+  return path.relative(root, p).split(path.sep).join("/");
+}
+function _blockerAnchor(rel) {
+  const stem = rel.endsWith(".md") ? rel.slice(0, -3) : rel;
+  return "blockers-" + stem.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function bar(pct, width = 10) {
+  const filled = _pyRound(pct * width / 100);
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function _rglobMdSorted(root) {
+  const out = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        walk(full);
+      } else if (ent.isSymbolicLink() && _isDir(full)) {
+        walk(full);
+      } else if (ent.name.endsWith(".md")) {
+        out.push(full);
+      }
+    }
+  };
+  walk(root);
+  out.sort();
+  return out;
+}
+function _isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function collect(roadmap_root) {
+  const results = [];
+  for (const p of _rglobMdSorted(roadmap_root)) {
+    if (!_isFile(p) || !is_roadmap_candidate(p)) {
+      continue;
+    }
+    const text = fs.readFileSync(p, { encoding: "utf-8" });
+    if (is_unscheduled(parse_frontmatter(text))) {
+      continue;
+    }
+    const stats = parse_roadmap(p, roadmap_root);
+    if (stats) {
+      results.push(stats);
+    }
+  }
+  return results;
+}
+var RESUME_STATEMENT = /\b(blocked until|resume when|resume-when|blocked-until)\b/i;
+var RESUME_LOOSE = /\btrigger\b/i;
+function collect_parked(roadmap_root) {
+  const dir = path.join(roadmap_root, "later");
+  let names;
+  try {
+    names = fs.readdirSync(dir).sort();
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const full = path.join(dir, name);
+    if (!_isFile(full) || !is_roadmap_name(name)) {
+      continue;
+    }
+    let text;
+    try {
+      text = fs.readFileSync(full, { encoding: "utf-8" });
+    } catch {
+      continue;
+    }
+    if (is_unscheduled(parse_frontmatter(text))) {
+      continue;
+    }
+    const cell = resume_cell(text);
+    const open = parse_blockers(text).filter((b) => !blocker_is_resolved(b));
+    out.push({
+      rel: name,
+      resume: cell.stated,
+      unlabelled: cell.unlabelled,
+      open_blockers: open.length,
+      needs_user: open.filter((b) => blocker_needs_user(b.owner)).length
+    });
+  }
+  return out;
+}
+function resume_cell(text) {
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (!RESUME_STATEMENT.test(raw)) {
+      continue;
+    }
+    const parts = [raw];
+    for (let j = i + 1; j < lines.length; j++) {
+      const next = lines[j].replace(/^\s*>\s?/, "").trim();
+      if (next === "" || /^([-*+]\s|#{1,6}\s|```|\||>\s*$)/.test(next)) {
+        break;
+      }
+      parts.push(next);
+    }
+    const joined = cell_text(parts.join(" "));
+    if (joined === "") {
+      continue;
+    }
+    return { stated: joined, unlabelled: false };
+  }
+  return { stated: null, unlabelled: lines.some((l) => RESUME_LOOSE.test(l)) };
+}
+function cell_text(raw) {
+  let out = raw.replace(/^\s*>\s?/, "").replace(/<!--[\s\S]*?-->/g, "").replace(/<!--|-->/g, "").replace(/\*\*/g, "").replace(/\s+/g, " ").trim();
+  if (out.length > 200) {
+    out = `${out.slice(0, 197).trimEnd()}...`;
+  }
+  return out.replace(/\|/g, "\\|");
+}
+function unarchived_complete(roadmaps) {
+  return roadmaps.filter((r) => r.total_active > 0 && r.open_ === 0 && r.deferred === 0);
+}
+function merge_gated_pending(roadmaps) {
+  return roadmaps.filter((r) => r.open_ > 0 && r.merge_gated === r.open_);
+}
+function pending_iron_law_3(roadmaps) {
+  return roadmaps.filter((r) => r.total_active > 0 && r.open_ === 0 && r.deferred > 0);
+}
+function collect_bundles(repo_root) {
+  const reg = path.join(repo_root, "agents", "tickets", "_registry.yml");
+  if (!fs.existsSync(reg)) {
+    return [];
+  }
+  let YAML;
+  try {
+    YAML = _require("yaml");
+  } catch {
+    return [];
+  }
+  let data;
+  try {
+    data = YAML.parse(fs.readFileSync(reg, { encoding: "utf-8" }), { version: "1.1" }) ?? {};
+  } catch {
+    return [];
+  }
+  const out = [];
+  const bundles = data && typeof data === "object" && !Array.isArray(data) ? data["bundles"] ?? null : null;
+  const bundleMap = bundles && typeof bundles === "object" && !Array.isArray(bundles) ? bundles : {};
+  for (const slug of Object.keys(bundleMap).sort()) {
+    const metaRaw = bundleMap[slug];
+    const meta = metaRaw && typeof metaRaw === "object" && !Array.isArray(metaRaw) ? metaRaw : {};
+    const bdir = path.join(repo_root, "agents", "tickets", slug);
+    let n = 0;
+    if (_isDir(bdir)) {
+      try {
+        n = fs.readdirSync(bdir).filter((f) => f.startsWith("T-") && f.endsWith(".md")).length;
+      } catch {
+        n = 0;
+      }
+    }
+    out.push({
+      slug,
+      tickets: n,
+      status: meta["status"] ?? "?",
+      roadmap: meta["source_roadmap"] ?? ""
+    });
+  }
+  return out;
+}
+function render(roadmaps, bundles, roadmap_root) {
+  const total_done = roadmaps.reduce((s, r) => s + r.done, 0);
+  const total_active = roadmaps.reduce((s, r) => s + r.total_active, 0);
+  const overall_pct = total_active ? _pyRound(total_done * 100 / total_active) : 0;
+  const pending = pending_iron_law_3(roadmaps);
+  const gated = merge_gated_pending(roadmaps);
+  const total_open_blockers = roadmaps.reduce((s, r) => s + r.open_blockers.length, 0);
+  const user_open_blockers = roadmaps.reduce(
+    (s, r) => s + r.open_blockers.filter((b) => blocker_needs_user(b.owner)).length,
+    0
+  );
+  const lines = [];
+  lines.push("# Roadmap Progress\n");
+  const header_meta = `> ${roadmaps.length} open roadmap${roadmaps.length !== 1 ? "s" : ""} \xB7 [roadmaps/](roadmaps/) \xB7 [archive/](roadmaps/archive/) \xB7 [skipped/](roadmaps/skipped/) \xB7 [later/](roadmaps/later/)` + (total_open_blockers > 0 ? ` \xB7 **${total_open_blockers}** open blocker${total_open_blockers !== 1 ? "s" : ""} in the active tree` + (user_open_blockers > 0 ? `, **${user_open_blockers}** need you \u2192 \`agent-config gates\`` : "") : "") + // Two integers, never a row — see `stubs_due.headerFragment`.
+  headerFragment(path.join(roadmap_root, "stubs")) + "\n";
+  lines.push(
+    // Honest provenance (road-to-roadmap-archival-robustness, gap C): name a
+    // regen path that exists in EVERY install, not a hardcoded
+    // `.augment/scripts/...` that a script-less / non-Augment consumer does
+    // not have. `task roadmap-progress` covers Taskfile projects; the bare
+    // script name covers the rest.
+    "> Auto-generated \u2014 do not edit. Regenerate with `task roadmap-progress` or by running the `update_roadmap_progress` script for your install; rewritten on every roadmap create / execute / completion change. A repository that does not commit this file has no git history for it \u2014 regenerate to see the current state.\n>\n" + header_meta
+  );
+  lines.push("## Overall\n");
+  lines.push(`**${total_done} / ${total_active} steps done \xB7 ${overall_pct}%**
+`);
+  lines.push("```text\n" + bar(overall_pct, 40) + `   ${overall_pct}%
+\`\`\`
+`);
+  if (pending.length) {
+    lines.push("## \u26A0\uFE0F Iron Law 3 \u2014 unresolved deferred items\n");
+    lines.push(
+      "These roadmaps have `count_open == 0` but carry `[~]` deferred items. Per `roadmap-progress-sync` Iron Law 3 they do NOT auto-archive \u2014 the user must resolve the deferrals first (spawn follow-up, restore, or cancel). See [`roadmap-management \xA7 4b`](../packages/core/.agent-src.uncondensed/skills/roadmap-management/SKILL.md).\n"
+    );
+    lines.push("| Roadmap | Done | Deferred | Cancelled |");
+    lines.push("|---|---:|---:|---:|");
+    for (const r of pending) {
+      lines.push(
+        `| [${r.rel}](roadmaps/${r.rel}) | ${r.done} | ${r.deferred} | ${r.cancelled} |`
+      );
+    }
+    lines.push("");
+  }
+  if (gated.length) {
+    lines.push("## \u23F3 Merge-gated \u2014 pending post-merge archival\n");
+    lines.push(
+      "Every open item in these roadmaps is `merge-gated`: held open on purpose while a closing PR is in flight, so inbound references keep resolving until the file archives. **The moment the gating PR merges**, flip the merge-gated box \u2192 `[x]`, `git mv` the roadmap to `archive/`, migrate inbound refs, and regenerate this dashboard \u2014 all in the same response (per `roadmap-progress-sync` Iron Law 1). Do NOT leave it lingering at < 100%.\n"
+    );
+    lines.push("| Roadmap | Done | Merge-gated open | Gating PR |");
+    lines.push("|---|---:|---:|---|");
+    for (const r of gated) {
+      const prs = r.merge_gated_prs.map((n) => `#${n}`).join(", ") || "\u2014";
+      lines.push(
+        `| [${r.rel}](roadmaps/${r.rel}) | ${r.done} | ${r.merge_gated} | ${prs} |`
+      );
+    }
+    lines.push("");
+  }
+  const unarchived = unarchived_complete(roadmaps);
+  if (unarchived.length) {
+    lines.push("## \u2705 Completed \u2014 pending archival\n");
+    lines.push(
+      "These roadmaps are **complete** (`count_open == 0`, `count_deferred == 0`) but still sit in the active tree. They should be in `agents/roadmaps/archive/`. Run the archival sweep `archive_completed_roadmaps --all` (untracked-safe), or follow the manual fallback documented in the `roadmap-management` skill, then regenerate this dashboard.\n"
+    );
+    lines.push("| Roadmap | Done | Total |");
+    lines.push("|---|---:|---:|");
+    for (const r of unarchived) {
+      lines.push(`| [${r.rel}](roadmaps/${r.rel}) | ${r.done} | ${r.total_active} |`);
+    }
+    lines.push("");
+  }
+  if (roadmaps.length === 0) {
+    lines.push("_No open roadmaps._\n");
+    return lines.join("\n") + "\n";
+  }
+  lines.push("## Open roadmaps\n");
+  lines.push(
+    "| # | Roadmap | Phases | Steps | Open | Done | Deferred | Cancelled | Blocker | Progress |"
+  );
+  lines.push("|---|---|---:|---:|---:|---:|---:|---:|---:|---|");
+  roadmaps.forEach((r, idx) => {
+    const i = idx + 1;
+    const openBlockers = r.open_blockers.length;
+    const blockerCell = openBlockers > 0 ? `[${openBlockers}](#${_blockerAnchor(r.rel)})` : "0";
+    lines.push(
+      `| ${i} | [${r.rel}](roadmaps/${r.rel}) | ${r.phases.length} | ${r.total_all} | ${r.open_} | ${r.done} | ${r.deferred} | ${r.cancelled} | ${blockerCell} | ${bar(r.percent)} ${r.percent}% |`
+    );
+  });
+  lines.push("");
+  lines.push("---\n");
+  const parked = collect_parked(roadmap_root);
+  if (parked.length > 0) {
+    lines.push(
+      `## Parked \u2014 \`later/\` (${parked.length} roadmap${parked.length !== 1 ? "s" : ""}, not active backlog)
+`
+    );
+    lines.push(
+      "> Excluded from the table above and from `/roadmap:process-*` by design. Listed here so a resume condition is visible without opening the file.\n"
+    );
+    const parked_open = parked.reduce((n, r) => n + r.open_blockers, 0);
+    const parked_user = parked.reduce((n, r) => n + r.needs_user, 0);
+    if (parked_open > 0) {
+      lines.push(
+        `> Carrying **${parked_open}** open blocker${parked_open !== 1 ? "s" : ""}` + (parked_user > 0 ? `, **${parked_user}** owned by you` : "") + " \u2014 parking resolves nothing, so these are NOT in the active-tree count above.\n"
+      );
+    }
+    lines.push("| Roadmap | Open blockers | Resume when |");
+    lines.push("|---|---:|---|");
+    for (const r of parked) {
+      const cell = r.resume ?? (r.unlabelled ? "_condition present but unlabelled \u2014 see file_" : "_no resume line recorded_");
+      const blockers = r.open_blockers === 0 ? "0" : `${r.open_blockers}${r.needs_user > 0 ? ` (${r.needs_user} you)` : ""}`;
+      lines.push(
+        `| [${r.rel}](roadmaps/later/${r.rel}) | ${blockers} | ${cell} | <!-- ref-ignore -->`
+      );
+    }
+    lines.push("");
+    lines.push("---\n");
+  }
+  lines.push("## Per-roadmap phase breakdown\n");
+  for (const r of roadmaps) {
+    lines.push(`### [${r.rel}](roadmaps/${r.rel})
+`);
+    lines.push(`**${r.title}** \u2014 ${r.done} / ${r.total_active} done (${r.percent}%)
+`);
+    lines.push("| # | Phase | State | Open | Done | Deferred | Cancelled | % |");
+    lines.push("|---|---|---|---:|---:|---:|---:|---:|");
+    for (const p of r.phases) {
+      lines.push(
+        `| ${p.id} | ${p.name} | ${p.state} | ${p.open_} | ${p.done} | ${p.deferred} | ${p.cancelled} | ${p.percent}% |`
+      );
+    }
+    lines.push("");
+    const openBlockers = r.open_blockers;
+    if (openBlockers.length) {
+      lines.push(`<a id="${_blockerAnchor(r.rel)}"></a>`);
+      lines.push("**Blockers**\n");
+      for (const b of openBlockers) {
+        lines.push(`- **${b.id}** (owner: ${b.owner}) \u2014 blocks ${b.blocks}`);
+        if (b.recommendation) {
+          lines.push(`  - **Recommendation:** ${b.recommendation}`);
+        }
+        if (b.ifNothing) {
+          lines.push(`  - **If you do nothing:** ${b.ifNothing}`);
+        }
+        lines.push("  - **What to do:**");
+        for (const step of b.todo) {
+          lines.push(`    ${step}`);
+        }
+        lines.push(`  - **Resolved when:** ${b.resolvedWhen}`);
+      }
+      const resolvedCount = r.resolved_blockers.length;
+      if (resolvedCount > 0) {
+        lines.push(
+          `
+_${resolvedCount} blocker${resolvedCount !== 1 ? "s" : ""} resolved._`
+        );
+      }
+      lines.push("");
+    }
+  }
+  if (bundles && bundles.length) {
+    lines.push("---\n");
+    lines.push("## Ticket bundles\n");
+    lines.push(
+      "Materialised ticket bundles under [`agents/tickets/`](tickets/) (via `/roadmap:materialize`), counted from `agents/tickets/_registry.yml`.\n"
+    );
+    lines.push("| Bundle | Tickets | Status | Source roadmap |");
+    lines.push("|---|---:|---|---|");
+    for (const b of bundles) {
+      lines.push(
+        `| ${b.slug} | ${b.tickets} | ${b.status} | ${b.roadmap} |`
+      );
+    }
+    lines.push("");
+  }
+  return lines.join("\n") + "\n";
+}
+var ArgparseExit = class extends Error {
+  code;
+  constructor(code) {
+    super(`ArgparseExit(${code})`);
+    this.name = "ArgparseExit";
+    this.code = code;
+  }
+};
+var _PROG = "update_roadmap_progress.py";
+function _usage() {
+  return `usage: ${_PROG} [-h] [--check] [--tracked-mode | --untracked-mode]
+       [--archive | --no-archive] [--repo-root REPO_ROOT] [--dashboard-only]
+`;
+}
+function _parseArgs(argv) {
+  let check = false;
+  let mode = "tracked";
+  let archive = false;
+  let dashboard_only = false;
+  let repo_root = process.cwd();
+  const emitError = (msg) => {
+    process.stderr.write(_usage());
+    process.stderr.write(`${_PROG}: error: ${msg}
+`);
+    throw new ArgparseExit(2);
+  };
+  let i = 0;
+  while (i < argv.length) {
+    const tok = argv[i];
+    if (tok === "-h" || tok === "--help") {
+      process.stdout.write(_usage());
+      throw new ArgparseExit(0);
+    } else if (tok === "--check") {
+      check = true;
+      i += 1;
+    } else if (parseModeToken(tok) !== null) {
+      mode = parseModeToken(tok);
+      i += 1;
+    } else if (tok === "--dashboard-only") {
+      dashboard_only = true;
+      i += 1;
+    } else if (tok === "--archive") {
+      archive = true;
+      i += 1;
+    } else if (tok === "--no-archive") {
+      archive = false;
+      i += 1;
+    } else if (tok === "--repo-root") {
+      const val = argv[i + 1];
+      if (val === void 0) {
+        emitError("argument --repo-root: expected one argument");
+      }
+      repo_root = val;
+      i += 2;
+    } else if (tok.startsWith("--repo-root=")) {
+      repo_root = tok.slice("--repo-root=".length);
+      i += 1;
+    } else {
+      emitError(`unrecognized arguments: ${tok}`);
+    }
+  }
+  if (check && archive) {
+    emitError("argument --archive: not allowed with --check");
+  }
+  if (dashboard_only && !check) {
+    emitError("argument --dashboard-only: only meaningful with --check");
+  }
+  return { check, mode, archive, repo_root, dashboard_only };
+}
+function _fallback_git_toplevel(repo_root) {
+  try {
+    const r = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: repo_root,
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    const top = (r.stdout || "").trim();
+    if (r.status === 0 && top !== "" && _isDir(path.join(top, "agents", "roadmaps"))) {
+      return top;
+    }
+  } catch {
+  }
+  return repo_root;
+}
+function main(argv) {
+  const args = _parseArgs(argv ?? process.argv.slice(2));
+  let repo_root = args.repo_root;
+  if (repo_root === process.cwd() && !_isDir(path.join(repo_root, "agents", "roadmaps"))) {
+    repo_root = _fallback_git_toplevel(repo_root);
+  }
+  const roadmap_root = path.join(repo_root, "agents", "roadmaps");
+  const target = path.join(repo_root, "agents", "roadmaps-progress.md");
+  if (!_isDir(roadmap_root)) {
+    if (args.check) {
+      return 0;
+    }
+    process.stdout.write(`\u2139\uFE0F  No roadmaps directory at ${roadmap_root} \u2014 nothing to do.
+`);
+    return 0;
+  }
+  let sweep_out = "";
+  if (!args.check && args.archive && unarchived_complete(collect(roadmap_root)).length > 0) {
+    const swept = run_archival_sweep(repo_root);
+    sweep_out = swept.stdout;
+    if (swept.stderr) {
+      process.stderr.write(swept.stderr);
+    }
+    if (!swept.ok) {
+      process.stderr.write(
+        "\u274C  The archival sweep failed \u2014 dashboard NOT regenerated. Fix the tree, then re-run.\n"
+      );
+      return 1;
+    }
+  }
+  const roadmaps = collect(roadmap_root), guarded = reportGuardedBaselines(roadmaps, repo_root);
+  const new_text = render(roadmaps, collect_bundles(repo_root), roadmap_root) + guarded.section;
+  const complete = unarchived_complete(roadmaps);
+  const pending = pending_iron_law_3(roadmaps);
+  const gated = merge_gated_pending(roadmaps);
+  const _warn_merge_gated = () => {
+    process.stderr.write(
+      "\u23F3  Merge-gated roadmaps (every open item gated on a PR) \u2014 flip + archive the moment the gating PR merges (`roadmap-progress-sync` Iron Law 1):\n"
+    );
+    for (const r of gated) {
+      const prs = r.merge_gated_prs.map((n) => `#${n}`).join(", ") || "PR unknown";
+      process.stderr.write(
+        `      - ${r.rel}  (${r.done}/${r.total_active} done \xB7 ${r.merge_gated} merge-gated \xB7 ${prs})
+`
+      );
+    }
+  };
+  if (args.check) {
+    const rel = _relPosix(repo_root, target);
+    const r = reportCheckVerdict({
+      verdict: evaluateDashboardOnDisk({ mode: args.mode, target, repo_root, rendered: new_text, rel }),
+      complete,
+      pending,
+      dashboardOnly: args.dashboard_only,
+      warnMergeGated: _warn_merge_gated,
+      gatedCount: gated.length
+    });
+    if (r.stderr) process.stderr.write(r.stderr);
+    if (r.stdout) process.stdout.write(r.stdout);
+    return guarded.problems > 0 ? 1 : r.rc;
+  }
+  fs.writeFileSync(target, new_text, { encoding: "utf-8" });
+  process.stdout.write(
+    `\u2705  Wrote ${_relPosix(repo_root, target)} \xB7 ${roadmaps.length} roadmap(s) \xB7 ${roadmaps.reduce((s, r) => s + r.done, 0)}/${roadmaps.reduce((s, r) => s + r.total_active, 0)} steps done.
+`
+  );
+  if (sweep_out) {
+    process.stdout.write(sweep_out);
+  }
+  if (complete.length) {
+    process.stderr.write(
+      "\u26A0\uFE0F   Completed roadmaps not yet archived \u2014 move to `agents/roadmaps/archive/`:\n"
+    );
+    for (const r of complete) {
+      process.stderr.write(`      - ${r.rel}
+`);
+    }
+  }
+  if (pending.length) {
+    process.stderr.write(
+      "\u26A0\uFE0F   Iron Law 3 \u2014 roadmaps with unresolved `[~]` deferred items. Surface them and ask the user (`roadmap-management \xA7 4b`) before any archive:\n"
+    );
+    for (const r of pending) {
+      process.stderr.write(`      - ${r.rel}  (${r.deferred} deferred)
+`);
+    }
+  }
+  if (gated.length) {
+    _warn_merge_gated();
+  }
+  return guarded.problems > 0 ? 1 : 0;
+}
+if (isCliEntry(import.meta.url, "update_roadmap_progress")) {
+  try {
+    process.exitCode = main();
+  } catch (exc) {
+    if (exc instanceof ArgparseExit) {
+      process.exitCode = exc.code;
+    } else {
+      throw exc;
+    }
+  }
+}
+
+export {
+  CHECKBOX_RE,
+  PHASE_RE,
+  TITLE_RE,
+  FRONTMATTER_RE,
+  _pyRound,
+  PhaseStats,
+  RoadmapStats,
+  parse_frontmatter,
+  is_unscheduled,
+  is_roadmap_candidate,
+  count_checkboxes,
+  blocker_is_resolved,
+  blocker_class,
+  parse_blockers,
+  blocker_needs_user,
+  parse_roadmap,
+  bar,
+  collect,
+  unarchived_complete,
+  merge_gated_pending,
+  pending_iron_law_3,
+  collect_bundles,
+  render,
+  main
+};