@event4u/agent-config 14.17.0 → 14.19.0

package/src/scripts/measure_sibling_naming.ts

@@ -0,0 +1,150 @@
+/**
+ * measure_sibling_naming — how many skill descriptions name another skill.
+ *
+ * `road-to-one-motion-authority` step 5.2. An inbox census claimed "44/299
+ * descriptions name a sibling" and shipped no definition of *naming* and no
+ * script, so the figure could be neither reproduced nor refuted. A companion
+ * claim of "218/299 bodies" reproduced under no reading of the tree at all.
+ * This script exists so the next such number is falsifiable.
+ *
+ * WHAT "NAMES A SIBLING" MEANS HERE, stated because the census did not.
+ *
+ * A description names a sibling when it contains the exact `name:` value of a
+ * DIFFERENT shipped skill, delimited so it is not a fragment of a longer
+ * identifier. `\b` is not enough: it puts a boundary between `brand` and the
+ * hyphen in `brand-identity`, so a bare `\b`-matched `brand` would score every
+ * mention of `brand-identity` as naming `brand` too. The delimiter here is
+ * "not `[A-Za-z0-9-]`" on both sides, which is the smallest rule that keeps
+ * `mcp` out of `mcp-builder` and `laravel` out of `laravel-dto`.
+ *
+ * A skill naming ITSELF does not count — that is a description, not a pointer.
+ *
+ * WHAT THE NUMBER IS AND IS NOT.
+ *
+ * A KNOWN AND UNFIXABLE FALSE POSITIVE, named rather than left for a reader to
+ * find: some skill names are ordinary English words, so a description can score
+ * a match by accident. `canvas-design` scores `brand` on the phrase "brand
+ * assets", which is not a pointer to the `brand` skill. Excluding short or
+ * common names would trade this for a false negative on the skills whose names
+ * really are those words, and there is no rule that gets both. The count is
+ * therefore an upper bound; the per-skill list is printed so a reader can see
+ * which matches are real.
+ *
+ * It is a count of descriptions that mention a sibling by name. It is NOT a
+ * measure of routing quality: a description can name a sibling uselessly, and a
+ * description that names none can be perfectly routable on its own keywords.
+ * The reason the count is worth having is narrower — the router reads
+ * descriptions and nothing else, so a family whose members never point at each
+ * other is a family the router cannot traverse.
+ *
+ * Exit code is 0 unless `--min <n>` is given and the count falls below it.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..', '..');
+const SKILLS_REL = path.join('src', 'skills');
+
+export interface SkillRecord { name: string; description: string }
+
+/** Read `name:` and `description:` out of a SKILL.md frontmatter block. */
+export function parseSkill(text: string): SkillRecord | null {
+    if (!text.startsWith('---')) return null;
+    const end = text.indexOf('\n---', 3);
+    if (end < 0) return null;
+    const fm = text.slice(3, end);
+    const name = /^name:\s*(.+)$/m.exec(fm)?.[1]?.trim() ?? '';
+    let description = /^description:\s*(.+)$/m.exec(fm)?.[1]?.trim() ?? '';
+    if ((description.startsWith('"') && description.endsWith('"'))
+        || (description.startsWith("'") && description.endsWith("'"))) {
+        description = description.slice(1, -1);
+    }
+    description = description.replace(/\\"/g, '"');
+    if (name === '') return null;
+    return { name, description };
+}
+
+export function loadSkills(root: string): SkillRecord[] {
+    const dir = path.join(root, SKILLS_REL);
+    if (!fs.existsSync(dir)) return [];
+    const out: SkillRecord[] = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const file = path.join(dir, entry.name, 'SKILL.md');
+        if (!fs.existsSync(file)) continue;
+        const rec = parseSkill(fs.readFileSync(file, 'utf-8'));
+        if (rec !== null) out.push(rec);
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Identifier-boundary containment: `mcp` is not found inside `mcp-builder`. */
+export function namesIdentifier(haystack: string, id: string): boolean {
+    let from = 0;
+    for (;;) {
+        const i = haystack.indexOf(id, from);
+        if (i < 0) return false;
+        const before = i === 0 ? '' : haystack[i - 1] ?? '';
+        const after = haystack[i + id.length] ?? '';
+        const isPart = (c: string): boolean => c !== '' && /[A-Za-z0-9-]/.test(c);
+        if (!isPart(before) && !isPart(after)) return true;
+        from = i + 1;
+    }
+}
+
+/** For each skill, the OTHER skills its description names. Sorted, deterministic. */
+export function siblingsNamed(skills: readonly SkillRecord[]): Map<string, string[]> {
+    const names = skills.map((s) => s.name);
+    const out = new Map<string, string[]>();
+    for (const s of skills) {
+        const hits = names
+            .filter((n) => n !== s.name && namesIdentifier(s.description, n))
+            .sort();
+        out.set(s.name, hits);
+    }
+    return out;
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    const rootFlag = argv.indexOf('--root');
+    const root = rootFlag >= 0 ? (argv[rootFlag + 1] ?? REPO_ROOT) : REPO_ROOT;
+    const minFlag = argv.indexOf('--min');
+    const min = minFlag >= 0 ? Number(argv[minFlag + 1]) : null;
+    const json = argv.includes('--json');
+
+    const skills = loadSkills(root);
+    const map = siblingsNamed(skills);
+    const naming = [...map].filter(([, v]) => v.length > 0);
+
+    if (json) {
+        process.stdout.write(`${JSON.stringify({
+            total: skills.length,
+            naming: naming.length,
+            entries: Object.fromEntries(naming),
+        }, null, 1)}\n`);
+    } else {
+        process.stdout.write(`scanned: ${String(skills.length)}\n`);
+        process.stdout.write(
+            `sibling-naming: ${String(naming.length)}/${String(skills.length)} description(s) name at least one other shipped skill\n\n`,
+        );
+        for (const [name, hits] of naming) {
+            process.stdout.write(`  ${name} → ${hits.join(', ')}\n`);
+        }
+    }
+
+    if (min !== null && Number.isFinite(min) && naming.length < min) {
+        process.stderr.write(
+            `\n❌  measure_sibling_naming: ${String(naming.length)} below the declared floor of ${String(min)}\n`,
+        );
+        return 1;
+    }
+    return 0;
+}
+
+if (process.argv[1] !== undefined) {
+    const invoked = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (invoked === import.meta.url) process.exitCode = main();
+}

package/src/scripts/redact_hook_capture.ts

@@ -4,7 +4,7 @@
  *
  * Ported from the retired Python `redact_hook_capture.py` (Phase 8 / Wave 8g).
  *
- * Reads JSON capture files written by `dispatch_hook.py` (when
+ * Reads JSON capture files written by `dispatch_hook.ts` (when
  * `AGENT_HOOK_CAPTURE_DIR` is set) and produces a redacted version
  * suitable for pasting into the verified-platforms roadmap.
  *

package/src/scripts/release.ts

@@ -102,7 +102,6 @@
  * - `_lib.changelog_eras` imports resolve to the `.ts` twin, never a `.py`.
  */
 
-import { spawnSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import process from 'node:process';
@@ -120,16 +119,17 @@ import {
 } from './_lib/changelog_eras.js';
 import {
     HEAD_LABELS,
+    type MixObligation,
     collect_span_commits,
     derive_category_hits,
     render_derived_head_values,
 } from './_lib/release_highlights.js';
 import {
-    NEXT_SECTION_RE,
     RELEASE_HEAD_DEFAULT,
     extract_changelog_section,
     pr_body_from_section,
     release_notes_from_section,
+    render_mix_response,
 } from './_lib/release_material.js';
 
 // `__doc__.splitlines()[0]` in `_parse_args` — the argparse description. Kept
@@ -164,11 +164,16 @@ import {
     _splitlines,
 } from './release_env.js';
 import type { RunResult } from './release_publication.js';
-// Re-export surface for the six names tests import from `release.js` and that
-// moved into the publication unit. `export ... from` rather than a bare import,
+// Re-export surface for the names tests import from `release.js` and that moved
+// into the publication unit — eleven since the test-count-trend unit followed. `export ... from` rather than a bare import,
 // because these are not USED here — an unused import would be dropped and the
 // test import path would break silently.
 export {
+    _TEST_LIST_MAX_BUFFER,
+    _count_from_list_result,
+    _count_tests_current,
+    _previous_test_count_from_changelog,
+    _render_test_trend_line,
     _failed_check_names,
     _failed_checks_report,
     _is_non_fast_forward,
@@ -176,7 +181,7 @@ export {
     _no_checks_action,
     _required_contexts_from_rules,
 } from './release_publication.js';
-import { _cap_body, jsonDumpsIndent, reEscape } from './release_env.js';
+import { _cap_body, jsonDumpsIndent } from './release_env.js';
 import {
     _MERGE_UPDATE_ROUNDS,
     _branch_exists_local,
@@ -195,7 +200,10 @@ import {
     create_and_push_annotated_tag,
     guard_publication,
     checkout_release_branch,
+    _render_test_trend_line,
     guard_release_curation,
+    local_release_gate_argv,
+    measure_mix_obligation,
     die,
     gh,
     git,
@@ -500,7 +508,11 @@ function render_changelog_entry(
     prev: string | null,
     commits: readonly Commit[],
     today: string,
-    opts: { test_trend_line?: string | null; head?: Readonly<Record<string, string>> } = {},
+    opts: {
+        test_trend_line?: string | null;
+        head?: Readonly<Record<string, string>>;
+        mix?: MixObligation | null;
+    } = {},
 ): [string, string] {
     const test_trend_line = opts.test_trend_line ?? null;
     let heading: string;
@@ -539,6 +551,11 @@ function render_changelog_entry(
 
     // The curated head sits above the generated log, which stays unchanged.
     const body_lines: string[] = [...render_release_head(opts.head ?? {})];
+    // Under the head and outside it — rationale on `MIX_RESPONSE_PLACEHOLDER`.
+    if (opts.mix?.triggered) {
+        body_lines.push('');
+        body_lines.push(...render_mix_response(opts.mix.level));
+    }
     const ordered_labels = ['BREAKING CHANGES', ...SECTIONS.map(([label]) => label)];
     for (const label of ordered_labels) {
         const bucket = grouped[label] ?? [];
@@ -581,139 +598,6 @@ function _changelog_line(c: Commit): string {
     return `* ${scope}${c.subject} ([${short}](${link}))`;
 }
 
-// ─── test-count trend (road-to-feedback-followups P3.2) ───────────────────────
-
-const _TEST_COUNT_LINE_RE = /^Tests:\s+(\d+)/m;
-
-/**
- * Buffer ceiling for the `vitest list` probe, in bytes.
- *
- * `spawnSync` buffers the child's whole stdout in memory and fails with
- * ENOBUFS past `maxBuffer`, whose default is 1 MiB. The probe emits one line
- * per test case, so its output grows with the suite: at 9470 cases the listing
- * is ~1.25 MB, i.e. already past the default. That is what silently dropped
- * the footer from the 9.10.0 notes and turned the `changelog-entry` gate red.
- * 64 MiB is ~50× the current listing — headroom for a suite many times this
- * size, at no cost when the output is small.
- */
-const _TEST_LIST_MAX_BUFFER = 64 * 1024 * 1024;
-
-/**
- * Count test cases from a finished `vitest list` spawn result, or return null
- * when the probe did not produce a usable listing.
- *
- * Split out from `_count_tests_current` so the failure modes are testable
- * without spawning the real (~14s, >1 MB) collection. `warn` is injected for
- * the same reason; it defaults to stderr.
- */
-function _count_from_list_result(
-    res: {
-        error?: (Error & { code?: string }) | undefined;
-        status: number | null;
-        stdout: string | null;
-    },
-    warn: (msg: string) => void = (msg) => void process.stderr.write(msg),
-): number | null {
-    // The trend line is informational and never blocks a release — but a
-    // SILENT drop is what shipped 9.8.0 and 9.10.0 without a footer, so every
-    // degradation says why. The `changelog-entry` CI gate treats a missing
-    // footer as fatal, so this warning is the difference between fixing the
-    // probe now and finding out from a red release PR.
-    if (res.error) {
-        // ENOENT (no npx) · ETIMEDOUT · ENOBUFS (listing past maxBuffer).
-        const code = res.error.code ?? res.error.message;
-        warn(
-            `⚠️  test-count probe failed (${code}) — the \`Tests:\` footer will ` +
-                `be omitted from the release notes, which fails the ` +
-                `\`CHANGELOG entry exists for head version\` gate.\n`,
-        );
-        return null;
-    }
-    if ((res.status ?? 1) !== 0) {
-        warn(
-            `⚠️  test-count probe exited ${res.status ?? '(null)'} — the ` +
-                `\`Tests:\` footer will be omitted from the release notes.\n`,
-        );
-        return null;
-    }
-    const lines = (res.stdout ?? '').split('\n').filter((l) => l.trim().length > 0);
-    if (lines.length === 0) {
-        warn('⚠️  test-count probe listed 0 cases — the `Tests:` footer will be omitted.\n');
-        return null;
-    }
-    return lines.length;
-}
-
-/**
- * Return the collected vitest test-case count on the current tree
- * (`npx vitest list`, one line per case; ~14s wall). Returns null when
- * collection fails — the trend line is informational, never a release
- * blocker, but every failure warns (see `_count_from_list_result`).
- * (Replaced the dead `pytest --collect-only` probe on 2026-07-08,
- * road-to-truth-and-reference-hygiene Phase 3: the Python suite was retired
- * with ADR-200, so the old probe always degraded to null and the `Tests:`
- * footer silently vanished from release notes.)
- */
-function _count_tests_current(): number | null {
-    // Recursion/cost guard: `npx vitest list` inside a vitest-driven release
-    // test would collect the whole suite from within the suite (the child
-    // inherits VITEST=… from the runner) — the exact recursion the caller
-    // comment warns about. Degrade to null there, same as any other
-    // collection failure.
-    if (process.env['VITEST'] !== undefined) {
-        return null;
-    }
-    const res = spawnSync('npx', ['vitest', 'list'], {
-        cwd: REPO_ROOT,
-        encoding: 'utf-8',
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: 180_000,
-        maxBuffer: _TEST_LIST_MAX_BUFFER,
-    });
-    return _count_from_list_result(res);
-}
-
-/**
- * Read CHANGELOG.md and return the most recent `Tests: N` footer under the
- * `prev_tag` heading, or null when not found.
- */
-function _previous_test_count_from_changelog(prev_tag: string | null): number | null {
-    if (!prev_tag || !fs.existsSync(CHANGELOG)) {
-        return null;
-    }
-    const text = fs.readFileSync(CHANGELOG, 'utf-8');
-    const heading_re = new RegExp(`^##\\s+\\[?${reEscape(prev_tag)}\\b`, 'm');
-    const m = heading_re.exec(text);
-    if (!m) {
-        return null;
-    }
-    const headEnd = m.index + m[0].length;
-    const rest = text.slice(headEnd);
-    const next_heading = NEXT_SECTION_RE.exec(rest);
-    const sectionEnd = headEnd + (next_heading ? next_heading.index : rest.length);
-    const section = text.slice(headEnd, sectionEnd);
-    const count_match = _TEST_COUNT_LINE_RE.exec(section);
-    return count_match ? Number.parseInt(count_match[1] as string, 10) : null;
-}
-
-/**
- * Return the `Tests: N (+M since X.Y.Z)` footer line, or null when the current
- * count cannot be determined. Silent on collection errors.
- */
-function _render_test_trend_line(prev_tag: string | null): string | null {
-    const current = _count_tests_current();
-    if (current === null) {
-        return null;
-    }
-    const previous = _previous_test_count_from_changelog(prev_tag);
-    if (previous === null || !prev_tag) {
-        return `Tests: ${current}`;
-    }
-    const delta = current - previous;
-    const sign = delta >= 0 ? '+' : '';
-    return `Tests: ${current} (${sign}${delta} since ${prev_tag})`;
-}
-
 /**
  * Insert `entry` inside the current era block.
  *
@@ -1287,6 +1171,10 @@ function execute(
         // `git push -u` is naturally idempotent — it prints "Everything
         // up-to-date" when remote already matches. push_release_branch
         // additionally absorbs a remote that moved under us.
+        // Not a `_step`: a second `[4/10]` makes the cited evidence anchors ambiguous.
+        process.stdout.write('        · verifying release gates locally (`task release:verify -- --cheap`)\n');
+        run(local_release_gate_argv());
+
         _step(4, total, `Push ${branch} to ${REMOTE}`);
         push_release_branch(branch);
     }
@@ -1834,9 +1722,13 @@ function main(argv: readonly string[] | null = null): number {
     // made the preview print the `_none_` skeleton while the real run wrote
     // pre-filled lines — a preview that contradicts its own output, which is
     // the exact class of surface disagreement this pre-fill exists to end.
+    // Unconditional for the same preview-parity reason as `_derive_head_prefill`,
+    // at a different cost: one `git show` per commit — measured 3.2 s over a
+    // 120-commit span, paid 3-4× per release. Not the ~25 ms of the line above.
     const [full, body] = render_changelog_entry(target, prev, commits, today, {
         test_trend_line,
         head: _derive_head_prefill(prev),
+        mix: measure_mix_obligation(target, prev),
     });
 
     // Era-split planning — gate on the POST-release view (2026-07-07 fix).
@@ -1954,10 +1846,6 @@ export {
     _detect_in_flight_target,
     print_preview,
     latest_tag,
-    _render_test_trend_line,
-    _previous_test_count_from_changelog,
-    _count_from_list_result,
-    _TEST_LIST_MAX_BUFFER,
     Commit,
     Plan,
     SystemExitError,

package/src/scripts/release_drill.ts

@@ -209,6 +209,18 @@ interface WorldConfig {
      * it fakes is one every resumed release actually passes through.
      */
     pr_already_merged?: boolean;
+
+    /**
+     * Make `task release:verify` fail, as a red local release gate would.
+     *
+     * Without this the drill returns OK for EVERY `task` invocation, so the
+     * pre-push gate run added 2026-09-05 would be exercised only on its happy
+     * path — wired but never proven to stop anything. The whole point of that
+     * step is that a red local gate costs one edit instead of a branch, a PR
+     * and a CI run, and that property is only real if a scenario watches it
+     * hold.
+     */
+    release_verify_fails?: boolean;
 }
 
 /**
@@ -232,6 +244,20 @@ export function defaultChangelogFixture(target: string): string {
         '',
         '- fixture entry for the release drill',
         '',
+        // Both lines are section-level publication obligations
+        // (`section_publication_blockers`), so a fixture without them refuses
+        // at the curation guard and every sequencing scenario dies at step 2 —
+        // the same "fixture trips the guard the drill exists to sequence"
+        // failure this builder's docstring already warns about, for the two
+        // obligations added 2026-09-05. The mix answer is written OUT rather
+        // than measured: measuring would couple every scenario to the live
+        // repository's commit span, which is the coupling `changelog` was
+        // introduced to remove.
+        '> **Governance mix:** governance-only 2 vs consumer-only 1 (taxonomy 1.0.0).',
+        '> Next cycle ships the fixture consumer work, tracked in the drill.',
+        '',
+        'Tests: 1000 (+0 since 0.0.0)',
+        '',
         '## [0.0.0]',
         '',
         '- earlier release, present so the section boundary is exercised',
@@ -267,6 +293,8 @@ class FakeWorld {
     pr_merged = false;
     release_created = false;
     branch_exists_remote = true;
+    /** Whether the simulated `task release:verify` reports a red local gate. */
+    private readonly release_verify_fails: boolean;
     /** Live PR body (release-truth Phase 1: refreshed from the changelog at head). */
     pr_body = '';
 
@@ -296,6 +324,7 @@ class FakeWorld {
         this.merge_fails_hard = cfg.merge_fails_hard ?? false;
         this.checks_fail = cfg.checks_fail ?? false;
         this.pr_merged = cfg.pr_already_merged ?? false;
+        this.release_verify_fails = cfg.release_verify_fails ?? false;
     }
 
     exec(args: readonly string[]): ExecResult {
@@ -374,7 +403,14 @@ class FakeWorld {
 
         // ── task ─────────────────────────────────────────────────────────
         if (args[0] === 'task') {
-            return OK; // release-prepare — regeneration is out of drill scope
+            // `release-prepare` — regeneration is out of drill scope.
+            // `release:verify` — the pre-push local gate run; simulated
+            // red only when a scenario asks for it, so the step's stopping
+            // power is exercised rather than assumed.
+            if (args[1] === 'release:verify' && this.release_verify_fails) {
+                return { status: 1, stdout: '', stderr: '❌  1 release gate(s) would fail the release PR: release-shape.\n' };
+            }
+            return OK;
         }
 
         // ── gh ───────────────────────────────────────────────────────────
@@ -541,6 +577,40 @@ const SCENARIOS: Record<string, Scenario> = {
             return f;
         },
     },
+    'local-gates-refuse-before-push': {
+        summary:
+            'step 4: a red local release gate stops the run BEFORE the branch is pushed — no branch on origin, no PR, no CI',
+        config: { release_verify_fails: true },
+        expect_success: false,
+        verify: (w, err) => {
+            const f: string[] = [];
+            _expect(
+                (err ?? '').includes('release:verify'),
+                `died for the wrong reason: ${err ?? '(no error)'}`,
+                f,
+            );
+            // The three remote side effects the 14.17.0 run actually produced
+            // before `check_release_highlights` refused it on the PR. Each is
+            // a separate assertion because each was a separate cost.
+            _expect(
+                !w.calls.some((c) => c.startsWith('git push')),
+                'the release branch was pushed after the local gates refused',
+                f,
+            );
+            _expect(
+                !w.calls.some((c) => c.startsWith('gh pr create')),
+                'a pull request was opened after the local gates refused',
+                f,
+            );
+            _expect(
+                !w.calls.some((c) => c.includes('pr checks')),
+                'CI was watched after the local gates refused',
+                f,
+            );
+            return f;
+        },
+    },
+
     'marker-refuses-before-commit': {
         summary:
             'step 3: a draft marker refuses BEFORE the release commit — no local release state, and therefore no remote state either',