@event4u/agent-config 16.5.0 → 17.0.0

package/src/scripts/check_gate_coverage.ts

@@ -45,6 +45,7 @@
  * disagrees with the census) · 2 the manifest itself is missing/empty/malformed.
  */
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -53,7 +54,7 @@ import * as yaml from 'js-yaml';
 import { asOf } from './_lib/as_of.js';
 import { checkRatchet } from './_lib/gate_baseline.js';
 import { GateLedger, type GateSkipReason } from './_lib/gate_ledger.js';
-import { runCountedProbe } from './_lib/counted_probe.js';
+import { runCountedProbe, runCountedProbeAsync } from './_lib/counted_probe.js';
 import { listGateScripts } from './_lib/gate_population.js';
 import { describeOutcome, namesEstateInvalidatingError } from './_lib/gate_result.js';
 import { assertScanned } from './_lib/scan_scope.js';
@@ -129,6 +130,15 @@ export interface GateSpec {
    * gate whose argument list equals `argv` exactly.
    */
   ci_invocation?: string;
+  /**
+   * Repo-relative workflow that already runs this gate AND asserts its floor in
+   * the same job via `check_gate_coverage --from-output <file> --only <id>`.
+   * The per-PR census then does not execute the gate a second time — but only
+   * after confirming that workflow still carries the assertion; otherwise it
+   * runs the gate as usual, so a removed assertion can never leave the floor
+   * unenforced.
+   */
+  floor_asserted_in?: string;
   note?: string;
 }
 
@@ -139,7 +149,8 @@ export type Verdict =
   | 'crashed'
   | 'estate_invalid'
   | 'pending'
-  | 'unavailable';
+  | 'unavailable'
+  | 'delegated';
 
 export interface GateResult {
   id: string;
@@ -148,6 +159,8 @@ export interface GateResult {
   scanned: number | null;
   min_scanned: number;
   message: string;
+  /** Wall time of this gate's run inside the guard; absent when it was not executed. */
+  elapsed_ms?: number;
 }
 
 function _require_str(v: unknown, field: string, id: string, i: number): string {
@@ -210,6 +223,9 @@ export function load_manifest(file = MANIFEST): GateSpec[] {
       ...(e['ci_invocation'] === undefined
         ? {}
         : { ci_invocation: _require_str(e['ci_invocation'], 'ci_invocation', id, i) }),
+      ...(e['floor_asserted_in'] === undefined
+        ? {}
+        : { floor_asserted_in: _require_str(e['floor_asserted_in'], 'floor_asserted_in', id, i) }),
       ...(e['note'] === undefined ? {} : { note: String(e['note']) }),
       ...(e['canary'] === undefined ? {} : { canary: _require_canary(e['canary'], id, i) }),
       ...(e['no_canary_reason'] === undefined
@@ -283,6 +299,10 @@ export function ledgerOutcomeFor(
       return 'fail';
     case 'ok':
       return 'complete';
+    case 'delegated':
+      // Not inspected HERE: the row's `floor_asserted_in` is the reviewable
+      // exemption, and the floor is asserted in that workflow's own job.
+      return 'declared_exemption';
     default: {
       // Exhaustiveness guard. A `Verdict` member added later must be classified
       // deliberately: without this, a new member would silently count as
@@ -362,23 +382,82 @@ export function classify(
   return { ...base, verdict: 'ok', message: `scanned ${String(scanned)} ≥ ${String(spec.min_scanned)}` };
 }
 
-function run_gate(spec: GateSpec): {
+async function run_gate_async(spec: GateSpec): Promise<{
   scanned: number | null;
   crashed: boolean;
   exit_code: number | null;
   output: string;
-} {
+  elapsed_ms: number;
+}> {
   const runner = path.join(REPO_ROOT, 'scripts-run');
   // Bounded read: a gate whose output overflowed would lose its `scanned:`
   // line and be classified `silent` — the scan-scope guard reporting a dead
-  // scope that is merely truncated. `runCountedProbe` throws instead.
-  const r = runCountedProbe(runner, [`src/scripts/${spec.id}`, ...spec.argv], { cwd: REPO_ROOT });
+  // scope that is merely truncated. `runCountedProbeAsync` rejects instead.
+  const t0 = performance.now();
+  const r = await runCountedProbeAsync(runner, [`src/scripts/${spec.id}`, ...spec.argv], { cwd: REPO_ROOT });
+  const elapsed_ms = Math.round(performance.now() - t0);
   const output = `${r.stdout}\n${r.stderr}`;
   if (r.failure !== null && r.status === null)
-    return { scanned: null, crashed: true, exit_code: null, output };
+    return { scanned: null, crashed: true, exit_code: null, output, elapsed_ms };
   // A gate may legitimately exit non-zero (it found real violations) and still
   // have scanned plenty — coverage and verdict are different questions.
-  return { scanned: parse_scanned(output), crashed: false, exit_code: r.status, output };
+  return { scanned: parse_scanned(output), crashed: false, exit_code: r.status, output, elapsed_ms };
+}
+
+/**
+ * Run `fn` over `items` with at most `jobs` in flight, returning results in
+ * INPUT order — the report must be byte-stable whatever order the gates finish in.
+ */
+export async function runPool<T, R>(
+  items: readonly T[],
+  jobs: number,
+  fn: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  const out: R[] = new Array<R>(items.length);
+  let next = 0;
+  const worker = async (): Promise<void> => {
+    for (;;) {
+      const i = next++;
+      if (i >= items.length) return;
+      out[i] = await fn(items[i] as T, i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(jobs, items.length)) }, worker));
+  return out;
+}
+
+/** `--jobs N` when given and valid, else the host's available parallelism. */
+export function parse_jobs(argv: readonly string[]): number {
+  const i = argv.indexOf('--jobs');
+  if (i >= 0) {
+    const n = Number(argv[i + 1]);
+    if (Number.isInteger(n) && n >= 1) return n;
+  }
+  return os.availableParallelism();
+}
+
+/**
+ * Why a row's `floor_asserted_in` cannot be honoured, or null when it can: the
+ * named workflow must call `check_gate_coverage --from-output … --only <id>`.
+ */
+export function floor_delegation_problem(workflowText: string, id: string): string | null {
+  const calls = ci_invocations(workflowText, 'check_gate_coverage');
+  const ok = calls.some((a) => a.includes('--from-output') && a[a.indexOf('--only') + 1] === id);
+  return ok ? null : `no \`check_gate_coverage --from-output … --only ${id}\` assertion there`;
+}
+
+/** Apply one row's floor to a captured gate output, without running the gate. */
+export function assert_from_output(specs: readonly GateSpec[], argv: readonly string[]): number {
+  const file = argv[argv.indexOf('--from-output') + 1];
+  const id = argv[argv.indexOf('--only') + 1];
+  const spec = specs.find((s) => s.id === id);
+  if (file === undefined || id === undefined || spec === undefined || !fs.existsSync(file)) {
+    process.stderr.write(`❌  --from-output needs an existing file and --only <manifest id>\n`);
+    return 2;
+  }
+  const r = classify(spec, parse_scanned(fs.readFileSync(file, 'utf-8')), false);
+  process.stdout.write(`  ${ICON[r.verdict]} ${r.id}: ${r.message}\n`);
+  return r.verdict === 'ok' ? 0 : 1;
 }
 
 const ICON: Record<Verdict, string> = {
@@ -389,6 +468,7 @@ const ICON: Record<Verdict, string> = {
   estate_invalid: '❌',
   pending: '⚠️',
   unavailable: '⚠️',
+  delegated: '↪️',
 };
 
 /**
@@ -491,7 +571,7 @@ export function ci_invocation_drift(specs: readonly GateSpec[], repoRoot = REPO_
   return problems;
 }
 
-export function main(argv: readonly string[]): number {
+export async function main(argv: readonly string[]): Promise<number> {
   const wantJson = argv.includes('--format') && argv[argv.indexOf('--format') + 1] === 'json';
   const listOnly = argv.includes('--list');
 
@@ -518,6 +598,9 @@ export function main(argv: readonly string[]): number {
   if (argv.includes('--canary')) {
     return run_canary_mode(specs, argv);
   }
+  if (argv.includes('--from-output')) {
+    return assert_from_output(specs, argv);
+  }
 
   if (listOnly) {
     for (const s of specs) {
@@ -555,13 +638,29 @@ export function main(argv: readonly string[]): number {
   // refuses to double-count it.
   ledger.plan([...new Set(specs.map((s) => s.id))]);
 
-  const results = specs.map((s) => {
-    if (spec_is_pending(s)) {
-      const { scanned, crashed } = probe_pending(s);
-      return classify(s, scanned, crashed);
+  const results = await runPool(specs, parse_jobs(argv), async (s): Promise<GateResult> => {
+    if (s.floor_asserted_in !== undefined && !spec_is_pending(s)) {
+      const file = path.join(REPO_ROOT, s.floor_asserted_in);
+      const problem = fs.existsSync(file)
+        ? floor_delegation_problem(fs.readFileSync(file, 'utf-8'), s.id)
+        : `${s.floor_asserted_in} does not exist`;
+      if (problem === null) {
+        return {
+          id: s.id,
+          status: s.status,
+          verdict: 'delegated',
+          scanned: null,
+          min_scanned: s.min_scanned,
+          message: `floor asserted in ${s.floor_asserted_in}, not re-run here`,
+        };
+      }
+      process.stdout.write(`  ⚠️  ${s.id}: floor_asserted_in ignored — ${problem}; running it here\n`);
     }
-    const { scanned, crashed, exit_code, output } = run_gate(s);
-    return classify(s, scanned, crashed, exit_code, output);
+    const { scanned, crashed, exit_code, output, elapsed_ms } = await run_gate_async(s);
+    // Pending gates are still probed (so the report shows what they currently
+    // do), but their count never fails the build.
+    const r = spec_is_pending(s) ? classify(s, scanned, crashed) : classify(s, scanned, crashed, exit_code, output);
+    return { ...r, elapsed_ms };
   });
 
   // `recorded` pairs with the deduplicated plan above: a duplicated manifest id
@@ -584,6 +683,14 @@ export function main(argv: readonly string[]): number {
     for (const r of results) {
       process.stdout.write(`  ${ICON[r.verdict]} ${r.id}: ${r.message}\n`);
     }
+    const slowest = results
+      .filter((r) => r.elapsed_ms !== undefined)
+      .sort((a, b) => (b.elapsed_ms ?? 0) - (a.elapsed_ms ?? 0))
+      .slice(0, 10);
+    process.stdout.write(`\nslowest gates (wall, ${String(parse_jobs(argv))} in parallel):\n`);
+    for (const r of slowest) {
+      process.stdout.write(`  ${(((r.elapsed_ms ?? 0) / 1000).toFixed(1)).padStart(7)} s  ${r.id}\n`);
+    }
   }
 
   const failed = results.filter((r) => r.verdict === 'below_floor' || r.verdict === 'silent' || r.verdict === 'crashed');
@@ -794,11 +901,6 @@ function spec_is_pending(s: GateSpec): boolean {
   return s.status === 'pending';
 }
 
-/** Pending gates are still probed (so the report shows what they currently do),
- * but their count never fails the build. */
-function probe_pending(s: GateSpec): { scanned: number | null; crashed: boolean } {
-  return run_gate(s);
-}
 
 // ── Mutation canary (Phase 7) ──────────────────────────────────────────────
 
@@ -1113,5 +1215,5 @@ function _isCliEntry(): boolean {
 }
 
 if (_isCliEntry()) {
-  process.exit(main(process.argv.slice(2)));
+  void main(process.argv.slice(2)).then((code) => process.exit(code));
 }

package/src/scripts/check_gate_reachability.ts

@@ -196,9 +196,23 @@ export interface Reachability {
     unreachable: string[];
 }
 
-/** The script a target runs, as a repo-relative path, or `null`. */
+/**
+ * The script a target runs, as a repo-relative path, or `null`.
+ *
+ * COMMENT LINES ARE NOT COMMANDS. The block captured per target carries the
+ * target's comments as well as its `cmds:`, and a comment that merely NAMES a
+ * script is not the target running it. `ci-strict` is the worked example: it
+ * runs no script at all, and its comment says it is "Guarded by
+ * `check-ci-strict-superset` (src/scripts/check_ci_strict_superset.ts)". Once
+ * that guard was wired into a workflow, the prose made `ci-strict` read as
+ * script-invoked-by-a-workflow, so a meta-task that is deliberately unwired
+ * was reported as reachable and its exemption row as stale. Dropping comment
+ * lines before the match is what keeps a sentence about a script from
+ * counting as a call to it.
+ */
 export function scriptOf(d: TargetDef): string | null {
-    const m = d.cmds.join(' ').match(/src\/scripts\/[a-z0-9_/]+/);
+    const code = d.cmds.filter((line) => !/^\s*#/.test(line));
+    const m = code.join(' ').match(/src\/scripts\/[a-z0-9_/]+/);
     return m === null ? null : m[0];
 }
 

package/src/scripts/check_generator_sync.ts

@@ -593,12 +593,58 @@ const GIT_CONVENTION_GRAMMAR_TRIPLE: Triple = {
     },
 };
 
+const OWNED_DIGEST = 'agents/roadmaps-owned.md';
+const OWNED_GENERATOR = 'src/scripts/generate_owned_digest.ts';
+
+/**
+ * The owned-roadmap digest rows every active, parked and stub roadmap, so a
+ * landing, a park, an archive or a rewritten goal changes it. A checkbox flip
+ * does not: the row holds only fields that change rarely.
+ */
+const OWNED_DIGEST_TRIPLE: Triple = {
+    id: 'owned-digest',
+    output: OWNED_DIGEST,
+    remedy: './scripts-run src/scripts/generate_owned_digest',
+    why: 'the digest carries one row per active, parked and stub roadmap, read from its goal and status',
+    sourcesOf() {
+        return {
+            ok: true,
+            sources: [
+                { kind: 'prefix', value: 'agents/roadmaps/' },
+                { kind: 'file', value: OWNED_GENERATOR },
+                { kind: 'file', value: OWNED_DIGEST },
+            ],
+        };
+    },
+    regenerate(root, workDir) {
+        const outFile = path.join(workDir, 'roadmaps-owned.md');
+        const tsx = path.join(root, 'node_modules', '.bin', process.platform === 'win32' ? 'tsx.cmd' : 'tsx');
+        if (!fs.existsSync(tsx)) {
+            return { ok: false, reason: `no tsx at ${path.relative(root, tsx)} — run \`npm ci\` before this gate` };
+        }
+        const res = spawnSync(tsx, [path.join(root, OWNED_GENERATOR), '--out', outFile], {
+            cwd: root,
+            encoding: 'utf8',
+            maxBuffer: 64 * 1024 * 1024,
+        });
+        if (res.status !== 0) {
+            return { ok: false, reason: `generate_owned_digest exited ${String(res.status)}: ${(res.stderr ?? '').trim()}` };
+        }
+        try {
+            return { ok: true, text: fs.readFileSync(outFile, 'utf8') };
+        } catch (e) {
+            return { ok: false, reason: `generate_owned_digest reported success but wrote no readable file (${String(e)})` };
+        }
+    },
+};
+
 export const REGISTRY: readonly Triple[] = [
     CENSUS_TRIPLE,
     INSTALL_BUNDLE_TRIPLE,
     HOOK_MANIFEST_TRIPLE,
     HOST_LOWERING_TRIPLE,
     GIT_CONVENTION_GRAMMAR_TRIPLE,
+    OWNED_DIGEST_TRIPLE,
 ];
 
 // ---------------------------------------------------------------------------

package/src/scripts/check_hook_bundle_composition.ts

@@ -69,6 +69,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { runGateCli, runSelfTest } from './_lib/gate_self_test.js';
 import { reportScanned } from './_lib/scan_scope.js';
 import { buildScript } from './check_hook_bundle_content.js';
+import { buildChunk, HOOK_CHUNKS } from './hook_chunks.mjs';
 import { rewriteOutfile } from './rebuild_hook_bundle.js';
 
 const _HERE = path.dirname(fileURLToPath(import.meta.url));
@@ -151,6 +152,127 @@ export function analyzeMetafile(json: string): Analysis {
     };
 }
 
+/** A conditional chunk's own ceiling: the bytes `build:hook-chunks` emits for `entry`. */
+export interface ChunkBudget {
+    readonly entry: string;
+    readonly maxBytes: number;
+}
+
+/**
+ * The chunk ceilings, from the budget's optional `chunks` list. A chunk moves
+ * bytes out of the dispatch bundle; without a ceiling of its own it would only
+ * move uncontrolled growth somewhere nobody measures (council 2026-10-18).
+ */
+export function readChunkBudgets(root: string): ChunkBudget[] {
+    const raw = JSON.parse(fs.readFileSync(path.join(root, BUDGET_REL), 'utf-8')) as Record<string, unknown>;
+    const list = raw['chunks'];
+    if (list === undefined) return [];
+    if (!Array.isArray(list)) throw new Error(`${BUDGET_REL}: chunks must be a list`);
+    const budgets = list.map((c, i) => {
+        const entry = isRecord(c) ? c['entry'] : undefined;
+        const max = isRecord(c) ? c['max_bytes'] : undefined;
+        if (typeof entry !== 'string' || typeof max !== 'number' || !Number.isInteger(max) || max <= 0) {
+            throw new Error(`${BUDGET_REL}: chunks[${String(i)}] needs a string entry and a positive integer max_bytes`);
+        }
+        return { entry, maxBytes: max };
+    });
+    const seen = new Set<string>();
+    for (const b of budgets) {
+        if (seen.has(b.entry)) throw new Error(`${BUDGET_REL}: chunks lists ${b.entry} twice`);
+        seen.add(b.entry);
+    }
+    return budgets;
+}
+
+/**
+ * Build the chunk for `entry` from the one chunk definition (`hook_chunks.mjs`,
+ * which `build:hook-chunks` runs) to a throwaway path, and return its size. The
+ * gate and the shipped build call the same function with the same options, so
+ * what is measured is what ships. Throws when no chunk is defined for the entry
+ * — a ceiling on a chunk nothing builds bounds nothing.
+ */
+export function buildChunkBytes(root: string, entry: string): number {
+    if (!HOOK_CHUNKS.some((c) => c.entry === entry)) {
+        throw new Error(`hook_chunks.mjs defines no chunk built from ${entry}`);
+    }
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'hook-chunk-composition-'));
+    const out = path.join(dir, 'chunk.cjs');
+    try {
+        buildChunk(root, entry, out);
+        return fs.statSync(out).size;
+    } finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+
+/**
+ * Every defined chunk carries exactly one ceiling and every ceiling names a
+ * defined chunk — so a chunk added to `hook_chunks.mjs` cannot ship unmeasured,
+ * and a ceiling cannot outlive the chunk it bounded.
+ */
+export function chunkCoverageFindings(defined: readonly string[], budgets: readonly ChunkBudget[]): string[] {
+    const out: string[] = [];
+    const twice = (xs: readonly string[]): string[] => [...new Set(xs.filter((x, i) => xs.indexOf(x) !== i))];
+    for (const d of twice(defined)) out.push(`chunk ${d} is defined more than once in hook_chunks.mjs`);
+    for (const d of twice(budgets.map((b) => b.entry))) out.push(`chunk ${d} has more than one ceiling in ${BUDGET_REL}`);
+    const budgeted = new Set(budgets.map((b) => b.entry));
+    for (const d of defined) if (!budgeted.has(d)) out.push(`chunk ${d} is built by hook_chunks.mjs but has no ceiling in ${BUDGET_REL}`);
+    for (const b of budgets) if (!defined.includes(b.entry)) out.push(`ceiling for ${b.entry} names no chunk hook_chunks.mjs builds`);
+    return out;
+}
+
+/** Over-ceiling findings for measured chunks. */
+export function chunkFindings(measured: ReadonlyMap<string, number>, budgets: readonly ChunkBudget[]): string[] {
+    const out: string[] = [];
+    for (const b of budgets) {
+        const bytes = measured.get(b.entry);
+        if (bytes === undefined) out.push(`chunk ${b.entry} was not measured`);
+        else if (bytes > b.maxBytes) {
+            out.push(
+                `chunk ${b.entry} is ${String(bytes)} bytes, ceiling is ${String(b.maxBytes)} ` +
+                    `(over by ${String(bytes - b.maxBytes)}). Shrink it, or raise its max_bytes in ${BUDGET_REL} ` +
+                    'WITH a raise_log entry naming the chunk and what was added.',
+            );
+        }
+    }
+    return out;
+}
+
+/**
+ * A chunk ceiling raised against the base revision needs a new raise_log entry
+ * whose `chunk` is the entry and whose `to` is the new ceiling — the main
+ * ceiling's rule, applied per chunk.
+ */
+export function chunkRaiseFindings(baseRaw: string | null, workingRaw: string): string[] {
+    if (baseRaw === null) return [];
+    const base = JSON.parse(baseRaw) as Record<string, unknown>;
+    const working = JSON.parse(workingRaw) as Record<string, unknown>;
+    const ceilings = (raw: Record<string, unknown>): Map<string, number> =>
+        new Map(
+            (Array.isArray(raw['chunks']) ? (raw['chunks'] as unknown[]) : [])
+                .filter(isRecord)
+                .map((c) => [String(c['entry']), Number(c['max_bytes'])]),
+        );
+    const before = ceilings(base);
+    const seen = new Set((Array.isArray(base['raise_log']) ? (base['raise_log'] as unknown[]) : []).map((e) => JSON.stringify(e)));
+    const gained = (Array.isArray(working['raise_log']) ? (working['raise_log'] as unknown[]) : []).filter(
+        (e) => !seen.has(JSON.stringify(e)),
+    );
+    const out: string[] = [];
+    for (const [entry, to] of ceilings(working)) {
+        const from = before.get(entry);
+        if (from === undefined || to <= from) continue;
+        const logged = gained.find((e) => isRecord(e) && e['chunk'] === entry && e['to'] === to);
+        if (logged === undefined) {
+            out.push(`chunk ${entry} ceiling raised from ${String(from)} to ${String(to)} with no new raise_log entry for it`);
+        } else {
+            const problems = raiseEntryProblems(logged as Record<string, unknown>, from);
+            if (problems.length > 0) out.push(`the raise_log entry for chunk ${entry} is incomplete: ${problems.join('; ')}.`);
+        }
+    }
+    return out;
+}
+
 /** Read the committed budget. Throws rather than defaulting — a guessed ceiling bounds nothing. */
 export function readBudget(root: string): Budget {
     const abs = path.join(root, BUDGET_REL);
@@ -420,6 +542,20 @@ export function main(argv: readonly string[] = process.argv.slice(2), root: stri
     }
 
     const findings = verdict(analysis, budget);
+    const chunkSizes = new Map<string, number>();
+    if (fixture === undefined) {
+        try {
+            const budgets = readChunkBudgets(root);
+            findings.push(...chunkCoverageFindings(HOOK_CHUNKS.map((c) => c.entry), budgets));
+            for (const b of budgets) {
+                if (HOOK_CHUNKS.some((c) => c.entry === b.entry)) chunkSizes.set(b.entry, buildChunkBytes(root, b.entry));
+            }
+            findings.push(...chunkFindings(chunkSizes, budgets));
+        } catch (e) {
+            process.stderr.write(`check_hook_bundle_composition: ${String(e instanceof Error ? e.message : e)}\n`);
+            return 2;
+        }
+    }
     const baseAt = argv.indexOf('--base-ref');
     const baseBudget = readBaseBudget(root, baseAt >= 0 ? argv[baseAt + 1] : undefined);
     if (baseBudget === undefined) {
@@ -436,7 +572,8 @@ export function main(argv: readonly string[] = process.argv.slice(2), root: stri
         }
         process.stdout.write('raise rule: no base revision resolved — the max_bytes raise check was not evaluated\n');
     } else {
-        findings.push(...raiseFindings(baseBudget, fs.readFileSync(path.join(root, BUDGET_REL), 'utf-8')));
+        const workingBudget = fs.readFileSync(path.join(root, BUDGET_REL), 'utf-8');
+        findings.push(...raiseFindings(baseBudget, workingBudget), ...chunkRaiseFindings(baseBudget, workingBudget));
     }
     // Reported on BOTH paths, red included: a census that goes quiet exactly
     // when the gate fires is the shape `reportScanned` exists to prevent.
@@ -453,6 +590,7 @@ export function main(argv: readonly string[] = process.argv.slice(2), root: stri
                 `${String(analysis.yamlPackages.length)} YAML reader(s) ` +
                 `[${analysis.yamlPackages.join(', ')}], ${String(analysis.modules)} modules\n`,
         );
+        for (const [entry, bytes] of chunkSizes) process.stdout.write(`✅  chunk ${entry}: ${String(bytes)} B\n`);
         return 0;
     }
     process.stderr.write('❌  hook bundle composition is out of budget\n');