@event4u/agent-config 14.20.0 → 14.22.0

package/src/scripts/_lib/layer_overlap_notice.ts

@@ -54,12 +54,16 @@ const TYPES = ['rules', 'skills', 'commands', 'personas', 'user-types', 'agents'
 export function overlapFindings(homeDir: string, projectRoot: string): string[] {
     const findings: string[] = [];
     for (const type of TYPES) {
-        let g: string[];
-        let p: string[];
-        try {
-            g = fs.readdirSync(path.join(homeDir, '.claude', type));
-            p = fs.readdirSync(path.join(projectRoot, '.claude', type));
-        } catch {
+        // `commands` keys on the POSIX SUBPATH, matching
+        // `check_single_delivery`'s own key. Top-level names are the CLUSTER, and
+        // since per-name withholding (2026-09-07) the project layer holds exactly
+        // the commands the host lacks — which can share a cluster with commands the
+        // host has. Observed the same day: `analyze/` in both layers over two
+        // disjoint command sets, reported here as `commands=1`. This notice and
+        // that gate must not disagree about the same question.
+        const g = _entries(path.join(homeDir, '.claude', type), type === 'commands');
+        const p = _entries(path.join(projectRoot, '.claude', type), type === 'commands');
+        if (g === null || p === null) {
             continue;
         }
         const gset = new Set(g);
@@ -69,6 +73,46 @@ export function overlapFindings(homeDir: string, projectRoot: string): string[]
     return findings;
 }
 
+/**
+ * One layer's entry names — top level, or every `*.md` subpath when `recursive`.
+ *
+ * `null` means the directory is not readable, which the caller must treat as "skip
+ * this type": one layer absent means nothing is doubled there.
+ */
+function _entries(dir: string, recursive: boolean): string[] | null {
+    if (!recursive) {
+        try {
+            return fs.readdirSync(dir);
+        } catch {
+            return null;
+        }
+    }
+    let top: fs.Dirent[];
+    try {
+        top = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+        return null;
+    }
+    const out: string[] = [];
+    const walk = (kids: fs.Dirent[], abs: string, rel: string): void => {
+        for (const k of kids) {
+            const childRel = rel === '' ? k.name : `${rel}/${k.name}`;
+            if (k.isDirectory()) {
+                try {
+                    walk(fs.readdirSync(path.join(abs, k.name), { withFileTypes: true }), path.join(abs, k.name), childRel);
+                } catch {
+                    // An unreadable subdirectory contributes no names; the layer
+                    // itself was readable, so the type stays compared.
+                }
+            } else if (k.name.endsWith('.md') && k.name !== 'README.md') {
+                out.push(childRel);
+            }
+        }
+    };
+    walk(top, dir, '');
+    return out;
+}
+
 /** Render the notice, or `null` when there is nothing to say. */
 export function overlapNotice(homeDir: string, projectRoot: string): string | null {
     const findings = overlapFindings(homeDir, projectRoot);

package/src/scripts/_lib/packed_binary_predicate.ts

@@ -0,0 +1,225 @@
+/**
+ * Binary-payload eligibility — the mechanically verified predicate that
+ * reopened the `binary` class.
+ *
+ * WHAT THIS IS, SAID PLAINLY.
+ *
+ * `f573d628c` closed `binary` as a hard zero on 2026-09-07. This REOPENS it,
+ * 24 hours later, and that IS A WEAKENING OF A CONTROL. An AI council
+ * (2026-09-08, 2 seats, unanimous, deep tier) authorised it, and one seat
+ * explicitly refused the framing that this is merely "correcting an
+ * over-generalisation" — that distinction is cosmetic. The control was closed
+ * for the wrong reason, so reopening it is a weakening: justified, and still a
+ * weakening. It is written down here rather than softened because a control
+ * that gets quietly relaxed is worse than one that never existed.
+ *
+ * WHY THE CLOSURE WAS WRONG.
+ *
+ * Decision A over-generalised. Its reasoning was "the three observed binaries
+ * are unused, therefore no binary can ever be required" — an invalid
+ * generalisation from an observed sample to a universal rule. The vendored
+ * tree-sitter grammars are the direct counterexample: bytes the production path
+ * loads and the engine requires. A textual placeholder was lossless for three
+ * PNGs nothing decoded; for a grammar it does not degrade a fixture, it breaks
+ * the engine.
+ *
+ * WHAT REPLACES THE HARD ZERO — AND WHAT DOES NOT.
+ *
+ * Not a prose exception. A binary is admitted only when EVERY condition below
+ * is verified mechanically, on the bytes that are actually in the tarball:
+ *
+ *   1. exactly one manifest entry for the path
+ *   2. no wildcard or directory grant anywhere in the manifest
+ *   3. the packed tarball really contains the path
+ *   4. sha256(bytes) equals the manifest hash
+ *   5. size equals the manifest size
+ *   6. kind is `tree-sitter-wasm-grammar`
+ *   7. WASM magic and version are valid
+ *   8. the PRODUCTION loader reports the manifest's grammar_id
+ *   9. the PRODUCTION loader reports the manifest's ABI
+ *  10. a defined invalid-header mutation of the bytes is REJECTED
+ *  11. a defined unsupported-ABI expectation is REJECTED
+ *
+ * 8 and 9 go through `probeGrammarFile`, the engine's own loader, deliberately:
+ * a second implementation inside the gate could accept bytes the engine
+ * rejects, which is exactly the gap that would let a broken grammar ship while
+ * the gate called it valid.
+ *
+ * 10 and 11 run on every invocation, not in a separate test, because a
+ * predicate whose refusals nobody exercises is a predicate nobody has checked.
+ *
+ * `archive` IS NOT REOPENED.
+ *
+ * This collision produced evidence about grammars and none whatsoever about
+ * archives. `archive` stays a hard zero with no manifest path, and this module
+ * offers none.
+ *
+ * ELIGIBILITY NEVER TOUCHES THE MEASUREMENT.
+ *
+ * The gate reports `observed` as the true count and byte total on every run.
+ * Compliance is `observed <= allowed`, where `allowed` is the number of entries
+ * that passed every condition above — never `observed` minus something excused.
+ * A file that fails one condition lowers `allowed`; it never disappears from
+ * `observed`.
+ */
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/** One manifest row. Path-exact; `why` is documentation, never a condition. */
+export interface PackedBinaryEntry {
+    readonly path: string;
+    readonly sha256: string;
+    readonly size: number;
+    readonly kind: string;
+    readonly grammar_id: string;
+    readonly abi: number;
+    readonly why?: string;
+}
+
+export interface PackedBinaryManifest {
+    readonly schema_version: number;
+    readonly entries: readonly PackedBinaryEntry[];
+}
+
+/** The one kind this predicate knows how to verify. */
+export const VERIFIABLE_KIND = 'tree-sitter-wasm-grammar';
+
+/** What the production loader reported for a file. */
+export interface GrammarProbe {
+    readonly abi: number;
+    readonly grammar_id: string;
+}
+
+/** A per-file verdict, with the failing condition named. */
+export interface EligibilityVerdict {
+    readonly path: string;
+    readonly eligible: boolean;
+    /** Every condition that failed, in predicate order. Empty iff eligible. */
+    readonly failures: readonly string[];
+}
+
+/** WASM preamble: `\0asm` followed by little-endian version 1. */
+const WASM_MAGIC = [0x00, 0x61, 0x73, 0x6d] as const;
+const WASM_VERSION = [0x01, 0x00, 0x00, 0x00] as const;
+
+/**
+ * Condition 7, on its own so the header mutation in condition 10 has something
+ * specific to defeat.
+ */
+export function wasmMagicAndVersionValid(bytes: Uint8Array): boolean {
+    if (bytes.length < 8) return false;
+    for (let i = 0; i < 4; i += 1) if (bytes[i] !== WASM_MAGIC[i]) return false;
+    for (let i = 0; i < 4; i += 1) if (bytes[4 + i] !== WASM_VERSION[i]) return false;
+    return true;
+}
+
+/**
+ * The DEFINED invalid-header mutation for condition 10.
+ *
+ * One byte of the magic, flipped. Deliberately NOT `corrupt(bytes)`: arbitrary
+ * corruption can land in a custom section and leave a still-valid module, or
+ * hit padding and change nothing, so a test built on it can pass while proving
+ * nothing. This targets a property the predicate actually validates.
+ */
+export function definedInvalidHeaderMutation(bytes: Uint8Array): Uint8Array {
+    const out = Uint8Array.from(bytes);
+    if (out.length > 1) out[1] = (out[1] as number) ^ 0xff;
+    return out;
+}
+
+/**
+ * The DEFINED unsupported-ABI expectation for condition 11.
+ *
+ * The ABI is not a byte at a known offset — it is what the loader reports after
+ * parsing the module — so this mutates the EXPECTATION rather than the bytes:
+ * an entry claiming an ABI the grammar does not have must be refused. Same
+ * validated property, targeted from the side where it can be stated exactly.
+ */
+export function definedUnsupportedAbiEntry(entry: PackedBinaryEntry): PackedBinaryEntry {
+    return { ...entry, abi: entry.abi + 1 };
+}
+
+/** Condition 2, evaluated over the whole manifest rather than per file. */
+export function wildcardGrants(manifest: PackedBinaryManifest): string[] {
+    return manifest.entries
+        .filter((e) => e.path.includes('*') || e.path.includes('?') || e.path.endsWith('/'))
+        .map((e) => e.path);
+}
+
+/** Paths carrying more than one row — condition 1's uniqueness half. */
+export function duplicatePaths(manifest: PackedBinaryManifest): string[] {
+    const seen = new Map<string, number>();
+    for (const e of manifest.entries) seen.set(e.path, (seen.get(e.path) ?? 0) + 1);
+    return [...seen.entries()].filter(([, n]) => n > 1).map(([p]) => p);
+}
+
+/**
+ * Evaluate every condition for one packed file.
+ *
+ * `probe` is injected so the caller decides how the production loader is
+ * reached — in the gate it is a child process, in a test it can be a stub that
+ * returns a wrong ABI. `null` means the loader could not answer, which fails
+ * conditions 8 and 9 rather than passing them by default.
+ */
+export function evaluateEntry(options: {
+    readonly filePath: string;
+    readonly packedPaths: ReadonlySet<string>;
+    readonly manifest: PackedBinaryManifest;
+    readonly bytes: Uint8Array | null;
+    readonly probe: GrammarProbe | null;
+}): EligibilityVerdict {
+    const { filePath, packedPaths, manifest, bytes, probe } = options;
+    const failures: string[] = [];
+
+    const rows = manifest.entries.filter((e) => e.path === filePath);
+    if (rows.length === 0) failures.push('no manifest entry for this path');
+    if (rows.length > 1) failures.push('more than one manifest entry for this path');
+    const wild = wildcardGrants(manifest);
+    if (wild.length > 0) failures.push(`manifest carries wildcard or directory grants: ${wild.join(', ')}`);
+    if (!packedPaths.has(filePath)) failures.push('path is not in the packed tarball');
+
+    const entry = rows[0];
+    if (entry === undefined) return { path: filePath, eligible: false, failures };
+
+    if (bytes === null) {
+        failures.push('bytes could not be read');
+        return { path: filePath, eligible: false, failures };
+    }
+    const digest = createHash('sha256').update(bytes).digest('hex');
+    if (digest !== entry.sha256) failures.push(`sha256 mismatch: ${digest} != ${entry.sha256}`);
+    if (bytes.length !== entry.size) failures.push(`size mismatch: ${String(bytes.length)} != ${String(entry.size)}`);
+    if (entry.kind !== VERIFIABLE_KIND) failures.push(`kind is not ${VERIFIABLE_KIND}: ${entry.kind}`);
+    if (!wasmMagicAndVersionValid(bytes)) failures.push('WASM magic or version invalid');
+
+    if (probe === null) {
+        failures.push('the production loader could not read this file');
+    } else {
+        if (probe.grammar_id !== entry.grammar_id) {
+            failures.push(`grammar_id mismatch: loader says ${probe.grammar_id}, manifest says ${entry.grammar_id}`);
+        }
+        if (probe.abi !== entry.abi) {
+            failures.push(`ABI mismatch: loader says ${String(probe.abi)}, manifest says ${String(entry.abi)}`);
+        }
+    }
+
+    // Conditions 10 and 11 — the predicate refusing what it must refuse. Run
+    // here, on every invocation, so a refusal path is never merely asserted in
+    // a test somebody can skip.
+    if (wasmMagicAndVersionValid(definedInvalidHeaderMutation(bytes))) {
+        failures.push('self-check failed: a defined invalid-header mutation was NOT rejected');
+    }
+    if (probe !== null && probe.abi === definedUnsupportedAbiEntry(entry).abi) {
+        failures.push('self-check failed: a defined unsupported-ABI expectation was NOT rejected');
+    }
+
+    return { path: filePath, eligible: failures.length === 0, failures };
+}
+
+/** Read and shape-check the manifest. Throws rather than degrading to empty. */
+export function loadManifest(repoRoot: string): PackedBinaryManifest {
+    const p = path.join(repoRoot, 'src', 'config', 'packed-binary-manifest.json');
+    const raw = JSON.parse(fs.readFileSync(p, 'utf-8')) as PackedBinaryManifest;
+    if (!Array.isArray(raw.entries)) throw new Error(`packed-binary-manifest: entries must be an array (${p})`);
+    return raw;
+}

package/src/scripts/_lib/pin_resolver.ts

@@ -253,10 +253,23 @@ function _parse_cli(argv: string[]): { cwd: string; installed: string; forward:
 }
 
 // Script entry — mirrors the Python `if __name__ == "__main__"` block.
+// `build:delegate-aux` bundles this file with `--splitting`, which can move the
+// module body into a shared chunk: `import.meta.url` then names the CHUNK, the
+// URL comparison below never matches, and the entry silently no-ops. Inside that
+// bundle the invoked file name is the reliable signal (same pattern as
+// src/scripts/_cli/cmd_migrate.ts). Defined by that build only.
+declare const __AGENT_CONFIG_CLI_DELEGATE__: boolean | undefined;
 function _isCliEntry(): boolean {
     if (process.argv[1] === undefined) {
         return false;
     }
+    if (typeof __AGENT_CONFIG_CLI_DELEGATE__ !== 'undefined' && __AGENT_CONFIG_CLI_DELEGATE__) {
+        // A miss falls THROUGH to the URL comparison below, which is the
+        // symlinked-invocation case that fallback exists for.
+        if (path.basename(process.argv[1], '.js') === 'pin_resolver') {
+            return true;
+        }
+    }
     const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
     if (import.meta.url === argvUrl) {
         return true;

package/src/scripts/_lib/regression_neighbourhood.ts

@@ -18,7 +18,7 @@
  * of them resolves here, so the substitution is STATED rather than hidden.
  *
  *   · `agent-config code-graph` — the native code-graph engine (ADR-124). It
- *     ships `hooks.code_graph.enabled: false`
+ *     shipped `hooks.code_graph.enabled: false` (a flag retired 2026-09-07)
  *     (`src/config/agent-settings.template.yml:1373-1374`), and
  *     `agent-config code-graph detect` in this checkout answers
  *     `no code-graph source detected`. There is no index to select against.

package/src/scripts/_lib/release_highlights.ts

@@ -25,15 +25,7 @@
  */
 import { spawnSync } from 'node:child_process';
 
-import {
-    CURATED_HEAD_INSTRUCTION,
-    MIX_RESPONSE_MARKER,
-    MIX_RESPONSE_PLACEHOLDERS,
-    PROMISE_OUTCOMES,
-    PROMISE_PHRASE,
-    PROMISE_READBACK_MARKER,
-    extract_changelog_section,
-} from './release_material.js';
+import { CURATED_HEAD_INSTRUCTION } from './release_material.js';
 
 /** The five curated labels, in the order an operator reads them. */
 export const HEAD_LABELS: readonly string[] = [
@@ -406,7 +398,6 @@ export function publication_blockers(
     sectionBody: string,
     version: string,
     where = '`main`',
-    mix: MixObligation | null = null,
 ): string[] {
     const out: string[] = [];
     if (sectionBody.includes(DERIVED_MARKER)) {
@@ -423,13 +414,15 @@ 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.
+ * blockers above plus the tests footer, which only exists for a full section.
+ *
+ * It was "the two obligations" until 2026-09-07: the governance-versus-product
+ * written answer was the other, and ADR-261 deleted it. One remains.
  *
  * 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
@@ -450,9 +443,8 @@ export function section_publication_blockers(
     sectionBody: string,
     version: string,
     where = '`main`',
-    mix: MixObligation | null = null,
 ): string[] {
-    const out = publication_blockers(sectionBody, version, where, mix);
+    const out = publication_blockers(sectionBody, version, where);
     if (!TEST_FOOTER_RE.test(sectionBody)) {
         out.push(
             `the ${version} section carries no \`Tests: N (+M since PREV)\` footer. ` +
@@ -479,208 +471,24 @@ export function section_publication_blockers(
 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.
+ * The measured governance-versus-product level, as the writer receives it.
+ *
+ * A plain record and not the measurement itself: only the callers have git to
+ * measure with, and keeping `measure_release_mix`'s git access out of this
+ * module keeps it importable by the guards.
+ *
+ * It carried a `triggered` boolean until ADR-261, when the obligation that
+ * boolean gated was deleted. It was removed rather than kept with a rationale:
+ * the first attempt at this docblock claimed a reader of the published line
+ * could see the verdict, and a neutral review falsified that — `triggered` was
+ * set once and read nowhere, and `render_mix_response` never received it. The
+ * two counts in `level` are what the line publishes, and the taxonomy's own
+ * verdict stays where it is computed and printed, in `measure_release_mix`.
  */
 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 promise the PREVIOUS release head made, or null when it made none.
- *
- * Scoped to that section's governance-response block, not to its whole body: a
- * product line that happens to contain the phrase is not a promise the project
- * made about the next cycle.
- */
-export function previous_promise(changelogText: string, previousVersion: string): string | null {
-    const section = extract_changelog_section(changelogText, previousVersion);
-    if (section === null) return null;
-    const idx = section.body.indexOf(MIX_RESPONSE_MARKER);
-    if (idx === -1) return null;
-    const block = mix_response_block(section.body, idx);
-    return block.includes(PROMISE_PHRASE) ? block : null;
-}
-
-/**
- * The ONE predicate for "did this head answer the previous head's promise?".
- *
- * The defect: `_lib/release_material.ts` generates a `Next cycle ships …` line
- * and nothing has ever read the previous one back, so an unmet promise can be
- * restated indefinitely at zero cost — the debt is booked and never called. A
- * promise nobody reads is not a commitment, it is a sentence.
- *
- * Three outcomes are accepted and one of them must be chosen, which is the
- * whole mechanism: it does not require the promise to have been KEPT, and no
- * ratio, deadline or count is enforced here. Refusing an unkept promise would
- * make the honest answer the expensive one and teach an author to promise less
- * rather than to answer truthfully.
- *
- * Length floor and placeholder scan reuse the governance-response discipline
- * for the same reason it exists there: a bare marker, or the writer's own
- * scaffolding, is not an answer a human wrote.
- */
-export function promise_readback_blockers(
-    sectionBody: string,
-    version: string,
-    previousVersion: string,
-    promise: string | null,
-    where = '`main`',
-): string[] {
-    if (promise === null) return [];
-    const idx = sectionBody.indexOf(PROMISE_READBACK_MARKER);
-    if (idx === -1) {
-        return [
-            `the ${version} section does not answer the ${previousVersion} head's ` +
-                `\`${PROMISE_PHRASE}\` promise. Add one \`> ${PROMISE_READBACK_MARKER}\` line ` +
-                `immediately under the curated head on ${where}, naming the promise and whether ` +
-                `it ${PROMISE_OUTCOMES.join(', ')} (the last one with its reason).`,
-        ];
-    }
-    const block = mix_response_block(sectionBody, idx);
-    const left = MIX_RESPONSE_PLACEHOLDERS.filter((t) => block.includes(t));
-    if (left.length > 0) {
-        return [
-            `the ${version} previous-cycle answer still carries the writer's placeholder(s) ` +
-                `(${left.map((t) => `\`${t}\``).join(', ')}). \`CHANGELOG.md\` is published to npm. ` +
-                `Write the outcome on ${where} and re-run.`,
-        ];
-    }
-    const lower = block.toLowerCase();
-    const named = PROMISE_OUTCOMES.filter((o) => lower.includes(o));
-    if (named.length === 0) {
-        return [
-            `the ${version} previous-cycle answer names no outcome. It has to say which of ` +
-                `${PROMISE_OUTCOMES.join(', ')} applies to the ${previousVersion} promise — an ` +
-                'answer that restates the promise without resolving it is the failure this reads ' +
-                'back for.',
-        ];
-    }
-    if (readback_answer(block).length < MIX_RESPONSE_MIN_CHARS) {
-        return [
-            `the ${version} previous-cycle answer is shorter than a written answer ` +
-                `(${String(MIX_RESPONSE_MIN_CHARS)} characters after the marker). Name what was ` +
-                `promised and what became of it on ${where}, not the outcome word alone.`,
-        ];
-    }
-    return [];
-}
-
-/** What the author wrote under the read-back marker, marker and quoting removed. */
-export function readback_answer(block: string): string {
-    return block
-        .replace(PROMISE_READBACK_MARKER, '')
-        .replace(/^[>\s.]+|[>\s.]+$/gu, '')
-        .replace(/[>\s]+/gu, ' ')
-        .trim();
-}
-
-/**
- * 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>>,