@event4u/agent-config 7.0.1 → 7.0.2

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Shared agent configuration — skills for AI coding tools (Claude Code, Augment, Cursor, Cline, Windsurf, Gemini CLI).",
-    "version": "7.0.1",
+    "version": "7.0.2",
     "keywords": [
       "agent-config",
       "skills",

package/CHANGELOG.md

@@ -948,6 +948,27 @@ our recommendation order, not its support status.
 > that forces a new era split (`# Era: 7.1.x`, etc.) — see
 > [`docs/contracts/CHANGELOG-conventions.md § Era splits`](docs/contracts/CHANGELOG-conventions.md).
 
+## [7.0.2](https://github.com/event4u-app/agent-config/compare/7.0.1...7.0.2) (2026-06-22)
+
+### Bug Fixes
+
+* **roadmaps:** regen entry-guard fires under symlinked invocation ([244e4e4](https://github.com/event4u-app/agent-config/commit/244e4e45a42a6b3d4793ac192e0f912d71954ba4))
+* **rdp-eval:** harden index access for strict typecheck (noUncheckedIndexedAccess) ([041b21e](https://github.com/event4u-app/agent-config/commit/041b21e4877361b1499328216242fa6ec595ff99))
+* **rdp-eval:** satisfy eslint on the new runners ([3c418e1](https://github.com/event4u-app/agent-config/commit/3c418e16faf340b8367148f6788835e400241e4e))
+
+### Documentation
+
+* **rdp-eval:** keep-scoped L6 verdict — scope orchestrator to multi-step work ([61173ca](https://github.com/event4u-app/agent-config/commit/61173ca899442b81159e4f3efe586251dcea4459))
+
+### Tests
+
+* **rdp-eval:** capture larger-N L6 + gate-classification data ([f92aad3](https://github.com/event4u-app/agent-config/commit/f92aad32620af27c5cf4d000859adeeb9894a819))
+* **rdp-eval:** port quality+L6 eval runners to TypeScript (fetch-based) ([9c4ec60](https://github.com/event4u-app/agent-config/commit/9c4ec604ca6fbb82d796cf2d65626d381a854142))
+
+### CI
+
+* **consistency:** trigger on src/** and dist/agent-src/** paths ([6a5e5e7](https://github.com/event4u-app/agent-config/commit/6a5e5e76cea3d5f879f9fcda6e510cc73039826e))
+
 ## [7.0.1](https://github.com/event4u-app/agent-config/compare/7.0.0...7.0.1) (2026-06-22)
 
 ### Bug Fixes

package/dist/agent-src/scripts/update_roadmap_progress.ts

@@ -784,10 +784,28 @@ function main(argv?: readonly string[]): number {
     return 0;
 }
 
-const _isCliEntry =
-    process.argv[1] !== undefined &&
-    import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
-if (_isCliEntry || process.argv[1] === _HERE) {
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) {
+        return false;
+    }
+    const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (import.meta.url === argvUrl) {
+        return true;
+    }
+    // A symlinked invocation (e.g. via `.augment/scripts` → `dist/agent-src/scripts`,
+    // or macOS /var → /private/var temp dirs) makes the raw URLs differ:
+    // import.meta.url is the resolved real path while argv[1] keeps the symlink
+    // path. Compare realpaths so the entry guard still fires (without this the
+    // dashboard regen silently no-ops when run through the symlink).
+    try {
+        const here = fs.realpathSync(fileURLToPath(import.meta.url));
+        const argv = fs.realpathSync(path.resolve(process.argv[1]));
+        return here === argv;
+    } catch {
+        return false;
+    }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
     try {
         process.exitCode = main();
     } catch (exc) {

package/dist/agent-src/skills/reasoning-orchestrator/SKILL.md

@@ -34,12 +34,29 @@ coordinates); on a standard host run the full chain.
 
 ## When to use
 
-- A complex, ambiguous, or long-horizon task on a standard host.
-- Work where the reasoning steps are interdependent (a missed grounding or skipped
-  verification compounds downstream).
-
-Do NOT use for trivial / linear / fully-specified tasks (the gate filters these),
-and do not let it duplicate the work of the skills it coordinates.
+Scope (eval-calibrated, L6): engage only for **interdependent multi-step** work
+— steps whose ordering/handoffs matter (schema → API → job → UI; staged
+migration; cross-cutting refactor). **Not** for single-turn analysis (explain /
+name / yes-no / pick-X-or-Y / one-shot edit): there the ordered chain is a no-op,
+only adds tokens.
+
+- Interdependent **multi-step** task on a standard host. Analyze the dependency
+  structure (what blocks what) before acting.
+- Work where a missed/out-of-order link (grounding, verification) compounds
+  downstream.
+
+Do NOT use for trivial / linear / fully-specified tasks **or single-turn
+analysis** (the gate filters these); don't duplicate the work of the skills it
+coordinates.
+
+> **Why scoped (L6, 2026-06-22).** Controlled distributed-vs-orchestrated eval
+> (N=16, independent rater): ordered chain gains **+19.2%** on multi-step,
+> **−1.1%** (no-op) on single-turn. Standard host classifies multi-step vs
+> single-turn at gate time 16/16; misclassification degrades gracefully (wrong
+> arm still functional). Revert trigger = re-run `tests/reasoning-layer-eval`
+> (eval is the telemetry — no-runtime package); RDP flip conditions judged
+> per-mechanism, never univariate aggregate. Evidence:
+> `tests/reasoning-layer-eval/RESULTS-L6-largeN-2026-06-22.md`.
 
 ## When the agent should load this
 
@@ -77,8 +94,16 @@ not exclusivity.
 
 ## Output
 
-The task's actual deliverable — produced through the chain. Reasoning stays in the
-notes file; the response leads with the outcome + its evidence.
+The task's actual deliverable, produced **through the chain** (analysis before
+action — grounding + load-bearing-unknown resolution precede any edit):
+
+1. **Outcome first** — response leads with the result + its evidence.
+2. **Reasoning stays in notes** — hypotheses / predictions / decisions in the
+   notes file, never dumped into the response.
+3. **Chain honoured in order** — ground → intent → notes → resolve-hardest-first
+   → audit → verify ran as ordered links (with handoffs), not a buffet.
+4. **Verified before "done"** — no completion claim without the verifier link's
+   evidence.
 
 ## Do NOT
 

package/dist/discovery/deprecation-report.md

@@ -1,6 +1,6 @@
 # Discovery — Deprecation Report
 
-- Generated: `2026-06-21T23:17:03Z`
+- Generated: `2026-06-22T07:13:57Z`
 - Deprecated artefacts: **0**
 
 _None. Tree is clean._

package/dist/discovery/discovery-manifest.json

@@ -10357,7 +10357,7 @@
     },
     {
       "category": "skill",
-      "checksum": "sha256:949bab08a36fcbc7b88de82c6facb3490b59478d430eec284a96a83ac7456a60",
+      "checksum": "sha256:c7a74836f37f983ea6432ce8773fd03df7c20bdb616616db4852364406b4ad78",
       "install": {
         "default": true,
         "removable": false
@@ -11742,7 +11742,7 @@
       ]
     }
   ],
-  "checksum": "sha256:f2a4c972feea1c5cde8781f698209980d6d156e17612b71b66e885f6a97ed19e",
+  "checksum": "sha256:f5d227f1f899e88091f76a952cdfadda24da8bcc233811a2c55a8ebfdf564fa7",
   "deprecations": [
     {
       "key": "tier",
@@ -11880,7 +11880,7 @@
       "reason": "scaffold template for ticket-bundle tickets (ADR-101); carries no runtime frontmatter — emit-tickets fills it in per ticket"
     }
   ],
-  "generated_at": "2026-06-21T23:17:03Z",
+  "generated_at": "2026-06-22T07:13:57Z",
   "packs": [
     {
       "artefact_count": 93,

package/dist/discovery/discovery-manifest.json.sha256

@@ -1 +1 @@
-b14a0a566a169fd604a5937ce681473bc8f4690936172300e680950c0599ed3c  discovery-manifest.json
+a8b3e192c4c3462c185328180eed27e001de5e3f87feba346a63e42c6d6ebcb0  discovery-manifest.json

package/dist/discovery/discovery-manifest.summary.md

@@ -1,6 +1,6 @@
 # Discovery Manifest — Summary
 
-- Generated: `2026-06-21T23:17:03Z`
+- Generated: `2026-06-22T07:13:57Z`
 - Scanner: `47c9a32fb265`
 - Artefacts: **501**
 - Unassigned: **0**

package/dist/discovery/orphan-report.md

@@ -1,6 +1,6 @@
 # Discovery — Orphan Report
 
-- Generated: `2026-06-21T23:17:03Z`
+- Generated: `2026-06-22T07:13:57Z`
 - Orphan artefacts: **0**
 
 > An orphan is an artefact whose declared pack has no other members.

package/dist/discovery/packs.json

@@ -1,6 +1,6 @@
 {
-  "checksum": "sha256:f2a4c972feea1c5cde8781f698209980d6d156e17612b71b66e885f6a97ed19e",
-  "generated_at": "2026-06-21T23:17:03Z",
+  "checksum": "sha256:f5d227f1f899e88091f76a952cdfadda24da8bcc233811a2c55a8ebfdf564fa7",
+  "generated_at": "2026-06-22T07:13:57Z",
   "packs": [
     {
       "always_on": false,

package/dist/discovery/trust-report.md

@@ -1,6 +1,6 @@
 # Discovery — Trust Report
 
-- Generated: `2026-06-21T23:17:03Z`
+- Generated: `2026-06-22T07:13:57Z`
 - Workspaces tracked: **8**
 - Human-review-required artefacts: **2**
 

package/dist/discovery/workspaces.json

@@ -1,6 +1,6 @@
 {
-  "checksum": "sha256:f2a4c972feea1c5cde8781f698209980d6d156e17612b71b66e885f6a97ed19e",
-  "generated_at": "2026-06-21T23:17:03Z",
+  "checksum": "sha256:f5d227f1f899e88091f76a952cdfadda24da8bcc233811a2c55a8ebfdf564fa7",
+  "generated_at": "2026-06-22T07:13:57Z",
   "scanner_version": "47c9a32fb265",
   "workspaces": [
     {

package/dist/mcp/registry-manifest.json

@@ -3,13 +3,13 @@
     "artefact_count": 501,
     "scanner_version": "47c9a32fb265"
   },
-  "generated_at": "2026-06-21",
+  "generated_at": "2026-06-22",
   "package": {
     "description": "Universal AI Agent OS \u2014 audited skills, governance rules, commands, and templates for AI coding tools (Claude Code, Cursor, Windsurf, Copilot).",
     "homepage": "https://github.com/event4u-app/agent-config#readme",
     "name": "@event4u/agent-config",
     "repository": "https://github.com/event4u-app/agent-config",
-    "version": "7.0.1"
+    "version": "7.0.2"
   },
   "registries": [
     {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@event4u/agent-config",
-    "version": "7.0.1",
+    "version": "7.0.2",
     "description": "Universal AI Agent OS — audited skills, governance rules, commands, and templates for AI coding tools (Claude Code, Cursor, Windsurf, Copilot).",
     "license": "MIT",
     "private": false,

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); });

package/src/scripts/rdp_quality_eval.ts

@@ -0,0 +1,437 @@
+#!/usr/bin/env tsx
+/**
+ * RDP quality-layer + L6-isolation eval runner (TypeScript).
+ *
+ * Ports the Python `run_quality_eval.py` removed in the py2ts teardown. The
+ * Anthropic SDK is not a dependency in this repo (the TS trigger runner throws
+ * on the live path); this runner therefore calls the Messages API directly via
+ * Node's global `fetch` — no new dependency. It reuses the 0600-key gate, the
+ * cost-estimate, and the price tables exported by `skill_trigger_eval.ts`.
+ *
+ * Two modes (controlled system-prompt differential — the differing block is the
+ * only variable, so the delta isolates that block's effect):
+ *   --mode quality : baseline (no RDP) vs treatment (+RDP layer)            [L8]
+ *   --mode l6      : distributed-only (RDP buffet) vs orchestrated (ordered) [L6]
+ *
+ * The measured model runs with the system prompt this runner supplies, so a
+ * baseline is NOT contaminated by the calling agent's own active rules.
+ *
+ * Optional `--score-with <model>` adds an independent model rater (rater 2):
+ * after capture, each variant transcript is scored 0–3 on the 4 rubric dims by
+ * a separate model call, recorded alongside the transcript.
+ *
+ * Cost discipline mirrors skill_trigger_eval.ts: dry-run by default; a billable
+ * run needs --confirm, and on a non-tty stdin also RDP_EVAL_ALLOW_NONTTY=1
+ * (set only when the caller has already confirmed the cost).
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/rdp_quality_eval --mode l6 --corpus <file>
+ *   ./scripts-run src/scripts/rdp_quality_eval --mode l6 --corpus <file> --confirm --score-with claude-sonnet-4-5
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { estimate_cost, load_anthropic_key } from './skill_trigger_eval.js';
+
+/** stdout helper — the lint config forbids `console.log` (allows warn/error). */
+const out = (s: string): void => {
+    process.stdout.write(`${s}\n`);
+};
+
+const REPO_ROOT = path.resolve(import.meta.dirname, '..', '..');
+const EVAL_DIR = path.join(REPO_ROOT, 'tests', 'reasoning-layer-eval');
+const GT_DIR = path.join(EVAL_DIR, 'golden-transcripts');
+const DEFAULT_CORPUS = path.join(GT_DIR, 'corpus-prompts.json');
+
+const ANTHROPIC_URL = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_VERSION = '2023-06-01';
+
+// ---- the system-prompt blocks (verbatim port of the Python harness) ---------
+const BASE_SYSTEM = `You are a senior software engineering assistant working inside a real codebase.
+
+Operating posture:
+- Keep diffs minimal and scoped to the stated task; no drive-by refactors.
+- When a requirement is ambiguous, you may ask one focused clarifying question.
+- Do not claim work is complete without the evidence that proves it.
+- Be direct and concise. No flattery, no filler.`;
+
+const RDP_BLOCK = `## Reasoning Discipline Protocol
+
+Engage the protocol below only where it pays: skip it on trivial, short, fully
+specified tasks (rename, one-liner, list files); apply it on complex, ambiguous,
+multi-component, stateful, or irreversible tasks. If you are a strong-reasoning
+model that already self-coordinates, apply it lightly.
+
+1. GROUND BEFORE DESIGNING. Enumerate the constraints, available facts, and the
+   information gaps the task leaves open. Close the load-bearing gaps (by asking
+   or by stating an explicit assumption) BEFORE proposing a solution. Never design
+   against unstated assumptions.
+
+2. INFER THE REAL GOAL. When the literal request and the underlying goal may
+   differ, state the inferred goal in one line, then give ONE recommendation —
+   not a spread of framings.
+
+3. COMPLEXITY-FIRST SEQUENCING. For multi-step work, resolve the hardest /
+   most load-bearing unknown FIRST, before dependent work. Do not build the easy
+   parts first and rework later. Name what you would tackle first and why.
+
+4. NOTES-FIRST OUTPUT. Keep multi-hypothesis reasoning, predictions, and
+   decisions in a clearly delimited "## Working notes" section. Your "## Answer"
+   section carries CONCLUSIONS + EVIDENCE only — never a raw chain-of-thought
+   dump. The answer must be readable by someone who saw none of the working
+   thread: outcome-first, no arrow-chain shorthand.
+
+5. VERIFIER GATE (risky change). When the task shows two or more of {branching /
+   conditional logic, three or more explicit must/must-not constraints, stateful
+   operations, irreversibility}, explicitly name what must be verified and how
+   BEFORE treating the change as done. Surface the irreversible step for
+   confirmation rather than executing it blind.
+
+6. PREDICTIONS + DECISIONS (calibration / ledger). When you make an estimate,
+   log it as a prediction with a confidence level so it can be checked against
+   the actual outcome later. When you choose between alternatives, record the
+   decision, the alternatives, the reason, and what would make you revisit it —
+   in the Working notes, so a later session can reuse it instead of re-deriving.
+
+7. ADAPTIVE EFFORT. Scale effort to difficulty; stop when marginal evidence
+   drops rather than over-elaborating.`;
+
+const ORCHESTRATOR_PREAMBLE = `## Reasoning orchestration (run the disciplines as ONE ordered chain)
+
+Do not treat the protocol below as an optional buffet. Run it as a single
+coordinated chain, in order, with explicit handoffs between links — a skipped or
+out-of-order link compounds downstream:
+
+  ground → infer intent → write working notes → resolve the load-bearing unknown
+  first → audit progress against real evidence → verify before claiming done.
+
+Coordinate the links; do not let later steps run before earlier ones. On a
+trivial or fully-specified task, do NOT force the chain (that is over-process) —
+engage it only where the task is genuinely complex/ambiguous/interdependent.`;
+
+interface Slot {
+    n: string;
+    slug: string;
+    family?: string;
+    band: string;
+    discipline?: string;
+    mechanism?: string;
+    prompt: string;
+}
+
+interface Variant {
+    model: string;
+    text: string;
+    input_tokens: number;
+    output_tokens: number;
+    cost_usd: number;
+    score?: Record<string, unknown>;
+}
+
+function buildArms(mode: string): Array<[string, string]> {
+    const treat = `${BASE_SYSTEM}\n\n${RDP_BLOCK}`;
+    if (mode === 'l6') {
+        return [
+            ['distributed', treat],
+            ['orchestrated', `${treat}\n\n${ORCHESTRATOR_PREAMBLE}`],
+        ];
+    }
+    return [
+        ['baseline', BASE_SYSTEM],
+        ['treatment', treat],
+    ];
+}
+
+function approxTokens(text: string): number {
+    return Math.max(1, Math.floor(text.length / 4));
+}
+
+function modelFor(band: string, standard: string, strong: string): string {
+    return band === 'strong' ? strong : standard;
+}
+
+interface ApiResult {
+    text: string;
+    input_tokens: number;
+    output_tokens: number;
+}
+
+async function callAnthropic(
+    apiKey: string,
+    model: string,
+    system: string,
+    userContent: string,
+    maxTokens: number,
+): Promise<ApiResult> {
+    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: maxTokens,
+            system,
+            messages: [{ role: 'user', content: userContent }],
+        }),
+    });
+    if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(`Anthropic API ${resp.status}: ${body.slice(0, 400)}`);
+    }
+    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('');
+    return {
+        text,
+        input_tokens: data.usage?.input_tokens ?? 0,
+        output_tokens: data.usage?.output_tokens ?? 0,
+    };
+}
+
+const SCORER_SYSTEM = `You are a strict, impartial evaluator. Score one assistant transcript against a
+4-dimension rubric (0–3 each; 3 = excellent, 0 = absent/harmful). Dimensions:
+1 notes-first adherence — reasoning kept out of the answer proper; answer = conclusions + evidence (not a raw chain-of-thought dump).
+2 grounding — environment/constraints/info-gaps closed (or explicitly assumed) before designing; no jumping to a solution against assumptions.
+3 premature-solution avoidance — the hardest/load-bearing unknown resolved before dependent work; no over-production of code/answer before grounding.
+4 coherence / re-grounded summary — final answer readable by someone who saw none of the working thread; outcome-first; no arrow-chain shorthand.
+Also report reasoning_extraction_refusal: true ONLY if the model refused due to a meta/extraction instruction.
+Respond with STRICT JSON only, no prose: {"dim1":N,"dim2":N,"dim3":N,"dim4":N,"reasoning_extraction_refusal":false,"note":"<=120 chars"}`;
+
+async function scoreTranscript(
+    apiKey: string,
+    scorerModel: string,
+    prompt: string,
+    transcript: string,
+): Promise<Record<string, unknown> | null> {
+    const user = `## Task prompt given to the assistant\n${prompt}\n\n## Assistant transcript to score\n${transcript}\n\nScore now as strict JSON.`;
+    const r = await callAnthropic(apiKey, scorerModel, SCORER_SYSTEM, user, 300);
+    const m = r.text.match(/\{[\s\S]*\}/);
+    if (!m) return null;
+    try {
+        return JSON.parse(m[0]) as Record<string, unknown>;
+    } catch {
+        return null;
+    }
+}
+
+function loadSlots(corpusPath: string, selected: Set<string> | null): Slot[] {
+    const data = JSON.parse(fs.readFileSync(corpusPath, 'utf-8')) as { slots: Slot[] };
+    let slots = data.slots;
+    if (selected) slots = slots.filter((s) => selected.has(s.n));
+    return slots;
+}
+
+function parseArgs(argv: string[]): Record<string, string | boolean> {
+    const a: Record<string, string | boolean> = {};
+    for (let i = 0; i < argv.length; i++) {
+        const t = argv[i];
+        if (t === undefined) continue;
+        if (t === '--confirm') a.confirm = true;
+        else if (t.startsWith('--')) {
+            const key = t.slice(2);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith('--')) {
+                a[key] = next;
+                i++;
+            } else a[key] = true;
+        }
+    }
+    return a;
+}
+
+function meanDims(score: Record<string, unknown> | undefined): number | null {
+    if (!score) return null;
+    const ds = ['dim1', 'dim2', 'dim3', 'dim4'].map((k) => Number(score[k]));
+    if (ds.some((x) => Number.isNaN(x))) return null;
+    return ds.reduce((p, c) => p + c, 0) / 4;
+}
+
+async function main(): Promise<number> {
+    const args = parseArgs(process.argv.slice(2));
+    const mode = (args.mode as string) ?? 'quality';
+    const corpusPath = (args.corpus as string) ?? DEFAULT_CORPUS;
+    const standardModel = (args['standard-model'] as string) ?? 'claude-haiku-4-5-20251001';
+    const strongModel = (args['strong-model'] as string) ?? 'claude-sonnet-4-5';
+    const maxTokens = args['max-tokens'] ? Number(args['max-tokens']) : 1600;
+    const scoreWith = args['score-with'] as string | undefined;
+    const selected = args.slots
+        ? new Set(String(args.slots).split(',').map((s) => s.trim().padStart(2, '0')))
+        : null;
+    const resultsPath =
+        (args.results as string) ??
+        path.join(GT_DIR, mode === 'l6' ? 'l6-results.json' : 'results.json');
+
+    const slots = loadSlots(corpusPath, selected);
+    const arms = buildArms(mode);
+    const variantNames = arms.map((a) => a[0]);
+
+    // ---- cost preview --------------------------------------------------------
+    let total = 0;
+    const byModel: Record<string, number> = {};
+    for (const s of slots) {
+        const model = modelFor(s.band, standardModel, strongModel);
+        for (const [, sys] of arms) {
+            const tin = approxTokens(sys) + approxTokens(s.prompt);
+            const c = estimate_cost(model, tin, maxTokens);
+            total += c;
+            byModel[model] = (byModel[model] ?? 0) + c;
+        }
+        if (scoreWith) {
+            // 2 scoring calls per slot (one per variant)
+            const c = estimate_cost(scoreWith, 2000, 300) * 2;
+            total += c;
+            byModel[`${scoreWith} (scorer)`] = (byModel[`${scoreWith} (scorer)`] ?? 0) + c;
+        }
+    }
+    const nCalls = slots.length * arms.length + (scoreWith ? slots.length * 2 : 0);
+    out(
+        `rdp-eval · mode=${mode} · ${slots.length} slots × ${arms.length} variants (${variantNames.join('/')}) ` +
+            `${scoreWith ? `+ scorer(${scoreWith})` : ''} = ${nCalls} calls`,
+    );
+    for (const [m, c] of Object.entries(byModel)) out(`    ${m}: ~$${c.toFixed(4)}`);
+    out(`  EXPECTED TOTAL (worst-case): ~$${total.toFixed(4)}`);
+
+    if (!args.confirm) {
+        out('\nDRY-RUN — no spend. Re-run with --confirm to capture transcripts.');
+        return 0;
+    }
+    if (!process.stdin.isTTY && process.env.RDP_EVAL_ALLOW_NONTTY !== '1') {
+        throw new Error(
+            'Refusing a billable run on non-tty stdin. Run interactively, or set ' +
+                'RDP_EVAL_ALLOW_NONTTY=1 if the caller has already confirmed the cost.',
+        );
+    }
+
+    const apiKey = load_anthropic_key();
+    const ts = (args.date as string) ?? '0000-00-00';
+    let actual = 0;
+    const results: Array<Record<string, unknown>> = [];
+
+    for (const s of slots) {
+        const model = modelFor(s.band, standardModel, strongModel);
+        const variants: Record<string, Variant> = {};
+        for (const [variant, sys] of arms) {
+            console.error(`  → slot ${s.n} ${variant} (${model}) …`);
+            const r = await callAnthropic(apiKey, model, sys, s.prompt, maxTokens);
+            const cost = estimate_cost(model, r.input_tokens, r.output_tokens);
+            actual += cost;
+            const v: Variant = {
+                model,
+                text: r.text,
+                input_tokens: r.input_tokens,
+                output_tokens: r.output_tokens,
+                cost_usd: cost,
+            };
+            if (scoreWith) {
+                console.error(`     scoring ${variant} via ${scoreWith} …`);
+                const sc = await scoreTranscript(apiKey, scoreWith, s.prompt, r.text);
+                actual += estimate_cost(scoreWith, 2000, 300);
+                if (sc) v.score = sc;
+            }
+            variants[variant] = v;
+        }
+        const [v0, v1] = variantNames;
+        const va = v0 !== undefined ? variants[v0] : undefined;
+        const vb = v1 !== undefined ? variants[v1] : undefined;
+        if (v0 === undefined || v1 === undefined || va === undefined || vb === undefined) {
+            continue;
+        }
+        const aOut = va.output_tokens;
+        const bOut = vb.output_tokens;
+        const overhead = aOut ? Math.round(((bOut - aOut) / aOut) * 1000) / 10 : null;
+        const m0 = meanDims(va.score);
+        const m1 = meanDims(vb.score);
+        results.push({
+            slot: s.n,
+            slug: s.slug,
+            band: s.band,
+            mechanism: s.mechanism ?? null,
+            discipline: s.discipline ?? null,
+            prompt: s.prompt,
+            model,
+            variants,
+            output_token_overhead_pct: overhead,
+            rater2_mean: { [v0]: m0, [v1]: m1 },
+            rater2_delta: m0 !== null && m1 !== null ? Math.round((m1 - m0) * 100) / 100 : null,
+        });
+        writeTranscript(s, variants, ts, overhead, variantNames, mode);
+    }
+
+    fs.writeFileSync(
+        resultsPath,
+        JSON.stringify(
+            {
+                date: ts,
+                mode,
+                standard_model: standardModel,
+                strong_model: strongModel,
+                scorer_model: scoreWith ?? null,
+                actual_cost_usd: Math.round(actual * 10000) / 10000,
+                results,
+            },
+            null,
+            2,
+        ),
+        'utf-8',
+    );
+    out(`\nDONE · mode=${mode} · actual ~$${(Math.round(actual * 10000) / 10000).toFixed(4)}`);
+    out(`Results JSON: ${resultsPath}`);
+    return 0;
+}
+
+function writeTranscript(
+    slot: Slot,
+    variants: Record<string, Variant>,
+    ts: string,
+    overhead: number | null,
+    variantNames: string[],
+    mode: string,
+): void {
+    const prefix = mode === 'l6' ? 'l6n-' : '';
+    const p = path.join(GT_DIR, `${prefix}${slot.n}-${slot.slug}.md`);
+    const L: string[] = [
+        `# Transcript — slot ${slot.n}: ${slot.slug}`,
+        '',
+        `- **Band:** ${slot.band}${slot.mechanism ? ` · **Mechanism:** ${slot.mechanism}` : ''}`,
+        `- **Captured:** ${ts} (controlled system-prompt differential; rater 2 = model scorer)`,
+        '',
+        '## Prompt',
+        '',
+        slot.prompt,
+        '',
+    ];
+    for (const variant of variantNames) {
+        const v = variants[variant];
+        if (v === undefined) continue;
+        const sc = v.score ? ` · rater2 ${JSON.stringify(v.score)}` : '';
+        L.push(
+            `## Transcript — ${variant} (${v.model})`,
+            '',
+            '~~~text',
+            v.text.trimEnd(),
+            '~~~',
+            '',
+            `**Tokens:** in ${v.input_tokens} / out ${v.output_tokens} / est $${v.cost_usd}${sc}`,
+            '',
+        );
+    }
+    if (overhead !== null) {
+        L.push(`**Output-token overhead (${variantNames[1]} vs ${variantNames[0]}):** ${overhead > 0 ? '+' : ''}${overhead}%`, '');
+    }
+    fs.writeFileSync(p, L.join('\n'), 'utf-8');
+}
+
+main().then(
+    (code) => process.exit(code),
+    (err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    },
+);