@attalabs/vinaya 0.23.0 → 0.24.0

package/studio-standalone/_node_modules/@attalabs/aeg-core/src/doctrine-no-procedures.ts

@@ -0,0 +1,94 @@
+/**
+ * Doctrine-no-procedures sweep (task 10, Issue #385) — task 9's rule that
+ * doctrine prose describes no command sequence, made a check. `roles/*.md`
+ * and `contracts/*.md` explain *what* a command sequence does and *why*;
+ * they are not a runbook a reader executes verbatim, and a copy-pasted
+ * sequence rots the moment the real command changes (found live: two of
+ * this tranche's own PRs were blocked writing exactly this shape after the
+ * rule was already known in prose).
+ *
+ * Zero I/O: every input (file paths + contents) is read by the adapter
+ * (`check-doctrine-no-procedures.ts`) and passed in — same discipline as
+ * `doctrine-portability.ts` beside it.
+ */
+
+import { COMMAND_WORDS, extractFencedBlocks } from './brief-validation'
+import { VENDOR_EXAMPLE_END, VENDOR_EXAMPLE_START } from './doctrine-portability'
+
+export type DoctrineFile = { path: string; content: string }
+export type DoctrineProcedureFinding = { file: string; line: number; message: string }
+
+/**
+ * The one sanctioned fenced home for a real command sequence in doctrine
+ * (`tranche-model.md` §12's `AEG:VENDOR-EXAMPLE` pair) — same markers
+ * `doctrine-portability.ts` exempts from its own vendor-name scan, exported
+ * from there rather than re-declared here. First pair wins, same rule as
+ * every other `AEG:*` anchor consumer.
+ */
+function vendorExampleSpan(content: string): { start: number; end: number } | null {
+  const start = VENDOR_EXAMPLE_START.exec(content)
+  if (!start) return null
+  const afterStart = start.index + start[0].length
+  const end = VENDOR_EXAMPLE_END.exec(content.slice(afterStart))
+  if (!end) return null
+  return { start: start.index, end: afterStart + end.index + end[0].length }
+}
+
+function isCommandLine(line: string): boolean {
+  const word = line.trim().split(/\s+/)[0] ?? ''
+  return (COMMAND_WORDS as readonly string[]).includes(word)
+}
+
+/**
+ * A fence's language tag that reads as shell — the empty tag (` ``` `, most
+ * doctrine command blocks) or an explicit `sh`/`bash`/`shell`/`console`.
+ * Anything else (`ts`, `js`, `yaml`, `json`, …) is a real illustration in
+ * that language, not a command sequence — a two-line ` ```ts ` block with two
+ * `export` statements is TypeScript, not shell, even though `export` is also
+ * a shell builtin (round-2 ruling item 2, found live: this task's own
+ * `brief-validation.ts` excerpt in `state-machine.md` reads exactly this
+ * way). A block outside this set never reaches the command-line count at
+ * all — it is not a candidate, regardless of its content.
+ */
+const SHELL_LANGS: ReadonlySet<string> = new Set(['', 'sh', 'bash', 'shell', 'console'])
+
+function procedureLineNumberAt(content: string, index: number): number {
+  return content.slice(0, index).split('\n').length
+}
+
+/** `aeg-root/templates/**` (or any adopter's `<doctrineRoot>/templates/**`) — worked-example templates that show the vendor-facing PR-report shape and legitimately carry a full command block. */
+function isTemplatePath(path: string): boolean {
+  return /(^|\/)templates\//.test(path)
+}
+
+/**
+ * A fenced block containing two or more lines that each start with a shell
+ * command word is a command sequence, not an illustration — the failure
+ * names it: "this sequence is a `vinaya` command, name it." Exempt: a block
+ * inside the `AEG:VENDOR-EXAMPLE` anchor pair, and any file under a
+ * `templates/` directory.
+ */
+export function checkDoctrineNoProcedures(files: DoctrineFile[]): DoctrineProcedureFinding[] {
+  const findings: DoctrineProcedureFinding[] = []
+
+  for (const file of files) {
+    if (isTemplatePath(file.path)) continue
+    const span = vendorExampleSpan(file.content)
+
+    for (const block of extractFencedBlocks(file.content)) {
+      if (span && block.start >= span.start && block.end <= span.end) continue
+      if (!SHELL_LANGS.has(block.lang)) continue
+
+      const commandLineCount = block.content.split('\n').filter(isCommandLine).length
+      if (commandLineCount >= 2) {
+        findings.push({
+          file: file.path,
+          line: procedureLineNumberAt(file.content, block.start),
+          message: `this fenced block has ${commandLineCount} shell-command lines — this sequence is a \`vinaya\` command, name it (or move it inside the \`AEG:VENDOR-EXAMPLE\` anchor / a \`templates/\` file).`
+        })
+      }
+    }
+  }
+
+  return findings
+}

package/studio-standalone/_node_modules/@attalabs/aeg-core/src/doctrine-portability.ts

@@ -17,10 +17,31 @@
  * from), where a deny-list of "known author-repo prefixes" would fail open
  * on the next unlisted one instead.
  *
+ * **A second, additive dimension (Issue #298): a portable path is not the
+ * only way doctrine couples itself to one vendor.** Prose can name a
+ * specific AI company, product, or agent directly — "Claude Code", "GPT",
+ * "Anthropic" — with no path shape for the path-based predicate above to
+ * even look at. `checkDoctrinePortability` now emits a SECOND finding kind
+ * for exactly that: a fixed vendor-name word list, scanned against prose
+ * (never against code — a masked, `maskCode`-blind scan, the identical
+ * code-recognition grammar `anchored-region.ts` uses for the `AEG:*` PR/Issue
+ * body anchors, imported directly rather than re-implemented), with exactly
+ * ONE standing exemption: text inside a `<!-- AEG:VENDOR-EXAMPLE:START -->` /
+ * `<!-- AEG:VENDOR-EXAMPLE:END -->` pair — doctrine's one sanctioned, fenced
+ * home for naming today's shipped reference host by product name
+ * (`tranche-model.md` §12). A vendor word that is itself part of an
+ * already-portable path citation (`` `.claude/hooks/x.sh` ``, `` `CLAUDE.md` ``)
+ * is not re-flagged here: it is inline code, already masked by `maskCode`
+ * before the word scan ever runs, and the path-shape predicate above already
+ * has an opinion about it. This dimension has no I/O of its own either — same
+ * inputs, same adapter.
+ *
  * Zero I/O: every input (file paths + contents) is read by the adapter and
  * passed in.
  */
 
+import { maskCode } from '@attalabs/aeg-forge-state/strip-code'
+
 export type PortabilitySourceFile = { path: string; content: string }
 
 export type PortabilityFinding = {
@@ -28,6 +49,8 @@ export type PortabilityFinding = {
   line: number
   cited: string
   message: string
+  /** `'path'` — the original non-portable-path predicate. `'vendor-name'` — Issue #298's word-list predicate. */
+  kind: 'path' | 'vendor-name'
 }
 
 /** `aeg-root/**` by default — what this repo's own package ships and every adopter installs read-only. */
@@ -105,6 +128,93 @@ const CITED_PATH_PATTERN = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]*)+$/
  */
 export const NON_PATH_TOP_SEGMENTS: ReadonlySet<string> = new Set(['origin', 'refs', 'HEAD', 'vinaya', 'fix'])
 
+/**
+ * The vendor-name word list (Issue #298's re-count, live at authoring):
+ * every AI company/product/agent name this doctrine's own prose has
+ * actually used, as either the shipped reference host or a peer example —
+ * a real, hardcoded list for this repo's own corpus, not a growable
+ * config surface (brief `fix/doctrine-vendor-neutrality` §10: ship a
+ * reasonable hardcoded list, flag generalization for later). Longest
+ * alternative first ("claude code" before "claude") so a two-word mention
+ * is reported whole rather than as a truncated single-word match followed
+ * by a dangling "code".
+ *
+ * Includes model-TIER names (`opus`/`sonnet`/`haiku`), not just
+ * company/product names — a review round on this task's own PR (#338)
+ * found the first cut missed exactly this class: `brief-authoring/SKILL.md`
+ * and `brief-template.md` named a specific model tier bare, in prose, in
+ * three places the path-shape predicate could never see either. `sonnet`
+ * and `haiku` are ordinary English words outside this domain — a real
+ * false-positive risk for a general-purpose tool, accepted here on the
+ * same "reasonable hardcoded list for this repo's own corpus" basis as the
+ * rest of this list (verified against the live corpus: no non-vendor use
+ * of either word exists in `aeg-root/**` today).
+ */
+const VENDOR_NAME_SOURCE =
+  '\\bclaude code\\b|\\bclaude\\b|\\banthropic\\b|\\bchatgpt\\b|\\bopenai\\b|\\bgpt\\b|\\bgemini\\b|\\bcodex\\b|\\bgrok\\b|\\bdeepseek\\b|\\bopus\\b|\\bsonnet\\b|\\bhaiku\\b'
+
+/**
+ * Exported (alongside `VENDOR_EXAMPLE_END` below) so `doctrine-no-procedures.ts`
+ * can find the same fenced home's raw-text span — never a second copy of this
+ * pattern — to exempt a fenced block that sits inside it, the same way this
+ * file exempts the region from its own vendor-name word scan.
+ */
+export const VENDOR_EXAMPLE_START = /<!--\s*AEG:VENDOR-EXAMPLE:START\s*-->/
+export const VENDOR_EXAMPLE_END = /<!--\s*AEG:VENDOR-EXAMPLE:END\s*-->/
+
+/**
+ * Blanks (same-length, index-preserving — same discipline as `maskCode`
+ * itself) the region between the first well-formed
+ * `<!-- AEG:VENDOR-EXAMPLE:START -->` … `<!-- AEG:VENDOR-EXAMPLE:END -->`
+ * pair in `masked` — doctrine's one sanctioned home for naming today's
+ * shipped reference host by product name (`tranche-model.md` §12).
+ * Markers are searched on already-`maskCode`d text, the same order
+ * `anchoredRegionBounds` searches the `AEG:*` PR/Issue-body anchors, so a
+ * decoy pair quoted inside a fenced example never wins. A START with no
+ * following END is not a fence at all — the same "malformed half-pair is no
+ * anchor" rule `anchored-region.ts` applies.
+ *
+ * **First pair wins, same as `anchoredRegionBounds` — a SECOND pair in the
+ * same file is not masked.** By design there is exactly one fenced home in
+ * the whole doctrine tree (the Goal this check exists to hold), so a
+ * second pair anywhere is itself a doctrine defect, not a shape this
+ * function needs to accommodate; scanning per-file rather than per-pair
+ * keeps that failure visible (a second, unmasked pair still reports its
+ * own `vendor-name` findings) instead of silently exempting it too.
+ */
+function maskVendorExampleRegion(masked: string): string {
+  const start = VENDOR_EXAMPLE_START.exec(masked)
+  if (!start) return masked
+  const afterStart = start.index + start[0].length
+  const end = VENDOR_EXAMPLE_END.exec(masked.slice(afterStart))
+  if (!end) return masked
+  const regionEnd = afterStart + end.index + end[0].length
+  const region = masked.slice(start.index, regionEnd)
+  const blanked = region.replace(/[^\n]/g, ' ')
+  return masked.slice(0, start.index) + blanked + masked.slice(regionEnd)
+}
+
+/**
+ * Every vendor-name-list match in `content`, code-blind (`maskCode`, the
+ * same grammar `anchored-region.ts` uses) and blind to the one fenced
+ * `AEG:VENDOR-EXAMPLE` home. A vendor word that is only part of an
+ * already-portable inline-code path citation (`` `.claude/hooks/x.sh` ``,
+ * `` `CLAUDE.md` ``) never reaches this scan at all — it is masked before
+ * the word list ever runs, the same way a fenced worked example is blind to
+ * `body-bare-digits`.
+ */
+function extractVendorMentions(content: string): { name: string; index: number }[] {
+  const scoped = maskVendorExampleRegion(maskCode(content))
+  const found: { name: string; index: number }[] = []
+  const pattern = new RegExp(VENDOR_NAME_SOURCE, 'gi')
+  let match: RegExpExecArray | null = pattern.exec(scoped)
+  while (match !== null) {
+    found.push({ name: match[0], index: match.index })
+    match = pattern.exec(scoped)
+  }
+  return found
+}
+
 /** Every inline-backtick span in `content`, tested against `CITED_PATH_PATTERN`. */
 function extractCitedPaths(content: string): { cited: string; index: number }[] {
   const found: { cited: string; index: number }[] = []
@@ -140,10 +250,12 @@ function isPortable(cited: string, shipsPrefix: string): boolean {
 }
 
 /**
- * Sweeps every file under `shipsPrefix` for a cited path whose top segment
- * is not allow-listed portable. Files outside `shipsPrefix` are out of
- * scope entirely — this check only judges what the shipped doctrine tree
- * itself cites, never a repo's other source.
+ * Sweeps every file under `shipsPrefix` for two independent finding kinds:
+ * a cited path whose top segment is not allow-listed portable (`'path'`),
+ * and a vendor-name-list word used in prose outside the one fenced
+ * `AEG:VENDOR-EXAMPLE` home (`'vendor-name'`, Issue #298). Files outside
+ * `shipsPrefix` are out of scope entirely — this check only judges what the
+ * shipped doctrine tree itself cites/names, never a repo's other source.
  */
 export function checkDoctrinePortability(
   files: readonly PortabilitySourceFile[],
@@ -161,7 +273,18 @@ export function checkDoctrinePortability(
         file: file.path,
         line: lineAtIndex(file.content, index),
         cited,
-        message: `cites "${cited}", a path that only exists in the authoring repository — not portable doctrine`
+        message: `cites "${cited}", a path that only exists in the authoring repository — not portable doctrine`,
+        kind: 'path'
+      })
+    }
+
+    for (const { name, index } of extractVendorMentions(file.content)) {
+      findings.push({
+        file: file.path,
+        line: lineAtIndex(file.content, index),
+        cited: name,
+        message: `names "${name}" outside the one fenced vendor-example home (an <!-- AEG:VENDOR-EXAMPLE:START --> … <!-- AEG:VENDOR-EXAMPLE:END --> pair) — portable doctrine refers to a host generically everywhere else`,
+        kind: 'vendor-name'
       })
     }
   }

package/studio-standalone/_node_modules/@attalabs/aeg-core/src/gate-audience.ts

@@ -121,6 +121,7 @@ export const SHIPPED_BIN_AUDIENCE: Record<string, GateAudience> = {}
  */
 export const CLI_CHECK_RING: Readonly<Record<string, 0 | 1 | 2>> = {
   'brief-shape': 0,
+  'pr-report-density': 0,
   'doc-coverage': 0,
   coherence: 0,
   'dispatch-readiness': 0,
@@ -139,8 +140,10 @@ export const CLI_CHECK_RING: Readonly<Record<string, 0 | 1 | 2>> = {
   'evidence-fresh': 1,
   'reader-resolvable-prose': 0,
   'retired-vocabulary': 0,
+  'doctrine-no-procedures': 0,
   'doctrine-portability': 0,
   'workspace-escape': 0,
+  'exec-bits': 0,
   'changeset-coverage': 0,
   'quoted-command': 0,
   'main-branch-refusal': 0,

package/studio-standalone/_node_modules/@attalabs/aeg-core/src/index.ts

@@ -10,14 +10,19 @@ export {
   CROSS_CUTTING_CANDIDATES,
   deriveBuiltinCrossCuttingDefaults,
   deriveWorkspacePackageDomains,
-  parsePnpmWorkspaceYaml
+  parsePnpmWorkspaceYaml,
+  resolveWorkspaceEntry
 } from './blast-radius-domains'
+export { buildConsumersOf, deriveWorkspaceMemberDirs } from './consumer-enumeration'
+export type { PackageManifest } from './consumer-enumeration'
 export { parseTranche } from './parse-tranche'
 export { deriveTranche } from './derive-tranche'
 export { parseLedger, rowFromCells } from './parse-ledger'
 export { sumLedger } from './sum-ledger'
 export { aggregateTaskTokenRows, parseTokenReportEntries, parseTokensLines } from './parse-token-report'
 export type { TokenSourcePr } from './parse-token-report'
+export { deriveReviewStatus, parseDeveloperRoundMarker, renderReviewStatus } from './review-status'
+export type { ReviewStatus, ReviewStatusInput } from './review-status'
 export { formatBreakdown, formatTokenReportRow, formatTokensLine } from './report-tokens'
 export type { TokenReportRowInput, TokensLineInput, TranscriptSummary, UsageComponents } from './report-tokens'
 // The Claude Code collection adapter (`tranche-model.md` §12 layer 2) — one
@@ -72,9 +77,14 @@ export {
   checkAutonomyClause,
   checkBriefSections,
   checkClosesN as checkBriefClosesN,
+  checkCommandsCarryOutput,
+  checkConsumerTests,
+  checkDefeatCases,
   checkDocUpdateList,
   checkForField,
   checkForgeTitle,
+  checkNoAgentBoxes,
+  checkNoUnpinnedCodeClaims,
   checkPlanPrNoCloses,
   checkPremiseCoverage,
   checkPrincipalPlaceholder,
@@ -85,14 +95,24 @@ export {
   checkTestPlanExclusivity,
   checkTierField,
   checkWorktreeStep0,
+  AGENT_BOXES_REFUSED_SINCE_PR,
+  BRIEF_RULES_SINCE_PR,
+  COMMAND_WORDS,
   COMMIT_TYPE_STYLE,
   COMMIT_TYPES,
+  extractFencedBlocks,
   headerRegion,
   inferBranchFromBody,
   isBriefShaped,
-  isTaskBranch
+  isGrandfatherableBriefRuleError,
+  isTaskBranch,
+  partitionBriefErrorsByRollout
 } from './brief-validation'
-export type { BriefSectionResult, BriefSectionsOptions } from './brief-validation'
+export type { BriefSectionResult, BriefSectionsOptions, FencedBlock } from './brief-validation'
+export { checkDoctrineNoProcedures } from './doctrine-no-procedures'
+export type { DoctrineFile, DoctrineProcedureFinding } from './doctrine-no-procedures'
+export { checkPrReportDensity, checkScopeDensity, checkSummaryDensity } from './pr-report-density'
+export type { DensityResult } from './pr-report-density'
 export {
   checkA1,
   checkA2,
@@ -299,3 +319,5 @@ export type {
 } from './milestone-validation'
 export { findWorkspaceEscapes } from './workspace-escape'
 export type { WorkspaceEscapeFinding, WorkspaceEscapeReason, WorkspaceEscapeSourceFile } from './workspace-escape'
+export { parseRationaleFields, renderBrief } from './brief-render'
+export type { BriefFacts, RationaleFieldKey, RenderResult, SurfaceFileFact } from './brief-render'

package/studio-standalone/_node_modules/@attalabs/aeg-core/src/parse-token-report.ts

@@ -1,6 +1,7 @@
 import { rowFromCells } from './parse-ledger'
 import { splitTableRow } from './parse-registry'
 import type { LedgerRow } from './types'
+import { isPrincipal } from './waiver-label'
 
 /**
  * Live-source token parsing (aeg-forge-state-v1 task 4b, #445). Where
@@ -138,28 +139,39 @@ function isDashOnly(s: string): boolean {
   return s === '—' || s === '-' || s === '–'
 }
 
-/** One merged PR's body + top-level comments — the caller's fetch result, no I/O here. */
+/**
+ * One merged PR's body + top-level comments — the caller's fetch result, no
+ * I/O here. Each comment carries its author's login (`null` when the forge
+ * reports none, e.g. a deleted account) because a comment's `Tokens:` line is
+ * only a ledger row when an allowlisted principal posted it — every agent in
+ * this model posts under the Principal's own `gh` identity, so an unfiltered
+ * read counts a stranger's pasted table as a real turn.
+ */
 export type TokenSourcePr = {
   number: number
   body: string
-  comments: string[]
+  comments: { body: string; author: string | null }[]
 }
 
 /**
  * Pure aggregation over every merged PR associated with a task (its own
  * branch's PR(s), plus any plan/cross-referenced PR carrying the Planner's
  * report) — Developer "Token report" entries and `Tokens: …` lines from
- * each PR body, and `Tokens: …` lines from each PR's comments. Missing or
+ * each PR body, and `Tokens: …` lines from each PR's comments — the latter
+ * only from a comment an allowlisted principal authored. Missing or
  * malformed reports simply produce no row for that report — never a
  * fabricated figure — matching `archivist.md`'s own "flag it under DANGLING
  * instead" discipline; the caller decides how to surface an empty result.
  */
-export function aggregateTaskTokenRows(prs: TokenSourcePr[]): LedgerRow[] {
+export function aggregateTaskTokenRows(prs: TokenSourcePr[], principalAllowlist: string[]): LedgerRow[] {
   const out: LedgerRow[] = []
   for (const pr of prs) {
     out.push(...parseTokenReportEntries(pr.body))
     out.push(...parseTokensLines(pr.body))
-    for (const comment of pr.comments) out.push(...parseTokensLines(comment))
+    for (const comment of pr.comments) {
+      if (!isPrincipal(comment.author, principalAllowlist)) continue
+      out.push(...parseTokensLines(comment.body))
+    }
   }
   return out
 }

package/studio-standalone/_node_modules/@attalabs/aeg-core/src/pr-report-density.ts

@@ -0,0 +1,116 @@
+/**
+ * PR-report density (aeg-governance-hardening, dogfooding finding 2026-09-02).
+ * Pure — no `fs`, no `fetch`, no `process.env`.
+ *
+ * `aeg-root/roles/developer.md` § "PR body — canonical form" and
+ * `aeg-root/templates/pr-report-template.md` both require `## Summary` and
+ * `## Scope` to be exactly one paragraph — narrative root-cause detail
+ * belongs in a section of its own below the canonical four, a commit
+ * message, or the changeset, never padded into the report itself and never
+ * hand-typed into the AEG:EVIDENCE block. Nothing enforced that rule
+ * mechanically:
+ * confirmed live, three real PRs (`atta-labs/vinaya#343`, `#346`, `#354`)
+ * shipped multi-paragraph Summary/Scope sections and nothing caught it,
+ * neither at `vinaya pr create`/`pr edit` time nor in CI. Longer, denser
+ * prose is also strictly more surface for every other body-text gate
+ * (`body-bare-digits`, `reader-resolvable-prose`'s glossary rule) — the same
+ * class of gap `#341` hit in code, just in prose instead.
+ *
+ * Deterministic and structural only, matching `brief-validation.ts`'s own
+ * "presence-only" philosophy: this counts blank-line-delimited text blocks,
+ * never judges whether the prose itself is good.
+ *
+ * The rule is literal — one paragraph, full stop — so a `### subsection`, a
+ * bullet list, or a markdown table under Summary/Scope all fail too, same as
+ * a second prose paragraph would (confirmed by probe, PR review on #358).
+ * That is intentional, not an oversight: `developer.md`'s own escape hatch
+ * for exactly this case is "Add anything you want beneath the four
+ * sections" — structured detail belongs in a section of its own below
+ * Summary/Scope/Test-plan/Evidence, not folded into one of the four. A
+ * multi-line blockquote is the one shape this rule does NOT split on (its
+ * `\n>\n` continuation lines are never blank) — but only when the
+ * blockquote IS the section, start to finish: prose before or after it is
+ * still a separate blank-line-delimited block, so "intro sentence, then a
+ * blockquote aside, then a closing sentence" is three blocks and still
+ * fails (confirmed by probe, PR review on #358 — this is not the
+ * "structured aside alongside prose" shape it can look like at a glance).
+ * The exemption only covers a section whose entire content, quoted in
+ * full, is the one thing being said.
+ */
+
+import { anchoredRegionBounds, stripCode } from './anchored-region'
+
+export type DensityResult = { status: 'pass' | 'fail'; errors: string[] }
+
+/**
+ * The named `## <heading>` section's raw body text — from just after the
+ * heading line to the next `##`-or-shallower heading, or end of body.
+ * `null` when the heading itself is absent (a different check's job to
+ * require it — this one is silent on presence, per the module's scope).
+ */
+function headingSectionBody(prBody: string, heading: string): string | null {
+  const headingRe = new RegExp(`^##\\s+${heading}\\s*$`, 'im')
+  const m = headingRe.exec(prBody)
+  if (!m) return null
+  const start = m.index + m[0].length
+  const rest = prBody.slice(start)
+  const nextHeading = /^#{1,2}\s/m.exec(rest)
+  return nextHeading ? rest.slice(0, nextHeading.index) : rest
+}
+
+/**
+ * `headingSectionBody`'s text with every well-formed `AEG:*` anchor block removed
+ * outright (not just unwrapped) — an anchored field (Scope's trailing
+ * `AEG:TIER` block, in the canonical template) is a field, not a second
+ * prose paragraph, and must not count as one. Reuses `anchoredRegionBounds`
+ * (the same span `vinaya pr report --write` targets) rather than a second,
+ * drifting regex for "what an anchor block looks like."
+ */
+function stripAnchorBlocks(sectionText: string): string {
+  let result = sectionText
+  for (const field of ['CLOSES', 'PROJECT', 'TIER', 'PREMISE', 'TEST-PLAN', 'EVIDENCE'] as const) {
+    for (;;) {
+      const bounds = anchoredRegionBounds(result, field)
+      if (!bounds) break
+      result = result.slice(0, bounds.outerStart) + result.slice(bounds.outerEnd)
+    }
+  }
+  return result
+}
+
+/** Non-empty, blank-line-delimited text blocks, code-blind (a fenced example inside the section is not a second paragraph). */
+function paragraphCount(sectionText: string): number {
+  const stripped = stripCode(stripAnchorBlocks(sectionText)).trim()
+  if (stripped.length === 0) return 0
+  return stripped
+    .split(/\n[ \t]*\n/)
+    .map((block) => block.trim())
+    .filter((block) => block.length > 0).length
+}
+
+function checkSectionDensity(prBody: string, heading: string): DensityResult {
+  const body = headingSectionBody(prBody, heading)
+  if (body === null) return { status: 'pass', errors: [] }
+  const count = paragraphCount(body)
+  if (count <= 1) return { status: 'pass', errors: [] }
+  return {
+    status: 'fail',
+    errors: [
+      `pr-report-density ${heading}: "## ${heading}" holds ${count} paragraphs — the canonical PR-report form (aeg-root/roles/developer.md § PR body) requires exactly one. Collapse it to one paragraph; move the rest into a section of your own below the canonical four ("Add anything you want beneath the four sections", developer.md), a commit message, or the changeset — never into the AEG:EVIDENCE block, which is emitted only, never hand-typed.`
+    ]
+  }
+}
+
+export function checkSummaryDensity(prBody: string): DensityResult {
+  return checkSectionDensity(prBody, 'Summary')
+}
+
+export function checkScopeDensity(prBody: string): DensityResult {
+  return checkSectionDensity(prBody, 'Scope')
+}
+
+/** Aggregates both section checks — one error line per over-dense section. */
+export function checkPrReportDensity(prBody: string): { errors: string[] } {
+  const results = [checkSummaryDensity(prBody), checkScopeDensity(prBody)]
+  return { errors: results.flatMap((r) => r.errors) }
+}

package/studio-standalone/_node_modules/@attalabs/aeg-core/src/premise-check.ts

@@ -80,6 +80,41 @@ export function parsePremiseBlock(prBody: string): PremiseAssertion[] {
   return assertions
 }
 
+/**
+ * The `Premise:` block's own raw text (header line through its last bullet),
+ * mirroring `parsePremiseBlock`'s exact same header/bullet/stop rules so the
+ * two can never disagree about where the block ends. Returns `null` when no
+ * header is found. Used by `brief-validation.ts`'s `checkNoUnpinnedCodeClaims`
+ * to exclude the block's own bullets (a pin's path is a legitimate file
+ * reference, not an unpinned prose claim) — reuses this parser's block
+ * boundaries rather than a second one.
+ */
+export function premiseBlockText(prBody: string): string | null {
+  const searchIn = anchoredRegion(prBody, 'PREMISE') ?? prBody
+  const lines = searchIn.split(/\r?\n/)
+  let startIdx = -1
+  let endIdxExclusive = lines.length
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] as string).trim()
+    if (startIdx === -1) {
+      if (isPremiseHeader(line)) startIdx = i
+      continue
+    }
+    if (line === '') {
+      endIdxExclusive = i
+      break
+    }
+    if (!PREMISE_LINE.test(line)) {
+      endIdxExclusive = i
+      break
+    }
+  }
+
+  if (startIdx === -1) return null
+  return lines.slice(startIdx, endIdxExclusive).join('\n')
+}
+
 export type PremiseCheckResult = { pass: boolean; failures: string[] }
 
 /**

package/studio-standalone/_node_modules/@attalabs/aeg-core/src/quoted-command.ts

@@ -75,8 +75,8 @@ import { classifyProseFile, type ProseFileClass } from './reader-resolvable-pros
 // package's own barrel comment ("reachable through the `./strip-code`
 // subpath for the two callers that need them"). Not through
 // `anchored-region.ts`'s re-export: that file's own `anchoredRegionBounds`
-// is scoped to its closed six-field `AnchorField` grammar, which this
-// marker (a free-form cited-file path, not one of those six names) cannot
+// is scoped to its closed seven-field `AnchorField` grammar, which this
+// marker (a free-form cited-file path, not one of those seven names) cannot
 // use without widening a PR-body-specific type for a doc-authoring concern
 // outside this task's surface. Reusing `maskCode` itself — rather than
 // writing a second masker — is the actual "do not write a second anchor
@@ -164,7 +164,7 @@ function extractQuotedText(raw: string): string {
  * (index-preserving, same primitive `anchored-region.ts` uses) to find
  * marker positions code-blind, then slices the real inner text from the
  * original `content` at those same indices, exactly as `anchoredRegionBounds`
- * does for its own six fields.
+ * does for its own seven fields.
  */
 function findQuotesInFile(path: string, content: string): CitedQuote[] {
   const masked = maskCode(content)