@event4u/agent-config 7.0.1 → 7.1.0

package/src/scripts/bench_ab_v2_run.ts

@@ -67,14 +67,20 @@ type Dict = Record<string, unknown>;
 interface ArmSpec {
     setting_sources: string | null;
     inject: string | null; // None | "rdp" | "placebo"
+    recursive?: boolean; // ADR-106 D₂ arm: depth-bounded attempt→critic→re-attempt loop
 }
 
 // Arm -> (setting_sources, inject) where inject ∈ {None, "rdp", "placebo"}.
+// `package-recursive` (ADR-106's D₂) reuses the real-plugin `package` config but
+// runs the recursion loop instead of a single --print. It only executes when
+// explicitly selected (`--arms package-recursive`); the four default arms are
+// untouched, so existing runs and their golden-parity outputs are unchanged.
 const ARMS: Record<string, ArmSpec> = {
     vanilla: { setting_sources: 'project,local', inject: null },
     package: { setting_sources: null, inject: null },
     'package-rdp': { setting_sources: null, inject: 'rdp' },
     placebo: { setting_sources: 'project,local', inject: 'placebo' },
+    'package-recursive': { setting_sources: null, inject: null, recursive: true },
 };
 
 /**
@@ -165,10 +171,14 @@ interface RunOneOpts {
     timeout: number;
     placebo_chars: number;
     sp_dir: string;
+    max_depth?: number | null; // recursion arm only — hard cap on correction rounds (default 1)
 }
 
 export function run_one(task: Dict, arm: string, opts: RunOneOpts): Dict {
     const spec = ARMS[arm] as ArmSpec;
+    if (spec.recursive) {
+        return run_one_recursive(task, opts);
+    }
     const [clone, fixture] = reset_fixture(task);
     const sp_text = injected_text(spec.inject, opts.placebo_chars);
     let sp_file: string | null = null;
@@ -198,6 +208,123 @@ export function run_one(task: Dict, arm: string, opts: RunOneOpts): Dict {
     };
 }
 
+export interface RecursiveAttempt {
+    run: Dict;
+    score: scoring.ScoreResultV2;
+    output?: string; // pair-capture: changed-file contents at this depth (for human-preference judging)
+}
+
+/**
+ * ADR-106 D₂ arm — depth-bounded recursive self-verification.
+ *
+ * Loop: attempt → critic verdict → conditional re-attempt, depth = hard compute
+ * cap. The critic is the DETERMINISTIC v2 scorer (accept iff the attempt is both
+ * capability- AND discipline-passing) — cheapest critic, no extra model call,
+ * fully testable. A model-based / cross-vendor critic is a later option (see
+ * road-to-recursive-verification.md Phase 4).
+ *
+ * `attemptFn(depth, priorVerdict)` is an injectable seam: the default runs the
+ * real `package`-config agent (prior verdict threaded as the system prompt on
+ * re-attempts) and scores it; tests inject a scripted attemptFn to exercise the
+ * loop control flow with NO live model call.
+ *
+ * Verifies the loop's CONTROL FLOW (stop conditions, depth cap, verdict
+ * threading). Whether recursion actually lifts capability/discipline is the
+ * empirical question the live `bench:ab` run answers — not asserted here.
+ */
+export function run_one_recursive(
+    task: Dict,
+    opts: RunOneOpts,
+    attemptFn?: (depth: number, priorVerdict: string | null) => RecursiveAttempt,
+    onAttempt?: (depth: number, attempt: RecursiveAttempt) => void,
+): Dict {
+    const maxDepth = Math.max(0, opts.max_depth ?? 1);
+    const makeAttempt =
+        attemptFn ??
+        ((depth: number, priorVerdict: string | null): RecursiveAttempt => {
+            const [clone, fixture] = reset_fixture(task);
+            let sp_file: string | null = null;
+            if (priorVerdict) {
+                sp_file = path.join(opts.sp_dir, `.sp-recursive-${depth}.txt`);
+                fs.writeFileSync(sp_file, priorVerdict, { encoding: 'utf-8' });
+            }
+            const run = v1.run_live(task, clone, opts.timeout, {
+                sysprompt_file: sp_file,
+                setting_sources: (ARMS['package'] as ArmSpec).setting_sources,
+                max_budget: opts.max_budget,
+                model: opts.model,
+            }) as unknown as Dict;
+            const score = scoring.score_task_v2(task, {
+                fixture_root: fixture,
+                clone_root: clone,
+                transcript: String(run['transcript'] ?? ''),
+            });
+            // Capture the attempt's output (changed-file contents) for the
+            // human-preference pair, before the next depth resets the clone.
+            const output = score.files_changed
+                .map((f: string) => {
+                    try {
+                        return `--- ${f} ---\n${fs.readFileSync(path.join(clone, f), 'utf-8')}`;
+                    } catch {
+                        return `--- ${f} --- (unreadable)`;
+                    }
+                })
+                .join('\n\n')
+                .slice(0, 4000);
+            return { run, score, output };
+        });
+
+    const accepts = (s: scoring.ScoreResultV2): boolean => Boolean(s.capability_pass) && Boolean(s.discipline_pass);
+
+    let depth = 0;
+    let prior: RecursiveAttempt | null = null;
+    let attempt = makeAttempt(0, null);
+    onAttempt?.(0, attempt);
+    let stop_reason: string;
+    let last_verdict_len = 0;
+    for (;;) {
+        const s = attempt.score;
+        if (accepts(s)) {
+            stop_reason = 'accept';
+            break;
+        }
+        if (depth >= maxDepth) {
+            stop_reason = 'max_depth';
+            break;
+        }
+        if (
+            prior !== null &&
+            s.discipline_score === prior.score.discipline_score &&
+            Boolean(s.capability_pass) === Boolean(prior.score.capability_pass)
+        ) {
+            stop_reason = 'no_progress';
+            break;
+        }
+        depth += 1;
+        const verdict =
+            `Prior attempt (depth ${depth - 1}) did not pass: ` +
+            `capability=${s.capability_pass}, discipline=${s.discipline_score}. ` +
+            `Revise to satisfy the unmet acceptance criteria; change only what the task requires.`;
+        last_verdict_len = verdict.length;
+        prior = attempt;
+        attempt = makeAttempt(depth, verdict);
+        onAttempt?.(depth, attempt);
+    }
+
+    const { run, score } = attempt;
+    return {
+        errored: _pyBool(run['errored']),
+        reason: run['reason'] ?? null,
+        capability_pass: score.capability_pass,
+        discipline_score: new PyFloat(score.discipline_score),
+        discipline_pass: score.discipline_pass,
+        metrics: trajectory_metrics(run, score),
+        injected_chars: last_verdict_len,
+        depth_reached: depth,
+        stop_reason,
+    };
+}
+
 export function main(argv: string[] | null = null): number {
     const args = parse_args(argv ?? process.argv.slice(2));
 

package/src/scripts/bench_ab_v2_stats.ts

@@ -41,6 +41,11 @@ const COMPARISONS: Array<[string, string, string]> = [
     ['package', 'vanilla', 'package lift'],
     ['package-rdp', 'package', 'RDP lift'],
     ['package', 'placebo', 'attribution (content vs length)'],
+    // ADR-106: recursion's NOVEL lift over rules-only (D₂ − D₁). The analyse()
+    // loop is arm-guarded (`arms.includes(t) && arms.includes(b)`), so this row
+    // renders ONLY when a `package-recursive` arm is present — existing runs
+    // (no such arm) are byte-identical, golden parity preserved.
+    ['package-recursive', 'package', 'recursion novel lift (D₂ − D₁)'],
 ];
 
 // ── CPython math.erf / math.comb ports ────────────────────────────────────
@@ -333,6 +338,40 @@ export function compare(records: Dict[], arm_t: string, arm_b: string): Dict {
     };
 }
 
+/**
+ * Recursion's NOVEL discipline lift over rules-only (ADR-106).
+ *
+ * Compares the `package-recursive` arm (D₂ = rules + recursion) against
+ * `package` (D₁ = rules only) via the existing pure `compare()`, so recursion's
+ * marginal lift `D₂ − D₁` is a measured fact, never an assumed redundancy.
+ *
+ * ADDITIVE: does NOT touch the rendered COMPARISONS path — existing CLI output
+ * (and its golden-parity tests) are unaffected. Returns `null` when no
+ * `package-recursive` arm is present in the records, so a future renderer can
+ * skip the block cleanly for non-recursion runs.
+ *
+ * NOTE (Phase 2b live-integration, NOT done here): wiring this into the rendered
+ * stats output (a guarded COMPARISONS entry + a golden-parity fixture refresh)
+ * and producing the `package-recursive` arm itself (a multi-call recursion loop
+ * the single-`--print` runner does not yet support) require the live bench and
+ * are deferred to the supervised Phase 3 session.
+ */
+export const RECURSIVE_ARM = 'package-recursive';
+export const RECURSIVE_BASELINE_ARM = 'package';
+
+export function recursiveNovelLift(records: Dict[]): Dict | null {
+    const hasRecursion = records.some((rec) => {
+        const runs = _dictOr(rec['arms'])[RECURSIVE_ARM];
+        return Array.isArray(runs) && runs.length > 0;
+    });
+    if (!hasRecursion) return null;
+    return {
+        label: 'recursion novel lift (D₂ − D₁)',
+        arms: [RECURSIVE_ARM, RECURSIVE_BASELINE_ARM],
+        ...compare(records, RECURSIVE_ARM, RECURSIVE_BASELINE_ARM),
+    };
+}
+
 export function mean_tokens_by_arm(records: Dict[], arms: string[]): Dict {
     // Mean total tokens per arm over non-errored runs (the cost axis, L10).
     // Truncated/errored runs are excluded — their token count is capped by the

package/src/scripts/check_council_config_location.ts

@@ -9,11 +9,12 @@
  * and the same `<!-- council-config-allowed -->` escape pragma. No behaviour
  * changes — latent bugs replicated.
  *
- * Per ADR-093 the council reads a dedicated `.ai-council.yml` — resolved
- * project-local (`agents/settings/.ai-council.yml`) first, else user-global
- * (`~/.event4u/agent-config/settings/.ai-council.yml`). Keys are top-level in
- * that file; the legacy `ai_council.*` block under `.agent-settings.yml` was
- * removed in Phase 0.
+ * Per ADR-104 (superseding ADR-093) the council reads a dedicated
+ * `.ai-council.yml` resolved ALWAYS from the user-global location
+ * (`~/.event4u/agent-config/settings/.ai-council.yml`) — the project tree
+ * is never searched (the only escape is the explicit `$AI_COUNCIL_CONFIG`
+ * path). Keys are top-level in that file; the legacy `ai_council.*` block
+ * under `.agent-settings.yml` was removed in Phase 0.
  *
  * What it flags, in the council command/skill surfaces + the config contract:
  *

package/src/scripts/lint_discovery_vocabulary.ts

@@ -29,6 +29,8 @@ const PACKS_YML = path.join(REPO_ROOT, 'src', 'config', 'discovery', 'packs.yml'
 const ADR_WORKSPACES: ReadonlySet<string> = new Set<string>([
     'engineering', 'product', 'finance', 'founder', 'gtm', 'ops',
     'small-business', 'construction', 'agent-config-maintainer',
+    // road-to-legal-pack Phase 0 (ADR-013 amendment, same PR).
+    'legal',
 ]);
 const ADR_PACKS: ReadonlySet<string> = new Set<string>([
     'engineering-base', 'php', 'laravel', 'symfony', 'javascript',
@@ -40,6 +42,10 @@ const ADR_PACKS: ReadonlySet<string> = new Set<string>([
     'memory', 'analytics', 'product-reasoning',
     // road-to-image-brand-typography Phase B (ADR-013 amendment, same PR).
     'brand',
+    // Pre-existing drift restore: present in packs.yml but missing from this set.
+    'ai-image', 'analysis-workbench',
+    // road-to-legal-pack Phase 0 (ADR-013 amendment, same PR).
+    'legal',
 ]);
 
 // ADR-010 non-overlap reservations.

package/src/scripts/lint_framework_leakage_allowlist.json

@@ -577,6 +577,27 @@
         24
       ],
       "reason": "Single Laravel-shape example for per-module agents directory (road-to-configurable-modules Phase D)"
+    },
+    {
+      "file": "src/skills/code-review/SKILL.md",
+      "lines": [
+        214
+      ],
+      "reason": "Cross-stack formatter enumeration (ECS, Prettier, Ruff, gofmt) — multi-ecosystem documentation"
+    },
+    {
+      "file": "src/skills/context-document/SKILL.md",
+      "lines": [
+        82
+      ],
+      "reason": "Laravel example path inside a stack-agnostic module-context table"
+    },
+    {
+      "file": "src/skills/iconography/SKILL.md",
+      "lines": [
+        29
+      ],
+      "reason": "Cross-stack UI-stack enumeration (React, Blade, Tailwind)"
     }
   ]
 }

package/src/scripts/lint_legal_pack.ts

@@ -0,0 +1,139 @@
+#!/usr/bin/env tsx
+/**
+ * Lint the legal pack's deterministic safety-floor backstops.
+ *
+ * The `legal-safety-floor` rule is prose; this linter makes three of its
+ * Iron-Law elements machine-checkable over every `packs: [legal]` skill —
+ * so they are governance, not just prompt instructions (road-to-legal-pack
+ * Phase 1, the "deterministic hardening = differentiator" thesis):
+ *
+ *   1.1 disclaimer-presence — the exact attorney-review line must appear in
+ *       the skill body (a skill that drafts legal work must instruct the model
+ *       to emit it).
+ *   1.2 jurisdiction-tag — the skill must reference the machine-checkable
+ *       `Jurisdiction:` tag (jurisdiction-honesty made deterministic).
+ *   1.3 freshness — any legal-pack artefact that DECLARES `last_verified` /
+ *       `freshness_window` frontmatter must use a valid shape and not be stale
+ *       (no-op when absent; the mechanism for when positions carry dates).
+ *
+ * Scope is the legal pack only — it never touches the other 250+ skills.
+ * Exit codes: 0 all legal-pack skills compliant, 1 one or more violations.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const QUIET = process.argv.includes('--quiet');
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO = path.resolve(path.dirname(_HERE), '..', '..');
+const SKILLS_DIR = path.join(REPO, 'src', 'skills');
+
+// The exact line the floor requires in every legal-pack deliverable.
+const ATTORNEY_LINE = 'Attorney review required on material use';
+const JURISDICTION_TAG = 'Jurisdiction:';
+const FRESHNESS_WINDOW_RE = /^\d+\s+(day|days|month|months|year|years)$/;
+
+// D4 — definitive-legal-language blocklist (the floor bans these; this is the
+// deterministic backstop over skill bodies). Narrow on purpose; the floor's
+// prompt layer is the primary enforcement.
+const DEFINITIVE_PATTERNS: readonly (readonly [RegExp, string])[] = [
+    [/\bthis (contract|nda|agreement|dpa|clause) is (valid|enforceable|compliant|legal|illegal)\b/i, 'definitive validity/compliance verdict'],
+    [/\b(is|are) (fully |now )?gdpr[- ]compliant\b/i, 'definitive GDPR-compliance claim'],
+    [/\byou are (legally )?required to\b/i, 'definitive legal obligation'],
+    [/\byou will (win|lose|prevail)\b/i, 'outcome prediction'],
+    [/\byour chances (of success )?are\b/i, 'success prognosis'],
+];
+// A line is exempt when it is clearly a negative example / guidance / quote —
+// so "Do NOT say 'this contract is valid'" or "Forbidden: …" never false-positive.
+const NEG_EXAMPLE_RE = /(never|avoid|forbidden|do not|don'?t|instead|rather than|not say|→|⚠️)/i;
+
+function _print(msg: string): void {
+    if (!QUIET) process.stdout.write(`${msg}\n`);
+}
+
+function _readText(p: string): string {
+    return fs.readFileSync(p, 'utf-8');
+}
+
+/** Return [frontmatterText, body] — frontmatter null when no `---` fence. */
+function _splitFrontmatter(content: string): [string | null, string] {
+    if (!content.startsWith('---\n')) return [null, content];
+    const end = content.indexOf('\n---', 4);
+    if (end === -1) return [null, content];
+    return [content.slice(4, end), content.slice(end + 4)];
+}
+
+/** True when the frontmatter `packs:` block lists `legal`. */
+function _isLegalPack(fm: string): boolean {
+    // Match a `packs:` block then a `- legal` item before the next top-level key.
+    const m = /(^|\n)packs:\s*\n((?:\s*-\s*[^\n]+\n?)+)/.exec(fm);
+    if (!m) return false;
+    return /(^|\n)\s*-\s*legal\s*$/m.test(m[2] ?? '');
+}
+
+interface Violation {
+    file: string;
+    rule: string;
+    msg: string;
+}
+
+export function lintLegalPack(skillsDir: string = SKILLS_DIR): Violation[] {
+    const violations: Violation[] = [];
+    let dirs: string[] = [];
+    try {
+        dirs = fs.readdirSync(skillsDir).sort();
+    } catch {
+        return violations;
+    }
+    for (const d of dirs) {
+        const file = path.join(skillsDir, d, 'SKILL.md');
+        if (!fs.existsSync(file)) continue;
+        const content = _readText(file);
+        const [fm, body] = _splitFrontmatter(content);
+        if (fm === null || !_isLegalPack(fm)) continue;
+        const rel = path.relative(REPO, file);
+
+        // 1.1 disclaimer-presence
+        if (!body.includes(ATTORNEY_LINE)) {
+            violations.push({ file: rel, rule: 'disclaimer-presence', msg: `missing the attorney-review line ("${ATTORNEY_LINE}")` });
+        }
+        // 1.2 jurisdiction-tag
+        if (!body.includes(JURISDICTION_TAG)) {
+            violations.push({ file: rel, rule: 'jurisdiction-tag', msg: `missing the machine-checkable "${JURISDICTION_TAG}" tag` });
+        }
+        // 1.3 freshness — only when declared
+        const fw = /(^|\n)freshness_window:\s*"?([^"\n]+)"?/.exec(fm);
+        if (fw && !FRESHNESS_WINDOW_RE.test((fw[2] ?? '').trim())) {
+            violations.push({ file: rel, rule: 'freshness', msg: `freshness_window "${fw[2]}" is not a valid "<N> days|months|years" shape` });
+        }
+        // 4.1 — no definitive legal language (line-scoped, skips negative examples)
+        for (const line of body.split('\n')) {
+            if (NEG_EXAMPLE_RE.test(line)) continue;
+            for (const [re, label] of DEFINITIVE_PATTERNS) {
+                if (re.test(line)) {
+                    violations.push({ file: rel, rule: 'definitive-language', msg: `${label}: ${line.trim().slice(0, 80)}` });
+                }
+            }
+        }
+    }
+    return violations;
+}
+
+export function main(): number {
+    const violations = lintLegalPack();
+    if (violations.length === 0) {
+        _print('✅  legal pack — all legal-pack skills carry the attorney-review line + Jurisdiction tag');
+        return 0;
+    }
+    _print(`❌  legal pack — ${violations.length} violation(s):`);
+    for (const v of violations) {
+        _print(`  - [${v.rule}] ${v.file}: ${v.msg}`);
+    }
+    return 1;
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
+    process.exit(main());
+}

package/src/scripts/probe_projection_fidelity.ts

@@ -154,7 +154,13 @@ function check_entry(entry: Record<string, unknown>): EntryResult {
     for (const [tool, spec] of Object.entries(checks)) {
         const result: CheckResult = { status: 'pass', details: [] };
         const expect_present = 'present' in spec ? Boolean(spec['present']) : true;
-        const pathLocated = locate(tool, out.type, entry['source'] as string);
+        // Honor an explicit per-tool `location` from the fixture when present
+        // (e.g. a renamed command whose projection stem differs from its source
+        // stem); otherwise derive the path from the artefact source.
+        const explicitLoc = spec['location'] as string | undefined;
+        const pathLocated = typeof explicitLoc === 'string'
+            ? (fs.existsSync(path.join(ROOT, explicitLoc)) ? path.join(ROOT, explicitLoc) : null)
+            : locate(tool, out.type, entry['source'] as string);
 
         if (tool === 'windsurf' && spec['concatenated_in']) {
             const fp = path.join(ROOT, spec['concatenated_in'] as string);

package/src/scripts/rdp_gate_classify.ts

@@ -0,0 +1,131 @@
+#!/usr/bin/env tsx
+/**
+ * RDP gate-time classification validation (road-to-rdp-frontier-polish Phase 1).
+ *
+ * The council's blocker on "keep-scoped" (2026-06-22): scoping the orchestrator
+ * to interdependent-multi-step work via agent self-assessment is only honest if
+ * the agent can classify a task AT GATE TIME — from the prompt alone, before
+ * doing the work. This script measures exactly that: the standard host classifies
+ * each labelled corpus prompt as multi-step vs single-turn, scored against the
+ * ground-truth `mechanism` label. High accuracy → the self-assessment gate is a
+ * real control, not vibes. Low accuracy → keep-scoped is not implementable.
+ *
+ * Direct Messages API via fetch (no SDK dep), reuses the key gate + cost
+ * estimate from skill_trigger_eval.ts. Dry-run by default; --confirm to spend
+ * (+ RDP_EVAL_ALLOW_NONTTY=1 on a non-tty caller that has confirmed cost).
+ *
+ * Usage: ./scripts-run src/scripts/rdp_gate_classify --corpus <file> --confirm
+ */
+import * as fs from 'node:fs';
+import { estimate_cost, load_anthropic_key } from './skill_trigger_eval.js';
+
+/** stdout helper — the lint config forbids `console.log` (allows warn/error). */
+const emit = (s: string): void => {
+    process.stdout.write(`${s}\n`);
+};
+
+const ANTHROPIC_URL = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_VERSION = '2023-06-01';
+
+const GATE_SYSTEM = `You are an agent deciding, at the START of a task (before doing any work), whether
+to engage a heavyweight multi-step reasoning orchestrator. You see ONLY the task
+prompt. Classify the task into exactly one bucket using the rdp-gate criterion:
+
+- "multi-step": interdependent multi-step work where the ordering and handoffs
+  between steps matter (e.g. schema → API → job → UI; a migration with stages; a
+  cross-cutting refactor). The orchestrator helps here.
+- "single-turn": a single analytical or lookup question, a naming/explain/yes-no
+  ask, or a one-shot edit — work that does NOT decompose into ordered
+  interdependent steps. The orchestrator over-processes here.
+
+Respond with STRICT JSON only: {"bucket":"multi-step"|"single-turn","confidence":"high"|"medium"|"low"}`;
+
+interface Slot {
+    n: string;
+    slug: string;
+    mechanism?: string;
+    band: string;
+    prompt: string;
+}
+
+async function classify(apiKey: string, model: string, prompt: string): Promise<{ bucket: string; confidence: string } | null> {
+    const resp = await fetch(ANTHROPIC_URL, {
+        method: 'POST',
+        headers: {
+            'x-api-key': apiKey,
+            'anthropic-version': ANTHROPIC_VERSION,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            model,
+            max_tokens: 60,
+            system: GATE_SYSTEM,
+            messages: [{ role: 'user', content: `Task prompt:\n${prompt}` }],
+        }),
+    });
+    if (!resp.ok) throw new Error(`API ${resp.status}: ${(await resp.text()).slice(0, 300)}`);
+    const data = (await resp.json()) as {
+        content?: Array<{ type?: string; text?: string }>;
+        usage?: { input_tokens?: number; output_tokens?: number };
+    };
+    const text = (data.content ?? []).filter((b) => b.type === 'text').map((b) => b.text ?? '').join('');
+    const m = text.match(/\{[\s\S]*\}/);
+    if (!m) return null;
+    try {
+        return JSON.parse(m[0]) as { bucket: string; confidence: string };
+    } catch {
+        return null;
+    }
+}
+
+function expectedBucket(mechanism: string | undefined): string {
+    return mechanism === 'multi-stage' ? 'multi-step' : 'single-turn';
+}
+
+async function main(): Promise<number> {
+    const argv = process.argv.slice(2);
+    const args: Record<string, string | boolean> = {};
+    for (let i = 0; i < argv.length; i++) {
+        const t = argv[i];
+        if (t === undefined) continue;
+        if (t === '--confirm') args.confirm = true;
+        else if (t.startsWith('--')) {
+            const next = argv[i + 1];
+            if (next && !next.startsWith('--')) { args[t.slice(2)] = next; i++; } else args[t.slice(2)] = true;
+        }
+    }
+    const corpusPath = (args.corpus as string) ?? '';
+    const model = (args.model as string) ?? 'claude-haiku-4-5-20251001';
+    if (!corpusPath) throw new Error('--corpus <file> required');
+    const slots = (JSON.parse(fs.readFileSync(corpusPath, 'utf-8')) as { slots: Slot[] }).slots;
+
+    const est = slots.reduce((p) => p + estimate_cost(model, 250, 60), 0);
+    emit(`rdp-gate-classify · ${slots.length} prompts · ${model} · ~$${est.toFixed(4)}`);
+    if (!args.confirm) {
+        emit('DRY-RUN — no spend. Re-run with --confirm.');
+        return 0;
+    }
+    if (!process.stdin.isTTY && process.env.RDP_EVAL_ALLOW_NONTTY !== '1') {
+        throw new Error('Non-tty: set RDP_EVAL_ALLOW_NONTTY=1 only after confirming cost.');
+    }
+    const apiKey = load_anthropic_key();
+    let correct = 0;
+    const rows: Array<Record<string, unknown>> = [];
+    for (const s of slots) {
+        const r = await classify(apiKey, model, s.prompt);
+        const exp = expectedBucket(s.mechanism);
+        const got = r?.bucket ?? 'parse-error';
+        const ok = got === exp;
+        if (ok) correct++;
+        console.error(`  ${s.n} ${s.slug}: expected ${exp} · got ${got} (${r?.confidence ?? '-'}) ${ok ? 'OK' : 'MISS'}`);
+        rows.push({ slot: s.n, slug: s.slug, expected: exp, got, confidence: r?.confidence ?? null, ok });
+    }
+    const acc = Math.round((correct / slots.length) * 1000) / 10;
+    const out = (args.results as string) ?? '/tmp/rdp-gate-classify.json';
+    fs.writeFileSync(out, JSON.stringify({ model, n: slots.length, correct, accuracy_pct: acc, rows }, null, 2), 'utf-8');
+    emit(`\nGATE-TIME CLASSIFICATION ACCURACY: ${correct}/${slots.length} = ${acc}%  (model ${model})`);
+    emit(`Results: ${out}`);
+    return 0;
+}
+
+main().then((c) => process.exit(c), (e) => { console.error(e instanceof Error ? e.message : String(e)); process.exit(1); });