@event4u/agent-config 14.21.0 → 14.23.0

package/src/scripts/rdp_candidates_delta.ts

@@ -0,0 +1,276 @@
+#!/usr/bin/env tsx
+/**
+ * rdp_candidates_delta.ts — step 3.2's two numbers, computed from the two
+ * stored runs rather than asserted.
+ *
+ * Reads a baseline results file and a treatment results file in the envelope
+ * `rdp_quality_eval` writes, joins them on slot plus variant name, and prints:
+ *
+ *   - the dim-5 delta, INTENTION-TO-TREAT: every treatment transcript against
+ *     every baseline transcript on the same 16 slots. This is the primary
+ *     reading, and it is primary on the 2026-09-08 council's instruction:
+ *     conditioning on whether the model complied selects treatment outputs on
+ *     post-treatment behaviour and biases the estimate. The compliance-
+ *     conditioned figure is printed too, labelled exploratory.
+ *   - the dim-1 reading on both arms. Dim 1 is the notes-first tripwire: dim 5
+ *     rising while dim 1 falls means the line is being emitted into the reply
+ *     instead of the notes, which is the third outcome step 3.3 must name
+ *     rather than round away.
+ *   - the output-token delta on the single-step (`ss`) slots, which are this
+ *     corpus's trivial-task proxy and therefore where the published ~5 %
+ *     L10 cost guard (`tests/reasoning-layer-eval/README.md` § Fail
+ *     conditions) applies.
+ *
+ * A NOTE ON WHICH OVERHEAD THIS IS, because the corpus carries two and they
+ * are not the same number. `output_token_overhead_pct` stored in each run is
+ * arm-versus-arm WITHIN that run (orchestrated vs distributed). What step 3.2
+ * asks for is treatment-versus-baseline, which no stored field holds, so it is
+ * computed here from raw `output_tokens` on both sides.
+ *
+ * Exit: 0 printed · 1 usage/IO error · 2 a join hole (a slot or variant present
+ * on one side and not the other — a delta over a partial join is not a delta).
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { checkReport } from './check_candidate_lines.js';
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+interface Variant {
+    text?: string;
+    output_tokens?: number;
+    score?: Record<string, unknown>;
+}
+
+export interface SlotRecord {
+    slot: string;
+    slug?: string;
+    mechanism?: string;
+    variants?: Record<string, Variant>;
+}
+
+/** Exported so a test can build a synthetic run without widening to `unknown`. */
+export interface Run {
+    date?: string;
+    mode?: string;
+    scorer_model?: string | null;
+    actual_cost_usd?: number;
+    results?: SlotRecord[];
+}
+
+export interface Cell {
+    slot: string;
+    slug: string;
+    family: 'ms' | 'ss';
+    variant: string;
+    dim1: number | null;
+    dim5: number | null;
+    outputTokens: number | null;
+    /** Treatment side only: did the transcript actually carry a clean line? */
+    complied: boolean;
+}
+
+function familyOf(r: SlotRecord): 'ms' | 'ss' {
+    if (r.mechanism === 'stateless') return 'ss';
+    if (r.mechanism === 'multi-stage') return 'ms';
+    return (r.slug ?? '').startsWith('ss-') ? 'ss' : 'ms';
+}
+
+function num(v: unknown): number | null {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+}
+
+export function flatten(run: Run, measureCompliance: boolean): Cell[] {
+    const out: Cell[] = [];
+    for (const r of run.results ?? []) {
+        for (const [variant, v] of Object.entries(r.variants ?? {})) {
+            let complied = false;
+            if (measureCompliance && typeof v.text === 'string' && v.text !== '') {
+                const verdict = checkReport(v.text);
+                complied = verdict.lines.length > 0 && verdict.findings.length === 0;
+            }
+            out.push({
+                slot: r.slot,
+                slug: r.slug ?? '',
+                family: familyOf(r),
+                variant,
+                dim1: num(v.score?.dim1),
+                dim5: num(v.score?.dim5),
+                outputTokens: num(v.output_tokens),
+                complied,
+            });
+        }
+    }
+    return out;
+}
+
+const mean = (xs: number[]): number | null =>
+    xs.length === 0 ? null : Math.round((xs.reduce((p, c) => p + c, 0) / xs.length) * 1000) / 1000;
+
+const fmt = (x: number | null, digits = 3): string => (x === null ? 'n/a' : x.toFixed(digits));
+
+export interface Report {
+    lines: string[];
+    joinHoles: string[];
+}
+
+export function compare(base: Run, treat: Run): Report {
+    const b = flatten(base, false);
+    const t = flatten(treat, true);
+    const key = (c: Cell): string => `${c.slot}/${c.variant}`;
+    const bMap = new Map(b.map((c) => [key(c), c]));
+    const tMap = new Map(t.map((c) => [key(c), c]));
+
+    const joinHoles: string[] = [];
+    for (const k of bMap.keys()) if (!tMap.has(k)) joinHoles.push(`treatment missing ${k}`);
+    for (const k of tMap.keys()) if (!bMap.has(k)) joinHoles.push(`baseline missing ${k}`);
+
+    const paired = [...bMap.keys()].filter((k) => tMap.has(k)).sort();
+    const L: string[] = [];
+
+    L.push(`baseline:  ${base.mode ?? '?'} · ${String((base.results ?? []).length)} slot(s) · rater ${base.scorer_model ?? '?'}`);
+    L.push(`treatment: ${treat.mode ?? '?'} · ${String((treat.results ?? []).length)} slot(s) · rater ${treat.scorer_model ?? '?'}`);
+    L.push(`paired transcripts: ${String(paired.length)}`);
+    L.push('');
+
+    // ---- dim5, intention-to-treat (primary) ---------------------------------
+    const bDim5 = paired.map((k) => (bMap.get(k) as Cell).dim5).filter((x): x is number => x !== null);
+    const tDim5 = paired.map((k) => (tMap.get(k) as Cell).dim5).filter((x): x is number => x !== null);
+    const bM = mean(bDim5);
+    const tM = mean(tDim5);
+    L.push('dim5 — form-alternative surfacing (INTENTION-TO-TREAT, primary)');
+    L.push(`  baseline  mean ${fmt(bM)} / 3   (${bM === null ? 'n/a' : ((bM / 3) * 100).toFixed(1)} %)  n=${String(bDim5.length)}`);
+    L.push(`  treatment mean ${fmt(tM)} / 3   (${tM === null ? 'n/a' : ((tM / 3) * 100).toFixed(1)} %)  n=${String(tDim5.length)}`);
+    if (bM !== null && tM !== null) {
+        const dPts = Math.round((tM - bM) * 1000) / 1000;
+        const dPp = Math.round(((tM - bM) / 3) * 1000) / 10;
+        L.push(`  delta          ${dPts > 0 ? '+' : ''}${fmt(dPts)} / 3   (${dPp > 0 ? '+' : ''}${dPp.toFixed(1)} pp of the 0-3 scale)`);
+    }
+    const bZero = bDim5.filter((x) => x === 0).length;
+    const tZero = tDim5.filter((x) => x === 0).length;
+    L.push(`  scoring 0 (one form only): baseline ${String(bZero)}/${String(bDim5.length)} → treatment ${String(tZero)}/${String(tDim5.length)}`);
+    const bTop = bDim5.filter((x) => x >= 2).length;
+    const tTop = tDim5.filter((x) => x >= 2).length;
+    L.push(`  scoring >= 2:              baseline ${String(bTop)}/${String(bDim5.length)} → treatment ${String(tTop)}/${String(tDim5.length)}`);
+    L.push('');
+
+    // ---- dim1, the tripwire -------------------------------------------------
+    const bDim1 = paired.map((k) => (bMap.get(k) as Cell).dim1).filter((x): x is number => x !== null);
+    const tDim1 = paired.map((k) => (tMap.get(k) as Cell).dim1).filter((x): x is number => x !== null);
+    const b1 = mean(bDim1);
+    const t1 = mean(tDim1);
+    L.push('dim1 — notes-first adherence (TRIPWIRE: dim5 up while dim1 down = the line is in the reply)');
+    L.push(`  baseline  mean ${fmt(b1)} / 3    treatment mean ${fmt(t1)} / 3` +
+        (b1 !== null && t1 !== null ? `    delta ${t1 - b1 > 0 ? '+' : ''}${fmt(Math.round((t1 - b1) * 1000) / 1000)}` : ''));
+    L.push('');
+
+    // ---- compliance (exploratory) ------------------------------------------
+    const complied = paired.filter((k) => (tMap.get(k) as Cell).complied);
+    L.push('compliance — a well-formed Candidates line, zero shape findings');
+    L.push(`  ${String(complied.length)} / ${String(paired.length)} treatment transcript(s)` +
+        ` (${paired.length === 0 ? 'n/a' : ((complied.length / paired.length) * 100).toFixed(1)} %)`);
+    const cDim5 = complied.map((k) => (tMap.get(k) as Cell).dim5).filter((x): x is number => x !== null);
+    const cM = mean(cDim5);
+    L.push(`  dim5 among compliant: ${fmt(cM)} / 3  n=${String(cDim5.length)}   [EXPLORATORY — conditioning on`);
+    L.push('    post-treatment behaviour biases the estimate; the ITT figure above is primary]');
+    L.push('');
+
+    // ---- per family ---------------------------------------------------------
+    L.push('dim5 by family');
+    for (const fam of ['ms', 'ss'] as const) {
+        const ks = paired.filter((k) => (bMap.get(k) as Cell).family === fam);
+        const bf = mean(ks.map((k) => (bMap.get(k) as Cell).dim5).filter((x): x is number => x !== null));
+        const tf = mean(ks.map((k) => (tMap.get(k) as Cell).dim5).filter((x): x is number => x !== null));
+        L.push(`  ${fam}: baseline ${fmt(bf)} → treatment ${fmt(tf)}` +
+            (bf !== null && tf !== null ? `   delta ${tf - bf > 0 ? '+' : ''}${fmt(Math.round((tf - bf) * 1000) / 1000)}` : '') +
+            `   n=${String(ks.length)}`);
+    }
+    L.push('');
+
+    // ---- ss output-token overhead, treatment vs baseline -------------------
+    L.push('output-token overhead on the ss (single-step) slots — treatment vs baseline');
+    L.push('  the L10 cost guard is ~5 % on the trivial proxy (README.md § Fail conditions)');
+    const ssKeys = paired.filter((k) => (bMap.get(k) as Cell).family === 'ss');
+    const perSlot: number[] = [];
+    for (const k of ssKeys) {
+        const bo = (bMap.get(k) as Cell).outputTokens;
+        const to = (tMap.get(k) as Cell).outputTokens;
+        if (bo === null || to === null || bo === 0) continue;
+        const pct = Math.round(((to - bo) / bo) * 1000) / 10;
+        perSlot.push(pct);
+        L.push(`    ${k.padEnd(18)} ${String(bo).padStart(5)} → ${String(to).padStart(5)}  ${pct > 0 ? '+' : ''}${pct.toFixed(1)} %`);
+    }
+    const ssMean = mean(perSlot);
+    L.push(`  mean per-slot overhead: ${ssMean === null ? 'n/a' : `${ssMean > 0 ? '+' : ''}${ssMean.toFixed(1)} %`}  n=${String(perSlot.length)}`);
+    // Aggregate too: a mean of per-slot percentages is dominated by small
+    // denominators, so the token-weighted figure is printed beside it rather
+    // than instead of it.
+    const bTot = ssKeys.reduce((p, k) => p + ((bMap.get(k) as Cell).outputTokens ?? 0), 0);
+    const tTot = ssKeys.reduce((p, k) => p + ((tMap.get(k) as Cell).outputTokens ?? 0), 0);
+    if (bTot > 0) {
+        const agg = Math.round(((tTot - bTot) / bTot) * 1000) / 10;
+        L.push(`  token-weighted overhead: ${agg > 0 ? '+' : ''}${agg.toFixed(1)} %  (${String(bTot)} → ${String(tTot)} output tokens)`);
+    }
+
+    return { lines: L, joinHoles };
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    const bIdx = argv.indexOf('--baseline');
+    const tIdx = argv.indexOf('--treatment');
+    const bPath = bIdx === -1 ? undefined : argv[bIdx + 1];
+    const tPath = tIdx === -1 ? undefined : argv[tIdx + 1];
+    if (bPath === undefined || tPath === undefined) {
+        process.stderr.write('usage: rdp_candidates_delta --baseline <results.json> --treatment <results.json>\n');
+        return 1;
+    }
+    let base: Run;
+    let treat: Run;
+    try {
+        base = JSON.parse(fs.readFileSync(path.resolve(bPath), 'utf-8')) as Run;
+        treat = JSON.parse(fs.readFileSync(path.resolve(tPath), 'utf-8')) as Run;
+    } catch (e) {
+        process.stderr.write(`cannot read inputs: ${String(e)}\n`);
+        return 1;
+    }
+
+    const rep = compare(base, treat);
+    process.stdout.write(`${rep.lines.join('\n')}\n`);
+
+    const paired = rep.lines.find((l) => l.startsWith('paired transcripts:'));
+    const n = paired ? Number(paired.split(':')[1]) : 0;
+    try {
+        assertScanned({
+            gate: 'rdp_candidates_delta',
+            scanned: n,
+            units: 'paired transcript(s)',
+            roots: [bPath, tPath],
+        });
+    } catch (e) {
+        if (e instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${e.message}\n`);
+            return 1;
+        }
+        throw e;
+    }
+
+    if (rep.joinHoles.length > 0) {
+        process.stderr.write(`\n❌  ${String(rep.joinHoles.length)} join hole(s) — a delta over a partial join is not a delta:\n`);
+        for (const h of rep.joinHoles) process.stderr.write(`    ${h}\n`);
+        return 2;
+    }
+    process.stdout.write(`\nscanned: ${String(n)}\n`);
+    return 0;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+    process.exit(main());
+}
+
+export { REPO_ROOT };

package/src/scripts/rdp_quality_eval.ts

@@ -108,6 +108,50 @@ 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.`;
 
+/**
+ * The candidate-forms treatment, appended to EVERY arm by `--candidates`.
+ *
+ * Step 3.1 of `road-to-candidate-moves-floor`. The 2026-09-07 split council
+ * authorised instructing this line to the model under test in the treatment
+ * arm, "where it can be measured without being a shipped obligation on
+ * anyone", and blocked the shipped form. So it lives here, in the eval's own
+ * system prompt, and nowhere in `src/rules/` or `mandated-lines.md`.
+ *
+ * Appended to BOTH l6 arms rather than becoming a third arm, because the
+ * corpus has no per-slot field for a treatment and the baseline this must be
+ * compared against is the 32 stored transcripts — 16 slots × the same two RDP
+ * framings. Appending to both keeps the candidates block the single variable.
+ *
+ * The grammar is the one `check_candidate_lines.ts` parses, so compliance is
+ * measurable rather than eyeballed.
+ */
+const CANDIDATES_BLOCK = `## Candidate forms before the choice
+
+Before you settle on HOW to solve this, generate the candidate solution FORMS
+and emit one line naming them. Do this at the decision point, before the
+answer — not as a trailing summary.
+
+Emit exactly one line in this shape:
+
+  Candidates: K0 <keep the current form / change nothing> · A <form> [<the axis
+  it differs on>] · B <form> [<axis>] → <chosen id>; <the observation that
+  decided it>
+
+Rules:
+- \`K0\` is "keep the current form / change nothing". It is listed FIRST and it
+  is a real option — draw it when it is right.
+- Each non-K0 candidate carries, in brackets, the AXIS it differs on. Three
+  candidates that differ only in where a helper lives are one candidate.
+- The axes must be pairwise distinct.
+- End with the choice and the OBSERVATION that decided between them — not a
+  preference.
+- Where exactly one form is admissible (a framework fixes the extension point,
+  an existing contract fixes the location), emit a single candidate carrying
+  \`[forced: <the constraint>]\` and say what it forecloses. Never invent a
+  second form so the line looks full.
+- On a genuinely trivial or fully-specified task, this line is not owed. Do not
+  emit it to prove you read this.`;
+
 interface Slot {
     n: string;
     slug: string;
@@ -127,18 +171,22 @@ interface Variant {
     score?: Record<string, unknown>;
 }
 
-function buildArms(mode: string): Array<[string, string]> {
+function buildArms(mode: string, candidates = false): 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],
-    ];
+    const arms: Array<[string, string]> =
+        mode === 'l6'
+            ? [
+                  ['distributed', treat],
+                  ['orchestrated', `${treat}\n\n${ORCHESTRATOR_PREAMBLE}`],
+              ]
+            : [
+                  ['baseline', BASE_SYSTEM],
+                  ['treatment', treat],
+              ];
+    if (!candidates) return arms;
+    // Appended to EVERY arm: the candidates block is the single variable
+    // against the stored run, so it must not co-vary with the arm.
+    return arms.map(([name, sys]) => [name, `${sys}\n\n${CANDIDATES_BLOCK}`]);
 }
 
 function approxTokens(text: string): number {
@@ -196,13 +244,20 @@ async function callAnthropic(
 }
 
 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:
+5-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.
+5 form-alternative surfacing — was a materially DIFFERENT SOLUTION FORM generated and discriminated BEFORE the choice, rather than the one form the transcript started with being verified afterwards? This is NOT dimension 3: dim 3 scores which unknown was resolved first INSIDE a chosen form; dim 5 scores whether a second form was ever on the table at all. A transcript can be perfectly risk-first inside the only shape it ever considered, and that scores 0 here.
+  0 = one form only. A single approach appears and everything after it is verification. Good execution does NOT raise this.
+  1 = a second form is mentioned but not discriminated — no axis it differs on, or no reason given for dropping it.
+  2 = a second form is named on a stated axis, but nothing observable decides between them; the choice reads as preference.
+  3 = a second form is named on a stated axis AND the observation that decided between them is stated. "Keep the current form / change nothing" counts as a form.
+  Forced-form carve-out: where exactly one form is admissible (a framework fixes the extension point, an existing contract fixes the location), a transcript that NAMES the constraint foreclosing the alternatives scores 3, not 0.
+  Materially different means differing on an AXIS, not in placement: three options that differ only in where a helper lives are one option.
 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"}`;
+Respond with STRICT JSON only, no prose: {"dim1":N,"dim2":N,"dim3":N,"dim4":N,"dim5":N,"reasoning_extraction_refusal":false,"note":"<=120 chars"}`;
 
 async function scoreTranscript(
     apiKey: string,
@@ -246,11 +301,118 @@ function parseArgs(argv: string[]): Record<string, string | boolean> {
     return a;
 }
 
+/**
+ * Mean over the dimensions the score actually carries.
+ *
+ * `dim5` is scored from 2026-09-07 and the 32 stored L6N transcripts predate
+ * it, so the divisor is the number of dimensions PRESENT, never a constant.
+ * A fixed `/5` would silently deflate every historical mean by a fifth and
+ * make the treatment-minus-baseline delta this eval exists to compute read as
+ * an improvement that is really an arithmetic artefact.
+ */
 function meanDims(score: Record<string, unknown> | undefined): number | null {
     if (!score) return null;
-    const ds = ['dim1', 'dim2', 'dim3', 'dim4'].map((k) => Number(score[k]));
+    const required = ['dim1', 'dim2', 'dim3', 'dim4'];
+    const ds = required.map((k) => Number(score[k]));
     if (ds.some((x) => Number.isNaN(x))) return null;
-    return ds.reduce((p, c) => p + c, 0) / 4;
+    if (score.dim5 !== undefined && !Number.isNaN(Number(score.dim5))) ds.push(Number(score.dim5));
+    return ds.reduce((p, c) => p + c, 0) / ds.length;
+}
+
+/** One stored run: the envelope `--score-only` reads and writes back. */
+interface StoredRun {
+    date?: string;
+    mode?: string;
+    scorer_model?: string | null;
+    results: Array<{
+        slot: string;
+        slug?: string;
+        band?: string;
+        prompt: string;
+        variants: Record<string, { text?: string; score?: Record<string, unknown> }>;
+    }>;
+}
+
+/**
+ * Re-score an existing results file with a rater, capturing nothing.
+ *
+ * The transcripts are read from disk and sent to the scorer; no assistant call
+ * is made, so the only spend is the rater. Every score the run already carried
+ * is REPLACED rather than merged: a half-updated score object where `dim5` came
+ * from one rater and `dim1`-`dim4` from another is not a reading of anything.
+ */
+async function scoreOnly(
+    sourcePath: string,
+    scorerModel: string,
+    outPath: string,
+    confirm: boolean,
+): Promise<number> {
+    if (!fs.existsSync(sourcePath)) {
+        process.stderr.write(`❌  --score-only: no such results file: ${sourcePath}\n`);
+        return 2;
+    }
+    const run = JSON.parse(fs.readFileSync(sourcePath, 'utf-8')) as StoredRun;
+    const transcripts: Array<{ slot: string; variant: string; prompt: string; text: string }> = [];
+    for (const r of run.results ?? []) {
+        for (const [variant, v] of Object.entries(r.variants ?? {})) {
+            if (typeof v.text === 'string' && v.text.length > 0) {
+                transcripts.push({ slot: r.slot, variant, prompt: r.prompt, text: v.text });
+            }
+        }
+    }
+    if (transcripts.length === 0) {
+        // Not "scored zero and passed" — an empty corpus is unreadable input.
+        process.stderr.write(
+            `❌  --score-only: ${sourcePath} carries no transcript text. ` +
+                `A re-score over nothing is not a baseline.\n`,
+        );
+        return 2;
+    }
+
+    const est = estimate_cost(scorerModel, 2000, 300) * transcripts.length;
+    out(
+        `rdp-eval · mode=score-only · ${String(transcripts.length)} stored transcript(s) ` +
+            `from ${sourcePath} · rater ${scorerModel} · 0 capture calls`,
+    );
+    out(`  EXPECTED TOTAL (worst-case): ~$${est.toFixed(4)}`);
+    if (!confirm) {
+        out('\nDRY-RUN — no spend. Re-run with --confirm to score.');
+        return 0;
+    }
+    // Score-only skips CAPTURE, not spend — the rater is billed per transcript.
+    // It therefore inherits the capture path's non-tty guard verbatim rather
+    // than becoming the unguarded way to bill the same account.
+    if (!process.stdin.isTTY && process.env.RDP_EVAL_ALLOW_NONTTY !== '1') {
+        throw new Error(
+            'Refusing a billable score-only 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();
+    let actual = 0;
+    let failed = 0;
+    for (const t of transcripts) {
+        console.error(`     scoring ${t.slot}/${t.variant} via ${scorerModel} …`);
+        const sc = await scoreTranscript(apiKey, scorerModel, t.prompt, t.text);
+        actual += estimate_cost(scorerModel, 2000, 300);
+        const target = run.results.find((r) => r.slot === t.slot)?.variants[t.variant];
+        if (target) {
+            // An unparsable reply DELETES the stale score rather than keeping
+            // it: a score from the previous rater sitting under this run's
+            // `scorer_model` would misattribute the reading.
+            if (sc === null) delete target.score;
+            else target.score = sc;
+        }
+        if (sc === null) failed += 1;
+    }
+    run.scorer_model = scorerModel;
+    run.mode = `${run.mode ?? 'unknown'}+score-only`;
+    fs.writeFileSync(outPath, `${JSON.stringify(run, null, 2)}\n`);
+    out(`\nscanned: ${String(transcripts.length)}`);
+    out(`rdp-eval · wrote ${outPath} · ~$${actual.toFixed(4)} · ${String(failed)} unparsable`);
+    // An unparsable rater reply is a hole in the reading, not a rounding error.
+    return failed > 0 ? 1 : 0;
 }
 
 async function main(): Promise<number> {
@@ -268,9 +430,29 @@ async function main(): Promise<number> {
         (args.results as string) ??
         path.join(GT_DIR, mode === 'l6' ? 'l6-results.json' : 'results.json');
 
+    // ---- score-only: re-score transcripts that already exist -----------------
+    // A stored results file IS the baseline arm for a dimension added after it
+    // was captured. Re-scoring it costs the scorer calls and NOTHING for
+    // capture, which is the only way a baseline for `dim5` can exist at all:
+    // the 32 L6N transcripts predate the dimension, and re-capturing them would
+    // produce a *different* baseline under today's suite rather than the one
+    // the treatment must be compared against.
+    if (args['score-only']) {
+        const scoreOnlyPath = String(args['score-only']);
+        if (!scoreWith) {
+            process.stderr.write('❌  --score-only requires --score-with <model> (the rater).\n');
+            return 2;
+        }
+        return await scoreOnly(scoreOnlyPath, scoreWith, resultsPath, Boolean(args.confirm));
+    }
+
+    const withCandidates = Boolean(args.candidates);
     const slots = loadSlots(corpusPath, selected);
-    const arms = buildArms(mode);
+    const arms = buildArms(mode, withCandidates);
     const variantNames = arms.map((a) => a[0]);
+    if (withCandidates) {
+        out('  treatment: +CANDIDATES_BLOCK on every arm (step 3.1 — instructed, not shipped)');
+    }
 
     // ---- cost preview --------------------------------------------------------
     let total = 0;
@@ -361,7 +543,7 @@ async function main(): Promise<number> {
             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);
+        writeTranscript(s, variants, ts, overhead, variantNames, mode, withCandidates);
     }
 
     fs.writeFileSync(
@@ -369,7 +551,9 @@ async function main(): Promise<number> {
         JSON.stringify(
             {
                 date: ts,
-                mode,
+                // Self-describing: a results file whose arms carried the
+                // candidates block must not be readable as a plain l6 run.
+                mode: withCandidates ? `${mode}+candidates` : mode,
                 standard_model: standardModel,
                 strong_model: strongModel,
                 scorer_model: scoreWith ?? null,
@@ -386,6 +570,18 @@ async function main(): Promise<number> {
     return 0;
 }
 
+/**
+ * The transcript filename is keyed on the MODE, so a run under a different
+ * treatment must not reuse it.
+ *
+ * Found the hard way on 2026-09-08: `--candidates` reused the plain `l6n-`
+ * prefix and silently overwrote all 16 committed June baseline transcripts
+ * mid-run. The measurement survived — `--results` had been pointed at a new
+ * path and every transcript body is stored in that JSON — but the baseline's
+ * human-readable artefacts were replaced by treatment ones under the baseline's
+ * own names, which is the worst kind of quiet: a later reader comparing the
+ * markdown would have compared the treatment against itself.
+ */
 function writeTranscript(
     slot: Slot,
     variants: Record<string, Variant>,
@@ -393,8 +589,10 @@ function writeTranscript(
     overhead: number | null,
     variantNames: string[],
     mode: string,
+    withCandidates = false,
 ): void {
-    const prefix = mode === 'l6' ? 'l6n-' : '';
+    const base = mode === 'l6' ? 'l6n-' : '';
+    const prefix = withCandidates ? `${base}cand-` : base;
     const p = path.join(GT_DIR, `${prefix}${slot.n}-${slot.slug}.md`);
     const L: string[] = [
         `# Transcript — slot ${slot.n}: ${slot.slug}`,

package/src/scripts/release_mix_taxonomy.json

@@ -1,6 +1,6 @@
 {
-  "taxonomy_version": "1.0.0",
-  "updated": "2026-09-04",
+  "taxonomy_version": "1.1.0",
+  "updated": "2026-09-08",
   "contract": "docs/decisions/ADR-253-per-pr-user-artifact-gate-declined.md",
   "reader": "src/scripts/measure_release_mix.ts",
   "note": [
@@ -62,6 +62,7 @@
     { "prefix": "src/install/", "category": "consumer" },
     { "prefix": "src/server/", "category": "consumer" },
     { "prefix": "src/ui/", "category": "consumer" },
+    { "prefix": "src/vendor/grammars/", "category": "consumer" },
     { "prefix": "src/shared/", "category": "unclassified" },
 
     { "prefix": "src/scripts/", "category": "maintenance" },