@attalabs/vinaya 0.24.0 → 0.25.0

package/dist/checks/bin/check-coherence.js

@@ -1941,13 +1941,18 @@ function parseInlineFieldList(section) {
 }
 // ../../packages/aeg-core/src/verdict-extraction.ts
 var HEAD_SHA_PATTERN = /^[ \t]*(?:\*{1,3}|_{1,3})?Judged head:\s*([0-9a-f]{7,40})(?![A-Za-z0-9])/im;
-function firstThreeLines(comment) {
+var OBJECTIVES_VERSION_PATTERN = /^[ \t]*(?:\*{1,3}|_{1,3})?Objectives version:\s*([0-9a-f]{64})(?![A-Za-z0-9])/im;
+function firstFiveLines(comment) {
   return comment.split(`
-`).slice(0, 3).join(`
+`).slice(0, 5).join(`
 `);
 }
 function extractHeadSha(comment) {
-  const m = firstThreeLines(comment).match(HEAD_SHA_PATTERN);
+  const m = firstFiveLines(comment).match(HEAD_SHA_PATTERN);
+  return m ? m[1].toLowerCase() : null;
+}
+function extractObjectivesVersion(comment) {
+  const m = firstFiveLines(comment).match(OBJECTIVES_VERSION_PATTERN);
   return m ? m[1].toLowerCase() : null;
 }
 function extractVerdict(comments, valuePattern, missingLabel) {
@@ -1956,21 +1961,24 @@ function extractVerdict(comments, valuePattern, missingLabel) {
     return {
       value: `no ${missingLabel} pass was run before merge — DANGLING, see below`,
       headSha: null,
+      objectivesVersion: null,
       danglingNote: `no ${missingLabel} verdict comment found on this PR`
     };
   }
   const latest = candidates[candidates.length - 1];
-  const m = firstThreeLines(latest).match(valuePattern);
+  const m = firstFiveLines(latest).match(valuePattern);
   if (!m) {
     return {
-      value: `the most recent ${missingLabel} comment's VERDICT line is not within its first three lines — DANGLING, see below`,
+      value: `the most recent ${missingLabel} comment's VERDICT line is not within its first five lines — DANGLING, see below`,
       headSha: null,
-      danglingNote: `the most recent ${missingLabel} verdict comment carries a VERDICT-shaped line outside the first-three-line read window`
+      objectivesVersion: null,
+      danglingNote: `the most recent ${missingLabel} verdict comment carries a VERDICT-shaped line outside the first-five-line read window`
     };
   }
   return {
     value: m[1].toUpperCase().replace(/[_-]/g, " "),
     headSha: extractHeadSha(latest),
+    objectivesVersion: extractObjectivesVersion(latest),
     danglingNote: null
   };
 }
@@ -2327,8 +2335,105 @@ function overrideActive(opts) {
     return true;
   return false;
 }
-// ../../packages/aeg-core/src/premise-check.ts
+// ../../packages/aeg-core/src/objectives.ts
 import { createHash as createHash2 } from "node:crypto";
+var HEADING_RE = /^##[ \t]*Objectives[ \t]*$/im;
+var NEXT_HEADING_RE = /^##[ \t]/m;
+var OBJECTIVE_LINE_RE = /^O(\d+)\.[ \t]*(.*)$/;
+function hasBacktickedPath(text) {
+  let i = 0;
+  while (i < text.length) {
+    const start = text.indexOf("`", i);
+    if (start === -1)
+      return false;
+    const end = text.indexOf("`", start + 1);
+    if (end === -1)
+      return false;
+    if (text.slice(start + 1, end).includes("/"))
+      return true;
+    i = end + 1;
+  }
+  return false;
+}
+var MIN_WORDS_OUTSIDE_BACKTICKS = 3;
+function stripObjectiveBackticks(text) {
+  return text.replace(/`[^`\n]*`/g, " ");
+}
+function wordCount(text) {
+  return text.split(/\s+/).filter((w) => /[a-z]/i.test(w)).length;
+}
+function objectivesSectionText(body) {
+  const heading = HEADING_RE.exec(body);
+  if (!heading)
+    return null;
+  const afterHeading = body.slice(heading.index + heading[0].length);
+  const next = NEXT_HEADING_RE.exec(afterHeading);
+  return next ? afterHeading.slice(0, next.index) : afterHeading;
+}
+function hasObjectivesHeading(body) {
+  return HEADING_RE.test(body);
+}
+function objectivesOf(body) {
+  const section = objectivesSectionText(body);
+  if (section === null) {
+    return { ok: false, errors: ["no `## Objectives` heading found in the body."] };
+  }
+  const lines = section.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+  if (lines.length === 0) {
+    return { ok: false, errors: ["the `## Objectives` section has no `O<n>.` lines."] };
+  }
+  const objectives = [];
+  const errors = [];
+  for (const line of lines) {
+    const m = OBJECTIVE_LINE_RE.exec(line);
+    if (!m) {
+      errors.push(`"${line}" is not a well-formed objective line — expected \`O<n>. <sentence>\`, e.g. \`O1. …\`.`);
+      continue;
+    }
+    const n = m[1];
+    const text = m[2].trim();
+    if (text.length === 0) {
+      errors.push(`O${n} has no sentence — every objective is one observable sentence.`);
+      continue;
+    }
+    if (hasBacktickedPath(text) && wordCount(stripObjectiveBackticks(text)) < MIN_WORDS_OUTSIDE_BACKTICKS) {
+      errors.push(`O${n} is little more than a file path — an objective states an observable outcome, never a bare path (the Brief Author maps it to files).`);
+      continue;
+    }
+    objectives.push({ id: `O${n}`, text });
+  }
+  for (let i = 0;i < objectives.length; i++) {
+    const expected = i + 1;
+    const actual = Number.parseInt(objectives[i].id.slice(1), 10);
+    if (actual !== expected) {
+      errors.push(`numbering is not contiguous from O1 — expected O${expected}, found ${objectives[i].id}.`);
+      break;
+    }
+  }
+  if (errors.length > 0)
+    return { ok: false, errors };
+  return { ok: true, objectives };
+}
+function normalizeText(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+function objectivesVersion(objectives) {
+  const normalized = objectives.map((o) => `${o.id} ${normalizeText(o.text)}`).join(`
+`);
+  return createHash2("sha256").update(normalized).digest("hex");
+}
+function isIssueNotFoundError(err) {
+  const stderr = err?.stderr;
+  const haystack = [
+    err?.message ?? "",
+    typeof stderr === "string" ? stderr : stderr?.toString() ?? ""
+  ].join(`
+`);
+  return /could not resolve to an (?:issue|pull request)|\b404\b|not found/i.test(haystack);
+}
+
+// ../../packages/aeg-core/src/premise-check.ts
+import { createHash as createHash3 } from "node:crypto";
 var ASSERTION_KINDS = new Set(["contains", "absent", "sha256"]);
 function isPremiseHeader(line) {
   const stripped = line.replace(/[*#]/g, "").trim();
@@ -2399,7 +2504,7 @@ function checkPremises(assertions, fileReader) {
     } else if (a.kind === "absent" && content.includes(a.value)) {
       failures.push(`premise-check: ${a.path} now contains "${a.value}", but the brief pinned it absent — the premise has moved; re-dig before proceeding.`);
     } else if (a.kind === "sha256") {
-      const actual = createHash2("sha256").update(content).digest("hex");
+      const actual = createHash3("sha256").update(content).digest("hex");
       if (actual !== a.value.toLowerCase()) {
         failures.push(`premise-check: ${a.path} sha256 mismatch (brief pinned ${a.value}, file is now ${actual}) — the file changed since this brief was authored; re-dig before proceeding.`);
       }
@@ -2760,8 +2865,55 @@ function checkDefeatCases(prBody) {
     ]
   };
 }
+var PART_CITATION_RE = /Part\s+\d+\s*\(([^)]*)\)/gi;
+var OBJECTIVE_REF_RE = /O(\d+)/g;
+function citedObjectiveIds(section6) {
+  const ids = new Set;
+  for (const m of section6.matchAll(PART_CITATION_RE)) {
+    for (const r of m[1].matchAll(OBJECTIVE_REF_RE))
+      ids.add(Number.parseInt(r[1], 10));
+  }
+  return ids;
+}
+function checkObjectivesCopy(prBody, issueObjectives) {
+  const parsed = objectivesOf(prBody);
+  if (!parsed.ok) {
+    return { status: "fail", errors: parsed.errors.map((e) => `brief-validation objectives copy: ${e}`) };
+  }
+  if (objectivesVersion(parsed.objectives) !== objectivesVersion(issueObjectives)) {
+    return {
+      status: "fail",
+      errors: [
+        "brief-validation objectives copy: the brief's `## Objectives` section does not match the Issue's — copy the Issue's `## Objectives` section (aeg-root/roles/developer.md)."
+      ]
+    };
+  }
+  return { status: "pass", errors: [] };
+}
+function checkObjectivesCoverage(prBody) {
+  const parsed = objectivesOf(prBody);
+  if (!parsed.ok) {
+    return { status: "fail", errors: parsed.errors.map((e) => `brief-validation objectives coverage: ${e}`) };
+  }
+  const declaredIds = new Set(parsed.objectives.map((o) => Number.parseInt(o.id.slice(1), 10)));
+  const section6 = extractNumberedSection(prBody, 6) ?? "";
+  const cited = citedObjectiveIds(section6);
+  const maxDeclared = Math.max(...declaredIds, 0);
+  const errors = [];
+  for (const id of declaredIds) {
+    if (!cited.has(id)) {
+      errors.push(`brief-validation objectives coverage: O${id} is not cited by any Part in §6 — every objective must be cited by at least one Part.`);
+    }
+  }
+  for (const id of cited) {
+    if (!declaredIds.has(id)) {
+      errors.push(`brief-validation objectives coverage: a Part in §6 cites O${id}, but the Objectives section ends at O${maxDeclared}.`);
+    }
+  }
+  return errors.length === 0 ? { status: "pass", errors: [] } : { status: "fail", errors };
+}
 function checkBriefSections(prBody, readTier, options = {}) {
-  const { requireClosesN = true, consumersOf = () => [] } = options;
+  const { requireClosesN = true, consumersOf = () => [], issueObjectives } = options;
   const results = [
     checkTierField(prBody, readTier),
     checkTestPlan(prBody),
@@ -2779,6 +2931,7 @@ function checkBriefSections(prBody, readTier, options = {}) {
     checkCommandsCarryOutput(prBody),
     checkConsumerTests(prBody, consumersOf),
     checkDefeatCases(prBody),
+    ...issueObjectives !== undefined ? [checkObjectivesCopy(prBody, issueObjectives), checkObjectivesCoverage(prBody)] : [],
     ...requireClosesN ? [checkClosesN(prBody)] : []
   ];
   return { errors: results.flatMap((r) => r.errors) };
@@ -2977,14 +3130,14 @@ function checkSectionDensity(prBody, heading) {
     ]
   };
 }
-function checkSummaryDensity(prBody) {
-  return checkSectionDensity(prBody, "Summary");
+function checkDecisionsDensity(prBody) {
+  return checkSectionDensity(prBody, "Decisions");
 }
 function checkScopeDensity(prBody) {
   return checkSectionDensity(prBody, "Scope");
 }
 function checkPrReportDensity(prBody) {
-  const results = [checkSummaryDensity(prBody), checkScopeDensity(prBody)];
+  const results = [checkDecisionsDensity(prBody), checkScopeDensity(prBody)];
   return { errors: results.flatMap((r) => r.errors) };
 }
 // ../../packages/aeg-core/src/issue-validation.ts
@@ -3016,6 +3169,15 @@ function checkIssueRationale(body) {
   }
   return { status: errors.length > 0 ? "fail" : "pass", errors };
 }
+var OBJECTIVES_SINCE_ISSUE = 404;
+function checkIssueObjectives(body, issueNumber) {
+  if (issueNumber !== null && issueNumber < OBJECTIVES_SINCE_ISSUE)
+    return { status: "pass", errors: [] };
+  const result = objectivesOf(body);
+  if (result.ok)
+    return { status: "pass", errors: [] };
+  return { status: "fail", errors: result.errors.map((e) => `issue-validation objectives: ${e}`) };
+}
 function isTaskIssueLabelSet(labels) {
   return hasLabel("tranche", labels);
 }
@@ -3277,7 +3439,8 @@ function checkR1(issuesBySlug, grandfatheredIssues, registeredNames = []) {
         continue;
       const errors = [
         ...checkIssueRationale(issue.body).errors,
-        ...checkProjectsRegistered(issue.body, issue.labels, registeredNames).errors
+        ...checkProjectsRegistered(issue.body, issue.labels, registeredNames).errors,
+        ...checkIssueObjectives(issue.body, issue.number).errors
       ];
       if (errors.length === 0)
         continue;
@@ -3392,6 +3555,27 @@ function checkClosesN2(branch, prBody, trancheFiles, taskIssueRefs) {
   }
   return { ok: true, expectedIssue };
 }
+// ../../packages/aeg-core/src/archive-task.ts
+function closesRefs(text) {
+  return [...new Set([...text.matchAll(/Closes #(\d+)/gi)].map((m) => Number(m[1])))];
+}
+function extractIssue(body) {
+  const stripped = stripCode(body);
+  const bodyNums = closesRefs(stripped);
+  const anchored = anchoredRegion(stripped, "CLOSES");
+  if (anchored !== null) {
+    const anchorNums = closesRefs(anchored);
+    if (anchorNums.length === 0)
+      return { issue: null, extraIssues: bodyNums, outsideHeader: false };
+    const issue2 = anchorNums[0];
+    return { issue: issue2, extraIssues: bodyNums.filter((n) => n !== issue2), outsideHeader: false };
+  }
+  const headerNums = closesRefs(headerRegion(stripped));
+  if (bodyNums.length === 0)
+    return { issue: null, extraIssues: [], outsideHeader: false };
+  const issue = headerNums.length > 0 ? headerNums[0] : bodyNums[0];
+  return { issue, extraIssues: bodyNums.filter((n) => n !== issue), outsideHeader: headerNums.length === 0 };
+}
 // ../../packages/aeg-core/src/review-gate.ts
 function isBoundToHead(extraction, headSha) {
   if (!extraction.headSha)
@@ -3410,6 +3594,11 @@ function isBoundByPatchIdentity(extraction, headSha, patchIdOf) {
 function isBoundToPatch(extraction, headSha, patchIdOf) {
   return isBoundToHead(extraction, headSha) || isBoundByPatchIdentity(extraction, headSha, patchIdOf);
 }
+function isBoundToObjectives(extraction, currentVersion) {
+  if (currentVersion === null)
+    return true;
+  return extraction.objectivesVersion === currentVersion;
+}
 function checkReviewGate(input) {
   const principalAllowlist = input.principalAllowlist ?? PRINCIPAL_ALLOWLIST;
   const waived = isWaiverLabelActorVerified({
@@ -3436,7 +3625,9 @@ function checkReviewGate(input) {
   const securityClean = security.value === "PASS";
   const codeReviewBound = isBoundToPatch(codeReview, input.headSha, input.patchIdOf);
   const securityBound = isBoundToPatch(security, input.headSha, input.patchIdOf);
-  if (codeReviewClean && codeReviewBound && securityClean && securityBound && mechanicalChecksClean) {
+  const codeReviewObjectivesBound = isBoundToObjectives(codeReview, input.objectivesVersion);
+  const securityObjectivesBound = isBoundToObjectives(security, input.objectivesVersion);
+  if (codeReviewClean && codeReviewBound && codeReviewObjectivesBound && securityClean && securityBound && securityObjectivesBound && mechanicalChecksClean) {
     return {
       verdict: "pass",
       reason: `code-reviewer verdict is a clean APPROVE and security-review verdict is a clean PASS, both covering head ${input.headSha}, and every reported mechanical check is green.`,
@@ -3448,11 +3639,15 @@ function checkReviewGate(input) {
     problems.push(`code-reviewer verdict is not a clean APPROVE (found: ${codeReview.value})`);
   } else if (!codeReviewBound) {
     problems.push(`the newest code-review verdict covers ${codeReview.headSha ?? "no recorded commit"}, head is ${input.headSha}`);
+  } else if (!codeReviewObjectivesBound) {
+    problems.push(`the newest code-review verdict was cast against objectives version ${codeReview.objectivesVersion ?? "none"}, the Issue's list is now ${input.objectivesVersion}`);
   }
   if (!securityClean) {
     problems.push(`security-review verdict is not a clean PASS (found: ${security.value})`);
   } else if (!securityBound) {
     problems.push(`the newest security-review verdict covers ${security.headSha ?? "no recorded commit"}, head is ${input.headSha}`);
+  } else if (!securityObjectivesBound) {
+    problems.push(`the newest security-review verdict was cast against objectives version ${security.objectivesVersion ?? "none"}, the Issue's list is now ${input.objectivesVersion}`);
   }
   if (!mechanicalChecksClean) {
     problems.push(reportedMechanicalChecks.length === 0 ? "no mechanical checks have reported for this head yet" : `mechanical check(s) not green: ${reportedMechanicalChecks.filter((c) => c.bucket !== "pass").map((c) => `${c.name} (${c.bucket})`).join(", ")}`);
@@ -3688,55 +3883,20 @@ function checkG6(rows, registeredCheckNames) {
   }
   return { check: "G6", status: findings.length > 0 ? "fail" : "pass", findings };
 }
-// ../../packages/aeg-core/src/dead-branch-push-guard.ts
-function checkDeadBranchPush(input) {
-  const { branch, prState, prNumber } = input;
-  if (prState === "MERGED") {
-    return {
-      verdict: "refuse",
-      reason: `Branch \`${branch}\` already has a MERGED PR (#${prNumber}) — this branch's work is done. Push a new task branch instead of pushing onto an already-resolved one.`
-    };
-  }
-  if (prState === "CLOSED") {
-    return {
-      verdict: "refuse",
-      reason: `Branch \`${branch}\` has a CLOSED PR (#${prNumber}) that was never merged — pushing here would resurrect abandoned/rejected work. Open a new task branch instead.`
-    };
-  }
-  if (prState === "OPEN") {
-    return {
-      verdict: "allow",
-      reason: `Branch \`${branch}\` has an OPEN PR (#${prNumber}) — pushing more commits to it is normal.`
-    };
-  }
-  if (prState === "NONE") {
-    return {
-      verdict: "allow",
-      reason: `Branch \`${branch}\` has no PR yet — a brand-new task branch legitimately has none.`
-    };
-  }
-  return {
-    verdict: "allow",
-    reason: `Could not determine \`${branch}\`'s PR state (forge unreachable) — failing open rather than blocking the push on a transient issue.`
-  };
-}
-// ../../packages/aeg-core/src/baseline-capture.ts
-function captureBaseline(counts, capturedAt) {
-  return counts.map((c) => ({ tool: c.tool, findingCount: c.findingCount, capturedAt }));
+// ../../packages/aeg-core/src/reader-resolvable-prose.ts
+var PRODUCT_SLUG_SCOPE = [
+  "apps/cli/src",
+  ".github/workflows",
+  ".vinaya",
+  "apps/cli/README.md",
+  "packages/sources/README.md"
+];
+function isUnderOrEqual(path, prefix) {
+  return path === prefix || path.startsWith(`${prefix}/`);
 }
-function compareToBaseline(current, baseline) {
-  const perTool = current.map((c) => {
-    const baselineEntry = baseline.find((b) => b.tool === c.tool);
-    const baselineCount = baselineEntry ? baselineEntry.findingCount : c.findingCount;
-    return { tool: c.tool, baseline: baselineCount, current: c.findingCount, delta: c.findingCount - baselineCount };
-  });
-  return {
-    withinBudget: perTool.every((t) => t.delta <= 0),
-    delta: perTool.reduce((sum, t) => sum + t.delta, 0),
-    perTool
-  };
+function isProductScopeFile(path) {
+  return PRODUCT_SLUG_SCOPE.some((prefix) => isUnderOrEqual(path, prefix));
 }
-// ../../packages/aeg-core/src/reader-resolvable-prose.ts
 var SHIPS_PREFIX = "aeg-root/";
 function shipsArchivePrefix(shipsPrefix) {
   return `${shipsPrefix}tranches/completed/`;
@@ -3756,6 +3916,8 @@ function classifyProseFile(path, readerFacingPrefix, readerFacingSuffix, shipsPr
   }
   if (isSpecFile2(path) || isClaudeMdFile(path))
     return "internal";
+  if (isProductScopeFile(path))
+    return "product";
   return null;
 }
 var SWEPT_CLASSES = new Set(["ships", "reader-facing"]);
@@ -3768,6 +3930,9 @@ function stripNonProse(path, content) {
   }
   return content;
 }
+function stripNonProseForProduct(path, content) {
+  return path.endsWith(".md") ? stripNonProse(path, content) : content;
+}
 function lineAt(content, index) {
   let line = 1;
   for (let i = 0;i < index; i++) {
@@ -3792,12 +3957,19 @@ function checkUnresolvableReferences(files, readerFacingPrefix, readerFacingSuff
     { pattern: TRANCHE_SLUG_VN_PATTERN, what: "an internal tranche slug" },
     ...legacyPattern ? [{ pattern: legacyPattern, what: "an internal tranche slug", group: 2 }] : []
   ];
+  const productPatterns = [
+    { pattern: TRANCHE_SLUG_VN_PATTERN, what: "an internal tranche slug in product code" }
+  ];
   for (const file of files) {
     const cls = classifyProseFile(file.path, readerFacingPrefix, readerFacingSuffix, shipsPrefix);
-    if (!cls || !SWEPT_CLASSES.has(cls))
+    if (!cls || cls === "internal")
       continue;
-    const scrubbed = stripNonProse(file.path, file.content);
-    for (const { pattern, what, group } of patterns) {
+    if (cls !== "product" && !SWEPT_CLASSES.has(cls))
+      continue;
+    const blocking = cls === "product";
+    const scrubbed = blocking ? stripNonProseForProduct(file.path, file.content) : stripNonProse(file.path, file.content);
+    const patternsToRun = blocking ? productPatterns : patterns;
+    for (const { pattern, what, group } of patternsToRun) {
       pattern.lastIndex = 0;
       let match = pattern.exec(scrubbed);
       while (match !== null) {
@@ -3805,7 +3977,8 @@ function checkUnresolvableReferences(files, readerFacingPrefix, readerFacingSuff
         findings.push({
           file: file.path,
           line: lineAt(scrubbed, match.index),
-          message: `references ${what} ("${cited}") a reader outside this repo's tracker cannot resolve`
+          message: `references ${what} ("${cited}") a reader outside this repo's tracker cannot resolve`,
+          blocking
         });
         match = pattern.exec(scrubbed);
       }
@@ -3855,7 +4028,8 @@ function checkUndefinedVocabulary(files, glossaryTerms, readerFacingPrefix, read
       findings.push({
         file: file.path,
         line,
-        message: `uses coined term "${term}" without defining it inline or linking the glossary`
+        message: `uses coined term "${term}" without defining it inline or linking the glossary`,
+        blocking: false
       });
     }
   }
@@ -3878,6 +4052,7 @@ function parseGlossaryTerms(glossaryContent) {
   }
   return terms;
 }
+
 // ../../packages/aeg-core/src/quoted-command.ts
 var QUOTED_COMMAND_SHIPS_PREFIX = "aeg-root/";
 var QUOTED_COMMAND_SWEPT_CLASSES = new Set(["ships", "reader-facing"]);
@@ -3972,6 +4147,54 @@ function evaluateCitedQuotes(citedQuotes, citedFileContents) {
   }
   return findings;
 }
+// ../../packages/aeg-core/src/dead-branch-push-guard.ts
+function checkDeadBranchPush(input) {
+  const { branch, prState, prNumber } = input;
+  if (prState === "MERGED") {
+    return {
+      verdict: "refuse",
+      reason: `Branch \`${branch}\` already has a MERGED PR (#${prNumber}) — this branch's work is done. Push a new task branch instead of pushing onto an already-resolved one.`
+    };
+  }
+  if (prState === "CLOSED") {
+    return {
+      verdict: "refuse",
+      reason: `Branch \`${branch}\` has a CLOSED PR (#${prNumber}) that was never merged — pushing here would resurrect abandoned/rejected work. Open a new task branch instead.`
+    };
+  }
+  if (prState === "OPEN") {
+    return {
+      verdict: "allow",
+      reason: `Branch \`${branch}\` has an OPEN PR (#${prNumber}) — pushing more commits to it is normal.`
+    };
+  }
+  if (prState === "NONE") {
+    return {
+      verdict: "allow",
+      reason: `Branch \`${branch}\` has no PR yet — a brand-new task branch legitimately has none.`
+    };
+  }
+  return {
+    verdict: "allow",
+    reason: `Could not determine \`${branch}\`'s PR state (forge unreachable) — failing open rather than blocking the push on a transient issue.`
+  };
+}
+// ../../packages/aeg-core/src/baseline-capture.ts
+function captureBaseline(counts, capturedAt) {
+  return counts.map((c) => ({ tool: c.tool, findingCount: c.findingCount, capturedAt }));
+}
+function compareToBaseline(current, baseline) {
+  const perTool = current.map((c) => {
+    const baselineEntry = baseline.find((b) => b.tool === c.tool);
+    const baselineCount = baselineEntry ? baselineEntry.findingCount : c.findingCount;
+    return { tool: c.tool, baseline: baselineCount, current: c.findingCount, delta: c.findingCount - baselineCount };
+  });
+  return {
+    withinBudget: perTool.every((t) => t.delta <= 0),
+    delta: perTool.reduce((sum, t) => sum + t.delta, 0),
+    perTool
+  };
+}
 // ../../packages/aeg-core/src/retired-vocabulary.ts
 var RETIRED_PATTERNS = [
   String.raw`\bD-[0-9]{3}\b`,
@@ -4441,6 +4664,222 @@ function findWorkspaceEscapes(files, knownPaths, workspaceDirs = DEFAULT_WORKSPA
   }
   return findings;
 }
+// ../../packages/aeg-core/src/log/schema.ts
+import { z } from "zod";
+var ROLE_VALUES = [
+  "planner",
+  "brief-author",
+  "developer",
+  "code-reviewer",
+  "security",
+  "principal",
+  "archivist",
+  "architect"
+];
+var RoleSchema = z.enum(ROLE_VALUES);
+var HOST_VALUES = ["hook", "ci", "cli", "loop"];
+var HostSchema = z.enum(HOST_VALUES);
+var RUN_ID_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
+var HeaderMetaSchema = z.object({
+  schema: z.literal(1),
+  ts: z.string(),
+  run_id: z.string().regex(RUN_ID_PATTERN),
+  seq: z.number().int().nonnegative(),
+  repo: z.string().nullable(),
+  vinaya: z.string(),
+  doctrine: z.string(),
+  host: HostSchema,
+  machine: z.string()
+}).strict();
+var SubjectSchema = z.object({
+  issue: z.number().int().nullable(),
+  pr: z.number().int().optional(),
+  sha: z.string().optional(),
+  role: z.union([RoleSchema, z.literal("unattributed")]),
+  round: z.number().int().optional(),
+  objectives_version: z.string().optional()
+}).strict();
+var HeaderSchema = z.object({
+  meta: HeaderMetaSchema,
+  subject: SubjectSchema
+}).strict();
+var envelopeTail = {
+  duration_ms: z.number().nonnegative().optional(),
+  payload: z.object({}).strict()
+};
+var DispatchOutcomeSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("pr_opened"), pr: z.number().int(), head: z.string() }).strict(),
+  z.object({
+    type: z.literal("round_pushed"),
+    pr: z.number().int(),
+    head: z.string(),
+    comment_id: z.number().int()
+  }).strict(),
+  z.object({
+    type: z.literal("verdict"),
+    verdict: z.enum(["APPROVE", "REQUEST CHANGES", "PASS", "FAIL"]),
+    head: z.string(),
+    comment_id: z.number().int(),
+    objectives: z.array(z.object({ id: z.string(), met: z.boolean() }).strict()),
+    findings: z.array(z.object({ id: z.string(), severity: z.string(), state: z.string().optional() }).strict())
+  }).strict(),
+  z.object({
+    type: z.literal("escalation"),
+    class: z.enum(["authority", "strategy", "product"]),
+    comment_id: z.number().int()
+  }).strict(),
+  z.object({ type: z.literal("brief"), comment_id: z.number().int(), hash: z.string() }).strict(),
+  z.object({ type: z.literal("plan"), issues: z.array(z.number().int()) }).strict(),
+  z.object({ type: z.literal("archive"), provenance_comment_id: z.number().int() }).strict()
+]);
+var dispatchShared = {
+  meta: HeaderMetaSchema,
+  subject: SubjectSchema,
+  kind: z.literal("dispatch"),
+  ...envelopeTail,
+  target_role: RoleSchema,
+  model: z.string(),
+  round: z.number().int().optional(),
+  effect_id: z.string()
+};
+var DispatchEventSchema = z.discriminatedUnion("event", [
+  z.object({ ...dispatchShared, event: z.literal("dispatched"), prompt_hash: z.string() }).strict(),
+  z.object({
+    ...dispatchShared,
+    event: z.literal("outcome_received"),
+    outcome: DispatchOutcomeSchema,
+    usage: z.object({ input: z.number().nonnegative(), output: z.number().nonnegative() }).strict().nullable()
+  }).strict(),
+  z.object({
+    ...dispatchShared,
+    event: z.literal("dispatch_failed"),
+    reason: z.enum(["timeout", "crash", "refused", "unattributed_write"])
+  }).strict()
+]);
+var loopShared = {
+  meta: HeaderMetaSchema,
+  subject: SubjectSchema,
+  kind: z.literal("dev_review_loop"),
+  ...envelopeTail,
+  loop_id: z.string()
+};
+var DevReviewLoopEventSchema = z.discriminatedUnion("event", [
+  z.object({
+    ...loopShared,
+    event: z.literal("loop_started"),
+    task: z.number().int(),
+    policy: z.object({
+      max_rounds: z.number().int().nonnegative(),
+      reviewers: z.array(RoleSchema),
+      models: z.record(RoleSchema, z.string())
+    }).strict()
+  }).strict(),
+  z.object({ ...loopShared, event: z.literal("round_started"), round: z.number().int(), base_head: z.string() }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("gate_result_read"),
+    round: z.number().int(),
+    head: z.string(),
+    green: z.boolean()
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("verdicts_read"),
+    round: z.number().int(),
+    head: z.string(),
+    all_approve: z.boolean(),
+    blockers: z.number().int().nonnegative()
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("findings_compared"),
+    round: z.number().int(),
+    open: z.array(z.string()),
+    resolved: z.array(z.string()),
+    new: z.array(z.string()),
+    recurring: z.array(z.string())
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("stop_condition_met"),
+    round: z.number().int(),
+    condition: z.enum([
+      "green",
+      "max_rounds",
+      "no_progress",
+      "escalated",
+      "principal_stop",
+      "confidence",
+      "reappearance"
+    ])
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("paused"),
+    round: z.number().int(),
+    reason: z.enum(["escalation", "principal_item", "refreeze_needed"])
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("resumed"),
+    round: z.number().int(),
+    by: z.literal("principal")
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("round_ended"),
+    round: z.number().int(),
+    base_head: z.string(),
+    head: z.string(),
+    files_changed: z.number().int().nonnegative(),
+    insertions: z.number().int().nonnegative(),
+    deletions: z.number().int().nonnegative(),
+    wall_ms: z.number().nonnegative(),
+    outcome: z.enum(["green", "changes_requested", "escalated"])
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("journal_finalized"),
+    rounds: z.number().int().nonnegative(),
+    total_wall_ms: z.number().nonnegative(),
+    time_to_green_ms: z.number().nonnegative().nullable(),
+    files_changed_total: z.number().int().nonnegative(),
+    final_head: z.string(),
+    result: z.enum(["merged_ready", "stopped"])
+  }).strict()
+]);
+var ForgeOpSchema = z.enum([
+  "pr.create",
+  "pr.comment",
+  "pr.body.replace",
+  "pr.refreeze",
+  "issue.create",
+  "issue.edit",
+  "issue.comment",
+  "milestone.create",
+  "milestone.edit",
+  "milestone.close",
+  "label.add",
+  "label.remove"
+]);
+var ForgeWriteTargetSchema = z.object({
+  issue: z.number().int().optional(),
+  pr: z.number().int().optional()
+}).strict();
+var forgeWriteShared = {
+  meta: HeaderMetaSchema,
+  subject: SubjectSchema,
+  kind: z.literal("forge_write"),
+  ...envelopeTail,
+  op: ForgeOpSchema,
+  target: ForgeWriteTargetSchema
+};
+var ForgeWriteEventSchema = z.discriminatedUnion("event", [
+  z.object({ ...forgeWriteShared, event: z.literal("validated") }).strict(),
+  z.object({ ...forgeWriteShared, event: z.literal("refused"), reason: z.string() }).strict(),
+  z.object({ ...forgeWriteShared, event: z.literal("written"), comment_ids: z.array(z.string()) }).strict()
+]);
+var LogEventSchema = z.union([DispatchEventSchema, DevReviewLoopEventSchema, ForgeWriteEventSchema]);
 // ../../packages/sources/src/commands.ts
 var COMMANDS = [
   {
@@ -4554,11 +4993,24 @@ var COMMANDS = [
       { flag: "--out <path>", description: "Write the rendered brief to a file instead of stdout" }
     ],
     details: [
-      "Reads the task Issue (`vinaya/tranche:<tranche>`-labeled, id `<n>`) and the tree, and fills every section a program can derive: the header `Project:`/`Tier:`/`Closes #N`, the Step 0 worktree line, the dispatch-gate status as the pre-flight line, §4's file list (with consumer packages and a `sha256` premise pin per file), §7 from the `.vinaya/doc-owners` derivation, and every remaining section from the Issue's eight-field Planner rationale. Refuses — naming the missing fact — when a derived section cannot be derived: no Issue, the dispatch gate not clear, or a `--surfaces` glob matching no tracked file.",
+      "Reads the task Issue (`vinaya/tranche:<tranche>`-labeled, id `<n>`) and the tree, and fills every section a program can derive: the header `Project:`/`Tier:`/`Closes #N`, the Step 0 worktree line, the dispatch-gate status as the pre-flight line, §4's file list (with consumer packages and a `sha256` premise pin per file, and Out of surface from the Issue's own `## Surface` `out:` list), §6 from the Issue's `## Parts`, §7 from the `.vinaya/doc-owners` derivation, §9 from the Issue's `## Test plan`, §10 from the Issue's `## Stop conditions` plus the rationale's Stop-and-escalate field, and every remaining section from the Issue's eight-field Planner rationale. Refuses — naming the missing section — when it cannot be derived: no Issue, the dispatch gate not clear, a `--surfaces` glob matching no tracked file, or the Issue missing/malformed `## Surface`/`## Parts`/`## Test plan`/`## Stop conditions` — never a bracketed placeholder.",
       "Never writes under `aeg-root/` or to the Issue — a brief is pasted to the Developer, never committed. Reads `aeg-root/templates/brief-template.md` at run time for its one fixed sentence and the standing autonomy clause; every other byte is generated from the forge/tree facts."
     ],
     status: "shipped"
   },
+  {
+    name: "task dispatch",
+    description: "Render, pin, and post the brief on the Issue as the frozen original; start the developer",
+    flags: [
+      { flag: "--agent <claude|codex|gemini>", description: "Start the developer through dispatchRole once posted" }
+    ],
+    details: [
+      "Renders the brief from the Issue and the tree (the same assembly `brief render` uses) and posts it once as an Issue comment whose first line is `<!-- aeg:brief:v1 -->` and whose second line is `Brief hash: <sha256>` — the hash covers only the body below those two lines, so any reader recomputes it. Refuses outright, naming the existing comment's URL, when a `v1` comment already exists on the Issue — the brief is frozen by design, never overwritten or silently reissued.",
+      "With `--agent`, starts the Developer through `dispatchRole` when `apps/cli/src/lib/dispatch.ts` exports it; otherwise prints the rendered brief and the manual dispatch instruction and exits `0` — a soft dependency, never a hard block.",
+      "Principal-only, with or without `--agent`: refuses before any render, forge read, or post when the authenticated `gh` identity is not on the Principal allowlist (or cannot be resolved at all) — dispatching is the `todo → in-flight` transition, not a general-purpose comment poster."
+    ],
+    status: "shipped"
+  },
   {
     name: "pr create",
     description: "Open a pull request after full brief-schema validation",
@@ -4611,6 +5063,19 @@ var COMMANDS = [
     ],
     status: "shipped"
   },
+  {
+    name: "pr rule",
+    description: "Post a Principal ruling on a PR, marked and versioned — never mistaken for a review verdict",
+    flags: [
+      { flag: "--file", description: "Path to the ruling file to post as a PR comment" },
+      { flag: "--json", description: "Enveloped JSON output (schema: 1)" }
+    ],
+    details: [
+      "Refuses before posting when the file's first line reads as an escalation (`ESCALATE:`), or when the file carries verdict grammar anywhere `extractCodeReviewVerdict`/`extractSecurityReviewVerdict` would treat as a candidate — a `VERDICT:` line past the extractor's own first-five-line window still counts, since the whole-body candidate test is what disqualifies the file, not merely a clean read.",
+      "Marker numbers (`<!-- aeg:principal:ruling:<pr>-<k> -->`) are counted on the forge at post time from `gh pr view --json comments`, never derived from a local file — two rulings racing to the same number are a known, undocumented-lock case."
+    ],
+    status: "shipped"
+  },
   {
     name: "pr verify-evidence",
     description: "Prove a pull request's AEG:EVIDENCE region was machine-generated — regenerate it and compare",
@@ -4652,6 +5117,44 @@ var COMMANDS = [
     ],
     status: "shipped"
   },
+  {
+    name: "issue objectives edit",
+    description: "Rewrite a task Issue's `## Objectives` section by command — versioned, findable on the forge",
+    flags: [
+      { flag: "--add", description: "Append a new objective as `O<max+1>` with the given sentence" },
+      { flag: "--drop", description: "Remove an objective by id (`O<k>`) — never renumbers the survivors" },
+      {
+        flag: "--replace",
+        description: 'Replace an objective\'s sentence in place, keeping its id (`O<k>` "<sentence>")'
+      },
+      { flag: "--reason", description: "Required, non-empty: why this change is being made" },
+      { flag: "--json", description: "Enveloped JSON output (schema: 1)" }
+    ],
+    details: [
+      "Exactly one of `--add`/`--drop`/`--replace` is required. Every edit goes through the same validated `issue edit` write path (`writeValidatedIssueEdit`) as `vinaya issue edit` itself — no second, unvalidated write path.",
+      "A `--drop` that leaves the surviving objectives non-contiguous from `O1` is refused with `objectivesOf`'s own parser message: dropping never renumbers survivors, and task 1's contiguous-from-O1 grammar is the one parser everything else reads, so a live contradiction between the two stops here for a Principal ruling rather than silently renumbering.",
+      "Splices the rendered section back in place (`## Objectives` heading through the next `##` heading, or end of body) — every other byte of the Issue body is untouched. Posts one comment marked `<!-- aeg:objectives:v<k> -->` carrying the previous list, the new list, the reason, and the new `objectivesVersion`; `k` is counted on the forge at post time, never derived from a local file."
+    ],
+    status: "shipped"
+  },
+  {
+    name: "log flush",
+    description: "Post a target Issue or PR's outbox as one or more marked comments, then truncate what the forge confirmed",
+    flags: [
+      { flag: "--issue", description: "Flush this Issue's outbox (`~/.vinaya/outbox/<owner>-<repo>/<n>.ndjson`)" },
+      {
+        flag: "--pr",
+        description: "Flush the Issue named by this PR's `Closes #N` line, posting the comments on the PR"
+      },
+      { flag: "--json", description: "Enveloped JSON output (schema: 1)" }
+    ],
+    details: [
+      "Exactly one of `--issue`/`--pr` is required. `--pr` resolves the Issue from the PR body's `Closes #N` line — the same anchor every gate reads — and refuses with a check error naming the missing line when the body carries none.",
+      "Splits the outbox first at `run_id` boundaries (a maximal run of consecutive lines sharing one `run_id`, never a global group-by, so an interleaved outbox never produces a range spanning a gap), then at `FORGE_COMMENT_MAX_CHARS` (65536) within each run. Each comment opens with `<!-- aeg:log:<run_id>:<seq_from>-<seq_to> -->` on its own line, then one fenced `ndjson` block, one outbox line per line, verbatim. A single line too large to fit alone is refused by name, never split across two comments.",
+      "Logs its own `forge_write` line — `validated` before posting, `written` (with every returned comment id) after the last post succeeds, or `refused` (with gh's error) on any failure — through the same `log()` every other family uses, into the same outbox, before truncating. The outbox is truncated only to the lines confirmed posted; a failed chunk's lines, and anything appended to the outbox during the flush (including the flush's own `validated`/`written`/`refused` line), always survive to ride the next flush."
+    ],
+    status: "shipped"
+  },
   {
     name: "milestone create",
     description: "Create a GitHub Milestone from a validated body",
@@ -4744,6 +5247,10 @@ var COMMANDS = [
         flag: "--findings-file",
         description: "One finding per line: `SEVERITY|file:line|description` (`|`-delimited). A re-review names a prior id in the description as `F<n> <class> <state>:`. Omit for zero findings."
       },
+      {
+        flag: "--objectives-file",
+        description: "One line per objective: `O<n>|MET|<evidence>` or `O<n>|NOT MET|<evidence>` (`|`-delimited; evidence is the rest of the line). Required whenever the closed Issue (or the PR body's own `## Objectives`) has an objectives list to judge; its ids must cover that list exactly, and a re-review must restate every prior objective. Never together with `--escalate`."
+      },
       { flag: "--brief-conformance", description: "code-reviewer only: the BRIEF CONFORMANCE line" },
       { flag: "--spec-conformance", description: "code-reviewer only: the SPEC CONFORMANCE line" },
       { flag: "--scope", description: "code-reviewer only: the SCOPE line" },
@@ -4774,8 +5281,9 @@ var COMMANDS = [
       "`--print-only` runs the exact same render-then-self-check path as a real post, then returns before `gh pr comment` — closes atta-labs/vinaya#184, where the old command silently posted a verdict anyway after a reviewer guessed this flag existed.",
       "Every structural line (`VERDICT:`, `Judged head:`) is rendered from this command's own validated enum/sha inputs — never from a caller-supplied string — so a Reviewer's free-typed prose can no longer produce a shape the merge gate's line-anchored regex fails to see.",
       "The verdict is derived, not typed: a BLOCKER (or CRITICAL/HIGH) finding forces REQUEST_CHANGES/FAIL and its absence forces APPROVE/PASS, before posting anything — an explicit `--verdict` that disagrees is refused naming the derived value. When a same-role verdict comment already exists on the PR, a new findings file must carry every prior id with a state and no non-blocking finding outside the diff since that comment's judged head, or the post is refused.",
-      "Before the post ever reaches the forge, runs the exact `extractCodeReviewVerdict`/`extractSecurityReviewVerdict` functions `checkReviewGate` calls over its own rendered text and refuses (exit 2) unless exactly the intended verdict extracts and the other role extracts none — an escalation requires both to extract none. Both extractors read only a comment's first three lines, which are always this command's own structural lines, so no caller-supplied field can smuggle a line the gate would misread.",
-      "After posting, re-fetches the PR's comments and runs them through the same extractors `checkReviewGate` calls — the same functions, not a second implementation — and exits non-zero naming precisely what failed to re-parse if the post does not come back clean, bound to the resolved head, and free of the other role's verdict. There is no `--skip-verify` escape."
+      "Renders an `OBJECTIVES:` block (one `O<n>: MET | NOT MET — <evidence>` line per objective) after `SPEC CONFORMANCE:`/before `CONFIG SCAN:`, and an `Objectives version:` line at line 5 — resolved from the closed Issue's `## Objectives` list, or the PR body's own section when it closes none. A clean verdict (`APPROVE`/`PASS`) is refused alongside any `NOT MET`; an Issue below the objectives cutover renders neither line at all, matching the merge gate's own skip.",
+      "Before the post ever reaches the forge, runs the exact `extractCodeReviewVerdict`/`extractSecurityReviewVerdict` functions `checkReviewGate` calls over its own rendered text and refuses (exit 2) unless exactly the intended verdict extracts and the other role extracts none — an escalation requires both to extract none. Both extractors read only a comment's first five lines; a code-review or security render's caller-supplied fields never open one of those lines, but an escalation's `--summary` can (pre-cutover, it becomes line 5 unprefixed) — this pre-post re-parse, not the render's construction, is what catches that case before it ever reaches the forge.",
+      "After posting, re-fetches the PR's comments and runs them through the same extractors `checkReviewGate` calls — the same functions, not a second implementation — and exits non-zero naming precisely what failed to re-parse if the post does not come back clean, bound to the resolved head and objectives version, and free of the other role's verdict. There is no `--skip-verify` escape."
     ],
     status: "shipped"
   },
@@ -4944,6 +5452,54 @@ var COMMANDS = [
       'This is the one procedure named in `apps/cli/specs/self-hosting.md`, "How the published version is produced" — publishing itself stays manual and human-triggered; this command only removes the hand-typed four-step recipe.'
     ],
     status: "shipped"
+  },
+  {
+    name: "dispatch",
+    description: "Start a role's headless agent session (claude/codex/gemini) with attribution set on its environment, recording the outcome through the Vinaya Log",
+    flags: [
+      {
+        flag: "--agent",
+        description: "Vendor to start: `claude`, `codex`, or `gemini` (falls back to `dispatch.agent` in config)"
+      },
+      { flag: "--prompt-file", description: "Path to the prompt text sent to the agent (never on argv)" },
+      { flag: "--task", description: "This dispatch's task Issue number — mutually exclusive with `--pr`" },
+      {
+        flag: "--pr",
+        description: "Flush the outbox to this PR's Issue after the dispatch — mutually exclusive with `--task`"
+      },
+      { flag: "--round", description: "Round number, for a dispatch inside a review loop" },
+      {
+        flag: "--resume <id>",
+        description: "Resume the vendor's own session/thread from a prior dispatch's returned `resumeId`, instead of starting a fresh one"
+      },
+      { flag: "--json", description: "Enveloped JSON output (schema: 1)" }
+    ],
+    details: [
+      "Sets `VINAYA_RUN_ID`/`VINAYA_ROLE`/`VINAYA_TASK`/`VINAYA_ROUND` on the child only — never on this process's own environment — and refuses by name, before any spawn attempt, when the named vendor binary is absent from `PATH` or present but not executable.",
+      "Records `dispatched` (with the prompt's sha256), `outcome_received` (duration, the vendor's own usage when its stdout prints a recognizable shape), or `dispatch_failed` (`timeout`, `crash`, or `refused`) through the Vinaya Log's one `dispatch` family writer, `dispatchRole`. A wall-time ceiling (`dispatch.timeoutMs` in config, default one hour) sends `SIGTERM` then, after a grace window, `SIGKILL`.",
+      "When `--task` or `--pr` is given, flushes that outbox via `vinaya log flush` immediately after the child settles — `--task` and `--pr` are mutually exclusive here, matching `log flush`'s own single-target rule. Without either, the dispatch still runs and logs; nothing is flushed, and the lines ride to the next flush.",
+      "A successful dispatch's `DispatchHandle` carries `resumeId` — the vendor's own session/thread identifier (claude/gemini: `session_id`; codex: `thread_id`), parsed from its stdout, `null` on any failure. Passing that value as `--resume <id>` on a later call swaps in that vendor's own resume invocation (`claude -p -r <id> ...`; `codex exec resume <id> ...`; `gemini ... --resume <id> ...`) in place of its first-dispatch args."
+    ],
+    status: "shipped"
+  },
+  {
+    name: "dev-review-loop",
+    description: "Dispatch the developer, run review rounds against the forge, resume the same developer session every round, and hold every verdict until the policy says publish",
+    flags: [
+      { flag: "--task <n>", description: "This task's Issue number — its frozen `aeg:brief:v1` comment is the brief" },
+      {
+        flag: "--agent <claude|codex|gemini>",
+        description: "Vendor for every dispatch this loop makes (falls back to `dispatch.agent` in config)"
+      },
+      { flag: "--json", description: "Enveloped JSON output (schema: 1)" }
+    ],
+    details: [
+      "Dispatches the developer through `dispatchRole` with the brief read from the Issue, waits for the PR it opens, then runs `assessRound` (`@attalabs/aeg-core`) — the entire policy — against observations this command reads from the forge: the head via `git ls-remote` only (never `gh pr view headRefOid`, which can lag a push), CI conclusion via the check-runs API (never run locally), and ruling comments matching `<!-- aeg:principal:ruling:<pr>-<k> -->`.",
+      "Nothing is posted to the PR before the policy decides `publish`: each round's reviewer and security verdicts are dispatched fresh (never a resumed session) through `dispatchRole`, rendered through `review post`'s own render functions, and written to a local file under the outbox — never `gh pr comment`/`gh pr review`. Posting the held verdicts is a separate, later task.",
+      "The developer's session is resumed every round via `dispatchRole`'s `resumeId` — never a fresh session — for every vendor; a round whose resume fails for a vendor that resumed successfully the round before stops the loop rather than silently falling back to a fresh developer session.",
+      "Every dispatch and round transition is a log line through the Vinaya Log, flushed to the forge at each round boundary."
+    ],
+    status: "shipped"
   }
 ];
 // ../../packages/sources/src/forge-adapter.ts
@@ -4955,10 +5511,10 @@ function createForgeSource(config) {
   };
 }
 // ../../packages/sources/src/select-source.ts
-import { z } from "zod";
-var StateSourceConfigSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("forge"), owner: z.string(), repo: z.string() }),
-  z.object({ kind: z.literal("file"), root: z.string().optional() })
+import { z as z2 } from "zod";
+var StateSourceConfigSchema = z2.discriminatedUnion("kind", [
+  z2.object({ kind: z2.literal("forge"), owner: z2.string(), repo: z2.string() }),
+  z2.object({ kind: z2.literal("file"), root: z2.string().optional() })
 ]);
 // src/checks/contract.ts
 var CHECK_SCHEMA_VERSION = 1;
@@ -4972,27 +5528,27 @@ import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync as readFileSync2, realpathSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/lib/agent-vendors.ts
 var AGENT_VENDORS = ["skills", "claude", "gemini"];
 
 // src/lib/config.ts
-var EnvEntrySchema = z2.union([
-  z2.literal(true),
-  z2.object({ optional: z2.literal(true) }),
-  z2.object({ anyOf: z2.array(z2.string()).min(2) }),
-  z2.string()
+var EnvEntrySchema = z3.union([
+  z3.literal(true),
+  z3.object({ optional: z3.literal(true) }),
+  z3.object({ anyOf: z3.array(z3.string()).min(2) }),
+  z3.string()
 ]);
-var CheckEntrySchema = z2.object({
-  run: z2.string(),
-  scope: z2.enum(["diff", "full"]),
-  include: z2.array(z2.string()).optional(),
-  args: z2.array(z2.string()).optional(),
-  timeoutMs: z2.number().optional(),
-  env: z2.record(z2.string(), EnvEntrySchema).optional(),
-  requiresOpenPr: z2.boolean().optional(),
-  ownWorkflow: z2.boolean().optional()
+var CheckEntrySchema = z3.object({
+  run: z3.string(),
+  scope: z3.enum(["diff", "full"]),
+  include: z3.array(z3.string()).optional(),
+  args: z3.array(z3.string()).optional(),
+  timeoutMs: z3.number().optional(),
+  env: z3.record(z3.string(), EnvEntrySchema).optional(),
+  requiresOpenPr: z3.boolean().optional(),
+  ownWorkflow: z3.boolean().optional()
 }).superRefine((entry2, ctx) => {
   if (!entry2.env)
     return;
@@ -5002,22 +5558,22 @@ var CheckEntrySchema = z2.object({
     const members = value.anyOf;
     if (new Set(members).size !== members.length) {
       ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
+        code: z3.ZodIssueCode.custom,
         message: `env.${key}.anyOf has duplicate members`,
         path: ["env", key, "anyOf"]
       });
     }
     if (!members.includes(key)) {
       ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
+        code: z3.ZodIssueCode.custom,
         message: `env.${key}.anyOf must include "${key}" itself as a member`,
         path: ["env", key, "anyOf"]
       });
     }
   }
 });
-var RoleEntrySchema = z2.object({
-  contract: z2.string().refine((p) => p.includes("/"), {
+var RoleEntrySchema = z3.object({
+  contract: z3.string().refine((p) => p.includes("/"), {
     message: 'must be a path (contain at least one "/"), not a bare filename'
   })
 });
@@ -5036,19 +5592,21 @@ var BRIEF_BUILTINS = [
   "closesN",
   "premiseCoverage",
   "issueRationale",
+  "objectives",
+  "briefSections",
   "milestoneShape"
 ];
-var BriefSectionSchema = z2.union([
-  z2.object({ builtin: z2.enum(BRIEF_BUILTINS) }),
-  z2.object({ heading: z2.string().min(1), name: z2.string().optional() }),
-  z2.object({ field: z2.string().min(1), name: z2.string().optional() }),
-  z2.object({ phrase: z2.string().min(1), name: z2.string().optional() })
+var BriefSectionSchema = z3.union([
+  z3.object({ builtin: z3.enum(BRIEF_BUILTINS) }),
+  z3.object({ heading: z3.string().min(1), name: z3.string().optional() }),
+  z3.object({ field: z3.string().min(1), name: z3.string().optional() }),
+  z3.object({ phrase: z3.string().min(1), name: z3.string().optional() })
 ]);
-var BriefSchemaSchema = z2.object({
-  pr: z2.object({ sections: z2.array(BriefSectionSchema) }).optional(),
-  issue: z2.object({ sections: z2.array(BriefSectionSchema) }).optional(),
-  milestone: z2.object({ sections: z2.array(BriefSectionSchema) }).optional(),
-  ack: z2.array(z2.enum(BRIEF_BUILTINS)).optional()
+var BriefSchemaSchema = z3.object({
+  pr: z3.object({ sections: z3.array(BriefSectionSchema) }).optional(),
+  issue: z3.object({ sections: z3.array(BriefSectionSchema) }).optional(),
+  milestone: z3.object({ sections: z3.array(BriefSectionSchema) }).optional(),
+  ack: z3.array(z3.enum(BRIEF_BUILTINS)).optional()
 });
 function isSafeRepoRelPath(p) {
   if (p.length === 0)
@@ -5057,7 +5615,7 @@ function isSafeRepoRelPath(p) {
     return false;
   return p.split(/[\\/]/).every((seg) => seg !== ".." && seg !== "");
 }
-var SafeRepoRelPath = z2.string().refine(isSafeRepoRelPath, {
+var SafeRepoRelPath = z3.string().refine(isSafeRepoRelPath, {
   message: "must be a repo-root-relative path with no `..` segment or absolute root"
 });
 var CANONICAL_HOOK_BLOCK_PREFIXES = [".git/", ".husky/", ".vinaya/hooks/", ".claude/hooks/"];
@@ -5067,22 +5625,22 @@ function isCanonicalHookBlockPath(p) {
 var ManagedHookBlockPath = SafeRepoRelPath.refine(isCanonicalHookBlockPath, {
   message: `must start with one of ${CANONICAL_HOOK_BLOCK_PREFIXES.join(", ")} (byte-exact, case-sensitive)`
 });
-var ManagedBlockRecordSchema = z2.object({
+var ManagedBlockRecordSchema = z3.object({
   path: ManagedHookBlockPath,
-  marker: z2.string(),
-  comment: z2.enum(["hash", "html"])
+  marker: z3.string(),
+  comment: z3.enum(["hash", "html"])
 });
-var ManagedManifestSchema = z2.object({
-  version: z2.number().int().positive(),
-  files: z2.array(SafeRepoRelPath),
-  blocks: z2.array(ManagedBlockRecordSchema),
-  labels: z2.array(z2.string()),
-  agents: z2.array(z2.enum(AGENT_VENDORS)).optional()
+var ManagedManifestSchema = z3.object({
+  version: z3.number().int().positive(),
+  files: z3.array(SafeRepoRelPath),
+  blocks: z3.array(ManagedBlockRecordSchema),
+  labels: z3.array(z3.string()),
+  agents: z3.array(z3.enum(AGENT_VENDORS)).optional()
 });
-var ProjectEntrySchema = z2.object({
-  name: z2.string().min(1),
-  description: z2.string().min(1).optional(),
-  path: z2.string().min(1).optional()
+var ProjectEntrySchema = z3.object({
+  name: z3.string().min(1),
+  description: z3.string().min(1).optional(),
+  path: z3.string().min(1).optional()
 });
 function parseTokensCollectDeclaration(value) {
   const m = value.trim().match(/^(\S+)\s+(\S+)$/);
@@ -5093,31 +5651,35 @@ function parseTokensCollectDeclaration(value) {
     return null;
   return { interpreter, script };
 }
-var VinayaConfigSchema = z2.object({
-  rings: z2.object({
-    ring1_forgeWriteInterception: z2.boolean(),
-    ring2_asyncAudits: z2.boolean()
+var VinayaConfigSchema = z3.object({
+  rings: z3.object({
+    ring1_forgeWriteInterception: z3.boolean(),
+    ring2_asyncAudits: z3.boolean()
   }).optional(),
-  checks: z2.record(z2.string(), CheckEntrySchema).optional(),
-  roles: z2.record(z2.string(), RoleEntrySchema).optional(),
+  checks: z3.record(z3.string(), CheckEntrySchema).optional(),
+  roles: z3.record(z3.string(), RoleEntrySchema).optional(),
   briefSchema: BriefSchemaSchema.optional(),
   managed: ManagedManifestSchema.optional(),
-  principals: z2.array(z2.string()).min(1).optional(),
-  releaseActor: z2.string().min(1).optional(),
-  ci: z2.object({ setup: z2.string().min(1) }).optional(),
-  tokens: z2.object({
-    collect: z2.string().min(1).refine((v) => parseTokensCollectDeclaration(v) !== null, {
+  principals: z3.array(z3.string()).min(1).optional(),
+  releaseActor: z3.string().min(1).optional(),
+  ci: z3.object({ setup: z3.string().min(1) }).optional(),
+  tokens: z3.object({
+    collect: z3.string().min(1).refine((v) => parseTokensCollectDeclaration(v) !== null, {
       message: 'tokens.collect must be exactly "<interpreter> <repo-relative-script-path>" — two whitespace-separated tokens, no flags, no shell syntax, no quoting'
     })
   }).optional(),
-  blastRadius: z2.object({ extraDomains: z2.array(z2.string()).optional() }).optional(),
-  proseGates: z2.object({
-    doctrineRoot: z2.string().min(1).optional(),
-    readerFacingPrefix: z2.string().min(1).optional(),
-    readerFacingSuffix: z2.string().min(1).optional(),
-    legacySlugDir: z2.string().min(1).optional()
+  blastRadius: z3.object({ extraDomains: z3.array(z3.string()).optional() }).optional(),
+  proseGates: z3.object({
+    doctrineRoot: z3.string().min(1).optional(),
+    readerFacingPrefix: z3.string().min(1).optional(),
+    readerFacingSuffix: z3.string().min(1).optional(),
+    legacySlugDir: z3.string().min(1).optional()
   }).optional(),
-  projects: z2.array(ProjectEntrySchema).optional()
+  projects: z3.array(ProjectEntrySchema).optional(),
+  dispatch: z3.object({
+    timeoutMs: z3.number().int().positive().optional(),
+    agent: z3.enum(["claude", "codex", "gemini"]).optional()
+  }).optional()
 });
 var GLOBAL_VINAYA_HOME = join(homedir(), ".vinaya");
 var GLOBAL_CONFIG_PATH = join(GLOBAL_VINAYA_HOME, "config.json");