@tangle-network/browser-agent-driver 0.33.3 → 0.34.0

package/dist/design/audit/reference/judge/pairwise.js

@@ -0,0 +1,105 @@
+/**
+ * Position-swapped pairwise debias — the core that cancels slot bias.
+ *
+ * A single judge call is contaminated by position bias: models systematically
+ * over-prefer whichever design sits in slot A. `judgePair` neutralises it by
+ * running BOTH slot orders through the INJECTED `TasteJudge` (A-vs-B and
+ * B-vs-A) and reconciling. The model call is the only impure part and it is
+ * injected, so `reconcileVerdicts` — where all the debias logic lives — is fully
+ * pure and unit-tests with stub verdicts and zero live model.
+ *
+ * Reconciliation rule (measures taste, not slot):
+ *  - both orders pick the SAME id  ⇒ that id wins (margin = mean confidence)
+ *  - the preferred id FLIPS with the slot ⇒ pure position bias ⇒ tie
+ *  - only one order separates them ⇒ a low-confidence win (margin halved)
+ *  - both orders tie ⇒ tie
+ *
+ * `swapped` re-labels the subjects (a↔b) while preserving `dimension`,
+ * `reference`, and `rubricBody`, so the judge sees the same comparison from the
+ * other side — the second call is a genuine slot swap, not a different question.
+ */
+const round4 = (n) => Math.round(n * 10000) / 10000;
+const clamp01 = (n) => (n < 0 ? 0 : n > 1 ? 1 : n);
+function slotToId(slot, idForSlotA, idForSlotB) {
+    if (slot === 'A')
+        return idForSlotA;
+    if (slot === 'B')
+        return idForSlotB;
+    return 'tie';
+}
+function mergeReasons(...lists) {
+    const out = [];
+    for (const list of lists) {
+        for (const r of list)
+            if (!out.includes(r))
+                out.push(r);
+    }
+    return out;
+}
+/**
+ * Reconcile the two slot-order verdicts into a stable, id-keyed `TasteVerdict`.
+ * Pure: no IO, no model. `ab` presented a→SLOT A, b→SLOT B; `ba` presented
+ * b→SLOT A, a→SLOT B.
+ */
+export function reconcileVerdicts(ab, ba, aId, bId) {
+    const w1 = slotToId(ab.winnerSlot, aId, bId);
+    const w2 = slotToId(ba.winnerSlot, bId, aId);
+    const reasons = mergeReasons(ab.reasons, ba.reasons);
+    if (w1 === 'tie' && w2 === 'tie') {
+        return { aId, bId, winner: 'tie', margin: 0, reasons };
+    }
+    if (w1 !== 'tie' && w2 !== 'tie') {
+        if (w1 === w2) {
+            const margin = clamp01(round4((ab.confidence + ba.confidence) / 2));
+            return { aId, bId, winner: w1, margin, reasons };
+        }
+        // The preferred id flipped with the slot ⇒ the signal is position, not taste.
+        return {
+            aId,
+            bId,
+            winner: 'tie',
+            margin: 0,
+            reasons: mergeReasons(reasons, [
+                'position bias: preferred slot flipped across orders; collapsed to tie',
+            ]),
+        };
+    }
+    // Exactly one order expressed a preference; the other could not separate them.
+    // Honour the uncontradicted signal but at halved confidence.
+    const decided = w1 !== 'tie' ? w1 : w2;
+    const conf = w1 !== 'tie' ? ab.confidence : ba.confidence;
+    return { aId, bId, winner: decided, margin: clamp01(round4(conf / 2)), reasons };
+}
+/**
+ * Run a single comparison through both slot orders (× `reps`) and reconcile to a
+ * position-debiased `TasteVerdict`. The `TasteJudge` is injected, so this is the
+ * only impure boundary; all aggregation is deterministic.
+ */
+export async function judgePair(judge, input, reps = 1) {
+    const aId = input.a.id;
+    const bId = input.b.id;
+    const swapped = { ...input, a: input.b, b: input.a };
+    const effReps = Math.max(1, Math.floor(reps));
+    let scoreA = 0;
+    let scoreB = 0;
+    const reasons = [];
+    for (let i = 0; i < effReps; i++) {
+        const ab = await judge.compare(input);
+        const ba = await judge.compare(swapped);
+        const v = reconcileVerdicts(ab, ba, aId, bId);
+        if (v.winner === aId)
+            scoreA += v.margin;
+        else if (v.winner === bId)
+            scoreB += v.margin;
+        for (const r of v.reasons)
+            if (!reasons.includes(r))
+                reasons.push(r);
+    }
+    const net = (scoreA - scoreB) / effReps;
+    if (net > 1e-9)
+        return { aId, bId, winner: aId, margin: clamp01(round4(net)), reasons };
+    if (net < -1e-9)
+        return { aId, bId, winner: bId, margin: clamp01(round4(-net)), reasons };
+    return { aId, bId, winner: 'tie', margin: 0, reasons };
+}
+//# sourceMappingURL=pairwise.js.map

package/dist/design/audit/reference/judge/pairwise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairwise.js","sourceRoot":"","sources":["../../../../../src/design/audit/reference/judge/pairwise.ts"],"names":[],"mappings":"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"}

package/dist/design/audit/reference/judge/parse.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Judge-response parsing — the PURE parse core. Turns one model response into a
+ * slot-relative `RawVerdict`. Fail-closed by contract: any unparseable or
+ * winner-less response collapses to a `tie` with confidence 0 and an explicit
+ * reason, never a fabricated A/B verdict. Slot bias is only neutralisable if a
+ * garbage response counts as "no signal", so this NEVER guesses a winner.
+ *
+ * It is deliberately tolerant of the noise real gateways add (markdown fences,
+ * prose preambles around the object) — mirroring `brain.parse` — but it is
+ * strict about the one field that matters: the winner must be an unambiguous
+ * A / B / tie token, or the verdict is a tie.
+ */
+import type { RawVerdict } from '../contracts.js';
+/**
+ * STRICT parse: return a `RawVerdict` ONLY when the response carries an
+ * unambiguous winner token, else `null` ("no usable verdict"). This is the
+ * single source of truth for the happy path; both consumers build on it:
+ *  - the text judge wraps it with a fail-closed tie (see `parseRawVerdict`), so a
+ *    garbage single-model response is treated as "no signal" and the outer
+ *    position-swap can cancel it;
+ *  - the vision ENSEMBLE judge uses the `null` to DROP a non-responding model
+ *    (exclude it from the majority tally + denominator), rather than diluting the
+ *    agreement fraction with a phantom tie vote.
+ */
+export declare function parseVerdictOrNull(raw: string): RawVerdict | null;
+/**
+ * Parse a judge response into a slot-relative `RawVerdict`. Garbage in →
+ * `{ winnerSlot: 'tie', confidence: 0, reasons: [<why>] }`.
+ */
+export declare function parseRawVerdict(raw: string): RawVerdict;
+//# sourceMappingURL=parse.d.ts.map

package/dist/design/audit/reference/judge/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../src/design/audit/reference/judge/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AA2DjD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAUjE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAWvD"}

package/dist/design/audit/reference/judge/parse.js

@@ -0,0 +1,113 @@
+/**
+ * Judge-response parsing — the PURE parse core. Turns one model response into a
+ * slot-relative `RawVerdict`. Fail-closed by contract: any unparseable or
+ * winner-less response collapses to a `tie` with confidence 0 and an explicit
+ * reason, never a fabricated A/B verdict. Slot bias is only neutralisable if a
+ * garbage response counts as "no signal", so this NEVER guesses a winner.
+ *
+ * It is deliberately tolerant of the noise real gateways add (markdown fences,
+ * prose preambles around the object) — mirroring `brain.parse` — but it is
+ * strict about the one field that matters: the winner must be an unambiguous
+ * A / B / tie token, or the verdict is a tie.
+ */
+const DEFAULT_CONFIDENCE = 0.5;
+function stripFences(raw) {
+    let t = raw.trim();
+    if (t.startsWith('```')) {
+        t = t
+            .replace(/^```(?:json)?\s*/i, '')
+            .replace(/```$/i, '')
+            .trim();
+    }
+    return t;
+}
+function extractObject(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        // Some gateways wrap the object in prose ("Here's the verdict: {…}"); fall
+        // back to the outermost brace pair before giving up.
+        const first = text.indexOf('{');
+        const last = text.lastIndexOf('}');
+        if (first >= 0 && last > first) {
+            try {
+                return JSON.parse(text.slice(first, last + 1));
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+}
+function normalizeWinner(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const w = raw.trim().toUpperCase();
+    if (w === 'A')
+        return 'A';
+    if (w === 'B')
+        return 'B';
+    if (w === 'TIE' || w === 'DRAW' || w === 'EQUAL' || w === 'NEITHER' || w === 'NONE')
+        return 'tie';
+    return null;
+}
+function normalizeConfidence(raw) {
+    const n = typeof raw === 'number' ? raw : typeof raw === 'string' ? parseFloat(raw) : NaN;
+    if (!Number.isFinite(n))
+        return DEFAULT_CONFIDENCE;
+    return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+function normalizeReasons(raw) {
+    if (Array.isArray(raw)) {
+        return raw
+            .filter((r) => typeof r === 'string' && r.trim().length > 0)
+            .map((r) => r.trim());
+    }
+    if (typeof raw === 'string' && raw.trim().length > 0)
+        return [raw.trim()];
+    return [];
+}
+/**
+ * STRICT parse: return a `RawVerdict` ONLY when the response carries an
+ * unambiguous winner token, else `null` ("no usable verdict"). This is the
+ * single source of truth for the happy path; both consumers build on it:
+ *  - the text judge wraps it with a fail-closed tie (see `parseRawVerdict`), so a
+ *    garbage single-model response is treated as "no signal" and the outer
+ *    position-swap can cancel it;
+ *  - the vision ENSEMBLE judge uses the `null` to DROP a non-responding model
+ *    (exclude it from the majority tally + denominator), rather than diluting the
+ *    agreement fraction with a phantom tie vote.
+ */
+export function parseVerdictOrNull(raw) {
+    const obj = extractObject(stripFences(raw));
+    if (!obj)
+        return null;
+    const winnerSlot = normalizeWinner(obj.winner ?? obj.winnerSlot ?? obj.choice);
+    if (!winnerSlot)
+        return null;
+    return {
+        winnerSlot,
+        confidence: normalizeConfidence(obj.confidence),
+        reasons: normalizeReasons(obj.reasons ?? obj.reason),
+    };
+}
+/**
+ * Parse a judge response into a slot-relative `RawVerdict`. Garbage in →
+ * `{ winnerSlot: 'tie', confidence: 0, reasons: [<why>] }`.
+ */
+export function parseRawVerdict(raw) {
+    const verdict = parseVerdictOrNull(raw);
+    if (verdict)
+        return verdict;
+    // No usable winner ⇒ fail closed to a tie, preserving the specific reason: an
+    // object with no valid winner vs. a response with no object at all.
+    const hasObject = extractObject(stripFences(raw)) !== null;
+    return {
+        winnerSlot: 'tie',
+        confidence: 0,
+        reasons: [hasObject ? 'judge response missing a valid winner' : 'unparseable judge response'],
+    };
+}
+//# sourceMappingURL=parse.js.map

package/dist/design/audit/reference/judge/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../../../../src/design/audit/reference/judge/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,MAAM,kBAAkB,GAAG,GAAG,CAAA;AAE9B,SAAS,WAAW,CAAC,GAAW;IAC9B,IAAI,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,CAAA;IAClB,IAAI,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QACxB,CAAC,GAAG,CAAC;aACF,OAAO,CAAC,mBAAmB,EAAE,EAAE,CAAC;aAChC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;aACpB,IAAI,EAAE,CAAA;IACX,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC;AAED,SAAS,aAAa,CAAC,IAAY;IACjC,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAA4B,CAAA;IACpD,CAAC;IAAC,MAAM,CAAC;QACP,2EAA2E;QAC3E,qDAAqD;QACrD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;QAClC,IAAI,KAAK,IAAI,CAAC,IAAI,IAAI,GAAG,KAAK,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,GAAG,CAAC,CAAC,CAA4B,CAAA;YAC3E,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,IAAI,CAAA;YACb,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAA;IACb,CAAC;AACH,CAAC;AAED,SAAS,eAAe,CAAC,GAAY;IACnC,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IACxC,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAA;IAClC,IAAI,CAAC,KAAK,GAAG;QAAE,OAAO,GAAG,CAAA;IACzB,IAAI,CAAC,KAAK,GAAG;QAAE,OAAO,GAAG,CAAA;IACzB,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,OAAO,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,MAAM;QAAE,OAAO,KAAK,CAAA;IACjG,OAAO,IAAI,CAAA;AACb,CAAC;AAED,SAAS,mBAAmB,CAAC,GAAY;IACvC,MAAM,CAAC,GAAG,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAA;IACzF,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QAAE,OAAO,kBAAkB,CAAA;IAClD,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAClC,CAAC;AAED,SAAS,gBAAgB,CAAC,GAAY;IACpC,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,GAAG;aACP,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;aACxE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAA;IACzB,CAAC;IACD,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAA;IACzE,OAAO,EAAE,CAAA;AACX,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAW;IAC5C,MAAM,GAAG,GAAG,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAA;IAC3C,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAA;IACrB,MAAM,UAAU,GAAG,eAAe,CAAC,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,MAAM,CAAC,CAAA;IAC9E,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IAC5B,OAAO;QACL,UAAU;QACV,UAAU,EAAE,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC;QAC/C,OAAO,EAAE,gBAAgB,CAAC,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,MAAM,CAAC;KACrD,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,GAAW;IACzC,MAAM,OAAO,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAA;IACvC,IAAI,OAAO;QAAE,OAAO,OAAO,CAAA;IAC3B,8EAA8E;IAC9E,oEAAoE;IACpE,MAAM,SAAS,GAAG,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI,CAAA;IAC1D,OAAO;QACL,UAAU,EAAE,KAAK;QACjB,UAAU,EAAE,CAAC;QACb,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,uCAAuC,CAAC,CAAC,CAAC,4BAA4B,CAAC;KAC9F,CAAA;AACH,CAAC"}

package/dist/design/audit/reference/judge/prompt.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Pairwise / absolute-quality judge prompts — the PURE prompt core of the taste
+ * judge. No IO, no LLM, no browser: every output is a deterministic function of
+ * the `JudgePairInput` + the chosen presentation `slot`, so identical inputs
+ * always yield byte-identical prompts (a hard requirement for reproducibility and
+ * for the position-swapped double run to cancel bias rather than introduce it).
+ *
+ * Two builders, one per judging leg:
+ *  - `buildPairwisePrompt` — the RELATIVE leg: two redesign directions judged
+ *    against a named reference (holistic taste/craft/fit).
+ *  - `buildQualityPrompt` — the ABSOLUTE leg: page vs world-class exemplar,
+ *    optionally narrowed to ONE product `Dimension` so the per-dimension win-rate
+ *    is genuinely judge-resolved, never one overall number stamped across dims.
+ *
+ * Both carry an explicit anti-position-bias clause: SLOT A/B order is declared
+ * information-free so the model is told to judge on merit alone. The `slot`
+ * argument decides which logical subject (`input.a` / `input.b`) is physically
+ * rendered as SLOT A — the debias core drives both orders through here.
+ */
+import type { JudgePairInput } from '../contracts.js';
+/** Presentation order: 'AB' renders input.a as SLOT A; 'BA' swaps them. */
+export type Slot = 'AB' | 'BA';
+/**
+ * The RELATIVE leg prompt: two redesign directions judged against a reference.
+ */
+export declare function buildPairwisePrompt(input: JudgePairInput, slot: Slot): {
+    system: string;
+    user: string;
+};
+/**
+ * The ABSOLUTE leg prompt: page vs world-class exemplar, optionally narrowed to
+ * a single product `Dimension`.
+ */
+export declare function buildQualityPrompt(input: JudgePairInput, slot: Slot): {
+    system: string;
+    user: string;
+};
+//# sourceMappingURL=prompt.d.ts.map

package/dist/design/audit/reference/judge/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../../../src/design/audit/reference/judge/prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAA6C,MAAM,iBAAiB,CAAA;AAEhG,2EAA2E;AAC3E,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAqE9B;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAUvG;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAatG"}

package/dist/design/audit/reference/judge/prompt.js

@@ -0,0 +1,111 @@
+/**
+ * Pairwise / absolute-quality judge prompts — the PURE prompt core of the taste
+ * judge. No IO, no LLM, no browser: every output is a deterministic function of
+ * the `JudgePairInput` + the chosen presentation `slot`, so identical inputs
+ * always yield byte-identical prompts (a hard requirement for reproducibility and
+ * for the position-swapped double run to cancel bias rather than introduce it).
+ *
+ * Two builders, one per judging leg:
+ *  - `buildPairwisePrompt` — the RELATIVE leg: two redesign directions judged
+ *    against a named reference (holistic taste/craft/fit).
+ *  - `buildQualityPrompt` — the ABSOLUTE leg: page vs world-class exemplar,
+ *    optionally narrowed to ONE product `Dimension` so the per-dimension win-rate
+ *    is genuinely judge-resolved, never one overall number stamped across dims.
+ *
+ * Both carry an explicit anti-position-bias clause: SLOT A/B order is declared
+ * information-free so the model is told to judge on merit alone. The `slot`
+ * argument decides which logical subject (`input.a` / `input.b`) is physically
+ * rendered as SLOT A — the debias core drives both orders through here.
+ */
+// Plain-language guidance per product-quality dimension, injected only when the
+// absolute leg scopes a comparison to one `Dimension`. Lives here (with the
+// prompt logic) — never in the logic-free contracts hub.
+const DIMENSION_GUIDANCE = {
+    product_intent: 'how clearly and directly the design serves its core job-to-be-done',
+    visual_craft: 'typographic precision, colour discipline, spacing rhythm, and overall polish',
+    trust_clarity: 'legibility, contrast, restraint, and signals of credibility',
+    workflow: 'how efficiently a user can complete the primary task with minimal friction',
+    content_ia: 'information hierarchy, scannability, and content organisation',
+};
+const ANTI_POSITION_BIAS = 'SLOT A and SLOT B are presented in a randomized order that carries NO information. ' +
+    'Do not favour a design because of its slot — judge only on merit.';
+const RESPONSE_CONTRACT = [
+    'Respond with ONLY a JSON object and no surrounding prose:',
+    '{"winner": "A" | "B" | "tie", "confidence": <number 0-1>, "reasons": [<short strings>]}',
+].join('\n');
+function orderedSubjects(input, slot) {
+    return slot === 'AB' ? [input.a, input.b] : [input.b, input.a];
+}
+function renderReference(ref) {
+    if (!ref)
+        return '';
+    return `REFERENCE (${ref.kind}) — judge both designs against this world-class target:\n${ref.summary}`;
+}
+function renderRubric(body) {
+    if (!body)
+        return '';
+    return `SCORING CRITERIA:\n${body}`;
+}
+function renderSubject(label, s) {
+    const lines = [`SLOT ${label} (identity withheld):`];
+    if (s.directionSummary)
+        lines.push(s.directionSummary);
+    lines.push(s.dnaSummary);
+    return lines.join('\n');
+}
+function joinSections(sections) {
+    return sections.filter((s) => s.length > 0).join('\n\n');
+}
+function pairwiseSystem() {
+    return [
+        'You are a world-class art director comparing two redesign directions for the same page against a named reference.',
+        'Pick the direction with stronger taste, craft, information hierarchy, and fit to the reference.',
+        ANTI_POSITION_BIAS,
+        RESPONSE_CONTRACT,
+        'Use "tie" only when the two are genuinely indistinguishable in quality.',
+    ].join('\n');
+}
+function qualitySystem(dimension) {
+    const focus = dimension
+        ? ` Focus ONLY on the "${dimension}" dimension: ${DIMENSION_GUIDANCE[dimension]}.`
+        : '';
+    return [
+        `You are a world-class design critic judging which of two designs is closer to world-class quality.${focus}`,
+        ANTI_POSITION_BIAS,
+        RESPONSE_CONTRACT,
+        'Use "tie" only when the two are genuinely on par.',
+    ].join('\n');
+}
+/**
+ * The RELATIVE leg prompt: two redesign directions judged against a reference.
+ */
+export function buildPairwisePrompt(input, slot) {
+    const [first, second] = orderedSubjects(input, slot);
+    const user = joinSections([
+        renderReference(input.reference),
+        renderRubric(input.rubricBody),
+        renderSubject('A', first),
+        renderSubject('B', second),
+        'Which slot is the stronger redesign direction?',
+    ]);
+    return { system: pairwiseSystem(), user };
+}
+/**
+ * The ABSOLUTE leg prompt: page vs world-class exemplar, optionally narrowed to
+ * a single product `Dimension`.
+ */
+export function buildQualityPrompt(input, slot) {
+    const [first, second] = orderedSubjects(input, slot);
+    const question = input.dimension
+        ? `Which slot better exemplifies world-class "${input.dimension}"?`
+        : 'Which slot is the higher-quality design overall?';
+    const user = joinSections([
+        renderReference(input.reference),
+        renderRubric(input.rubricBody),
+        renderSubject('A', first),
+        renderSubject('B', second),
+        question,
+    ]);
+    return { system: qualitySystem(input.dimension), user };
+}
+//# sourceMappingURL=prompt.js.map

package/dist/design/audit/reference/judge/prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.js","sourceRoot":"","sources":["../../../../../src/design/audit/reference/judge/prompt.ts"],"names":[],"mappings":"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"}

package/dist/design/audit/reference/judge/quality.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Absolute quality assessment — the single honest scoring leg.
+ *
+ * `assessPageQuality` judges the page-under-audit against the retrieved
+ * world-class exemplars with the same position-swapped `judgePair` debias, and
+ * reports the page's win-rate. This — NOT the relative direction ranking — is
+ * what `score-core` turns into the headline 0-10 and the per-`Dimension` scores.
+ *
+ * Overall leg: one debiased comparison per exemplar → `overallWinRate`.
+ * Optional per-dimension leg (`opts.dimensions`): one dimension-scoped
+ * comparison SET per `Dimension`, so each `dimensionWinRates` entry is genuinely
+ * judge-resolved (the judge narrows its rubric to that dimension), never the
+ * overall number stamped across dims. A dimension with no decisive comparison is
+ * OMITTED — callers must not fabricate a per-dim score from `overallWinRate`.
+ *
+ * Pure¹: the `TasteJudge` is injected, so this unit-tests with a stub judge and
+ * no live model. Comparisons run sequentially for deterministic accounting;
+ * concurrency/budget is the orchestrator's concern, not this leg's.
+ */
+import type { Dimension, JudgeSubject, QualityAssessment, TasteJudge } from '../contracts.js';
+/**
+ * Assess the absolute quality of `page` against `exemplars` → a `win-rate`-keyed
+ * `QualityAssessment`.
+ */
+export declare function assessPageQuality(judge: TasteJudge, page: JudgeSubject, exemplars: JudgeSubject[], opts?: {
+    dimensions?: Dimension[];
+}): Promise<QualityAssessment>;
+//# sourceMappingURL=quality.d.ts.map

package/dist/design/audit/reference/judge/quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality.d.ts","sourceRoot":"","sources":["../../../../../src/design/audit/reference/judge/quality.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACX,MAAM,iBAAiB,CAAA;AAgCxB;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,YAAY,EAClB,SAAS,EAAE,YAAY,EAAE,EACzB,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,SAAS,EAAE,CAAA;CAAO,GACtC,OAAO,CAAC,iBAAiB,CAAC,CAoB5B"}

package/dist/design/audit/reference/judge/quality.js

@@ -0,0 +1,62 @@
+/**
+ * Absolute quality assessment — the single honest scoring leg.
+ *
+ * `assessPageQuality` judges the page-under-audit against the retrieved
+ * world-class exemplars with the same position-swapped `judgePair` debias, and
+ * reports the page's win-rate. This — NOT the relative direction ranking — is
+ * what `score-core` turns into the headline 0-10 and the per-`Dimension` scores.
+ *
+ * Overall leg: one debiased comparison per exemplar → `overallWinRate`.
+ * Optional per-dimension leg (`opts.dimensions`): one dimension-scoped
+ * comparison SET per `Dimension`, so each `dimensionWinRates` entry is genuinely
+ * judge-resolved (the judge narrows its rubric to that dimension), never the
+ * overall number stamped across dims. A dimension with no decisive comparison is
+ * OMITTED — callers must not fabricate a per-dim score from `overallWinRate`.
+ *
+ * Pure¹: the `TasteJudge` is injected, so this unit-tests with a stub judge and
+ * no live model. Comparisons run sequentially for deterministic accounting;
+ * concurrency/budget is the orchestrator's concern, not this leg's.
+ */
+import { judgePair } from './pairwise.js';
+const round4 = (n) => Math.round(n * 10000) / 10000;
+/** Neutral rate when no decisive (non-tie) comparison backed a leg. */
+const ON_PAR = 0.5;
+async function pageWinRate(judge, page, exemplars, dimension) {
+    let wins = 0;
+    let comparisons = 0;
+    for (const exemplar of exemplars) {
+        const verdict = await judgePair(judge, { a: page, b: exemplar, dimension });
+        if (verdict.winner === 'tie')
+            continue;
+        comparisons++;
+        if (verdict.winner === page.id)
+            wins++;
+    }
+    return { rate: comparisons > 0 ? round4(wins / comparisons) : ON_PAR, comparisons };
+}
+/**
+ * Assess the absolute quality of `page` against `exemplars` → a `win-rate`-keyed
+ * `QualityAssessment`.
+ */
+export async function assessPageQuality(judge, page, exemplars, opts = {}) {
+    const overall = await pageWinRate(judge, page, exemplars);
+    let dimensionWinRates;
+    const dimensions = opts.dimensions ?? [];
+    if (dimensions.length > 0 && exemplars.length > 0) {
+        const collected = {};
+        for (const dimension of dimensions) {
+            const dim = await pageWinRate(judge, page, exemplars, dimension);
+            // Omit a dimension with no decisive signal rather than stamp a fake rate.
+            if (dim.comparisons > 0)
+                collected[dimension] = dim.rate;
+        }
+        if (Object.keys(collected).length > 0)
+            dimensionWinRates = collected;
+    }
+    return {
+        overallWinRate: overall.rate,
+        dimensionWinRates,
+        comparisons: overall.comparisons,
+    };
+}
+//# sourceMappingURL=quality.js.map

package/dist/design/audit/reference/judge/quality.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality.js","sourceRoot":"","sources":["../../../../../src/design/audit/reference/judge/quality.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAEzC,MAAM,MAAM,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK,CAAA;AAEnE,uEAAuE;AACvE,MAAM,MAAM,GAAG,GAAG,CAAA;AASlB,KAAK,UAAU,WAAW,CACxB,KAAiB,EACjB,IAAkB,EAClB,SAAyB,EACzB,SAAqB;IAErB,IAAI,IAAI,GAAG,CAAC,CAAA;IACZ,IAAI,WAAW,GAAG,CAAC,CAAA;IACnB,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,MAAM,OAAO,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAA;QAC3E,IAAI,OAAO,CAAC,MAAM,KAAK,KAAK;YAAE,SAAQ;QACtC,WAAW,EAAE,CAAA;QACb,IAAI,OAAO,CAAC,MAAM,KAAK,IAAI,CAAC,EAAE;YAAE,IAAI,EAAE,CAAA;IACxC,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,CAAA;AACrF,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,KAAiB,EACjB,IAAkB,EAClB,SAAyB,EACzB,OAAqC,EAAE;IAEvC,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAA;IAEzD,IAAI,iBAAiE,CAAA;IACrE,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,EAAE,CAAA;IACxC,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClD,MAAM,SAAS,GAAuC,EAAE,CAAA;QACxD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,GAAG,GAAG,MAAM,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;YAChE,0EAA0E;YAC1E,IAAI,GAAG,CAAC,WAAW,GAAG,CAAC;gBAAE,SAAS,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,IAAI,CAAA;QAC1D,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,CAAC;YAAE,iBAAiB,GAAG,SAAS,CAAA;IACtE,CAAC;IAED,OAAO;QACL,cAAc,EAAE,OAAO,CAAC,IAAI;QAC5B,iBAAiB;QACjB,WAAW,EAAE,OAAO,CAAC,WAAW;KACjC,CAAA;AACH,CAAC"}

package/dist/design/audit/reference/judge/rank.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Direction ranking — the PURE Bradley-Terry / Elo rollup. Folds many debiased
+ * `TasteVerdict`s into a single `RankResult`. No IO, no model: deterministic for
+ * a fixed verdict set, so `rankDirections` IS the `DirectionRanker`
+ * implementation (`{ rank: rankDirections }` at the wiring root).
+ *
+ * Two complementary solvers, both reported:
+ *  - Bradley-Terry strengths via minorization-maximization (the maximum-
+ *    likelihood stationary ranking; order-independent, sum-normalised).
+ *  - Elo via sequential `updateElo` (cheap, online, conserves total rating).
+ *
+ * The published order is by Bradley-Terry strength, with Elo then id as
+ * deterministic tie-breaks. `calibrateAgainstVotes` scores judge-vs-human
+ * agreement so the taste judge can be validated against ground-truth votes.
+ */
+import type { CalibrationResult, HumanVote, RankResult, TasteVerdict } from '../contracts.js';
+/**
+ * One Elo update for a single game. `outcome` is the score for the FIRST player
+ * (1 win, 0.5 tie, 0 loss). Total rating is conserved (the two deltas cancel),
+ * and the update is symmetric under swapping players + complementing the outcome.
+ */
+export declare function updateElo(ra: number, rb: number, outcome: number, k?: number): [number, number];
+/**
+ * Bradley-Terry strengths per id, sum-normalised. A win counts as one game won;
+ * a tie splits the game half-and-half. Returns `{}` for no verdicts and a
+ * uniform distribution when ids exist but no games were played.
+ */
+export declare function bradleyTerry(verdicts: TasteVerdict[]): Record<string, number>;
+/**
+ * Roll a set of pairwise verdicts up into a ranking. `ids` seeds the population
+ * (so a direction with no verdicts still appears, ranked last). Order is by
+ * Bradley-Terry strength, tie-broken by Elo then id for determinism.
+ */
+export declare function rankDirections(ids: string[], verdicts: TasteVerdict[]): RankResult;
+/**
+ * Judge-vs-human agreement over a set of votes. Ties (on either side) and pairs
+ * the judge never compared are excluded from `n`. Empty → `{ agreement: 0, n: 0 }`,
+ * never NaN.
+ */
+export declare function calibrateAgainstVotes(verdicts: TasteVerdict[], votes: HumanVote[]): CalibrationResult;
+//# sourceMappingURL=rank.d.ts.map

package/dist/design/audit/reference/judge/rank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rank.d.ts","sourceRoot":"","sources":["../../../../../src/design/audit/reference/judge/rank.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAoB7F;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,GAAE,MAAc,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAOtG;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmD7E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,UAAU,CAwDlF;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,iBAAiB,CAerG"}