@event4u/agent-config 16.2.0 → 16.3.0

package/src/scripts/report_standing_payload_by_host.ts

@@ -54,6 +54,11 @@ import {
     type SlotFireSizes,
 } from './_lib/activation_payload.js';
 import { loadRouter, pathOnlyRuleIds } from './_lib/rule_injection.js';
+// The windsurf emitter itself, not a second renderer beside it — 3.1 of
+// `road-to-a-hook-bundle-with-one-yaml-reader`, whose Risk 3 is precisely a
+// census that measures a file nobody receives. `condense.generate_windsurfrules`
+// writes with this same function.
+import { render_windsurfrules } from './_lib/windsurf_render.js';
 import { CAP_BYTES } from './hooks/rule_inject_hook.js';
 
 // Re-exported rather than redefined: this module was their only home until the
@@ -99,8 +104,47 @@ export interface HostSurface {
      */
     readonly anchor: string;
     readonly note: string;
+    /**
+     * Where a SINGLE-FILE row's byte figure comes from. Absent on per-rule-tree
+     * rows, which read the projection source like every other row.
+     *
+     * `road-to-a-hook-bundle-with-one-yaml-reader` 3.1. Until this field existed
+     * every single-file row read its surface off disk with `fs.readFileSync`,
+     * and three of the four surfaces are UNTRACKED generated projections. So the
+     * published windsurf figure was a function of when the checkout last ran
+     * `task generate-tools` — `absent` on a fresh worktree, some older byte count
+     * on a stale one, and nothing in the artifact said which. A census whose
+     * number moves with the measurer's housekeeping is not a measurement.
+     *
+     * Three kinds, and the rule that picks between them is reproducibility, not
+     * convenience: `render` recomputes the surface from the emitter itself;
+     * `tracked` reads a file that is IN GIT, so its bytes are the repository's;
+     * `unrenderable` refuses with a named reason rather than publishing a figure
+     * it cannot stand behind. Reading an untracked file is not one of the three.
+     */
+    readonly bytes?: ByteSource;
 }
 
+/** How a single-file surface's byte figure is obtained. See {@link HostSurface.bytes}. */
+export type ByteSource =
+    | {
+          /** Recomputed in memory by the emitter that writes the surface. */
+          readonly kind: 'render';
+          readonly detail: string;
+      }
+    | {
+          /** Read from a file tracked in git, so the figure is the repository's. */
+          readonly kind: 'tracked';
+          /** Repo-relative path actually read — not always `surface`. */
+          readonly path: string;
+          readonly detail: string;
+      }
+    | {
+          /** No in-memory emitter and no tracked file: the row reports a refusal. */
+          readonly kind: 'unrenderable';
+          readonly reason: string;
+      };
+
 /**
  * The host axis, taken from `docs/enforcement-by-host.md:18-28` rather than
  * invented here, plus the writer each surface has in this tree.
@@ -108,19 +152,19 @@ export interface HostSurface {
 export const HOST_SURFACES: readonly HostSurface[] = [
     {
         host: 'augment', surface: '.augment/rules', perRuleTree: true,
-        writer: 'src/scripts/condense.ts:2495',
+        writer: 'src/scripts/condense.ts:2482',
         anchor: '\'.augment/rules\',',
         note: 'copies by default; symlinks under `augment.rules_use_symlinks`',
     },
     {
         host: 'claude-code', surface: '.claude/rules', perRuleTree: true,
-        writer: 'src/scripts/condense.ts:1188',
+        writer: 'src/scripts/condense.ts:1181',
         anchor: '_emit_claude_rule(',
         note: '`_emit_claude_rule` rewrites frontmatter to the host\'s own `paths:` key',
     },
     {
         host: 'cline', surface: '.clinerules', perRuleTree: true,
-        writer: 'src/scripts/condense.ts:1190',
+        writer: 'src/scripts/condense.ts:1183',
         anchor: 'fs.symlinkSync(',
         note: 'symlink per rule into the projection',
     },
@@ -129,6 +173,16 @@ export const HOST_SURFACES: readonly HostSurface[] = [
         writer: 'src/scripts/generate_capability_matrix.ts:138',
         anchor: '_INSTALL_TIME_CELLS',
         note: 'NOT written by `condense`: the installer aggregates it from `src/agent-src/templates/copilot-instructions.md`, which is why the capability matrix marks this cell `adapter` and footnotes it as install-time',
+        bytes: {
+            kind: 'tracked',
+            path: '.github/copilot-instructions.md',
+            detail:
+                'the surface is COMMITTED in this repository, so its bytes are the ' +
+                'repository\'s rather than this checkout\'s. The installer aggregates a ' +
+                'consumer\'s copy from a template at install time and there is no in-memory ' +
+                'emitter to call here; a tracked read is reproducible on any clone, which is ' +
+                'the property the figure needs.',
+        },
     },
     {
         host: 'cowork', surface: null, perRuleTree: false,
@@ -138,25 +192,44 @@ export const HOST_SURFACES: readonly HostSurface[] = [
     },
     {
         host: 'cursor', surface: '.cursor/rules', perRuleTree: true,
-        writer: 'src/scripts/condense.ts:1190',
+        writer: 'src/scripts/condense.ts:1183',
         anchor: 'fs.symlinkSync(',
-        note: 'symlink per rule, plus `.mdc` companions at `condense.ts:1418`',
+        note: 'symlink per rule, plus `.mdc` companions at `condense.ts:1405`',
     },
     {
         host: 'gemini', surface: 'GEMINI.md', perRuleTree: false,
-        writer: 'src/scripts/condense.ts:1494',
+        writer: 'src/scripts/condense.ts:1481',
         anchor: '\'GEMINI.md\'',
-        note: 'single file',
+        note: 'single file — a symlink to the tracked `AGENTS.md`, so the bytes are that file\'s',
+        bytes: {
+            kind: 'tracked',
+            path: 'AGENTS.md',
+            detail:
+                '`generate_gemini_md` writes a SYMLINK to `AGENTS.md` and no content of its ' +
+                'own, so the emitter\'s output IS that file and reading it is calling the ' +
+                'emitter. `GEMINI.md` itself is untracked and is never read for the figure — ' +
+                'on a checkout that has not generated it, the row is unchanged.',
+        },
     },
     {
         host: 'windsurf', surface: '.windsurfrules', perRuleTree: false,
-        writer: 'src/scripts/condense.ts:1238',
+        writer: 'src/scripts/condense.ts:1225',
         anchor: '\'.windsurfrules\'',
-        note: 'single concatenated file',
+        note: 'single concatenated file, rendered here by `condense.render_windsurfrules` rather than read off disk',
+        bytes: {
+            kind: 'render',
+            detail:
+                'rendered in memory by `condense.render_windsurfrules`, the function ' +
+                '`generate_windsurfrules` writes with — never a second renderer. It is fed the ' +
+                'SAME unscoped, non-manual rule set every other row uses, not the install-local ' +
+                'scoped-and-deduplicated set the writer passes, so it reports this table\'s ' +
+                'stated unit: the upper bound a consumer install receives. Reading `.windsurfrules` ' +
+                'off disk reported instead when the checkout last ran `task generate-tools`.',
+        },
     },
     {
         host: 'codex', surface: '.codex/agent-config.md', perRuleTree: false,
-        writer: 'src/scripts/install.ts:1431',
+        writer: 'src/scripts/install.ts:1382',
         // Scoped to `.codex` rather than the bare filename: nine other lines in
         // `install.ts` write an `agent-config.md` for some other host, so the
         // unscoped anchor would have accepted a drift onto any of them — the
@@ -164,6 +237,16 @@ export const HOST_SURFACES: readonly HostSurface[] = [
         // to close, one level down.
         anchor: '\'.codex\', \'agent-config.md\'',
         note: 'written by the installer, not by `condense`; absent in this checkout',
+        bytes: {
+            kind: 'unrenderable',
+            reason:
+                'written by the installer into a consumer project, not by any emitter this ' +
+                'repository can call in memory, and not committed here. There is no byte count ' +
+                'this tree can stand behind, so the row refuses rather than publishing one. It ' +
+                'read `absent` before this change too — the difference is that `absent` then ' +
+                'meant "not on this disk right now" and could have become a number on a ' +
+                'checkout that happened to have run an install.',
+        },
     },
 ];
 
@@ -214,7 +297,17 @@ export function manualCorpusChars(root: string): number {
     return chars;
 }
 
-/** Bytes of a single-file surface, or `null` when it is absent from this checkout. */
+/**
+ * Bytes of a file at `rel`, or `null` when it cannot be read.
+ *
+ * ONLY LEGITIMATE BEHIND A TRACKEDNESS CHECK, and `generate_host_cost_table` is
+ * its one remaining caller — it tests `isTracked` first and reports
+ * `unverifiable` otherwise, so what it reads is always in the committed tree.
+ * THIS CENSUS NO LONGER USES IT: an unguarded read of an untracked generated
+ * projection is the 3.1 defect, and `singleFileBytes` below is what replaced it
+ * here. Kept rather than deleted because the guarded caller is correct as it
+ * stands and rewriting it would change a different generated table.
+ */
 export function singleFileChars(root: string, rel: string): number | null {
     try {
         return Buffer.byteLength(fs.readFileSync(path.join(root, rel), 'utf-8'), 'utf-8');
@@ -223,6 +316,73 @@ export function singleFileChars(root: string, rel: string): number | null {
     }
 }
 
+/** The non-manual rules a per-tool tree receives — the unit every row in this table reports. */
+export function projectedRuleBasenames(root: string): string[] {
+    const dir = path.join(root, RULES_DIST_REL);
+    return fs
+        .readdirSync(dir)
+        .filter((f) => f.endsWith('.md'))
+        .filter((f) => !isManualRule(fs.readFileSync(path.join(dir, f), 'utf-8')))
+        .sort();
+}
+
+/** A single-file row's figure, with how it was obtained — or why there is none. */
+export interface SingleFileMeasure {
+    /** Bytes, or `null` when the row refuses. */
+    readonly bytes: number | null;
+    /** `render` · `tracked:<path>` · `refused` — printed in the artifact. */
+    readonly how: string;
+    /** Set when `bytes` is null. */
+    readonly reason?: string;
+}
+
+/**
+ * Bytes of a single-file surface, computed from what the tree GENERATES rather
+ * than from what happens to sit on this disk.
+ *
+ * `road-to-a-hook-bundle-with-one-yaml-reader` 3.1. The predecessor
+ * (`singleFileChars`) read the surface with `fs.readFileSync`, and three of the
+ * four single-file surfaces are untracked generated projections — so the figure
+ * it published was a reading of the measurer's housekeeping. This function never
+ * reads an untracked file: it renders, reads a tracked one, or refuses.
+ *
+ * A row with no `bytes` declaration is a programming error rather than a
+ * fallback to the old behaviour, and it throws. A silent fallback is how the
+ * defect would come back one row at a time.
+ */
+export function singleFileBytes(root: string, h: HostSurface): SingleFileMeasure {
+    const src = h.bytes;
+    if (src === undefined) {
+        throw new Error(
+            `${h.host}: single-file surface with no \`bytes\` source declared. Declare render, ` +
+                'tracked or unrenderable — reading the surface off disk is not an option here.',
+        );
+    }
+    if (src.kind === 'unrenderable') {
+        return { bytes: null, how: 'refused', reason: src.reason };
+    }
+    if (src.kind === 'tracked') {
+        try {
+            const text = fs.readFileSync(path.join(root, src.path), 'utf-8');
+            return { bytes: Buffer.byteLength(text, 'utf-8'), how: `tracked:${src.path}` };
+        } catch {
+            return {
+                bytes: null,
+                how: 'refused',
+                reason: `${src.path} is tracked but could not be read from this root`,
+            };
+        }
+    }
+    // `render` — windsurf is the only one, and the renderer is named rather than
+    // dispatched on, because a table of host → renderer with one row is a lookup
+    // pretending to be a mechanism.
+    if (h.host !== 'windsurf') {
+        throw new Error(`${h.host}: declares a render source but no renderer is wired for it`);
+    }
+    const text = render_windsurfrules(path.join(root, RULES_DIST_REL), projectedRuleBasenames(root));
+    return { bytes: Buffer.byteLength(text, 'utf-8'), how: 'render' };
+}
+
 /**
  * Every `writer` citation resolves to a real line.
  *
@@ -365,16 +525,29 @@ export function renderArtifact(root: string, pin: string): string {
             );
             continue;
         }
-        const chars = singleFileChars(root, h.surface);
-        const bytes = chars === null ? 'absent' : String(chars);
-        const toks = chars === null ? 'absent' : String(tokensChars4(chars));
-        L.push(`| \`${h.host}\` | \`${h.surface}\` | single file | ${bytes} | ${toks} | \`${h.writer}\` |`);
+        const m = singleFileBytes(root, h);
+        const bytes = m.bytes === null ? 'refused' : String(m.bytes);
+        const toks = m.bytes === null ? 'refused' : String(tokensChars4(m.bytes));
+        L.push(
+            `| \`${h.host}\` | \`${h.surface}\` | single file (${m.how}) | ${bytes} | ${toks} | \`${h.writer}\` |`,
+        );
     }
     L.push('');
+    L.push('**Where the single-file figures come from.** Each is RENDERED by the emitter that writes');
+    L.push('the surface, or read from a file tracked in git — never read off an untracked generated');
+    L.push('projection, which is what the `(…)` in the Shape column names. Three of the four');
+    L.push('single-file surfaces are untracked, so the earlier read-off-disk figure reported when');
+    L.push('this checkout last ran `task generate-tools` rather than anything about the tree. A row');
+    L.push('with neither an emitter nor a tracked file reads `refused` and says why below.');
+    L.push('');
     L.push('Notes per host:');
     L.push('');
     for (const h of HOST_SURFACES) {
         L.push(`- \`${h.host}\` — ${h.note}`);
+        if (h.bytes !== undefined) {
+            const detail = h.bytes.kind === 'unrenderable' ? h.bytes.reason : h.bytes.detail;
+            L.push(`  - bytes (\`${h.bytes.kind}\`): ${detail}`);
+        }
     }
     L.push('');
     L.push('## The two units, recorded once');

package/src/scripts/report_verification_record_coverage.ts

@@ -0,0 +1,306 @@
+#!/usr/bin/env tsx
+/**
+ * How often a verification command leaves no usable record — per host.
+ *
+ * The question this answers is not "did the checks pass". It is whether the
+ * INSTRUMENT that the turn-end gate reads is working on a given host at all. A
+ * host whose records never carry an exit code gives the gate nothing to refuse
+ * on, and that failure is silent in both directions: the gate does not complain,
+ * and the records look like a clean run of passes.
+ *
+ * Named `report_` and not `check_` deliberately. `gate_population` classifies on
+ * a `lint|check|audit|skill|verify_` prefix, and this gates nothing — it exits 0
+ * whatever it finds. A high instrument-gap rate is answered by repairing the
+ * carrier, never by refusing more often.
+ *
+ * What it can see, and the one thing it cannot.
+ *
+ * Its corpus is the witness files the recorder writes, one per session. From
+ * those it reads, per host: sessions, records written, how many carry an exit
+ * code, each record's verdict class, and the share of verdicts that are
+ * instrument gaps rather than statements about the work.
+ *
+ * It CANNOT see a verification command that was never recorded. A candidate and
+ * a record are the same event here — the recorder writes a record for every
+ * command its selector admits — so the two can never differ in this corpus, and
+ * a column reporting both would invite exactly the reading that nothing was
+ * dropped. The failure that motivated this whole measurement was of that shape:
+ * a failing command fired an event bound to nothing, so it left no record, and
+ * no reading over records could have found it. That blind spot is printed with
+ * the table rather than left for a reader to infer.
+ *
+ * A host is `unobserved` when it binds the recorder but no witness file names
+ * it. That is not the same as a host with no gaps, and the output never lets the
+ * two share a row.
+ *
+ * Usage:
+ *   report_verification_record_coverage [--root DIR] [--json] [--quiet]
+ *
+ * Exit 0 always — except a dead scan scope, which throws via `assertScanned`:
+ * a reader that read nothing has measured nothing, and printing 0 % gaps over an
+ * empty corpus is the most misleading output this script could produce.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { parse as parseYaml } from 'yaml';
+
+import { assertScanned } from './_lib/scan_scope.js';
+import {
+    classifyRun,
+    isInstrumentGap,
+    type VerificationVerdict,
+} from './_lib/verification_evidence.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+/** Where the recorder writes one witness per session. */
+export const WITNESS_DIR = path.join('agents', 'state', 'verify-before-complete');
+
+/** The concern whose binding decides whether a host can produce a record at all. */
+const RECORDER_CONCERN = 'verify-before-complete';
+
+/** A witness file written before the producer recorded its host. */
+export const UNATTRIBUTED = 'unattributed';
+
+export interface HostCoverage {
+    host: string;
+    /** The host binds the recorder on a tool event, so a record is possible there. */
+    binds_recorder: boolean;
+    sessions: number;
+    records: number;
+    /** Records whose `exit_code` is a number — the gate's only hard signal. */
+    exit_code_available: number;
+    /** Verdict kind (or `INVALID_RUN:<reason>`) → count. */
+    verdicts: Record<string, number>;
+    /** Verdicts that describe the instrument rather than the work. */
+    instrument_gaps: number;
+    /** `instrument_gaps / records`, or null when there is nothing to divide. */
+    instrument_gap_share: number | null;
+}
+
+export interface CoverageReport {
+    root: string;
+    files_scanned: number;
+    hosts: HostCoverage[];
+    /** Hosts that bind the recorder and left no witness at all. */
+    unobserved: string[];
+}
+
+function _verdictKey(v: VerificationVerdict): string {
+    return v.kind === 'INVALID_RUN' ? `INVALID_RUN:${v.reason}` : v.kind;
+}
+
+/**
+ * Hosts whose manifest binds the recorder on a tool event.
+ *
+ * Read from the manifest rather than hardcoded, so a host that gains or loses
+ * the binding changes this report without anybody remembering to edit it. A
+ * manifest that cannot be read yields an empty set, which makes every observed
+ * host report `binds_recorder: false` — visibly wrong rather than quietly
+ * plausible.
+ */
+export function hostsBindingRecorder(manifestText: string): Set<string> {
+    const out = new Set<string>();
+    let manifest: Record<string, unknown>;
+    try {
+        manifest = (parseYaml(manifestText) ?? {}) as Record<string, unknown>;
+    } catch {
+        return out;
+    }
+    const platforms = (manifest['platforms'] ?? {}) as Record<string, unknown>;
+    for (const [host, spec] of Object.entries(platforms)) {
+        if (typeof spec !== 'object' || spec === null) continue;
+        for (const [event, concerns] of Object.entries(spec as Record<string, unknown>)) {
+            if (!event.endsWith('tool_use')) continue;
+            if (Array.isArray(concerns) && concerns.includes(RECORDER_CONCERN)) out.add(host);
+        }
+    }
+    return out;
+}
+
+export function computeCoverage(
+    files: ReadonlyArray<{ path: string; text: string }>,
+    binding: ReadonlySet<string>,
+    root: string,
+): CoverageReport {
+    const byHost = new Map<string, HostCoverage>();
+    const ensure = (host: string): HostCoverage => {
+        let h = byHost.get(host);
+        if (h === undefined) {
+            h = {
+                host,
+                binds_recorder: binding.has(host),
+                sessions: 0,
+                records: 0,
+                exit_code_available: 0,
+                verdicts: {},
+                instrument_gaps: 0,
+                instrument_gap_share: null,
+            };
+            byHost.set(host, h);
+        }
+        return h;
+    };
+
+    for (const f of files) {
+        let state: Record<string, unknown>;
+        try {
+            state = JSON.parse(f.text) as Record<string, unknown>;
+        } catch {
+            // A torn or half-written witness is counted under the host that
+            // cannot be read from it, never dropped: a file the reader could not
+            // parse is evidence about the instrument too.
+            ensure(UNATTRIBUTED).sessions += 1;
+            continue;
+        }
+        const platform = state['platform'];
+        const host = typeof platform === 'string' && platform ? platform : UNATTRIBUTED;
+        const h = ensure(host);
+        h.sessions += 1;
+
+        const runs = state['verification_runs'];
+        if (!Array.isArray(runs)) continue;
+        for (const rec of runs) {
+            h.records += 1;
+            const code = (rec as Record<string, unknown> | null)?.['exit_code'];
+            if (typeof code === 'number') h.exit_code_available += 1;
+            const verdict = classifyRun(rec);
+            const key = _verdictKey(verdict);
+            h.verdicts[key] = (h.verdicts[key] ?? 0) + 1;
+            if (isInstrumentGap(verdict)) h.instrument_gaps += 1;
+        }
+    }
+
+    for (const h of byHost.values()) {
+        h.instrument_gap_share = h.records > 0 ? h.instrument_gaps / h.records : null;
+    }
+
+    const hosts = [...byHost.values()].sort((a, b) => a.host.localeCompare(b.host));
+    const unobserved = [...binding].filter((x) => !byHost.has(x)).sort();
+    return { root, files_scanned: files.length, hosts, unobserved };
+}
+
+function _pct(x: number | null): string {
+    return x === null ? '—' : `${(x * 100).toFixed(1)}%`;
+}
+
+export function renderText(r: CoverageReport): string {
+    const lines: string[] = [];
+    lines.push(`verification record coverage — ${r.files_scanned} witness file(s) under ${r.root}`);
+    lines.push('');
+    lines.push('| host | binds recorder | sessions | records | exit_code available | instrument gaps | gap share |');
+    lines.push('|---|---|---|---|---|---|---|');
+    for (const h of r.hosts) {
+        lines.push(
+            `| ${h.host} | ${h.binds_recorder ? 'yes' : 'no'} | ${String(h.sessions)} | ` +
+                `${String(h.records)} | ${String(h.exit_code_available)} | ` +
+                `${String(h.instrument_gaps)} | ${_pct(h.instrument_gap_share)} |`,
+        );
+    }
+    for (const host of r.unobserved) {
+        lines.push(`| ${host} | yes | 0 | 0 | 0 | 0 | unobserved |`);
+    }
+    lines.push('');
+    lines.push('verdict classes');
+    for (const h of r.hosts) {
+        const keys = Object.keys(h.verdicts).sort();
+        if (keys.length === 0) {
+            lines.push(`  ${h.host}: no records`);
+            continue;
+        }
+        lines.push(`  ${h.host}: ${keys.map((k) => `${k}=${String(h.verdicts[k])}`).join(' · ')}`);
+    }
+    lines.push('');
+    if (r.unobserved.length > 0) {
+        lines.push(
+            `unobserved (binds the recorder, left no witness here): ${r.unobserved.join(', ')} — ` +
+                'this is an absence of measurement, not an absence of gaps.',
+        );
+    }
+    lines.push(
+        'blind spot: a verification command that left no record at all is invisible to this ' +
+            'reading. Records are the corpus, so a command the recorder never saw cannot appear ' +
+            'as a gap — it appears as nothing.',
+    );
+    return lines.join('\n');
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    let root = path.join(REPO_ROOT, WITNESS_DIR);
+    let asJson = false;
+    let quiet = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const a = argv[i] as string;
+        if (a === '--root') {
+            const next = argv[i + 1];
+            if (next === undefined) {
+                process.stderr.write('report_verification_record_coverage: --root needs a path\n');
+                return 2;
+            }
+            root = next;
+            i += 1;
+        } else if (a === '--json') {
+            asJson = true;
+        } else if (a === '--quiet') {
+            quiet = true;
+        } else {
+            process.stderr.write(
+                'usage: report_verification_record_coverage [--root DIR] [--json] [--quiet]\n',
+            );
+            return 2;
+        }
+    }
+
+    const files: Array<{ path: string; text: string }> = [];
+    if (fs.existsSync(root)) {
+        for (const name of fs.readdirSync(root).sort()) {
+            if (!name.endsWith('.json')) continue;
+            const p = path.join(root, name);
+            try {
+                files.push({ path: p, text: fs.readFileSync(p, 'utf8') });
+            } catch {
+                // Unreadable on this filesystem — skipped, and the file count
+                // below reflects what was actually read rather than what was listed.
+            }
+        }
+    }
+
+    // A dead scope is the one outcome this report must refuse. Everything else
+    // it has to say is a number; "0 % gaps" over nothing is not a number, it is
+    // a sentence about an empty directory wearing a measurement's clothes.
+    assertScanned({
+        gate: 'report_verification_record_coverage',
+        scanned: files.length,
+        units: 'witness files',
+        roots: [root],
+    });
+
+    let manifestText = '';
+    try {
+        manifestText = fs.readFileSync(
+            path.join(REPO_ROOT, 'src', 'scripts', 'hook_manifest.yaml'),
+            'utf8',
+        );
+    } catch {
+        manifestText = '';
+    }
+
+    const report = computeCoverage(files, hostsBindingRecorder(manifestText), root);
+    if (!quiet) {
+        process.stdout.write(asJson ? `${JSON.stringify(report, null, 2)}\n` : `${renderText(report)}\n`);
+    }
+    return 0;
+}
+
+if (
+    process.argv[1] !== undefined &&
+    import.meta.url === pathToFileURL(fs.realpathSync(process.argv[1])).href
+) {
+    process.exit(main());
+}
+
+export { _HERE };

package/src/scripts/rule_activation_census.ts

@@ -131,8 +131,11 @@ export function classify_rule(
     const type = typeof meta['type'] === 'string' ? (meta['type'] as string) : 'unknown';
     const always = Boolean(meta['alwaysApply'] || type === 'always');
 
-    // `_has_non_path_trigger` is the guard's own predicate and is deliberately
-    // narrower than `has_text_trigger` looks: it ignores `command:` triggers.
+    // `_has_non_path_trigger` is the guard's own predicate, and it is BROADER
+    // than `has_text_trigger`: it counts every match key that is not
+    // path-shaped, so `command:` triggers count too. It used to enumerate
+    // `keyword` and `phrase` and therefore missed them — `roadmap-progress-sync`
+    // read as path-only here while losing three command routes on Claude.
     // Reported separately rather than conflated, because a rule that is mixed by
     // the guard's definition is the one that flipped.
     const mixed = has_path_trigger && _has_non_path_trigger(meta);

package/src/scripts/rule_trigger_eval.ts

@@ -51,6 +51,7 @@ import {
 } from './skill_trigger_eval.js';
 import { AnthropicFetchRouter, loadKeyFromFile } from './_lib/trigger_routers.js';
 import { RULES_MODE_FLOOR } from './_lib/trigger_eval_floors.js';
+import { fnv1a } from './_lib/fnv.js';
 
 const _HERE = path.dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = path.resolve(_HERE, '..', '..');
@@ -144,15 +145,14 @@ export interface RuleCase {
     expected: boolean;
 }
 
-/** FNV-1a 32-bit — deterministic sampling key (no Math.random). */
-export function fnv1a(s: string): number {
-    let h = 0x811c9dc5;
-    for (let i = 0; i < s.length; i += 1) {
-        h ^= s.charCodeAt(i);
-        h = Math.imul(h, 0x01000193) >>> 0;
-    }
-    return h >>> 0;
-}
+/**
+ * FNV-1a 32-bit — deterministic sampling key (no Math.random).
+ *
+ * Moved to `_lib/fnv.ts` when the held-out partition in
+ * `measure_skill_ranker_baseline` became its second caller; re-exported here
+ * because this module's own suite imports the name from this file.
+ */
+export { fnv1a };
 
 /**
  * Derive the eval suite from the routing-matrix fixtures: positive →

package/src/scripts/schemas/review-findings.schema.json

@@ -111,9 +111,10 @@
               "open",
               "fixed",
               "accepted_risk",
-              "false_positive"
+              "false_positive",
+              "still_open"
             ],
-            "description": "Disposition. `fixed` / `false_positive` / `accepted_risk` are the three terminal states check_finding_dispositions accepts; `open` is the initial state. NOTE the underscore spelling — the Markdown track writes `accepted-risk` with a hyphen in its Status cell, and the two vocabularies are deliberately not unified here: renaming either would break committed artefacts on that track."
+            "description": "Disposition. `fixed` / `false_positive` / `accepted_risk` are the three terminal states check_finding_dispositions accepts ON A BLOCKING ROW; `open` is the initial state, meaning nobody has looked yet. `still_open` is a fourth TERMINAL state: a row somebody re-read against a named head, confirmed as a real unfixed issue, and recorded as such. It is deliberately distinct from `open`, which the two look identical to a reader checking only for a non-empty field while being opposites — nobody looked, versus somebody looked and this is the answer. `check_finding_dispositions.TERMINAL_STATUSES` carries all four and `DISPOSITION_STATUSES` only the first three, so a BLOCKING row marked `still_open` reports as an unknown status and keeps the gate red, which is the behaviour a blocking finding that is still open should have. NOTE the underscore spelling — the Markdown track writes `accepted-risk` with a hyphen in its Status cell, and the two vocabularies are deliberately not unified here: renaming either would break committed artefacts on that track."
           },
           "rationale": {
             "type": "string",