@attalabs/vinaya 0.9.0 → 0.12.0

package/aeg-root/tranche-model.md

@@ -260,32 +260,54 @@ Append-only. Each row records one role's turn at a phase. Re-entry appends a **n
 
 - **Phase** — free-text. Convention: `<task-id>: <phase>` for per-task work (e.g. `9: develop`, `9: review`), or a bare phase for tranche-wide work (e.g. `planning`). Phase is opaque to the parser; the convention exists so a future view can pivot by task.
 - **Role** — the AEG role doing the work (`Planner`, `Brief Author`, `Developer`, `Reviewer`, `Security`, `Archivist`).
-- **Agent/Model** — the role's agent + model, with the surface in parentheses: `claude-opus-4-7 (CC)` for Claude Code (terminal), `claude-opus-4-7 (chat)` for a claude.ai conversation. The surface matters because it is what tells you which capture source applies (below).
+- **Agent/Model** — free text: the role's agent + model, with a short tag for the host surface in parentheses (`claude-opus-4-7 (CC)` for a coding-agent session, `claude-opus-4-7 (chat)` for a conversational one — the tags the archived ledgers already use). Nothing parses the tag; it is there because the surface is what tells a reader which collection capability applied (below), and therefore whether a `—` cell was sanctioned.
 - **Tokens in / Tokens out** — integers from the meter, or `—` for "not yet known."
-- **Cost** — USD as `$X.XXXX` from the adapter's PRICING table, or `—`. *(V1 honesty: the PRICING table is currently missing some recent models — e.g. `claude-sonnet-4-20250514` — so cost can read `$0.00` for an otherwise real row. Tokens are still exact; that gap is a known backlog dependency in the model catalogue, not a ledger bug.)*
+- **Cost** — USD as `$X.XXXX`, or `—`. *(V1 honesty: no maintained $/token pricing table for current models ships in this package, so `formatTokensLine` renders this cell as `—` on every row it emits. Historical rows may carry a `$X.XXXX` value supplied by hand or by an earlier table. Tokens are still exact; pricing is a known backlog dependency, not a ledger bug.)*
 - **Date** — `YYYY-MM-DD`.
 
 ### The append rule (read this exactly the way you read derived status)
 
-- **No role appends its own row on a task branch.** Two live-fire incidents forced this: chat/read-only roles (Reviewer, Security, Planner, Brief Author) structurally cannot append — they hold no task branch, and some never touch the repo's filesystem at all; and parallel Developer sessions on different tasks collided appending to the same shared `tokens.md` file. Instead, every role **reports** its token spend in the artifact its turn already produces — the PR body ("Token report" section) for terminal roles, the verdict comment for chat roles doing review, the plan PR or planning report for the Planner — and the per-task **Archivist appends every row at task close-out**, one row per role-turn, including its own.
+- **No role appends its own row on a task branch.** Two live-fire incidents forced this: read-only roles (Reviewer, Security, Planner, Brief Author) structurally cannot append — they hold no task branch, and some never touch the repo's filesystem at all; and parallel Developer sessions on different tasks collided appending to the same shared `tokens.md` file. Instead, every role **reports** its token spend in the artifact its turn already produces — the PR body ("Token report" section) for a role holding a branch, the verdict comment for a reviewing role, the plan PR or planning report for the Planner — and the per-task **Archivist appends every row at task close-out**, one row per role-turn, including its own.
 - **Never edit** an existing row. If you discover a mistake, append a new row that supersedes it in prose (or fix the source file in a separate, declared edit — same exception that `state-machine.md` §13 carves for forward-reference fields).
 - **Re-entry appends.** A Developer dispatched for `9: develop`, asked for changes, and re-running for `9: develop` again produces a **second** `9: develop` report, which the Archivist appends as a **second** row — never a sum, never an overwrite. The two rows both count.
 - The **tranche total is `sum(rows)`**, derived at read time, never stored. This is the same philosophy as forge-derived status (don't store the aggregate; sum the immutable entries). A stored total reintroduces the merge-collision + stale-aggregate problem.
 
-### Two capture sources (the design constraint, not a bug)
+### Three layers — two portable, one host-specific
 
-Token reporting is asymmetric — and any honest design has to encode that, because the asymmetry is a property of the surfaces, not of AEG. The asymmetry now lives in *what a role reports*, not in *who writes the ledger file* — the Archivist writes every row, but the precision of the numbers it copies still depends on the reporting role's surface:
+Token reporting is three separable things, and only one of them depends on the agent host a role happens to run in. Keeping them apart is what lets this model be adopted on a harness AEG has never seen.
 
-The split is **operator vs. agent, not terminal vs. chat** — `/cost` is a Claude Code slash command an operator types at the interactive prompt; an unattended agent session (dispatched, automated, no human at the keyboard) has no way to invoke it, terminal or not. (2026-08-08: retracted — an earlier revision of this section claimed a terminal role reports exact numbers "from `/cost`"; no agent session ever could.)
+1. **The obligation — portable.** Every role reports its own turn's usage at turn-end. This does not weaken, is not best-effort, and is not conditional on the host making it convenient. It exists because the figure is otherwise unrecoverable after the fact (see the retraction below).
+2. **Collection — host-specific.** *How* a role obtains true figures for its own turn. This is the only layer an adapter belongs in, and the only layer that may name a host, a transcript format, or a script path.
+3. **The destination and the grammar — portable.** The `Tokens: …` line, in the artifact the role's turn already produced: the PR body's "Token report" section for a role that holds a branch, the verdict comment for a reviewing role, the plan PR or planning report for the Planner. The ledger stays append-only, and the Archivist transcribes what each role reported rather than re-deriving it.
 
-- **Terminal roles run in Claude Code (Developer; Archivist when automated).** The session's own transcript (`~/.claude/projects/<slug>/<session-id>.jsonl`) carries a `usage` object per assistant message — real, agent-reachable, no operator required. The role runs `packages/aeg-core/bin/report-tokens.ts` against its own session and reports the exact numbers it emits in its PR body. The Archivist copies these numbers verbatim into the row it appends at close-out.
-- **claude.ai roles run in chat (Planner; Brief Author; Reviewer; Security).** A claude.ai conversation **cannot read its own token count** via tool or API, and has no transcript file the way a Claude Code session does — the reporter has nothing to run against. The role still reports at turn-end — phase, role, model, date, in its verdict comment or planning report — but leaves the numeric cells as `—`. The Archivist copies the report as-is; the **Principal** may later supply the real figures from the claude.ai UI usage figure, filling a previously-`—` cell (the one narrow forward-reference exception `state-machine.md` §13 allows).
+The destination was never the coupled part — no role writes a shared ledger file on a task branch, so layer 3 is satisfied through the forge for every task-branch role. Two sources remain the known open gap recorded in `roles/archivist.md`: the Archivist's own row, and the Planner's tranche-wide report. **An adopter implements layer 2 for their own harness and inherits layers 1 and 3 unchanged.** A doctrine sentence that names a tool belongs in layer 2 or nowhere.
 
-Terminal self-capture is real, not manual: the reporter sums a session's own transcript, so a Developer or automated Archivist turn's numbers are exact without any operator step. The remaining manual seam is chat roles only — auto-capture there depends on claude.ai giving a session a way to read its own token count, which it does not today. **Known gap (flagged, not solved):** tranche-wide chat-role turns with no task PR to report into — a Planner session outside a plan PR, a Brief Author session — have no established recording path; see `roles/planner.md` "Plan-PR close-out."
+### Two collection capabilities (the design constraint, not a bug)
+
+Token reporting is asymmetric — and any honest design has to encode that, because the asymmetry is a property of the **host's capability**, not of AEG and not of the role. The asymmetry lives in *what a role can collect*, not in *who writes the ledger file*: the Archivist writes every row, but the precision of the numbers it copies depends on whether the reporting role's host exposes usage to the agent at all.
+
+The split is **operator vs. agent, not terminal vs. chat** — a figure a human reads off an interactive prompt or a usage dashboard is not reachable from an unattended agent session (dispatched, automated, no human at the keyboard), whatever kind of surface it runs on. (2026-08-08: retracted — an earlier revision of this section claimed a terminal role reports exact numbers "from `/cost`", an operator-typed slash command in one particular host; no agent session ever could, in that host or any other.)
+
+- **Self-metering** — a role whose host exposes the running session's own usage to the agent itself, so the role can collect real figures with no operator step. Typically the Developer, and the Archivist when it runs as automation. The role collects through its host's layer-2 mechanism and reports the exact numbers in its PR body; the Archivist copies them verbatim into the row it appends at close-out. **A self-metering role may not report `—` in the `Tokens in` or `Tokens out` cells** — real figures, or the collection step is broken and *that* is what to report. The `Cost` cell is outside this rule: it reads `—` on every row the shipped renderer emits, for the pricing-table reason given above.
+- **Operator-metered** — a role whose host exposes no usage to the agent, leaving a human the only source of the figure. Typically the Planner, Brief Author, Reviewer and Security, which run in conversational surfaces with no session record the agent can read and no meter it can query. The role **still reports at turn-end** — phase, role, model, date, in its verdict comment or planning report — and leaves the numeric cells as `—` when no figure reached it. The blank is licensed by the **absence of a figure**, not by the role's label: where an operator hands the role real numbers at report time (a route layer 2 explicitly allows), those numbers go in the cells and `—` is not correct. The Archivist copies the report as-is; the **Principal** may later supply the real figures from whatever usage view the host does offer a human, filling a previously-`—` cell (the one narrow forward-reference exception `state-machine.md` §13 allows).
+
+**Per-cell optionality is conditioned on host capability, never on convenience.** `—` in a **token** cell is sanctioned in exactly one situation: the host cannot expose the figure to the agent. (The **Cost** cell is separate and is always `—` while this package carries no maintained $/token table — see the Cost bullet above.) It is never a shortcut for a role that could have collected the number, and no role ever estimates a figure or fills in another role's cell — an invented number in an append-only ledger is worse than an honest unknown, because nothing downstream can tell the two apart.
+
+Which capability applies is a fact about the **host**, not a fixed property of the role: the same role is self-metering on a harness that exposes usage and operator-metered on one that does not. Read the role names above as today's common case, not as an allocation.
+
+Self-metering capture is real, not estimated: the adapter sums the session's own usage records, so a Developer or automated Archivist turn's numbers are exact rather than approximated. Whether it also runs with *no* operator step depends on the host's wiring — where a Stop hook writes a transcript pointer — configured in the repo or in the operator's own host settings — the adapter finds it unaided; with no pointer written, the caller names the transcript with `--transcript <path>`. Either way the figures are read, never guessed. The remaining manual seam is operator-metered roles only — closing it depends on the host giving a session a way to read its own usage, which conversational surfaces generally do not today. **Known gap (flagged, not solved):** tranche-wide operator-metered turns with no task PR to report into — a Planner session outside a plan PR, a Brief Author session — have no established recording path; see `roles/planner.md` "Plan-PR close-out."
+
+### The collection adapter AEG ships (one layer-2 instance, not the requirement)
+
+AEG ships exactly one collection adapter, for the Claude Code host: `packages/aeg-core/bin/report-tokens.ts`. It reads that host's session transcript — a JSONL file carrying a `usage` object per assistant message — sums it, and emits a layer-3 `Tokens: …` line. Every doctrine citation of it is an **example of one way to satisfy layer 2**, never the requirement; a role on another host satisfies the same obligation by other means and is equally compliant.
+
+**The seam is the summary shape, not the file tree.** An adapter's whole job is to produce a `TranscriptSummary` — four integers (fresh input, cache creation, cache read, output) plus a model id. Everything downstream of that shape is portable and already shipped: `formatTokensLine` renders the grammar, `parse-token-report.ts` reads it back. Two things sit adapter-side because both know host-specific facts: `summarizeTranscript` (`packages/aeg-core/src/claude-code-transcript.ts`), which knows Claude Code's transcript JSONL and its `usage` field names, and the bin itself, which knows how that host points a session at its own transcript. The `bin/` vs `src/` split does **not** mark this seam and never did.
+
+**To satisfy layer 2 on another harness:** obtain your turn's usage figures by whatever means your host offers — its own transcript or log, an API usage response, a meter the harness exposes, or an operator reading them off a dashboard and handing them over — and write the layer-3 line yourself. Reusing this adapter is not required, and neither is writing any code: the requirement is the reported figures, in the grammar, in the right artifact. If your host exposes nothing to the agent, you are operator-metered and the `—` rule above applies — that is the sanctioned outcome, not a failure to comply.
 
 ### Live reads (Studio) — a second, narrower read path
 
-Vinaya Studio's tranche page no longer reads `<name>.tokens.md` off disk to render token totals — it re-derives the same row shape live off the forge: every MERGED PR on a task's own branch (`task/<tranche>/<id>`), parsing the Developer's "Token report" entries from the PR body (every one, including re-push entries) and the Reviewer's/Security's `Tokens: …` lines from that PR's comments (`packages/aeg-core/src/parse-token-report.ts`'s `aggregateTaskTokenRows`, fetched by `apps/vinaya/web/src/lib/forge/fetch-token-ledger.ts`). Same row shape, same `sumLedger` totals math (`parse-ledger.ts`) — different source.
+Vinaya Studio's tranche page no longer reads `<name>.tokens.md` off disk to render token totals — it re-derives the same row shape live off the forge: every MERGED PR on a task's own branch (`task/<tranche>/<id>`), parsing the Developer's "Token report" entries from the PR body (every one, including re-push entries) and the Reviewer's/Security's `Tokens: …` lines from that PR's comments (`packages/aeg-core/src/parse-token-report.ts`'s `aggregateTaskTokenRows`, fetched by Studio's own forge-reading layer in the repo that hosts it). Same row shape, same `sumLedger` totals math (`parse-ledger.ts`) — different source.
 
 This is deliberately **narrower** than what the Archivist collects into the file: it cannot recover the Archivist's own `<task-id>: archive` row (no PR carries it — the file itself is that row's only record) or the Planner's `Tokens: planning …` report (no reliable way to attribute a plan PR to one task from the forge alone without false-positive cross-task matches, confirmed live during 4b's build — a task Issue's cross-reference timeline picks up ANY PR that merely mentions its number in passing prose, not just its own plan PR). Both remain recoverable only from `.tokens.md`, which is why the file is not deleted here (task 7's job, once the live mechanism is proven in wider use). A task's report that's missing or malformed (e.g. a "Token report" heading with no table and no parseable text after it) yields no row for that report, never a fabricated one — same discipline as the Archivist's own DANGLING convention.
 
@@ -294,7 +316,7 @@ This is deliberately **narrower** than what the Archivist collects into the file
 The ledger is a Section-13 append-only artifact. The familiar forbidden moves apply:
 
 - **No stored total.** Do not add a "current total" row, header field, or anything that has to be edited when a row appends. Derive it.
-- **No edits to past rows** (except the forward-reference exception in §13: filling a previously `—` numeric cell from the claude.ai UI is permitted — it does not change history, only completes it).
+- **No edits to past rows** (except the forward-reference exception in §13: the Principal filling a previously `—` numeric cell from whatever usage view the host offers a human is permitted — it does not change history, only completes it).
 - **No "current spend"** field anywhere — including the tranche file's header. The forge holds execution state; the ledger file holds the cost history. The thin tranche file holds topology. Three artifacts, three concerns.
 
 ---

package/dist/checks/bin/check-branch-topology.js

@@ -2,7 +2,7 @@
 
 // src/checks/bin/check-branch-topology.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-// ../../packages/aeg-core/src/anchored-region.ts
+// ../../packages/aeg-forge-state/src/strip-code.ts
 function maskCode(body) {
   const fill = (line) => " ".repeat(line.length);
   return maskIndentedCode(maskFencedCode(body, fill), fill).replace(/(`+)[^\n]*?\1/g, (m) => " ".repeat(m.length));
@@ -19,29 +19,38 @@ function stripCode(body, options = {}) {
 var FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})([^\r\n]*)\r?$/;
 var FENCE_CLOSE = /^ {0,3}(`+|~+)[ \t]*\r?$/;
 function maskFencedCode(body, fill) {
+  const { lines } = scanFencedCode(body);
+  return lines.map(({ line, inCode }) => inCode ? fill(line) : line).join(`
+`);
+}
+function scanFencedCode(body) {
   let fenceChar = null;
   let fenceLen = 0;
-  return body.split(`
+  const lines = body.split(`
 `).map((line) => {
     if (fenceChar === null) {
       const open = line.match(FENCE_OPEN);
       if (!open)
-        return line;
+        return { line, inCode: false };
       const marker = open[1];
       if (marker[0] === "`" && open[2].includes("`"))
-        return line;
+        return { line, inCode: false };
       fenceChar = marker[0];
       fenceLen = marker.length;
-      return fill(line);
+      return { line, inCode: true };
     }
     const close = line.match(FENCE_CLOSE);
     if (close && close[1][0] === fenceChar && close[1].length >= fenceLen) {
       fenceChar = null;
       fenceLen = 0;
     }
-    return fill(line);
-  }).join(`
-`);
+    return { line, inCode: true };
+  });
+  return { lines, unterminated: fenceChar !== null };
+}
+function hasUnterminatedFence(body) {
+  return scanFencedCode(body.replace(/\r\n?/g, `
+`)).unterminated;
 }
 var LIST_MARKER = /^ {0,3}(?:[-*+]|\d{1,9}[.)])(?:\s|$)/;
 function indentWidth(line) {
@@ -84,88 +93,7 @@ function maskIndentedCode(body, fill) {
   return out.join(`
 `);
 }
-function anchoredRegion(body, field) {
-  const masked = maskCode(body);
-  const start = new RegExp(`<!--\\s*AEG:${field}:START\\s*-->`).exec(masked);
-  if (!start)
-    return null;
-  const afterStart = start.index + start[0].length;
-  const end = new RegExp(`<!--\\s*AEG:${field}:END\\s*-->`).exec(masked.slice(afterStart));
-  if (!end)
-    return null;
-  return body.slice(afterStart, afterStart + end.index);
-}
-// ../../packages/aeg-core/src/parse-registry.ts
-function parseRegistry(md) {
-  const rows = readMarkdownTable(md, /^##\s+Registry\b/i);
-  const projects = [];
-  for (const row of rows) {
-    if (row.length < 4)
-      continue;
-    const name = stripBackticks(row[0] ?? "").trim();
-    const path = stripBackticks(row[1] ?? "").trim();
-    const specsPath = stripBackticks(row[2] ?? "").trim();
-    const stateCell = (row[3] ?? "").trim();
-    if (!name || !path || !specsPath)
-      continue;
-    projects.push({
-      name,
-      path,
-      specsPath,
-      statePath: parseStateCell(stateCell)
-    });
-  }
-  return projects;
-}
-function parseStateCell(cell) {
-  if (!cell)
-    return null;
-  const stripped = stripBackticks(cell).trim();
-  if (/^[\w./@-]+\/?$/.test(stripped) && cell.includes("`")) {
-    return stripped;
-  }
-  return null;
-}
-function stripBackticks(s) {
-  return s.replace(/`/g, "");
-}
-function readMarkdownTable(md, headingMatcher) {
-  const lines = md.split(/\r?\n/);
-  let i = 0;
-  for (;i < lines.length; i++) {
-    if (headingMatcher.test(lines[i] ?? "")) {
-      i++;
-      break;
-    }
-  }
-  if (i >= lines.length)
-    return [];
-  for (;i < lines.length; i++) {
-    if ((lines[i] ?? "").trim().startsWith("|"))
-      break;
-  }
-  if (i + 1 >= lines.length)
-    return [];
-  i += 2;
-  const out = [];
-  for (;i < lines.length; i++) {
-    const trimmed = (lines[i] ?? "").trim();
-    if (!trimmed.startsWith("|"))
-      break;
-    out.push(splitTableRow(trimmed));
-  }
-  return out;
-}
-function splitTableRow(row) {
-  const PLACEHOLDER = "\x00PIPE\x00";
-  const escaped = row.replace(/\\\|/g, PLACEHOLDER);
-  const parts = escaped.split("|").map((s) => s.trim());
-  if (parts.length && parts[0] === "")
-    parts.shift();
-  if (parts.length && parts[parts.length - 1] === "")
-    parts.pop();
-  return parts.map((p) => p.split(PLACEHOLDER).join("|"));
-}
+
 // ../../packages/aeg-forge-state/src/parse-rationale-deps.ts
 var SECTION_HEADER = /\*\*Dependency rationale\*\*/i;
 var NEXT_HEADER = /\*\*[A-Z][^*]*\*\*/;
@@ -463,11 +391,37 @@ function findTrancheSlug(names) {
 var TITLE_PATTERN = /^\[([^\]]+)]\s*(\S+)\s*—\s*(.+)$/;
 var PROJECT_SLUG = /^[a-z0-9][a-z0-9-]*$/i;
 var PROJECT_FIELD = /^\s*(?:\*\*)?Project(?:\(s\))?(?:\*\*)?\s*:\s*(?:\*\*)?\s*(.+)$/im;
+var VALUE_EDGE_MARKUP = /^[`.;\s]+|[`.;\s]+$/g;
+function unwrapValue(raw) {
+  return raw.replace(/\*\*/g, "").replace(VALUE_EDGE_MARKUP, "");
+}
+function projectFieldFromBody(body) {
+  const m = stripCode(body, { inlineSpans: "keep" }).match(PROJECT_FIELD);
+  if (m)
+    return parseFieldValue(m[1] ?? "");
+  if (hasUnterminatedFence(body)) {
+    const raw = body.match(PROJECT_FIELD);
+    if (raw)
+      return { declared: true, names: [], unparsed: [(raw[1] ?? "").trim()], unreadable: true };
+  }
+  return { declared: false, names: [], unparsed: [], unreadable: false };
+}
+function parseFieldValue(value) {
+  const names = [];
+  const unparsed = [];
+  for (const raw of value.split(",")) {
+    const name = unwrapValue(raw);
+    if (name.length === 0)
+      continue;
+    if (PROJECT_SLUG.test(name))
+      names.push(name);
+    else
+      unparsed.push(raw.trim());
+  }
+  return { declared: true, names: [...new Set(names)], unparsed, unreadable: false };
+}
 function projectsFromBody(body) {
-  const m = body.match(PROJECT_FIELD);
-  if (!m)
-    return [];
-  return (m[1] ?? "").split(",").map((s) => s.trim()).filter((s) => PROJECT_SLUG.test(s));
+  return projectFieldFromBody(body).names;
 }
 function taskFromIssue(issue) {
   const m = issue.title.match(TITLE_PATTERN);
@@ -509,8 +463,8 @@ function tasksFromIssues(issues) {
   }
   return tasks.sort((a, b) => compareTaskIds(a.id, b.id));
 }
-async function listTasksForSlugAsync(owner, repo, slug) {
-  return tasksFromIssues(await ghIssueListByAnyLabelAsync(owner, repo, [trancheLabel(slug)]));
+async function fetchTrancheIssuesAsync(owner, repo, slug) {
+  return ghIssueListByAnyLabelAsync(owner, repo, [trancheLabel(slug)]);
 }
 function resolveTaskIssueRef(title, labels) {
   const m = title.match(TITLE_PATTERN);
@@ -526,17 +480,20 @@ function resolveTaskIssueRef(title, labels) {
 }
 
 // ../../packages/aeg-forge-state/src/derive-from-forge.ts
-async function deriveTrancheFromForge(owner, repo, slug, known) {
-  const milestone = known ?? findMilestoneForSlug(owner, repo, slug);
-  const tasks = await listTasksForSlugAsync(owner, repo, slug);
+function trancheFromIssues(slug, issues, known) {
   return {
     name: slug,
-    lifecycle: milestone?.lifecycle ?? "active",
-    goal: milestone?.goal ?? "",
-    tasks,
+    lifecycle: known?.lifecycle ?? "active",
+    goal: known?.goal ?? "",
+    tasks: tasksFromIssues(issues),
     backlog: []
   };
 }
+async function deriveTrancheFromForge(owner, repo, slug, known) {
+  const milestone = known ?? findMilestoneForSlug(owner, repo, slug);
+  const issues = await fetchTrancheIssuesAsync(owner, repo, slug);
+  return trancheFromIssues(slug, issues, milestone);
+}
 // ../../node_modules/universal-user-agent/index.js
 function getUserAgent() {
   if (typeof navigator === "object" && "userAgent" in navigator) {
@@ -1456,6 +1413,96 @@ var systemEnv3 = {
   ...process.env,
   PATH: [process.env.PATH, "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"].filter(Boolean).join(":")
 };
+// ../../packages/aeg-core/src/anchored-region.ts
+function anchoredRegionBounds(body, field) {
+  const masked = maskCode(body);
+  const start = new RegExp(`<!--\\s*AEG:${field}:START\\s*-->`).exec(masked);
+  if (!start)
+    return null;
+  const innerStart = start.index + start[0].length;
+  const end = new RegExp(`<!--\\s*AEG:${field}:END\\s*-->`).exec(masked.slice(innerStart));
+  if (!end)
+    return null;
+  const innerEnd = innerStart + end.index;
+  return { outerStart: start.index, outerEnd: innerEnd + end[0].length, innerStart, innerEnd };
+}
+function anchoredRegion(body, field) {
+  const bounds = anchoredRegionBounds(body, field);
+  if (!bounds)
+    return null;
+  return body.slice(bounds.innerStart, bounds.innerEnd);
+}
+// ../../packages/aeg-core/src/parse-registry.ts
+function parseRegistry(md) {
+  const rows = readMarkdownTable(md, /^##\s+Registry\b/i);
+  const projects = [];
+  for (const row of rows) {
+    if (row.length < 4)
+      continue;
+    const name = stripBackticks(row[0] ?? "").trim();
+    const path = stripBackticks(row[1] ?? "").trim();
+    const specsPath = stripBackticks(row[2] ?? "").trim();
+    const stateCell = (row[3] ?? "").trim();
+    if (!name || !path || !specsPath)
+      continue;
+    projects.push({
+      name,
+      path,
+      specsPath,
+      statePath: parseStateCell(stateCell)
+    });
+  }
+  return projects;
+}
+function parseStateCell(cell) {
+  if (!cell)
+    return null;
+  const stripped = stripBackticks(cell).trim();
+  if (/^[\w./@-]+\/?$/.test(stripped) && cell.includes("`")) {
+    return stripped;
+  }
+  return null;
+}
+function stripBackticks(s) {
+  return s.replace(/`/g, "");
+}
+function readMarkdownTable(md, headingMatcher) {
+  const lines = md.split(/\r?\n/);
+  let i = 0;
+  for (;i < lines.length; i++) {
+    if (headingMatcher.test(lines[i] ?? "")) {
+      i++;
+      break;
+    }
+  }
+  if (i >= lines.length)
+    return [];
+  for (;i < lines.length; i++) {
+    if ((lines[i] ?? "").trim().startsWith("|"))
+      break;
+  }
+  if (i + 1 >= lines.length)
+    return [];
+  i += 2;
+  const out = [];
+  for (;i < lines.length; i++) {
+    const trimmed = (lines[i] ?? "").trim();
+    if (!trimmed.startsWith("|"))
+      break;
+    out.push(splitTableRow(trimmed));
+  }
+  return out;
+}
+function splitTableRow(row) {
+  const PLACEHOLDER = "\x00PIPE\x00";
+  const escaped = row.replace(/\\\|/g, PLACEHOLDER);
+  const parts = escaped.split("|").map((s) => s.trim());
+  if (parts.length && parts[0] === "")
+    parts.shift();
+  if (parts.length && parts[parts.length - 1] === "")
+    parts.pop();
+  return parts.map((p) => p.split(PLACEHOLDER).join("|"));
+}
 // ../../packages/aeg-core/src/state-machine-model.ts
 var FORGE_FACT_INPUTS = [
   {
@@ -1959,23 +2006,65 @@ function checkIssueRationale(body) {
 function isTaskIssueLabelSet(labels) {
   return hasLabel("tranche", labels);
 }
+function isControlCodePoint(codePoint) {
+  return codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+}
+function isDisplayControlCodePoint(codePoint) {
+  return codePoint >= 8203 && codePoint <= 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8294 && codePoint <= 8297 || codePoint === 65279;
+}
+var MESSAGE_VALUE_COUNT_MAX = 5;
+function residueForMessage(values) {
+  const shown = values.slice(0, MESSAGE_VALUE_COUNT_MAX).map((v) => `\`${forMessage(v)}\``);
+  const rest = values.length - shown.length;
+  return rest > 0 ? `${shown.join(", ")} and ${rest} more` : shown.join(", ");
+}
+var MESSAGE_VALUE_MAX = 64;
+function forMessage(value) {
+  const kept = [];
+  for (const ch of value.replace(/\s+/g, " ")) {
+    const codePoint = ch.codePointAt(0) ?? 0;
+    if (isControlCodePoint(codePoint) || isDisplayControlCodePoint(codePoint))
+      continue;
+    kept.push(ch);
+  }
+  const cleaned = kept.join("").trim();
+  if (cleaned.length === 0)
+    return "(unprintable)";
+  const points = Array.from(cleaned);
+  return points.length > MESSAGE_VALUE_MAX ? `${points.slice(0, MESSAGE_VALUE_MAX).join("")}…` : cleaned;
+}
 function checkProjectsRegistered(body, _labels, registeredNames) {
   if (registeredNames.length === 0)
     return { status: "pass", errors: [] };
-  const known = new Set(registeredNames.map((n) => n.trim()));
-  const unregistered = projectsFromBody(body).filter((p) => !known.has(p));
-  if (unregistered.length === 0)
+  const field = projectFieldFromBody(body);
+  if (!field.declared)
     return { status: "pass", errors: [] };
-  const caseHints = unregistered.map((p) => {
-    const row = [...known].find((k) => k.toLowerCase() === p.toLowerCase());
-    return row ? `\`${p}\` differs from the registered \`${row}\` only in case` : null;
-  }).filter((h) => h !== null);
-  return {
-    status: "fail",
-    errors: [
-      `issue-validation project registry: the \`**Project:**\` field declares ${unregistered.join(", ")} — no such row in \`.vinaya/projects.md\`, which is the authority for valid project names (registered: ${[...registeredNames].join(", ")}). Fix the name, or register the project with \`vinaya init product <name> --path <folder>\` first; an unregistered project has no specs to read and no per-project state to update.${caseHints.length > 0 ? ` Note: ${caseHints.join("; ")} — project names are matched exactly, because every downstream consumer compares them literally.` : ""} This reads the same field \`projectsFromBody\` derives the task's project from, so a name here that is not a row is a task that resolves to a project that does not exist.`
-    ]
-  };
+  const known = new Set(registeredNames.map((n) => n.trim()));
+  const registeredList = [...registeredNames].map(forMessage).join(", ");
+  const errors = [];
+  if (field.unreadable) {
+    return {
+      status: "fail",
+      errors: [
+        `issue-validation project registry: the body has an unterminated code fence, so its \`**Project:**\` field could not be read reliably — the fence runs to end of body (CommonMark, and how the forge renders it), swallowing everything after it including the foot field where the declaration lives by convention. Read from the raw body the field says ${residueForMessage(field.unparsed) || "(nothing)"}, but a line inside a swallowed region may be a quoted example rather than a real declaration, so this gate refuses rather than guessing which. Balance the fences — every opening run of backticks or tildes needs a closing run at least as long — and the field reads normally.`
+      ]
+    };
+  }
+  const unregistered = field.names.filter((p) => !known.has(p));
+  if (unregistered.length > 0) {
+    const caseHints = unregistered.map((p) => {
+      const row = [...known].find((k) => k.toLowerCase() === p.toLowerCase());
+      return row ? `\`${forMessage(p)}\` differs from the registered \`${forMessage(row)}\` only in case` : null;
+    }).filter((h) => h !== null);
+    errors.push(`issue-validation project registry: the \`**Project:**\` field declares ${unregistered.map(forMessage).join(", ")} — no such row in \`.vinaya/projects.md\`, which is the authority for valid project names (registered: ${registeredList}). Fix the name, or register the project with \`vinaya init product <name> --path <folder>\` first; an unregistered project has no specs to read and no per-project state to update.${caseHints.length > 0 ? ` Note: ${caseHints.join("; ")} — project names are matched exactly, because every downstream consumer compares them literally.` : ""} This reads the same field \`projectsFromBody\` derives the task's project from, so a name here that is not a row is a task that resolves to a project that does not exist.`);
+  }
+  if (field.names.length === 0) {
+    const residue = field.unparsed.length > 0 ? ` — ${residueForMessage(field.unparsed)}` : " — the field is empty";
+    errors.push(`issue-validation project registry: the \`**Project:**\` field is present but resolves to no project name${residue} (registered: ${registeredList}). A project name is a slug (\`[a-z0-9][a-z0-9-]*\`, matched exactly); prose, a parenthetical, or a sentence in this field resolves to no project at all, and this gate cannot check a name it never receives — which is how a declaration like this used to pass. Write the registered name on its own, or register the project with \`vinaya init product <name> --path <folder>\` first. If the task genuinely touches no registered project, omit the field rather than explaining its absence inside it — \`checkIssueRationale\` already requires the \`Project(s) + blast radius\` narrative field for that.`);
+  } else if (field.unparsed.length > 0) {
+    errors.push(`issue-validation project registry: the \`**Project:**\` field declares a value that is not a project name — ${residueForMessage(field.unparsed)} (registered: ${registeredList}). The rest of the field parsed, so this is a name the gate silently could not check rather than a field it could not read at all. A project name is a slug (\`[a-z0-9][a-z0-9-]*\`, matched exactly); write it on its own, or drop it if it names no project.`);
+  }
+  return errors.length > 0 ? { status: "fail", errors } : { status: "pass", errors: [] };
 }
 
 // ../../packages/aeg-core/src/coherence-checks.ts