@pareto4/pp-core 1.12.1 → 1.17.1

package/scripts/gen-practice-arithmetic-contract.cjs

@@ -0,0 +1,412 @@
+#!/usr/bin/env node
+/**
+ * Inject the canonical practice-verdict arithmetic contract into every
+ * instruction surface that states it.
+ *
+ * WHY THIS EXISTS. Phase 6 verification took seven passes and found eight gaps.
+ * Every one had the same root cause: one contract restated in English on five
+ * surfaces, with nothing keeping the copies true. Two of the gaps were defects
+ * introduced while repairing another.
+ *
+ * WHY GENERATION AND NOT AN `@`-INCLUDE — checked, not assumed, because
+ * ignoring the delivering surface is exactly what produced three of those
+ * misses. `agents/pp-vault-reviewer.md` and
+ * `pp-core/references/verifier-practice-verdicts.md` carry no `@`-includes; the
+ * text must be physically present for the agent reading them. And
+ * `steps/verifier-practice-payload.md` is interpolated VERBATIM into
+ * pp-verifier's prompt (execute-phase.md:1358 -> :1382), so an `@` line there
+ * would reach the agent as literal text. Physical copies are required, so this
+ * follows the repo's existing answer for required-but-must-not-drift copies:
+ * `gen-capability-registry`, `gen-platform-bindings-schema --check`.
+ *
+ * NOT A TARGET: `pp-core/templates/VAULT-REVIEW.md`. Its prose is a worked
+ * sample the agent ADAPTS, not normative text — verified by diffing the
+ * template against an artifact a reviewer actually wrote, where the wording
+ * legitimately differs. It stays guarded mechanically instead, by the
+ * arithmetic sweep in `tests/vault-review.test.cjs`.
+ *
+ * THE UNIT OF GOVERNANCE IS THE FILE, NOT THE REGION (06-16, gap G10).
+ * Verification pass 8 reproduced the hole this originally left: it replaced
+ * `verifier-practice-verdicts.md:98-100` — thirty lines ABOVE that file's own
+ * generated block, outside every marker — with the contract's exact inverse,
+ * and `--check`, `lint:ci` and the suite all stayed green. Marker-region
+ * equality says nothing about the rest of the file, and an agent reads a file
+ * linearly, so the hand-written copy is the one it meets first.
+ *
+ * So `--check` also runs a RESIDUE SCAN: for each target, the text outside its
+ * region is scanned for the contract's load-bearing needles. The needle list is
+ * NOT hardcoded here — it lives in a second marker region in the same single
+ * source, so the guard cannot drift from the contract it guards. One file owns
+ * both the canonical text and what counts as restating it.
+ *
+ * THE SCAN GOVERNS TEXT, NOT LINE BREAKS (06-17, W13). It runs the needles
+ * twice: once per raw line, and once over joined normalised windows, reporting
+ * the second as its own class only where no single line in the window matches.
+ * Verification pass 9 measured why: the per-line pass alone was defeated by an
+ * ordinary markdown wrap, using nothing but the needles' own phrases. See
+ * `scanResidue`.
+ *
+ * `--write` deliberately does NOT scan. Generation injects; it must never
+ * delete a surface's prose on the strength of a regex.
+ *
+ * Usage: --write (inject) | --check (exit 1 on drift OR residue, for lint:ci)
+ *
+ * Exit codes use `process.exitCode` + `return`, never `process.exit()`: the
+ * repo's `n/no-process-exit` rule forbids the latter, and the lint scripts here
+ * already use this form.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const ROOT = path.join(__dirname, '..');
+const SOURCE = path.join(ROOT, 'pp-core', 'references', 'practice-arithmetic-contract.md');
+const ALLOWLIST = path.join(ROOT, 'scripts', 'practice-arithmetic-contract.allow.json');
+const S_START = '<!-- gen:practice-arithmetic-contract:source:start -->';
+const S_END = '<!-- gen:practice-arithmetic-contract:source:end -->';
+const N_START = '<!-- gen:practice-arithmetic-contract:needles:start -->';
+const N_END = '<!-- gen:practice-arithmetic-contract:needles:end -->';
+const START = '<!-- gen:practice-arithmetic-contract:start -->';
+const END = '<!-- gen:practice-arithmetic-contract:end -->';
+
+/** The four INSTRUCTION surfaces. The template is deliberately absent (see above). */
+const TARGETS = [
+  'pp-core/workflows/vault-review.md',
+  'agents/pp-vault-reviewer.md',
+  'pp-core/references/verifier-practice-verdicts.md',
+  'pp-core/workflows/execute-phase/steps/verifier-practice-payload.md',
+];
+
+function readCanonical() {
+  const text = fs.readFileSync(SOURCE, 'utf-8');
+  const a = text.indexOf(S_START);
+  const b = text.indexOf(S_END);
+  if (a === -1 || b === -1 || b < a) {
+    throw new Error(`${SOURCE}: source markers missing or inverted — cannot generate`);
+  }
+  const body = text.slice(a + S_START.length, b).trim();
+  if (!body) throw new Error(`${SOURCE}: canonical block is empty — refusing to blank every target`);
+  return body;
+}
+
+/**
+ * The residue needles, read from the SAME source file as the canonical text and
+ * with the SAME empty-block refusal. A needle line is `- ` + a backtick-quoted
+ * regex source + ` — ` + why it is load-bearing; the description may itself
+ * contain backticks, so only the FIRST backtick span is the pattern.
+ *
+ * A non-blank line that does not parse is a hard error. A silently skipped
+ * needle is a guard that has quietly stopped guarding, which is the whole class
+ * this file exists to end.
+ */
+function readNeedles() {
+  const text = fs.readFileSync(SOURCE, 'utf-8');
+  const a = text.indexOf(N_START);
+  const b = text.indexOf(N_END);
+  if (a === -1 || b === -1 || b < a) {
+    throw new Error(`${SOURCE}: needle markers missing or inverted — cannot scan for residue`);
+  }
+  const body = text.slice(a + N_START.length, b).trim();
+  if (!body) throw new Error(`${SOURCE}: the needle list is empty — refusing to scan for nothing`);
+
+  const needles = [];
+  for (const raw of body.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line) continue;
+    const m = /^-\s+`([^`]+)`\s+—\s+(\S.*)$/.exec(line);
+    if (!m) {
+      throw new Error(
+        `${SOURCE}: unparseable needle line — expected "- \`<regex>\` — <why>", got:\n  ${line}`,
+      );
+    }
+    let re;
+    try {
+      re = new RegExp(m[1], 'i');
+    } catch (err) {
+      throw new Error(`${SOURCE}: needle \`${m[1]}\` is not a valid regex — ${err.message}`);
+    }
+    needles.push({ source: m[1], re, why: m[2] });
+  }
+  if (!needles.length) throw new Error(`${SOURCE}: the needle list parsed to zero needles`);
+  return needles;
+}
+
+const sha256 = (s) => crypto.createHash('sha256').update(s, 'utf-8').digest('hex');
+
+/**
+ * Allowlist entries are keyed by target path and hash the EXACT allowed line.
+ * Content-hashing is `06-02`'s mechanism for the protected `pp-vault-audit`
+ * sites: editing an allowed line breaks its entry, so an allowance can never
+ * quietly widen to cover text nobody justified. A `reason` is mandatory.
+ *
+ * An ABSENT allowlist means nothing is allowed — the fail-closed direction.
+ */
+function readAllowlist() {
+  if (!fs.existsSync(ALLOWLIST)) return {};
+  const raw = JSON.parse(fs.readFileSync(ALLOWLIST, 'utf-8'));
+  const out = {};
+  for (const [file, entries] of Object.entries(raw)) {
+    if (file.startsWith('//')) continue; // a comment key, never a path
+    if (!TARGETS.includes(file)) {
+      throw new Error(
+        `${ALLOWLIST}: "${file}" is not one of the generated targets. ` +
+          'A stale key means the allowlist outlived the file it excused — re-justify or delete it.',
+      );
+    }
+    if (!Array.isArray(entries)) throw new Error(`${ALLOWLIST}: "${file}" must map to an array`);
+    for (const e of entries) {
+      if (!/^[0-9a-f]{64}$/.test(String(e && e.sha256))) {
+        throw new Error(`${ALLOWLIST}: "${file}" has an entry without a 64-hex sha256`);
+      }
+      if (!String((e && e.reason) || '').trim()) {
+        throw new Error(
+          `${ALLOWLIST}: "${file}" entry ${e.sha256.slice(0, 12)} has no reason. ` +
+            'An unjustified allowance is a rubber stamp; state why the line is not a restatement.',
+        );
+      }
+    }
+    out[file] = entries;
+  }
+  return out;
+}
+
+/**
+ * Adjacent non-blank lines outside the region, joined with a single space and
+ * whitespace-collapsed. A markdown paragraph is one window.
+ *
+ * Joining a whole run rather than sliding a 2-line window is not a wider net:
+ * the needles are contiguous phrases, so the only adjacencies a join creates
+ * are the ones at line boundaries — exactly the adjacencies the wrap destroyed.
+ * A run simply also covers a phrase a reflow spread over three lines.
+ */
+function normalisedWindows(lines, inRegion) {
+  const windows = [];
+  let run = [];
+  const flush = () => {
+    // A one-line run says nothing the per-line pass did not already say.
+    if (run.length > 1) windows.push(run);
+    run = [];
+  };
+  lines.forEach((line, i) => {
+    if (inRegion(i) || !line.trim()) {
+      flush();
+      return;
+    }
+    run.push({ line, i });
+  });
+  flush();
+  return windows;
+}
+
+/**
+ * Scan one target's text OUTSIDE its generated region. Returns findings and the
+ * set of allowlist hashes this file actually used, so an entry that matches no
+ * line can be reported as rotted rather than sitting there looking like cover.
+ *
+ * TWO PASSES, and the second is additive (06-17, W13).
+ *
+ * The first tests each raw LINE, which is what shipped and what the three
+ * allowlist entries hash. Verification pass 9 measured its ceiling: an ordinary
+ * markdown wrap defeats every multi-word needle, including the needles' OWN
+ * literal phrases — `two count` ending a line and `populations` opening the
+ * next scanned clean, while the same words on one line failed naming all four.
+ * The guard governed line breaks where it must govern text. Pass 9 probed all
+ * four targets and found 0 live instances, so this was latent coverage rather
+ * than residue at HEAD; the trigger, though, is an accidental prose reflow and
+ * the direction of failure is silent.
+ *
+ * So the second pass runs the same needles over joined normalised WINDOWS, and
+ * reports a hit only when the needle matches the window and matches NO single
+ * line within it. That makes a wrap-only match its own named class instead of
+ * folding it into the per-line one, and it leaves per-line semantics — and
+ * therefore the existing allowlist hashes — exactly as they were.
+ *
+ * A wrap-only finding is allowlistable like any other, but its hash is of the
+ * JOINED NORMALISED WINDOW, not of a raw line, and `--check` prints that exact
+ * text beside the hash so nobody has to reconstruct it. That digest is stable
+ * under a reflow of the same words, which is the right behaviour: what somebody
+ * justified is the sentence, not where its line breaks happened to fall.
+ */
+function scanResidue(file, needles, allowed) {
+  const abs = path.join(ROOT, file);
+  // Split on /\r?\n/, not '\n': the allowlist hashes the EXACT line, so a
+  // CRLF checkout must not produce a different digest for the same text.
+  const lines = fs.readFileSync(abs, 'utf-8').split(/\r?\n/);
+  const a = lines.findIndex((l) => l.includes(START));
+  const b = lines.findIndex((l) => l.includes(END));
+  const inRegion = (i) => a !== -1 && b >= a && i >= a && i <= b;
+
+  const allowedHashes = new Map((allowed[file] || []).map((e) => [e.sha256, e.reason]));
+  const used = new Set();
+  const findings = [];
+  const wrapped = [];
+
+  lines.forEach((line, i) => {
+    if (inRegion(i)) return;
+    const hits = needles.filter((n) => n.re.test(line));
+    if (!hits.length) return;
+    const h = sha256(line);
+    if (allowedHashes.has(h)) {
+      used.add(h);
+      return;
+    }
+    findings.push({ file, line: i + 1, text: line, hits: hits.map((n) => n.source), sha256: h });
+  });
+
+  for (const run of normalisedWindows(lines, inRegion)) {
+    const text = run
+      .map((r) => r.line.trim())
+      .join(' ')
+      .replace(/\s+/g, ' ');
+    // `n.re.test(r.line)` against the RAW line, exactly as the first pass tests
+    // it, so "wrap-only" means precisely "the first pass could not have seen
+    // this" — including when the first pass saw it and the allowlist excused it.
+    const hits = needles.filter((n) => n.re.test(text) && !run.some((r) => n.re.test(r.line)));
+    if (!hits.length) continue;
+    const h = sha256(text);
+    if (allowedHashes.has(h)) {
+      used.add(h);
+      continue;
+    }
+    wrapped.push({
+      file,
+      line: run[0].i + 1,
+      endLine: run[run.length - 1].i + 1,
+      text,
+      hits: hits.map((n) => n.source),
+      sha256: h,
+    });
+  }
+
+  const unused = [...allowedHashes.keys()].filter((h) => !used.has(h));
+  return { findings, wrapped, unused };
+}
+
+function apply(file, canonical, { write }) {
+  const abs = path.join(ROOT, file);
+  const text = fs.readFileSync(abs, 'utf-8');
+  const a = text.indexOf(START);
+  const b = text.indexOf(END);
+  if (a === -1 || b === -1) {
+    return { file, status: 'missing-markers' };
+  }
+  if (b < a) return { file, status: 'inverted-markers' };
+
+  const desired = `${START}\n${canonical}\n${END}`;
+  const current = text.slice(a, b + END.length);
+  if (current === desired) return { file, status: 'unchanged' };
+  if (write) {
+    fs.writeFileSync(abs, text.slice(0, a) + desired + text.slice(b + END.length), 'utf-8');
+    return { file, status: 'transformed' };
+  }
+  return { file, status: 'drifted' };
+}
+
+function main() {
+  const write = process.argv.includes('--write');
+  const check = process.argv.includes('--check');
+  if (write === check) {
+    console.error('usage: gen-practice-arithmetic-contract.cjs (--write | --check)');
+    process.exitCode = 2;
+    return;
+  }
+
+  const canonical = readCanonical();
+  const results = TARGETS.map((f) => apply(f, canonical, { write }));
+
+  const bad = results.filter((r) => r.status !== 'unchanged' && r.status !== 'transformed');
+  for (const r of bad) console.error(`  ${r.status}: ${r.file}`);
+
+  if (check) {
+    if (bad.length) {
+      console.error(
+        `\nFAIL: ${bad.length} surface(s) drifted from ${path.relative(ROOT, SOURCE)}.\n` +
+          'Edit that file, then run: npm run gen:practice-arithmetic-contract',
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    // The residue scan. Region equality is necessary and not sufficient: a
+    // surface can restate the contract by hand ANYWHERE ELSE in the same file,
+    // where the region comparison never looks. That is G10.
+    const needles = readNeedles();
+    const allowed = readAllowlist();
+    const findings = [];
+    const wrapped = [];
+    const rotted = [];
+    for (const file of TARGETS) {
+      const r = scanResidue(file, needles, allowed);
+      findings.push(...r.findings);
+      wrapped.push(...r.wrapped);
+      for (const h of r.unused) rotted.push({ file, sha256: h });
+    }
+
+    if (findings.length || wrapped.length) {
+      console.error(
+        `\nFAIL: ${findings.length + wrapped.length} hand-written restatement(s) of the contract, OUTSIDE the generated region:\n`,
+      );
+      for (const f of findings) {
+        console.error(`  residue: ${f.file}:${f.line}  [${f.hits.join(', ')}]`);
+        console.error(`    ${f.text.trim()}`);
+      }
+      // Named as its own class: the phrase is only visible once the lines are
+      // joined, so the line number is a RANGE and the hash below is of the
+      // joined text, not of any line you can see in the file (06-17, W13).
+      for (const f of wrapped) {
+        console.error(`  wrapped residue: ${f.file}:${f.line}-${f.endLine}  [${f.hits.join(', ')}]`);
+        console.error(`    ${f.text}`);
+      }
+      console.error(
+        '\nREMEDY: replace the sentence with a POINTER to the generated block in the same file\n' +
+          '("§7 states the rule; it is not restated here"), keeping only what the canonical block\n' +
+          'does not say — a per-tier destination, for instance. The facts stay physically present\n' +
+          'in the file, in the generated block the agent also reads.\n' +
+          `If the line genuinely restates nothing, allowlist it in ${path.relative(ROOT, ALLOWLIST)}\n` +
+          'with its sha256 and a stated reason:\n',
+      );
+      for (const f of findings) console.error(`  "${f.file}": [{ "sha256": "${f.sha256}", "reason": "…" }]`);
+      if (wrapped.length) {
+        console.error(
+          '\nA WRAPPED finding is hashed over the JOINED, whitespace-collapsed text printed above —\n' +
+            'not over any single line of the file. The digest therefore survives a reflow of the same\n' +
+            'words, because what an allowance justifies is the sentence, not its line breaks:\n',
+        );
+        for (const f of wrapped) console.error(`  "${f.file}": [{ "sha256": "${f.sha256}", "reason": "…" }]`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+
+    if (rotted.length) {
+      console.error(
+        `\nFAIL: ${rotted.length} allowlist entr(ies) match no line or window in their file:\n`,
+      );
+      for (const r of rotted) console.error(`  rotted: ${r.file}  ${r.sha256}`);
+      console.error(
+        '\nThe allowed line was edited or removed. Re-justify the new line or delete the entry —\n' +
+          'an allowance nobody can point at is exactly the rubber stamp content-hashing prevents.',
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    const allowCount = Object.values(allowed).reduce((n, e) => n + e.length, 0);
+    console.log(
+      `ok practice-arithmetic-contract: ${results.length} surface(s) match the source; ` +
+        `no residue outside the regions, per line or across a wrap (${needles.length} needles, ` +
+        `${allowCount} allowlisted).`,
+    );
+    return;
+  }
+
+  const t = results.filter((r) => r.status === 'transformed').length;
+  const u = results.filter((r) => r.status === 'unchanged').length;
+  if (bad.length) {
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`Done. ${t} transformed, ${u} unchanged.`);
+}
+
+main();

package/scripts/lib/allowlist-ratchet.cjs

@@ -233,106 +233,4 @@ function assertFileBaseline({ label, current, baseline, fail, updateHint }) {
   return { grown, shrunk, added, removed };
 }
 
-/**
- * Assert that each artifact's measured size stays within a per-change DELTA
- * BUDGET of its committed baseline (workflow size budget policy, 2026-10-11).
- *
- * Unlike `assertFileBaseline` (exact-byte pins), small growth is absorbed by a
- * slack so routine edits need no baseline commit, while large or cumulative
- * growth still fails by name:
- *
- * - A file may exceed its baseline by at most `perFileSlack` bytes.
- * - The SUM of all positive overages may not exceed `totalSlack` bytes, so many
- *   small growths cannot add up to a large one unseen.
- * - Shrinking always passes and never needs a baseline commit.
- * - A file with no baseline entry (ADDED) or a baseline entry with no file
- *   (REMOVED) fails: the baseline must name exactly the files on disk.
- *   Recording either needs no reason.
- * - An EMPTY baseline fails: with no entries every file is "added", but an
- *   explicit message makes the vacuous-pass case impossible to misread.
- *
- * Overage is measured against the committed baseline, not the previous commit,
- * so the slack is a budget that a re-baseline resets — not a per-commit
- * allowance that can be spent again on every commit.
- *
- * @param {object} opts
- * @param {string} opts.label - Guard name (used in messages).
- * @param {Object<string, number>} opts.current  - Measured sizes by name.
- * @param {Object<string, number>} opts.baseline - Committed sizes by name
- *                                  (numbers only; strip metadata keys first).
- * @param {number} opts.perFileSlack - Max bytes one file may exceed its baseline.
- * @param {number} opts.totalSlack   - Max sum of all positive overages.
- * @param {function(string): void} opts.fail - Invoked once per violation category.
- * @param {string} [opts.updateHint] - Remediation hint appended to growth failures.
- * @returns {{ overages: Array<{name:string,from:number,to:number,delta:number}>,
- *             totalOverage: number,
- *             shrunk: Array<{name:string,from:number,to:number,delta:number}>,
- *             added: string[], removed: string[] }}
- */
-function assertDeltaBudget({ label, current, baseline, perFileSlack, totalSlack, fail, updateHint }) {
-  const currentNames = new Set(Object.keys(current));
-  const baselineNames = new Set(Object.keys(baseline));
-  const hint = updateHint ? `\n${updateHint}` : '';
-
-  if (baselineNames.size === 0) {
-    fail(
-      `[${label}] the committed baseline has no size entries — an empty baseline would make ` +
-        `every growth check pass vacuously. Regenerate it with \`npm run size:baseline\`.`
-    );
-  }
-
-  const added = [...currentNames].filter((n) => !baselineNames.has(n)).sort();
-  const removed = [...baselineNames].filter((n) => !currentNames.has(n)).sort();
-
-  const overages = [];
-  const shrunk = [];
-  for (const name of [...currentNames].filter((n) => baselineNames.has(n)).sort()) {
-    const from = baseline[name];
-    const to = current[name];
-    if (!Number.isInteger(from) || from < 0) {
-      fail(`[${label}] baseline entry ${name} is not a non-negative integer byte size: ${JSON.stringify(from)}`);
-      continue;
-    }
-    if (to > from) overages.push({ name, from, to, delta: to - from });
-    else if (to < from) shrunk.push({ name, from, to, delta: from - to });
-  }
-  const totalOverage = overages.reduce((sum, o) => sum + o.delta, 0);
-  const fmt = (o) => `  - ${o.name}: ${o.from} → ${o.to} (+${o.delta})`;
-
-  const overFile = overages.filter((o) => o.delta > perFileSlack);
-  if (overFile.length > 0) {
-    fail(
-      `[${label}] ${overFile.length} file(s) grew more than the per-file slack of ${perFileSlack} bytes ` +
-        `past the committed baseline. Shrink them (extract content lazily), or re-baseline with a ` +
-        `reason: npm run size:baseline -- --reason "<why this growth is needed>"\n` +
-        `${overFile.map(fmt).join('\n')}${hint}`
-    );
-  }
-
-  if (totalOverage > totalSlack) {
-    fail(
-      `[${label}] total growth past the committed baseline is ${totalOverage} bytes, over the total ` +
-        `slack of ${totalSlack} bytes (each file may be under its own slack — the sum is what failed). ` +
-        `Shrink, or re-baseline with a reason: npm run size:baseline -- --reason "<why>"\n` +
-        `${overages.map(fmt).join('\n')}${hint}`
-    );
-  }
-
-  if (added.length > 0) {
-    fail(
-      `[${label}] ${added.length} file(s) are not in the baseline — run \`npm run size:baseline\` ` +
-        `to record them (no --reason needed for new files).\n${added.map((n) => `  - ${n}`).join('\n')}`
-    );
-  }
-
-  if (removed.length > 0) {
-    fail(
-      `[${label}] ${removed.length} baseline entry(ies) no longer exist — run \`npm run size:baseline\` ` +
-        `to drop them (no --reason needed).\n${removed.map((n) => `  - ${n}`).join('\n')}`
-    );
-  }
-
-  return { overages, totalOverage, shrunk, added, removed };
-}
-
-module.exports = { assertWithinAllowlist, assertTightCeiling, assertFileBaseline, assertDeltaBudget };
+module.exports = { assertWithinAllowlist, assertTightCeiling, assertFileBaseline };

package/scripts/lint-allow-test-rule-refs.allowlist.json

@@ -288,7 +288,6 @@
   "tests/read-guard.test.cjs :: source-text-is-the-product",
   "tests/reapply-patches.test.cjs :: source-text-is-the-product",
   "tests/reapply-verify-hunks.test.cjs :: source-text-is-the-product",
-  "tests/release-coverage-scope.test.cjs :: source-text-is-the-product",
   "tests/release-tarball-smoke-workflow.test.cjs :: source-text-is-the-product",
   "tests/release-tarball-smoke.install.test.cjs :: integration-test-input",
   "tests/research-agent-profiles.test.cjs :: <runtime-contract-is-the-product> research agent .md content is the governed surface",
@@ -321,7 +320,6 @@
   "tests/windows-test-parity-guard.test.cjs :: structural-regression-guard",
   "tests/workflow-compat.test.cjs :: source-text-is-the-product",
   "tests/workflow-guard-registration.test.cjs :: structural-regression-guard",
-  "tests/workflow-maintainer-skip.test.cjs :: source-text-is-the-product",
   "tests/workflow-shell-pinning.test.cjs :: file-scope prefilter, not a test assertion — we need to",
   "tests/workflow-size-budget.test.cjs :: source-text-is-the-product",
   "tests/workspace.test.cjs :: source-text-is-the-product",

package/scripts/lint-pr-check-project-dir.cjs

@@ -9,9 +9,7 @@ const { runMain } = require('./lib/cli-exit.cjs');
 const ROOT = path.join(__dirname, '..');
 
 const DEFAULT_RELATIVE_FILES = [
-  '.github/workflows/test.yml',
-  '.github/workflows/pr-template-format.yml',
-  '.github/workflows/changeset-required.yml',
+  '.github/workflows/ci.yml',
   'scripts/lint-command-contract.cjs',
   'scripts/lint-skill-deps.cjs',
   'scripts/lint-descriptions.cjs',

package/scripts/lint-test-file-count.allowlist.json

@@ -114,6 +114,14 @@
       ],
       "issue": "180"
     },
+    "vault-review": {
+      "files": [
+        "vault-review.integration.test.cjs",
+        "vault-review.security.test.cjs",
+        "vault-review.test.cjs"
+      ],
+      "issue": "71924 — Vault Assurance phase 06 (06-03/06-04), three distinct concerns for pp-core/bin/lib/vault-review.cjs: vault-review.test (06-03 unit tests over every pure derivation — the verdict vocabularies, both derived-N-A arms, the counts arithmetic, the range resolver and the clean-render refusal predicate), vault-review.integration.test (06-04 SEAM tests — the deterministic validator of the agent-written artifact, plus the `check vault-review` arm driven through the real pp-core/bin/pp-tools.cjs, where the exit-0/no-block-key contract of D-06-01 and VERIFY-03 is proved at the boundary a gate enforcer actually reads, with RED control 2 proving that guard non-vacuous), and vault-review.security.test (06-04 ADVERSARIAL tests — a spoofed external-content fence-end marker, directive-shaped text and a forged tool-call block planted in real practice BODIES, proving 05-REVIEW's open Critical CR-02 is not repeated on this surface, plus the CR-03 class: no absolute filesystem path in any emitted byte). The split mirrors the `vault` cluster's own reasoning: the unit lane, the CLI seam and the security marker are independently load-bearing verification gates, and the `.security.test.cjs` marker is what makes the adversarial lane identifiable to a reader and to scripts/run-tests.cjs. Consolidating would blur three different questions into one file."
+    },
     "verify": {
       "files": [
         "bug-2969-verify-reapply-patches.test.cjs",
@@ -179,21 +187,24 @@
     },
     "vault": {
       "files": [
+        "feat-71924-vault-required-gate.test.cjs",
+        "vault-doors.integration.test.cjs",
         "vault-practices.property.test.cjs",
         "vault-read-path.test.cjs",
         "vault-security.test.cjs",
         "vault-status-check.test.cjs",
         "vault.test.cjs"
       ],
-      "issue": "v1.7.0 Client Vault Load — four distinct concerns: vault.test (fetch/status/summary unit), vault-security (VSEC-02/03 write-guard + secret/fence), vault-read-path (VGATE-03 SUMMARY pointer), vault-status-check (VGATE-02 gate-query handler). Phase 24-02 added vault-practices.property.test.cjs (fast-check fuzz of the practices glob-fallback compiler + a practices-frontmatter round-trip, PRAC-02) — it is grouped under this bucket rather than \"vault-practices\" because the test-file-count lint's hyphen-prefix matcher treats \"vault-practices.property\" (period before \"property\") as starting with \"vault-\" before it can match the more specific \"vault-practices-\" prefix; the module it actually tests is pp-core/bin/lib/vault-practices.cjs, not vault.cjs."
+      "issue": "v1.7.0 Client Vault Load — four distinct concerns: vault.test (fetch/status/summary unit), vault-security (VSEC-02/03 write-guard + secret/fence), vault-read-path (VGATE-03 SUMMARY pointer), vault-status-check (VGATE-02 gate-query handler). Phase 24-02 added vault-practices.property.test.cjs (fast-check fuzz of the practices glob-fallback compiler + a practices-frontmatter round-trip, PRAC-02) — it is grouped under this bucket rather than \"vault-practices\" because the test-file-count lint's hyphen-prefix matcher treats \"vault-practices.property\" (period before \"property\") as starting with \"vault-\" before it can match the more specific \"vault-practices-\" prefix; the module it actually tests is pp-core/bin/lib/vault-practices.cjs, not vault.cjs. Vault Assurance phase 02 (#71924) added feat-71924-vault-required-gate.test.cjs as the phase's ONE consolidated source-grep feature file — it owns the source-text assertions for GATE-02, GATE-03, GATE-06, GATE-08, GATE-09 and GATE-10 together, deliberately in a single file so the phase's six requirements do not each spawn a sibling; later plans in the phase extend it rather than adding files. Vault Assurance phase 16 plan 10 added vault-doors.integration.test.cjs as the phase's ONE door fence-proof owner (DOOR-01..05, D-09): every door's shipped fence (execute-plan, quick, fast, debug, the secondary doors) composed by tests/helpers/gate-fence-composer.cjs and run in bash and zsh, one describe per door plan, so 16-12..16-15 extend it rather than each adding a sibling. The hyphen-prefix matcher attributes it here because no vault-doors module exists; it tests workflow fences, not vault.cjs."
     },
     "vault-practices": {
       "files": [
         "vault-practices-examples.test.cjs",
         "vault-practices-matcher.test.cjs",
+        "vault-practices.slow.test.cjs",
         "vault-practices.test.cjs"
       ],
-      "issue": "Phase 24 (24-01/24-02/24-04) — three distinct concerns for pp-core/bin/lib/vault-practices.cjs: vault-practices.test (24-01 parser/validation/discovery unit tests), vault-practices-matcher.test (24-02 glob matcher + two-bucket result + report unit tests), vault-practices-examples.test (24-04 shipped-example drift guard + minimal-comments global-bucket smoke case, PRAC-03 Success Criterion 3). All three test the same production module and are each independently load-bearing; consolidating would blur distinct plan-level verification gates."
+      "issue": "Phase 24 (24-01/24-02/24-04) — three distinct concerns for pp-core/bin/lib/vault-practices.cjs: vault-practices.test (24-01 parser/validation/discovery unit tests), vault-practices-matcher.test (24-02 glob matcher + two-bucket result + report unit tests), vault-practices-examples.test (24-04 shipped-example drift guard + minimal-comments global-bucket smoke case, PRAC-03 Success Criterion 3). All three test the same production module and are each independently load-bearing; consolidating would blur distinct plan-level verification gates. Vault Assurance phase 05 (#71924) added vault-practices.slow.test.cjs — the >5 s six-axis worst-case matcher corpus for the same production module (pp-core/bin/lib/vault-practices.cjs), split out per the .slow suffix convention so the default suite stays fast; attributed here once the count lint learned to strip the .slow suffix."
     }
   }
 }

package/scripts/practice-arithmetic-contract.allow.json

@@ -0,0 +1,35 @@
+{
+  "//": [
+    "Lines that carry a residue needle but restate NO fact the canonical block states.",
+    "Read by scripts/gen-practice-arithmetic-contract.cjs --check. Keys starting with // are comments.",
+    "sha256 is of the EXACT allowed line. Editing that line breaks its entry and forces re-justification;",
+    "an entry matching no line in its file fails as rotted. A reason is mandatory.",
+    "A WRAPPED finding — one visible only once adjacent lines are joined — is hashed over the joined,",
+    "whitespace-collapsed window text that --check prints beside it, not over any single line of the",
+    "file. That digest survives a reflow of the same words, because what an allowance justifies is the",
+    "sentence and not where its line breaks fell. All three entries below are per-LINE. 06-17, W13.",
+    "Every entry below is the same shape: a payload-KEY INVENTORY, where `derivedCounts` /",
+    "`derivedRateLine` are named as things the CLI hands the agent, and the very next clause points at",
+    "the generated contract block rather than saying what they mean. Naming a key is not restating a",
+    "contract. Keep this file as close to empty as the prose allows.",
+    "06-16, gap G10."
+  ],
+  "pp-core/workflows/vault-review.md": [
+    {
+      "sha256": "1766709dca03a214fb8fa5496fe6b2aef06fc1b02e67832a6048eeac78e29d6a",
+      "reason": "Section 4 is the inventory of what REVIEW_PAYLOAD carries; this line names the two keys and its own continuation says what they describe is stated once in the contract block carried into the spawn prompt below. It states nothing itself."
+    }
+  ],
+  "agents/pp-vault-reviewer.md": [
+    {
+      "sha256": "1fac53fb5988ab5278f2a262f1564b5dbef830531ec0a82f7200c9b940b45b8d",
+      "reason": "The left cell of the supplied-fact table, where the key name IS the row's subject. The right cell is a pointer to the contract block twelve lines below, in the same <derived_facts> element."
+    }
+  ],
+  "pp-core/references/verifier-practice-verdicts.md": [
+    {
+      "sha256": "52872e6f4b821944e026667c5bd48a3c2319f6876e805e8721865cbf6eb27816",
+      "reason": "Section 6's inventory of what the check vault-review arm hands the verifier. The sentence that follows it points at section 7 and says explicitly that the rule is not restated here."
+    }
+  ]
+}