@attalabs/vinaya 0.25.0 → 0.26.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { readFileSync as readFileSync35 } from "node:fs";
-import { dirname as dirname10, join as join34 } from "node:path";
+import { dirname as dirname12, join as join34 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/commands/archive.ts
@@ -374,7 +374,7 @@ var LABELS = [
     id: "vinaya/needs:brief-correction",
     category: "needs",
     form: "literal",
-    carries: "Waiting on the Brief Author — the brief contradicts the surface it describes."
+    carries: "Waiting on the Planner — the brief contradicts the surface it describes."
   },
   {
     key: "waiver-docs",
@@ -2460,6 +2460,11 @@ function readTierFromPrBody(prBody) {
   const t = Number(m[4]);
   return t === 0 || t === 1 || t === 3 ? t : null;
 }
+function applyTierFloor(declared, derivedFloor) {
+  if (declared === null)
+    return derivedFloor;
+  return declared >= derivedFloor ? declared : derivedFloor;
+}
 var OVERRIDE_BODY_TOKEN = `[${label("override-docs")}]`;
 // ../../packages/aeg-core/src/objectives.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -2523,7 +2528,7 @@ function objectivesOf(body) {
       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).`);
+      errors.push(`O${n} is little more than a file path — an objective states an observable outcome, never a bare path (the Planner maps it to files).`);
       continue;
     }
     objectives.push({ id: `O${n}`, text });
@@ -2691,18 +2696,14 @@ function checkTestPlanExclusivity(prBody) {
 function checkPrincipalPlaceholder(prBody) {
   const region = testPlanRegion(prBody);
   const lineRe = /^-\s*\[[ xX]\]\s*\*{2}\[principal\]\*{2}(.*)$/gim;
+  const errors = [];
   for (const m of region.matchAll(lineRe)) {
     const content = m[1] ?? "";
     if (/^\s*None\b/i.test(content)) {
-      return {
-        status: "fail",
-        errors: [
-          'brief-validation Test Plan shape: a `**[principal]**` checkbox item is a "None" placeholder — if there is no principal-runnable surface, omit the item entirely; an untickable placeholder box blocks the merge gate forever.'
-        ]
-      };
+      errors.push(`brief-validation Test Plan shape: a \`**[principal]**\` checkbox item is a "None" placeholder ("${content.trim()}") — if there is no principal-runnable surface, omit the item entirely; an untickable placeholder box blocks the merge gate forever.`);
     }
   }
-  return { status: "pass", errors: [] };
+  return errors.length > 0 ? { status: "fail", errors } : { status: "pass", errors: [] };
 }
 function checkPremiseCoverage(prBody, surfaceFiles) {
   if (surfaceFiles.length === 0)
@@ -2828,6 +2829,18 @@ function extractFencedBlocks(text) {
   }
   return blocks;
 }
+var AEG_BRIEF_V1_MARKER = "<!-- aeg:brief:v1 -->";
+function contentAfterTwoLines(body) {
+  const first = body.indexOf(`
+`);
+  if (first === -1)
+    return "";
+  const second = body.indexOf(`
+`, first + 1);
+  if (second === -1)
+    return "";
+  return body.slice(second + 1);
+}
 // ../../packages/aeg-core/src/doctrine-portability.ts
 var EXEMPT_LITERALS = new Set([
   "path/inside/the/shipped/diff.ts",
@@ -2909,7 +2922,9 @@ function partWordCount(text) {
 }
 function looksLikeFilePath(entry2) {
   const stripped = entry2.replace(/\/\*\*?$/, "");
-  return /\.[A-Za-z0-9]{1,6}$/.test(stripped);
+  const lastSegment = stripped.split("/").pop() ?? stripped;
+  const extMatch = /\.[A-Za-z0-9]{1,6}$/.exec(lastSegment);
+  return extMatch !== null && extMatch.index > 0;
 }
 function splitGlobList(raw) {
   return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -2940,6 +2955,23 @@ function parseIssueSurface(body) {
     return { ok: false, errors };
   return { ok: true, value: { in: inGlobs, out: outGlobs } };
 }
+function globCoversPath(glob, path) {
+  const g = glob.replace(/\/\*\*?$/, "").replace(/\/+$/, "");
+  const p = path.replace(/\/+$/, "");
+  return g === p || g.startsWith(`${p}/`) || p.startsWith(`${g}/`);
+}
+function checkSurfaceGlobsResolve(body, resolvesToFile) {
+  const surface = parseIssueSurface(body);
+  if (!surface.ok)
+    return { status: "pass", errors: [] };
+  const errors = [];
+  for (const glob of surface.value.in) {
+    if (!resolvesToFile(glob)) {
+      errors.push(`issue-validation Surface: \`${glob}\` in \`## Surface\`'s \`in:\` list matches no tracked file — a Surface that cannot resolve cannot render a brief's file list.`);
+    }
+  }
+  return { status: errors.length > 0 ? "fail" : "pass", errors };
+}
 var ISSUE_PART_LINE_RE = /^Part\s+(\d+)\s*\(([^)]*)\)\s*[-—–]\s*(.*)$/i;
 function parseIssueParts(body) {
   const section = topLevelSectionText(body, "Parts");
@@ -2975,6 +3007,22 @@ function parseIssueParts(body) {
     return { ok: false, errors };
   return { ok: true, value: parts };
 }
+function checkPartsCiteDefinedObjectives(body) {
+  const parts = parseIssueParts(body);
+  const objectives = objectivesOf(body);
+  if (!parts.ok || !objectives.ok)
+    return { status: "pass", errors: [] };
+  const definedIds = new Set(objectives.objectives.map((o) => Number.parseInt(o.id.slice(1), 10)));
+  const errors = [];
+  for (const part of parts.value) {
+    for (const objectiveId of part.objectiveIds) {
+      if (!definedIds.has(objectiveId)) {
+        errors.push(`issue-validation Parts: Part ${part.n} cites O${objectiveId}, which the Issue's own \`## Objectives\` section does not define.`);
+      }
+    }
+  }
+  return { status: errors.length > 0 ? "fail" : "pass", errors };
+}
 var ISSUE_PRINCIPAL_LINE_RE = /^-\s*\[[ xX]\]\s*\*{2}\[principal\]\*{2}(.*)$/gim;
 var UNIT_TESTS_ONLY_SENTINEL_RE = /(?:\*\*)?Test plan(?:\*\*)?\s*:\s*(?:\*\*)?\s*unit-tests-only/i;
 function parseIssueTestPlan(body) {
@@ -3055,15 +3103,23 @@ function namesPath(text, path) {
   return false;
 }
 var BLAST_RADIUS_ACK_RE = /(?:\*\*)?blast-radius-ack(?:\*\*)?\s*[:—–-]/i;
-function checkBlastRadiusScope(body, _labels, sharedPackages, projectPaths) {
+function checkBlastRadiusScope(body, _labels, sharedPackages, projectPaths, issueNumber = null) {
   if (sharedPackages.length === 0)
     return { status: "pass", errors: [] };
-  const text = [
-    rationaleFieldText(PATH_TEXT(body), "Boundary"),
-    rationaleFieldText(PATH_TEXT(body), "Project\\(s\\)|Project(?:s)?\\s*\\+|blast radius")
-  ].join(`
+  const decideFromSurface = issueNumber !== null && issueNumber >= BRIEF_SECTIONS_SINCE_ISSUE;
+  let named;
+  if (decideFromSurface) {
+    const surface = parseIssueSurface(body);
+    const surfaceIn = surface.ok ? surface.value.in : [];
+    named = sharedPackages.filter((d) => surfaceIn.some((glob) => globCoversPath(glob, d)));
+  } else {
+    const text = [
+      rationaleFieldText(PATH_TEXT(body), "Boundary"),
+      rationaleFieldText(PATH_TEXT(body), "Project\\(s\\)|Project(?:s)?\\s*\\+|blast radius")
+    ].join(`
 `);
-  const named = sharedPackages.filter((d) => namesPath(text, d));
+    named = sharedPackages.filter((d) => namesPath(text, d));
+  }
   if (named.length === 0)
     return { status: "pass", errors: [] };
   const registered = new Set(projectPaths.map((p) => p.name.trim()));
@@ -3103,6 +3159,7 @@ function rationaleFieldText(text, labelPattern) {
   return m ? m[0] : "";
 }
 var DOC_PATH_RE = /(?:(?:aeg-root|apps|packages|specs|docs|tools|\.claude|\.github)\/[\w./@-]*\.(?:md|mdx)|\.claude\/(?:skills|rules)\/[\w./-]+|\b(?:docs-index|decisions|projects|state-machine|enforcement|process|README|CLAUDE)\.md\b|\b[\w-]+-(?:spec|decisions|backlog)\.md\b)/i;
+var DOC_PATH_RE_GLOBAL = new RegExp(DOC_PATH_RE.source, "gi");
 var NO_DOC_SURFACE_RE = /(?:\*\*)?\s*no-doc-surface/i;
 function checkRationaleNamesDocs(body) {
   const text = PATH_TEXT(body);
@@ -3119,6 +3176,26 @@ function checkRationaleNamesDocs(body) {
     ]
   };
 }
+function checkDocsWithinSurface(body, issueNumber) {
+  if (issueNumber !== null && issueNumber < BRIEF_SECTIONS_SINCE_ISSUE)
+    return { status: "pass", errors: [] };
+  const surface = parseIssueSurface(body);
+  if (!surface.ok)
+    return { status: "pass", errors: [] };
+  const text = PATH_TEXT(body);
+  const scope = rationaleFieldText(text, "Docs to keep coherent|§7");
+  if (NO_DOC_SURFACE_RE.test(scope))
+    return { status: "pass", errors: [] };
+  const pointers = [...new Set([...scope.matchAll(DOC_PATH_RE_GLOBAL)].map((m) => m[0]))];
+  const errors = [];
+  for (const pointer of pointers) {
+    const excludingGlob = surface.value.out.find((glob) => globCoversPath(glob, pointer));
+    if (excludingGlob) {
+      errors.push(`issue-validation Docs to keep coherent: \`${pointer}\` falls inside \`## Surface\`'s \`out:\` glob \`${excludingGlob}\` — this task's own declared surface explicitly excludes the doc it claims to keep coherent.`);
+    }
+  }
+  return { status: errors.length > 0 ? "fail" : "pass", errors };
+}
 
 // ../../packages/aeg-core/src/coherence-checks.ts
 var R1_GRANDFATHERED_ISSUES = new Set([279, 280, 281, 282]);
@@ -3478,8 +3555,31 @@ function parseRationaleFields(body) {
     if (text)
       out[key] = text;
   }
+  return { ...out, declaredTier: readTierFromPrBody(body) };
+}
+function extractBoundaryFilePaths(boundaryText) {
+  const out = [];
+  const seen = new Set;
+  for (const match of boundaryText.matchAll(/`([^`\n]+)`/g)) {
+    const token = match[1].trim();
+    if (token.length === 0 || token.includes(" ") || token.includes("*"))
+      continue;
+    if (!/\.[A-Za-z0-9]{1,6}$/.test(token))
+      continue;
+    if (seen.has(token))
+      continue;
+    seen.add(token);
+    out.push(token);
+  }
   return out;
 }
+function admittedSurfaceFiles(surfaceFiles, surface) {
+  return surfaceFiles.filter((f) => {
+    const admitted = surface.in.some((g) => globCoversPath(g, f.path));
+    const excluded = surface.out.some((g) => globCoversPath(g, f.path));
+    return admitted && !excluded;
+  });
+}
 function bulletList(items) {
   return items.map((i) => `- ${i}`).join(`
 `);
@@ -3491,7 +3591,8 @@ function renderHeader(facts, template) {
   const introMatch = template.match(/^You are the AEG Developer\.[^\n]*$/m);
   const intro = introMatch ? introMatch[0].replace(/\s*\[[^\]]*\]/g, "").replace(/\bBoth mandatory\.$/, "Mandatory.").trim() : "You are the AEG Developer. Read `aeg-root/roles/developer.md` first. Mandatory.";
   const reason = facts.rationale.suggestedAgentClass ?? "";
-  const tier = deriveTierFromDiff(facts.surfaceFiles.map((f) => f.path));
+  const derivedFloor = deriveTierFromDiff(facts.surfaceFiles.map((f) => f.path));
+  const tier = applyTierFloor(facts.rationale.declaredTier ?? null, derivedFloor);
   const lines = [
     "**For:** [model] (coding-agent CLI on a dev machine, dispatched locally, unattended)",
     `**Reason:** ${reason}`,
@@ -3575,7 +3676,7 @@ function renderSection5(facts) {
     "**Step 0 (mandatory, verbatim):**",
     "",
     "```",
-    `git worktree add .worktrees/task/${facts.trancheSlug}/${facts.taskId} -b task/${facts.trancheSlug}/${facts.taskId} origin/main && cd .worktrees/task/${facts.trancheSlug}/${facts.taskId} && bun install --frozen-lockfile --silent`,
+    `git worktree add .worktrees/task/${facts.trancheSlug}/${facts.taskId} -b task/${facts.trancheSlug}/${facts.taskId} --no-track origin/main && cd .worktrees/task/${facts.trancheSlug}/${facts.taskId} && git config push.autoSetupRemote true && bun install --frozen-lockfile --silent`,
     "```",
     "",
     "1. Clean status; parent `origin/main`; branch suffix literal-matches the task id.",
@@ -3746,22 +3847,27 @@ function renderBrief(facts, template) {
     if (!facts.rationale[key])
       missing.push(RATIONALE_FIELD_NAMES[key]);
   }
+  const filteredSurfaceFiles = admittedSurfaceFiles(facts.surfaceFiles, facts.surface);
+  if (facts.surface.in.length > 0 && facts.surfaceFiles.length > 0 && filteredSurfaceFiles.length === 0) {
+    missing.push("Surface map (every file the Boundary named is excluded by the Issue's own `## Surface` `in:`/`out:` globs — Boundary and Surface disagree; fix the Issue rather than render an empty surface map)");
+  }
   if (missing.length > 0)
     return { ok: false, missing };
-  const section7Pointers = facts.docOwnersContent ? deriveSection7Pointers(facts.surfaceFiles.map((f) => f.path), facts.docOwnersContent) : [];
+  const scopedFacts = { ...facts, surfaceFiles: filteredSurfaceFiles };
+  const section7Pointers = facts.docOwnersContent ? deriveSection7Pointers(filteredSurfaceFiles.map((f) => f.path), facts.docOwnersContent) : [];
   const brief = [
-    renderHeader(facts, template),
+    renderHeader(scopedFacts, template),
     "",
     ...facts.objectives.length > 0 ? [renderObjectives(facts.objectives), ""] : [],
     renderSection2(facts),
     "",
     renderSection3(facts),
     "",
-    renderSection4(facts),
+    renderSection4(scopedFacts),
     "",
     renderSection5(facts),
     "",
-    renderSection6(facts),
+    renderSection6(scopedFacts),
     "",
     renderSection7(section7Pointers),
     "",
@@ -4112,6 +4218,25 @@ function assessRound(state, observations) {
     return assessGate(state, observations);
   return assessVerdicts(state, observations);
 }
+// ../../packages/aeg-core/src/dev-review-loop/render-summary.ts
+function confidenceCell(confidence) {
+  if (confidence === null)
+    return "—";
+  if (confidence === "absent")
+    return "absent";
+  return `${confidence.value}%`;
+}
+function row(record) {
+  const counts = SEVERITY_COLUMNS.map((key) => String(record.countsBySeverity[key] ?? 0));
+  return `| ${record.round} | ${counts.join(" | ")} | ${confidenceCell(record.confidence)} | ${record.outcome} |`;
+}
+function renderSummary(journal) {
+  const header = `| round | ${SEVERITY_COLUMNS.join(" | ")} | confidence | outcome |`;
+  const divider = `| --- | ${SEVERITY_COLUMNS.map(() => "---").join(" | ")} | --- | --- |`;
+  const rows = journal.rounds.map(row);
+  return [header, divider, ...rows].join(`
+`);
+}
 // ../../packages/aeg-core/src/log/envelope.ts
 import { createHash as createHash3 } from "node:crypto";
 
@@ -4119,7 +4244,6 @@ import { createHash as createHash3 } from "node:crypto";
 import { z } from "zod";
 var ROLE_VALUES = [
   "planner",
-  "brief-author",
   "developer",
   "code-reviewer",
   "security",
@@ -4193,18 +4317,20 @@ var dispatchShared = {
   round: z.number().int().optional(),
   effect_id: z.string()
 };
+var dispatchUsageField = z.object({ input: z.number().nonnegative(), output: z.number().nonnegative() }).strict().nullable();
 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()
+    usage: dispatchUsageField
   }).strict(),
   z.object({
     ...dispatchShared,
     event: z.literal("dispatch_failed"),
-    reason: z.enum(["timeout", "crash", "refused", "unattributed_write"])
+    reason: z.enum(["timeout", "crash", "refused", "unattributed_write"]),
+    usage: dispatchUsageField
   }).strict()
 ]);
 var loopShared = {
@@ -4479,6 +4605,7 @@ function resolveDoctrineRootInfo(pkg = packageRoot(import.meta.url), cwd = proce
   return hasDoctrineEntry(bundleRoot) ? { root: bundleRoot, source: "bundle" } : null;
 }
 var ROLE_ALIASES = { "code-reviewer": "reviewer" };
+var RETIRED_ROLES = { "brief-author": "planner" };
 function hasDoctrineEntry(root) {
   return existsSync2(join2(root, ...ENTRY_SEGMENTS));
 }
@@ -4502,6 +4629,11 @@ function doctrineCommand(args) {
   if (roleFlagIndex !== -1) {
     const requested = args[roleFlagIndex + 1];
     const roleName = requested !== undefined ? Object.hasOwn(ROLE_ALIASES, requested) ? ROLE_ALIASES[requested] : requested : undefined;
+    if (roleName !== undefined && Object.hasOwn(RETIRED_ROLES, roleName)) {
+      process.stderr.write(`vinaya doctrine --role: '${roleName}' has been retired — use --role ${RETIRED_ROLES[roleName]}.
+`);
+      process.exit(1);
+    }
     const validRoleNames = listRoleNames(root);
     if (roleName === undefined || roleName.startsWith("--") || !validRoleNames.includes(roleName)) {
       process.stderr.write(`vinaya doctrine --role: '${requested ?? ""}' is not a known role. ` + `Valid role names: ${validRoleNames.join(", ")}
@@ -4534,11 +4666,12 @@ var AGENTS_SKILLS_GROUP = "Agent skills (.agents/skills/)";
 function formatRoleTitle(roleName) {
   return roleName.split("-").filter((segment) => segment.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
+var RETIRED_ROLE_NAMES = new Set(["brief-author"]);
 function discoverRoleNames(doctrineRoot) {
   const rolesDir = join3(doctrineRoot, "roles");
   if (!existsSync3(rolesDir))
     return [];
-  return readdirSync2(rolesDir).filter((name) => name.endsWith(".md")).map((name) => name.slice(0, -".md".length)).filter((roleName) => {
+  return readdirSync2(rolesDir).filter((name) => name.endsWith(".md")).map((name) => name.slice(0, -".md".length)).filter((roleName) => !RETIRED_ROLE_NAMES.has(roleName)).filter((roleName) => {
     const { data } = matter3(readFileSync3(join3(rolesDir, `${roleName}.md`), "utf8"));
     return data.actor !== "human";
   }).sort();
@@ -4567,6 +4700,14 @@ function buildAgentsSkillsOps(doctrineRoot, selfHost = null) {
     group: AGENTS_SKILLS_GROUP
   }));
 }
+var AGENT_SKILL_PATH_PATTERN = /^\.agents\/skills\/vinaya-([^/]+)\/SKILL\.md$/;
+function staleAgentSkillPaths(doctrineRoot, manifestFiles) {
+  const liveRoles = new Set(discoverRoleNames(doctrineRoot));
+  return manifestFiles.filter((path) => {
+    const match = AGENT_SKILL_PATH_PATTERN.exec(path);
+    return match !== null && !liveRoles.has(match[1]);
+  });
+}
 
 // src/lib/claude-command-emitter.ts
 var CLAUDE_COMMAND_GROUP = "Claude Code command (.claude/commands/)";
@@ -5415,9 +5556,21 @@ fi
 node ${selfHost.bin} ${args} || exit 1`;
 }
 function preCommitBody(selfHost) {
-  return `# Vinaya commit-time gate. Runs the deterministic checks over your staged
+  const doctrineGate = `# Vinaya commit-time gate. Runs the deterministic checks over your staged
 # diff before the commit lands.
 ${hookRun(selfHost, "check --all --diff-only --local --skip-full")}`;
+  if (!selfHost)
+    return doctrineGate;
+  return `# Ring 0: format + lint your staged files, applying every safe fix, then
+# type-check only the packages your staged diff actually touches (O9) —
+# scoped so this hook costs seconds, not the whole repo's worth of work.
+VINAYA_STAGED_FILES="$(git diff --cached --name-only --diff-filter=ACMR)"
+bunx biome check --write --staged . || exit 1
+if [ -n "$VINAYA_STAGED_FILES" ]; then
+  echo "$VINAYA_STAGED_FILES" | xargs git add --
+fi
+bunx turbo typecheck --affected || exit 1
+${doctrineGate}`;
 }
 function prePushBody(selfHost) {
   const base = `# Vinaya pre-push gate. Runs branch/dispatch checks before the push leaves.
@@ -5489,7 +5642,7 @@ anything substantive:
 
 prints the absolute path to that role's doctrine — \`architect\`,
 \`developer\`, \`reviewer\`, \`planner\`, \`security\`, \`archivist\`,
-\`tranche-archivist\`, \`brief-author\`, or \`principal\`. If your agent tool
+\`tranche-archivist\`, or \`principal\`. If your agent tool
 supports slash-style commands, the same doctrine is likely exposed as
 \`/vinaya <role>\` — check your tool's command list before falling back to
 the raw CLI form.
@@ -5630,7 +5783,7 @@ var FIXED_LABEL_METADATA = {
   "needs-principal-input": { color: "b60205", description: "Blocked on a Principal decision" },
   "needs-brief-correction": {
     color: "fbca04",
-    description: "Blocked on the Brief Author — brief contradicts the surface"
+    description: "Blocked on the Planner — brief contradicts the surface"
   },
   "waiver-docs": { color: "0e8a16", description: "Doc-coverage gate excused for this PR (principal-applied)" },
   "waiver-review": { color: "0e8a16", description: "Review gate excused for this PR (principal-applied)" },
@@ -8511,6 +8664,21 @@ function expandGlob(glob) {
 function sha256OfFile(path) {
   return createHash5("sha256").update(readFileSync9(path)).digest("hex");
 }
+function resolveBoundaryPaths(tokens, allTrackedFiles) {
+  const trackedSet = new Set(allTrackedFiles);
+  const resolved = new Set;
+  for (const token of tokens) {
+    if (trackedSet.has(token)) {
+      resolved.add(token);
+      continue;
+    }
+    const suffix = `/${token}`;
+    const suffixMatches = allTrackedFiles.filter((f) => f.endsWith(suffix));
+    if (suffixMatches.length === 1)
+      resolved.add(suffixMatches[0]);
+  }
+  return [...resolved];
+}
 function listDirs(dir) {
   try {
     return readdirSync5(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -8618,17 +8786,17 @@ async function assembleAndRenderBrief(trancheSlug, taskId, surfaceGlobsOverride)
   const gate = checkDispatchReadiness(gateInput);
   const surfaceResult = parseIssueSurface(issueBody);
   const surface = surfaceResult.ok ? surfaceResult.value : { in: [], out: [] };
+  const rationale = parseRationaleFields(issueBody);
   const globs = surfaceGlobsOverride ?? surface.in;
-  const surfaceFiles = [];
   for (const glob of globs) {
-    const matches = expandGlob(glob);
-    if (matches.length === 0) {
+    if (expandGlob(glob).length === 0) {
       return { ok: false, missing: [`--surfaces glob "${glob}" matched no tracked file.`] };
     }
-    for (const path of matches) {
-      surfaceFiles.push({ path, sha256: sha256OfFile(path), packageName: packageNameForPath(path) });
-    }
   }
+  const allTrackedFiles = git(["ls-files"]).split(`
+`).map((s) => s.trim()).filter(Boolean);
+  const boundaryTokens = extractBoundaryFilePaths(rationale.boundary ?? "");
+  const surfaceFiles = resolveBoundaryPaths(boundaryTokens, allTrackedFiles).sort().map((path) => ({ path, sha256: sha256OfFile(path), packageName: packageNameForPath(path) }));
   const workspaces = workspaceGlobs();
   const consumersOf = buildConsumersOf(workspaces, listDirs, readManifest);
   const partsResult = parseIssueParts(issueBody);
@@ -8645,7 +8813,7 @@ async function assembleAndRenderBrief(trancheSlug, taskId, surfaceGlobsOverride)
     projects: task.projects,
     dependsOn: task.dependsOn,
     conflictsWith: task.conflictsWith,
-    rationale: parseRationaleFields(issueBody),
+    rationale,
     objectives: (() => {
       const parsed = objectivesOf(issueBody);
       return parsed.ok ? parsed.objectives : [];
@@ -8662,7 +8830,7 @@ async function assembleAndRenderBrief(trancheSlug, taskId, surfaceGlobsOverride)
   };
   const template = readFileSync9(TEMPLATE_PATH, "utf8");
   const result = renderBrief(facts, template);
-  return result.ok ? { ok: true, brief: result.brief } : { ok: false, missing: result.missing };
+  return result.ok ? { ok: true, brief: result.brief, issue: task.issue } : { ok: false, missing: result.missing };
 }
 
 // src/commands/brief.ts
@@ -8674,16 +8842,19 @@ async function briefRenderCommand(args) {
   const trancheSlug = args[0];
   const taskId = args[1];
   if (!trancheSlug || !taskId || trancheSlug.startsWith("--")) {
-    console.error("Usage: vinaya brief render <tranche> <n> --surfaces <glob1,glob2,...> [--out <path>]");
+    console.error("Usage: vinaya brief render <tranche> <n> [--surfaces <glob1,glob2,...>] [--out <path>]");
     process.exit(2);
   }
   const surfacesIdx = args.indexOf("--surfaces");
   const surfacesArg = surfacesIdx !== -1 ? args[surfacesIdx + 1] : undefined;
-  if (!surfacesArg)
-    refuse("--surfaces <glob1,glob2,...> is required.");
-  const globs = surfacesArg.split(",").map((s) => s.trim()).filter(Boolean);
-  if (globs.length === 0)
-    refuse("--surfaces resolved to zero globs.");
+  let globs;
+  if (surfacesIdx !== -1) {
+    if (!surfacesArg)
+      refuse("--surfaces <glob1,glob2,...> was passed with no value.");
+    globs = surfacesArg.split(",").map((s) => s.trim()).filter(Boolean);
+    if (globs.length === 0)
+      refuse("--surfaces resolved to zero globs.");
+  }
   const outIdx = args.indexOf("--out");
   const outPath = outIdx !== -1 ? args[outIdx + 1] : undefined;
   const result = await assembleAndRenderBrief(trancheSlug, taskId, globs);
@@ -8790,6 +8961,18 @@ var REGISTRY = [
     },
     0
   ],
+  [
+    {
+      name: "pr-premise-reassert",
+      run: bin("check-pr-premise-reassert"),
+      scope: "diff",
+      timeoutMs: 15000,
+      env: {
+        PR_BODY: { optional: true }
+      }
+    },
+    0
+  ],
   [
     {
       name: "dispatch-readiness",
@@ -8838,6 +9021,22 @@ var REGISTRY = [
     },
     0
   ],
+  [
+    {
+      name: "surface-scope",
+      run: bin("check-surface-scope"),
+      scope: "diff",
+      timeoutMs: 15000,
+      env: {
+        AEG_REPO: { optional: true },
+        BASE_SHA: { optional: true },
+        BRANCH: { optional: true },
+        GITHUB_TOKEN: { optional: true },
+        GH_TOKEN: { optional: true }
+      }
+    },
+    0
+  ],
   [
     {
       name: "test-plan",
@@ -8879,6 +9078,7 @@ var REGISTRY = [
       requiresOpenPr: true,
       env: {
         PR_BODY: { optional: true },
+        BRANCH: { optional: true },
         CLAUDE_PROJECT_DIR: { optional: true },
         CLAUDE_CODE_SESSION_ID: { optional: true }
       }
@@ -9751,8 +9951,8 @@ function renderPlanTable(result) {
   const rows = result.resolved.map((entry2) => [entry2.name, entry2.state, entry2.source, envCellFor(entry2.spec)]);
   const failureRows = result.failures.map((f) => [f.key, "FAILED", "—", f.reason]);
   const table = [header, ...rows, ...failureRows];
-  const widths = header.map((_, col) => Math.max(...table.map((row) => row[col]?.length ?? 0)));
-  return table.map((row) => row.map((cell, col) => (cell ?? "").padEnd(widths[col] ?? 0)).join("  ")).join(`
+  const widths = header.map((_, col) => Math.max(...table.map((row2) => row2[col]?.length ?? 0)));
+  return table.map((row2) => row2.map((cell, col) => (cell ?? "").padEnd(widths[col] ?? 0)).join("  ")).join(`
 `);
 }
 function renderRolesTable(rolePlan) {
@@ -9762,8 +9962,8 @@ function renderRolesTable(rolePlan) {
   const rows = rolePlan.resolved.map((r) => [r.name, r.state, r.source, r.renderId, r.inertToGating ? "inert" : "core"]);
   const failureRows = rolePlan.failures.map((f) => [f.key, "FAILED", "—", "—", f.reason]);
   const table = [header, ...rows, ...failureRows];
-  const widths = header.map((_, col) => Math.max(...table.map((row) => row[col]?.length ?? 0)));
-  return table.map((row) => row.map((cell, col) => (cell ?? "").padEnd(widths[col] ?? 0)).join("  ")).join(`
+  const widths = header.map((_, col) => Math.max(...table.map((row2) => row2[col]?.length ?? 0)));
+  return table.map((row2) => row2.map((cell, col) => (cell ?? "").padEnd(widths[col] ?? 0)).join("  ")).join(`
 `);
 }
 function duplicateIdFailures(resolved) {
@@ -10031,6 +10231,12 @@ None — fixture content only.
 ## Test Plan
 Test Plan: unit-tests-only
 
+## Token report
+
+| Phase | Role | Agent/Model | Tokens in | Tokens out | Cost | Date |
+| --- | --- | --- | --- | --- | --- | --- |
+| demo: develop | Developer | — | — | — | — | — |
+
 ## Stop Conditions
 Autonomy: Do not stop to ask clarifying questions — this is a scripted demo; proceed and clean up automatically.
 
@@ -10152,8 +10358,10 @@ async function demoBreakCommand(args) {
 
 // src/lib/dispatch.ts
 import { randomUUID as randomUUID2, createHash as createHash6 } from "node:crypto";
-import { accessSync, constants as fsConstants3, readFileSync as readFileSync14 } from "node:fs";
+import { accessSync, constants as fsConstants3, mkdirSync as mkdirSync4, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "node:fs";
+import { chmodSync as chmodSync2, createWriteStream } from "node:fs";
 import { execFileSync as execFileSync13, spawn as spawn2 } from "node:child_process";
+import { homedir as homedir3 } from "node:os";
 
 // src/lib/log-sink.ts
 import { execFileSync as execFileSync12 } from "node:child_process";
@@ -10354,21 +10562,112 @@ function log(e) {
 }
 
 // src/lib/dispatch.ts
-import { join as join14 } from "node:path";
+import { dirname as dirname7, join as join14 } from "node:path";
 var AGENT_VENDOR_NAMES = ["claude", "codex", "gemini"];
 function isAgentVendor2(value) {
   return AGENT_VENDOR_NAMES.includes(value);
 }
-var DEFAULT_TIMEOUT_MS = 3600000;
+var AGENT_CLASS_VALUES = ["high", "mid", "fast"];
+function isAgentClass(value) {
+  return AGENT_CLASS_VALUES.includes(value);
+}
+var DEFAULT_TIMEOUT_MS = 14400000;
 var SIGKILL_GRACE_MS = 5000;
-function parseClaudeUsage(stdout) {
+var HEARTBEAT_INTERVAL_MS = 60000;
+function timeoutWarningLeadMs(timeoutMs) {
+  return Math.min(300000, Math.floor(timeoutMs / 2));
+}
+var MAX_TEE_BYTES = 8 * 1024 * 1024;
+function openOutputTee(effectId) {
+  const inert = { write: () => {}, end: () => {}, path: null };
+  if (!/^[A-Za-z0-9_-]{1,128}$/.test(effectId))
+    return inert;
   try {
-    const obj = JSON.parse(stdout);
-    const u = obj.usage;
-    if (u && typeof u.input_tokens === "number" && typeof u.output_tokens === "number") {
-      return { input: u.input_tokens, output: u.output_tokens };
-    }
-  } catch {}
+    const dir = join14(GLOBAL_VINAYA_HOME, "dispatch-output");
+    mkdirSync4(dir, { recursive: true, mode: 448 });
+    chmodSync2(dir, 448);
+    const path = join14(dir, `${effectId}.log`);
+    const stream = createWriteStream(path, { flags: "a", mode: 384 });
+    let broken = false;
+    let written = 0;
+    let carry = "";
+    stream.on("error", () => {
+      broken = true;
+    });
+    const home = homedir3();
+    return {
+      write: (chunk) => {
+        if (broken || written >= MAX_TEE_BYTES)
+          return;
+        try {
+          const text = carry + chunk.toString("utf8");
+          const cut = Math.max(0, text.length - 256);
+          const emit = redact(text.slice(0, cut), home);
+          carry = text.slice(cut);
+          if (emit.length === 0)
+            return;
+          written += Buffer.byteLength(emit);
+          stream.write(emit);
+        } catch {
+          broken = true;
+        }
+      },
+      end: () => {
+        try {
+          if (!broken && carry.length > 0)
+            stream.write(redact(carry, home));
+          stream.end();
+        } catch {
+          broken = true;
+        }
+      },
+      path
+    };
+  } catch {
+    return inert;
+  }
+}
+function parseClaudeModel(stdout) {
+  const lines = stdout.split(`
+`).filter((l) => l.trim().length > 0);
+  for (let i = lines.length - 1;i >= 0; i--) {
+    try {
+      const obj = JSON.parse(lines[i]);
+      const keys = obj.modelUsage ? Object.keys(obj.modelUsage) : [];
+      if (keys.length > 0)
+        return keys.join(",");
+    } catch {}
+  }
+  return null;
+}
+function parseCodexModel(_stdout) {
+  return null;
+}
+function parseGeminiModel(stdout) {
+  const lines = stdout.split(`
+`).filter((l) => l.trim().length > 0);
+  for (let i = lines.length - 1;i >= 0; i--) {
+    try {
+      const obj = JSON.parse(lines[i]);
+      const keys = obj.stats?.models ? Object.keys(obj.stats.models) : [];
+      if (keys.length > 0)
+        return keys.join(",");
+    } catch {}
+  }
+  return null;
+}
+function parseClaudeUsage(stdout) {
+  const lines = stdout.split(`
+`).filter((l) => l.trim().length > 0);
+  for (let i = lines.length - 1;i >= 0; i--) {
+    try {
+      const obj = JSON.parse(lines[i]);
+      const u = obj.usage;
+      if (u && typeof u.input_tokens === "number" && typeof u.output_tokens === "number") {
+        return { input: u.input_tokens, output: u.output_tokens };
+      }
+    } catch {}
+  }
   return null;
 }
 function parseCodexUsage(stdout) {
@@ -10390,16 +10689,31 @@ function parseCodexUsage(stdout) {
   }
   return null;
 }
-function parseGeminiUsage(_stdout) {
+function parseGeminiUsage(stdout) {
+  const lines = stdout.split(`
+`).filter((l) => l.trim().length > 0);
+  for (let i = lines.length - 1;i >= 0; i--) {
+    try {
+      const obj = JSON.parse(lines[i]);
+      const st = obj.stats;
+      if (st && typeof st.input_tokens === "number" && typeof st.output_tokens === "number") {
+        return { input: st.input_tokens, output: st.output_tokens };
+      }
+    } catch {}
+  }
   return null;
 }
 function parseClaudeResumeId(stdout) {
-  try {
-    const obj = JSON.parse(stdout);
-    return typeof obj.session_id === "string" ? obj.session_id : null;
-  } catch {
-    return null;
+  const lines = stdout.split(`
+`).filter((l) => l.trim().length > 0);
+  for (let i = lines.length - 1;i >= 0; i--) {
+    try {
+      const obj = JSON.parse(lines[i]);
+      if (typeof obj.session_id === "string")
+        return obj.session_id;
+    } catch {}
   }
+  return null;
 }
 function parseCodexResumeId(stdout) {
   for (const raw of stdout.split(`
@@ -10423,29 +10737,132 @@ function parseGeminiResumeId(stdout) {
     return null;
   }
 }
+var SAFE_REPO_SEGMENT = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
+function isSafeRepoSegment2(segment) {
+  return SAFE_REPO_SEGMENT.test(segment) && !segment.includes("..");
+}
+function resumeRecordPathFor(role, agent, repo, task, pr) {
+  const repoSegment = repo && isSafeRepoSegment2(repo.owner) && isSafeRepoSegment2(repo.repo) ? `${repo.owner}-${repo.repo}` : "unresolved";
+  const scope = task !== undefined ? `issue${task}` : pr !== undefined ? `pr${pr}` : "unscoped";
+  return join14(GLOBAL_VINAYA_HOME, "dispatch-resume", repoSegment, `${role}-${agent}-${scope}.json`);
+}
+function recordResumeState(record) {
+  try {
+    const path = resumeRecordPathFor(record.role, record.agent, record.repo, record.task ?? undefined, record.pr ?? undefined);
+    mkdirSync4(dirname7(path), { recursive: true, mode: 448 });
+    chmodSync2(dirname7(path), 448);
+    writeFileSync5(path, JSON.stringify(record, null, 2), { mode: 384 });
+    return path;
+  } catch {
+    return null;
+  }
+}
+function renderClaudeEvent(obj) {
+  const type = obj.type;
+  if (type === "assistant" || type === "user") {
+    const msg = obj.message;
+    const content = Array.isArray(msg?.content) ? msg?.content : [];
+    const out = [];
+    for (const block of content) {
+      if (block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0) {
+        out.push(block.text.trim());
+      } else if (block.type === "tool_use" && typeof block.name === "string") {
+        const input = block.input;
+        const subject = typeof input?.file_path === "string" && input.file_path || typeof input?.command === "string" && input.command || typeof input?.pattern === "string" && input.pattern || typeof input?.path === "string" && input.path || "";
+        const trimmed = subject.length > 120 ? `${subject.slice(0, 117)}...` : subject;
+        out.push(trimmed ? `⚙ ${block.name}: ${trimmed}` : `⚙ ${block.name}`);
+      }
+    }
+    return out.length > 0 ? out.join(`
+`) : null;
+  }
+  if (type === "system" && obj.subtype === "init")
+    return "⏵ session started";
+  if (typeof obj.stop_reason === "string")
+    return `⏹ ${obj.stop_reason}`;
+  return null;
+}
+function renderCodexEvent(obj) {
+  const type = typeof obj.type === "string" ? obj.type : "";
+  if (type.endsWith(".completed") || type.endsWith(".started"))
+    return `⏵ ${type}`;
+  const item = obj.item;
+  return typeof item?.text === "string" && item.text.trim().length > 0 ? item.text.trim() : null;
+}
+function renderGeminiEvent(obj) {
+  if (obj.type === "init")
+    return "⏵ session started";
+  if (obj.type === "message" && obj.role === "assistant") {
+    const text = typeof obj.content === "string" ? obj.content.trim() : "";
+    return text.length > 0 ? text : null;
+  }
+  if (obj.type === "result") {
+    const status = typeof obj.status === "string" ? obj.status : "finished";
+    return `⏹ ${status}`;
+  }
+  return null;
+}
 var VENDOR_TABLE = {
   claude: {
     binary: "claude",
-    args: ["-p", "--output-format", "json"],
-    resumeArgs: (id) => ["-p", "-r", id, "--output-format", "json"],
+    args: (model) => ["-p", "--verbose", "--output-format", "stream-json", ...model ? ["--model", model] : []],
+    resumeArgs: (id, model) => [
+      "-p",
+      "-r",
+      id,
+      "--verbose",
+      "--output-format",
+      "stream-json",
+      ...model ? ["--model", model] : []
+    ],
     parseUsage: parseClaudeUsage,
-    parseResumeId: parseClaudeResumeId
+    parseModel: parseClaudeModel,
+    parseResumeId: parseClaudeResumeId,
+    renderEvent: renderClaudeEvent,
+    classModels: { high: "opus", mid: "sonnet", fast: "haiku" }
   },
   codex: {
     binary: "codex",
-    args: ["exec", "--json", "-"],
-    resumeArgs: (id) => ["exec", "resume", id, "--json", "-"],
+    args: (model) => ["exec", ...model ? ["--model", model] : [], "--json", "-"],
+    resumeArgs: (id, model) => ["exec", "resume", id, ...model ? ["--model", model] : [], "--json", "-"],
     parseUsage: parseCodexUsage,
-    parseResumeId: parseCodexResumeId
+    parseModel: parseCodexModel,
+    parseResumeId: parseCodexResumeId,
+    renderEvent: renderCodexEvent,
+    classModels: {}
   },
   gemini: {
     binary: "gemini",
-    args: ["-p", "", "--output-format", "json", "--skip-trust"],
-    resumeArgs: (id) => ["-p", "", "--resume", id, "--output-format", "json", "--skip-trust"],
+    args: (model) => ["-p", "", ...model ? ["--model", model] : [], "--output-format", "stream-json", "--skip-trust"],
+    resumeArgs: (id, model) => [
+      "-p",
+      "",
+      "--resume",
+      id,
+      ...model ? ["--model", model] : [],
+      "--output-format",
+      "stream-json",
+      "--skip-trust"
+    ],
     parseUsage: parseGeminiUsage,
-    parseResumeId: parseGeminiResumeId
+    parseModel: parseGeminiModel,
+    parseResumeId: parseGeminiResumeId,
+    renderEvent: renderGeminiEvent,
+    classModels: {}
   }
 };
+var CLAUDE_MODEL_ALIASES = new Set(["fable", "opus", "sonnet", "haiku"]);
+function identifyVendorFromModelShape(model) {
+  const lower = model.toLowerCase();
+  if (CLAUDE_MODEL_ALIASES.has(lower) || lower.startsWith("claude-"))
+    return "claude";
+  if (lower.startsWith("gemini-") || lower.startsWith("gemma-"))
+    return "gemini";
+  return null;
+}
+function resolveClassModel(agent, agentClass) {
+  return VENDOR_TABLE[agent].classModels[agentClass] ?? null;
+}
 function resolveExecutable(binary) {
   try {
     const path = execFileSync13("which", [binary], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
@@ -10513,6 +10930,30 @@ async function dispatchRole(role, agent, prompt2, opts) {
   const vendor = VENDOR_TABLE[agent];
   const start = Date.now();
   const roundField = opts.round !== undefined ? { round: opts.round } : {};
+  const resolvedModel = opts.model !== undefined ? `requested:${opts.model}` : "default";
+  if (opts.model !== undefined) {
+    const foreignVendor = identifyVendorFromModelShape(opts.model);
+    if (foreignVendor !== null && foreignVendor !== agent) {
+      const durationMs = Date.now() - start;
+      const priorSize = sizeOfSafe(outboxPath);
+      log2({
+        kind: "dispatch",
+        event: "dispatch_failed",
+        payload: {},
+        target_role: role,
+        model: resolvedModel,
+        ...roundField,
+        effect_id: effectId,
+        reason: "refused",
+        usage: null,
+        duration_ms: durationMs
+      });
+      process.stderr.write(`[vinaya dispatch ${effectId}] ${role} via ${agent}: refused — model '${opts.model}' is a ${foreignVendor} model; ` + `${agent} does not accept it. ${agent} accepts its own model names (never a ${foreignVendor} alias or a ` + `'${foreignVendor}-'/'gemma-' full name).
+`);
+      await waitForDispatchLine(outboxPath, priorSize, runId, effectId, "dispatch_failed");
+      return { exitCode: null, durationMs, usage: null, resumeId: null, timedOut: false, failureReason: "refused" };
+    }
+  }
   const binaryPath = resolveExecutable(vendor.binary);
   if (binaryPath === null) {
     const durationMs = Date.now() - start;
@@ -10522,10 +10963,11 @@ async function dispatchRole(role, agent, prompt2, opts) {
       event: "dispatch_failed",
       payload: {},
       target_role: role,
-      model: agent,
+      model: resolvedModel,
       ...roundField,
       effect_id: effectId,
       reason: "refused",
+      usage: null,
       duration_ms: durationMs
     });
     await waitForDispatchLine(outboxPath, priorSize, runId, effectId, "dispatch_failed");
@@ -10538,7 +10980,7 @@ async function dispatchRole(role, agent, prompt2, opts) {
       event: "dispatched",
       payload: {},
       target_role: role,
-      model: agent,
+      model: resolvedModel,
       ...roundField,
       effect_id: effectId,
       prompt_hash: promptHashOf(prompt2)
@@ -10547,7 +10989,7 @@ async function dispatchRole(role, agent, prompt2, opts) {
   }
   const timeoutMs = loadConfig()?.dispatch?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   return new Promise((resolve3) => {
-    const child = spawn2(binaryPath, opts.resumeId ? vendor.resumeArgs(opts.resumeId) : vendor.args, {
+    const child = spawn2(binaryPath, opts.resumeId ? vendor.resumeArgs(opts.resumeId, opts.model) : vendor.args(opts.model), {
       stdio: ["pipe", "pipe", "pipe"],
       env: {
         ...process.env,
@@ -10562,15 +11004,52 @@ async function dispatchRole(role, agent, prompt2, opts) {
     let killTimer;
     let stdoutBuf = "";
     const MAX_STDOUT_BYTES = 1e6;
+    const outputTee = openOutputTee(effectId);
+    if (outputTee.path !== null) {
+      process.stderr.write(`[vinaya dispatch ${effectId}] ${role} via ${agent}: output teed to ${outputTee.path}
+`);
+    }
+    let renderCarry = "";
     child.stdout.on("data", (chunk) => {
+      outputTee.write(chunk);
       if (stdoutBuf.length < MAX_STDOUT_BYTES)
         stdoutBuf += chunk.toString("utf8");
+      renderCarry += chunk.toString("utf8");
+      const lines = renderCarry.split(`
+`);
+      renderCarry = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.trim().length === 0)
+          continue;
+        try {
+          const rendered = vendor.renderEvent(JSON.parse(line));
+          if (rendered)
+            process.stderr.write(`${rendered}
+`);
+        } catch {}
+      }
     });
-    child.stderr.on("data", () => {});
+    child.stderr.on("data", (chunk) => {
+      outputTee.write(chunk);
+    });
+    const heartbeatTimer = setInterval(() => {
+      const elapsedS = Math.round((Date.now() - start) / 1000);
+      process.stderr.write(`[vinaya dispatch ${effectId}] ${role} via ${agent}: still running — ${elapsedS}s elapsed (ceiling ${Math.round(timeoutMs / 1000)}s)
+`);
+    }, HEARTBEAT_INTERVAL_MS);
+    const warnLeadMs = timeoutWarningLeadMs(timeoutMs);
+    const warnTimer = setTimeout(() => {
+      process.stderr.write(`[vinaya dispatch ${effectId}] ${role} via ${agent}: approaching timeout — SIGTERM in ~${Math.round(warnLeadMs / 1000)}s unless it finishes first
+`);
+    }, Math.max(timeoutMs - warnLeadMs, 0));
     const timeoutTimer = setTimeout(() => {
       timedOut = true;
+      process.stderr.write(`[vinaya dispatch ${effectId}] ${role} via ${agent}: ceiling reached — sending SIGTERM
+`);
       child.kill("SIGTERM");
       killTimer = setTimeout(() => {
+        process.stderr.write(`[vinaya dispatch ${effectId}] ${role} via ${agent}: still alive after SIGTERM — sending SIGKILL
+`);
         child.kill("SIGKILL");
       }, SIGKILL_GRACE_MS);
     }, timeoutMs);
@@ -10581,6 +11060,9 @@ async function dispatchRole(role, agent, prompt2, opts) {
       clearTimeout(timeoutTimer);
       if (killTimer)
         clearTimeout(killTimer);
+      clearInterval(heartbeatTimer);
+      clearTimeout(warnTimer);
+      outputTee.end();
       await waitForDispatchLine(outboxPath, priorSize, runId, effectId, event);
       resolve3(handle);
     }
@@ -10592,16 +11074,18 @@ async function dispatchRole(role, agent, prompt2, opts) {
         event: "dispatch_failed",
         payload: {},
         target_role: role,
-        model: agent,
+        model: resolvedModel,
         ...roundField,
         effect_id: effectId,
         reason: "crash",
+        usage: null,
         duration_ms: durationMs
       });
       finish({ exitCode: null, durationMs, usage: null, resumeId: null, timedOut: false, failureReason: "crash" }, "dispatch_failed", priorSize);
     });
     child.on("exit", (code) => {
       const durationMs = Date.now() - start;
+      const usage = vendor.parseUsage(stdoutBuf);
       if (timedOut) {
         const priorSize2 = sizeOfSafe(outboxPath);
         log2({
@@ -10609,13 +11093,14 @@ async function dispatchRole(role, agent, prompt2, opts) {
           event: "dispatch_failed",
           payload: {},
           target_role: role,
-          model: agent,
+          model: resolvedModel,
           ...roundField,
           effect_id: effectId,
           reason: "timeout",
+          usage,
           duration_ms: durationMs
         });
-        finish({ exitCode: code, durationMs, usage: null, resumeId: null, timedOut: true, failureReason: "timeout" }, "dispatch_failed", priorSize2);
+        finish({ exitCode: code, durationMs, usage, resumeId: null, timedOut: true, failureReason: "timeout" }, "dispatch_failed", priorSize2);
         return;
       }
       if (code !== 0) {
@@ -10625,24 +11110,42 @@ async function dispatchRole(role, agent, prompt2, opts) {
           event: "dispatch_failed",
           payload: {},
           target_role: role,
-          model: agent,
+          model: resolvedModel,
           ...roundField,
           effect_id: effectId,
           reason: "crash",
+          usage,
           duration_ms: durationMs
         });
-        finish({ exitCode: code, durationMs, usage: null, resumeId: null, timedOut: false, failureReason: "crash" }, "dispatch_failed", priorSize2);
+        finish({ exitCode: code, durationMs, usage, resumeId: null, timedOut: false, failureReason: "crash" }, "dispatch_failed", priorSize2);
         return;
       }
-      const usage = vendor.parseUsage(stdoutBuf);
       const resumeId = vendor.parseResumeId(stdoutBuf);
+      if (resumeId !== null) {
+        const resumeRecordPath = recordResumeState({
+          resumeId,
+          role,
+          agent,
+          repo,
+          task: opts.task ?? null,
+          pr: opts.pr ?? null,
+          round: opts.round ?? null,
+          effectId,
+          capturedAt: new Date().toISOString()
+        });
+        if (resumeRecordPath !== null) {
+          process.stderr.write(`[vinaya dispatch ${effectId}] ${role} via ${agent}: resumable — session recorded at ${resumeRecordPath}
+`);
+        }
+      }
+      const reportedModel = vendor.parseModel(stdoutBuf);
       const priorSize = sizeOfSafe(outboxPath);
       log2({
         kind: "dispatch",
         event: "outcome_received",
         payload: {},
         target_role: role,
-        model: agent,
+        model: reportedModel ?? resolvedModel,
         ...roundField,
         effect_id: effectId,
         outcome: { type: "plan", issues: [] },
@@ -10659,19 +11162,19 @@ async function dispatchRole(role, agent, prompt2, opts) {
 // src/lib/dev-review-loop.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { execFileSync as execFileSync17 } from "node:child_process";
-import { mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync3, readFileSync as readFileSync17, rmSync as rmSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync8 } from "node:fs";
+import { mkdirSync as mkdirSync5, mkdtempSync as mkdtempSync3, readFileSync as readFileSync17, rmSync as rmSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join18 } from "node:path";
+import { dirname as dirname8, join as join18 } from "node:path";
 
 // src/commands/review-post.ts
 import { execFileSync as execFileSync15 } from "node:child_process";
-import { readFileSync as readFileSync16, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { readFileSync as readFileSync16, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join16 } from "node:path";
 
 // src/lib/forge-write.ts
 import { execFileSync as execFileSync14 } from "node:child_process";
-import { existsSync as existsSync12, mkdtempSync, readdirSync as readdirSync6, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync12, mkdtempSync, readdirSync as readdirSync6, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { readFileSync as readFileSync15 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join15 } from "node:path";
@@ -10709,7 +11212,7 @@ function resolveShippableArgs(args, bodyResult) {
   }
   const dir = mkdtempSync(join15(tmpdir(), "vinaya-forge-body-"));
   const tempPath = join15(dir, "body.md");
-  writeFileSync5(tempPath, bodyResult.body, "utf8");
+  writeFileSync6(tempPath, bodyResult.body, "utf8");
   const finalArgs = [...args];
   const { argIndex, inlineForm } = bodyResult.source;
   finalArgs[argIndex] = inlineForm ? `--body-file=${tempPath}` : tempPath;
@@ -10995,13 +11498,22 @@ var CHECK_ISSUE_CONTENT = "issue-content";
 var ISSUE_CONTENT_RECOVERY = {
   blastRadius: "Add a second registered `Project(s)` this task also touches, or a `blast-radius-ack: <why one lens is enough>` line, then re-run `{cmd}`.",
   noBriefContent: "Move the brief-shaped section named above out of the Issue body and into the brief — the Issue carries the Planner's durable rationale, not the brief's just-in-time surface — then re-run `{cmd}`.",
-  rationaleNamesDocs: 'Name a concrete doc/skill path (e.g. `aeg-root/…`, `.claude/skills/…/SKILL.md`) in "Docs to keep coherent" or "Traps", or write the `no-doc-surface` sentinel if the surface genuinely has none, then re-run `{cmd}`.'
+  rationaleNamesDocs: 'Name a concrete doc/skill path (e.g. `aeg-root/…`, `.claude/skills/…/SKILL.md`) in "Docs to keep coherent" or "Traps", or write the `no-doc-surface` sentinel if the surface genuinely has none, then re-run `{cmd}`.',
+  surfaceGlobsResolve: "Fix the named `## Surface` `in:` glob so it matches at least one real tracked file (a typo, or a directory that does not exist yet), then re-run `{cmd}`.",
+  partsCiteObjectives: "Fix the named Part to cite an objective id the `## Objectives` section actually defines, or add the missing objective, then re-run `{cmd}`.",
+  docsWithinSurface: 'Move the named doc pointer to a path `## Surface`\'s `in:` globs actually cover (never widen the surface just to fit the pointer — that renders an unusable brief), or drop it from "Docs to keep coherent" if this task does not really keep it coherent, then re-run `{cmd}`.'
 };
 function validateIssueContent(input) {
   const findings = [
-    [checkBlastRadiusScope(input.body, input.labels, input.sharedPackages, input.projectPaths).errors, "blastRadius"],
+    [
+      checkBlastRadiusScope(input.body, input.labels, input.sharedPackages, input.projectPaths, input.issueNumber).errors,
+      "blastRadius"
+    ],
     [checkNoBriefContent(input.body).errors, "noBriefContent"],
-    [checkRationaleNamesDocs(input.body).errors, "rationaleNamesDocs"]
+    [checkRationaleNamesDocs(input.body).errors, "rationaleNamesDocs"],
+    [checkSurfaceGlobsResolve(input.body, input.resolvesToFile).errors, "surfaceGlobsResolve"],
+    [checkPartsCiteDefinedObjectives(input.body).errors, "partsCiteObjectives"],
+    [checkDocsWithinSurface(input.body, input.issueNumber).errors, "docsWithinSurface"]
   ];
   const errors = [];
   for (const [messages, kind] of findings) {
@@ -11073,7 +11585,9 @@ function validateTaskIssue(body, title, labels, retryCommand, issueNumber) {
     labels,
     sharedPackages: readSharedPackages(),
     projectPaths: readProjectPaths(),
-    retryCommand
+    retryCommand,
+    issueNumber,
+    resolvesToFile: (glob) => expandGlob(glob).length > 0
   });
   if (contentErrors.length > 0)
     refuse2(contentErrors);
@@ -11120,7 +11634,7 @@ ${body}
 `;
   const dir = mkdtempSync(join15(tmpdir(), "vinaya-marked-comment-"));
   const tmp = join15(dir, "comment.md");
-  writeFileSync5(tmp, commentBody, "utf8");
+  writeFileSync6(tmp, commentBody, "utf8");
   try {
     const out = execFileSync14("gh", [kind, "comment", ref, "--body-file", tmp], {
       encoding: "utf8",
@@ -11769,7 +12283,7 @@ function printOnlyResult(json, role, headSha, body) {
 }
 function postComment(pr, body) {
   const tmp = join16(tmpdir2(), `vinaya-review-post-${process.pid}-${Date.now()}.md`);
-  writeFileSync6(tmp, body);
+  writeFileSync7(tmp, body);
   try {
     return gh(["pr", "comment", pr, "--body-file", tmp]).trim();
   } catch (err) {
@@ -12114,10 +12628,9 @@ Self-verification: clean — re-parsed VERDICT is bound to head ${headSha}.
 // src/lib/dispatch-task.ts
 import { execFileSync as execFileSync16 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join17 } from "node:path";
-var AEG_BRIEF_V1_MARKER = "<!-- aeg:brief:v1 -->";
 var DISPATCH_AGENTS = ["claude", "codex", "gemini"];
 
 class DispatchTaskError extends Error {
@@ -12125,17 +12638,6 @@ class DispatchTaskError extends Error {
 function sh3(cmd, args) {
   return execFileSync16(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
 }
-function contentAfterTwoLines(body) {
-  const first = body.indexOf(`
-`);
-  if (first === -1)
-    return "";
-  const second = body.indexOf(`
-`, first + 1);
-  if (second === -1)
-    return "";
-  return body.slice(second + 1);
-}
 function briefHash(brief) {
   return createHash7("sha256").update(`${brief}
 `).digest("hex");
@@ -12153,6 +12655,32 @@ function fetchIssueComments(n) {
     throw new DispatchTaskError(`could not parse \`gh issue view ${n} --json comments\` output.`);
   }
 }
+function fetchIssueBody(n) {
+  try {
+    return JSON.parse(sh3("gh", ["issue", "view", String(n), "--json", "body"])).body;
+  } catch (err) {
+    throw new DispatchTaskError(`could not fetch Issue #${n}'s body (\`gh issue view\`) to resolve its suggested agent-class: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function extractAgentClass(rawRationaleField) {
+  const m = /agent-class\**\s*[—–-]\s*(\w+)/i.exec(rawRationaleField);
+  const word = m?.[1]?.toLowerCase();
+  return word !== undefined && isAgentClass(word) ? word : null;
+}
+function resolveModelFromRationale(agent, rawRationaleField, explicitModel) {
+  if (explicitModel !== undefined)
+    return explicitModel;
+  const agentClass = rawRationaleField !== undefined ? extractAgentClass(rawRationaleField) : null;
+  if (agentClass === null)
+    return;
+  return resolveClassModel(agent, agentClass) ?? undefined;
+}
+function resolveModelForDispatch(agent, issue, explicitModel) {
+  if (explicitModel !== undefined)
+    return explicitModel;
+  const raw = parseRationaleFields(fetchIssueBody(issue)).suggestedAgentClass;
+  return resolveModelFromRationale(agent, raw, undefined);
+}
 function findExistingV1Comment(n) {
   return fetchIssueComments(n).find((c) => c.body.split(`
 `)[0] === AEG_BRIEF_V1_MARKER) ?? null;
@@ -12178,7 +12706,7 @@ Once \`dispatchRole\` ships, the same \`--agent\` flag on \`task dispatch\` will
 async function withPromptFile(prompt2, fn) {
   const dir = mkdtempSync2(join17(tmpdir3(), "vinaya-dispatch-prompt-"));
   const promptFile = join17(dir, "prompt.md");
-  writeFileSync7(promptFile, prompt2, "utf8");
+  writeFileSync8(promptFile, prompt2, "utf8");
   try {
     return await fn(promptFile);
   } finally {
@@ -12195,10 +12723,11 @@ var defaultDeps2 = {
   findExistingV1Comment,
   postMarkedComment,
   resolveDispatchRole,
-  resolveDispatchAuthorization
+  resolveDispatchAuthorization,
+  resolveModelForDispatch
 };
 async function dispatchTask(input, deps = defaultDeps2) {
-  const { tranche, n, agent } = input;
+  const { tranche, n, agent, model } = input;
   {
     const { authorized, login } = deps.resolveDispatchAuthorization();
     if (!authorized) {
@@ -12211,18 +12740,30 @@ async function dispatchTask(input, deps = defaultDeps2) {
 ${result.missing.map((m) => `  - ${m}`).join(`
 `)}`);
   }
-  const existing = deps.findExistingV1Comment(n);
+  const issue = result.issue;
+  const existing = deps.findExistingV1Comment(issue);
   if (existing) {
     throw new DispatchTaskError(`Task ${n} in tranche \`${tranche}\` is already dispatched — see ${existing.url}`);
   }
+  let dispatchRole2 = null;
+  let resolvedModel;
+  if (agent) {
+    dispatchRole2 = await deps.resolveDispatchRole();
+    if (dispatchRole2) {
+      resolvedModel = deps.resolveModelForDispatch(agent, issue, model);
+    }
+  }
   const hash = briefHash(result.brief);
   const commentBody = `Brief hash: ${hash}
 ${result.brief}`;
-  const url = deps.postMarkedComment("issue", String(n), AEG_BRIEF_V1_MARKER, commentBody);
+  const url = deps.postMarkedComment("issue", String(issue), AEG_BRIEF_V1_MARKER, commentBody);
   if (agent) {
-    const dispatchRole2 = await deps.resolveDispatchRole();
     if (dispatchRole2) {
-      await withPromptFile(result.brief, (promptFile) => dispatchRole2("developer", agent, result.brief, { task: n, promptFile }));
+      await withPromptFile(result.brief, (promptFile) => dispatchRole2("developer", agent, result.brief, {
+        task: issue,
+        promptFile,
+        model: resolvedModel
+      }));
     } else {
       printManualDispatchInstruction(tranche, n, agent);
     }
@@ -12385,14 +12926,123 @@ function renderReviewerPrompt(facts) {
 function outboxRoot() {
   return join18(GLOBAL_VINAYA_HOME, "outbox");
 }
+function heldVerdictPath(root, task, round, role) {
+  return join18(root, "dev-review-loop", String(task), `round-${round}-${role}.md`);
+}
 function writeHeldVerdict(root, task, round, role, renderedComment) {
   const dir = join18(root, "dev-review-loop", String(task));
-  mkdirSync4(dir, { recursive: true });
-  writeFileSync8(join18(dir, `round-${round}-${role}.md`), renderedComment, "utf8");
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync9(heldVerdictPath(root, task, round, role), renderedComment, "utf8");
 }
 function reviewerWorkDir(root, task, round, role) {
   return join18(root, "dev-review-loop", String(task), `round-${round}-${role}-work`);
 }
+function forgeEffectPath(root, task, key) {
+  return join18(root, "dev-review-loop", String(task), `effect-${key}.json`);
+}
+function readForgeEffect(path) {
+  const raw = readIfExists(path);
+  if (!raw)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeForgeEffect(path, record) {
+  mkdirSync5(dirname8(path), { recursive: true });
+  writeFileSync9(path, JSON.stringify(record), "utf8");
+}
+function postForgeEffectOnce(root, task, key, poster) {
+  const path = forgeEffectPath(root, task, key);
+  const existing = readForgeEffect(path);
+  if (existing?.status === "posted" && existing.url)
+    return existing.url;
+  const effectId = existing?.effectId ?? randomUUID3();
+  writeForgeEffect(path, { effectId, status: "started" });
+  const url = poster();
+  writeForgeEffect(path, { effectId, status: "posted", url });
+  return url;
+}
+function postPrComment(pr, body) {
+  const dir = mkdtempSync3(join18(tmpdir4(), "vinaya-dev-review-loop-comment-"));
+  const tmp = join18(dir, "comment.md");
+  writeFileSync9(tmp, body, "utf8");
+  try {
+    return execFileSync17("gh", ["pr", "comment", String(pr), "--body-file", tmp], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } finally {
+    rmSync6(dir, { recursive: true, force: true });
+  }
+}
+function fetchAllPrCommentBodies(pr) {
+  const out = sh4("gh", ["pr", "view", String(pr), "--json", "comments"]);
+  return principalBodies(markerComments(out), principalAllowlist());
+}
+function publishRound(root, input) {
+  const { task, round, prNumber, expectedHead } = input;
+  const reviewerBody = readIfExists(heldVerdictPath(root, task, round, "reviewer"));
+  const securityBody = readIfExists(heldVerdictPath(root, task, round, "security"));
+  if (!reviewerBody || !securityBody) {
+    throw new Error(`publishRound: missing held verdict file(s) for task ${task} round ${round} — writeHeldVerdict should have written both before assessRound ever returned 'publish'.`);
+  }
+  postForgeEffectOnce(root, task, `${round}-reviewer-verdict`, () => postPrComment(prNumber, reviewerBody));
+  const postedReviewer = extractCodeReviewVerdict(fetchAllPrCommentBodies(prNumber));
+  if (postedReviewer.danglingNote || postedReviewer.headSha !== expectedHead) {
+    throw new Error(`publishRound: posted reviewer verdict does not re-parse clean through extractCodeReviewVerdict bound to ${expectedHead}: ${postedReviewer.danglingNote ?? `headSha read back as ${String(postedReviewer.headSha)}`}`);
+  }
+  postForgeEffectOnce(root, task, `${round}-security-verdict`, () => postPrComment(prNumber, securityBody));
+  const postedSecurity = extractSecurityReviewVerdict(fetchAllPrCommentBodies(prNumber));
+  if (postedSecurity.danglingNote || postedSecurity.headSha !== expectedHead) {
+    throw new Error(`publishRound: posted security verdict does not re-parse clean through extractSecurityReviewVerdict bound to ${expectedHead}: ${postedSecurity.danglingNote ?? `headSha read back as ${String(postedSecurity.headSha)}`}`);
+  }
+  const summary = renderSummary(input.journal);
+  const summaryAsCodeReview = extractCodeReviewVerdict([summary]);
+  const summaryAsSecurity = extractSecurityReviewVerdict([summary]);
+  if (summaryAsCodeReview.danglingNote === null || summaryAsSecurity.danglingNote === null) {
+    throw new Error("publishRound: the rendered summary re-parses as a real verdict through the gate's own extractors — refusing to post it (a summary mistaken for a verdict decides a merge).");
+  }
+  postForgeEffectOnce(root, task, `${round}-summary`, () => postPrComment(prNumber, summary));
+}
+function pauseMarker(reason) {
+  return `<!-- aeg:loop:paused:${reason} -->`;
+}
+function renderPauseComment(prNumber, reason) {
+  return [
+    `The dev-review-loop paused: ${reason}.`,
+    "",
+    "A Principal ruling is needed before this can continue. Once one is posted on this PR, resume with:",
+    "",
+    "```",
+    `vinaya dev-review-loop --resume ${prNumber}`,
+    "```"
+  ].join(`
+`);
+}
+function postPauseComment(root, task, round, head, prNumber, reason) {
+  postForgeEffectOnce(root, task, `pause-${round}-${head}`, () => postMarkedComment("pr", String(prNumber), pauseMarker(reason), renderPauseComment(prNumber, reason)));
+}
+function pauseStatePath(root, task) {
+  return join18(root, "dev-review-loop", String(task), "pause-state.json");
+}
+function writePauseState(root, state) {
+  const path = pauseStatePath(root, state.task);
+  mkdirSync5(dirname8(path), { recursive: true });
+  writeFileSync9(path, JSON.stringify(state), "utf8");
+}
+function readPauseState(root, task) {
+  const raw = readIfExists(pauseStatePath(root, task));
+  if (!raw)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 var CONFIDENCE_PROMPT_LINE = "Before ending this turn, write your confidence in this round's changes to a file named `.vinaya-confidence` at the root of your worktree, containing exactly one line: `CONFIDENCE: <0-100> — <one-sentence reason>` (a whole number from 0 to 100, an em dash, then your reason in one sentence). This is read by the review loop before it decides the next step — do not skip it.";
 var CONFIDENCE_LINE = /^CONFIDENCE:\s*(\d{1,3})\s*(?:—|-)\s*(.+)$/m;
 function parseConfidenceReply(replyText) {
@@ -12430,7 +13080,7 @@ function readIfExists(path) {
 function withPromptFile2(prompt2, fn) {
   const dir = mkdtempSync3(join18(tmpdir4(), "vinaya-dev-review-loop-prompt-"));
   const promptFile = join18(dir, "prompt.md");
-  writeFileSync8(promptFile, prompt2, "utf8");
+  writeFileSync9(promptFile, prompt2, "utf8");
   try {
     return fn(promptFile);
   } finally {
@@ -12675,18 +13325,66 @@ function renderReviewerDispatchPrompt(role, facts, workDir) {
 
 ${instructions}`;
 }
+function taskFromPrBody(body) {
+  const m = /Closes #(\d+)/i.exec(body);
+  return m ? Number(m[1]) : null;
+}
+function fetchPrBody2(pr) {
+  const out = sh4("gh", ["pr", "view", String(pr), "--json", "body"]);
+  return JSON.parse(out).body;
+}
+function routeCompletionEvents(events, decisionType) {
+  if (decisionType !== "publish")
+    return { toLogNow: [...events], toDeferUntilPublish: [] };
+  return {
+    toLogNow: events.filter((e) => e.event !== "journal_finalized"),
+    toDeferUntilPublish: events.filter((e) => e.event === "journal_finalized")
+  };
+}
 async function devReviewLoop(input, deps = {}) {
   const d = { ...defaultDeps3(), ...deps };
+  const root = d.outboxRoot();
+  let task;
+  let branch;
+  let prNumber = -1;
+  let resumeFrom = null;
+  if ("resumePr" in input) {
+    const resumePr = input.resumePr;
+    const closesTask = taskFromPrBody(fetchPrBody2(resumePr));
+    if (closesTask === null) {
+      throw new Error(`devReviewLoop --resume: PR #${resumePr}'s body carries no \`Closes #N\` reference — cannot derive its task.`);
+    }
+    const held = readPauseState(root, closesTask);
+    if (!held) {
+      throw new Error(`devReviewLoop --resume: no held pause state found for task ${closesTask} (PR #${resumePr}) — nothing to resume.`);
+    }
+    if (held.prNumber !== resumePr) {
+      throw new Error(`devReviewLoop --resume: task ${closesTask}'s held pause state names PR #${held.prNumber}, not PR #${resumePr}.`);
+    }
+    const rulings = d.fetchRulings(resumePr);
+    if (rulings.length === 0) {
+      throw new Error(`devReviewLoop --resume: PR #${resumePr} carries no Principal ruling comment yet — nothing to resume from.`);
+    }
+    const currentHead = d.resolveHead(held.branch);
+    if (currentHead !== held.head) {
+      throw new Error(`devReviewLoop --resume: PR #${resumePr}'s head has moved since it paused (paused at ${held.head}, now ${currentHead}) — restart from round ${held.round} against the new head; resume never silently replays from round 1.`);
+    }
+    task = held.task;
+    branch = held.branch;
+    prNumber = held.prNumber;
+    resumeFrom = held;
+  } else {
+    task = input.task;
+    branch = d.developerBranchFor(task);
+  }
   const { log: log2, runId } = createLogSink();
   if (!process.env.VINAYA_RUN_ID)
     process.env.VINAYA_RUN_ID = runId;
-  process.env.VINAYA_TASK = String(input.task);
+  process.env.VINAYA_TASK = String(task);
   const repo = await resolveRepo().catch(() => null);
-  const branch = d.developerBranchFor(input.task);
-  const root = d.outboxRoot();
   const repoRoot2 = d.repoRoot();
   const confidenceFilePath = join18(repoRoot2, ".worktrees", branch, CONFIDENCE_FILE_NAME);
-  const loopOutboxPath = outboxPathFor({ outboxRoot: () => root }, repo, input.task);
+  const loopOutboxPath = outboxPathFor({ outboxRoot: () => root }, repo, task);
   async function logEvents(events) {
     for (const e of events) {
       const priorSize = sizeOfSafe2(loopOutboxPath);
@@ -12696,20 +13394,20 @@ async function devReviewLoop(input, deps = {}) {
   }
   const config = {
     loopId: randomUUID3(),
-    task: input.task,
+    task,
     reviewers: ["code-reviewer", "security"],
     models: { developer: input.agent, "code-reviewer": input.agent, security: input.agent }
   };
   let state = initialLoopState(config);
-  let round = 1;
+  let round = resumeFrom ? resumeFrom.round : 1;
   let devResumeId = null;
   let devDispatchSucceededBefore = false;
-  let prNumber = -1;
   let lastReviewContext = null;
+  let resumedDispatch = resumeFrom !== null;
   async function dispatchDeveloper(prompt2, roundNum) {
     const isResume = devResumeId !== null;
     const handle = await withPromptFile2(prompt2, (promptFile) => d.dispatchRole("developer", input.agent, prompt2, {
-      task: input.task,
+      task,
       round: roundNum,
       resumeId: devResumeId ?? undefined,
       promptFile
@@ -12723,14 +13421,14 @@ async function devReviewLoop(input, deps = {}) {
     return handle;
   }
   async function dispatchReviewer(role, roundNum, facts) {
-    const workDir = reviewerWorkDir(root, input.task, roundNum, role);
-    mkdirSync4(workDir, { recursive: true });
+    const workDir = reviewerWorkDir(root, task, roundNum, role);
+    mkdirSync5(workDir, { recursive: true });
     const dispatchRoleName = role === "reviewer" ? "code-reviewer" : "security";
     const prompt2 = renderReviewerDispatchPrompt(role, facts, workDir);
-    const handle = await withPromptFile2(prompt2, (promptFile) => d.dispatchRole(dispatchRoleName, input.agent, prompt2, { task: input.task, round: roundNum, promptFile }));
+    const handle = await withPromptFile2(prompt2, (promptFile) => d.dispatchRole(dispatchRoleName, input.agent, prompt2, { task, round: roundNum, promptFile }));
     await assertDispatchOrEscalate(handle, input.agent, false, false);
-    const parsed = buildVerdictFromReport(role, workDir, facts.head, input.agent, input.task, handle);
-    writeHeldVerdict(root, input.task, roundNum, role, parsed.rendered);
+    const parsed = buildVerdictFromReport(role, workDir, facts.head, input.agent, task, handle);
+    writeHeldVerdict(root, task, roundNum, role, parsed.rendered);
     return parsed;
   }
   function computeStats(head, roundStartMs2) {
@@ -12754,18 +13452,27 @@ async function devReviewLoop(input, deps = {}) {
     } catch {}
     return content ? parseConfidenceReply(content) : "absent";
   }
-  const roundStart0 = d.now();
-  const brief = d.fetchFrozenBrief(input.task);
-  await dispatchDeveloper(brief, round);
-  prNumber = await pollUntil(() => d.findOpenPrForBranch(branch), d.prPollMaxAttempts, d.prPollIntervalMs, d.sleep, `devReviewLoop: no open PR appeared for branch \`${branch}\` within the poll budget.`).then((pr) => pr.number);
+  let roundStartMs = d.now();
+  if (resumeFrom) {
+    const rulings = d.fetchRulings(prNumber);
+    lastReviewContext = rulings.map((r, i) => `${i + 1}. ${r}`).join(`
+`);
+  } else {
+    const brief = d.fetchFrozenBrief(task);
+    await dispatchDeveloper(brief, round);
+    prNumber = await pollUntil(() => d.findOpenPrForBranch(branch), d.prPollMaxAttempts, d.prPollIntervalMs, d.sleep, `devReviewLoop: no open PR appeared for branch \`${branch}\` within the poll budget.`).then((pr) => pr.number);
+  }
   let decision = { type: "dispatch_developer" };
-  let roundStartMs = roundStart0;
-  let firstPass = true;
+  let firstPass = !resumeFrom;
+  let pendingCompletionEvents = [];
   while (true) {
     if (decision.type === "dispatch_developer") {
       if (!firstPass) {
         const prompt2 = [
-          lastReviewContext ? `Round ${round} review findings:
+          resumedDispatch ? `Principal ruling on this pause:
+
+${lastReviewContext}
+` : lastReviewContext ? `Round ${round} review findings:
 
 ${lastReviewContext}
 ` : "CI was red on the last head — fix and push.",
@@ -12776,6 +13483,7 @@ ${lastReviewContext}
 `);
         roundStartMs = d.now();
         await dispatchDeveloper(prompt2, round);
+        resumedDispatch = false;
       }
       firstPass = false;
       const gate = await waitForGreenGate(roundStartMs);
@@ -12785,7 +13493,7 @@ ${lastReviewContext}
       state = result.state;
       decision = result.decision;
       await logEvents(result.events);
-      d.flushOutbox(input.task);
+      d.flushOutbox(task);
     } else if (decision.type === "ask_confidence") {
       const reaskPrompt = `Your last reply did not include a valid confidence line.
 
@@ -12799,11 +13507,11 @@ ${CONFIDENCE_PROMPT_LINE}`;
       state = result.state;
       decision = result.decision;
       await logEvents(result.events);
-      d.flushOutbox(input.task);
+      d.flushOutbox(task);
     } else if (decision.type === "dispatch_reviewers") {
       const head = d.resolveHead(branch);
       const ciConclusion = d.fetchCiConclusion(head);
-      const objectives = d.fetchIssueObjectives(input.task);
+      const objectives = d.fetchIssueObjectives(task);
       const rulings = d.fetchRulings(prNumber);
       const facts = { objectives, rulings, head, ciConclusion };
       const [reviewer, security] = await Promise.all([
@@ -12819,14 +13527,39 @@ ${security.rendered}`;
       const result = assessRound(state, obs);
       state = result.state;
       decision = result.decision;
-      await logEvents(result.events);
-      d.flushOutbox(input.task);
+      const routed = routeCompletionEvents(result.events, decision.type);
+      pendingCompletionEvents = routed.toDeferUntilPublish;
+      await logEvents(routed.toLogNow);
+      d.flushOutbox(task);
       if (decision.type === "dispatch_developer")
         round += 1;
     }
-    if (decision.type === "publish" || decision.type === "pause") {
-      d.flushOutbox(input.task);
-      return { finalDecision: decision, prNumber };
+    if (decision.type === "publish") {
+      publishRound(root, {
+        task,
+        round,
+        prNumber,
+        expectedHead: d.resolveHead(branch),
+        journal: { rounds: state.rounds }
+      });
+      await logEvents(pendingCompletionEvents);
+      d.flushOutbox(task);
+      return { finalDecision: decision, prNumber, task };
+    }
+    if (decision.type === "pause") {
+      const pauseHead = d.resolveHead(branch);
+      writePauseState(root, {
+        task,
+        round,
+        head: pauseHead,
+        branch,
+        prNumber,
+        reason: decision.reason,
+        pausedAt: new Date().toISOString()
+      });
+      postPauseComment(root, task, round, pauseHead, prNumber, decision.reason);
+      d.flushOutbox(task);
+      return { finalDecision: decision, prNumber, task };
     }
   }
 }
@@ -12834,27 +13567,24 @@ ${security.rendered}`;
 // src/commands/dev-review-loop.ts
 function parseArgs2(args) {
   let task;
+  let resumePr;
   let agent;
   let json = false;
   for (let i = 0;i < args.length; i++) {
     const a = args[i];
     if (a === "--task")
       task = Number(args[++i]);
+    else if (a === "--resume")
+      resumePr = Number(args[++i]);
     else if (a === "--agent")
       agent = args[++i];
     else if (a === "--json")
       json = true;
   }
-  return { task, agent, json };
+  return { task, resumePr, agent, json };
 }
 async function devReviewLoopCommand(args) {
   const parsed = parseArgs2(args);
-  if (parsed.task === undefined || !Number.isInteger(parsed.task) || parsed.task <= 0) {
-    process.stderr.write(`vinaya dev-review-loop: --task <n> is required (a positive integer Issue number)
-`);
-    process.exit(1);
-  }
-  const task = parsed.task;
   const agentRaw = parsed.agent ?? loadConfig()?.dispatch?.agent;
   if (!agentRaw) {
     process.stderr.write(`vinaya dev-review-loop: --agent <claude|codex|gemini> is required (or set dispatch.agent in vinaya.config.json)
@@ -12867,16 +13597,34 @@ async function devReviewLoopCommand(args) {
     process.exit(1);
   }
   const agent = agentRaw;
-  const result = await devReviewLoop({ task, agent });
+  let input;
+  if (parsed.resumePr !== undefined) {
+    if (!Number.isInteger(parsed.resumePr) || parsed.resumePr <= 0) {
+      process.stderr.write(`vinaya dev-review-loop: --resume <pr> requires a positive integer PR number
+`);
+      process.exit(1);
+    }
+    input = { resumePr: parsed.resumePr, agent };
+  } else {
+    if (parsed.task === undefined || !Number.isInteger(parsed.task) || parsed.task <= 0) {
+      process.stderr.write(`vinaya dev-review-loop: --task <n> is required (a positive integer Issue number)
+`);
+      process.exit(1);
+    }
+    input = { task: parsed.task, agent };
+  }
+  const result = await devReviewLoop(input);
   if (parsed.json) {
-    printJson({ finalDecision: result.finalDecision, prNumber: result.prNumber });
+    printJson({ finalDecision: result.finalDecision, prNumber: result.prNumber, task: result.task });
   } else if (result.finalDecision.type === "publish") {
-    process.stdout.write(`vinaya dev-review-loop: task ${task}, PR #${result.prNumber} — publish
+    process.stdout.write(`vinaya dev-review-loop: task ${result.task}, PR #${result.prNumber} — publish
 `);
   } else if (result.finalDecision.type === "pause") {
-    process.stdout.write(`vinaya dev-review-loop: task ${task}, PR #${result.prNumber} — paused (${result.finalDecision.reason})
+    process.stdout.write(`vinaya dev-review-loop: task ${result.task}, PR #${result.prNumber} — paused (${result.finalDecision.reason})
 `);
   }
+  if (result.finalDecision.type === "pause")
+    process.exit(1);
 }
 
 // src/commands/dispatch.ts
@@ -12884,8 +13632,8 @@ import { readFileSync as readFileSync19 } from "node:fs";
 
 // src/commands/log.ts
 import { execFileSync as execFileSync18 } from "node:child_process";
-import { lstatSync, readFileSync as readFileSync18, statSync as statSync2, writeFileSync as writeFileSync9, rmSync as rmSync7 } from "node:fs";
-import { homedir as homedir3, tmpdir as tmpdir5 } from "node:os";
+import { lstatSync, readFileSync as readFileSync18, statSync as statSync2, writeFileSync as writeFileSync10, rmSync as rmSync7 } from "node:fs";
+import { homedir as homedir4, tmpdir as tmpdir5 } from "node:os";
 import { join as join19 } from "node:path";
 var FORGE_COMMENT_MAX_CHARS = 65536;
 function isEnoent2(err) {
@@ -12956,7 +13704,7 @@ function refuse22(error) {
   process.exit(2);
 }
 var SAFE_PATH_SEGMENT2 = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
-function isSafeRepoSegment2(segment) {
+function isSafeRepoSegment3(segment) {
   return SAFE_PATH_SEGMENT2.test(segment) && !segment.includes("..");
 }
 function outboxPathFor2(deps, target) {
@@ -12989,7 +13737,7 @@ function parseOutboxLine(raw, index) {
   if (!result.success) {
     throw new CorruptOutboxLineError(index, result.error.issues[0]?.message ?? "schema violation");
   }
-  const redacted = redact(result.data, homedir3());
+  const redacted = redact(result.data, homedir4());
   return { postLine: JSON.stringify(redacted), runId: redacted.meta.run_id, seq: redacted.meta.seq };
 }
 function renderChunk(runId, seqFrom, seqTo, postLines) {
@@ -13062,7 +13810,7 @@ function issueFromPr(prNumber) {
 }
 function postChunk(op, targetId, body, index) {
   const tmp = join19(tmpdir5(), `vinaya-log-flush-${process.pid}-${Date.now()}-${index}.md`);
-  writeFileSync9(tmp, body, { flag: "wx" });
+  writeFileSync10(tmp, body, { flag: "wx" });
   try {
     const out = op === "pr.comment" ? gh2(["pr", "comment", targetId, "--body-file", tmp]) : gh2(["issue", "comment", targetId, "--body-file", tmp]);
     const match = /#issuecomment-(\d+)/.exec(out);
@@ -13104,7 +13852,7 @@ async function logFlushCommand(args) {
   const target = parsed.pr !== undefined ? { pr: parsed.pr } : { issue: issueNumber };
   const forgeTargetId = parsed.pr !== undefined ? String(parsed.pr) : String(issueNumber);
   const resolved = await resolveRepo();
-  const repo = resolved && isSafeRepoSegment2(resolved.owner) && isSafeRepoSegment2(resolved.repo) ? resolved : null;
+  const repo = resolved && isSafeRepoSegment3(resolved.owner) && isSafeRepoSegment3(resolved.repo) ? resolved : null;
   const outboxRoot2 = () => join19(GLOBAL_VINAYA_HOME, "outbox");
   const path = outboxPathFor2({ outboxRoot: outboxRoot2, repo }, { issue: issueNumber });
   let lstat;
@@ -13185,7 +13933,7 @@ async function logFlushCommand(args) {
 `).join("");
   const liveNow = readFileSync18(path);
   const tail = liveNow.subarray(Math.min(startOffset, liveNow.byteLength));
-  writeFileSync9(path, Buffer.concat([Buffer.from(unposted, "utf8"), tail]));
+  writeFileSync10(path, Buffer.concat([Buffer.from(unposted, "utf8"), tail]));
   if (!finalLanded) {
     emitCheckError({
       schema: CHECK_SCHEMA_VERSION,
@@ -13210,6 +13958,7 @@ async function logFlushCommand(args) {
 function parseArgs4(args) {
   const role = args[0];
   let agent;
+  let model;
   let promptFile;
   let task;
   let pr;
@@ -13220,6 +13969,8 @@ function parseArgs4(args) {
     const a = args[i];
     if (a === "--agent")
       agent = args[++i];
+    else if (a === "--model")
+      model = args[++i];
     else if (a === "--prompt-file")
       promptFile = args[++i];
     else if (a === "--task")
@@ -13233,7 +13984,7 @@ function parseArgs4(args) {
     else if (a === "--json")
       json = true;
   }
-  return { role, agent, promptFile, task, pr, round, resume, json };
+  return { role, agent, model, promptFile, task, pr, round, resume, json };
 }
 async function dispatchCommand(args) {
   const parsed = parseArgs4(args);
@@ -13280,6 +14031,7 @@ async function dispatchCommand(args) {
     pr: parsed.pr,
     round: parsed.round,
     resumeId: parsed.resume,
+    model: parsed.model,
     promptFile
   });
   if (parsed.json) {
@@ -13452,8 +14204,8 @@ function envDeclarationWarning(name) {
 }
 
 // src/lib/registry-write.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync22, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname7, join as join21 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync22, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname9, join as join21 } from "node:path";
 var PROJECTS_REGISTRY_PATH = ".vinaya/projects.md";
 var CONFIG_FILE_PATH = "vinaya.config.json";
 function rowLine(name, path, specsPath) {
@@ -13531,11 +14283,11 @@ function planRegistryRow(repoRoot2, name, path, specsPath) {
 function applyRegistryRow(repoRoot2, plan, name, path, specsPath) {
   const abs2 = join21(repoRoot2, PROJECTS_REGISTRY_PATH);
   if (plan.action === "create-host") {
-    mkdirSync5(dirname7(abs2), { recursive: true });
-    writeFileSync10(abs2, freshProjectsRegistry(name, path, specsPath), "utf-8");
+    mkdirSync6(dirname9(abs2), { recursive: true });
+    writeFileSync11(abs2, freshProjectsRegistry(name, path, specsPath), "utf-8");
   } else if (plan.action === "append-row") {
     const existing = readFileSync22(abs2, "utf-8");
-    writeFileSync10(abs2, appendRegistryRow(existing, name, path, specsPath), "utf-8");
+    writeFileSync11(abs2, appendRegistryRow(existing, name, path, specsPath), "utf-8");
   }
 }
 function renderRegistryRowDiffLine(plan) {
@@ -13567,7 +14319,7 @@ function applyConfigProjectEntry(repoRoot2, plan) {
   const abs2 = join21(repoRoot2, CONFIG_FILE_PATH);
   const seed = JSON.parse(readFileSync22(abs2, "utf-8"));
   const projects = Array.isArray(seed.projects) ? seed.projects : [];
-  writeFileSync10(abs2, `${JSON.stringify({ ...seed, projects: [...projects, plan.entry] }, null, 2)}
+  writeFileSync11(abs2, `${JSON.stringify({ ...seed, projects: [...projects, plan.entry] }, null, 2)}
 `, "utf-8");
 }
 function renderConfigProjectEntryDiffLine(plan) {
@@ -14188,7 +14940,7 @@ async function ejectCommand(args) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync17, readFileSync as readFileSync25, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync25, writeFileSync as writeFileSync12 } from "node:fs";
 import { join as join24 } from "node:path";
 function realDeps6() {
   return {
@@ -14241,7 +14993,7 @@ function readManifest3(repoRoot2) {
 function writeManifest(repoRoot2, manifest) {
   const configAbs = join24(repoRoot2, CONFIG_PATH);
   const seed = JSON.parse(readFileSync25(configAbs, "utf-8"));
-  writeFileSync11(configAbs, `${JSON.stringify({ ...seed, managed: manifest }, null, 2)}
+  writeFileSync12(configAbs, `${JSON.stringify({ ...seed, managed: manifest }, null, 2)}
 `, "utf-8");
 }
 async function runInit(args, deps) {
@@ -14457,7 +15209,7 @@ function issueEditCommand(args) {
 
 // src/commands/issue-objectives.ts
 import { execFileSync as execFileSync20 } from "node:child_process";
-import { mkdtempSync as mkdtempSync4, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "node:fs";
+import { mkdtempSync as mkdtempSync4, rmSync as rmSync8, writeFileSync as writeFileSync13 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
 import { join as join25 } from "node:path";
 var RETRY = 'vinaya issue objectives edit <n> --add "<sentence>" | --drop O<k> | --replace O<k> "<sentence>" --reason "<text>"';
@@ -14592,7 +15344,7 @@ function issueObjectivesEditCommand(args) {
   const newBody = spliceObjectivesSection(body, renderObjectives(updated));
   const dir = mkdtempSync4(join25(tmpdir6(), "vinaya-objectives-edit-"));
   const tmp = join25(dir, "body.md");
-  writeFileSync12(tmp, newBody, "utf8");
+  writeFileSync13(tmp, newBody, "utf8");
   try {
     const ghArgs = ["--body-file", tmp];
     writeValidatedIssueEdit({
@@ -15007,7 +15759,7 @@ async function milestoneCloseCommand(args) {
 }
 
 // src/commands/new-check.ts
-import { chmodSync as chmodSync2, existsSync as existsSync18, mkdirSync as mkdirSync6, readFileSync as readFileSync26, writeFileSync as writeFileSync13 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync26, writeFileSync as writeFileSync14 } from "node:fs";
 import { join as join26 } from "node:path";
 var TEMPLATE_PATH2 = join26(packageRoot(import.meta.url), "templates", "custom-check.template.ts");
 var CHECKS_DIR = join26("scripts", "vinaya-checks");
@@ -15029,7 +15781,7 @@ function newCheckCommand(args) {
   }
   const scriptsDir = join26(process.cwd(), CHECKS_DIR);
   if (!existsSync18(scriptsDir))
-    mkdirSync6(scriptsDir, { recursive: true });
+    mkdirSync7(scriptsDir, { recursive: true });
   const fileStem = name.slice(name.indexOf("/") + 1);
   const targetPath = join26(scriptsDir, `${fileStem}.ts`);
   if (existsSync18(targetPath)) {
@@ -15038,8 +15790,8 @@ function newCheckCommand(args) {
   }
   const template = readFileSync26(TEMPLATE_PATH2, "utf-8");
   const contents = template.split("{{CHECK_NAME}}").join(name);
-  writeFileSync13(targetPath, contents, "utf-8");
-  chmodSync2(targetPath, 493);
+  writeFileSync14(targetPath, contents, "utf-8");
+  chmodSync3(targetPath, 493);
   const relPath = join26(CHECKS_DIR, `${fileStem}.ts`);
   const registration = JSON.stringify({ checks: { [name]: { run: `./${relPath}`, scope: "diff" } } }, null, 2);
   process.stdout.write(`Created ${relPath}
@@ -15050,7 +15802,7 @@ ${registration}
 }
 
 // src/commands/new-noop-check.ts
-import { chmodSync as chmodSync3, existsSync as existsSync19, mkdirSync as mkdirSync7, readFileSync as readFileSync27, writeFileSync as writeFileSync14 } from "node:fs";
+import { chmodSync as chmodSync4, existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync27, writeFileSync as writeFileSync15 } from "node:fs";
 import { join as join27 } from "node:path";
 var TEMPLATE_PATH3 = join27(packageRoot(import.meta.url), "templates", "noop-check.template.ts");
 var CHECKS_DIR2 = join27("vinaya", "checks");
@@ -15069,7 +15821,7 @@ function newNoopCheckCommand(args) {
   }
   const checksDir = join27(process.cwd(), CHECKS_DIR2);
   if (!existsSync19(checksDir))
-    mkdirSync7(checksDir, { recursive: true });
+    mkdirSync8(checksDir, { recursive: true });
   const targetPath = join27(checksDir, `${name}.ts`);
   if (existsSync19(targetPath)) {
     console.error(`Error: ${targetPath} already exists.`);
@@ -15077,8 +15829,8 @@ function newNoopCheckCommand(args) {
   }
   const template = readFileSync27(TEMPLATE_PATH3, "utf-8");
   const contents = template.split("{{CHECK_NAME}}").join(name);
-  writeFileSync14(targetPath, contents, "utf-8");
-  chmodSync3(targetPath, 493);
+  writeFileSync15(targetPath, contents, "utf-8");
+  chmodSync4(targetPath, 493);
   const relPath = join27(CHECKS_DIR2, `${name}.ts`);
   const entry2 = {
     run: `./${relPath}`,
@@ -15097,7 +15849,7 @@ ${registration}
 }
 
 // src/commands/new-role.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync8, readFileSync as readFileSync28, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9, readFileSync as readFileSync28, writeFileSync as writeFileSync16 } from "node:fs";
 import { join as join28 } from "node:path";
 var TEMPLATE_PATH4 = join28(packageRoot(import.meta.url), "templates", "role.template.md");
 var ROLES_DIR = join28("vinaya", "roles");
@@ -15115,7 +15867,7 @@ A bare, un-namespaced key resolves as an OVERRIDE of a core role — a complete
   }
   const rolesDir = join28(process.cwd(), ROLES_DIR);
   if (!existsSync20(rolesDir))
-    mkdirSync8(rolesDir, { recursive: true });
+    mkdirSync9(rolesDir, { recursive: true });
   const roleId = name.slice(name.indexOf("/") + 1);
   const targetPath = join28(rolesDir, `${roleId}.md`);
   if (existsSync20(targetPath)) {
@@ -15124,7 +15876,7 @@ A bare, un-namespaced key resolves as an OVERRIDE of a core role — a complete
   }
   const template = readFileSync28(TEMPLATE_PATH4, "utf-8");
   const contents = template.split("{{ROLE_ID}}").join(roleId);
-  writeFileSync15(targetPath, contents, "utf-8");
+  writeFileSync16(targetPath, contents, "utf-8");
   const relPath = join28(ROLES_DIR, `${roleId}.md`);
   const registration = JSON.stringify({ roles: { [name]: { contract: `./${relPath}` } } }, null, 2);
   process.stdout.write(`Created ${relPath}
@@ -15144,8 +15896,8 @@ function summariseNumstat(numstat) {
   let added = 0;
   let deleted = 0;
   let binary = 0;
-  for (const row of rows) {
-    const [a, d] = row.split("\t");
+  for (const row2 of rows) {
+    const [a, d] = row2.split("\t");
     if (a === "-" || d === "-") {
       binary++;
       continue;
@@ -15709,7 +16461,7 @@ function prRuleCommand(args) {
 
 // src/commands/pr-report.ts
 import { execFileSync as execFileSync24, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync21, mkdtempSync as mkdtempSync5, readFileSync as readFileSync30, rmSync as rmSync9, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync21, mkdtempSync as mkdtempSync5, readFileSync as readFileSync30, rmSync as rmSync9, writeFileSync as writeFileSync17 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
 import { join as join29 } from "node:path";
 var EVIDENCE_START = "<!-- AEG:EVIDENCE:START -->";
@@ -16112,7 +16864,7 @@ var USAGE5 = "Usage: vinaya pr report [--write <body-file> | --push <pr>] [--pha
 function ghEditBody(pr, body) {
   const dir = mkdtempSync5(join29(tmpdir7(), "vinaya-pr-report-push-"));
   const tmp = join29(dir, "body.md");
-  writeFileSync16(tmp, body);
+  writeFileSync17(tmp, body);
   try {
     gh3(["pr", "edit", pr, "--body-file", tmp]);
   } finally {
@@ -16208,7 +16960,7 @@ ${USAGE5}`);
       } catch (err) {
         const dir = mkdtempSync5(join29(tmpdir7(), "vinaya-pr-report-push-restore-failed-"));
         const savePath = join29(dir, "pre-edit-body.md");
-        writeFileSync16(savePath, preEditBody);
+        writeFileSync17(savePath, preEditBody);
         console.error(`vinaya pr report: self-verification FAILED on PR ${pushPr} AND the restore of its pre-edit body also failed: ${err instanceof Error ? err.message : String(err)}. PR ${pushPr}'s body may now be corrupted — the pre-edit body was saved to ${savePath}; restore it by hand with \`gh pr edit ${pushPr} --body-file ${savePath}\`.`);
         process.exit(1);
       }
@@ -16241,7 +16993,7 @@ The AEG:EVIDENCE block was still pushed to PR ${pushPr}.`);
       transcriptPath,
       modelOverride
     });
-    writeFileSync16(writePath, composeWrittenBody(existing, result.blockInner, tokens));
+    writeFileSync17(writePath, composeWrittenBody(existing, result.blockInner, tokens));
     if (tokens.collected) {
       process.stdout.write(`Wrote AEG:EVIDENCE and AEG:TOKENS blocks to ${writePath}
 `);
@@ -16440,8 +17192,8 @@ import { existsSync as existsSync23, readFileSync as readFileSync32 } from "node
 import { join as join31 } from "node:path";
 
 // src/lib/doc-owners-write.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync9, readFileSync as readFileSync31, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname8, join as join30 } from "node:path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync10, readFileSync as readFileSync31, writeFileSync as writeFileSync18 } from "node:fs";
+import { dirname as dirname10, join as join30 } from "node:path";
 function bindingLine(glob, pointer) {
   return `${glob}  ${pointer}`;
 }
@@ -16469,11 +17221,11 @@ function planDocOwnersBinding(repoRoot3, glob, pointer) {
 function applyDocOwnersBinding(repoRoot3, plan, glob, pointer) {
   const abs2 = join30(repoRoot3, DOC_OWNERS_PATH);
   if (plan.action === "create-host") {
-    mkdirSync9(dirname8(abs2), { recursive: true });
-    writeFileSync17(abs2, freshDocOwners(glob, pointer), "utf-8");
+    mkdirSync10(dirname10(abs2), { recursive: true });
+    writeFileSync18(abs2, freshDocOwners(glob, pointer), "utf-8");
   } else if (plan.action === "append-row") {
     const existing = readFileSync31(abs2, "utf-8");
-    writeFileSync17(abs2, appendDocOwnersBinding(existing, glob, pointer), "utf-8");
+    writeFileSync18(abs2, appendDocOwnersBinding(existing, glob, pointer), "utf-8");
   }
 }
 function renderDocOwnersBindingDiffLine(plan) {
@@ -17033,7 +17785,7 @@ async function reviewStatusCommand(args) {
 import { execFile as execFile5, spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync24, readFileSync as readFileSync33, renameSync as renameSync2 } from "node:fs";
 import net from "node:net";
-import { dirname as dirname9, join as join32 } from "node:path";
+import { dirname as dirname11, join as join32 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // src/lib/studio-bundle.ts
@@ -17098,7 +17850,7 @@ function resolveStudioTarget(cwd, moduleUrl = import.meta.url) {
     }
     if (existsSync24(join32(dir, ".git")))
       break;
-    const parent = dirname9(dir);
+    const parent = dirname11(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -17189,7 +17941,7 @@ async function taskDispatchCommand(args) {
   const trancheSlug = args[0];
   const taskIdArg = args[1];
   if (!trancheSlug || !taskIdArg || trancheSlug.startsWith("--")) {
-    console.error(`Usage: vinaya task dispatch <tranche> <n> [--agent ${DISPATCH_AGENTS.join(" | ")}]`);
+    console.error(`Usage: vinaya task dispatch <tranche> <n> [--agent ${DISPATCH_AGENTS.join(" | ")}] [--model <name>]`);
     process.exit(2);
   }
   const n = Number.parseInt(taskIdArg, 10);
@@ -17208,7 +17960,17 @@ async function taskDispatchCommand(args) {
     }
     agent = value;
   }
-  const result = await dispatchTask({ tranche: trancheSlug, n, agent });
+  const modelIdx = rest.indexOf("--model");
+  let model;
+  if (modelIdx !== -1) {
+    const value = rest[modelIdx + 1];
+    if (!value) {
+      console.error("--model requires a value");
+      process.exit(2);
+    }
+    model = value;
+  }
+  const result = await dispatchTask({ tranche: trancheSlug, n, agent, model });
   process.stdout.write(`${result.brief}
 `);
   if (result.commentUrl)
@@ -17218,7 +17980,7 @@ Posted: ${result.commentUrl}
 }
 
 // src/commands/upgrade.ts
-import { existsSync as existsSync25, readFileSync as readFileSync34, rmSync as rmSync10, writeFileSync as writeFileSync18 } from "node:fs";
+import { existsSync as existsSync25, readFileSync as readFileSync34, rmSync as rmSync10, writeFileSync as writeFileSync19 } from "node:fs";
 import { join as join33 } from "node:path";
 function realDeps9() {
   return {
@@ -17261,7 +18023,7 @@ function writeManifestVersion(repoRoot3, manifest) {
   const configAbs = join33(repoRoot3, CONFIG_PATH);
   const seed = JSON.parse(readFileSync34(configAbs, "utf-8"));
   const updated = { ...manifest, version: MANAGED_MANIFEST_VERSION };
-  writeFileSync18(configAbs, `${JSON.stringify({ ...seed, managed: updated }, null, 2)}
+  writeFileSync19(configAbs, `${JSON.stringify({ ...seed, managed: updated }, null, 2)}
 `, "utf-8");
 }
 function stripFor(repoRoot3, path, marker, comment) {
@@ -17328,9 +18090,13 @@ function extractWorkflowTrigger(content) {
   const match = content.match(/^on:\r?\n {2}([A-Za-z0-9_]+):/m);
   return match?.[1] ?? null;
 }
-function planUpgrade(ops, repoRoot3, manifest, routing) {
+function planUpgrade(ops, repoRoot3, manifest, routing, staleSkillPaths = []) {
   const entries = [];
-  let hasChanges = routing.arm || routing.migratesManifest || routing.strips.some((s) => s.present);
+  const staleFiles = staleSkillPaths.map((path) => ({
+    path,
+    present: existsSync25(join33(repoRoot3, path))
+  }));
+  let hasChanges = routing.arm || routing.migratesManifest || routing.strips.some((s) => s.present) || staleFiles.some((f) => f.present);
   const ownedFiles = new Set(manifest.files);
   const blockKey = (path, marker) => `${path}::${marker}`;
   const ownedBlocks = new Set(manifest.blocks.map((b) => blockKey(b.path, b.marker)));
@@ -17394,7 +18160,13 @@ function planUpgrade(ops, repoRoot3, manifest, routing) {
     }
   }
   const versionMigration = manifest.version === MANAGED_MANIFEST_VERSION ? null : { from: manifest.version, to: MANAGED_MANIFEST_VERSION };
-  return { entries, routing, versionMigration, hasChanges: hasChanges || versionMigration !== null };
+  return { entries, routing, staleFiles, versionMigration, hasChanges: hasChanges || versionMigration !== null };
+}
+function withoutStaleFiles(manifest, plan) {
+  if (plan.staleFiles.length === 0)
+    return manifest;
+  const stale = new Set(plan.staleFiles.map((f) => f.path));
+  return { ...manifest, files: manifest.files.filter((f) => !stale.has(f)) };
 }
 function withClaudeStopHookRecorded(manifest, plan) {
   let files = manifest.files;
@@ -17419,6 +18191,13 @@ function renderUpgradeDiff(plan) {
     lines.push(`  ~ migrate manifest version ${plan.versionMigration.from} → ${plan.versionMigration.to}`);
     lines.push("");
   }
+  if (plan.staleFiles.length > 0) {
+    lines.push("── Retired role skills ─────────────────────────────");
+    for (const f of plan.staleFiles) {
+      lines.push(f.present ? `  - remove ${f.path} (role retired — its doctrine now refuses)` : `  · gone   ${f.path} (already removed)`);
+    }
+    lines.push("");
+  }
   const r = plan.routing;
   if (r.blockedReason || r.arm || r.migratesManifest || r.strips.length > 0) {
     lines.push("── Hook location ─────────────────────────────");
@@ -17503,7 +18282,7 @@ function regenerateBlock(repoRoot3, op) {
   const content = readFileSync34(abs2, "utf-8");
   const stripped = stripBlockFromContent(content, op.marker, op.comment);
   if (stripped !== null) {
-    writeFileSync18(abs2, stripped.endsWith(`
+    writeFileSync19(abs2, stripped.endsWith(`
 `) ? stripped : `${stripped}
 `, "utf-8");
   }
@@ -17524,6 +18303,13 @@ function applyUpgrade(plan, repoRoot3) {
         regenerateBlock(repoRoot3, e.op);
     }
   }
+  for (const f of plan.staleFiles) {
+    if (!f.present)
+      continue;
+    const abs2 = containedAbs(repoRoot3, f.path);
+    if (abs2 !== null)
+      rmSync10(abs2, { force: true });
+  }
   for (const s of plan.routing.strips) {
     if (!s.present)
       continue;
@@ -17536,7 +18322,7 @@ function applyUpgrade(plan, repoRoot3) {
     if (blockStripLeavesEmpty(stripped))
       rmSync10(abs2, { force: true });
     else
-      writeFileSync18(abs2, stripped.endsWith(`
+      writeFileSync19(abs2, stripped.endsWith(`
 `) ? stripped : `${stripped}
 `, "utf-8");
   }
@@ -17575,7 +18361,9 @@ async function runUpgrade(args, deps) {
     agents: resolveAgentVendors(planManifest)
   };
   const ops = buildInitOps(ctx);
-  const plan = planUpgrade(ops, repo.repoRoot, planManifest, routing);
+  const doctrineRootForStaleSkills = ctx.agents.has("skills") ? resolveDoctrineRoot() : null;
+  const staleSkillPaths = doctrineRootForStaleSkills ? staleAgentSkillPaths(doctrineRootForStaleSkills, planManifest.files) : [];
+  const plan = planUpgrade(ops, repo.repoRoot, planManifest, routing, staleSkillPaths);
   if (!plan.hasChanges) {
     if (routing.blockedReason) {
       process.stdout.write(routing.target === TRACKED_HOOK_DIR ? `Note: core.hooksPath NOT armed — ${routing.blockedReason}.
@@ -17608,7 +18396,7 @@ async function runUpgrade(args, deps) {
   applyUpgrade(plan, repo.repoRoot);
   if (routing.arm)
     await deps.setHooksPath(repo.repoRoot, TRACKED_HOOK_DIR);
-  writeManifestVersion(repo.repoRoot, withClaudeStopHookRecorded(planManifest, plan));
+  writeManifestVersion(repo.repoRoot, withClaudeStopHookRecorded(withoutStaleFiles(planManifest, plan), plan));
   process.stdout.write(`
 Vinaya upgraded.
 `);
@@ -17734,7 +18522,7 @@ Reason: ${reason}`];
 // src/lib/output.ts
 var NAME_COLUMN_WIDTH = 28;
 var PLANNED_MARKER = "[planned — not yet implemented] ";
-function row(indent2, name, description) {
+function row2(indent2, name, description) {
   const padded = name.length >= NAME_COLUMN_WIDTH ? `${name} ` : name.padEnd(NAME_COLUMN_WIDTH);
   return `${indent2}${padded}${description}`;
 }
@@ -17742,9 +18530,9 @@ function printHelp() {
   const lines = ["vinaya — Vinaya CLI", "", "USAGE", "  vinaya <command> [options]", "", "COMMANDS"];
   for (const command of COMMANDS) {
     const marker = command.status === "planned" ? PLANNED_MARKER : "";
-    lines.push(row("  ", command.name, `${marker}${command.description}`));
+    lines.push(row2("  ", command.name, `${marker}${command.description}`));
     for (const flag of command.flags ?? []) {
-      lines.push(row("    ", flag.flag, `${marker}${flag.description}`));
+      lines.push(row2("    ", flag.flag, `${marker}${flag.description}`));
     }
   }
   lines.push("", "Run 'vinaya version' to check what's installed.");
@@ -17754,7 +18542,7 @@ function printHelp() {
 }
 
 // src/index.ts
-var PACKAGE_ROOT = join34(dirname10(fileURLToPath2(import.meta.url)), "..");
+var PACKAGE_ROOT = join34(dirname12(fileURLToPath2(import.meta.url)), "..");
 function readVersion2() {
   const pkg = JSON.parse(readFileSync35(join34(PACKAGE_ROOT, "package.json"), "utf-8"));
   return pkg.version;