@attalabs/vinaya 0.23.0 → 0.24.0

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

@@ -13,7 +13,7 @@
  */
 
 import { type AnchorField, anchoredRegion, stripCode } from './anchored-region'
-import { parsePremiseBlock } from './premise-check'
+import { parsePremiseBlock, premiseBlockText } from './premise-check'
 import { locateTestPlanSection } from './test-plan-section'
 
 export type BriefSectionResult = { status: 'pass' | 'fail'; errors: string[] }
@@ -126,14 +126,37 @@ function testPlanRegion(prBody: string): string {
  * judge whether tags are correctly assigned or whether `unit-tests-only` is
  * justified by the surface map.
  */
+/**
+ * Presence-only Test Plan detector — three acceptable shapes since task 12
+ * (#387) rendered the `[agent]` half of a Test Plan as a fenced command list
+ * rather than a checkbox: the `unit-tests-only` sentinel; a
+ * `**[agent]**`/`**[principal]**`-tagged checkbox line (the pre-#387 shape,
+ * still valid on a PR below `AGENT_BOXES_REFUSED_SINCE_PR` and for
+ * `[principal]` items on every PR); or a fenced code block anywhere in the
+ * Test Plan region (the fenced-command-list shape). This gate does not judge
+ * WHICH shape a given PR number must use — `checkNoAgentBoxes`, below, is the
+ * rule that refuses a checkbox `[agent]` item on a PR at or above the rollout
+ * constant; this one only asks "is there a Test Plan at all."
+ */
 export function checkTestPlan(prBody: string): BriefSectionResult {
-  const region = testPlanRegion(prBody)
+  const located = locateTestPlanSection(prBody)
+  const region = located.found ? located.section : prBody
   if (TEST_PLAN_UNIT_TESTS_ONLY_RE.test(region)) return { status: 'pass', errors: [] }
   if (/\*\*\[(?:agent|principal)\]\*\*/.test(region)) return { status: 'pass', errors: [] }
+  // Fenced-block detection only counts when the section was genuinely
+  // LOCATED, never on the whole-body fallback: `testPlanRegion`'s fallback
+  // exists so the sentinel/tag checks above still work on a body with no
+  // recognizable heading, but a fence can appear anywhere in a brief (Step
+  // 0's own worktree command, a Part's own command block) — trusting ANY
+  // fence in the whole body would pass a brief whose Test Plan section was
+  // deleted outright, as long as it kept some unrelated fence elsewhere
+  // (found live, fixing this same rule: `checkBriefSections`'s own "missing
+  // Test Plan" regression fixture stopped failing until this guard landed).
+  if (located.found && extractFencedBlocks(region).length > 0) return { status: 'pass', errors: [] }
   return {
     status: 'fail',
     errors: [
-      'brief-validation Test Plan: no Test Plan section found — expected `Test Plan: unit-tests-only`, or at least one `**[agent]**`/`**[principal]**`-tagged checklist item.'
+      'brief-validation Test Plan: no Test Plan section found — expected `Test Plan: unit-tests-only`, a fenced `[agent]` command list, or at least one `**[agent]**`/`**[principal]**`-tagged checklist item.'
     ]
   }
 }
@@ -466,6 +489,370 @@ export function inferBranchFromBody(prBody: string): string {
   return m?.[1] ?? ''
 }
 
+/**
+ * The shell-command-word vocabulary this task's two prose-shape rules share
+ * (`checkCommandsCarryOutput` and `doctrine-no-procedures.ts`'s sweep) — one
+ * list, so the two rules can never silently diverge on what counts as "a
+ * command". Exported for that reuse, not for callers to extend at runtime.
+ */
+export const COMMAND_WORDS = ['export', 'bun', 'gh', 'git', 'grep', 'sed', 'cat', 'diff', 'vinaya'] as const
+
+/**
+ * Rollout PR number for the four brief-shape rules this task added
+ * (`checkNoUnpinnedCodeClaims`, `checkCommandsCarryOutput`,
+ * `checkConsumerTests`, `checkDefeatCases`). A PR numbered below this is
+ * grandfathered: the CI shim (`check-brief-shape.ts`) reports a finding from
+ * one of these four rules as informational, never a failure. A PR at or
+ * above it is held to the rule for real. `verify-brief.ts` (authoring time,
+ * pre-dispatch) has no PR number and applies all four unconditionally —
+ * grandfathering is a CI-only rollout concern, not a grammar relaxation
+ * (round-2 ruling addendum 1).
+ */
+export const BRIEF_RULES_SINCE_PR = 394
+
+/**
+ * Rollout PR number for `checkNoAgentBoxes`, below — a second, distinct
+ * cutover from `BRIEF_RULES_SINCE_PR` above, per the Principal's ruling
+ * (2026-09-03, after PR #395): an agent never ticks a box or edits a PR
+ * body, so the `[agent]` half of a Test Plan stops being checkboxes and
+ * becomes a fenced command list (task 12, #387). A PR numbered below this
+ * is grandfathered — its checkbox `[agent]` items were written before the
+ * ruling and are reported informationally, never a failure. `verify-brief.ts`
+ * (authoring time, pre-dispatch) has no PR number and applies the rule
+ * unconditionally, same grandfathering-is-CI-only posture as
+ * `BRIEF_RULES_SINCE_PR`.
+ */
+export const AGENT_BOXES_REFUSED_SINCE_PR = 396
+
+const AGENT_BOX_LINE_RE = /^-\s*\[[ xX]\]\s*\*{2}\[agent\]\*{2}/im
+
+/**
+ * Refuses a Test Plan whose `[agent]` half is still a checkbox item — the
+ * shape the fenced-command-list rule (task 12, #387) replaces. Presence-only
+ * within the Test Plan region (`testPlanRegion`), like every sibling check
+ * in this file: whether the fenced list a body carries instead is any GOOD
+ * is a Reviewer/Verification judgment, not this gate's.
+ */
+export function checkNoAgentBoxes(prBody: string): BriefSectionResult {
+  const region = testPlanRegion(prBody)
+  if (!AGENT_BOX_LINE_RE.test(region)) return { status: 'pass', errors: [] }
+  return {
+    status: 'fail',
+    errors: [
+      'brief-validation no agent boxes: the Test Plan carries a checkbox `[agent]` item — an agent never ticks a box or edits a PR body (Principal ruling, 2026-09-03, after PR #395). Render the `[agent]` half as a fenced command list instead; `vinaya pr report` runs each command from the PR head and writes its actual output into the AEG:EVIDENCE block. `[principal]` checkboxes are unaffected.'
+    ]
+  }
+}
+
+/**
+ * True for an error message produced by one of the five grandfatherable
+ * rules below (the original four, plus `checkNoAgentBoxes`) — classified by
+ * each rule's own distinct message prefix, since `checkBriefSections`
+ * aggregates every sub-check's errors into one flat `string[]` and this is
+ * the only reader that ever needs to tell them apart from the rest.
+ */
+export function isGrandfatherableBriefRuleError(message: string): boolean {
+  return rolloutThresholdFor(message) !== null
+}
+
+/**
+ * The rollout constant a given error message is grandfathered against, or
+ * `null` for a message this rollout scheme does not cover (always blocking,
+ * on every PR). Two thresholds exist today (`BRIEF_RULES_SINCE_PR`,
+ * `AGENT_BOXES_REFUSED_SINCE_PR`) — a message is matched to whichever rule
+ * produced it, never a single global cutover, so a later third threshold
+ * can be added here without touching either existing one's grandfather
+ * window.
+ */
+function rolloutThresholdFor(message: string): number | null {
+  if (
+    message.startsWith('brief-validation unpinned code claim:') ||
+    message.startsWith('brief-validation commands carry output:') ||
+    message.startsWith('brief-validation consumer tests:') ||
+    message.startsWith('brief-validation defeat cases:')
+  ) {
+    return BRIEF_RULES_SINCE_PR
+  }
+  if (message.startsWith('brief-validation no agent boxes:')) return AGENT_BOXES_REFUSED_SINCE_PR
+  return null
+}
+
+/**
+ * Splits `checkBriefSections`'s flat error list into `blocking` (fails the
+ * check) and `info` (printed, never a failure) — the CI shim
+ * (`check-brief-shape.ts`) is the only caller, but the split is a pure
+ * function of `(errors, prNumber)` so it is unit-testable directly.
+ *
+ * `prNumber === null` (no `PR_NUMBER`, or an unparseable one) is NOT
+ * grandfathered — only a real, parsed number below a message's own
+ * threshold (`rolloutThresholdFor`) is. Fail-closed: a check that can't tell
+ * which PR it's grading must not quietly waive rules it has no number to
+ * check against.
+ */
+export function partitionBriefErrorsByRollout(
+  errors: string[],
+  prNumber: number | null
+): { blocking: string[]; info: string[] } {
+  const blocking: string[] = []
+  const info: string[] = []
+  for (const e of errors) {
+    const threshold = rolloutThresholdFor(e)
+    const grandfathered = threshold !== null && prNumber !== null && prNumber < threshold
+    ;(grandfathered ? info : blocking).push(e)
+  }
+  return { blocking, info }
+}
+
+/**
+ * One fenced block's raw span, content, and language tag — `start`/`end` are
+ * char offsets into the original text. `lang` is the fence's info-string,
+ * lowercased and trimmed to its first word (` ```ts ` → `'ts'`, ` ``` ` →
+ * `''`) — `doctrine-no-procedures.ts` uses it to exempt a non-shell block
+ * (e.g. a TypeScript illustration whose two `export` lines are not a
+ * command sequence, task 10 round-2 ruling item 2).
+ */
+export type FencedBlock = { start: number; end: number; lang: string; content: string }
+
+/**
+ * Every fenced (``` or ~~~) code block in `text`, in document order, with its
+ * raw content, language tag, and char-offset span. Tolerant of the 3-space
+ * list-item indentation every brief's own numbered steps use (`   \`\`\``) —
+ * the fence marker need not sit at column 0. Not a full CommonMark
+ * implementation (no nested-fence-length edge cases beyond "the closer
+ * repeats the opener's exact run"), which this repo's own doctrine/brief
+ * prose never exercises.
+ *
+ * Shared by `checkCommandsCarryOutput` (below) and `doctrine-no-procedures.ts`
+ * — one fence scanner, never a second copy of this pattern.
+ */
+export function extractFencedBlocks(text: string): FencedBlock[] {
+  const re = /^[ \t]*(`{3,}|~{3,})([^\n]*)\n([\s\S]*?)^[ \t]*\1[ \t]*$/gm
+  const blocks: FencedBlock[] = []
+  let m: RegExpExecArray | null = re.exec(text)
+  while (m !== null) {
+    const lang = (m[2] as string).trim().toLowerCase().split(/\s+/)[0] ?? ''
+    blocks.push({ start: m.index, end: m.index + m[0].length, lang, content: m[3] as string })
+    m = re.exec(text)
+  }
+  return blocks
+}
+
+function firstNonBlankLine(text: string): string {
+  const line = text.split('\n').find((l) => l.trim().length > 0)
+  return line?.trim() ?? ''
+}
+
+/**
+ * A file-and-line reference — `<path>.<ext>:<digits>` — the shape a brief
+ * states a code fact by pointer instead of by an executed command or a
+ * `Premise:` pin. Extension list is this repo's own doctrine/code file kinds;
+ * deliberately not "any word after a dot" (that would also catch a semver
+ * string or a decimal figure with a trailing count).
+ */
+const FILE_LINE_RE = /\b[\w./-]+\.(?:tsx?|jsx?|mjs|cjs|md|mdx|json|ya?ml|sh|py|toml):\d+\b/g
+
+/**
+ * Rule (i) (task 10, Issue #385) — a brief states no code fact as a bare
+ * `file:line` prose pointer; it either pins the fact in `Premise:` (re-
+ * asserted at dispatch, `verify-dispatch --premise`) or shows the executed
+ * command whose output names the line. A pointer that survives outside both
+ * homes is a claim nobody re-checks — exactly the class task 9's rule
+ * forbids in prose (PR #382's `security-archivist.md:88` mention, backticked
+ * but never pinned nor shown as command output).
+ *
+ * Scans `stripCode(…, { inlineSpans: 'keep' })`: fenced/indented **blocks**
+ * are removed (a worked example's own line numbers are not a live claim),
+ * but a single-backtick inline span is left as literal text — the PR #382
+ * sentence was exactly an inline span, and this rule must still catch it.
+ * This is why `maskCode` (which blanks inline spans too) is the wrong tool
+ * here, unlike `checkClosesN`/`isBriefShaped` elsewhere in this file.
+ */
+export function checkNoUnpinnedCodeClaims(prBody: string): BriefSectionResult {
+  const premiseText = premiseBlockText(prBody)
+  const withoutPremise = premiseText ? prBody.replace(premiseText, '') : prBody
+  const scanned = stripCode(withoutPremise, { inlineSpans: 'keep' })
+  const matches = scanned.match(FILE_LINE_RE) ?? []
+  if (matches.length === 0) return { status: 'pass', errors: [] }
+  return {
+    status: 'fail',
+    errors: matches.map(
+      (m) =>
+        `brief-validation unpinned code claim: "${m}" states a code fact by file-and-line reference outside a \`Premise:\` pin and outside a fenced code block — pin it in \`Premise:\`, or show the executed command and its output instead.`
+    )
+  }
+}
+
+/**
+ * Section `num`'s own text (the heading line's content, ending at the next
+ * heading of any level 1-4) — `§4`/`§5`/`§6` share this numbered-heading
+ * shape with `headingCheck`'s keyword form, so this mirrors that pattern
+ * rather than inventing a second heading grammar. `null` when no such
+ * section exists (the composer's other checks already judge whether a
+ * required section is missing; these two rules apply only when it is
+ * present).
+ */
+function extractNumberedSection(prBody: string, num: number): string | null {
+  const startRe = new RegExp(`^#{1,4}\\s*(?:\\*\\*)?${num}[a-z]?\\.\\s`, 'im')
+  const start = startRe.exec(prBody)
+  if (!start) return null
+  const afterStart = start.index + start[0].length
+  const rest = prBody.slice(afterStart)
+  const next = /^#{1,4}\s/m.exec(rest)
+  return next ? rest.slice(0, next.index) : rest
+}
+
+function commandWordOf(line: string): string {
+  return line.trim().split(/\s+/)[0] ?? ''
+}
+
+function isCommandBlock(content: string): boolean {
+  return (COMMAND_WORDS as readonly string[]).includes(commandWordOf(firstNonBlankLine(content)))
+}
+
+/** The Step 0 exemption — `git worktree add …` is a command with no separate output block by convention. */
+function isStep0Block(content: string): boolean {
+  return firstNonBlankLine(content).startsWith('git worktree add')
+}
+
+/**
+ * Rule (ii) (task 10, Issue #385; tightened by the round-2 ruling item 1) —
+ * in a brief's `§5` (Pre-flight checks) or `§6` (Numbered parts), a fenced
+ * block that opens with a shell command must be immediately followed by
+ * another fenced block that does NOT itself open with a shell command — its
+ * output. The Step `0` `git worktree add` block is exempt: it is a setup
+ * command with no output to show, by the convention every brief's own
+ * pre-flight step already follows.
+ *
+ * **The immediately-following fence, never merely "a later one".** The first
+ * cut of this rule accepted `blocks[i + 1]` existing at all, which let three
+ * undocumented command blocks in a row pass as long as a single trailing
+ * output fence sat after the last of them — each of the first two command
+ * blocks' own "next fence" was itself another un-followed command, and the
+ * rule never noticed (round-2 ruling, found live reviewing this PR's own
+ * diff). A command block's output claim is only satisfied by the very next
+ * fence, and only if that fence is not itself a command.
+ *
+ * Deliberately loose about what sits *between* the two fences (the prose
+ * separating them, never counted) — this brief's own pre-flight steps
+ * (`§5` items 4-9) interleave a sentence of prose between a command fence
+ * and its output fence ("Output the Brief Author obtained at authoring
+ * time…"), and the rule must not fail the brief that documents it.
+ */
+export function checkCommandsCarryOutput(prBody: string): BriefSectionResult {
+  const errors: string[] = []
+  for (const [label, num] of [
+    ['5', 5],
+    ['6', 6]
+  ] as const) {
+    const section = extractNumberedSection(prBody, num)
+    if (!section) continue
+    const blocks = extractFencedBlocks(section)
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i] as FencedBlock
+      if (isStep0Block(block.content) || !isCommandBlock(block.content)) continue
+      const next = blocks[i + 1]
+      if (!next || isCommandBlock(next.content)) {
+        errors.push(
+          `brief-validation commands carry output: §${label} has a command block ("${firstNonBlankLine(block.content)}") not immediately followed by a non-command output block — the very next fenced block must hold that command's actual output, not another command.`
+        )
+      }
+    }
+  }
+  return errors.length === 0 ? { status: 'pass', errors: [] } : { status: 'fail', errors }
+}
+
+const CONSUMER_TESTS_SENTINEL_RE = /consumer-tests\s*:\s*none\s*[-—–]\s*\S/i
+
+/** Every distinct `packages/<pkg>/` reference in `text` — the packages a §4 surface map names. */
+function packagesNamedIn(text: string): string[] {
+  const re = /\bpackages\/([A-Za-z0-9_-]+)\//g
+  const pkgs = new Set<string>()
+  let m: RegExpExecArray | null = re.exec(text)
+  while (m !== null) {
+    pkgs.add(m[1] as string)
+    m = re.exec(text)
+  }
+  return [...pkgs]
+}
+
+/** Whether `text` names a test-shaped path (`*.test.<ext>`) under workspace directory `consumerDir` (e.g. `apps/cli`, `packages/sources`). */
+function hasTestPathForConsumer(text: string, consumerDir: string): boolean {
+  const escaped = consumerDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const re = new RegExp(`${escaped}\\/[\\w./-]*\\.test\\.[A-Za-z0-9]+`)
+  return re.test(text)
+}
+
+/**
+ * Rule (iii) (task 10, Issue #385) — a brief whose `§4` names a path under a
+ * shared `packages/<pkg>/` must also name, for every workspace package that
+ * depends on `@attalabs/<pkg>`, a test path proving that consumer still
+ * works, or the sentinel `consumer-tests: none — <reason>` opting out with a
+ * stated reason. A shared-package edit with no consumer awareness at all is
+ * exactly the gap task 9's rule targets alongside the unpinned-claim and
+ * missing-output shapes.
+ *
+ * `consumersOf` is injected (never `fs`/`package.json` reads here) — the CLI
+ * shim (`check-brief-shape.ts`) builds it once from the real workspace
+ * dependency graph. Both the trigger and its satisfying test path/sentinel
+ * are read from `§4` alone, never the whole body — scanning the whole body
+ * let a brief's own §2 prose, quoting the sentinel grammar as an example of
+ * the rule (exactly this task's own dispatched brief), silently satisfy the
+ * rule it was merely describing. `§4` is where a surface map states its
+ * blast radius; that is also where this rule's own answer belongs.
+ */
+export function checkConsumerTests(prBody: string, consumersOf: (pkg: string) => string[]): BriefSectionResult {
+  const section4 = extractNumberedSection(prBody, 4)
+  if (!section4) return { status: 'pass', errors: [] }
+  if (CONSUMER_TESTS_SENTINEL_RE.test(section4)) return { status: 'pass', errors: [] }
+
+  const errors: string[] = []
+  for (const pkg of packagesNamedIn(section4)) {
+    for (const consumerDir of consumersOf(pkg)) {
+      if (hasTestPathForConsumer(section4, consumerDir)) continue
+      errors.push(
+        `brief-validation consumer tests: §4 names a path under packages/${pkg}/, and ${consumerDir} depends on @attalabs/${pkg}, but no test path under ${consumerDir} is named in §4 — name one, or add \`consumer-tests: none — <reason>\`.`
+      )
+    }
+  }
+  return errors.length === 0 ? { status: 'pass', errors: [] } : { status: 'fail', errors }
+}
+
+/** A check bin filename (`check-<slug>.ts`) — the shape both a §4 "Create"/"Modify" entry and a registry entry use for a check's own name. */
+const CHECK_NAME_RE = /\bcheck-[a-z0-9-]+(?:\.ts)?\b/
+
+/** A command that writes to the forge — as opposed to a read-only query — the class this rule wants a `Defeat cases:` line for. */
+const FORGE_WRITE_COMMAND_RE =
+  /\bgh\s+(?:pr|issue)\s+(?:create|merge|close|comment|edit|review)\b|\bgit\s+push\b|\bvinaya\s+pr\s+(?:create|report\s+--write)\b/i
+
+const DEFEAT_CASES_RE = /defeat cases\s*:/i
+
+/**
+ * Rule (v) — Principal ruling amending Issue #385: a brief whose `§4`
+ * names a check (a `check-<slug>.ts` bin, or its registry entry) or a
+ * forge-writing command (`gh pr create`, `git push`, `vinaya pr create`, …)
+ * must carry a `Defeat cases:` line in `§6` — the inputs that would defeat
+ * the check, or the ones a forge-writing command must not accidentally
+ * trigger on. A check or a write path shipped with no stated defeat case is
+ * exactly the kind of untested edge this task's own sibling rules exist to
+ * close for a brief's prose claims; this one closes it for the check/command
+ * itself.
+ */
+export function checkDefeatCases(prBody: string): BriefSectionResult {
+  const section4 = extractNumberedSection(prBody, 4)
+  if (!section4) return { status: 'pass', errors: [] }
+  if (!CHECK_NAME_RE.test(section4) && !FORGE_WRITE_COMMAND_RE.test(section4)) return { status: 'pass', errors: [] }
+
+  const section6 = extractNumberedSection(prBody, 6) ?? ''
+  if (DEFEAT_CASES_RE.test(section6)) return { status: 'pass', errors: [] }
+
+  return {
+    status: 'fail',
+    errors: [
+      'brief-validation defeat cases: §4 names a check or a forge-writing command, but §6 carries no `Defeat cases:` line — name the inputs that would defeat this check, or that this command must not accidentally trigger on.'
+    ]
+  }
+}
+
 /** Composition knobs for `checkBriefSections` — see each field. */
 export type BriefSectionsOptions = {
   /**
@@ -480,6 +867,15 @@ export type BriefSectionsOptions = {
    * linkage is a task-branch obligation; brief completeness is not.
    */
   requireClosesN?: boolean
+  /**
+   * Consumer enumeration for `checkConsumerTests` (task 10) — workspace
+   * directories (e.g. `apps/cli`) whose `package.json` depends on
+   * `@attalabs/<pkg>`. Defaults to `() => []`, which makes rule (iii) a
+   * no-op — the callers that don't wire a real dependency graph (tests,
+   * `verify-brief.ts`) keep today's behavior rather than silently failing
+   * on an empty consumer list.
+   */
+  consumersOf?: (pkg: string) => string[]
 }
 
 /**
@@ -492,7 +888,7 @@ export function checkBriefSections(
   readTier: (body: string) => 0 | 1 | 3 | null,
   options: BriefSectionsOptions = {}
 ): { errors: string[] } {
-  const { requireClosesN = true } = options
+  const { requireClosesN = true, consumersOf = () => [] } = options
   const results = [
     checkTierField(prBody, readTier),
     checkTestPlan(prBody),
@@ -505,6 +901,11 @@ export function checkBriefSections(
     checkAutonomyClause(prBody),
     checkProjectField(prBody),
     checkForField(prBody),
+    checkNoUnpinnedCodeClaims(prBody),
+    checkNoAgentBoxes(prBody),
+    checkCommandsCarryOutput(prBody),
+    checkConsumerTests(prBody, consumersOf),
+    checkDefeatCases(prBody),
     ...(requireClosesN ? [checkClosesN(prBody)] : [])
   ]
   return { errors: results.flatMap((r) => r.errors) }

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

@@ -379,6 +379,25 @@ export function checkD1(
       const depEntry = resolveDepEntry(dep, e.trancheSlug, issueToEntry, taskToEntry)
       if (!depEntry) continue // unknown dep — not a D1 concern
 
+      // A self-dependency is unsatisfiable by construction, so it is never a
+      // real D1 state — it is proof of a parser defect upstream. Reported as
+      // an INTERNAL error rather than as "is not closed", which reads as a
+      // legitimate unmet dependency and invites routing around the gate.
+      // Mirrors `isSelfDependency` in `dispatch-gate.ts`; deliberately a
+      // second small local predicate rather than a shared export, since the
+      // two modules match on different fact shapes.
+      const sameTask = depEntry.trancheSlug === e.trancheSlug && depEntry.task.id === e.task.id
+      const sameIssue = depEntry.task.issue !== null && e.task.issue !== null && depEntry.task.issue === e.task.issue
+      if (sameTask || sameIssue) {
+        failures.push({
+          issue: e.task.issue,
+          tranche: e.trancheSlug,
+          task: e.task.id,
+          reason: `INTERNAL: parsed a self-dependency (depends-on ${dep}) — this is a parser bug in parseRationaleDeps, not a real dependency. Please report it upstream.`
+        })
+        continue
+      }
+
       const depFacts = depEntry.facts
       const depClosed = depFacts?.issueState === 'closed'
       if (!depClosed) {

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

@@ -0,0 +1,75 @@
+/**
+ * `checkConsumerTests`'s consumer enumeration (`brief-validation.ts`, task 10,
+ * Issue #385; corrected by the round-2 ruling item 3) — every workspace
+ * member whose own `package.json` depends on `@attalabs/<pkg>`, for "every
+ * workspace package depending on `@attalabs/<pkg>`" to mean what it says.
+ *
+ * The first cut reused `deriveWorkspacePackageDomains` (`blast-radius-domains.ts`),
+ * which deliberately collapses to `packages/*` members only — correct for
+ * that module's own collision-domain purpose, wrong here: it silently
+ * exempted `apps/cli`, a real `@attalabs/aeg-core` consumer, from a rule
+ * that promises "every workspace package" (found live reviewing this PR's
+ * own diff). This module resolves every workspace glob instead —
+ * `apps/*` and `packages/*` alike — via `resolveWorkspaceEntry`, the same
+ * glob grammar `deriveWorkspacePackageDomains` uses, reused rather than
+ * re-derived a second time.
+ *
+ * Zero I/O: `listDirs`/`readManifest` are injected by each of the two real
+ * entry points — `packages/aeg-core/bin/verify-brief.ts` (authoring-time,
+ * pre-dispatch) and `apps/cli`'s `check-brief-shape.ts` (CI) — so both share
+ * ONE enumeration rather than two independently-maintained copies that can
+ * silently diverge (round-2 ruling item 4).
+ */
+
+import { resolveWorkspaceEntry } from './blast-radius-domains'
+
+export type PackageManifest = { dependencies?: Record<string, string>; devDependencies?: Record<string, string> }
+
+/**
+ * Every workspace member directory (`apps/cli`, `packages/aeg-core`, …),
+ * resolved from `workspaces` (positive entries minus any `!`-negated ones,
+ * same semantics as `deriveWorkspacePackageDomains`) — but NOT collapsed to
+ * `packages/*` only, since a real consumer can live anywhere in the
+ * workspace.
+ */
+export function deriveWorkspaceMemberDirs(workspaces: string[], listDirs: (dir: string) => string[]): string[] {
+  const positive = workspaces.filter((entry) => !entry.startsWith('!'))
+  const negative = workspaces.filter((entry) => entry.startsWith('!')).map((entry) => entry.slice(1))
+
+  const excluded = new Set<string>()
+  for (const entry of negative) {
+    for (const member of resolveWorkspaceEntry(entry, listDirs)) excluded.add(member)
+  }
+
+  const members = new Set<string>()
+  for (const entry of positive) {
+    for (const member of resolveWorkspaceEntry(entry, listDirs)) {
+      if (!excluded.has(member)) members.add(member)
+    }
+  }
+  return [...members].sort()
+}
+
+/**
+ * Builds `checkConsumerTests`'s `consumersOf` callback: for a package `pkg`
+ * (as named in a brief's `§4`, e.g. `packages/aeg-core/` → `'aeg-core'`),
+ * every workspace member directory (self excluded) whose own manifest lists
+ * `@attalabs/<pkg>` in `dependencies` or `devDependencies`.
+ */
+export function buildConsumersOf(
+  workspaces: string[],
+  listDirs: (dir: string) => string[],
+  readManifest: (dir: string) => PackageManifest | null
+): (pkg: string) => string[] {
+  const members = deriveWorkspaceMemberDirs(workspaces, listDirs)
+
+  return (pkg: string): string[] => {
+    const target = `@attalabs/${pkg}`
+    return members.filter((dir) => {
+      if (dir === `packages/${pkg}`) return false
+      const manifest = readManifest(dir)
+      if (!manifest) return false
+      return target in (manifest.dependencies ?? {}) || target in (manifest.devDependencies ?? {})
+    })
+  }
+}

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

@@ -145,6 +145,39 @@ export type DispatchGateInput = {
 
 export type DispatchResult = { ready: boolean; blockers: string[] }
 
+/**
+ * True when a parsed `depends-on` edge points back at its own host task.
+ *
+ * A self-dependency is unsatisfiable by construction, so it is never a real
+ * gate state — its presence is proof of a defect in the edge text or in its
+ * resolution. `parseRationaleDeps` (`@attalabs/aeg-forge-state`) reads only
+ * a labeled `Depends-on:`/`Conflicts-with:` field's own comma-separated,
+ * id-shaped tokens; since Issue #347 an unlabeled/bare span elsewhere in the
+ * "Dependency rationale" section is never read as an edge, whatever its
+ * shape (`parse-rationale-deps.ts`'s own module comment states the rule). A
+ * slug-qualified token in that list (`aeg-governance-hardening #368`) still
+ * resolves its trailing bare number against the NAMED tranche, not the host
+ * — a resolver bug there is what would land a task depending on itself, on
+ * that tranche's own task `1`.
+ *
+ * Reported as an INTERNAL error rather than through the ordinary
+ * "not merged yet" branch below, because that message reads as a legitimate
+ * serialization and invites the reader to route around it: two Developer
+ * agents faced with exactly this gate concluded it was a false positive and
+ * committed with `--no-verify` to get past their hooks. Naming it a tool bug
+ * converts "agent improvises around a nonsense gate" into "agent escalates,"
+ * which is the behavior the gate architecture assumes.
+ *
+ * Two arms, because the edge can carry either shape: a resolved Issue number
+ * equal to this task's own, or — the live case — a bare same-tranche id equal
+ * to this task's own id.
+ */
+function isSelfDependency(dep: DispatchDependsOnFact, task: Task, issue: DispatchIssueFact): boolean {
+  if (dep.issue !== null && issue !== null && dep.issue === issue.number) return true
+  const bare = dep.id.trim().replace(/^#/, '')
+  return bare.toLowerCase() === task.id.trim().toLowerCase()
+}
+
 export function checkDispatchReadiness(input: DispatchGateInput): DispatchResult {
   const { trancheSlug, task } = input
   const taskLabel = `task ${task.id} (tranche ${trancheSlug})`
@@ -174,6 +207,17 @@ export function checkDispatchReadiness(input: DispatchGateInput): DispatchResult
   // `vinaya-engine-v1` 21, #99): a second, narrower path for a dependency
   // Issue closed directly rather than via a merged PR.
   for (const dep of input.dependsOn) {
+    // Evaluated BEFORE the unresolvable branch: a self-reference that also
+    // failed to resolve is still a parser bug, and reporting it as an
+    // unresolvable edge would send the reader to correct edge text that is
+    // not actually the fault.
+    if (isSelfDependency(dep, task, input.issue)) {
+      const issueStr = input.issue !== null ? `#${input.issue.number}` : '?'
+      blockers.push(
+        `dispatch-gate INTERNAL: parsed a self-dependency for task ${task.id} (${issueStr}) — this is a parser bug in parseRationaleDeps, not a real dependency. Please report it upstream. Re-run once the rationale is corrected or the fix ships.`
+      )
+      continue
+    }
     if (dep.resolved === false) {
       // Distinct from the "not merged yet" branch below (#196): this edge
       // never resolved to any tranche/task/Issue at all, so a "not merged"