@dzhechkov/harness-core 0.8.11 → 0.8.21

package/src/agents-policy.ts

@@ -40,7 +40,16 @@ export const POLICY_SOURCES: readonly PolicySource[] = [
     file: 'CLAUDE.md',
     heading: 'Test execution: never watch',
     why: 'A watch-mode test run hangs an unattended coding session.',
-    operativeClause: 'npm test -- --run',
+    // Была `npm test -- --run` — эта команда в корне НЕ СУЩЕСТВУЕТ (Missing script: test), и
+    // 2026-09-03 канон исправлен. Несущей стала команда, которая есть.
+    operativeClause: 'npm run test:all',
+  },
+  {
+    id: 'backlog-coverage',
+    file: 'CLAUDE.md',
+    heading: 'Backlog coverage',
+    why: 'Работа, не закрытая в этом же ходу, иначе не оставляет следа нигде, кроме переписки, которая прокручивается.',
+    operativeClause: 'ALWAYS say out loud which records you filed',
   },
   {
     id: 'data-protection',
@@ -101,7 +110,26 @@ export interface ExtractPolicyBlocksResult {
   readonly missing: readonly string[];
 }
 
-export type PolicyDriftStatus = 'ok' | 'stale' | 'missing-stamp' | 'missing-anchor' | 'orphan-stamp';
+export type PolicyDriftStatus =
+  | 'ok'
+  | 'stale'
+  | 'missing-stamp'
+  | 'missing-anchor'
+  | 'orphan-stamp'
+  /**
+   * Секция `<!-- dz:policy id=X -->` найдена в ФАЙЛЕ-ИСТОЧНИКЕ, но не объявлена в `POLICY_SOURCES`.
+   *
+   * ЗАЧЕМ ОТДЕЛЬНЫЙ СТАТУС. `orphan-stamp` смотрит в другую сторону — штамп в проекции без
+   * источника. Обратный случай не покрывался ничем, и это давало ЛОЖНОЕ ЗЕЛЁНОЕ: реестр
+   * `POLICY_SOURCES` ведётся руками, поэтому секция, дописанная в CLAUDE.md и не вписанная в него,
+   * молча не попадала в AGENTS.md, а `dz agents-sync --check` отвечал «in sync».
+   *
+   * ИЗМЕРЕНО 2026-09-03 на живом случае: добавил в канон секцию `backlog-coverage`, прогнал
+   * `agents-sync` — «in sync — 9 policy section(s), 9250 bytes», ровно те же число секций и байт,
+   * что до правки, ни на единицу не изменившиеся. Правило, ради которого всё делалось, до агентов
+   * не доехало, а прибор доложил успех.
+   */
+  | 'unregistered-section';
 
 export interface PolicyDriftFinding {
   readonly id: string;
@@ -320,6 +348,22 @@ export function detectPolicyDrift(
     findings.push({ id: stamp.id, file: stamp.file, status: 'orphan-stamp', expectedSha: null, actualSha: stamp.sha });
   }
 
+  // Секции канона, о которых реестр не знает. Ищем во ВСЕХ переданных файлах-источниках, а не
+  // только в тех, что уже объявлены: файл может целиком отсутствовать в реестре.
+  {
+    const declared = new Set(sources.map((source) => source.id));
+    const seen = new Set<string>();
+    for (const [file, text] of sourceFiles) {
+      if (typeof text !== 'string') continue;
+      for (const m of text.matchAll(/<!-- dz:policy id=([a-z0-9-]+) -->/g)) {
+        const id = m[1]!;
+        if (declared.has(id) || seen.has(id)) continue;
+        seen.add(id);
+        findings.push({ id, file, status: 'unregistered-section', expectedSha: null, actualSha: null });
+      }
+    }
+  }
+
   if (typeof agentsMdText === 'string') {
     const beginCount = markerCount(agentsMdText, POLICY_BLOCK_BEGIN);
     const endCount = markerCount(agentsMdText, POLICY_BLOCK_END);

package/src/amendment-trace.ts

@@ -20,7 +20,38 @@ export interface AmendmentRow {
   readonly id: string;
   readonly testIds: readonly string[];
   readonly file: string | null;
+  /** The row's literal text, fenced examples included — what the author wrote. */
   readonly raw: string;
+  /**
+   * The same slice with non-rendered regions (fenced blocks, HTML comments) blanked out, same
+   * length, so an index means the same byte in both. EVERY semantic read goes through this one —
+   * pointers, retraction, subject — because an EXAMPLE inside a row's block is not that row's
+   * answer.
+   *
+   * OPTIONAL, and that is a compatibility promise rather than sloppiness: round 4 made it REQUIRED
+   * and thereby broke every downstream constructor of a row the previous release accepted — a
+   * TypeScript consumer stopped compiling, and a legacy or deserialised row reaching
+   * `amendmentsMissingFromPlan` threw `TypeError: Cannot read properties of undefined (reading
+   * 'split')` (MEASURED 2026-09-06, Codex cross-family review round 5, P1). Every read goes through
+   * `rowScan()`, which falls back to `raw` — the honest degradation for a row that was built
+   * without a mask and therefore has no masked text to offer.
+   *
+   * MEASURED 2026-09-06 (Codex cross-family review round 4, P2): row starts were found in the mask
+   * while the text was sliced from the original, so a testless `AM-1` followed by a fenced
+   * `AM-2 … → test \`x\` in \`x.ts\`` example borrowed the example's pointer, resolved, and the
+   * gate answered `pass` with exit 0. Finding in the mask and reading past it is not masking.
+   */
+  readonly scan?: string;
+}
+
+/**
+ * The text a row's SEMANTICS are read from: its masked slice when it has one, its raw text when it
+ * does not. A row built by hand or revived from JSON has no mask to speak of, so `raw` is the only
+ * honest answer for it — and a fallback that returns text is the difference between a legacy row
+ * being read slightly too generously and the whole call throwing.
+ */
+function rowScan(row: AmendmentRow): string {
+  return row.scan ?? row.raw;
 }
 
 export type AmendmentVerdict =
@@ -109,39 +140,364 @@ export function normalizeTestId(s: string): string {
 // bullet drops 104 of the corpus's 347 real amendment rows out of the check entirely, and a
 // bullet-less row made this tool return `not-established` — which the pipeline's own gate text calls
 // "NEVER a pass". C6 has always treated the bullet as optional; this is that half of the contract.
-const ROW_START = /^(?:[-*|]\s*)?\*{0,2}AM-(?:CP-)?(\d+)/gm;
+//
+// The `CP-` prefix is CAPTURED, because it is IDENTITY: `AM-CP-N` is a row like any other AND a
+// DIFFERENT id from `AM-N`. It was a non-capturing group until 2026-09-05 and the id was rebuilt
+// from the number alone, so a challenge-panel row collided with the ideation's `AM-1` and the
+// subject guard failed an honest plan as `subject-changed`. MEASURED TWICE that day (backlog
+// a7d0aece023774a0): `run-registry-liveness` re-numbered 7 panel rows to AM-18…AM-31 to escape it,
+// `core-boundary-guard` refused the `AM-CP-N` form outright. K2 (check-plan-completeness.mjs:361,
+// `(AM-(?:CP-)?\d+)`) has always kept the whole token — this ends that disagreement, and the
+// agreement is pinned by test/amendment-grammar-agreement.test.ts, not by this comment.
+const ROW_START = /^(?:[-*|]\s*)?\*{0,2}AM-(CP-)?(\d+)/gm;
+
+/**
+ * The same token, read out of ORDINARY PROSE rather than at the start of a row — `dz score` scans a
+ * whole plan and a whole QE report for the amendments it must account for, and a scan is not a row
+ * grammar (a row is anchored to the line start; a mention is not).
+ *
+ * It lives HERE, next to `ROW_START`, because the defect it closes is the same class the row
+ * grammar just closed (doc-26: two tools, one text, two contracts) — measured one reader later.
+ * MEASURED 2026-09-06: `score.ts` scanned with its own `/AM-\d+/g`, which does not match `AM-CP-1`
+ * at all (`node -e "console.log('AM-CP-1'.match(/AM-\d+/g))"` → `null`), so a plan whose amendments
+ * were all challenge-panel rows produced an EMPTY planned set and the amendment-confirmation
+ * discipline was skipped with no trace — a check that silently checked nothing, the very class this
+ * module exists to remove. There were never two readers of `AM-*`; there were three.
+ *
+ * The trailing `\b` is identity too: without it a planned `AM-1` is "covered" by a report that only
+ * ever mentions `AM-10` (MEASURED — `'AM-10'.includes('AM-1')` → `true`). A substring is not an id.
+ */
+const AMENDMENT_ID_TOKEN = /\bAM-(?:CP-)?\d+\b/g;
+
+/** Every distinct amendment id mentioned in `text`, in first-seen order. */
+export function amendmentIdsIn(text: string): string[] {
+  return [...new Set(text.match(AMENDMENT_ID_TOKEN) ?? [])];
+}
+
+/**
+ * Does `text` mention `id` AS AN ID? `AM-10` is not a mention of `AM-1`, and `AM-CP-1` is not a
+ * mention of `AM-1` — both are what a `String.includes` check answers wrongly.
+ */
+export function mentionsAmendmentId(text: string, id: string): boolean {
+  return amendmentIdsIn(text).includes(id);
+}
+
+/**
+ * The `## Amendments` heading line — ONE definition, because two readers of the same line is the
+ * defect class this module keeps closing. Group 1 is the heading SUFFIX: everything after the word
+ * `Amendments` on that line, which is where the inline declaration `## Amendments: None` lives.
+ * The final newline is optional so a document that ENDS on its heading is still a section that
+ * exists (an empty one) rather than no section at all.
+ */
+const AMENDMENT_HEADING = /^ {0,3}(#{2,4})\s+Amendments\b([^\n]*)(?:\n|$)/m;
+
+/**
+ * The CLOSED set of explicit-none forms, matched against a WHOLE trimmed heading suffix or a WHOLE
+ * trimmed first paragraph. The word alone, optionally with a full stop — nothing else.
+ *
+ * The previous trailing-guard form only checked the character AFTER the word, so ordinary prose such
+ * as `None of the required rows has been written yet.` passed as a DECLARATION because the next
+ * character was a space, and with zero parsed rows the gate answered skip/exit 0 (MEASURED
+ * 2026-09-06, Codex cross-family review round 7, P1). A declaration is a whole utterance, not a
+ * prefix: "none" is an answer, "none of X yet" is a description of work outstanding.
+ */
+const NONE_DECLARATION_EXACT = /^(?:none|n\/a|нет)\.?$/iu;
+
+/** Anything that LOOKS like amendment content in rendered text: a row id, a table cell, a child section. */
+const AMENDMENT_LIKE = /\bAM-(?:CP-)?\d+\b|^\s*\|\s*\*{0,2}AM-|^ {0,3}#{3,6}\s+Amendments\b/;
+
+/** A separator that turns a heading suffix into a DECLARATION rather than a qualifier. */
+const HEADING_DECLARATION_SEPARATOR = /^\s*[:\u2014\u2013-]\s*/;
+
+/**
+ * The document with every FENCED block blanked out — same length, same line count, so every index
+ * computed on the mask addresses the identical byte of the original.
+ *
+ * A plan is allowed to SHOW the form it may write, and this module must not read the example as the
+ * document's own answer. MEASURED 2026-09-06 (Codex round 3, P2): a fenced `## Amendments: None`
+ * placed above the real section won the raw heading search, the fence's own body parsed as zero
+ * rows, and the explicit-none branch exited 0 WITHOUT EVER LOOKING at the real section, which
+ * carried an unresolvable `AM-1`. That is the new false pass NFR-3 forbids. K2 has refused fenced
+ * examples from the start (`check-plan-completeness.mjs`, its fence-blindness fix); this is that
+ * half of the contract, arriving here.
+ *
+ * An UNCLOSED fence is reverted rather than trusted — masking may only lose EXAMPLES, never hide a
+ * real section, because a hidden section is a skip and a skip is exit 0. The safe direction is
+ * chosen explicitly and pinned by a test.
+ */
+function blankLine(line: string): string {
+  return ' '.repeat(line.length);
+}
+
+/**
+ * The document with every NON-RENDERED block blanked out — same length, same line count, so every
+ * index computed on the mask addresses the identical byte of the original.
+ *
+ * ONE BLOCK SCAN, not a stack of regexes. Five rounds of cross-family review found the same class
+ * five times — a fenced heading, a fenced row, a fenced pointer, a fence closed by a shorter run,
+ * an HTML-commented template — and round 6 found the sixth: `<!--` and `-->` written inside INLINE
+ * CODE SPANS in ordinary prose, which a `<!--[\s\S]*?-->` mask happily read as a comment spanning
+ * the real section (MEASURED 2026-09-06: `section: NULL`, `skip`, exit 0, the whole section
+ * swallowed). Each mask was born to close the previous one's hole, which is the signature of the
+ * wrong level: markdown decides what a document CONTAINS at BLOCK level, so that is where this
+ * reads. An inline construct cannot open a block, so the code-span case is closed BY CONSTRUCTION
+ * rather than by a longer pattern.
+ *
+ * WHAT THIS IMPLEMENTS, named so the gap is auditable:
+ *   • CommonMark §4.5 fenced code blocks — opener ``` or ~~~ (three or more, indented ≤3), closed
+ *     only by a run of the SAME character at least as long, with nothing but whitespace after it.
+ *   • CommonMark §4.6 HTML blocks, TYPE 2 ONLY (`<!-- … -->`) — start condition `<!--` at the start
+ *     of a line after at most three spaces; end condition `-->` anywhere on a line, the start line
+ *     included. This is the rule that makes a code-spanned delimiter a non-event.
+ *   • CommonMark §4.2 ATX headings are then matched only in what survives (the heading pattern
+ *     itself is unchanged and allows at most three spaces of indent).
+ *   • CommonMark §6.1 code spans are deliberately NOT parsed: no inline construct can open a block,
+ *     so there is nothing left for them to forge.
+ *
+ * WHAT IT DOES NOT IMPLEMENT (honest, and the reason a fixture outside this list is not covered):
+ * indented code blocks (§4.4) — a four-space-indented row still parses as a row, though a
+ * four-space-indented heading is not a heading; HTML block types 1 and 3–7 (`<script>`, `<?`,
+ * `<!DOCTYPE`, `<![CDATA[`, block tags, generic tags); block quotes and list containers, so a fence
+ * nested inside them is matched by its own indentation rather than relative to its container; tabs
+ * as indentation; link reference definitions.
+ *
+ * DELIBERATE DEVIATION: CommonMark runs an unclosed fence (or HTML block) to the end of the
+ * document. Here an unclosed block is REVERTED — its lines come back. The asymmetry is the point:
+ * masking may lose an EXAMPLE, but hiding a real section turns the gate into `skip`, and a skip is
+ * exit 0. Pinned by its own tests, for both fences and comments.
+ */
+function maskNonRendered(md: string): string {
+  const lines = md.split('\n');
+  const out = lines.slice();
+  let state: 'text' | 'fence' | 'html' = 'text';
+  let marker = '';
+  let markerLength = 0;
+  let openedAt = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] as string;
+    if (state === 'text') {
+      const fence = /^ {0,3}(`{3,}|~{3,})([^\n]*)$/.exec(line);
+      // CommonMark §4.5: the info string of a BACKTICK fence may not contain a backtick (a tilde
+      // fence may). An invalid opener is not an opener — accepting one let a later run close a
+      // fence that markdown never opened, exposing a `## Amendments: None` that is really inside an
+      // unclosed fence and hiding a real section above it (Codex round 7, P2).
+      if (fence && (fence[1] as string)[0] === '`' && (fence[2] as string).includes('`')) {
+        continue;
+      }
+      if (fence) {
+        const run = fence[1] as string;
+        state = 'fence';
+        marker = run[0] as string;
+        markerLength = run.length;
+        openedAt = i;
+        out[i] = blankLine(line);
+        continue;
+      }
+      // §4.6 type 2 START CONDITION: line start, at most three spaces. NOT anywhere in the line —
+      // that spelling is what let a code-spanned `<!--` in prose open a comment (round 6, P1).
+      const htmlStart = /^ {0,3}<!--/.exec(line);
+      if (htmlStart) {
+        state = 'html';
+        openedAt = i;
+        out[i] = blankLine(line);
+        // The end condition may be satisfied on the start line itself.
+        if (/-->/.test(line)) {
+          state = 'text';
+          openedAt = -1;
+        }
+      }
+      continue;
+    }
+    out[i] = blankLine(line);
+    if (state === 'fence') {
+      const close = /^ {0,3}(`{3,}|~{3,})\s*$/.exec(line);
+      if (close) {
+        const run = close[1] as string;
+        if ((run[0] as string) === marker && run.length >= markerLength) {
+          state = 'text';
+          openedAt = -1;
+        }
+      }
+    } else if (/-->/.test(line)) {
+      state = 'text';
+      openedAt = -1;
+    }
+  }
+  // An unclosed block is not trusted: put its lines back (see DELIBERATE DEVIATION above).
+  if (openedAt >= 0) for (let i = openedAt; i < lines.length; i++) out[i] = lines[i] as string;
+  return out.join('\n');
+}
+
+/**
+ * How many RENDERED `## Amendments` sections the document opens. More than one is a document that
+ * contradicts itself, and until 2026-09-06 the FIRST one answered for all of them: a stale
+ * `## Amendments: None` left above the real section made the explicit-none branch exit 0 while the
+ * real section's unresolved rows were never parsed (Codex round 6, P2 — MEASURED `skip`, exit 0).
+ */
+/** Where the document contradicts its own "no amendments" declaration. */
+export interface AmendmentAmbiguity {
+  /** 1-based line in the ORIGINAL document. */
+  readonly line: number;
+  /** the offending line, trimmed and capped — evidence, not a hint. */
+  readonly text: string;
+}
+
+/**
+ * The FAIL-CLOSED half of the explicit-none contract (Codex cross-family review round 7).
+ *
+ * Seven rounds produced one outcome again and again: an ambiguous document answering `skip`/exit 0.
+ * Each round closed the parser hole that round's fixture used — and the next fixture used the next
+ * hole. This function stops paying that toll by inverting the burden: a declaration of "no
+ * amendments" is honoured ONLY IF the rendered document carries no amendment-shaped content below
+ * it. Anything AM-like with zero parsed rows means the PARSER and the DOCUMENT disagree, and the
+ * honest verdict for a disagreement is NOT-ESTABLISHED, never a pass and never a skip.
+ *
+ * Scanned in the block-scanned text, so fenced examples and HTML comments are already out; scanned
+ * from the section heading DOWN, which is deliberately more than "below the declaration" — the
+ * conservative direction here is to see more, because every miss is an exit 0.
+ */
+export function amendmentDeclarationAmbiguity(md: string): AmendmentAmbiguity | null {
+  const mask = maskNonRendered(md);
+  const m = AMENDMENT_HEADING.exec(mask);
+  if (m === null) return null;
+  const maskLines = mask.split('\n');
+  const rawLines = md.split('\n');
+  const headingIndex = mask.slice(0, m.index).split('\n').length - 1;
+  for (let i = headingIndex + 1; i < maskLines.length; i++) {
+    const line = maskLines[i] as string;
+    if (AMENDMENT_LIKE.test(line)) {
+      return { line: i + 1, text: (rawLines[i] ?? '').trim().slice(0, 160) };
+    }
+  }
+  return null;
+}
+
+export function amendmentSectionCount(md: string): number {
+  const mask = maskNonRendered(md);
+  // DEPTH MATTERS, and the corpus is why (MEASURED 2026-09-06 on the 363-feature census while this
+  // refusal was being added): `features/p16-non-js-portability/06_implementation_plan.md` carries
+  // `## Amendments` at line 780 and `### Amendments folded in from the challenge panel …` at 845.
+  // The second is a SUBSECTION of the first, not a rival for it, and counting it turned a feature
+  // whose rows are genuinely broken from `fail` into `not-established` — a gate that answers "I
+  // cannot tell" where it used to name six bad rows is a REGRESSION dressed as caution. So a
+  // duplicate is a later heading at the SAME depth or shallower; anything deeper is a child.
+  const re = /^ {0,3}(#{2,4})\s+Amendments\b/gm;
+  let first: number | null = null;
+  let count = 0;
+  for (let m = re.exec(mask); m !== null; m = re.exec(mask)) {
+    const depth = (m[1] as string).length;
+    if (first === null) {
+      first = depth;
+      count = 1;
+      continue;
+    }
+    if (depth <= first) count++;
+  }
+  return count;
+}
+
+/**
+ * Does the heading itself declare "none"? `## Amendments: None` is the form the pipeline's own
+ * Step-8 module documents (`.claude/skills/feature-adr/modules/08-qe.md:166`), and until 2026-09-06
+ * `amendmentSection` ate `: None` as part of the heading and returned an EMPTY body, so the
+ * explicit-none branch never ran and the gate answered NOT-ESTABLISHED (exit 3) on a plan that had
+ * said its piece (Codex cross-family review round 2, P2).
+ *
+ * A DECLARATION, not a qualifier: a separator (`:` or a dash) must precede the word, and the word
+ * must end there. That rule was chosen from the corpus rather than invented — the 363 features
+ * carry `## Amendments (carried verbatim into the plan)` (8×), `## Amendments — conditions before
+ * plan/code`, `## Amendments applied before Step 6` and `## Amendments and confirmation
+ * obligations`, and none of them may read as "none". Whole-utterance matching refuses
+ * `none-blocking`; an optional whitespace-separated closing `#` sequence is heading furniture.
+ */
+function headingSaysNone(md: string): boolean {
+  const m = AMENDMENT_HEADING.exec(maskNonRendered(md));
+  if (!m) return false;
+  const suffix = m[1 + 1] ?? '';
+  const sep = HEADING_DECLARATION_SEPARATOR.exec(suffix);
+  if (!sep) return false;
+  // CommonMark §4.2 permits an optional closing `#` sequence when whitespace separates it from
+  // the heading text. `None##` deliberately stays text because it has no separating whitespace.
+  const declaration = suffix.slice((sep[0] as string).length).replace(/[ \t]+#+[ \t]*$/, '').trim();
+  // The WHOLE remainder must be the declaration (round 7, P1): `## Amendments: None` is an answer,
+  // `## Amendments: None of the panel rows landed` is a sentence about outstanding work.
+  return NONE_DECLARATION_EXACT.test(declaration);
+}
+
+/**
+ * The `## Amendments` section body AND the same body with fenced examples blanked out. Both are
+ * returned because they answer different questions: the RAW body is what a row's text is, and the
+ * MASKED body is what counts as a row or as a heading at all. Two callers, one traversal, no way
+ * for them to disagree about where the section is.
+ */
+function amendmentSectionPair(md: string): { raw: string; masked: string } | null {
+  const mask = maskNonRendered(md);
+  const m = AMENDMENT_HEADING.exec(mask);
+  if (!m) return null;
+  const start = m.index + (m[0] as string).length;
+  const depth = (m[1] as string).length;
+  // The boundary is searched in the MASK for the same reason the heading is: a `## Something`
+  // inside a fenced example does not end the section, it illustrates one.
+  //
+  // And it ends only at a heading of the SAME depth or SHALLOWER. A `### Amendments folded in from
+  // the challenge panel` under a `## Amendments` is a CHILD, and round 6 made it a non-duplicate
+  // for the ambiguity count while parsing still stopped dead at it — so `## Amendments: None` plus
+  // a deeper subsection full of rows read as zero rows and answered skip/exit 0 (MEASURED
+  // 2026-09-06, Codex round 7, P1). One rule for both questions: deeper is inside.
+  const rest = mask.slice(start);
+  const boundary = /^ {0,3}(#{1,6})\s+\S/gm;
+  let end = md.length;
+  for (let b = boundary.exec(rest); b !== null; b = boundary.exec(rest)) {
+    if ((b[1] as string).length <= depth) {
+      end = start + b.index;
+      break;
+    }
+  }
+  return { raw: md.slice(start, end), masked: mask.slice(start, end) };
+}
 
 /** The `## Amendments` section body, or null when the document has none (acid case A5). */
 export function amendmentSection(md: string): string | null {
-  const m = /^ {0,3}#{2,4}\s+Amendments\b[^\n]*\n/m.exec(md);
-  if (!m) return null;
-  const start = m.index + m[0].length;
-  const rest = md.slice(start);
-  const next = /^ {0,3}#{2,4}\s+\S/m.exec(rest);
-  return next ? rest.slice(0, next.index) : rest;
+  return amendmentSectionPair(md)?.raw ?? null;
 }
 
 /** `## Amendments` present but recording nothing to check — distinct from the section being absent. */
 export function planSaysNoAmendments(planMd: string): boolean {
   const sec = amendmentSection(planMd);
   if (sec === null) return false;
-  return /^\s*(none|n\/a|нет)\b/i.test(sec.trim());
+  // BOTH homes of the same declaration: the section body, and the heading suffix. A reader that
+  // knows only one of them tells a plan that answered honestly that its grammar matched nothing.
+  // The body form is the FIRST PARAGRAPH, whole: `None.` is a declaration, `None of the rows has
+  // been written yet.` is prose about outstanding work and used to pass as one (round 7, P1).
+  const firstParagraph = (sec.trim().split(/\n\s*\n/)[0] ?? '').trim();
+  return headingSaysNone(planMd) || NONE_DECLARATION_EXACT.test(firstParagraph);
 }
 
 export function parseAmendments(md: string): AmendmentRow[] {
-  const section = amendmentSection(md);
-  if (section === null) return [];
-  const starts: { index: number; num: string }[] = [];
+  const pair = amendmentSectionPair(md);
+  if (pair === null) return [];
+  const section = pair.raw;
+  // Rows are FOUND in the masked body (a fenced `- AM-9 …` is an example of the form, not an
+  // amendment) and SLICED from the raw one, which is the text the row actually carries. The mask is
+  // length-preserving, so an index means the same byte in both.
+  const scan = pair.masked;
+  const starts: { index: number; prefix: string; num: string }[] = [];
   ROW_START.lastIndex = 0;
-  for (let m = ROW_START.exec(section); m !== null; m = ROW_START.exec(section)) {
-    starts.push({ index: m.index, num: (m[1] ?? m[2]) as string });
+  for (let m = ROW_START.exec(scan); m !== null; m = ROW_START.exec(scan)) {
+    // group 1 is the optional `CP-` prefix, group 2 the number. The prefix is kept because it is
+    // part of the id (backlog a7d0aece) — dropping it merges two provenances into one identity.
+    starts.push({ index: m.index, prefix: m[1] ?? '', num: m[2] as string });
   }
   const rows: AmendmentRow[] = [];
   for (let i = 0; i < starts.length; i++) {
-    const s = starts[i] as { index: number; num: string };
+    const s = starts[i] as { index: number; prefix: string; num: string };
     const end = i + 1 < starts.length ? (starts[i + 1] as { index: number }).index : section.length;
     const raw = section.slice(s.index, end);
-    rows.push({ id: `AM-${s.num}`, testIds: extractTestIds(raw), file: extractFile(raw), raw });
+    // Pointers are read from the MASKED slice: a fenced example inside this row's block illustrates
+    // the form, it does not answer for the row (Codex round 4, P2 — it used to, and that resolved a
+    // testless amendment).
+    const rowScan = scan.slice(s.index, end);
+    rows.push({ id: `AM-${s.prefix}${s.num}`, testIds: extractTestIds(rowScan), file: extractFile(rowScan), raw, scan: rowScan });
   }
   return rows;
 }
@@ -180,7 +536,9 @@ export function resolveAmendments(
   for (const row of rows) {
     // A retraction is checked BEFORE the missing-pointer branch: a row that says it was superseded
     // is not a row that forgot its test.
-    if (SUPERSEDED.test(row.raw)) {
+    // The masked slice, for the same reason the pointer is: a retraction shown INSIDE a fenced
+    // example is an illustration of the form, not this row's retraction.
+    if (SUPERSEDED.test(rowScan(row))) {
       out.push({ id: row.id, testId: null, file: row.file, verdict: 'superseded', detail: 'the plan retracted this amendment and named its successor' });
       continue;
     }
@@ -260,6 +618,18 @@ export function decideAmendmentOutcome(input: {
   readError?: string | null;
   /** Ideation amendments the plan fails to carry — absent, or reworded under the same id. */
   missingFromPlan?: readonly { id: string; kind: 'dropped' | 'subject-changed' }[];
+  /**
+   * How many RENDERED `## Amendments` sections the inputs open (`amendmentSectionCount`). Optional
+   * for backward compatibility — absent means "not measured", never "exactly one".
+   */
+  sectionCount?: number;
+  /**
+   * Amendment-shaped content found below the section heading in RENDERED text
+   * (`amendmentDeclarationAmbiguity`). Optional for backward compatibility — absent means "not
+   * measured". Present WITH zero parsed rows is the fail-closed trigger: parser and document
+   * disagree, so the run is inconclusive rather than skipped.
+   */
+  ambiguity?: { readonly line: number; readonly text: string } | null;
 }): AmendmentDecision {
   const counts: Record<AmendmentVerdict, number> = { ...ZERO_COUNTS };
   for (const r of input.resolutions) counts[r.verdict]++;
@@ -278,6 +648,55 @@ export function decideAmendmentOutcome(input: {
       counts,
     };
   }
+  // A document that opens the section TWICE contradicts itself, and the first heading used to answer
+  // for both — a stale `## Amendments: None` above the real section bought a skip while the real
+  // section's rows were never parsed (Codex round 6, P2; MEASURED skip/exit 0). Refused BEFORE the
+  // explicit-none branch, and refused as INCONCLUSIVE rather than as a failure: which section is
+  // authoritative is not something this checker can decide, and guessing would be the same class of
+  // lie in a new place.
+  if ((input.sectionCount ?? 0) > 1) {
+    return {
+      outcome: 'not-established',
+      exit: 3,
+      reasons: [
+        `the document opens more than one rendered \`## Amendments\` section (${input.sectionCount}) — which one is authoritative is not decidable here, and the first one must never answer for the rest`,
+      ],
+      counts,
+    };
+  }
+  // An explicit "None" is an ANSWER; zero rows from a section that says nothing is a BLIND SPOT.
+  // Until 2026-09-06 the blind-spot branch below ran first, so a plan that honestly declared it had
+  // no amendments got NOT-ESTABLISHED (exit 3) — an inconclusive verdict on a document that was
+  // complete. MEASURED on this feature's own plan (backlog ce2da797e17a7a7f):
+  // `dz amendment-check --feature-dir features/amendment-trace-cp-prefix --json` → exit 3 with
+  // "the grammar matched nothing". The two facts are opposites and must not share a verdict.
+  // GUARDED: only when nothing is OWED. A gap carried in from the ideation side is owed, so an
+  // explicit "None" may never be the reason a dropped amendment exits 0 (that case falls through
+  // to the blind-spot branch, which is inconclusive — never a pass).
+  if (input.rows.length === 0 && input.planSaysNone && (input.missingFromPlan ?? []).length === 0) {
+    // FAIL-CLOSED (round 7): a declaration only answers for a document that carries nothing
+    // amendment-shaped below it. If it does and NOTHING parsed, the parser and the document
+    // disagree — which is exactly the shape every one of the seven review rounds arrived in — and a
+    // disagreement is NOT-ESTABLISHED. Absence of a receipt is not success.
+    if (input.ambiguity) {
+      return {
+        outcome: 'not-established',
+        exit: 3,
+        reasons: [
+          `the \`## Amendments\` section declares no amendments but AM-like content exists at line ${input.ambiguity.line} ("${input.ambiguity.text}") while ZERO rows parsed — the declaration and the document disagree, and a disagreement is never a pass`,
+        ],
+        counts,
+      };
+    }
+    return {
+      outcome: 'skip',
+      exit: 0,
+      reasons: [
+        'the `## Amendments` section explicitly declares no amendments ("None"/"нет"/"n/a") and zero rows parsed — an explicit absence, which is an answer and not a grammar failure (an absence is a skip, never a pass)',
+      ],
+      counts,
+    };
+  }
   // The whole class this feature removes: a check that silently checked nothing (AM-1, acid case A7).
   if (input.rows.length === 0) {
     return {
@@ -355,7 +774,10 @@ export function amendmentSubject(raw: string): string {
   // a colon. An earlier version consumed up to 80 characters after the id, which ate the SUBJECT
   // itself whenever a row carried no `(source):` tag — the checker then compared two truncations
   // and called honest rows a mismatch.
-  const stripped = withoutPointer.replace(/^[\s|*\-]*\**AM-\d+\**\s*(?:\([^)]{0,80}\))?\s*:?\s*/, '');
+  // `AM-CP-N` is furniture too. Until 2026-09-05 this pattern demanded a digit straight after
+  // `AM-`, so a panel row's own id stayed inside its "subject" and every CP row read as a different
+  // change from every other one (backlog a7d0aece).
+  const stripped = withoutPointer.replace(/^[\s|*\-]*\**AM-(?:CP-)?\d+\**\s*(?:\([^)]{0,80}\))?\s*:?\s*/, '');
   return normalizeTestId(stripped);
 }
 
@@ -382,8 +804,8 @@ export function amendmentsMissingFromPlan(
       gaps.push({ id: row.id, kind: 'dropped' });
       continue;
     }
-    const want = amendmentSubject(row.raw);
-    const got = amendmentSubject(planRow.raw);
+    const want = amendmentSubject(rowScan(row));
+    const got = amendmentSubject(rowScan(planRow));
     // Containment either way: a plan may append a note ("closes HIGH-2"), and ideation may be the
     // longer prose. What it may not do is describe a different change.
     if (want.length >= MIN_MATCHABLE_ID_LENGTH && !got.includes(want) && !want.includes(got)) {