@event4u/agent-config 14.17.0 → 14.18.0

package/dist/shared/settingsConsent.js

@@ -15,7 +15,7 @@
  * would mean the agent could arrive at its own permission by observing the
  * world, which is the confused-deputy shape in miniature.
  *
- * Modelled on `src/scripts/hooks/block_unauthorized_git.ts`: answer from a
+ * Modelled on `src/scripts/hooks/git_command_classifier.ts`: answer from a
  * recorded fact rather than from the model's recollection, and treat a missing
  * record as NOT granted rather than as probably-fine.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@event4u/agent-config",
     "mcpName": "io.github.event4u-app/agent-config",
-    "version": "14.17.0",
+    "version": "14.18.0",
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) — every claim machine-checked, including the counts in these badges.",
     "license": "MIT",
     "private": false,

package/src/config/conformance-claim-baseline.json

@@ -0,0 +1,9 @@
+{
+  "_comment": "Pre-existing standard-conformance claims in src/skills/**/SKILL.md and src/rules/*.md that carry NO `enforced_by:` declaration. The list may only SHRINK — an entry whose artefact gained a declaration must leave it in the same change, and a new undeclared claim is never added. Written by road-to-defect-population-sweeps 3.2; enforced by tests/contracts/conformance_claim_declaration.test.ts.",
+  "_why_empty": "The measured population was TWO artefacts, not the large legacy set 3.2 anticipated, and both were declarable honestly in the same change: accessibility-auditor names its real resolver, design-review declares the gap with its reason. An empty baseline is the strongest state this ratchet can be in, not a missing one — the file exists so the mechanism is wired and testable, and so a future undeclared claim has somewhere it is conspicuously NOT allowed to land.",
+  "_known_out_of_scope": [
+    "src/skills/design-intelligence/references/design-rules-checklist.md — carries `WCAG 2.2 AA` in a dedup NOTE that points at accessibility-auditor rather than claiming conformance itself. Out of scope because roadmap step 3.1 scopes the bar to `a skill or rule`, and the scanned set is the artefacts that carry frontmatter: `SKILL.md` and `src/rules/*.md`. Recorded here rather than silently excluded."
+  ],
+  "count": 0,
+  "undeclared": []
+}

package/src/config/gate-violation-baselines.json

@@ -34,10 +34,10 @@
       "note": "The nine active non-draft roadmaps that predate the `relates:` requirement (road-to-agentic-engineering-assurance, road-to-component-library-lifecycle, road-to-council-evidence-integrity, road-to-frontend-fidelity-calibration, road-to-monorepo-scope-and-detection, road-to-observability-plate, road-to-role-scoped-spawn-profiles, road-to-skill-delivery-over-mcp, road-to-standing-payload-diet). This is a NEW obligation rather than a repaired scan root, and the ratchet is the point: `depends:` shipped in the template with nothing requiring it and measured 0 adoption, so requiring `relates:` retroactively across the estate would be an owner-reserved write with no analysis behind the edges it would have to invent (held as step 4.3, deferred). Clearing an entry here is one roadmap at a time: run `agent-config roadmap:context` on it, write the rows the probe surfaces, and lower the count."
     },
     "check_source_size_budget": {
-      "count": 18180,
-      "landed": "2026-09-03",
+      "count": 18068,
+      "landed": "2026-09-05",
       "note": "Lowered 18,245 -> 18,230 on 2026-09-02 by drain/publication-integrity-option-a. Phase 2 Option A moved the authoring instruction out of the generator: release.ts, which sits ~530 lines PAST the 1500 cap so every line there costs one excess, loses the comment emission, a 16-line HEAD_DEFAULT doc block and its alias const, and gains a shorter writer docstring. The doc block moved to _lib/release_material.ts, which is 289 lines and therefore UNDER the cap, so the same prose now costs nothing. Net -15. The branch first came in at +8 and paid its own way down rather than raising the baseline.",
-      "reason": "Lowered 18,230 -> 18,209 on 2026-09-03 by drain/artifact-location. `doctor --strict` needed 16 lines of integration wiring in cmd_doctor.ts, which sits ~2,100 lines PAST the 1500 cap so every line there costs one excess. The branch first came in at +137 and paid its own way down rather than raising the baseline: the strict semantics, threshold, kill switch, payload helper and argv fragments moved to _cli/_doctor_strict.ts (~160 lines, under the cap, costs nothing), taking it to +15; then the 37-line drift renderer moved to _cli/_doctor_emit.ts. Net -21. The renderer was chosen deliberately: pure rendering, two dependencies, no argparse involvement and therefore none of the byte-parity risk the parser surface carries against the retired Python implementation; nothing outside cmd_doctor.ts imported it. An AI council on the residual split (a: raise by 15 / d: descope the feature); neither was taken, because a parallel branch demonstrated the same day that paying down is achievable in this codebase, which is the evidence the split lacked. This gate's own test comment prescribes it: a commit that splits a god-file lowers the excess and must carry the lowered baseline. MERGE RECONCILIATION 2026-09-03, 18,209 -> 18,205: drain/wired-instruments and drain/artifact-location each lowered from the SAME 18,230 base in parallel -- the branch to 18,226 (net -4, run_continuation_hook.ts's termination ladder moved to _lib/continuation_ladder.ts and runtime_journal.ts's prose to _lib/outcome_vocabularies.ts, both under the cap) and main to 18,209 (net -21, the doctor --strict split above). Taking either side alone is wrong in a different direction: main's value silently discards the branch's earned -4, and the branch's value RAISES the baseline against main and weakens the gate. The committed number is neither -- it is the gate's own output on the merged tree, where both reductions apply. THIS LOCAL READING IS ADMISSIBLE HERE, and the discriminator matters because this file's ci-parity:local-only entry records a 165 -> 164 lowering that was reverted for exactly the opposite case: that count depends on how the environment resolves the projection surface, whereas this gate walks only SOURCE_ROOTS = ['src'] (check_source_size_budget.ts:88) counting excess lines over the 1500 ceiling, and `git status --porcelain -uall -- src/` reported ZERO untracked files, so a clean CI checkout of this commit measures the same 18,205. If CI reads anything else, CI's number is the correct one and this note is the record of why. LOWERED 18,205 -> 18,193 on 2026-09-03 by fix/release-curation-ask. The change adds a fifth publication guard, and its own additions landed at +10 excess: release.ts 2,008 -> 2,018, every line of which is past the 1500 cap. Paid down rather than baselined, in the two ways this gate's doctrine prescribes. The guard's rationale (~13 lines of docstring, including why prMerged is a parameter rather than a call-site if) lives in release_publication.ts, 915 lines and therefore UNDER the cap, so the prose costs nothing; and the two pure text helpers _splitlines and _rstrip moved out of release.ts into release_env.ts (333 lines, also under the cap), taking release.ts to 1,996 -- 12 BELOW where it started. The branch came in at +10 and leaves at -12. Recorded while moving them: _splitlines is duplicated a third and fourth time at adoption_report.ts:106 and readme_linter.ts:418; collapsing all three onto one definition touches three modules and was left out of this change rather than done silently. LOWERED 18,193 -> 18,180 on 2026-09-03 by fix/release-branch-reuse. The step-1 branch decision -- twenty lines of if/else in release.ts -- became one call to checkout_release_branch in release_publication.ts, which is 1,019 lines and therefore UNDER the 1500 cap, so the twenty lines plus a ~35-line rationale now cost nothing. release.ts 1,996 -> 1,983, every one of those lines being past the cap. The drill grew 765 -> 918 for two new scenarios and the snapshot/restore that keeps them from writing the real CHANGELOG, and it is under the cap too. A change that adds a feature and lowers the excess is the shape this gate's doctrine asks for; the alternative was a +13 raise for logic that had no business in the god-file."
+      "reason": "Lowered 18,230 -> 18,209 on 2026-09-03 by drain/artifact-location. `doctor --strict` needed 16 lines of integration wiring in cmd_doctor.ts, which sits ~2,100 lines PAST the 1500 cap so every line there costs one excess. The branch first came in at +137 and paid its own way down rather than raising the baseline: the strict semantics, threshold, kill switch, payload helper and argv fragments moved to _cli/_doctor_strict.ts (~160 lines, under the cap, costs nothing), taking it to +15; then the 37-line drift renderer moved to _cli/_doctor_emit.ts. Net -21. The renderer was chosen deliberately: pure rendering, two dependencies, no argparse involvement and therefore none of the byte-parity risk the parser surface carries against the retired Python implementation; nothing outside cmd_doctor.ts imported it. An AI council on the residual split (a: raise by 15 / d: descope the feature); neither was taken, because a parallel branch demonstrated the same day that paying down is achievable in this codebase, which is the evidence the split lacked. This gate's own test comment prescribes it: a commit that splits a god-file lowers the excess and must carry the lowered baseline. MERGE RECONCILIATION 2026-09-03, 18,209 -> 18,205: drain/wired-instruments and drain/artifact-location each lowered from the SAME 18,230 base in parallel -- the branch to 18,226 (net -4, run_continuation_hook.ts's termination ladder moved to _lib/continuation_ladder.ts and runtime_journal.ts's prose to _lib/outcome_vocabularies.ts, both under the cap) and main to 18,209 (net -21, the doctor --strict split above). Taking either side alone is wrong in a different direction: main's value silently discards the branch's earned -4, and the branch's value RAISES the baseline against main and weakens the gate. The committed number is neither -- it is the gate's own output on the merged tree, where both reductions apply. THIS LOCAL READING IS ADMISSIBLE HERE, and the discriminator matters because this file's ci-parity:local-only entry records a 165 -> 164 lowering that was reverted for exactly the opposite case: that count depends on how the environment resolves the projection surface, whereas this gate walks only SOURCE_ROOTS = ['src'] (check_source_size_budget.ts:88) counting excess lines over the 1500 ceiling, and `git status --porcelain -uall -- src/` reported ZERO untracked files, so a clean CI checkout of this commit measures the same 18,205. If CI reads anything else, CI's number is the correct one and this note is the record of why. LOWERED 18,205 -> 18,193 on 2026-09-03 by fix/release-curation-ask. The change adds a fifth publication guard, and its own additions landed at +10 excess: release.ts 2,008 -> 2,018, every line of which is past the 1500 cap. Paid down rather than baselined, in the two ways this gate's doctrine prescribes. The guard's rationale (~13 lines of docstring, including why prMerged is a parameter rather than a call-site if) lives in release_publication.ts, 915 lines and therefore UNDER the cap, so the prose costs nothing; and the two pure text helpers _splitlines and _rstrip moved out of release.ts into release_env.ts (333 lines, also under the cap), taking release.ts to 1,996 -- 12 BELOW where it started. The branch came in at +10 and leaves at -12. Recorded while moving them: _splitlines is duplicated a third and fourth time at adoption_report.ts:106 and readme_linter.ts:418; collapsing all three onto one definition touches three modules and was left out of this change rather than done silently. LOWERED 18,193 -> 18,180 on 2026-09-03 by fix/release-branch-reuse. The step-1 branch decision -- twenty lines of if/else in release.ts -- became one call to checkout_release_branch in release_publication.ts, which is 1,019 lines and therefore UNDER the 1500 cap, so the twenty lines plus a ~35-line rationale now cost nothing. release.ts 1,996 -> 1,983, every one of those lines being past the cap. The drill grew 765 -> 918 for two new scenarios and the snapshot/restore that keeps them from writing the real CHANGELOG, and it is under the cap too. A change that adds a feature and lowers the excess is the shape this gate's doctrine asks for; the alternative was a +13 raise for logic that had no business in the god-file. LOWERED 18,180 -> 18,068 on 2026-09-05 by fix/release-gate-producer-parity. The change wires the governance-mix obligation into the writer and the two local guards and adds a release-gate locality registry; its own additions to release.ts landed at +19 excess, every one of those lines past the 1500 cap. Paid down rather than baselined, in the way this entry's doctrine prescribes: the 132-line test-count-trend unit (_TEST_COUNT_LINE_RE, _TEST_LIST_MAX_BUFFER, _count_from_list_result, _count_tests_current, _previous_test_count_from_changelog, _render_test_trend_line) moved from release.ts into release_publication.ts, which is under the cap and where it now belongs on merit rather than only on arithmetic -- the same diff makes the missing `Tests: N` footer a section-level publication blocker, so the writer that emits the footer and the guard that refuses its absence sit in one module. release.ts 1,983 -> 1,871. All four names are re-exported from release.ts, so tests/scripts/release.test.ts is unchanged. LOCAL READING, ADMISSIBLE ON THIS ENTRY'S OWN DISCRIMINATOR: the gate walks only SOURCE_ROOTS=['src'] counting excess over the ceiling, and `git status --porcelain -uall -- src/` reports ZERO untracked files with the two new src/ files staged, so a clean CI checkout of this commit measures the same 18,068. If CI reads anything else, CI's number is the correct one and this note is the record of why."
     },
     "ci-parity:local-only": {
       "count": 165,

package/src/config/release-gate-locality.yml

@@ -0,0 +1,129 @@
+# Release-gate locality registry
+#
+# WHY THIS FILE EXISTS
+#
+# `release-validation.yml` is the last gate a release passes and the first one
+# that costs something to fail: by the time it runs, a branch, a pull request
+# and a CI run already exist. Until 2026-09-05 nothing related its jobs to the
+# commands a maintainer can run BEFORE any of that leaves the machine, and the
+# result was a recurring failure shape rather than a one-off — 14.14.0 (PR
+# #1812) on the curated head, 14.17.0 (PR #1856) on the governance-mix
+# response. Both were discoverable locally in under two seconds. Neither was
+# discovered locally, because nothing asked.
+#
+# The registry is the relation the tree was missing. It is read by two
+# consumers, which is what keeps it from rotting into a comment:
+#
+#   1. `tests/scripts/release_gate_locality.test.ts` — every job in the
+#      workflow has a row, every row names a live job, every declared script
+#      exists, and every `local: ~` carries a reason with an approved prefix.
+#      A new release-validation job therefore cannot land without answering
+#      "and how does a maintainer run this before pushing?".
+#   2. `task release:verify` — runs every row marked `verify: true` against the
+#      working tree. That is the command the release pipeline points at, and
+#      the one to run before `task release`.
+#
+# WHAT A ROW MEANS
+#
+#   local:   the shell command that reproduces the job's assertion locally.
+#            `~` (null) means it genuinely cannot run before the PR exists.
+#   reason:  REQUIRED when `local` is null. Must start with one of
+#            NEEDS_PR: / NEEDS_ARTIFACT: / NEEDS_NETWORK: / NEEDS_TOKEN:
+#            so the cause is classified rather than merely narrated.
+#   verify:  whether `task release:verify` runs it. Cheap and deterministic
+#            rows are true; anything that packs or installs is false and stays
+#            opt-in.
+#   network: marks a row that leaves the machine. Excluded from `--cheap`,
+#            which is the set the release pipeline runs on its own, so a
+#            registry outage cannot read as a release defect.
+#   release_branch_only:
+#            the assertion only means anything on a `release/X.Y.Z` head.
+#            Skipped with a printed reason elsewhere — never silently, and
+#            never reported as a pass.
+#   script:  the implementing script, when the assertion lives in one. `~`
+#            marks an assertion that exists only as inline workflow YAML —
+#            which is itself the defect this column makes countable.
+#   guard:   the local guard site that ALSO refuses this, when one exists.
+#            A row with a guard fails before the push, not merely before CI.
+#   partial: REQUIRED when the `local` command reproduces only part of what the
+#            job asserts. Names the uncovered part. A row silently claiming
+#            full coverage it does not have is the defect this file exists to
+#            end, so the gap is written down rather than inferred.
+
+version: 1
+workflow: .github/workflows/release-validation.yml
+
+jobs:
+  release-shape:
+    local: 'git diff --name-only origin/main...HEAD | ./scripts-run src/scripts/check_release_pr_shape --files -'
+    verify: true
+    # The assertion is about a RELEASE PR's diff — every ordinary branch fails
+    # it by construction, so running it off a release branch would teach a
+    # maintainer to ignore this command's red. Skipped with a printed reason
+    # instead, which is the difference between a gate that is not applicable
+    # and one that passed.
+    release_branch_only: true
+    script: src/scripts/check_release_pr_shape.ts
+    guard: ~
+
+  changelog-entry:
+    # The job asserts three things: a heading for the head version, a non-empty
+    # body, and a `Tests: N (+M since PREV)` footer.
+    #
+    # `check_release_highlights` covers the first two — it exits 2 with
+    # "CHANGELOG carries no section for <v>". It does NOT read the footer, and
+    # saying otherwise here would be the exact defect this registry exists to
+    # end: a row asserting a coverage it does not have. The footer half is
+    # covered locally by the guard named below, not by the `local` command, so
+    # `partial` states that rather than leaving a reader to grep for it.
+    local: './scripts-run src/scripts/check_release_highlights --version ${VERSION}'
+    verify: true
+    partial: 'heading + non-empty body only; the `Tests: N` footer half is covered by the guard, not by this command'
+    script: ~
+    guard: guard_release_curation
+
+  surface-equality:
+    local: ~
+    reason: 'NEEDS_PR: compares the live PR body against the CHANGELOG section; there is no PR body before `gh pr create`. The body is DERIVED from that same section (`pr_body_from_section`), so the local half is the section check above.'
+    verify: false
+    script: src/scripts/check_release_surface_equality.ts
+    guard: ~
+
+  highlight-plausibility:
+    # The job that failed 14.17.0. All four sub-checks (authoring instruction,
+    # unrewritten derived marker, `_none_` contradiction, governance-mix
+    # response) run locally from local tags alone — no origin, no HEAD_REF.
+    local: './scripts-run src/scripts/check_release_highlights --version ${VERSION}'
+    verify: true
+    script: src/scripts/check_release_highlights.ts
+    guard: guard_release_branch_push
+
+  version-consistency:
+    local: './scripts-run src/scripts/check_template_pin_drift'
+    verify: true
+    script: src/scripts/check_template_pin_drift.ts
+    guard: ~
+
+  finding-dispositions:
+    local: './scripts-run src/scripts/check_finding_dispositions --release ${VERSION}'
+    verify: false
+    reason: 'NEEDS_PR: the unrecorded-findings half reads live PR review comments. The missing-dispositions half does run locally and is what the `local` command covers.'
+    script: src/scripts/check_finding_dispositions.ts
+    guard: ~
+
+  audit-gate:
+    local: 'npm audit --omit=dev --audit-level=high'
+    verify: true
+    # Reaches the registry, so it is excluded from the `--cheap` set the
+    # release pipeline runs unattended: a registry outage must not read as a
+    # release defect. `task release:verify` (no flag) still runs it.
+    network: true
+    script: ~
+    guard: ~
+
+  release-install-e2e:
+    local: ~
+    reason: 'NEEDS_ARTIFACT: needs a packed tarball plus a BASELINE_TARBALL of the upgrade-from version; runnable by hand as `bash tests/test_release_install_e2e.sh`, too slow for a pre-push gate.'
+    verify: false
+    script: ~
+    guard: ~

package/src/scripts/_lib/release_highlights.ts

@@ -25,7 +25,11 @@
  */
 import { spawnSync } from 'node:child_process';
 
-import { CURATED_HEAD_INSTRUCTION } from './release_material.js';
+import {
+    CURATED_HEAD_INSTRUCTION,
+    MIX_RESPONSE_MARKER,
+    MIX_RESPONSE_PLACEHOLDERS,
+} from './release_material.js';
 
 /** The five curated labels, in the order an operator reads them. */
 export const HEAD_LABELS: readonly string[] = [
@@ -398,6 +402,7 @@ export function publication_blockers(
     sectionBody: string,
     version: string,
     where = '`main`',
+    mix: MixObligation | null = null,
 ): string[] {
     const out: string[] = [];
     if (sectionBody.includes(DERIVED_MARKER)) {
@@ -414,9 +419,175 @@ export function publication_blockers(
                 'comment line from the section and re-run.',
         );
     }
+    out.push(...mix_response_blockers(sectionBody, version, where, mix));
     return out;
 }
 
+/**
+ * Everything that makes a whole SECTION unpublishable — the head-level
+ * blockers above plus the two obligations that only exist for a full section.
+ *
+ * Two levels and not one, because `publication_blockers` is legitimately called
+ * with a bare curated head (the prefill tests do exactly that), and a head
+ * fragment has no tests footer by construction. Folding a section obligation
+ * into the head predicate would make those callers red on a rule that does not
+ * apply to what they passed.
+ *
+ * The TWO cheapest guard sites call this one — `guard_release_curation` (before
+ * any commit) and `guard_release_branch_push` (before any remote state). The
+ * two publication sites reached through `_refuse_unpublishable` (the annotated
+ * tag and the GitHub Release) stay on the head-level predicate: by then the
+ * section has already shipped in a merged PR, and adding a refusal there would
+ * block a resumed publication over an obligation the release cannot still act
+ * on. Stated rather than implied, because "the guard sites call this one" read
+ * as all four and is not true of any of them but the two named here.
+ */
+export function section_publication_blockers(
+    sectionBody: string,
+    version: string,
+    where = '`main`',
+    mix: MixObligation | null = null,
+): string[] {
+    const out = publication_blockers(sectionBody, version, where, mix);
+    if (!TEST_FOOTER_RE.test(sectionBody)) {
+        out.push(
+            `the ${version} section carries no \`Tests: N (+M since PREV)\` footer. ` +
+                '`_render_test_trend_line` degrades to `null` when the vitest collection ' +
+                'fails, so a missing line means the collection failed during `task release`. ' +
+                'Fix the collection, then render the number and put it on the section — ' +
+                `the release commit already exists on ${where}, so amend it there. Do not ` +
+                'invent the count: `npx vitest list | wc -l` is the same probe the writer runs.',
+        );
+    }
+    return out;
+}
+
+/**
+ * The tests-footer convention, in force for every release since 9.1.0.
+ *
+ * Duplicated from `release-validation.yml`'s inline check until 2026-09-05,
+ * where it was the ONLY copy — so the absence was red at release-PR time and
+ * invisible before it. 9.8.0 shipped without the line. The regex is the same
+ * one the workflow uses; the workflow's own comment already recorded that the
+ * writer "degrades SILENTLY to null on collection failure", which is exactly a
+ * defect a local guard should see first.
+ */
+const TEST_FOOTER_RE = /^Tests: \d+/mu;
+
+/**
+ * The measured governance-versus-product level, as the writer and the guards
+ * both receive it.
+ *
+ * A plain record and not the measurement itself: this module is reached by the
+ * push guard, the pre-commit ask and the CI gate, and only the callers have git
+ * to measure with. Passing the reading in keeps the predicate pure and keeps
+ * `measure_release_mix`'s git access out of a module three guards import.
+ */
+export interface MixObligation {
+    triggered: boolean;
+    level: string;
+}
+
+/** Minimum written characters after the marker — a bare marker is not an answer. */
+export const MIX_RESPONSE_MIN_CHARS = 40;
+
+/**
+ * The ONE predicate for the governance-versus-product obligation.
+ *
+ * `check_release_highlights` refuses this from the CI side and
+ * `guard_release_branch_push` from the local side, and until 2026-09-05 only
+ * the first of the two knew the obligation existed. That asymmetry is what the
+ * contract itself recorded — *"the earliest refusal for this one obligation is
+ * the PR, not the push"* (`docs/contracts/CHANGELOG-conventions.md`) — and what
+ * cost 14.17.0 a red release PR. Both sides now read this function, so a change
+ * to the obligation cannot reach one guard and miss the other.
+ *
+ * `null` means the measurement did not run (shallow clone, missing tag). That
+ * degrades to no blocker, matching the gate's documented stance: this is a
+ * governance signal, not a correctness control, and an environment fact must
+ * not block a release.
+ */
+export function mix_response_blockers(
+    sectionBody: string,
+    version: string,
+    where = '`main`',
+    mix: MixObligation | null = null,
+): string[] {
+    if (!mix || !mix.triggered) {
+        return [];
+    }
+    const idx = sectionBody.indexOf(MIX_RESPONSE_MARKER);
+    if (idx === -1) {
+        return [
+            `the ${version} section owes a governance-versus-product response ` +
+                `(${mix.level}) and carries none. Add one \`> ${MIX_RESPONSE_MARKER}\` line ` +
+                `immediately under the curated head on ${where}, naming the next cycle's ` +
+                'consumer work or a maintainer justification.',
+        ];
+    }
+    const block = mix_response_block(sectionBody, idx);
+    const left = MIX_RESPONSE_PLACEHOLDERS.filter((t) => block.includes(t));
+    if (left.length > 0) {
+        return [
+            `the ${version} governance-versus-product response still carries the writer's ` +
+                `placeholder(s) (${left.map((t) => `\`${t}\``).join(', ')}) — the measured level ` +
+                'is the generator\'s, the answer is not, and `CHANGELOG.md` is published to npm. ' +
+                `Name the next cycle's consumer work (or the justification) on ${where} and re-run.`,
+        ];
+    }
+    if (human_answer(block, mix.level).length < MIX_RESPONSE_MIN_CHARS) {
+        return [
+            `the ${version} governance-versus-product response carries no written answer ` +
+                `beyond the measured level (${mix.level}). The level is the generator's; the ` +
+                `response has to name the next cycle's consumer work or a maintainer ` +
+                `justification. Write it on ${where}, in the \`> \` block under the marker.`,
+        ];
+    }
+    return [];
+}
+
+/**
+ * The whole response block: the marker's line plus every blockquote line under it.
+ *
+ * Reading only the FIRST line after the marker was wrong in both directions, and
+ * both were reproduced before this was written. It **accepted** a section whose
+ * placeholder line had simply been deleted, because the machine-written level
+ * alone is 54 characters and cleared the floor — the smuggled auto-approval the
+ * placeholder exists to prevent. And it **refused** the writer's own two-line
+ * template, where the level sits on line 1 and the answer on line 2.
+ *
+ * Scoping to the block also fixes the placeholder scan, which searched the
+ * entire section body: a legitimate changelog line containing
+ * `<roadmap or issue>` blocked the release.
+ */
+export function mix_response_block(sectionBody: string, markerIdx: number): string {
+    const lines = sectionBody.slice(markerIdx).split('\n');
+    const out: string[] = [lines[0] ?? ''];
+    for (const line of lines.slice(1)) {
+        if (!line.trimStart().startsWith('>')) break;
+        out.push(line);
+    }
+    return out.join('\n');
+}
+
+/**
+ * What is left of the response block once the generator's own contribution is
+ * removed — i.e. the part a human had to write.
+ *
+ * The measured level is stripped because the writer emitted it; a floor that
+ * counted it would be satisfied by the tool on the author's behalf, which is
+ * the whole failure this obligation guards against.
+ */
+export function human_answer(block: string, level: string): string {
+    return block
+        .replace(MIX_RESPONSE_MARKER, '')
+        .split(level)
+        .join('')
+        .replace(/^[>\s.]+|[>\s.]+$/gu, '')
+        .replace(/[>\s]+/gu, ' ')
+        .trim();
+}
+
 /** Labels whose curated value is still the generator's unedited draft. */
 export function stale_draft_labels(
     curated: Readonly<Record<string, string>>,

package/src/scripts/_lib/release_material.ts

@@ -288,3 +288,69 @@ function _first_diff(a: string, b: string): string {
     }
     return 'surfaces differ only in normalization-invisible content';
 }
+
+/**
+ * The marker the governance-versus-product response line carries.
+ *
+ * Relocated here on 2026-09-05 from `check_release_highlights.ts`, where it was
+ * defined next to the refusal that reads it. That placement is why 14.17.0
+ * failed: the gate owned the marker, so the **generator** could not write the
+ * line without importing a gate, and therefore did not write it at all. The
+ * obligation was then discoverable only after `gh pr create` had already spent
+ * a branch, a PR and a CI run — the exact cost `guard_release_branch_push` was
+ * added to avoid for the sibling obligation two releases earlier.
+ *
+ * This module has no imports on purpose (see `CURATED_HEAD_INSTRUCTION`), which
+ * is what lets the writer, the local push guard and the CI gate all reach one
+ * definition instead of three copies.
+ */
+export const MIX_RESPONSE_MARKER = '**Governance mix:**';
+
+/**
+ * The sentinel that marks an EMITTED-BUT-UNANSWERED response.
+ *
+ * A generator that emits the measured level alone would satisfy the gate's
+ * length floor (`MIX_RESPONSE_MIN_CHARS`, 40) with a number the machine
+ * produced, turning a written-answer obligation into a formality the tool
+ * discharges for itself. That is a smuggled auto-approval, not a fix.
+ *
+ * So the writer emits the level AND this sentinel, and every gate refuses the
+ * sentinel — the same discipline `CURATED_HEAD_INSTRUCTION` and
+ * `DERIVED_MARKER` already follow. The net effect is only that the obligation
+ * moves from CI to the moment the section is written, where the fix is an edit
+ * to a file already open in the working tree.
+ */
+export const MIX_RESPONSE_PLACEHOLDER = '<the consumer work>';
+
+/**
+ * Every placeholder token the writer emits, so none of them can ship.
+ *
+ * The block carries two, and refusing only the first would leave
+ * `<roadmap or issue>` publishable — `CHANGELOG.md` is in `package.json`
+ * `files`, so that is the same "the generator's own scaffolding reached npm"
+ * failure `CURATED_HEAD_INSTRUCTION` exists for, one token to the right.
+ *
+ * A named list rather than a shape match over angle brackets, for the reason
+ * that constant already states: a pattern such as `/<[a-z ]+>/` rejects
+ * unrelated legitimate prose and misses a reworded placeholder. Adding a token
+ * to `render_mix_response` means adding it here.
+ */
+export const MIX_RESPONSE_PLACEHOLDERS: readonly string[] = [
+    MIX_RESPONSE_PLACEHOLDER,
+    '<roadmap or issue>',
+];
+
+/**
+ * Render the response block the writer emits when the obligation triggers.
+ *
+ * Two blockquote lines, immediately under the curated head and outside it, per
+ * `docs/contracts/CHANGELOG-conventions.md` § Governance-versus-product
+ * response — the head's ten-line cap is for product lines, and a sixth label
+ * would make every historical section retroactively incomplete.
+ */
+export function render_mix_response(level: string): string[] {
+    return [
+        `> ${MIX_RESPONSE_MARKER} ${level}.`,
+        `> Next cycle ships ${MIX_RESPONSE_PLACEHOLDER}, tracked in <roadmap or issue>.`,
+    ];
+}

package/src/scripts/_lib/repeated_run.ts

@@ -0,0 +1,77 @@
+/**
+ * The repeated-run evidence mode and the `flaky` outcome.
+ *
+ * `docs/contracts/evidence-artifact-types.md` § The second axis is the
+ * contract; this is the executable half, so "a run that passes 4 of 5 times is
+ * recorded as flaky rather than as passing" is a thing a test can assert rather
+ * than a sentence in a document.
+ *
+ * Two rules carry the whole design, both from the AI council of 2026-09-04
+ * (2/2 convergent):
+ *
+ *   1. **`n >= 2`.** `repeated:1` is `single-run` wearing extra syntax, and
+ *      admitting it would let one run be presented as a repeat.
+ *   2. **Unanimity, no threshold.** All pass → pass. All fail → fail. Anything
+ *      else → flaky. A 4-of-5 pass is precisely the case this exists to stop
+ *      being called a pass, so a majority rule would defeat the purpose.
+ */
+
+export type ExecutionMode = { kind: 'single-run' } | { kind: 'repeated'; n: number };
+
+export type RepeatedOutcome = 'pass' | 'fail' | 'flaky';
+
+/** The marker, when an artifact declares one. `single-run` is never written. */
+export const EVIDENCE_MODE_RE = /<!--\s*evidence-mode:\s*(single-run|repeated:(\d+))\s*-->/;
+
+/**
+ * Read the mode an artifact declares.
+ *
+ * Absent → `single-run`, which is the default that keeps this axis from being
+ * a migration. A malformed `repeated:<n>` with `n < 2` is rejected rather than
+ * rounded to `single-run`: a declaration that does not parse must not read to
+ * its author as accepted.
+ */
+export function parseExecutionMode(text: string): ExecutionMode | { kind: 'invalid'; reason: string } {
+    const m = EVIDENCE_MODE_RE.exec(text);
+    if (m === null) return { kind: 'single-run' };
+    if (m[1] === 'single-run') return { kind: 'single-run' };
+    const n = Number(m[2]);
+    if (!Number.isInteger(n) || n < 2) {
+        return {
+            kind: 'invalid',
+            reason: `repeated:${String(n)} declares fewer than 2 runs; repeated:1 is single-run with extra syntax`,
+        };
+    }
+    return { kind: 'repeated', n };
+}
+
+/**
+ * Aggregate `n` retained per-run verdicts.
+ *
+ * Takes the RUNS, never a summary count — an artifact that kept only
+ * "3 of 5 passed" has recorded a number, not evidence, and this signature is
+ * where that requirement is enforced rather than requested.
+ */
+export function aggregateRepeatedRuns(runs: readonly boolean[]): RepeatedOutcome {
+    if (runs.length < 2) {
+        throw new Error(
+            `aggregateRepeatedRuns needs at least 2 retained runs, got ${String(runs.length)}; ` +
+                'a single run is `single-run`, not a repeat',
+        );
+    }
+    if (runs.every((r) => r)) return 'pass';
+    if (runs.every((r) => !r)) return 'fail';
+    return 'flaky';
+}
+
+/** One line for the artifact, so `flaky` is reported as itself. */
+export function describeRepeatedRun(runs: readonly boolean[]): string {
+    const outcome = aggregateRepeatedRuns(runs);
+    const passed = runs.filter((r) => r).length;
+    const line = `evidence-mode: repeated:${String(runs.length)} · outcome: ${outcome} · ${String(passed)}/${String(runs.length)} passed`;
+    if (outcome !== 'flaky') return line;
+    return (
+        `${line} — the runs did not agree, so this is neither a pass nor a fail. ` +
+        'Recording it as either would be the silent green or the silent red this outcome exists to prevent.'
+    );
+}