@event4u/agent-config 16.5.0 → 17.0.0

package/src/scripts/source_adapters.ts

@@ -0,0 +1,183 @@
+/**
+ * source_adapters.ts — the local sources of the foreign-source door: a path
+ * read in place, a tar archive, and an already-present clone. Each yields one
+ * `SourceRef` whose pin and digest make a later run checkable against the same
+ * bytes.
+ *
+ * Nothing here executes the source. A clone is pinned by reading `.git/HEAD`
+ * and its refs as files, because even `git rev-parse` would honour the clone's
+ * own config. An archive is parsed, never unpacked: an entry that would land
+ * outside the archive refuses the whole source. Network kinds go through
+ * `network_sources.ts` and fail here with a pointer there.
+ */
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { gunzipSync } from 'node:zlib';
+
+import { detectSpdxFromText, resolveLicenseSignals, scanDirectoryLicenseSignals } from './_lib/detect_target_license.js';
+
+export const FETCH_BLOCKER = 'source-fetch-authorization';
+export const DEFAULT_MAX_ARCHIVE_BYTES = 200 * 1024 * 1024;
+
+export type SourceKind = 'local-path' | 'archive' | 'local-clone';
+
+export interface SourceRef {
+    identity: string;
+    kind: SourceKind;
+    license: string;
+    pin: string;
+    digest: string;
+    tier: 'read';
+    files: Record<string, string>;
+}
+
+export class SourceError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'SourceError';
+    }
+}
+
+function sha(data: string | Buffer): string {
+    return `sha256:${createHash('sha256').update(data).digest('hex')}`;
+}
+
+function treeDigest(files: Record<string, string>): string {
+    return sha(
+        Object.keys(files)
+            .sort()
+            .map((k) => `${k}\0${files[k] as string}\n`)
+            .join(''),
+    );
+}
+
+function unsupported(arg: string, why: string): SourceError {
+    return new SourceError(
+        `${arg}: ${why} — resolveSource reads local paths, tar archives and present clones; a network source goes through network_sources.ts under the fetch answer of ${FETCH_BLOCKER} (ADR-288 D7)`,
+    );
+}
+
+function walk(rootAbs: string): Record<string, string> {
+    const files: Record<string, string> = {};
+    const real = fs.realpathSync(rootAbs);
+    const visit = (dir: string): void => {
+        for (const name of fs.readdirSync(dir).sort()) {
+            if (name === '.git') continue;
+            const abs = path.join(dir, name);
+            const st = fs.lstatSync(abs);
+            if (st.isSymbolicLink()) {
+                let target: string;
+                try {
+                    target = fs.realpathSync(abs);
+                } catch {
+                    // Dangling: nothing to read, and links are never followed here anyway.
+                    continue;
+                }
+                if (target !== real && !target.startsWith(`${real}${path.sep}`)) {
+                    throw new SourceError(`${abs}: symlink points outside the source`);
+                }
+                continue;
+            }
+            if (st.isDirectory()) visit(abs);
+            else if (st.isFile()) files[path.relative(rootAbs, abs).split(path.sep).join('/')] = sha(fs.readFileSync(abs));
+        }
+    };
+    visit(rootAbs);
+    return files;
+}
+
+function dirLicense(dirAbs: string): string {
+    return resolveLicenseSignals(scanDirectoryLicenseSignals(dirAbs, '.')).spdxId ?? 'unknown';
+}
+
+function readHeadSha(cloneAbs: string): string {
+    const gitDir = path.join(cloneAbs, '.git');
+    const head = fs.readFileSync(path.join(gitDir, 'HEAD'), 'utf8').trim();
+    if (/^[0-9a-f]{40}$/.test(head)) return head;
+    const ref = /^ref: (\S+)$/.exec(head)?.[1];
+    if (ref === undefined) throw new SourceError(`${cloneAbs}: unreadable HEAD`);
+    const loose = path.join(gitDir, ref);
+    if (fs.existsSync(loose)) return fs.readFileSync(loose, 'utf8').trim();
+    const packed = path.join(gitDir, 'packed-refs');
+    if (fs.existsSync(packed)) {
+        for (const line of fs.readFileSync(packed, 'utf8').split('\n')) {
+            const [shaPart, name] = line.split(' ');
+            if (name === ref && shaPart !== undefined && /^[0-9a-f]{40}$/.test(shaPart)) return shaPart;
+        }
+    }
+    throw new SourceError(`${cloneAbs}: HEAD ref ${ref} has no commit (empty clone)`);
+}
+
+function cString(buf: Buffer, start: number, len: number): string {
+    const raw = buf.subarray(start, start + len);
+    const end = raw.indexOf(0);
+    return raw.subarray(0, end === -1 ? raw.length : end).toString('utf8');
+}
+
+function assertInside(name: string, archive: string): void {
+    if (name.startsWith('/')) throw new SourceError(`${archive}: absolute entry ${name}`);
+    const norm = path.posix.normalize(name);
+    if (norm === '..' || norm.startsWith('../') || name.split('/').includes('..')) {
+        throw new SourceError(`${archive}: entry ${name} contains ../`);
+    }
+}
+
+function readTar(archiveAbs: string, maxBytes: number): { files: Record<string, string>; license: string } {
+    if (fs.statSync(archiveAbs).size > maxBytes) throw new SourceError(`${archiveAbs}: archive exceeds ${maxBytes} bytes`);
+    let buf = fs.readFileSync(archiveAbs);
+    if (buf[0] === 0x1f && buf[1] === 0x8b) buf = gunzipSync(buf, { maxOutputLength: maxBytes });
+    if (buf.length > maxBytes) throw new SourceError(`${archiveAbs}: archive exceeds ${maxBytes} bytes unpacked`);
+    if (cString(buf, 257, 5) !== 'ustar') throw unsupported(archiveAbs, 'not a tar archive');
+    const files: Record<string, string> = {};
+    let license = 'unknown';
+    for (let off = 0; off + 512 <= buf.length; ) {
+        const header = buf.subarray(off, off + 512);
+        if (header.every((b) => b === 0)) break;
+        const prefix = cString(header, 345, 155);
+        const base = cString(header, 0, 100);
+        const name = prefix.length > 0 ? `${prefix}/${base}` : base;
+        const size = parseInt(cString(header, 124, 12).trim() || '0', 8);
+        const type = String.fromCharCode(header[156] as number);
+        assertInside(name, archiveAbs);
+        if (type === '1' || type === '2') {
+            const link = cString(header, 157, 100);
+            const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(name), link));
+            if (link.startsWith('/') || resolved === '..' || resolved.startsWith('../')) {
+                throw new SourceError(`${archiveAbs}: symlink ${name} points outside the archive`);
+            }
+        }
+        const body = buf.subarray(off + 512, off + 512 + size);
+        if (type === '0' || type === '\0') {
+            files[name] = sha(body);
+            if (/(^|\/)(LICENSE|LICENSE\.md|COPYING)$/.test(name) && license === 'unknown') {
+                license = detectSpdxFromText(body.toString('utf8')) ?? 'unknown';
+            }
+        }
+        off += 512 + Math.ceil(size / 512) * 512;
+    }
+    return { files, license };
+}
+
+export function resolveSource(arg: string, opts: { maxArchiveBytes?: number } = {}): SourceRef {
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(arg) || /^[\w.-]+@[\w.-]+:/.test(arg)) {
+        throw unsupported(arg, 'a network source');
+    }
+    const abs = path.resolve(arg);
+    if (!fs.existsSync(abs)) throw new SourceError(`${arg}: no such path`);
+    const st = fs.statSync(abs);
+    if (st.isDirectory()) {
+        const files = walk(abs);
+        const digest = treeDigest(files);
+        if (fs.existsSync(path.join(abs, '.git', 'HEAD'))) {
+            return { identity: abs, kind: 'local-clone', license: dirLicense(abs), pin: readHeadSha(abs), digest, tier: 'read', files };
+        }
+        return { identity: abs, kind: 'local-path', license: dirLicense(abs), pin: digest, digest, tier: 'read', files };
+    }
+    if (/\.(tar|tgz|tar\.gz)$/.test(abs)) {
+        const { files, license } = readTar(abs, opts.maxArchiveBytes ?? DEFAULT_MAX_ARCHIVE_BYTES);
+        const digest = treeDigest(files);
+        return { identity: abs, kind: 'archive', license, pin: digest, digest, tier: 'read', files };
+    }
+    throw unsupported(arg, 'an unsupported source kind');
+}

package/src/scripts/step_receipt.ts

@@ -0,0 +1,100 @@
+#!/usr/bin/env tsx
+/**
+ * The receipt a roadmap step carries: its change class and what that class's
+ * row in the depth table would skip, and whether the step runs at that lower depth.
+ *
+ * The class is `classify_change_risk` over the step's paths — deterministic,
+ * unknown resolves upward — and `--raise` can only move it up, so an agent can
+ * ask for more ceremony and never for less. While the table's `mode` is
+ * `shadow`, the receipt is a measurement: every ceremony still runs at full
+ * depth, and `would-skip` is what a lowered depth would have dropped, so a
+ * finding those ceremonies produce on an R0/R1 step is a would-have-escape.
+ * Once the table is `active`, the receipt reads `active` only inside the flip
+ * scope (`_lib/depth_flip.ts`) and only for a class its audit samples have not
+ * rolled back; every other step still reads `shadow` and runs at full depth.
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/step_receipt --range <base>..HEAD [--raise R0|R1|R2|R3]
+ *   ./scripts-run src/scripts/step_receipt --paths a,b,c [--raise …]
+ *
+ * Prints one line, the marker the step's Done note carries. Exit 2 on a usage
+ * error, otherwise 0.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { changedPaths, classifyPaths, higher, type RiskClass } from './classify_change_risk.js';
+import { effectiveMode, isStructurallySafe, rolledBackClasses, type AuditSample, type FlipBlock } from './_lib/depth_flip.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+export const DEPTH_TABLE_REL = 'src/config/step-depth-table.json';
+export const AUDIT_SAMPLES_REL = 'src/config/depth-audit-samples.json';
+
+type Ceremony = 'review' | 'council' | 'evidence' | 'retro' | 'revalidation';
+
+export interface DepthTable {
+    mode: 'shadow' | 'active';
+    flip: FlipBlock;
+    full: Record<Ceremony, string>;
+    classes: Record<RiskClass, Record<Ceremony, string>>;
+}
+
+export function loadDepthTable(root = REPO_ROOT): DepthTable {
+    return JSON.parse(fs.readFileSync(path.join(root, DEPTH_TABLE_REL), 'utf8')) as DepthTable;
+}
+
+export function loadAuditSamples(root = REPO_ROOT): AuditSample[] {
+    return (JSON.parse(fs.readFileSync(path.join(root, AUDIT_SAMPLES_REL), 'utf8')) as { samples: AuditSample[] }).samples;
+}
+
+/** Ceremonies whose row for `cls` is anything other than full depth, sorted. */
+export function wouldSkip(cls: RiskClass, table: DepthTable): string[] {
+    const row = table.classes[cls];
+    return (Object.keys(table.full) as Ceremony[]).filter((c) => !row[c].startsWith('full')).sort();
+}
+
+export function receiptFor(
+    paths: readonly string[],
+    raise: RiskClass | null,
+    table: DepthTable,
+    samples: readonly AuditSample[] = [],
+): { cls: RiskClass; mode: 'shadow' | 'active'; line: string } {
+    const computed = classifyPaths(paths);
+    const cls = raise === null ? computed.cls : higher(computed.cls, raise);
+    const bound = cls === computed.cls ? computed.reason : `raised to ${cls} from ${computed.cls}`;
+    const skip = wouldSkip(cls, table);
+    const mode = effectiveMode(table.mode, cls, paths, table.flip, rolledBackClasses(samples, table.flip.requires));
+    const scope = isStructurallySafe(paths) ? ' · scope=safe' : '';
+    const line = `<!-- receipt: class=${cls} · ${mode}${scope} · would-skip=${skip.length === 0 ? 'none' : skip.join(',')} · bound=${bound} -->`;
+    return { cls, mode, line };
+}
+
+export function main(argv: readonly string[]): number {
+    const value = (flag: string): string | undefined => {
+        const i = argv.indexOf(flag);
+        return i >= 0 ? argv[i + 1] : undefined;
+    };
+    const raiseArg = value('--raise');
+    if (raiseArg !== undefined && !['R0', 'R1', 'R2', 'R3'].includes(raiseArg)) {
+        process.stderr.write('step_receipt: --raise takes R0, R1, R2 or R3\n');
+        return 2;
+    }
+    const pathsArg = value('--paths');
+    const range = value('--range');
+    if ((pathsArg === undefined) === (range === undefined)) {
+        process.stderr.write('usage: step_receipt (--range <base>..HEAD | --paths a,b,c) [--raise R0|R1|R2|R3]\n');
+        return 2;
+    }
+    const paths =
+        pathsArg !== undefined
+            ? pathsArg.split(',').map((s) => s.trim()).filter((s) => s !== '')
+            : changedPaths(range as string, REPO_ROOT);
+    process.stdout.write(`${receiptFor(paths, (raiseArg as RiskClass | undefined) ?? null, loadDepthTable(), loadAuditSamples()).line}\n`);
+    return 0;
+}
+
+if (process.argv[1] !== undefined && path.resolve(process.argv[1]) === path.resolve(_HERE)) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/sync_pr_branch.ts

@@ -133,6 +133,10 @@ const GENERATED = [
     // measured for road-to-merge-hotspot-drawdown. Regenerate; never merge.
     'agents/roadmaps/archive/INDEX.md',
     'agents/roadmaps/archive/index.json',
+    // Written by `generate_owned_digest.ts` from every active, parked and stub
+    // roadmap; two branches that land or park roadmaps both change it.
+    // Regenerate; never merge.
+    'agents/roadmaps-owned.md',
     // ── Added 2026-08-25 (road-to-merge-surface-zero 1.1). Each carries its
     // write site, because this list tells a human to DISCARD one side, and an
     // entry added on a conflict count alone would tell them to discard hand

package/src/scripts/test_council_qualification.ts

@@ -87,7 +87,7 @@ export function main(): number {
     // The roster is only constructible while the key var is set; restore
     // whatever was there so the probe leaves no environment residue.
     const prior = process.env[KEY_VAR];
-    process.env[KEY_VAR] = 'sk-probe-key';
+    process.env[KEY_VAR] = 'sk-probe-key'; // not-a-credential-pattern: inert fake key value
     try {
         // ── Criterion 1: a deliberately broken seat yields `unavailable`. ──
         const broken = qualifyMember({

package/src/scripts/trigger_eval_grandfather.json

@@ -1,68 +1,49 @@
 {
-  "_note": "Shrink-only grandfather allowlist for check_trigger_eval_presence (road-to-composition-ratchet). Skills listed here predate the trigger-eval presence gate and may lack evals/triggers.json. Entries may ONLY be removed (when the skill gains a triggers.json or is deleted) — never added. Frozen 2026-07-08 at 221 of 264 skills.",
-  "_no_obligation_note": "Entries in `_no_obligation` are on the `skills` allowlist for a DIFFERENT reason from the rest. The list above records skills that predate the gate and owe a triggers.json; these owe none, because their description says explicit-request-only and they publish no auto-trigger keywords — there is no trigger to evaluate. Listing them without this distinction reads as a waived obligation when the obligation is absent. Read by humans only: check_trigger_eval_presence parses `skills` and ignores every other key, so this changes no verdict. Removing one from `skills` WOULD change a verdict — the gate would then demand a triggers.json for a skill that has nothing to trigger on.",
+  "_note": "Shrink-only grandfather allowlist for check_trigger_eval_presence (road-to-composition-ratchet). Skills listed here predate the trigger-eval presence gate and may lack evals/triggers.json. Entries may ONLY be removed (when the skill gains a triggers.json or is deleted) \u2014 never added. Frozen 2026-07-08 at 221 of 264 skills.",
+  "_no_obligation_note": "Entries in `_no_obligation` are on the `skills` allowlist for a DIFFERENT reason from the rest. The list above records skills that predate the gate and owe a triggers.json; these owe none, because their description says explicit-request-only and they publish no auto-trigger keywords \u2014 there is no trigger to evaluate. Listing them without this distinction reads as a waived obligation when the obligation is absent. Read by humans only: check_trigger_eval_presence parses `skills` and ignores every other key, so this changes no verdict. Removing one from `skills` WOULD change a verdict \u2014 the gate would then demand a triggers.json for a skill that has nothing to trigger on.",
   "_no_obligation": [
     "sequential-thinking"
   ],
   "skills": [
     "activation-design",
     "agent-docs-writing",
-    "agents-md-thin-root",
-    "api-endpoint",
     "artisan-commands",
     "async-python-patterns",
     "aws-infrastructure",
-    "blade-ui",
     "build-buy-partner",
     "character-consistency",
     "check-refs",
     "churn-prevention",
     "command-writing",
     "comp-banding",
-    "competitive-positioning",
-    "composer-packages",
-    "condense-memory",
-    "content-funnel-design",
-    "context-authoring",
     "context-document",
     "contracts-cognition",
     "copilot-agents-optimization",
     "copilot-config",
-    "dashboard-design",
     "data-handling-judgment",
     "dcf-modeling",
     "deal-qualification-meddic",
     "decision-review",
-    "deep-reading-analyst",
     "defense-in-depth",
-    "dependency-upgrade",
-    "description-assist",
-    "design-review",
     "devcontainer",
     "developer-like-execution",
     "discovery-interview",
-    "docker",
     "editorial-calendar",
     "emit-tickets",
     "error-handling-patterns",
     "expansion-playbook",
     "file-editor",
-    "finishing-a-development-branch",
-    "flux",
     "forecast-accuracy",
     "forecasting",
-    "form-handler",
     "fundraising-narrative",
     "funnel-analysis",
     "github-ci",
     "grafana",
-    "gtm-launch",
     "guideline-writing",
     "hiring-loop-design",
     "jobs-events",
     "judge-bug-hunter",
     "judge-code-quality",
-    "judge-security-auditor",
     "judge-test-coverage",
     "laravel",
     "laravel-api-endpoint",
@@ -78,22 +59,16 @@
     "laravel-scheduling",
     "laravel-validation",
     "laravel-websocket",
-    "launch-readiness",
-    "learning-to-rule-or-skill",
     "lint-skills",
-    "livewire",
     "livewire-architect",
-    "market-entry-analysis",
     "mcp",
     "mcp-builder",
     "md-language-check",
     "memory-consolidation",
-    "messaging-architecture",
     "migration-architect",
     "mobile-e2e-strategy",
     "module-detect-on-the-fly",
     "module-management",
-    "motion-choreographer",
     "multi-tenancy",
     "nextjs-patterns",
     "okr-tree-modeling",
@@ -113,55 +88,37 @@
     "pipeline-strategy",
     "pixar-storyteller",
     "playwright-architect",
-    "playwright-testing",
-    "positioning-strategy",
     "premortem",
     "privacy-review",
-    "project-analysis-core",
-    "project-analysis-hypothesis-driven",
     "project-analysis-laravel",
     "project-analysis-nextjs",
     "project-analysis-node-express",
     "project-analysis-react",
     "project-analysis-symfony",
     "project-analysis-zend-laminas",
-    "project-analyzer",
     "project-docs",
     "prompt-optimizer",
-    "react-native-setup",
-    "react-shadcn-ui",
     "readme-reviewer",
     "readme-writing",
     "readme-writing-package",
-    "receiving-code-review",
     "recursive-verification",
     "refine-prompt",
-    "release-comms",
-    "repomix-packer",
-    "requesting-code-review",
     "retention-loops",
     "rice-prioritization",
     "risk-officer",
-    "roadmap-management",
     "root-cause-frameworks",
-    "rtk-output-filtering",
     "rule-refactor",
-    "rule-writing",
     "runway-cognition",
     "scenario-modeling",
     "scene-expander",
     "script-writing",
     "secrets-management",
-    "security",
     "sentry-integration",
     "sequential-thinking",
     "skill-management",
-    "skill-reviewer",
     "song-to-script",
-    "sql-writing",
     "stakeholder-tradeoff",
     "standards-from-config",
-    "subagent-orchestration",
     "symfony-workflow",
     "systematic-debugging",
     "tech-debt-tracker",
@@ -172,13 +129,10 @@
     "token-optimizer",
     "traefik",
     "unit-economics-modeling",
-    "universal-project-analysis",
-    "upstream-contribute",
     "validate-feature-fit",
     "verify-completion-evidence",
     "video-director",
     "vision-articulation",
-    "voc-extract",
-    "voice-and-tone-design"
+    "voc-extract"
   ]
 }

package/src/scripts/trigger_eval_rotation.ts

@@ -82,7 +82,24 @@ export const QUERIES_PER_SUITE = 10;
  * **Set from measurement, and the arithmetic is the point.** At 102 suites a
  * full pass costs ~1020 queries; spread over a 12-week cycle that is ~85 a week
  * on average and 140 in the busiest week (hash spread, measured 2026-09-30).
- * 160 leaves headroom for that unevenness and reds at roughly 117 suites.
+ * 160 left headroom for that unevenness. The estimate that it "reds at roughly
+ * 117 suites" assumed an even spread the hash did not produce — the tree passed
+ * at 140 — and is kept here as the 2026-09-30 reasoning, not as a live figure.
+ *
+ * **Raised to 200 by the repository owner on 2026-10-14** (the decision is
+ * recorded in commit 1696ac45b). Own analysis, re-derivable at any commit
+ * with `rotation_plan(list_trigger_suites())`. Measured that day:
+ * 140 suites on `main`, ~117 queries a week on average, and a peak of exactly
+ * 160 because FNV-1a puts 16 suites in each of slots 3 and 10. The `security`
+ * corpus hashes into slot 3 and made it 17, a peak of 170. The peak is set by
+ * the busiest slot, not by the suite count, so growth is free until a suite
+ * lands in a full slot. 200 was chosen over 170 because 170 would bring the same
+ * decision back with the next suite in slot 3 or 10. At 200 every slot holds 20
+ * suites: slot 3 (17) has room for 3 more, slot 10 (16) for 4. Each suite added
+ * to the busiest slot costs `QUERIES_PER_SUITE` on the peak; anywhere else it
+ * costs nothing on the peak. Rejected that day: rebalancing the slots (gives up
+ * "a new suite moves no other") and decoupling coverage from the paid replay
+ * (the largest change). Reopen when a slot reaches 20 suites.
  *
  * The number nobody can lower by tuning: a 90-day window over N suites costs
  * `N × QUERIES_PER_SUITE` every 90 days, whatever the schedule. The scheme this
@@ -90,7 +107,7 @@ export const QUERIES_PER_SUITE = 10;
  * over 102 suites is a 21-week cycle, which misses the 90-day window by 57 days.
  * Cheapness was the symptom of the defect, not a property worth preserving.
  */
-export const MAX_WEEKLY_QUERIES = 160;
+export const MAX_WEEKLY_QUERIES = 200;
 
 /**
  * FNV-1a over the suite id. Any stable hash works; what matters is that a
@@ -292,6 +309,8 @@ export interface RotationSuiteOutcome {
     minPrecision: number;
     minRecall: number;
     passed: boolean;
+    /** False when a live suite's router returned no usage on any call: no answer was scored. */
+    answered: boolean;
     resultPath: string;
 }
 
@@ -339,13 +358,15 @@ export async function run_rotation(opts: RotationOptions = {}): Promise<Rotation
             result.metrics.recall >= floor.minRecall;
         const resultPath = path.join(outDir, `${skillName}.json`);
         write_result(result, resultPath);
+        const answered = dryRun || result.input_tokens + result.output_tokens > 0;
         outcomes.push({
             skill: skillName,
             precision: result.metrics.precision,
             recall: result.metrics.recall,
             minPrecision: floor.minPrecision,
             minRecall: floor.minRecall,
-            passed,
+            passed: passed && answered,
+            answered,
             resultPath,
         });
     }
@@ -417,6 +438,13 @@ export async function main(argv?: string[]): Promise<number> {
     );
     for (const o of summary.outcomes) {
         const mark = o.passed ? '✅' : '❌';
+        if (!o.answered) {
+            process.stdout.write(
+                `  ${mark} ${o.skill} · NO ANSWER — the router returned no usage on any call ` +
+                    `(a transport or account error, not a routing score) · ${o.resultPath}\n`,
+            );
+            continue;
+        }
         process.stdout.write(
             `  ${mark} ${o.skill} · precision ${o.precision} (floor ${o.minPrecision}) · ` +
                 `recall ${o.recall} (floor ${o.minRecall}) · ${o.resultPath}\n`,