@event4u/agent-config 14.21.0 → 14.23.0

package/dist/cli-delegate/{chunk-YS6XTLEK.js → chunk-TYSY33MD.js}

@@ -224,6 +224,31 @@ var MAX_LINE_CHARS = 240;
 var MAX_ENTRIES = 40;
 var CAPSULE_SCHEMA_VERSION = 4;
 var ACCEPTED_CAPSULE_VERSIONS = [3, 4];
+var CAPSULE_VARIANTS = ["worker", "main_session", "continuity_record"];
+var CONTINUITY_RECORD_FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "decisions",
+  "constraints",
+  "do_not_touch",
+  "assumptions",
+  "failed_approaches",
+  "successful_approaches",
+  "open_questions",
+  "not_carried_forward",
+  "status_summary",
+  "suggested_skills",
+  "open_worker_envelopes"
+]);
+var CONTINUITY_RECORD_REQUIRED_KEYS = [
+  "capsule_version",
+  "variant",
+  "summary",
+  "task",
+  "workspace",
+  "written_at",
+  "acceptance_criteria",
+  "remaining",
+  "predecessor"
+];
 function isShortLine(value, max) {
   return typeof value === "string" && value.length > 0 && value.length <= max && !value.includes("\n");
 }
@@ -406,13 +431,38 @@ function validateRecycleEnvelope(input) {
       );
     }
   }
+  const variant = e["variant"];
+  if (typeof variant !== "string" || !CAPSULE_VARIANTS.includes(variant)) {
+    return [
+      `unknown variant ${JSON.stringify(variant)} \u2014 this reader knows ${CAPSULE_VARIANTS.join(" | ")}. A reader that does not know a variant must not guess at its required fields, so no further field checks were run.`
+    ];
+  }
+  if (variant === "worker") {
+    return [
+      "variant 'worker' is a subagent generation handover and is validated by the worker path, not by the main-session recycle validator \u2014 routing it here would apply the wrong required set to a well-formed record."
+    ];
+  }
+  const isDerived = variant === "continuity_record";
   const version = e["capsule_version"];
   if (typeof version !== "number" || !ACCEPTED_CAPSULE_VERSIONS.includes(version)) {
     errors.push(`capsule_version must be one of ${ACCEPTED_CAPSULE_VERSIONS.join(" | ")}`);
   }
-  const atV4 = version === 4;
-  if (e["variant"] !== "main_session") {
-    errors.push("variant must be 'main_session'");
+  const atV4 = version === 4 && !isDerived;
+  if (isDerived) {
+    for (const key of Object.keys(e)) {
+      if (CONTINUITY_RECORD_FORBIDDEN_KEYS.has(key)) {
+        errors.push(
+          `field "${key}" is forbidden on variant 'continuity_record' \u2014 it carries a model judgement, and a record written without model spend cannot have made one. Use variant 'main_session' for a judged record.`
+        );
+      }
+    }
+    for (const key of CONTINUITY_RECORD_REQUIRED_KEYS) {
+      if (e[key] === void 0) {
+        errors.push(
+          `field "${key}" is required on variant 'continuity_record' \u2014 it is computable from on-disk state, so its absence is a writer defect rather than an unavailable judgement.`
+        );
+      }
+    }
   }
   if (!isShortLine(e["summary"], MAX_LINE_CHARS)) {
     errors.push(`summary must be a single line of 1\u2013${MAX_LINE_CHARS} chars`);
@@ -432,7 +482,7 @@ function validateRecycleEnvelope(input) {
     errors.push('acceptance_criteria must carry at least one entry \u2014 the successor cannot know "done" without it');
   }
   checkList(errors, "remaining", e["remaining"], MAX_LINE_CHARS, true);
-  checkList(errors, "not_carried_forward", e["not_carried_forward"], MAX_LINE_CHARS, true);
+  checkList(errors, "not_carried_forward", e["not_carried_forward"], MAX_LINE_CHARS, !isDerived);
   checkList(errors, "decisions", e["decisions"], MAX_LINE_CHARS, false);
   errors.push(...decisionTagErrors(e["decisions"]));
   checkList(errors, "constraints", e["constraints"], MAX_LINE_CHARS, false);
@@ -443,7 +493,7 @@ function validateRecycleEnvelope(input) {
   if (e["next_task"] !== void 0 && !isShortLine(e["next_task"], MAX_LINE_CHARS)) {
     errors.push(`next_task must be a single line of 1\u2013${MAX_LINE_CHARS} chars`);
   }
-  checkList(errors, "failed_approaches", e["failed_approaches"], MAX_LINE_CHARS, true);
+  checkList(errors, "failed_approaches", e["failed_approaches"], MAX_LINE_CHARS, !isDerived);
   if (Array.isArray(e["failed_approaches"]) && e["failed_approaches"].length === 0) {
     errors.push(
       'failed_approaches must carry at least one entry \u2014 write "none" explicitly, so silence and "nothing was abandoned" stay distinguishable'
@@ -458,7 +508,7 @@ function validateRecycleEnvelope(input) {
   checkList(errors, "open_questions", e["open_questions"], MAX_LINE_CHARS, false);
   const predecessor = e["predecessor"];
   if (predecessor === void 0) {
-    if (atV4) {
+    if (atV4 || isDerived) {
       errors.push(
         'predecessor is required \u2014 name the session this one continues, or write "none" explicitly for the first session in a workspace'
       );

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

@@ -0,0 +1,328 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  isCliEntry
+} from "./chunk-5EK5WQN6.js";
+
+// src/agent-src/scripts/stubs_due.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var STUB_DIR = path.join("agents", "roadmaps", "stubs");
+var CADENCE_DAYS = { transfer: 30, orgmode: 120 };
+var TRANSFER_MARKER = "drain-run transfer";
+var _HERE = path.resolve(fileURLToPath(import.meta.url));
+var BLOCKED_QUICKWIN_FIELDS = ["design_validated", "capability_gap", "blocker_class"];
+var QUICKWIN_BLOCKER_CLASSES = ["estate", "budget"];
+function is_blocked_quickwin(design_validated, capability_gap, blocker_class) {
+  if (design_validated === null || design_validated === "") return false;
+  if (capability_gap !== "none") return false;
+  return QUICKWIN_BLOCKER_CLASSES.includes(blocker_class ?? "");
+}
+function _isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function repo_root(start) {
+  let cur = start ?? process.cwd();
+  const chain = [cur];
+  for (; ; ) {
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    chain.push(parent);
+    cur = parent;
+  }
+  for (const candidate of chain) {
+    if (_isDir(path.join(candidate, STUB_DIR))) {
+      return candidate;
+    }
+  }
+  return start ?? process.cwd();
+}
+function _frontmatter(text) {
+  const lines = text.split("\n");
+  if (lines[0]?.trim() !== "---") {
+    return [];
+  }
+  const out = [];
+  for (const line of lines.slice(1)) {
+    if (line.trim() === "---") {
+      return out;
+    }
+    out.push(line);
+  }
+  return [];
+}
+function _scalar(front, key) {
+  const prefix = `${key}:`;
+  for (const line of front) {
+    if (line.startsWith(prefix)) {
+      return line.slice(prefix.length).trim().replace(/^["']|["']$/g, "");
+    }
+  }
+  return null;
+}
+function count_owner_decisions(text) {
+  const lines = text.split("\n");
+  let n = 0;
+  for (const line of lines) {
+    if (/^#{2,4}\s+Unresolved decision\b/.test(line)) {
+      n += 1;
+    }
+  }
+  let inBlocker = false;
+  let ownerIsMaintainer = false;
+  let statusOpen = false;
+  const flush = () => {
+    if (inBlocker && ownerIsMaintainer && statusOpen) {
+      n += 1;
+    }
+    inBlocker = false;
+    ownerIsMaintainer = false;
+    statusOpen = false;
+  };
+  for (const line of lines) {
+    if (/^#{2,4}\s+(blocker:|b-)/.test(line.trim()) || /^#{2,4}\s+\S+ — /.test(line)) {
+      if (/blocker:/.test(line) || /^#{2,4}\s+b-/.test(line.trim())) {
+        flush();
+        inBlocker = true;
+        continue;
+      }
+    }
+    if (!inBlocker) continue;
+    if (/^#{1,4}\s/.test(line)) {
+      flush();
+      continue;
+    }
+    if (/^-\s+\*\*Owner:\*\*\s*maintainer\b/i.test(line)) ownerIsMaintainer = true;
+    if (/^-\s+\*\*Status:\*\*\s*open\b/i.test(line)) statusOpen = true;
+  }
+  flush();
+  return n;
+}
+function _addDays(from, days) {
+  const d = new Date(from.getTime() + days * 864e5);
+  return d.toISOString().slice(0, 10);
+}
+function _parseIso(s) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(s)) return null;
+  const d = /* @__PURE__ */ new Date(`${s}T00:00:00Z`);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+function scan(root, today) {
+  return scan_dir(path.join(root, STUB_DIR), today, release_dates(root));
+}
+var CHANGELOG_ERAS = ["CHANGELOG.md", "docs/archive/CHANGELOG-pre-14.12.0.md"];
+var RELEASE_HEADING = /^## \[\d+\.\d+\.\d+\][^\n]*\((\d{4}-\d{2}-\d{2})\)\s*$/gm;
+function release_dates(root) {
+  const out = [];
+  for (const rel of CHANGELOG_ERAS) {
+    let text;
+    try {
+      text = fs.readFileSync(path.join(root, rel), "utf8");
+    } catch {
+      continue;
+    }
+    for (const m of text.matchAll(RELEASE_HEADING)) {
+      if (m[1] !== void 0) out.push(m[1]);
+    }
+  }
+  return out;
+}
+function releases_since(opened, dates) {
+  return dates.filter((d) => d > opened).length;
+}
+function scan_dir(base, today, releaseDates = []) {
+  if (!_isDir(base)) return [];
+  const now = _parseIso(today);
+  const out = [];
+  let names;
+  try {
+    names = fs.readdirSync(base).filter((n) => n.endsWith(".md") && n !== "README.md").sort();
+  } catch {
+    return [];
+  }
+  for (const name of names) {
+    let text;
+    try {
+      text = fs.readFileSync(path.join(base, name), "utf8");
+    } catch {
+      continue;
+    }
+    const front = _frontmatter(text);
+    const review_by = _scalar(front, "review_by");
+    const reviewed_at = _scalar(front, "reviewed_at");
+    const probeVal = _scalar(front, "probe");
+    const design_validated = _scalar(front, "design_validated");
+    const capability_gap = _scalar(front, "capability_gap");
+    const blocker_class = _scalar(front, "blocker_class");
+    const blocker_opened = _scalar(front, "blocker_opened");
+    const shape = text.includes(TRANSFER_MARKER) ? "transfer" : "orgmode";
+    let overdue = false;
+    let days_overdue = null;
+    if (review_by !== null && now !== null) {
+      const due = _parseIso(review_by);
+      if (due !== null && due.getTime() < now.getTime()) {
+        overdue = true;
+        days_overdue = Math.round((now.getTime() - due.getTime()) / 864e5);
+      }
+    }
+    out.push({
+      file: `${STUB_DIR}/${name}`,
+      shape,
+      review_by,
+      reviewed_at,
+      probe_none: probeVal === "none",
+      has_probe_heading: /^#{1,4} *(Probe|Promotion)/m.test(text),
+      owner_decisions: count_owner_decisions(text),
+      overdue,
+      days_overdue,
+      design_validated,
+      capability_gap,
+      blocker_class,
+      blocker_opened,
+      releases_since_blocked: blocker_opened === null ? null : releases_since(blocker_opened, releaseDates),
+      blocked_quickwin: is_blocked_quickwin(design_validated, capability_gap, blocker_class)
+    });
+  }
+  return out;
+}
+function counts(records) {
+  return {
+    overdue: records.filter((r) => r.overdue).length,
+    owner_decisions: records.reduce((s, r) => s + r.owner_decisions, 0),
+    missing_review_by: records.filter((r) => r.review_by === null).length,
+    blocked_quickwin: records.filter((r) => r.blocked_quickwin).length,
+    total: records.length
+  };
+}
+function due_date(shape, from) {
+  const d = _parseIso(from) ?? /* @__PURE__ */ new Date();
+  return _addDays(d, CADENCE_DAYS[shape]);
+}
+function main(argv = process.argv.slice(2)) {
+  const asJson = argv.includes("--json");
+  const countsOnly = argv.includes("--counts");
+  const todayIdx = argv.indexOf("--today");
+  const today = todayIdx >= 0 && argv[todayIdx + 1] !== void 0 ? argv[todayIdx + 1] : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const root = repo_root();
+  const records = scan(root, today);
+  const c = counts(records);
+  if (countsOnly) {
+    process.stdout.write(`${c.overdue} ${c.owner_decisions}
+`);
+    return 0;
+  }
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify({ today, counts: c, stubs: records }, null, 2)}
+`);
+    return 0;
+  }
+  process.stdout.write(`stubs:due \xB7 ${today} \xB7 ${c.total} stub(s) under ${STUB_DIR}/
+
+`);
+  const overdue = records.filter((r) => r.overdue).sort((a, b) => (b.days_overdue ?? 0) - (a.days_overdue ?? 0));
+  if (overdue.length === 0) {
+    process.stdout.write("  \u2705  no stub is past its review date.\n");
+  } else {
+    process.stdout.write(`  \u26A0\uFE0F   ${overdue.length} overdue:
+`);
+    for (const r of overdue) {
+      process.stdout.write(
+        `      ${r.file}  (${r.shape}, due ${r.review_by}, ${r.days_overdue}d late)
+`
+      );
+    }
+  }
+  if (c.missing_review_by > 0) {
+    process.stdout.write(
+      `
+  \u26A0\uFE0F   ${c.missing_review_by} stub(s) carry no \`review_by:\` \u2014 see ${STUB_DIR}/README.md \xA7 Frontmatter contract:
+`
+    );
+    for (const r of records.filter((x) => x.review_by === null)) {
+      process.stdout.write(
+        `      ${r.file}  (${r.shape}, suggested ${due_date(r.shape, today)})
+`
+      );
+    }
+  }
+  const withDecisions = records.filter((r) => r.owner_decisions > 0);
+  process.stdout.write(`
+  ${c.owner_decisions} decision(s) routed to the owner`);
+  if (withDecisions.length === 0) {
+    process.stdout.write(".\n");
+  } else {
+    process.stdout.write(":\n");
+    for (const r of withDecisions) {
+      process.stdout.write(`      ${r.file}  (${r.owner_decisions})
+`);
+    }
+  }
+  const quickwins = records.filter((r) => r.blocked_quickwin);
+  if (quickwins.length > 0) {
+    process.stdout.write(
+      `
+  \u{1F513}  ${quickwins.length} BLOCKED QUICK-WIN(S) \u2014 design validated, no capability gap,
+      held by an estate or budget decision rather than a product one:
+`
+    );
+    for (const r of quickwins) {
+      const since = r.releases_since_blocked === null ? "no `blocker_opened:`" : `${String(r.releases_since_blocked)} release(s) since ${r.blocker_opened}`;
+      process.stdout.write(`      ${r.file}  (${r.blocker_class}, ${since})
+`);
+    }
+  }
+  const noProbe = records.filter((r) => !r.probe_none && !r.has_probe_heading);
+  if (noProbe.length > 0) {
+    process.stdout.write(
+      `
+  \u26A0\uFE0F   ${noProbe.length} stub(s) name no promoting probe and do not say \`probe: none\`:
+`
+    );
+    for (const r of noProbe) {
+      process.stdout.write(`      ${r.file}
+`);
+    }
+  }
+  process.stdout.write("\n  Read-only. This command writes nothing.\n");
+  return 0;
+}
+if (isCliEntry(import.meta.url, "stubs_due")) {
+  process.exitCode = main();
+}
+function headerFragment(stubsDir, today) {
+  let overdue = 0;
+  let decisions = 0;
+  try {
+    const c = counts(scan_dir(stubsDir, today ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)));
+    overdue = c.overdue;
+    decisions = c.owner_decisions;
+  } catch {
+    return "";
+  }
+  if (overdue === 0 && decisions === 0) {
+    return "";
+  }
+  return ` \xB7 **${overdue}** overdue stub${overdue !== 1 ? "s" : ""}, **${decisions}** owner decision${decisions !== 1 ? "s" : ""} \u2192 \`agent-config stubs:due\``;
+}
+
+export {
+  CADENCE_DAYS,
+  BLOCKED_QUICKWIN_FIELDS,
+  QUICKWIN_BLOCKER_CLASSES,
+  is_blocked_quickwin,
+  repo_root,
+  count_owner_decisions,
+  scan,
+  CHANGELOG_ERAS,
+  release_dates,
+  releases_since,
+  scan_dir,
+  counts,
+  due_date,
+  main,
+  headerFragment
+};

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

@@ -0,0 +1,187 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/agent-src/scripts/guarded_baseline.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+var GUARDED_BASELINE_RE = /<!--[ \t]*roadmap-status:[ \t]*guarded-baseline[ \t]*-->/;
+var GUARDED_CATEGORIES = ["future-mechanism", "absence-assertion"];
+var ANY_CHECKBOX_RE = /^[ \t]*[-*][ \t]+\[([ xX~-])\]/;
+var SPAN_END_RE = /^[ \t]*[-*][ \t]+\[[ xX~-]\]|^#{1,6}[ \t]/;
+var BLOCK_START_RE = /^[ \t]*guarded_baseline:[ \t]*$/;
+var FIELD_RE = /^[ \t]*([a-z_]+):[ \t]*(.*)$/;
+var FENCE_RE = /^[ \t]*(?:```|~~~)/;
+var LIST_ITEM_RE = /^[ \t]*[-*][ \t]+/;
+var INLINE_CODE_RE = /`[^`]*`/g;
+function _label(annotatedLine, lines, i) {
+  const own = annotatedLine.replace(ANY_CHECKBOX_RE, "").replace(GUARDED_BASELINE_RE, "").replace(/\*\*/g, "").trim();
+  if (own !== "") {
+    return own;
+  }
+  for (let j = i + 1; j < lines.length; j++) {
+    const next = lines[j].trim();
+    if (next === "") {
+      continue;
+    }
+    if (SPAN_END_RE.test(lines[j])) {
+      break;
+    }
+    return next.replace(/\*\*/g, "").trim();
+  }
+  return "(unlabelled)";
+}
+function parseGuardedBaselines(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (FENCE_RE.test(raw)) {
+      inFence = !inFence;
+    }
+    if (inFence || !LIST_ITEM_RE.test(raw)) {
+      continue;
+    }
+    if (!GUARDED_BASELINE_RE.test(raw.replace(INLINE_CODE_RE, ""))) {
+      continue;
+    }
+    const box = ANY_CHECKBOX_RE.exec(raw);
+    const fields = {};
+    let hasBlock = false;
+    for (let j = i + 1; j < lines.length; j++) {
+      const line = lines[j];
+      if (SPAN_END_RE.test(line)) {
+        break;
+      }
+      if (FENCE_RE.test(line)) {
+        continue;
+      }
+      if (!hasBlock) {
+        hasBlock = BLOCK_START_RE.test(line);
+        continue;
+      }
+      const f = FIELD_RE.exec(line);
+      if (f) {
+        fields[f[1]] = f[2].trim();
+      }
+    }
+    out.push({
+      line: i + 1,
+      label: _label(raw, lines, i),
+      glyph: box ? box[1] : null,
+      hasBlock,
+      fields
+    });
+  }
+  return out;
+}
+function guardedBaselineProblems(items) {
+  const problems = [];
+  for (const it of items) {
+    const at = `line ${it.line} (${it.label})`;
+    if (it.glyph === null) {
+      problems.push(
+        `${at}: the guarded-baseline annotation is not on a checkbox step \u2014 it is only legal on an unchecked \`- [ ]\` line`
+      );
+    } else if (it.glyph !== " ") {
+      problems.push(
+        `${at}: the guarded-baseline annotation sits on \`[${it.glyph}]\` \u2014 the canonical checkbox stays UNCHECKED; only verification against the real mechanism permits \`[x]\``
+      );
+    }
+    if (!it.hasBlock) {
+      problems.push(`${at}: carries no adjacent \`guarded_baseline:\` evidence block`);
+    }
+    if ((it.fields["red_proof"] ?? "") === "") {
+      problems.push(
+        `${at}: records no \`red_proof\` \u2014 a baseline that has not demonstrably gone RED is an ordinary open item, not a guarded one`
+      );
+    }
+    const category = it.fields["category"] ?? "";
+    if (category === "") {
+      problems.push(
+        `${at}: records no \`category\` \u2014 one of ${GUARDED_CATEGORIES.join(", ")} is required, and absence is not defaulted`
+      );
+    } else if (!GUARDED_CATEGORIES.includes(category)) {
+      problems.push(
+        `${at}: records category \`${category}\`, which is not one of ` + GUARDED_CATEGORIES.join(", ")
+      );
+    }
+  }
+  return problems;
+}
+function guardedBaselineStaleness(items, repo_root) {
+  const stale = [];
+  const unverifiable = [];
+  for (const it of items) {
+    const trigger = it.fields["recheck_when"] ?? "";
+    if (trigger === "") {
+      continue;
+    }
+    const tokens = trigger.split(/[\s,]+/).filter((t) => t !== "");
+    const paths = tokens.filter((t) => t.includes("/"));
+    for (const token of paths) {
+      if (fs.existsSync(path.join(repo_root, token))) {
+        stale.push(
+          `line ${it.line} (${it.label}): recheck_when \`${token}\` now exists \u2014 re-verify against the real mechanism`
+        );
+      }
+    }
+    if (paths.length > 0) {
+      continue;
+    }
+    for (const token of tokens) {
+      unverifiable.push(`line ${it.line} (${it.label}): recheck_when \`${token}\``);
+    }
+  }
+  return { stale, unverifiable };
+}
+function reportGuardedBaselines(roadmaps, repo_root, write = (s) => process.stderr.write(s)) {
+  const rows = [];
+  let problems = 0;
+  for (const r of roadmaps) {
+    let items;
+    try {
+      items = parseGuardedBaselines(fs.readFileSync(r.path, { encoding: "utf-8" }));
+    } catch {
+      continue;
+    }
+    if (items.length === 0) {
+      continue;
+    }
+    const bad = guardedBaselineProblems(items);
+    const { stale, unverifiable } = guardedBaselineStaleness(items, repo_root);
+    problems += bad.length;
+    rows.push(
+      `| [${r.rel}](roadmaps/${r.rel}) | ${items.length} | ${stale.length} | ${bad.length} |`
+    );
+    write(
+      `\u{1F6E1}\uFE0F   ${r.rel}: ${items.length} guarded-baseline step(s) \u2014 RED-proven, NOT complete, and blocking archival:
+`
+    );
+    for (const it of items) {
+      write(`      - ${it.label}  (category ${it.fields["category"] ?? "\u2014"})
+`);
+    }
+    for (const p of bad) write(`      \u274C ${p}
+`);
+    for (const s of stale) write(`      \u26A0\uFE0F  ${s}
+`);
+    for (const u of unverifiable) write(`      \xB7  not machine-checkable: ${u}
+`);
+  }
+  if (rows.length === 0) {
+    return { section: "", problems };
+  }
+  return {
+    section: "\n## \u{1F6E1}\uFE0F Guarded baselines \u2014 RED-proven, not complete\n\nThese steps carry `<!-- roadmap-status: guarded-baseline -->`: an executable guard exists and has been shown to go RED under a named sabotage, but the acceptance criterion names a mechanism that does not exist yet. They are **not** done, they are **not** counted as done, and they **block archival** until the real mechanism is verified (council 2026-08-31, 2/2 convergent).\n\n| Roadmap | Guarded | Stale | Rejected |\n|---|---:|---:|---:|\n" + rows.join("\n") + "\n",
+    problems
+  };
+}
+
+export {
+  GUARDED_BASELINE_RE,
+  GUARDED_CATEGORIES,
+  parseGuardedBaselines,
+  guardedBaselineProblems,
+  guardedBaselineStaleness,
+  reportGuardedBaselines
+};

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

@@ -0,0 +1,48 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/agent-src/scripts/archival_sweep.ts
+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);
+function _isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function run_archival_sweep(root) {
+  const script = path.join(path.dirname(_HERE), "archive_completed_roadmaps.ts");
+  if (!_isFile(script)) {
+    return { ran: false, ok: true, stdout: "", stderr: "" };
+  }
+  const argv = [script, "--all", "--repo-root", root];
+  const binName = process.platform === "win32" ? "tsx.cmd" : "tsx";
+  let dir = path.dirname(_HERE);
+  for (; ; ) {
+    const candidate = path.join(dir, "node_modules", ".bin", binName);
+    if (fs.existsSync(candidate)) {
+      return _sweepResult(spawnSync(candidate, argv, { cwd: root, encoding: "utf-8" }));
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return _sweepResult(spawnSync("npx", ["tsx", ...argv], { cwd: root, encoding: "utf-8" }));
+}
+function _sweepResult(r) {
+  return {
+    ran: true,
+    ok: r.status === 0,
+    stdout: String(r.stdout ?? ""),
+    stderr: String(r.stderr ?? "")
+  };
+}
+
+export {
+  run_archival_sweep
+};