@event4u/agent-config 16.4.0 → 17.0.0

package/src/scripts/report_reducible_classes.ts

@@ -0,0 +1,342 @@
+#!/usr/bin/env tsx
+/**
+ * Report — which tool-result classes enter the reducer's scope?
+ *
+ * `road-to-tool-results-that-leave-a-handle.md` step 1.1: a class is selected
+ * when its model-visible p95 exceeds the D1 threshold AND its results carry a
+ * failure-line structure (an exit code and error lines) a summary can keep,
+ * AND no non-goal of that roadmap excludes it. A REPORT, not a gate: exits 0.
+ *
+ * Step 1.2, `--profile content`: results classed exactly as
+ * `internal/bench/tool-results-content-profile-PREREG.md` registers them, read
+ * over its D11 window only, beside the execution profile on the same window.
+ * The same run reports step 1.4's repeat share (`repeatShare`), with no bar.
+ *
+ * ```bash
+ *   report_reducible_classes                      # human table
+ *   report_reducible_classes --profile content    # PREREG classes over the D11 window
+ *   report_reducible_classes --json
+ *   report_reducible_classes --threshold 8192 --project-prefix <slug> --census <path>
+ * ```
+ *
+ * Machine-local by construction: it reads this machine's Claude Code
+ * transcripts and this workspace's census.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { DEFAULT_PROJECTS_ROOT, projectStoreSlug, scanToolResultRecords, scanToolResults, type ToolResultRecord } from './_lib/cc_transcript.js';
+import { classifyResult, CONTENT_CLASSES } from './_lib/content_class.js';
+import { readCensusLine } from './_lib/tool_result_census.js';
+
+export { classifyResult, CONTENT_CLASSES, type ContentClass, pipelineStages } from './_lib/content_class.js';
+
+const _FILE = fileURLToPath(import.meta.url);
+const REPO = path.resolve(path.dirname(_FILE), '..', '..');
+const CENSUS = path.join('agents', 'runtime', 'state', 'tool-result-census.jsonl');
+
+export const D1_THRESHOLD_BYTES = 8192;
+
+/** Only a Bash result carries an exit code; every other class returns a body or a confirmation. */
+const FAILURE_STRUCTURED = new Set(['Bash']);
+
+function nonGoal(tool: string): 'K3' | 'K7' | null {
+    if (tool.endsWith(':image')) return 'K7';
+    if (tool === 'Edit' || tool === 'Write') return 'K3';
+    return null;
+}
+
+export interface ClassInput {
+    tool: string;
+    count: number;
+    payload_bytes: number;
+    payload_samples: number[];
+}
+
+export interface ClassVerdict {
+    tool: string;
+    count: number;
+    payload_bytes: number;
+    p95: number | null;
+    above_threshold: boolean;
+    failure_structured: boolean;
+    non_goal: 'K3' | 'K7' | null;
+    selected: boolean;
+}
+
+/** Nearest-rank with floor, the convention of the 2026-10-14 distribution. */
+export function nearestRankP95(samples: readonly number[]): number | null {
+    if (samples.length === 0) return null;
+    const sorted = [...samples].sort((a, b) => a - b);
+    return sorted[Math.min(sorted.length - 1, Math.floor(0.95 * sorted.length))] ?? null;
+}
+
+export function selectClasses(classes: Record<string, ClassInput>, thresholdBytes: number): ClassVerdict[] {
+    return Object.values(classes)
+        .map((c) => {
+            const p95 = nearestRankP95(c.payload_samples);
+            const above = p95 !== null && p95 > thresholdBytes;
+            const failure = FAILURE_STRUCTURED.has(c.tool);
+            const goal = nonGoal(c.tool);
+            return {
+                tool: c.tool,
+                count: c.count,
+                payload_bytes: c.payload_bytes,
+                p95,
+                above_threshold: above,
+                failure_structured: failure,
+                non_goal: goal,
+                selected: above && failure && goal === null,
+            };
+        })
+        .sort((a, b) => b.payload_bytes - a.payload_bytes);
+}
+
+/* -------------------------------------------------------------------------- */
+/* Content profile — step 1.2, classes exactly as                              */
+/* `internal/bench/tool-results-content-profile-PREREG.md` registers them      */
+/* -------------------------------------------------------------------------- */
+
+
+/** D11: the window opens at the committer date of the PREREG commit `033c3b2aa` and runs 14 days. */
+export const D11_WINDOW_START = '2026-10-15T12:26:27+02:00';
+export const D11_WINDOW_DAYS = 14;
+/** PREREG sample floor: a class with fewer results is `insufficient`, never `out`. */
+export const CONTENT_SAMPLE_FLOOR = 200;
+
+export function d11WindowEnd(): string {
+    return new Date(Date.parse(D11_WINDOW_START) + D11_WINDOW_DAYS * 24 * 3600 * 1000).toISOString();
+}
+
+/** Strictly after the start, strictly before the end; a result with no timestamp is outside. */
+export function inWindow(timestamp: string | null, startMs: number, endMs: number): boolean {
+    if (timestamp === null) return false;
+    const t = Date.parse(timestamp);
+    return !Number.isNaN(t) && t > startMs && t < endMs;
+}
+
+
+export interface ContentResult {
+    tool: string;
+    command: string | null;
+    bytes: number;
+}
+
+export interface ContentClassVerdict {
+    class: (typeof CONTENT_CLASSES)[number];
+    count: number;
+    payload_bytes: number;
+    p95: number | null;
+    verdict: 'selected' | 'out' | 'insufficient';
+}
+
+export interface ContentProfileReport {
+    classes: ContentClassVerdict[];
+    /** Bash results excluded by construct (leading `cd`, chain, redirect, subshell) — reported, never re-classed. */
+    residue: { count: number; above_threshold: number };
+    selected: string[];
+}
+
+export function contentProfile(results: readonly ContentResult[], thresholdBytes: number, floor = CONTENT_SAMPLE_FLOOR): ContentProfileReport {
+    const samples = new Map<string, number[]>(CONTENT_CLASSES.map((c) => [c, []]));
+    const residue = { count: 0, above_threshold: 0 };
+    for (const r of results) {
+        const c = classifyResult(r.tool, r.command);
+        if (c === 'residue') {
+            residue.count += 1;
+            if (r.bytes > thresholdBytes) residue.above_threshold += 1;
+        }
+        samples.get(c)?.push(r.bytes);
+    }
+    const classes = CONTENT_CLASSES.map((c): ContentClassVerdict => {
+        const s = samples.get(c) as number[];
+        const p95 = nearestRankP95(s);
+        const verdict = s.length < floor ? 'insufficient' : p95 !== null && p95 > thresholdBytes ? 'selected' : 'out';
+        return { class: c, count: s.length, payload_bytes: s.reduce((a, b) => a + b, 0), p95, verdict };
+    });
+    return { classes, residue, selected: classes.filter((c) => c.verdict === 'selected').map((c) => c.class) };
+}
+
+export interface RepeatClassCount {
+    count: number;
+    bytes: number;
+    repeats: number;
+    repeat_bytes: number;
+}
+
+export interface RepeatShare {
+    content: { count: number; bytes: number };
+    /** Content results byte-identical to one delivered earlier in the same session; `advised` = a re-read advisory preceded it. */
+    repeats: { count: number; bytes: number; advised: number };
+    by_class: Record<(typeof CONTENT_CLASSES)[number], RepeatClassCount>;
+}
+
+export type RepeatInput = Pick<ToolResultRecord, 'tool' | 'command' | 'bytes' | 'timestamp' | 'session' | 'path' | 'range' | 'digest' | 'advised'>;
+
+/**
+ * Step 1.4: the share of content results that repeat an earlier delivery in
+ * the same session — same path and range for `Read`, same command for a
+ * content-class Bash call, same sha256 over the delivered payload. A `Read`
+ * and a `cat` of one file never match each other, so the share is a lower
+ * bound. Reported with no bar.
+ */
+export function repeatShare(records: readonly RepeatInput[]): RepeatShare {
+    const by_class = Object.fromEntries(CONTENT_CLASSES.map((c) => [c, { count: 0, bytes: 0, repeats: 0, repeat_bytes: 0 }])) as RepeatShare['by_class'];
+    const out: RepeatShare = { content: { count: 0, bytes: 0 }, repeats: { count: 0, bytes: 0, advised: 0 }, by_class };
+    const ordered = records
+        .map((r, i) => {
+            const t = r.timestamp === null ? Number.NaN : Date.parse(r.timestamp);
+            return { r, i, t: Number.isNaN(t) ? Number.POSITIVE_INFINITY : t };
+        })
+        .sort((a, b) => (a.t === b.t ? a.i - b.i : a.t < b.t ? -1 : 1));
+    const delivered = new Set<string>();
+    for (const { r } of ordered) {
+        const c = classifyResult(r.tool, r.command);
+        if (!(CONTENT_CLASSES as readonly string[]).includes(c)) continue;
+        const k = by_class[c as (typeof CONTENT_CLASSES)[number]];
+        out.content.count += 1;
+        out.content.bytes += r.bytes;
+        k.count += 1;
+        k.bytes += r.bytes;
+        if (r.digest === null) continue;
+        const key = JSON.stringify([r.session, r.tool, r.tool === 'Read' ? [r.path, r.range] : r.command, r.digest]);
+        if (delivered.has(key)) {
+            out.repeats.count += 1;
+            out.repeats.bytes += r.bytes;
+            if (r.advised) out.repeats.advised += 1;
+            k.repeats += 1;
+            k.repeat_bytes += r.bytes;
+        } else delivered.add(key);
+    }
+    return out;
+}
+
+export interface CensusSummary {
+    legacy: number;
+    two_field: number;
+    unreadable: number;
+    delivered_unknown: number;
+    raw_bytes: number;
+    delivered_bytes_known: number;
+}
+
+export function readCensus(text: string): CensusSummary {
+    const out: CensusSummary = { legacy: 0, two_field: 0, unreadable: 0, delivered_unknown: 0, raw_bytes: 0, delivered_bytes_known: 0 };
+    for (const line of text.split('\n')) {
+        if (line.trim() === '') continue;
+        const r = readCensusLine(line);
+        if (r === null) {
+            out.unreadable += 1;
+            continue;
+        }
+        if (r.shape === 'legacy') out.legacy += 1;
+        else out.two_field += 1;
+        out.raw_bytes += r.raw_bytes ?? 0;
+        if (r.delivered_bytes === null) out.delivered_unknown += 1;
+        else out.delivered_bytes_known += r.delivered_bytes;
+    }
+    return out;
+}
+
+function mergeScans(prefix: string, root: string): Record<string, ClassInput> {
+    const merged: Record<string, ClassInput> = {};
+    const dirs = fs.existsSync(root) ? fs.readdirSync(root).filter((d) => d.startsWith(prefix)) : [];
+    for (const dir of dirs) {
+        for (const c of Object.values(scanToolResults({ root, projectDir: dir }).classes)) {
+            const m = (merged[c.tool] ??= { tool: c.tool, count: 0, payload_bytes: 0, payload_samples: [] });
+            m.count += c.count;
+            m.payload_bytes += c.payload_bytes;
+            m.payload_samples.push(...c.payload_samples);
+        }
+    }
+    return merged;
+}
+
+function flag(argv: readonly string[], name: string): string | null {
+    const i = argv.indexOf(name);
+    return i >= 0 ? (argv[i + 1] ?? null) : null;
+}
+
+function windowRecords(prefix: string, root: string, startMs: number, endMs: number): ToolResultRecord[] {
+    const dirs = fs.existsSync(root) ? fs.readdirSync(root).filter((d) => d.startsWith(prefix)) : [];
+    return dirs.flatMap((dir) => scanToolResultRecords({ root, projectDir: dir })).filter((r) => inWindow(r.timestamp, startMs, endMs));
+}
+
+/** Both profiles over the D11 window only; a run before the window closes is labelled a peek (PREREG). */
+function mainContent(argv: readonly string[], threshold: number, prefix: string, now: Date): number {
+    const startMs = Date.parse(D11_WINDOW_START);
+    const endMs = Date.parse(d11WindowEnd());
+    const peek = now.getTime() < endMs;
+    const records = windowRecords(prefix, DEFAULT_PROJECTS_ROOT, startMs, endMs);
+    const content = contentProfile(records, threshold);
+    const repeat = repeatShare(records);
+    const byTool: Record<string, ClassInput> = {};
+    for (const r of records) {
+        const m = (byTool[r.tool] ??= { tool: r.tool, count: 0, payload_bytes: 0, payload_samples: [] });
+        m.count += 1;
+        m.payload_bytes += r.bytes;
+        m.payload_samples.push(r.bytes);
+    }
+    const execution = selectClasses(byTool, threshold);
+    const window = { start: D11_WINDOW_START, end: d11WindowEnd(), results: records.length, peek };
+    if (argv.includes('--json')) {
+        const executionSelected = execution.filter((v) => v.selected).map((v) => v.tool);
+        process.stdout.write(`${JSON.stringify({ profile: 'content', threshold, prefix, window, content, repeat_share: repeat, execution, execution_selected: executionSelected }, null, 2)}\n`);
+        return 0;
+    }
+    const lines = [
+        `content profile: threshold ${String(threshold)} B, floor ${String(CONTENT_SAMPLE_FLOOR)} results, window ${window.start} .. ${window.end} (${String(records.length)} results), prefix ${prefix}`,
+    ];
+    if (peek) lines.push('PEEK — the window has not closed; this reading is not a selection (PREREG)');
+    for (const c of content.classes) lines.push(`  ${c.verdict.padEnd(12)} ${c.class} n=${String(c.count)} bytes=${String(c.payload_bytes)} p95=${String(c.p95)}`);
+    lines.push(`  residue      Bash n=${String(content.residue.count)} above ${String(threshold)} B: ${String(content.residue.above_threshold)}`);
+    lines.push(`content selected: ${content.selected.length === 0 ? 'none' : content.selected.join(', ')}`);
+    lines.push(
+        `repeat share (step 1.4, no bar): ${String(repeat.repeats.count)} of ${String(repeat.content.count)} content results, ${String(repeat.repeats.bytes)} of ${String(repeat.content.bytes)} B, ${String(repeat.repeats.advised)} after a re-read advisory`,
+    );
+    const executionSelected = execution.filter((v) => v.selected).map((v) => v.tool);
+    lines.push(`execution selected (1.1 criterion, same window): ${executionSelected.length === 0 ? 'none' : executionSelected.join(', ')}`);
+    process.stdout.write(`${lines.join('\n')}\n`);
+    return 0;
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2), now: Date = new Date()): number {
+    const threshold = Number(flag(argv, '--threshold') ?? D1_THRESHOLD_BYTES);
+    const prefix = flag(argv, '--project-prefix') ?? projectStoreSlug(REPO);
+    const profile = flag(argv, '--profile') ?? 'execution';
+    if (profile === 'content') return mainContent(argv, threshold, prefix, now);
+    if (profile !== 'execution') {
+        process.stderr.write(`unknown --profile ${profile} (execution | content)\n`);
+        return 2;
+    }
+    const verdicts = selectClasses(mergeScans(prefix, DEFAULT_PROJECTS_ROOT), threshold);
+    const censusPath = flag(argv, '--census') ?? path.join(REPO, CENSUS);
+    const census = fs.existsSync(censusPath) ? readCensus(fs.readFileSync(censusPath, 'utf-8')) : null;
+    const selected = verdicts.filter((v) => v.selected).map((v) => v.tool);
+    if (argv.includes('--json')) {
+        process.stdout.write(`${JSON.stringify({ threshold, prefix, selected, verdicts, census }, null, 2)}\n`);
+        return 0;
+    }
+    const lines = [`reducible classes: threshold ${String(threshold)} B (p95, model-visible), prefix ${prefix}`];
+    for (const v of verdicts) {
+        const why = v.non_goal ?? (v.above_threshold ? '' : 'p95<=threshold') + (v.failure_structured ? '' : ' no-failure-lines');
+        lines.push(`  ${v.selected ? 'SELECTED' : 'out     '} ${v.tool} n=${String(v.count)} bytes=${String(v.payload_bytes)} p95=${String(v.p95)} ${why.trim()}`);
+    }
+    lines.push(`selected: ${selected.length === 0 ? 'none' : selected.join(', ')}`);
+    lines.push(census === null ? `census: ${censusPath} absent` : `census: ${JSON.stringify(census)}`);
+    process.stdout.write(`${lines.join('\n')}\n`);
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    const a = process.argv[1];
+    if (!a) return false;
+    if (a === _FILE || pathToFileURL(path.resolve(a)).href === import.meta.url) return true;
+    try {
+        return fs.realpathSync(a) === fs.realpathSync(_FILE);
+    } catch {
+        return false;
+    }
+}
+if (_isCliEntry()) process.exit(main());

package/src/scripts/report_required_checks_drift.ts

@@ -11,9 +11,11 @@
  * `ENFORCED_CHECKS`.
  *
  * READ-ONLY. It writes nothing and changes nothing on the ruleset. It is run by
- * hand or on a schedule and is NOT wired as a required check — a network read
- * cannot sit on the path of every pull request, and the token it needs is a
- * repository-read token, not something each PR should depend on.
+ * hand and is NOT wired as a required check — a network read cannot sit on the
+ * path of every pull request, and the token it needs is a repository-read
+ * token, not something each PR should depend on. No workflow schedules it, and
+ * adding one is a separate decision rather than a gap this sentence may paper
+ * over by describing a cadence the tree does not have.
  *
  * Usage:
  *   ./scripts-run src/scripts/report_required_checks_drift

package/src/scripts/report_skill_host_census.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env tsx
+/**
+ * Per host and install path: how many authored skills land, what the listing
+ * costs, and what the host is modelled to leave out.
+ *
+ * `road-to-skills-that-arrive-when-called` step 0.1. Phase 4 decides where a
+ * skill is materialised on demand, and only where a host drops or lacks one.
+ * That decision needs one table, computed and not typed: per host, per install
+ * path, the installed count, the listing characters with descriptions and with
+ * names only, and the set the host leaves out.
+ *
+ * WHAT IT IS NOT. A report — the `report_` prefix keeps it out of the gate
+ * population, and the exit code carries no verdict. It does not observe a host
+ * either: every "omitted" figure is a MODEL over upstream prose, labelled as
+ * such, and a host whose omission rule this tree has not read is `unobserved`
+ * rather than guessed. Phase 0.2 and 0.3 are the probes; this is the arithmetic
+ * they are checked against.
+ *
+ * THE RULES, stated because they are the whole content:
+ *
+ *   authored      every `SKILL.md` the canonical walk (`update_counts.iter_skills`)
+ *                 yields.
+ *   install path  `default` — the installer's scoped projection with no runtime
+ *                 packs (`is_pruned_under_scoped`, the predicate the installer
+ *                 prunes with); `full` — every authored skill.
+ *   host          every tool whose global deploy table writes
+ *                 `dist/agent-src/skills`, with the root it writes to.
+ *   root_read     whether the host's own skills page names the written root:
+ *                 `yes` / `no` where a watched page says so
+ *                 (`hooks/host_docs_pages.yaml`), `unobserved` otherwise.
+ *   listing chars `name + description` per entry, summed; names-only sums the
+ *                 names. Separators and paths are not counted, so both are
+ *                 lower bounds on what a host spends.
+ *   omitted       claude-code: the descriptions `modelListingBudget` drops at a
+ *                 200,000-token window (names are never dropped there). codex:
+ *                 the documented budget (8,000 characters when the window is
+ *                 unknown) and whether the listing exceeds it; WHICH entries go
+ *                 is unobserved, so no set is named. Every other host:
+ *                 `unobserved`.
+ *
+ * Usage:
+ *     ./scripts-run src/scripts/report_skill_host_census          # JSON on stdout
+ *
+ * Deterministic: rows and names sort, no clock, no environment read.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { GLOBAL_DEPLOY_SOURCES } from '../install/wizard-plan.js';
+import { modelListingBudget } from './_lib/host_listing_model.js';
+import {
+    compute_active_pack_ids,
+    declared_skill_closure,
+    is_pruned_under_scoped,
+    load_packs_registry,
+    projected_command_files,
+} from './_lib/scoped_projection.js';
+import { USER_SCOPE_PATHS } from './install.js';
+import { iter_skills, REPO_ROOT } from './update_counts.js';
+import { parse_frontmatter } from './validate_frontmatter.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+
+const SKILLS_SRC = 'dist/agent-src/skills';
+const CLAUDE_WINDOW_TOKENS = 200_000;
+const CODEX_UNKNOWN_WINDOW_BUDGET_CHARS = 8_000;
+
+/** Roots a watched host page names. Anything absent is `unobserved`. */
+const DOCUMENTED_USER_ROOTS: Readonly<Record<string, string>> = {
+    'claude-code': '~/.claude/skills',
+    codex: '~/.agents/skills',
+};
+
+export interface SkillEntry {
+    name: string;
+    descriptionChars: number;
+    path: string;
+}
+
+export interface CensusRow {
+    host: string;
+    install_path: 'default' | 'full';
+    root: string;
+    root_read: 'yes' | 'no' | 'unobserved';
+    installed: number;
+    not_installed: number;
+    authored: number;
+    listing_chars_with_descriptions: number;
+    listing_chars_names_only: number;
+    omitted:
+        | { state: 'modelled'; kind: 'description'; budget_chars: number; names: string[] }
+        | { state: 'modelled'; kind: 'entry'; budget_chars: number; exceeds_budget: boolean; names: null }
+        | { state: 'unobserved' };
+}
+
+export interface Census {
+    authored: number;
+    rows: CensusRow[];
+}
+
+export function load_entries(skillPaths: Iterable<string> = iter_skills()): SkillEntry[] {
+    const out: SkillEntry[] = [];
+    for (const p of skillPaths) {
+        const [fm] = parse_frontmatter(fs.readFileSync(p, 'utf-8'));
+        const desc = fm === null ? undefined : (fm as Record<string, unknown>)['description'];
+        out.push({
+            name: path.basename(path.dirname(p)),
+            descriptionChars: typeof desc === 'string' ? desc.length : 0,
+            path: p,
+        });
+    }
+    return out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+
+function skillHosts(): Array<{ host: string; root: string }> {
+    const out: Array<{ host: string; root: string }> = [];
+    for (const [host, rows] of Object.entries(GLOBAL_DEPLOY_SOURCES)) {
+        const row = rows.find(([src]) => src === SKILLS_SRC);
+        const anchor = USER_SCOPE_PATHS[host];
+        if (row === undefined || anchor === undefined) continue;
+        out.push({ host, root: path.posix.join(anchor, row[1]) });
+    }
+    return out.sort((a, b) => (a.host < b.host ? -1 : a.host > b.host ? 1 : 0));
+}
+
+function rootRead(host: string, root: string): CensusRow['root_read'] {
+    const documented = DOCUMENTED_USER_ROOTS[host];
+    if (documented === undefined) return 'unobserved';
+    return documented === root ? 'yes' : 'no';
+}
+
+export function build_census(entries: readonly SkillEntry[], package_root: string = REPO_ROOT): Census {
+    const active = compute_active_pack_ids(load_packs_registry(package_root), []);
+    const kept = declared_skill_closure([...entries.map((e) => e.path), ...projected_command_files(package_root)], active);
+    const scoped = entries.filter((e) => !is_pruned_under_scoped(e.path, active, kept));
+    const paths: Array<['default' | 'full', readonly SkillEntry[]]> = [
+        ['default', scoped],
+        ['full', entries],
+    ];
+    const rows: CensusRow[] = [];
+    for (const { host, root } of skillHosts()) {
+        for (const [install_path, set] of paths) {
+            const withDesc = set.reduce((n, e) => n + e.name.length + e.descriptionChars, 0);
+            const namesOnly = set.reduce((n, e) => n + e.name.length, 0);
+            let omitted: CensusRow['omitted'];
+            if (host === 'claude-code') {
+                const m = modelListingBudget(
+                    set.map((e) => ({ name: e.name, descriptionChars: e.descriptionChars })),
+                    { contextWindowTokens: CLAUDE_WINDOW_TOKENS },
+                );
+                omitted = { state: 'modelled', kind: 'description', budget_chars: m.budgetChars, names: [...m.bare].sort() };
+            } else if (host === 'codex') {
+                omitted = {
+                    state: 'modelled',
+                    kind: 'entry',
+                    budget_chars: CODEX_UNKNOWN_WINDOW_BUDGET_CHARS,
+                    exceeds_budget: withDesc > CODEX_UNKNOWN_WINDOW_BUDGET_CHARS,
+                    names: null,
+                };
+            } else {
+                omitted = { state: 'unobserved' };
+            }
+            rows.push({
+                host,
+                install_path,
+                root,
+                root_read: rootRead(host, root),
+                installed: set.length,
+                not_installed: entries.length - set.length,
+                authored: entries.length,
+                listing_chars_with_descriptions: withDesc,
+                listing_chars_names_only: namesOnly,
+                omitted,
+            });
+        }
+    }
+    return { authored: entries.length, rows };
+}
+
+export function main(): number {
+    process.stdout.write(`${JSON.stringify(build_census(load_entries()), null, 2)}\n`);
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) return false;
+    if (import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) return true;
+    try {
+        return fs.realpathSync(_HERE) === fs.realpathSync(path.resolve(process.argv[1]));
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry()) {
+    process.exit(main());
+}

package/src/scripts/report_standing_payload_by_host.ts

@@ -152,19 +152,19 @@ export type ByteSource =
 export const HOST_SURFACES: readonly HostSurface[] = [
     {
         host: 'augment', surface: '.augment/rules', perRuleTree: true,
-        writer: 'src/scripts/condense.ts:2482',
+        writer: 'src/scripts/condense.ts:2476',
         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:1181',
+        writer: 'src/scripts/condense.ts:1180',
         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:1183',
+        writer: 'src/scripts/condense.ts:1182',
         anchor: 'fs.symlinkSync(',
         note: 'symlink per rule into the projection',
     },
@@ -192,13 +192,13 @@ export const HOST_SURFACES: readonly HostSurface[] = [
     },
     {
         host: 'cursor', surface: '.cursor/rules', perRuleTree: true,
-        writer: 'src/scripts/condense.ts:1183',
+        writer: 'src/scripts/condense.ts:1182',
         anchor: 'fs.symlinkSync(',
-        note: 'symlink per rule, plus `.mdc` companions at `condense.ts:1405`',
+        note: 'symlink per rule, plus `.mdc` companions at `condense.ts:1406`',
     },
     {
         host: 'gemini', surface: 'GEMINI.md', perRuleTree: false,
-        writer: 'src/scripts/condense.ts:1481',
+        writer: 'src/scripts/condense.ts:1480',
         anchor: '\'GEMINI.md\'',
         note: 'single file — a symlink to the tracked `AGENTS.md`, so the bytes are that file\'s',
         bytes: {
@@ -213,7 +213,7 @@ export const HOST_SURFACES: readonly HostSurface[] = [
     },
     {
         host: 'windsurf', surface: '.windsurfrules', perRuleTree: false,
-        writer: 'src/scripts/condense.ts:1225',
+        writer: 'src/scripts/condense.ts:1224',
         anchor: '\'.windsurfrules\'',
         note: 'single concatenated file, rendered here by `condense.render_windsurfrules` rather than read off disk',
         bytes: {