@event4u/agent-config 15.0.0 → 16.1.0

package/src/scripts/check_reply_consistency.ts

@@ -82,6 +82,10 @@ function _strip_codespans(line: string): string {
 }
 
 /** Split on \n / \r\n / \r, dropping a single trailing empty element. */
+export function splitAndMask(text: string): string[] {
+    return mask_fences(_splitlines(text));
+}
+
 function _splitlines(text: string): string[] {
     if (text === '') return [];
     const parts = text.split(/\r\n|\r|\n/);
@@ -143,6 +147,64 @@ export function find_option_blocks(text: string): OptionBlock[] {
     return blocks;
 }
 
+/** A recommendation line found in a block's adjacency window. */
+export interface RecommendationLine {
+    /** 1-based line of the recommendation. */
+    line: number;
+    /** The number it names. Not necessarily one of the block's options. */
+    num: number;
+}
+
+/**
+ * The recommendation line(s) sitting in ONE block's adjacency window.
+ *
+ * Extracted from `check_reply` rather than copied, because it has a second
+ * caller: `turn_end_gate_hook`'s `pending-decision` detector needs the same
+ * question this answers — is this numbered block an ASK, or is it a narrative
+ * list? Iron Law 1 says the recommendation line IS the ask, so a block without
+ * one was never a decision put to the user.
+ *
+ * That distinction is not decoration. Replayed over this repository's own 592
+ * assistant turns, a detector keyed on the block alone fired 29 times and 8 of
+ * those blocks carried no recommendation line anywhere near them — plans,
+ * findings lists, ordinary enumerations. Requiring the line removes that whole
+ * class, and it removes it by applying the rule the gate already cites rather
+ * than by adding a heuristic beside it.
+ *
+ * Returns every recommendation in the window, not the first: `check_reply`
+ * treats two as its own finding, and a caller that only wanted existence can
+ * read `.length > 0`.
+ */
+export function recommendationsUnder(
+    text: string,
+    block: OptionBlock,
+    maskedLines?: readonly string[],
+): RecommendationLine[] {
+    // `maskedLines` lets a caller with several blocks over one text mask once
+    // instead of once per block. It is the SAME array `check_reply` and
+    // `find_option_blocks` compute; passing anything else silently changes the
+    // line numbers this returns, which is why it is an optimisation parameter
+    // and not part of the contract.
+    const lines = maskedLines ?? mask_fences(_splitlines(text));
+    const recs: RecommendationLine[] = [];
+    let inspected = 0;
+    for (let idx = block.endLine; idx < lines.length && inspected < REC_ADJACENCY_WINDOW; idx++) {
+        const line = lines[idx]!;
+        if (line.trim() === '') {
+            continue; // blank lines do not consume the adjacency window
+        }
+        if (HEADING_RE.test(line) || OPTION_LINE_RE.test(line)) {
+            break; // a new heading or a new options block ends this block's window
+        }
+        inspected += 1;
+        const m = REC_LINE_RE.exec(line);
+        if (m) {
+            recs.push({ line: idx + 1, num: parseInt(m[1]!, 10) });
+        }
+    }
+    return recs;
+}
+
 /**
  * Core check — the exported function tests drive. Returns all findings for
  * one reply draft; empty array = the draft is consistent.
@@ -166,22 +228,7 @@ export function check_reply(text: string): Finding[] {
     // Per-block: exactly one adjacent recommendation line, number in range.
     const blocks = find_option_blocks(text);
     for (const block of blocks) {
-        const recs: Array<{ line: number; num: number }> = [];
-        let inspected = 0;
-        for (let idx = block.endLine; idx < lines.length && inspected < REC_ADJACENCY_WINDOW; idx++) {
-            const line = lines[idx]!;
-            if (line.trim() === '') {
-                continue; // blank lines do not consume the adjacency window
-            }
-            if (HEADING_RE.test(line) || OPTION_LINE_RE.test(line)) {
-                break; // a new heading or a new options block ends this block's window
-            }
-            inspected += 1;
-            const m = REC_LINE_RE.exec(line);
-            if (m) {
-                recs.push({ line: idx + 1, num: parseInt(m[1]!, 10) });
-            }
-        }
+        const recs = recommendationsUnder(text, block);
         if (recs.length === 0) {
             findings.push({
                 line: block.startLine,
@@ -421,7 +468,24 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
     return 2;
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url`.
+//
+// This module is not a hook, and until `turn_end_gate_hook` began importing
+// `find_option_blocks` / `recommendationsUnder` from it, it was never inside
+// one. It is now pulled into `dist/hooks/dispatch.js`, where without this guard
+// the `import.meta.url === argvUrl` comparison below is TRUE for every bundled
+// module — so importing this file would call `process.exit(main())` and take the
+// whole dispatch down at import time. The build banner's `.__direct__` argv
+// rewrite also prevents it, and a comment in the gate says so; a guard the other
+// bundled entries all carry is the load-bearing half, and depending on the
+// banner alone is depending on something no test pins.
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
+
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }
@@ -442,7 +506,12 @@ function _isCliEntry(): boolean {
     }
 }
 
-if (_isCliEntry() || process.argv[1] === _HERE) {
+// The `|| process.argv[1] === _HERE` arm is the reason the bundle check lives in
+// BOTH places: inside a bundle `_HERE` resolves to the bundle's own path and so
+// does `process.argv[1]`, so this arm would be true and would route straight past
+// a guard that only sat in `_isCliEntry`.
+const _IN_BUNDLE = typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__;
+if (!_IN_BUNDLE && (_isCliEntry() || process.argv[1] === _HERE)) {
     process.exit(main());
 }
 

package/src/scripts/check_rule_projection_integrity.ts

@@ -6,22 +6,32 @@
  * WHY THIS GATE EXISTS (road-to-conformance-round5 Phase 1, measured 2026-08-07)
  * ---------------------------------------------------------------------------
  * `docs/contracts/rule-router.md` (§ "The router earns its place as a
- * **compile-time** artifact") states that under every shipped default nothing
- * loads `dist/router.json` at runtime, so **projection is the only reach
- * mechanism there is**:
+ * **compile-time** artifact") used to state that under every shipped default
+ * nothing loads `dist/router.json` at runtime, so **projection is the only
+ * reach mechanism there is**. Both halves of that have since been corrected,
+ * and the gate outlived both:
  *
  * CORRECTED 2026-08-26. This docblock used to cite that section's "measured:
  * zero consumers under `src/scripts/hooks/`", and that measurement is stale: the
  * `rule-inject` concern reads the router via `_lib/rule_injection.ts:76-79` and
- * is bound on three slots. The gate's rationale survives the correction because
- * the concern is DEFAULT-OFF and returns before reading the router unless
- * `lean_projection.mode: delivery` is set — so on a shipped default, projection
- * IS still the only reach mechanism. What no longer holds is the stronger claim
- * that no such mechanism exists. Stated here rather than quietly re-worded,
- * because a gate whose stated reason rests on a refuted premise is exactly the
- * decoration ADR-127 rejects: a non-kernel rule activates by the model's judgment over text
- * already in context, and the per-tool rule tree is what puts it there. That
- * makes the state of the projection load-bearing, and it was broken:
+ * is bound on three slots. What no longer holds is the stronger claim that no
+ * such mechanism exists.
+ *
+ * CORRECTED AGAIN 2026-09-12. The 2026-08-26 note rescued the rationale with
+ * "the concern is DEFAULT-OFF … so on a shipped default, projection IS still
+ * the only reach mechanism". That rescue is now false and the clause is gone:
+ * since ADR-267 the shipped template carries `lean_projection.mode: delivery`
+ * with `hosts: [claude-code]`, so on the shipped default that one host does
+ * reach rule bodies at runtime. The gate never depended on the rescue — its two
+ * assertions below are about the emit plan and the entry mtimes, and a thinned
+ * tree of stubs is exactly as load-bearing as a tree of bodies: a missing entry
+ * is a rule the model neither reads nor has a pointer to, in either mode.
+ *
+ * Both are stated rather than quietly re-worded, because a gate whose stated
+ * reason rests on a refuted premise is exactly the decoration ADR-127 rejects:
+ * a non-kernel rule activates by the model's judgment over text already in
+ * context, and the per-tool rule tree is what puts it there. That makes the
+ * state of the projection load-bearing, and it was broken:
  *
  *   - `.claude/rules/` in the working checkout held **92** entries. A
  *     regeneration in a clean worktree produces **108**. The tree was last

package/src/scripts/check_test_delta.ts

@@ -0,0 +1,294 @@
+#!/usr/bin/env tsx
+/**
+ * check_test_delta — a code change with no credible test delta is a finding.
+ *
+ * `road-to-adversarial-verification-and-long-runs` Phase 2.4, first of two. The
+ * rule `test-first` states that a behaviour change gets a failing test first;
+ * nothing could see whether one arrived. This gate sees the cheap half: a diff
+ * that touches production code and touches no test at all.
+ *
+ * **What it deliberately cannot see.** Whether the test came FIRST, and whether
+ * it tests the thing that changed. Both are judgements about intent and content
+ * that no diff carries, and claiming them here would be the coverage inflation
+ * `evaluator-independence` exists over. This gate proves an ABSENCE, which is
+ * the one thing about a diff that is mechanically decidable.
+ *
+ * **The exemption is owner-set, and that is Risk 4's mitigation.** A gate that
+ * reds a legitimate PR invites the cheapest repair — widening the exemption until
+ * the gate finds nothing. So the escape is a PR LABEL a human applies, mirroring
+ * `check_kernel_rule_bundle`'s `bundled-always-rules-acknowledged`: it is visible
+ * on the PR, it is one click for the owner, and no agent can apply it by editing
+ * a file in the diff under review.
+ *
+ * Usage:
+ *   check_test_delta [--files F …] [--base-ref REF] [--root DIR]
+ *                    [--label NAME] [--event-path P] [--quiet] [--self-test]
+ *
+ * Exit codes: 0 = pass (or exempted) · 1 = fail · 2 = usage error / dead scope.
+ */
+
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { GateLedger } from './_lib/gate_ledger.js';
+import { runGateCli, runSelfTest } from './_lib/gate_self_test.js';
+import { reportScanned } from './_lib/scan_scope.js';
+import { isCodePath, isTestPath } from './_lib/test_delta.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO = path.resolve(path.dirname(_HERE), '..', '..');
+
+/** The label an owner applies to accept a code change with no test delta. */
+export const DEFAULT_LABEL = 'test-delta-acknowledged';
+
+export interface DeltaVerdict {
+    readonly code: string[];
+    readonly tests: string[];
+    readonly scanned: number;
+}
+
+/** Classify a changed-file list. Pure — the whole decision, without I/O. */
+export function classify(files: readonly string[]): DeltaVerdict {
+    return {
+        code: files.filter(isCodePath),
+        tests: files.filter(isTestPath),
+        scanned: files.length,
+    };
+}
+
+/** The finding, or `null`. Separated from rendering so a test reads the decision. */
+export function findingFor(v: DeltaVerdict): string | null {
+    if (v.code.length === 0) return null;
+    if (v.tests.length > 0) return null;
+    const shown = v.code.slice(0, 5).join(', ');
+    const more = v.code.length > 5 ? `, +${String(v.code.length - 5)} more` : '';
+    return (
+        `${String(v.code.length)} code path(s) changed and no test path did: ${shown}${more}. ` +
+        `A behaviour change gets a test (src/rules/test-first.md). If this change genuinely ` +
+        `has no testable behaviour, apply the \`${DEFAULT_LABEL}\` label to the PR — that is ` +
+        `an owner decision, deliberately not a file an agent can edit inside this diff.`
+    );
+}
+
+function gitChangedFiles(baseRef: string, root: string): string[] | null {
+    const r = spawnSync('git', ['diff', '--name-only', `${baseRef}...HEAD`], {
+        cwd: root,
+        encoding: 'utf8',
+    });
+    if (r.status !== 0) return null;
+    return r.stdout
+        .split('\n')
+        .map((s) => s.trim())
+        .filter((s) => s !== '');
+}
+
+function resolveBaseRef(explicit: string | null, root: string): string {
+    if (explicit !== null) return explicit;
+    for (const ref of ['origin/main', 'origin/master', 'main', 'master']) {
+        const r = spawnSync('git', ['rev-parse', '--verify', '--quiet', ref], {
+            cwd: root,
+            encoding: 'utf8',
+        });
+        if (r.status === 0) return ref;
+    }
+    return 'HEAD~1';
+}
+
+/** PR labels from the GitHub event JSON, or `[]` when there is none to read. */
+export function labelsFrom(eventPath: string | null): string[] {
+    if (eventPath === null || eventPath === '') return [];
+    try {
+        const raw = JSON.parse(fs.readFileSync(eventPath, 'utf8')) as Record<string, unknown>;
+        const pr = raw['pull_request'] as { labels?: unknown } | undefined;
+        const labels = Array.isArray(pr?.labels) ? pr.labels : [];
+        return labels
+            .map((l) => (l as { name?: unknown }).name)
+            .filter((n): n is string => typeof n === 'string');
+    } catch {
+        return [];
+    }
+}
+
+function usage(): string {
+    return (
+        'usage: check_test_delta [--files F …] [--base-ref REF] [--root DIR]\n' +
+        '                        [--label NAME] [--event-path P] [--quiet] [--self-test]\n'
+    );
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    if (argv.includes('--help') || argv.includes('-h')) {
+        process.stdout.write(usage());
+        return 0;
+    }
+    if (argv.includes('--self-test')) return selfTest();
+
+    const quiet = argv.includes('--quiet');
+    const at = (flag: string): string | null => {
+        const i = argv.indexOf(flag);
+        return i >= 0 ? (argv[i + 1] ?? null) : null;
+    };
+    const root = at('--root') ?? REPO;
+    const label = at('--label') ?? DEFAULT_LABEL;
+    const eventPath = at('--event-path') ?? process.env['GITHUB_EVENT_PATH'] ?? null;
+
+    let files: string[];
+    const fi = argv.indexOf('--files');
+    if (fi >= 0) {
+        files = argv.slice(fi + 1).filter((a) => !a.startsWith('--'));
+    } else {
+        const fromGit = gitChangedFiles(resolveBaseRef(at('--base-ref'), root), root);
+        if (fromGit === null) {
+            process.stderr.write('check_test_delta: git diff failed\n');
+            return 2;
+        }
+        files = fromGit;
+    }
+
+    // Per-path accounting, so "no code changed" and "code changed and nothing
+    // was looked at" stop printing the same green line. Every changed path is a
+    // planned target: a code path completes or fails, and everything else is out
+    // of scope by classification rather than silently skipped.
+    const ledger = new GateLedger('check_test_delta');
+    ledger.plan(files.map((f) => `path:${f}`));
+
+    const verdict = classify(files);
+    const finding0 = findingFor(verdict);
+    for (const f of files) {
+        const target = `path:${f}`;
+        if (!isCodePath(f)) {
+            ledger.outOfScope(target, 'not_applicable_kind');
+            continue;
+        }
+        if (finding0 === null) ledger.complete(target);
+        else ledger.fail(target, `${f}: no test path changed alongside it`);
+    }
+    ledger.report();
+
+    reportScanned({
+        gate: 'check_test_delta',
+        scanned: verdict.scanned,
+        units: 'changed path(s)',
+        roots: ['<the diff against the base ref>'],
+        // A diff with nothing in it is a real state — a docs-only branch, or a
+        // re-run against an already-merged base — and it is not this gate's job
+        // to red on it. Declared rather than silently passing a zero.
+        allowEmpty: 'EMPTY_VALID: a diff with no changed files carries no code change to gate',
+    });
+
+    const finding = finding0;
+    if (finding === null) {
+        if (!quiet) {
+            process.stdout.write(
+                `✅  check_test_delta: ${String(verdict.code.length)} code path(s), ` +
+                    `${String(verdict.tests.length)} test path(s)\n`,
+            );
+        }
+        return 0;
+    }
+
+    if (labelsFrom(eventPath).includes(label)) {
+        process.stdout.write(
+            `✅  check_test_delta: exempted by the \`${label}\` label — ` +
+                'an owner accepted a code change with no test delta.\n',
+        );
+        return 0;
+    }
+
+    process.stderr.write(`❌  check_test_delta: ${finding}\n`);
+    return 1;
+}
+
+function selfTest(): number {
+    const run = (files: Record<string, string>, args: readonly string[] = []): number => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ctd-'));
+        try {
+            return runGateCli(
+                REPO,
+                'src/scripts/check_test_delta.ts',
+                ['--root', dir, '--quiet', ...args],
+                dir,
+            );
+        } finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+            void files;
+        }
+    };
+    const eventWith = (labels: string[]): string => {
+        const f = path.join(
+            fs.mkdtempSync(path.join(os.tmpdir(), 'ctd-ev-')),
+            'event.json',
+        );
+        fs.writeFileSync(f, JSON.stringify({ pull_request: { labels: labels.map((name) => ({ name })) } }));
+        return f;
+    };
+
+    return runSelfTest({
+        gate: 'check_test_delta',
+        minCases: 6,
+        minRejectCases: 2,
+        cases: [
+            {
+                name: 'code change with no test delta is REJECTED',
+                expect: 'reject',
+                run: () => run({}, ['--files', 'src/scripts/thing.ts']),
+            },
+            {
+                name: 'several code changes with no test delta are REJECTED',
+                expect: 'reject',
+                run: () => run({}, ['--files', 'src/a.ts', 'src/b.ts', 'docs/x.md']),
+            },
+            {
+                name: 'code change WITH a test delta passes',
+                expect: 'accept',
+                run: () => run({}, ['--files', 'src/scripts/thing.ts', 'tests/scripts/thing.test.ts']),
+            },
+            {
+                name: 'a co-located *.test.ts counts as the test delta',
+                expect: 'accept',
+                run: () => run({}, ['--files', 'src/a.ts', 'src/a.test.ts']),
+            },
+            {
+                name: 'docs-only change is not a code change',
+                expect: 'accept',
+                run: () => run({}, ['--files', 'docs/x.md', 'README.md']),
+            },
+            {
+                name: 'a generated projection is not an independent code change',
+                expect: 'accept',
+                run: () => run({}, ['--files', 'dist/agent-src/scripts/thing.ts']),
+            },
+            {
+                name: 'the owner label exempts a real finding',
+                expect: 'accept',
+                run: () =>
+                    run({}, [
+                        '--files',
+                        'src/scripts/thing.ts',
+                        '--event-path',
+                        eventWith([DEFAULT_LABEL]),
+                    ]),
+            },
+            {
+                name: 'an unrelated label does NOT exempt it',
+                expect: 'reject',
+                run: () =>
+                    run({}, [
+                        '--files',
+                        'src/scripts/thing.ts',
+                        '--event-path',
+                        eventWith(['documentation']),
+                    ]),
+            },
+        ],
+    });
+}
+
+/* c8 ignore start — CLI entry, exercised by the self-test rather than in-process. */
+if (import.meta.url === pathToFileURL(path.resolve(process.argv[1] ?? '')).href) {
+    process.exit(main());
+}
+/* c8 ignore stop */