@event4u/agent-config 8.13.0 → 9.0.0

package/src/scripts/bench_parity_count.ts

@@ -0,0 +1,279 @@
+/**
+ * bench_parity_count.ts — cross-model parity eval, count-distribution pass.
+ *
+ * Design: docs/design/cross-model-parity-eval.md (road-to-opt-measurement-unblock
+ * Phase 3). Re-scope: council-transport execution, NOT an in-host subagent
+ * harness — each orchestration-corpus task is rendered into a single
+ * self-contained prompt (fixture files inlined) asking the model to produce
+ * the findings it would surface, dispatched identically to ≥2 vendors via the
+ * existing `ExternalAIClient` transport. Output: per-host finding-count
+ * distributions + the derived `finding_floor` calibration.
+ *
+ * Pre-registered BEFORE the first billable call (2026-07-12, maintainer
+ * approved "Bauen + Count-Pass", ceiling $8):
+ *   - VENDORS: anthropic/claude-sonnet-4-5 + openai/gpt-4o (the two council
+ *     defaults; no new transport, no new auth surface).
+ *   - REPEATS = 3 identical calls per (task × vendor) — distribution, not
+ *     a point estimate.
+ *   - MAX_TOKENS = 2000 per call.
+ *   - MAX_USD = 8.0 hard abort (exit 2) — the authorized ceiling.
+ *   - Floor rule: per non-control task, floor = max(1, min over hosts of the
+ *     median per-host count) — the cross-host lower envelope, so the gate
+ *     fires on a host/task that under-produces relative to the cross-vendor
+ *     norm, never relative to one vendor.
+ *   - pv-02 is a NEGATIVE CONTROL (clean code): its counts are reported but
+ *     excluded from floor derivation — a well-behaved host surfaces ~0
+ *     findings there, and a floor > 0 would reward spurious findings.
+ *   - Counting uses the SAME `_count_findings` as `run_skill_evals.ts`, so
+ *     calibration and gate measure identically.
+ *
+ * Usage:
+ *   npx tsx src/scripts/bench_parity_count.ts --dry-run   # render prompts, no API
+ *   npx tsx src/scripts/bench_parity_count.ts --live      # billable
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { _count_findings } from './run_skill_evals.js';
+import { price_usd } from './bench_quality_rerun.js';
+
+export const REPEATS = 3;
+export const MAX_TOKENS = 2000;
+export const DEFAULT_MAX_USD = 8.0;
+export const CORPUS_DIR = 'internal/bench/orchestration/corpus';
+export const REPORT_PATH = 'internal/bench/reports/parity-count.json';
+
+/** Fixture roots searched, in order, when inlining files a task references. */
+export const FIXTURE_ROOTS = [
+    'internal/bench/ab/fixture',
+    'internal/bench/ab/fixtures-v2/agL-debug-01',
+    'internal/bench/orchestration/fixtures/pv-hollow',
+];
+
+/** Static, auditable map: corpus task id → files inlined into its prompt. */
+export const TASK_FILES: Record<string, { files: string[]; control: boolean }> = {
+    'orch-01-multifile-analysis': {
+        files: ['src/parser.ts', 'src/formatter.ts', 'src/cli.ts', 'src/reducers.mjs'],
+        control: false,
+    },
+    'orch-02-ordered-refactor': {
+        files: ['src/parser.ts', 'src/formatter.ts'],
+        control: false,
+    },
+    'orch-03-competitive-impl': {
+        files: ['src/parser.ts'],
+        control: false,
+    },
+    'pv-01-hollow-detection': {
+        files: ['src/charge.ts', 'tests/charge.test.ts'],
+        control: false,
+    },
+    'pv-02-negative-control': {
+        files: ['src/slugify.ts'],
+        control: true,
+    },
+};
+
+const SYSTEM_PROMPT = [
+    'You are a senior engineer reviewing code for a benchmark. You cannot run',
+    'code, modify files, or spawn agents. Work only from the file contents',
+    'provided in the message.',
+].join(' ');
+
+const OUTPUT_CONTRACT = [
+    '',
+    '---',
+    'OUTPUT CONTRACT (benchmark): Do NOT modify files and do NOT describe how',
+    'you would delegate. Output ONLY a numbered markdown list of the concrete',
+    'findings / changes you would surface for this task — one finding per',
+    'list item, most important first, each with its file reference. If the',
+    'code is clean and you have nothing to surface, output exactly:',
+    'NO FINDINGS',
+    'with no list.',
+].join('\n');
+
+/** Extract the first fenced block after a `## Task prompt` heading. */
+export function extract_task_prompt(md: string): string {
+    const at = md.indexOf('## Task prompt');
+    if (at === -1) throw new Error('no "## Task prompt" heading');
+    const rest = md.slice(at);
+    const m = rest.match(/```\n([\s\S]*?)```/);
+    if (!m || m[1] === undefined) throw new Error('no fenced task-prompt block');
+    return m[1].trimEnd();
+}
+
+/** Resolve a task-referenced file against the fixture roots. */
+export function resolve_fixture(rel: string, repoRoot = '.'): string {
+    for (const root of FIXTURE_ROOTS) {
+        const p = path.join(repoRoot, root, rel);
+        if (fs.existsSync(p)) return p;
+    }
+    throw new Error(`fixture file not found in any root: ${rel}`);
+}
+
+export function render_user_prompt(taskId: string, taskPrompt: string, repoRoot = '.'): string {
+    const spec = TASK_FILES[taskId];
+    if (!spec) throw new Error(`no TASK_FILES entry for ${taskId}`);
+    const parts: string[] = ['Here are the project files for this task:', ''];
+    for (const rel of spec.files) {
+        const body = fs.readFileSync(resolve_fixture(rel, repoRoot), 'utf-8');
+        parts.push(`### ${rel}`, '```', body.trimEnd(), '```', '');
+    }
+    parts.push('## Task', '', taskPrompt, OUTPUT_CONTRACT);
+    return parts.join('\n');
+}
+
+export function median(xs: number[]): number {
+    if (xs.length === 0) return 0;
+    const s = [...xs].sort((a, b) => a - b);
+    const mid = Math.floor(s.length / 2);
+    return s.length % 2 === 1 ? (s[mid] ?? 0) : ((s[mid - 1] ?? 0) + (s[mid] ?? 0)) / 2;
+}
+
+export interface TaskCounts {
+    task: string;
+    control: boolean;
+    /** host → the REPEATS finding counts */
+    counts: Record<string, number[]>;
+}
+
+export interface FloorRow {
+    task: string;
+    control: boolean;
+    medians: Record<string, number>;
+    /** min over hosts of the per-host median (the lower envelope). */
+    envelope: number;
+    /** calibrated floor; null for controls (excluded by design). */
+    floor: number | null;
+}
+
+/** Pre-registered floor rule — see header. */
+export function derive_floors(rows: TaskCounts[]): FloorRow[] {
+    return rows.map((r) => {
+        const medians: Record<string, number> = {};
+        for (const [host, xs] of Object.entries(r.counts)) medians[host] = median(xs);
+        const vals = Object.values(medians);
+        const envelope = vals.length ? Math.min(...vals) : 0;
+        return {
+            task: r.task,
+            control: r.control,
+            medians,
+            envelope,
+            floor: r.control ? null : Math.max(1, Math.floor(envelope)),
+        };
+    });
+}
+
+interface Vendor {
+    host: string;
+    model: string;
+    ask: (system: string, user: string, maxTokens: number) => {
+        text: string;
+        input_tokens: number;
+        output_tokens: number;
+        error: string | null;
+    };
+}
+
+async function load_vendors(): Promise<Vendor[]> {
+    const c = await import('./ai_council/clients.js');
+    const anthropic = new c.AnthropicClient({ api_key: c.load_anthropic_key() });
+    const openai = new c.OpenAIClient({ api_key: c.load_openai_key() });
+    return [
+        {
+            host: `anthropic/${c.DEFAULT_ANTHROPIC_MODEL}`,
+            model: c.DEFAULT_ANTHROPIC_MODEL,
+            ask: (s, u, m) => anthropic.ask(s, u, m),
+        },
+        {
+            host: `openai/${c.DEFAULT_OPENAI_MODEL}`,
+            model: c.DEFAULT_OPENAI_MODEL,
+            ask: (s, u, m) => openai.ask(s, u, m),
+        },
+    ];
+}
+
+export async function main(argv: string[]): Promise<number> {
+    const live = argv.includes('--live');
+    const dry = argv.includes('--dry-run') || !live;
+    let maxUsd = DEFAULT_MAX_USD;
+    const mi = argv.indexOf('--max-usd');
+    if (mi !== -1) maxUsd = Number(argv[mi + 1]);
+
+    const taskIds = Object.keys(TASK_FILES);
+    const prompts: Record<string, string> = {};
+    for (const id of taskIds) {
+        const md = fs.readFileSync(path.join(CORPUS_DIR, `${id}.md`), 'utf-8');
+        prompts[id] = render_user_prompt(id, extract_task_prompt(md));
+    }
+
+    if (dry) {
+        for (const id of taskIds) {
+            process.stdout.write(`--- ${id} (${(prompts[id] ?? '').length} chars)\n`);
+        }
+        process.stdout.write('dry-run: prompts rendered, no API calls.\n');
+        return 0;
+    }
+
+    const vendors = await load_vendors();
+    let spent = 0;
+    const rows: TaskCounts[] = [];
+    const raw: Array<Record<string, unknown>> = [];
+    for (const id of taskIds) {
+        const counts: Record<string, number[]> = {};
+        for (const v of vendors) {
+            const hostCounts: number[] = [];
+            counts[v.host] = hostCounts;
+            for (let rep = 0; rep < REPEATS; rep += 1) {
+                if (spent >= maxUsd) {
+                    process.stderr.write(`ABORT: spent $${spent.toFixed(2)} >= --max-usd ${maxUsd}\n`);
+                    return 2;
+                }
+                const resp = v.ask(SYSTEM_PROMPT, prompts[id] ?? '', MAX_TOKENS);
+                if (resp.error) {
+                    process.stderr.write(`ERROR ${id} × ${v.host} rep${rep}: ${resp.error}\n`);
+                    return 1;
+                }
+                spent += price_usd(v.model, resp.input_tokens, resp.output_tokens);
+                const n = /^\s*NO FINDINGS\s*$/m.test(resp.text) ? 0 : _count_findings(resp.text);
+                hostCounts.push(n);
+                raw.push({ task: id, host: v.host, rep, count: n, text: resp.text });
+                process.stdout.write(`${id} × ${v.host} rep${rep}: ${n} findings ($${spent.toFixed(3)} total)\n`);
+            }
+        }
+        rows.push({ task: id, control: TASK_FILES[id]?.control ?? false, counts });
+    }
+
+    const floors = derive_floors(rows);
+    const report = {
+        schema: 'parity-count/1',
+        stamp: new Date().toISOString(),
+        design: 'docs/design/cross-model-parity-eval.md',
+        vendors: vendors.map((v) => v.host),
+        repeats: REPEATS,
+        max_tokens: MAX_TOKENS,
+        floor_rule: 'max(1, floor(min over hosts of median per-host count)); controls excluded',
+        counter: 'run_skill_evals._count_findings (identical to the gate)',
+        cost_usd_actual: Number(spent.toFixed(4)),
+        tasks: rows,
+        floors,
+        raw,
+    };
+    fs.mkdirSync(path.dirname(REPORT_PATH), { recursive: true });
+    fs.writeFileSync(REPORT_PATH, `${JSON.stringify(report, null, 1)}\n`);
+    process.stdout.write(`wrote ${REPORT_PATH} ($${spent.toFixed(2)} actual)\n`);
+    return 0;
+}
+
+const isMain = process.argv[1] !== undefined
+    && path.resolve(process.argv[1]) === path.resolve(new URL(import.meta.url).pathname);
+if (isMain) {
+    main(process.argv.slice(2)).then(
+        (code) => process.exit(code),
+        (err) => {
+            process.stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+            process.exit(1);
+        },
+    );
+}

package/src/scripts/build_linear_digest.ts

@@ -41,7 +41,9 @@ export function RuleEntry(name: string, mode = 'as-is', strip_sections: string[]
 export const WORKSPACE: RuleEntry[] = [
     RuleEntry('ask-when-uncertain'),
     RuleEntry('commit-conventions'),
-    RuleEntry('context-hygiene', 'degraded', ['Augment-specific: Ignored Skills Recovery']),
+    // P4 Batch B (2026-07-12): the Augment-specific section migrated to
+    // guideline:agent-infra/context-hygiene-mechanics — nothing left to strip.
+    RuleEntry('context-hygiene', 'degraded'),
     RuleEntry('direct-answers'),
     RuleEntry('markdown-safe-codeblocks'),
     RuleEntry('minimal-safe-diff'),

package/src/scripts/check_bridge_derivation.ts

@@ -0,0 +1,172 @@
+#!/usr/bin/env tsx
+/**
+ * check_bridge_derivation.ts — every generated bridge file hash-derives from
+ * its `src/` source (road-to-ecosystem-harvest-skill-quality-gates Phase 4,
+ * Source AA).
+ *
+ * Two deterministic legs:
+ *
+ *   1. **Symlink leg** — every symlink under a bridge root must resolve to an
+ *      existing target inside the repo, under one of the derivation sources
+ *      (`dist/agent-src/`, `src/`, `AGENTS.md`). A broken link or a link
+ *      escaping the derivation set is a bridge file that does NOT derive.
+ *   2. **Regeneration leg** — snapshot the bridge trees (content hash for
+ *      regular files, target string for symlinks), re-run the generator
+ *      (`condense --generate-tools`), snapshot again. Any added / removed /
+ *      changed entry means the tree on disk did not derive from the current
+ *      source (hand-edit, stale generation, or a nondeterministic generator).
+ *
+ * Run AFTER `task generate-tools` (CI: the sync-consistency job). Exit 1 on
+ * the first drifted artefact, naming it.
+ */
+import { execFileSync } from 'node:child_process';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.join(path.dirname(_HERE), '..', '..');
+
+/** Bridge roots covered by the derivation guarantee (repo-relative; dirs or files). */
+export const BRIDGE_ROOTS: readonly string[] = [
+    '.claude/rules',
+    '.claude/skills',
+    '.claude/agents',
+    '.claude/personas',
+    '.claude/user-types',
+    '.cursor/rules',
+    '.cursor/commands',
+    '.windsurf/rules',
+    '.windsurf/workflows',
+    '.clinerules',
+    '.windsurfrules',
+    'GEMINI.md',
+    '.augment',
+] as const;
+
+/** Repo-relative prefixes a bridge symlink may resolve into. */
+const DERIVATION_SOURCES = ['dist/agent-src', 'src', 'AGENTS.md'] as const;
+
+function _walk(p: string, out: string[]): void {
+    const st = fs.lstatSync(p);
+    if (st.isSymbolicLink() || st.isFile()) {
+        out.push(p);
+        return;
+    }
+    if (st.isDirectory()) {
+        for (const name of fs.readdirSync(p).sort()) {
+            _walk(path.join(p, name), out);
+        }
+    }
+}
+
+/** Map of entry → `link:<target>` (symlinks) or `sha256:<hash>` (files) under `root`. */
+export function snapshot_tree(root: string): Record<string, string> {
+    const out: Record<string, string> = {};
+    if (!fs.existsSync(root) && !_isSymlinkRaw(root)) return out;
+    const entries: string[] = [];
+    _walk(root, entries);
+    for (const p of entries) {
+        const rel = path.relative(path.dirname(root), p);
+        const st = fs.lstatSync(p);
+        if (st.isSymbolicLink()) {
+            out[rel] = `link:${fs.readlinkSync(p)}`;
+        } else {
+            out[rel] = `sha256:${crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex')}`;
+        }
+    }
+    return out;
+}
+
+function _isSymlinkRaw(p: string): boolean {
+    try {
+        return fs.lstatSync(p).isSymbolicLink();
+    } catch {
+        return false;
+    }
+}
+
+/** Human-readable drift lines between two snapshots; empty = identical. */
+export function diff_snapshots(before: Record<string, string>, after: Record<string, string>): string[] {
+    const errors: string[] = [];
+    for (const k of Object.keys(before).sort()) {
+        if (!(k in after)) errors.push(`${k}: present before regeneration, absent after (stale bridge file)`);
+        else if (before[k] !== after[k]) errors.push(`${k}: content differs from regenerated output (does not derive from src/)`);
+    }
+    for (const k of Object.keys(after).sort()) {
+        if (!(k in before)) errors.push(`${k}: produced by regeneration but absent before (generation was stale)`);
+    }
+    return errors;
+}
+
+/** Every symlink under `root` must resolve inside `repoRoot` to a derivation source. */
+export function validate_symlinks(root: string, repoRoot: string): string[] {
+    const errors: string[] = [];
+    if (!fs.existsSync(root) && !_isSymlinkRaw(root)) return errors;
+    const entries: string[] = [];
+    _walk(root, entries);
+    for (const p of entries) {
+        if (!fs.lstatSync(p).isSymbolicLink()) continue;
+        let real: string;
+        try {
+            real = fs.realpathSync(p);
+        } catch {
+            errors.push(`${path.relative(repoRoot, p)}: broken symlink (target missing)`);
+            continue;
+        }
+        const rel = path.relative(fs.realpathSync(repoRoot), real);
+        if (rel.startsWith('..')) {
+            errors.push(`${path.relative(repoRoot, p)}: symlink escapes the repository (${real})`);
+            continue;
+        }
+        const ok = DERIVATION_SOURCES.some((s) => rel === s || rel.startsWith(`${s}${path.sep}`));
+        if (!ok) {
+            errors.push(`${path.relative(repoRoot, p)}: symlink target '${rel}' is outside the derivation sources (${DERIVATION_SOURCES.join(', ')})`);
+        }
+    }
+    return errors;
+}
+
+export function run(repoRoot: string): string[] {
+    const errors: string[] = [];
+    const roots = BRIDGE_ROOTS.map((r) => path.join(repoRoot, r));
+
+    const before: Record<string, Record<string, string>> = {};
+    for (const r of roots) before[r] = snapshot_tree(r);
+
+    // Regenerate in a child process so MODULE_STATE resolves exactly as the
+    // real pipeline does (no partial in-process state). `--generate-tools`
+    // covers the host trees; `--project-augment` covers `.augment` (it is
+    // projected by the sync path, not by generate-tools).
+    for (const flag of ['--generate-tools', '--project-augment']) {
+        execFileSync(path.join(repoRoot, 'scripts-run'), ['src/scripts/condense', flag], {
+            cwd: repoRoot,
+            stdio: 'pipe',
+        });
+    }
+
+    for (const r of roots) {
+        const rel = path.relative(repoRoot, r);
+        for (const e of diff_snapshots(before[r] ?? {}, snapshot_tree(r))) {
+            errors.push(`${rel}: ${e}`);
+        }
+        for (const e of validate_symlinks(r, repoRoot)) {
+            errors.push(e);
+        }
+    }
+    return errors;
+}
+
+const isMain = process.argv[1] !== undefined && path.resolve(process.argv[1]) === path.resolve(_HERE);
+if (isMain) {
+    const idx = process.argv.indexOf('--root');
+    const root = idx !== -1 ? (process.argv[idx + 1] ?? REPO_ROOT) : REPO_ROOT;
+    const errors = run(root);
+    if (errors.length > 0) {
+        for (const e of errors) process.stderr.write(`❌  ${e}\n`);
+        process.exit(1);
+    }
+    process.stdout.write('✅  bridge trees derive from src/ (symlink targets valid, regeneration is a fixpoint)\n');
+    process.exit(0);
+}

package/src/scripts/check_consumer_scope_flip.ts

@@ -0,0 +1,179 @@
+/**
+ * check_consumer_scope_flip.ts — deterministic held-quality verification for
+ * the consumer-scoped rule-projection default flip
+ * (road-to-request-scoped-rule-load Phase 1 human gate, approved 2026-07-13).
+ *
+ * The LLM-paired judge path is CLOSED-BY-DIAGNOSIS (docs/benchmark.md § Length-
+ * neutral judge RERUN); the recorded re-open path is deterministic verification.
+ * For THIS lever it is exact, not sampled: scoping only REMOVES whole rules —
+ * it never edits a shipped body — so output quality on the consumer surface is
+ * held by construction iff NO rule the consumer golden set exercises is
+ * removed. That is a decidable set inclusion, checked here:
+ *
+ *   1. The template's flipped `projection.rule_workspaces` default excludes
+ *      ONLY exclusively-maintainer rules (workspaces == [agent-config-
+ *      maintainer]) plus the recorded compat exclusion (source-of-truth.md).
+ *   2. Every rule tagged by any golden-set task (internal/bench/corpora/
+ *      token-quality-golden.yaml, 90/90 labelled) still arrives, UNLESS that
+ *      rule is exclusively-maintainer (then the task is maintainer-scope by
+ *      the schema's own definition: consumer = kernel + every rule not
+ *      exclusively maintainer).
+ *   3. The before/after evidence (rule count + cl100k tokens via
+ *      _lib/token_count.ts) is recomputed over the SHIPPED dist rule tree and
+ *      written to internal/bench/reports/.
+ *
+ * Exit 0 = flip verified; exit 1 = violation (a consumer-relevant rule would
+ * drop — the flip must not ship).
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { parse as parseYaml } from 'yaml';
+
+import { excludedRuleBasenames, ruleScopeFromSettings } from '../install/rule_scope.js';
+
+export const RULES_DIR = 'dist/agent-src/rules';
+export const TEMPLATE = 'src/config/agent-settings.template.yml';
+export const GOLDEN = 'internal/bench/corpora/token-quality-golden.yaml';
+export const REPORT = 'internal/bench/reports/2026-07-13-consumer-scoped-default-flip.json';
+
+/** workspaces: frontmatter list of a rule file ([] when untagged). */
+export function rule_workspaces(rulePath: string): string[] {
+    const src = fs.readFileSync(rulePath, 'utf-8');
+    const m = src.match(/^---\n([\s\S]*?)\n---/);
+    if (!m) return [];
+    const meta = parseYaml(m[1] ?? '') as Record<string, unknown>;
+    const ws = meta['workspaces'];
+    return Array.isArray(ws) ? ws.map((w) => String(w)) : [];
+}
+
+export function is_exclusively_maintainer(ws: string[]): boolean {
+    return ws.length === 1 && ws[0] === 'agent-config-maintainer';
+}
+
+export interface FlipVerdict {
+    scope: string[];
+    excluded: string[];
+    violations: string[]; // excluded rules that are NOT exclusively-maintainer/compat
+    golden_rules_total: number;
+    golden_rules_dropped: string[]; // golden-tagged rules that would drop (non-maintainer)
+    pass: boolean;
+}
+
+export function verify_flip(repoRoot = '.'): FlipVerdict {
+    const template = parseYaml(fs.readFileSync(path.join(repoRoot, TEMPLATE), 'utf-8')) as Record<string, unknown>;
+    const scope = ruleScopeFromSettings(template);
+    if (scope.workspaces === null) {
+        throw new Error('template rule_workspaces is empty — nothing flipped, nothing to verify');
+    }
+    const rulesDir = path.join(repoRoot, RULES_DIR);
+    const excluded = excludedRuleBasenames(rulesDir, scope);
+
+    const violations: string[] = [];
+    for (const name of excluded) {
+        if (name === 'source-of-truth.md') continue; // recorded compat exclusion
+        const ws = rule_workspaces(path.join(rulesDir, name));
+        if (!is_exclusively_maintainer(ws)) {
+            violations.push(`${name} [${ws.join(', ')}]`);
+        }
+    }
+
+    const golden = parseYaml(fs.readFileSync(path.join(repoRoot, GOLDEN), 'utf-8')) as {
+        tasks: Array<{ rules?: string[] }>;
+    };
+    const goldenRules = new Set<string>();
+    for (const t of golden.tasks) for (const r of t.rules ?? []) goldenRules.add(r);
+    const excludedIds = new Set(excluded.map((n) => n.replace(/\.md$/, '')));
+    const goldenDropped: string[] = [];
+    for (const r of goldenRules) {
+        if (!excludedIds.has(r)) continue;
+        const ws = rule_workspaces(path.join(rulesDir, `${r}.md`));
+        if (!is_exclusively_maintainer(ws) && r !== 'source-of-truth') {
+            goldenDropped.push(r);
+        }
+    }
+
+    return {
+        scope: [...scope.workspaces],
+        excluded,
+        violations,
+        golden_rules_total: goldenRules.size,
+        golden_rules_dropped: goldenDropped,
+        pass: violations.length === 0 && goldenDropped.length === 0,
+    };
+}
+
+async function main(): Promise<number> {
+    const v = verify_flip();
+    const { gpt_tokens } = await import('./_lib/token_count.js');
+    const excludedSet = new Set(v.excluded);
+    let legacyRules = 0;
+    let legacyTok = 0;
+    let scopedRules = 0;
+    let scopedTok = 0;
+    for (const name of fs.readdirSync(RULES_DIR).sort()) {
+        if (!name.endsWith('.md')) continue;
+        const body = fs.readFileSync(path.join(RULES_DIR, name), 'utf-8');
+        const tok = gpt_tokens(body).tokens;
+        // legacy-all baseline mirrors the 2026-07-08 report: compat exclusion applies on both arms
+        if (name === 'source-of-truth.md') continue;
+        legacyRules += 1;
+        legacyTok += tok;
+        if (!excludedSet.has(name)) {
+            scopedRules += 1;
+            scopedTok += tok;
+        }
+    }
+    const report = {
+        schema_version: 1,
+        kind: 'consumer-scoped-default-flip-verification',
+        date: '2026-07-13',
+        roadmap: 'road-to-request-scoped-rule-load Phase 1 (human gate, approved in-session)',
+        tokenizer: 'cl100k_base (js-tiktoken via _lib/token_count.ts)',
+        held_quality_arm:
+            'deterministic set-inclusion (LLM judging closed-by-diagnosis): scoping removes whole '
+            + 'rules only; verified that every removed rule is exclusively-maintainer (+ the recorded '
+            + 'source-of-truth compat exclusion) and that zero golden-set-exercised consumer rules drop '
+            + '— consumer-surface quality held by construction.',
+        scope: { rule_workspaces: v.scope },
+        excluded_rules: v.excluded,
+        violations: v.violations,
+        golden: { rules_tagged: v.golden_rules_total, dropped_non_maintainer: v.golden_rules_dropped },
+        legacy_all: { rules: legacyRules, gpt_tokens: legacyTok },
+        scoped: { rules: scopedRules, gpt_tokens: scopedTok },
+        delta: {
+            rules: legacyRules - scopedRules,
+            gpt_tokens: legacyTok - scopedTok,
+            tokens_pct: Number((((legacyTok - scopedTok) / legacyTok) * 100).toFixed(1)),
+        },
+        pass: v.pass,
+    };
+    fs.mkdirSync(path.dirname(REPORT), { recursive: true });
+    fs.writeFileSync(REPORT, `${JSON.stringify(report, null, 1)}\n`);
+    process.stdout.write(`excluded ${v.excluded.length} rules under scope [${v.scope.join(', ')}]\n`);
+    if (v.violations.length > 0) {
+        process.stdout.write(`❌  NON-MAINTAINER rules would drop: ${v.violations.join(' · ')}\n`);
+    }
+    if (v.golden_rules_dropped.length > 0) {
+        process.stdout.write(`❌  golden-set rules would drop: ${v.golden_rules_dropped.join(' · ')}\n`);
+    }
+    process.stdout.write(
+        `legacy-all ${legacyRules} rules / ${legacyTok} tok → scoped ${scopedRules} rules / ${scopedTok} tok `
+        + `(−${legacyTok - scopedTok} tok, −${report.delta.tokens_pct}%)\n`,
+    );
+    process.stdout.write(v.pass ? `✅  flip verified — wrote ${REPORT}\n` : '❌  flip NOT verified\n');
+    return v.pass ? 0 : 1;
+}
+
+const isMain = process.argv[1] !== undefined
+    && path.resolve(process.argv[1]) === path.resolve(new URL(import.meta.url).pathname);
+if (isMain) {
+    main().then(
+        (code) => process.exit(code),
+        (err) => {
+            process.stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+            process.exit(1);
+        },
+    );
+}