@event4u/agent-config 16.1.0 → 16.3.0

package/src/scripts/lint_workflow_security.ts

@@ -35,12 +35,14 @@
  */
 
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import YAML from 'yaml';
 
-import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+import { runGateCli, runSelfTest } from './_lib/gate_self_test.js';
+import { DeadScopeError, reportScanned } from './_lib/scan_scope.js';
 import { py_json_dumps_indent2 } from './_lib/security_lint.js';
 
 const _HERE = fileURLToPath(import.meta.url);
@@ -48,8 +50,16 @@ const _HERE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 // Mutable bindings so tests can sandbox the scan target (mirrors the pytest
 // monkeypatch.setattr seam used by sibling lint twins).
-let WORKFLOWS_DIR = path.join(REPO_ROOT, '.github', 'workflows');
-let ALLOWLIST_PATH = path.join(path.dirname(_HERE), 'lint_workflow_security_allowlist.json');
+//
+// `--self-test` needs the same sandbox from a CHILD process, which cannot reach
+// the in-process seam, so the two paths are also readable from the environment.
+// Deliberately env and not argv: the CLI surface is pinned (argparse flags,
+// byte-identical usage lines, unknown arg → exit 2), and a scan root is not
+// something a caller should be able to redirect by typing a flag.
+let WORKFLOWS_DIR = process.env['LINT_WORKFLOW_SECURITY_DIR'] ?? path.join(REPO_ROOT, '.github', 'workflows');
+let ALLOWLIST_PATH =
+    process.env['LINT_WORKFLOW_SECURITY_ALLOWLIST'] ??
+    path.join(path.dirname(_HERE), 'lint_workflow_security_allowlist.json');
 const ALLOWLIST_CAP = 20;
 
 function _setWorkflowsDirForTest(p: string): void {
@@ -577,8 +587,147 @@ function _usageError(arg: string): string {
     );
 }
 
+/**
+ * Prove, on demand, that the gate's rejections still fire.
+ *
+ * The CI invocation is warn-only, so the exit code `runSelfTest` reads cannot be
+ * moved by a finding there. The cases below therefore drive the two exits the
+ * gate really has — 2 for a dead scan scope or an over-cap allowlist, 1 for a
+ * HIGH under `--strict` — and pin the warn-only tier itself from the other side:
+ * a MEDIUM under `--strict` must still PASS, which is the direction a future
+ * re-tiering would silently break.
+ */
+function selfTest(): number {
+    const plant = (name: string, files: Record<string, string>): string => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), `lws-selftest-${name}-`));
+        for (const [rel, body] of Object.entries(files)) {
+            fs.writeFileSync(path.join(dir, rel), body, 'utf-8');
+        }
+        return dir;
+    };
+    const allowlistFile = (entries: unknown[]): string => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lws-selftest-al-'));
+        const p = path.join(dir, 'allowlist.json');
+        fs.writeFileSync(p, JSON.stringify({ findings: entries }), 'utf-8');
+        return p;
+    };
+    const run = (wfDir: string, args: readonly string[], allowlist?: string): number => {
+        const prevDir = process.env['LINT_WORKFLOW_SECURITY_DIR'];
+        const prevAl = process.env['LINT_WORKFLOW_SECURITY_ALLOWLIST'];
+        process.env['LINT_WORKFLOW_SECURITY_DIR'] = wfDir;
+        if (allowlist !== undefined) {
+            process.env['LINT_WORKFLOW_SECURITY_ALLOWLIST'] = allowlist;
+        }
+        try {
+            return runGateCli(
+                REPO_ROOT,
+                path.join('src', 'scripts', 'lint_workflow_security.ts'),
+                args,
+                REPO_ROOT,
+            );
+        } finally {
+            if (prevDir === undefined) {
+                delete process.env['LINT_WORKFLOW_SECURITY_DIR'];
+            } else {
+                process.env['LINT_WORKFLOW_SECURITY_DIR'] = prevDir;
+            }
+            if (prevAl === undefined) {
+                delete process.env['LINT_WORKFLOW_SECURITY_ALLOWLIST'];
+            } else {
+                process.env['LINT_WORKFLOW_SECURITY_ALLOWLIST'] = prevAl;
+            }
+        }
+    };
+
+    const HIGH_WF = [
+        'on:',
+        '  pull_request_target:',
+        'jobs:',
+        '  build:',
+        '    steps:',
+        '      - uses: actions/checkout@0000000000000000000000000000000000000000',
+        '        with:',
+        '          persist-credentials: false',
+        '          ref: ${{ github.event.pull_request.head.sha }}',
+        '',
+    ].join('\n');
+    // Unpinned third-party action — MEDIUM, and MEDIUM alone.
+    const MEDIUM_WF = [
+        'on:',
+        '  push:',
+        'jobs:',
+        '  build:',
+        '    steps:',
+        '      - uses: somevendor/action@v1',
+        '',
+    ].join('\n');
+    const CLEAN_WF = [
+        'on:',
+        '  push:',
+        'jobs:',
+        '  build:',
+        '    steps:',
+        '      - uses: actions/checkout@0000000000000000000000000000000000000000',
+        '        with:',
+        '          persist-credentials: false',
+        '      - run: npm ci --ignore-scripts',
+        '',
+    ].join('\n');
+
+    return runSelfTest({
+        gate: 'lint_workflow_security',
+        minCases: 5,
+        minRejectCases: 3,
+        cases: [
+            {
+                name: 'an empty workflows directory is refused, not certified "0 HIGH, 0 MEDIUM"',
+                expect: 'reject',
+                run: () => run(plant('empty', {}), []),
+            },
+            {
+                name: 'a pull_request_target checkout of the untrusted ref fails under --strict',
+                expect: 'reject',
+                run: () => run(plant('high', { 'bad.yml': HIGH_WF }), ['--strict']),
+            },
+            {
+                name: 'an over-cap allowlist fails rather than suppressing silently',
+                expect: 'reject',
+                run: () =>
+                    run(
+                        plant('cap', { 'ok.yml': CLEAN_WF }),
+                        [],
+                        allowlistFile(
+                            Array.from({ length: ALLOWLIST_CAP + 1 }, (_, n) => ({
+                                workflow: `w${String(n)}.yml`,
+                                rule: 'unpinned-action',
+                            })),
+                        ),
+                    ),
+            },
+            {
+                name: 'a MEDIUM under --strict still PASSES — the tier split is real, not decorative',
+                expect: 'accept',
+                run: () => run(plant('medium', { 'med.yml': MEDIUM_WF }), ['--strict']),
+            },
+            {
+                name: 'a clean workflow passes under --strict',
+                expect: 'accept',
+                run: () => run(plant('clean', { 'ok.yml': CLEAN_WF }), ['--strict']),
+            },
+        ],
+    });
+}
+
 export function main(argv?: string[]): number {
-    const parsed = _parseArgs(argv ?? process.argv.slice(2));
+    const rawArgv = argv ?? process.argv.slice(2);
+    if (rawArgv.includes('--self-test')) {
+        if (process.env['GATE_SELF_TEST_CHILD'] === '1') {
+            process.stderr.write('lint_workflow_security: --self-test does not recurse\n');
+            return 2;
+        }
+        return selfTest();
+    }
+    const parsed = _parseArgs(rawArgv);
     if (parsed.exitCode !== undefined) {
         return parsed.exitCode;
     }
@@ -600,7 +749,14 @@ export function main(argv?: string[]): number {
     const yml = _sortedGlob('.yml');
     const yaml = _sortedGlob('.yaml');
     try {
-        assertScanned({
+        // `reportScanned`, not `assertScanned`: the gate now carries a floor in
+        // src/config/gate-coverage.yml, and the guard there reads the
+        // machine-readable `scanned:` line. Asserting without publishing leaves
+        // the gate invisible to the coverage guard — the half-adoption
+        // `_lib/scan_scope.reportScanned` was written to close. The line goes to
+        // stdout unconditionally, `--quiet` included, because CI passes
+        // `--quiet` and a count only visible without it is not a count.
+        reportScanned({
             gate: 'lint_workflow_security',
             scanned: yml.length + yaml.length,
             units: 'workflow file(s)',

package/src/scripts/mcp_server/consumer_tool_catalog.json

@@ -283,6 +283,59 @@
         "readOnlyHint": false
       }
     },
+    {
+      "name": "graph_node",
+      "description": "One symbol in full: where it is declared, what reaches it, what it reaches, and how connected it is. Resolves EXACTLY (node id, then label) and refuses anything it cannot — it never scores free text, so an answer is always about the node you named.",
+      "side_effect": "ro",
+      "implemented_on": [
+        "stdio"
+      ],
+      "input_schema": {
+        "type": "object",
+        "required": [
+          "id"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Node id `<relpath>#<sym>` or an exact label."
+          },
+          "direction": {
+            "type": "string",
+            "enum": [
+              "in",
+              "out",
+              "both"
+            ],
+            "default": "both",
+            "description": "Which edges to walk. `in` = who reaches it, `out` = what it reaches."
+          },
+          "depth": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 3,
+            "default": 1,
+            "description": "Hop limit."
+          },
+          "relation": {
+            "type": "string",
+            "enum": [
+              "calls",
+              "imports",
+              "uses",
+              "inherits",
+              "member",
+              "tests"
+            ],
+            "description": "Restrict to one relation. Omit for all of them."
+          }
+        },
+        "additionalProperties": false
+      },
+      "annotations": {
+        "readOnlyHint": true
+      }
+    },
     {
       "name": "graph_path",
       "description": "The shortest relation chain between two symbols, direction preserved. Answers \"how does A reach B\" without reading the files between. `(no path found)` when unconnected is an answer.",

package/src/scripts/mcp_server/graph_tools.ts

@@ -1,7 +1,13 @@
 /**
- * The five code-graph MCP tools (`road-to-a-graph-that-is-shipped` 4.1).
+ * The code-graph MCP tools (`road-to-a-graph-that-is-shipped` 4.1).
+ *
+ * `graph_impact`, `graph_tests_for`, `graph_dead`, `graph_query`, `graph_path`
+ * — and `graph_node`, added by `road-to-a-graph-that-feeds-the-gate` 3.1. The
+ * first five all answer about a NEIGHBOURHOOD or a SET; none answered "where
+ * does this live, who reaches it, what does it reach, how connected is it",
+ * which is the question an agent asks first and had to assemble from two calls
+ * and a file read.
  *
- * `graph_impact`, `graph_tests_for`, `graph_dead`, `graph_query`, `graph_path`.
  * They are the agent-facing half of Phase 3: the verbs exist on the CLI and an
  * agent that has to shell out to reach them will not, so the engine's answers
  * were unreachable from the surface the consumer actually talks to. Risk-Register
@@ -39,7 +45,15 @@ import { changedFiles } from '../code_graph/cli.js';
 import { detectSources, graphState, NATIVE_CACHE_REL, pickSource } from '../code_graph/detect.js';
 import { resolvePath } from './path_util.js';
 import { isTestFile } from '../code_graph/build.js';
-import { loadGraph, type LoadedGraph, path as graphPathVerb, query as graphQueryVerb } from '../code_graph/query.js';
+import {
+    loadGraph,
+    type LoadedGraph,
+    node as graphNodeVerb,
+    type NodeOptions,
+    path as graphPathVerb,
+    query as graphQueryVerb,
+} from '../code_graph/query.js';
+import type { Relation } from '../code_graph/types.js';
 import {
     dead,
     entryPointsFromFile,
@@ -97,6 +111,16 @@ function str(args: Record<string, unknown>, key: string): string {
     return typeof v === 'string' ? v.trim() : '';
 }
 
+/**
+ * The closed relation vocabulary, as a schema enum.
+ *
+ * Spelled out rather than derived from the `Relation` union, which erases at
+ * compile time — and pinned by a test against that union so the two cannot
+ * drift. An enum that silently lost a value would turn a legal filter into a
+ * rejected argument.
+ */
+const RELATIONS = ['calls', 'imports', 'uses', 'inherits', 'member', 'tests'] as const;
+
 function num(args: Record<string, unknown>, key: string, dflt: number): number {
     const v = args[key];
     return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : dflt;
@@ -263,6 +287,51 @@ export const GRAPH_TOOLS: Record<string, BuiltinTool> = {
         },
     },
 
+    graph_node: {
+        name: 'graph_node',
+        side_effect: 'ro',
+        description:
+            'One symbol in full: where it is declared, what reaches it, what it ' +
+            'reaches, and how connected it is. Resolves EXACTLY (node id, then ' +
+            'label) and refuses anything it cannot — it never scores free text, ' +
+            'so an answer is always about the node you named.',
+        input_schema: {
+            type: 'object',
+            required: ['id'],
+            properties: {
+                id: { type: 'string', description: 'Node id `<relpath>#<sym>` or an exact label.' },
+                direction: {
+                    type: 'string',
+                    enum: ['in', 'out', 'both'],
+                    default: 'both',
+                    description: 'Which edges to walk. `in` = who reaches it, `out` = what it reaches.',
+                },
+                depth: { type: 'integer', minimum: 1, maximum: 3, default: 1, description: 'Hop limit.' },
+                relation: {
+                    type: 'string',
+                    enum: RELATIONS,
+                    description: 'Restrict to one relation. Omit for all of them.',
+                },
+            },
+            additionalProperties: false,
+        },
+        handler: async (args, root) => {
+            const id = str(args, 'id');
+            if (id === '') return { status: 'error', error: 'id must be a non-empty string' };
+            const staleness = graphState(root);
+            const opts: NodeOptions = {};
+            const dir = str(args, 'direction');
+            if (dir === 'in' || dir === 'out' || dir === 'both') opts.direction = dir;
+            // `num` clamps at >0 only; the 1-3 band is the verb's, so an
+            // out-of-band value is clamped there rather than rejected here —
+            // two places enforcing one band is how they drift apart.
+            opts.depth = num(args, 'depth', 1);
+            const rel = str(args, 'relation');
+            if ((RELATIONS as readonly string[]).includes(rel)) opts.relation = rel as Relation;
+            return withGraph(root, (g) => ({ staleness, ...graphNodeVerb(g, id, opts) }));
+        },
+    },
+
     graph_path: {
         name: 'graph_path',
         side_effect: 'ro',

package/src/scripts/mcp_server/prompts.ts

@@ -69,6 +69,22 @@ export interface SkillPrompt {
     readonly kind: PromptKind;
     readonly recommended_for_user_types: readonly string[];
     readonly user_type_match: UserTypeMatch;
+    /**
+     * Declared parameters, from the frontmatter `inputs:` block.
+     *
+     * Empty for every artifact that declares none, which is the whole corpus
+     * today — so `arguments: []` on the wire stays the behaviour for an
+     * undeclared prompt rather than becoming a special case
+     * (road-to-an-invocation-contract-that-reaches-the-wire 3.2).
+     */
+    readonly inputs: readonly PromptInput[];
+}
+
+/** One declared parameter, reduced to what the MCP `arguments` shape carries. */
+export interface PromptInput {
+    readonly name: string;
+    readonly description: string;
+    readonly required: boolean;
 }
 
 /** Walk up from this file to the repo root (parent of `scripts/`). */
@@ -92,6 +108,124 @@ export function _project_root(): string {
  * Avoids a YAML dependency for Phase 1; the frontmatter shape is
  * enforced by `task lint-skills` upstream.
  */
+/** The raw frontmatter block of a document, or `''` when it has none. */
+export function _frontmatter_text(text: string): string {
+    if (!text.startsWith('---\n')) return '';
+    const parts = _splitMax(text, '---\n', 2);
+    return parts.length < 3 ? '' : (parts[1] as string);
+}
+
+/**
+ * Parse the frontmatter `inputs:` block out of raw frontmatter text.
+ *
+ * WHY THIS EXISTS RATHER THAN A YAML CALL. `_strip_frontmatter` is a flat
+ * `key: value` line scanner and cannot represent a nested list — `inputs:`
+ * would land as an empty string and its `- name: x` lines as stray keys. The
+ * MCP server is deliberately stdlib-only and is bundled for the wire, so
+ * pulling a YAML parser in to read one optional block would pay a dependency
+ * on every install for a block almost nothing declares yet.
+ *
+ * IT READS ONE SHAPE AND REFUSES THE REST. Accepted:
+ *
+ *     inputs:
+ *       - name: target
+ *         type: string
+ *         required: true
+ *         description: What to act on.
+ *
+ * Refused, by yielding NOTHING for the whole block: the flow form
+ * (`inputs: [{name: a}]`), a block scalar (`description: >`), and any nested
+ * mapping under an item key. Refusing is not silent — `check_inputs_parity`
+ * compares this reader against a real YAML parse for every declaring artifact
+ * and FAILS the build on any difference, so an unsupported form is a red gate
+ * with a named remedy rather than a wrong argument on the wire.
+ *
+ * That gate is the answer to the defect an independent review found here: the
+ * key scan used to run at any depth, so a `default:` MAPPING whose first child
+ * was `name:` overwrote the parameter's own name and the server offered a host
+ * an argument that did not exist. The header promised "no guessed input" while
+ * the code guessed. Depth is now tracked, and where this reader cannot be sure
+ * it declines and the parity gate makes the decline visible.
+ */
+export function _parse_inputs(fm: string): PromptInput[] {
+    const lines = fm.split('\n');
+    let i = lines.findIndex((l) => /^inputs:/.test(l));
+    if (i === -1) return [];
+    // The flow form carries its payload on the `inputs:` line itself. This
+    // reader does not parse it; the parity gate turns that into a failure.
+    if (!/^inputs:\s*$/.test(lines[i] as string)) return [];
+
+    const out: PromptInput[] = [];
+    let current: { name?: string; description?: string; required?: boolean } | null = null;
+    /** Indent of the key lines belonging to the item being read. */
+    let keyIndent: number | null = null;
+    let refused = false;
+
+    const flush = (): void => {
+        if (current?.name !== undefined) {
+            out.push({
+                name: current.name,
+                description: current.description ?? '',
+                required: current.required === true,
+            });
+        }
+        current = null;
+    };
+
+    const clean = (raw: string): string => {
+        const v = raw.trim();
+        // An unquoted trailing comment is not part of the value — the same strip
+        // `_strip_frontmatter` applies, kept consistent deliberately.
+        const hashed = /^(?!["'])([^#]*?)\s+#.*$/.exec(v);
+        return _stripQuotes((hashed === null ? v : (hashed[1] ?? '')).trim());
+    };
+
+    for (i += 1; i < lines.length && !refused; i += 1) {
+        const line = lines[i] as string;
+        if (line.trim() === '') continue;
+        // A comment at any column is not block content and does not end the block.
+        if (/^\s*#/.test(line)) continue;
+        // A non-indented line ends the block.
+        if (!/^\s/.test(line)) break;
+
+        const indent = (/^(\s*)/.exec(line) as RegExpExecArray)[1]!.replace(/\t/g, '    ').length;
+
+        const item = /^\s*-\s+([A-Za-z_]\w*):\s*(.*)$/.exec(line);
+        if (item !== null) {
+            flush();
+            current = {};
+            keyIndent = line.indexOf('-') + 2;
+            if (item[1] === 'name') current.name = clean(item[2] ?? '');
+            continue;
+        }
+
+        const kv = /^\s+([A-Za-z_]\w*):\s*(.*)$/.exec(line);
+        if (kv === null || current === null || keyIndent === null) continue;
+        // Deeper than the item's own keys: a nested mapping or sequence this
+        // reader does not model. Decline the whole block rather than absorb it.
+        if (indent > keyIndent) {
+            refused = true;
+            break;
+        }
+        const key = kv[1] as string;
+        const rawValue = (kv[2] ?? '').trim();
+        // A block scalar or an empty value means the real content is on the
+        // following lines, which this reader does not join.
+        if (rawValue === '' || rawValue === '>' || rawValue === '|') {
+            refused = true;
+            break;
+        }
+        const value = clean(rawValue);
+        if (key === 'name') current.name = value;
+        else if (key === 'description') current.description = value;
+        else if (key === 'required') current.required = value.toLowerCase() === 'true';
+    }
+
+    if (refused) return [];
+    flush();
+    return out;
+}
+
 export function _strip_frontmatter(text: string): [Record<string, string>, string] {
     if (!text.startsWith('---\n')) {
         return [{}, text];
@@ -365,6 +499,7 @@ function _load_file(p: string, kind: PromptKind, fallback_name: string): SkillPr
         kind,
         recommended_for_user_types: _parse_inline_array(meta.recommended_for_user_types ?? ''),
         user_type_match: '',
+        inputs: _parse_inputs(_frontmatter_text(text)),
     };
 }
 
@@ -548,7 +683,13 @@ export function to_mcp_prompt_meta(prompt: SkillPrompt): Record<string, unknown>
         name: wire,
         title: prompt.name,
         description: prompt.description,
-        arguments: [],
+        // Derived from the declaration, never invented. An artifact that
+        // declares nothing still serves `[]` — see `_parse_inputs`.
+        arguments: prompt.inputs.map((i) => ({
+            name: i.name,
+            description: i.description,
+            required: i.required,
+        })),
         _meta: meta,
     };
 }

package/src/scripts/measure_routing_signal.ts

@@ -117,6 +117,59 @@ export function mcnemarExactP(gained: number, lost: number): number {
 
 const pp = (hits: number, total: number): number => (total === 0 ? 0 : (hits / total) * 100);
 
+/** The inputs the pre-registered verdict function reads, and nothing else. */
+export interface VerdictInputs {
+    readonly deltaRecall: number;
+    readonly deltaFalse: number;
+    readonly p: number;
+    readonly gained: number;
+    readonly lost: number;
+}
+
+/**
+ * The pre-registered verdict function, in its pre-registered ORDER.
+ *
+ * Extracted from `measure` on 2026-10-04 so the order can be tested against
+ * chosen inputs rather than against whatever the live corpus happens to
+ * produce. The behaviour is unchanged, deliberately: this is a move, not a
+ * rewrite, and the bars it reads are the same module-level constants.
+ *
+ * WHY IT HAD TO MOVE. The order is load-bearing — power floor, then guard,
+ * then primary — and the only thing pinning it was a test asserting that the
+ * LIVE run happened to be a case that discriminates: primary met AND guard
+ * breached, so a function checking the primary first would wrongly say
+ * `signal`. That witness is a property of the corpus, not of the code, and the
+ * corpus grows whenever a skill gains a trigger file. On 2026-10-04 one such
+ * growth moved delta-recall from 5.128 to 4.608 and the witness was gone,
+ * leaving the ordering guarded by nothing. Tested here against chosen inputs,
+ * the discriminating case is always available and no future corpus growth can
+ * take it away.
+ */
+export function verdictOf(i: VerdictInputs): { verdict: Verdict; reason: string } {
+    if (i.gained + i.lost < POWER_FLOOR_DISCORDANT) {
+        return {
+            verdict: 'underpowered',
+            reason: `${i.gained + i.lost} discordant positive pairs < power floor ${POWER_FLOOR_DISCORDANT}`,
+        };
+    }
+    if (i.deltaFalse > FALSE_ACTIVATION_GUARD_PP) {
+        return {
+            verdict: 'harmful',
+            reason: `false activation +${i.deltaFalse.toFixed(2)} pp breaches the +${FALSE_ACTIVATION_GUARD_PP.toFixed(1)} pp guard`,
+        };
+    }
+    if (i.deltaRecall >= RECALL_GAIN_BAR_PP && i.p < ALPHA) {
+        return {
+            verdict: 'signal',
+            reason: `recall +${i.deltaRecall.toFixed(2)} pp at p=${i.p.toExponential(2)}`,
+        };
+    }
+    return {
+        verdict: 'null',
+        reason: `recall +${i.deltaRecall.toFixed(2)} pp at p=${i.p.toExponential(2)} does not clear +${RECALL_GAIN_BAR_PP.toFixed(1)} pp and p<${ALPHA}`,
+    };
+}
+
 export function measure(repo = REPO, k = K): Measurement {
     const catalogue: CatalogueEntry[] = loadCatalogue(repo);
     const cases: CorpusCase[] = loadTrainCases(repo);
@@ -170,22 +223,7 @@ export function measure(repo = REPO, k = K): Measurement {
         (falsePp['description+body'] as number) - (falsePp['description'] as number);
     const p = mcnemarExactP(gained, lost);
 
-    // The pre-registered verdict function, in its pre-registered order.
-    let verdict: Verdict;
-    let reason: string;
-    if (gained + lost < POWER_FLOOR_DISCORDANT) {
-        verdict = 'underpowered';
-        reason = `${gained + lost} discordant positive pairs < power floor ${POWER_FLOOR_DISCORDANT}`;
-    } else if (deltaFalse > FALSE_ACTIVATION_GUARD_PP) {
-        verdict = 'harmful';
-        reason = `false activation +${deltaFalse.toFixed(2)} pp breaches the +${FALSE_ACTIVATION_GUARD_PP.toFixed(1)} pp guard`;
-    } else if (deltaRecall >= RECALL_GAIN_BAR_PP && p < ALPHA) {
-        verdict = 'signal';
-        reason = `recall +${deltaRecall.toFixed(2)} pp at p=${p.toExponential(2)}`;
-    } else {
-        verdict = 'null';
-        reason = `recall +${deltaRecall.toFixed(2)} pp at p=${p.toExponential(2)} does not clear +${RECALL_GAIN_BAR_PP.toFixed(1)} pp and p<${ALPHA}`;
-    }
+    const { verdict, reason } = verdictOf({ deltaRecall, deltaFalse, p, gained, lost });
 
     return {
         k,