@bongos/core 1.19.1033 → 1.19.1034

package/tests/grade_engine_replay.mjs

@@ -0,0 +1,99 @@
+// tests/grade_engine_replay.mjs — the differential replay over RECORDED grades
+// (task 1002839, ADR 0089 §1).
+//
+// The corpus (tests/fixtures/grade-replay/recorded-panel-grades.json) is real:
+// production grade rows pulled by `scripts/gds/grade-replay.js --live
+// --write-fixture`, one per panel shape, with review prose hashed. Each row
+// carries the judges' persisted verdicts and the decision the server stored.
+// Replaying the verdicts through the grade engine's aggregate + gate stages must
+// reproduce that decision exactly — that is what "the extraction changed no
+// grade" means, measured on grades that actually happened rather than asserted.
+//
+// A future change to aggregation or the gate (task 1002841's normalization is
+// the next) that moves any of these recorded decisions fails here, and says
+// which task's grade moved and on which field.
+//
+// Run:  node --test tests/grade_engine_replay.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const grader = require('../modules/grading/grader.js');
+const replay = require('../scripts/gds/grade-replay.js');
+const { grades: corpus } = require('./fixtures/grade-replay/recorded-panel-grades.json');
+
+const clone = (v) => JSON.parse(JSON.stringify(v));
+
+test('the corpus is real and varied, not a pile of all-pass panels', () => {
+  assert.ok(corpus.length >= 20, `expected a corpus of 20+ recorded grades, got ${corpus.length}`);
+  const outcomes = new Set(corpus.map((g) => g.recorded.panel_outcome));
+  for (const o of ['pass', 'concerns', 'fail', 'unavailable']) assert.ok(outcomes.has(o), `no recorded '${o}' grade in the corpus`);
+  const workers = corpus.flatMap((g) => g.workers);
+  assert.ok(workers.some((w) => w.kind === 'route-rank'), 'a deterministic pseudo-judge');
+  assert.ok(workers.some((w) => w.kind === 'reader'), 'the non-gating reader');
+  assert.ok(workers.some((w) => w.retried), 'a retried worker');
+  assert.ok(workers.some((w) => w.error), 'an errored worker');
+  assert.equal(new Set(corpus.map(replay.shapeKey)).size, corpus.length, 'one row per panel shape');
+});
+
+test('every recorded grade replays to the decision production stored', () => {
+  for (const row of corpus) {
+    const { mismatches } = replay.replayRow(row);
+    assert.deepEqual(mismatches, [], `task ${row.task_id} (${row.graded_at}) replays differently: ${JSON.stringify(mismatches)}`);
+  }
+});
+
+test('the engine gate changes nothing for the code panel on any recorded grade', () => {
+  for (const row of corpus) {
+    const viaEngine = grader.gradeEngine.replayRecorded({ signals: { workers: row.workers } });
+    assert.deepEqual(viaEngine, grader.aggregatePanel(row.workers, {}), `task ${row.task_id}`);
+  }
+});
+
+test('the replay is not vacuous: a changed record, or a changed verdict, is flagged', () => {
+  const passing = corpus.find((g) => g.recorded.panel_outcome === 'pass' && g.workers.some((w) => w.kind === 'quality'));
+  const edited = clone(passing);
+  edited.recorded.panel_outcome = 'concerns';
+  assert.deepEqual(replay.replayRow(edited).mismatches.map((m) => m.field), ['panel_outcome']);
+
+  const flipped = clone(passing);
+  const q = flipped.workers.find((w) => w.kind === 'quality');
+  q.verdict = 'fail';
+  q.issues = [{ severity: 'major', file: 'h:x', summary: 'h:y' }];
+  const fields = replay.replayRow(flipped).mismatches.map((m) => m.field);
+  for (const f of ['panel_outcome', 'pass_count', 'fail_count', 'confidence']) assert.ok(fields.includes(f), `${f} not flagged: ${fields}`);
+});
+
+test('compareDecision: a stored 0 against an axis the panel left null is the old server coercion — nothing else is', () => {
+  const rec = { panel_outcome: 'unavailable', rubric: { code_quality: 0, functional_fidelity: 7 } };
+  const rep = { panel_outcome: 'unavailable', rubric: { code_quality: null, functional_fidelity: null } };
+  assert.deepEqual(replay.compareDecision(rec, rep), [{ field: 'rubric.functional_fidelity', recorded: 7, replayed: null }]);
+  assert.deepEqual(replay.compareDecision({ confidence: undefined, rubric: {} }, { confidence: 0.3, rubric: {} }), [],
+    'a confidence the server guards rewrote is recorded as undefined and not compared');
+});
+
+test('trimRecordedGrade keeps what aggregate + gate read and hashes the prose', () => {
+  const grade = {
+    rubric_scores: { functional_fidelity: '9', code_quality: 8 },
+    signals: {
+      panel_outcome: 'pass', pass_count: 1, worker_count: 1, panel_cost_usd: '0.5', confidence: 0.8,
+      server_guard: { downgraded_to: null },
+      workers: [{ kind: 'quality', verdict: 'pass', error: null, scores: { code_quality: 8 }, confidence: 0.8, model: 'm', cost_usd: 0.5,
+        notes_md: 'long review prose', name: 'Quality', issues: [{ severity: 'minor', file: 'a.js', summary: '  the same finding  ' }] }],
+    },
+  };
+  const row = replay.trimRecordedGrade({ task_id: 7, graded_at: 'T', grade });
+  assert.equal(row.task_id, '7');
+  assert.equal(row.recorded.rubric.functional_fidelity, 9);
+  assert.equal(row.recorded.panel_cost_usd, 0.5);
+  assert.equal(row.workers[0].notes_md, undefined, 'prose the gate never reads is dropped');
+  const [issue] = row.workers[0].issues;
+  assert.match(issue.summary, /^h:[0-9a-f]{10}$/);
+  assert.equal(issue.summary, replay.trimRecordedGrade({ task_id: 7, grade: { ...grade, signals: { ...grade.signals, workers: [{ ...grade.signals.workers[0], issues: [{ ...grade.signals.workers[0].issues[0], summary: 'the same finding' }] }] } } }).workers[0].issues[0].summary,
+    'hashing the TRIMMED summary keeps the de-duplication key exact');
+  assert.equal(replay.trimRecordedGrade({ task_id: 8, grade: { signals: { workers: [] } } }), null, 'not a panel grade');
+  const guarded = replay.trimRecordedGrade({ task_id: 9, grade: { ...grade, signals: { ...grade.signals, server_guard: { downgraded_to: 'concerns' } } } });
+  assert.equal(guarded.recorded.confidence, undefined, "a confidence the server guards rewrote is theirs, not the panel's — not recorded");
+});

package/tests/grader_prompt_window_bound.mjs

@@ -0,0 +1,132 @@
+// tests/grader_prompt_window_bound.mjs
+//
+// Task 1003648 — a worker prompt too big for its model's window degrades instead
+// of failing outright, and a real overflow is recognised as one.
+//
+// TWO DEFECTS, both in runWorker:
+//   1. The overflow tag never fired. Task 1003318 matched
+//      /prompt is too long: the request is .../ — a colon — but the line the
+//      `claude` CLI really prints (stored verbatim on task 1003298's grade row) is
+//      "Prompt is too long · the request is ~251248 tokens (limit 200000) ...".
+//      So a real overflow was filed as SUBAGENT_NONZERO_EXIT and retried as if
+//      it were transient. The existing test was green because its fixture used
+//      the paraphrase. REAL_REFUSAL below is the real sentence.
+//   2. Nothing smaller was ever tried. The post-change file bundle (up to 120k
+//      chars) is the one part of the prompt that can go without losing evidence —
+//      the worker can Read those files — so an overflow now retries ONCE without
+//      it, and only then stands as PROMPT_TOO_LONG (an explicit lens-unavailable).
+//
+// Run:  node tests/grader_prompt_window_bound.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { runWorker, quality, TRANSIENT_WORKER_ERRORS } = require('../modules/grading/grader-workers/index.js');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); }
+}
+
+// The CLI's own refusal sentence, exactly as stored in
+// signals.workers[quality].stderr_tail on task 1003298's grade (2026-08-27).
+const REAL_REFUSAL = 'Prompt is too long · the request is ~251248 tokens (limit 200000) but this conversation is only ~100861 tokens — the rest is system prompt, tool definitions, and attachment content. A single-exchange conversation cannot be compacted; reduce attached files/tools or start with less context.';
+
+// How runSubagent rejects when the CLI exits nonzero: the JSON result envelope is
+// on stdout (--output-format json) and stderr is empty — the 1003298 shape.
+const refusal = () => Object.assign(new Error('subagent exited with code 1'), {
+  code: 'SUBAGENT_NONZERO_EXIT', exit_code: 1, run_ms: 1087, stderr: '',
+  stdout: JSON.stringify({ type: 'result', subtype: 'success', is_error: true, result: REAL_REFUSAL, duration_ms: 1087 }),
+});
+const GOOD = JSON.stringify({ code_quality: 9, economy: 9, confidence: 0.9, issues: [], notes_md: 'clean' });
+
+const BUNDLE_MARKER = 'BUNDLED_CONTENT_OF_a_js_7f3e';
+const DIFF_MARKER = '+const shipped = true; // DIFF_MARKER_91c2';
+const bundle = (files) => ({ files, skipped: [], total_chars: files.reduce((n, f) => n + f.content.length, 0) });
+const ONE_FILE = [{ file: 'a.js', content: `// ${BUNDLE_MARKER}\n${'x'.repeat(5000)}`, truncated: false, chars_total: 5010 }];
+
+// The real Quality worker (real prompt scaffold, parser and verdict) with only the
+// subprocess replaced. `outcomes` is consumed one per spawn; every prompt is kept.
+async function run({ contextBundle, outcomes }) {
+  const prompts = [];
+  const r = await runWorker(quality, {
+    task: { id: 1003648, title: 't', description: 'd', kind: 'bug', discipline: 'engineer' },
+    valueSummary: 'v', diff: DIFF_MARKER, changedFiles: ['a.js'], diffStats: {},
+    model: 'claude-haiku-4-5-20251001', runOpts: {}, contextBundle,
+    runSubagentFn: async ({ prompt }) => {
+      prompts.push(prompt);
+      const next = outcomes.shift();
+      if (next === 'refuse') throw refusal();
+      return { stdout: next, run_ms: 5, cost_usd: 0.01 };
+    },
+  });
+  return { r, prompts };
+}
+
+// ---- 1. the real sentence is recognised (defect 1) ------------------------
+
+await test('the CLI\'s real refusal sentence is tagged PROMPT_TOO_LONG, and not retried as transient', async () => {
+  const { r, prompts } = await run({ contextBundle: bundle([]), outcomes: ['refuse', GOOD] });
+  assert.equal(r.error, 'PROMPT_TOO_LONG', 'the real " · " form must classify, not only a paraphrased colon');
+  assert.equal(prompts.length, 1, 'a window overflow is not transient — no task-465 retry of the same prompt');
+  assert.equal(r.retried, false);
+  assert.equal(TRANSIENT_WORKER_ERRORS.has('PROMPT_TOO_LONG'), false);
+  assert.equal('prompt_bounded' in r, false, 'with no bundle there was nothing smaller to try');
+});
+
+await test('the colon paraphrase still classifies too', async () => {
+  const r = await runWorker(quality, {
+    task: {}, diff: 'x', changedFiles: [], model: 'm', runOpts: {},
+    runSubagentFn: async () => { throw Object.assign(new Error('exit 1'), { code: 'SUBAGENT_NONZERO_EXIT', exit_code: 1, stderr: 'Prompt is too long: the request is ~9 tokens (limit 8)', stdout: '' }); },
+  });
+  assert.equal(r.error, 'PROMPT_TOO_LONG');
+});
+
+// ---- 2. the overflow degrades: one retry without the bundle (defect 2) -----
+
+await test('an overflow with a bundle retries ONCE without it — same diff — and grades normally', async () => {
+  const { r, prompts } = await run({ contextBundle: bundle(ONE_FILE), outcomes: ['refuse', GOOD] });
+  assert.equal(prompts.length, 2);
+  assert.ok(prompts[0].includes(BUNDLE_MARKER), 'the first prompt carried the bundle');
+  assert.ok(!prompts[1].includes(BUNDLE_MARKER), 'the retry drops the bundled file contents');
+  assert.ok(prompts[1].includes('DIFF_MARKER_91c2'), 'the retry still carries the whole diff');
+  assert.ok(prompts[1].length < prompts[0].length);
+  assert.equal(r.error, null);
+  assert.equal(r.verdict, 'pass');
+  assert.deepEqual(r.prompt_bounded, {
+    reason: 'PROMPT_TOO_LONG', bundle_dropped: true, bundle_files: 1,
+    prompt_chars: prompts[0].length, retry_prompt_chars: prompts[1].length,
+    request_tokens: 251248, window_tokens: 200000, retry_error: null,
+  });
+});
+
+await test('if the smaller prompt overflows too, the lens is explicitly unavailable — two spawns, no score', async () => {
+  const { r, prompts } = await run({ contextBundle: bundle(ONE_FILE), outcomes: ['refuse', 'refuse', GOOD] });
+  assert.equal(prompts.length, 2, 'one degraded retry, never a loop');
+  assert.equal(r.error, 'PROMPT_TOO_LONG');
+  assert.deepEqual(r.scores, {}, 'no axis is fabricated for a worker that never ran');
+  assert.equal(r.prompt_bounded.retry_error, 'PROMPT_TOO_LONG');
+});
+
+await test('an ordinary run keeps the bundle and its exact row shape', async () => {
+  const { r, prompts } = await run({ contextBundle: bundle(ONE_FILE), outcomes: [GOOD] });
+  assert.equal(prompts.length, 1);
+  assert.ok(prompts[0].includes(BUNDLE_MARKER));
+  assert.equal(r.verdict, 'pass');
+  assert.equal('prompt_bounded' in r, false);
+});
+
+await test('a transient error is still retried once with the SAME prompt (the task 465 retry, unchanged)', async () => {
+  const { r, prompts } = await run({ contextBundle: bundle(ONE_FILE), outcomes: ['not json at all', GOOD] });
+  assert.equal(prompts.length, 2);
+  assert.equal(prompts[0], prompts[1], 'a parse_error retry re-sends the same prompt, bundle included');
+  assert.equal(r.retried, true);
+  assert.equal(r.verdict, 'pass');
+  assert.equal('prompt_bounded' in r, false);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/grader_unbacked_score.mjs

@@ -0,0 +1,194 @@
+// tests/grader_unbacked_score.mjs
+//
+// Task 1002903 — a low score no finding stands behind must reach the builder as
+// what it is, and must still not pass.
+//
+// THE SHAPE. The severity gate (task 1002663, worker-verdict.js
+// applySeverityGatePolicy) downgrades a worker's sub-threshold 'fail' to
+// 'concerns' when no major/blocker finding backs it. The worker keeps its low
+// score, so the grade still read "FAIL 5.5" — and the card said "Fix the issues
+// above" over an empty list. Three defects made that shape:
+//   1. runWorker rebuilt the worker row field by field and dropped the policy's
+//      marker, so the stored grade could not say which low score was unbacked;
+//   2. an ADVISORY Narc's unbacked low ff made the panel report PASS while the
+//      server's ff gate failed the ship — a PASS verdict inside a FAIL grade;
+//   3. the card had no branch for it, so it printed the ordinary FAIL block.
+// The constraint the task set: close it WITHOUT letting an unbacked low score
+// pass and WITHOUT adding a gate (ADR 0162). Every case below that has a low
+// score also asserts the server still refuses it.
+//
+// Run:  node tests/grader_unbacked_score.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const grader = require('../modules/grading/grader.js');
+const { aggregatePanel, validateAndScore, serverSideGuards, THRESHOLD, FALLTHROUGH_CONFIDENCE } = grader;
+const { unbackedLowScores, UNBACKED_SCORE_DOWNGRADE, failResult } = require('../modules/grading/grader-workers/worker-verdict.js');
+const { runWorker, quality, narc, hacker, efficiency } = require('../modules/grading/grader-workers/index.js');
+const { buildGradePayload, formatGradeOutcome } = require('../scripts/gds/ship-grade-steps.js');
+const { CARDS } = require('../scripts/gds/plain-cards.js');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); }
+}
+
+// A REAL worker row: the real worker module's prompt, parser and verdict, run
+// through the real runWorker, with only the subprocess replaced by its output.
+// That is the point — defect 1 lived in runWorker's row assembly, so a
+// hand-built row would have hidden it.
+async function row(worker, output) {
+  return runWorker(worker, {
+    task: { id: 1002903, title: 't', description: 'd', kind: 'bug', discipline: 'engineer' },
+    valueSummary: 'v', diff: '+ const x = 1;', changedFiles: ['a.js'], diffStats: {},
+    model: 'claude-sonnet-5', runOpts: {},
+    runSubagentFn: async () => ({ stdout: JSON.stringify(output), run_ms: 5, cost_usd: 0 }),
+  });
+}
+const nit = { severity: 'nit', file: 'a.js', summary: 'comment style' };
+const major = { severity: 'major', file: 'a.js', summary: 'breaks the caller' };
+const ac = [{ ac: 'does the thing', status: 'satisfied', evidence: 'a.js:1' }];
+
+const OUT = {
+  narcPass: { functional_fidelity: 9, confidence: 0.9, issues: [], notes_md: 'ok', ac_checklist: ac },
+  narcUnbacked: { functional_fidelity: 4, confidence: 0.9, issues: [nit], notes_md: 'hm', ac_checklist: ac },
+  narcLowConf: { functional_fidelity: 7, confidence: 0.2, issues: [], notes_md: 'unsure', ac_checklist: ac },
+  qualityPass: { code_quality: 9, economy: 9, confidence: 0.9, issues: [], notes_md: 'fine' },
+  qualityUnbacked: { code_quality: 2, economy: 8, confidence: 0.9, issues: [nit], notes_md: 'meh' },
+  qualityBacked: { code_quality: 2, economy: 8, confidence: 0.9, issues: [major], notes_md: 'broken' },
+  hackerPass: { security_score: 9, confidence: 0.9, issues: [], notes_md: '', surfaces_checked: ['a.js'] },
+  hackerUnbacked: { security_score: 4, confidence: 0.9, issues: [nit], notes_md: '', surfaces_checked: ['a.js'] },
+  effPass: { efficiency_score: 9, confidence: 0.9, issues: [], notes_md: '', expensive_patterns_checked: ['loop'] },
+};
+
+// The server's half: what POST /tasks/:id/grade does to the body ship.js sends —
+// the same two calls the route makes, in the same order.
+function serverGrade(panelResult) {
+  const body = buildGradePayload(panelResult, ['a.js']);
+  const scored = validateAndScore(body.subagent_output, body.signals);
+  return serverSideGuards(scored, { committedFiles: ['a.js'], builderRank: 'archon', diffStats: null });
+}
+
+// ---- 1. the helper reads only the policy's own marker ---------------------
+
+await test('an unbacked low cq is listed; the axes that were fine are not', async () => {
+  const q = await row(quality, OUT.qualityUnbacked);
+  assert.equal(q.verdict, 'concerns');
+  assert.deepEqual(unbackedLowScores([q], { threshold: THRESHOLD }), [{ kind: 'quality', axis: 'code_quality', score: 2 }]);
+});
+
+await test('a low score BACKED by a major finding is not unbacked (the worker stays fail)', async () => {
+  const q = await row(quality, OUT.qualityBacked);
+  assert.equal(q.verdict, 'fail');
+  assert.deepEqual(unbackedLowScores([q], { threshold: THRESHOLD }), []);
+});
+
+await test('the exempt Hacker never appears: its unbacked low score stays a hard fail', async () => {
+  const h = await row(hacker, OUT.hackerUnbacked);
+  assert.equal(h.verdict, 'fail', 'the security lens is fail-closed (task 1002663)');
+  assert.deepEqual(unbackedLowScores([h], { threshold: THRESHOLD }), []);
+});
+
+await test('an errored worker and junk input yield []', () => {
+  assert.deepEqual(unbackedLowScores([failResult({ notesMd: 'x', error: 'parse_error' })], { threshold: THRESHOLD }), []);
+  assert.deepEqual(unbackedLowScores(null, { threshold: THRESHOLD }), []);
+  assert.deepEqual(unbackedLowScores('workers', { threshold: THRESHOLD }), []);
+  assert.deepEqual(unbackedLowScores([null, 'x', { policy_downgrade: UNBACKED_SCORE_DOWNGRADE, scores: 'junk' }], { threshold: THRESHOLD }), []);
+});
+
+// ---- 2. runWorker keeps the marker (defect 1) -----------------------------
+
+await test('runWorker carries policy_downgrade onto the worker row', async () => {
+  const q = await row(quality, OUT.qualityUnbacked);
+  assert.equal(q.policy_downgrade, UNBACKED_SCORE_DOWNGRADE);
+});
+
+await test('an ordinary worker row keeps its exact shape (no policy_downgrade key)', async () => {
+  const q = await row(quality, OUT.qualityPass);
+  assert.equal('policy_downgrade' in q, false);
+});
+
+// ---- 3. aggregatePanel records it, and never claims a PASS the server refuses
+
+await test('Quality unbacked: the panel records unbacked_scores and names it in the notes', async () => {
+  const r = aggregatePanel([await row(narc, OUT.narcPass), await row(quality, OUT.qualityUnbacked), await row(hacker, OUT.hackerPass), await row(efficiency, OUT.effPass)]);
+  assert.equal(r.signals.panel_outcome, 'concerns');
+  assert.equal(r.passed, false);
+  assert.deepEqual(r.signals.unbacked_scores, [{ kind: 'quality', axis: 'code_quality', score: 2 }]);
+  assert.match(r.notes_md, /unbacked score: quality code_quality 2\/10/);
+});
+
+await test('Narc unbacked low ff: the panel says CONCERNS, not a PASS the server will fail (defect 2)', async () => {
+  const r = aggregatePanel([await row(narc, OUT.narcUnbacked), await row(quality, OUT.qualityPass), await row(hacker, OUT.hackerPass), await row(efficiency, OUT.effPass)]);
+  assert.equal(r.signals.panel_outcome, 'concerns', 'every gating worker passed, but ff 4 fails the server gate');
+  assert.equal(r.passed, false);
+  assert.equal(r.signals.confidence, FALLTHROUGH_CONFIDENCE, 'concerns forwards the fall-through confidence');
+  assert.match(r.notes_md, /functional_fidelity 4 is below 6/);
+  assert.deepEqual(r.signals.unbacked_scores, [{ kind: 'narc', axis: 'functional_fidelity', score: 4 }]);
+});
+
+await test('negative control: a Narc concerns with ff at/above threshold still PASSES (the Narc is advisory, task 481)', async () => {
+  const r = aggregatePanel([await row(narc, OUT.narcLowConf), await row(quality, OUT.qualityPass), await row(hacker, OUT.hackerPass), await row(efficiency, OUT.effPass)]);
+  assert.equal(r.signals.panel_outcome, 'pass');
+  assert.equal(r.passed, true);
+  assert.equal('unbacked_scores' in r.signals, false, 'an ordinary grade keeps its signals shape');
+});
+
+// ---- 4. not loosened: the server still refuses every unbacked low score ----
+
+await test('the server still refuses both shapes — an unbacked low score never passes', async () => {
+  const qualityShape = aggregatePanel([await row(narc, OUT.narcPass), await row(quality, OUT.qualityUnbacked), await row(hacker, OUT.hackerPass), await row(efficiency, OUT.effPass)]);
+  const narcShape = aggregatePanel([await row(narc, OUT.narcUnbacked), await row(quality, OUT.qualityPass), await row(hacker, OUT.hackerPass), await row(efficiency, OUT.effPass)]);
+  for (const [label, r] of [['quality', qualityShape], ['narc', narcShape]]) {
+    const g = serverGrade(r);
+    assert.equal(g.passed, false, `${label}: the server gate must still fail it`);
+    assert.ok(Array.isArray(g.signals.unbacked_scores) && g.signals.unbacked_scores.length === 1, `${label}: the list rides into the stored signals`);
+  }
+});
+
+// ---- 5. the card tells the truth (defect 3) --------------------------------
+
+await test('the card reads UNBACKED LOW SCORE, names the reviewer, and never says "fix the issues"', async () => {
+  const g = serverGrade(aggregatePanel([await row(narc, OUT.narcPass), await row(quality, OUT.qualityUnbacked), await row(hacker, OUT.hackerPass), await row(efficiency, OUT.effPass)]));
+  const out = formatGradeOutcome(g, 1002903);
+  assert.match(out, /UNBACKED LOW SCORE/);
+  assert.match(out, /quality: code_quality 2\/10 — no major or blocker finding/);
+  assert.match(out, /nothing listed to fix/);
+  assert.match(out, /ship\.js 1002903 --regrade/);
+  assert.match(out, /override-request/);
+  assert.doesNotMatch(out, /Fix the issues above/);
+  assert.ok(out.includes(CARDS.grade_unbacked_score.happened), 'the plain-language card follows');
+});
+
+await test('the card falls back to signals.workers for a grade recorded before unbacked_scores', async () => {
+  const g = serverGrade(aggregatePanel([await row(narc, OUT.narcPass), await row(quality, OUT.qualityUnbacked), await row(hacker, OUT.hackerPass), await row(efficiency, OUT.effPass)]));
+  delete g.signals.unbacked_scores;
+  assert.match(formatGradeOutcome(g, 7), /quality: code_quality 2\/10/);
+});
+
+await test('the card steps aside when a finding IS substantive — the ordinary FAIL block lists it', async () => {
+  const g = serverGrade(aggregatePanel([await row(narc, OUT.narcPass), await row(quality, OUT.qualityUnbacked), await row(hacker, OUT.hackerPass), await row(efficiency, OUT.effPass)]));
+  g.issues = [...g.issues, { severity: 'blocker', file: 'b.js', summary: 'real problem', worker: 'hacker' }];
+  const out = formatGradeOutcome(g, 7);
+  assert.doesNotMatch(out, /UNBACKED LOW SCORE/);
+  assert.match(out, /Fix the issues above/);
+});
+
+await test('the card steps aside when a gating worker hard-failed the panel', async () => {
+  const g = serverGrade(aggregatePanel([await row(narc, OUT.narcPass), await row(quality, OUT.qualityUnbacked), await row(hacker, OUT.hackerUnbacked), await row(efficiency, OUT.effPass)]));
+  assert.equal(g.signals.panel_outcome, 'fail', 'the exempt Hacker hard-fails');
+  assert.doesNotMatch(formatGradeOutcome(g, 7), /UNBACKED LOW SCORE/);
+});
+
+await test('a passing grade never gets the branch', async () => {
+  const g = serverGrade(aggregatePanel([await row(narc, OUT.narcPass), await row(quality, OUT.qualityPass), await row(hacker, OUT.hackerPass), await row(efficiency, OUT.effPass)]));
+  assert.equal(g.passed, true);
+  assert.doesNotMatch(formatGradeOutcome(g, 7), /UNBACKED LOW SCORE/);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/hall_preview_scrub.mjs

@@ -0,0 +1,214 @@
+// tests/hall_preview_scrub.mjs — the hall-preview fixtures carry stand-ins, never real
+// people (task 1003647).
+//
+// scripts/hall-preview/refresh-fixtures.js snapshots live API responses into COMMITTED
+// fixtures. Before this task it wrote them verbatim, so the repo held real builders'
+// GitHub logins, names, avatars and GitHub ids — and, in me.json, one builder's credit
+// balance and month-to-date spend. The fix lives in the writer (scrub-identity.js, run on
+// every snapshot before it is written), because a one-off clean-up of the output re-leaks
+// on the next refresh. These tests pin:
+//   1. the scheme — one stand-in per person, absence preserved, the account's own money
+//      figures fixed, everything that is not a person left alone;
+//   2. that it is a fixed point, which is what lets (4) work;
+//   3. that the WRITER applies it — driven with a fake API into a temp dir, no network;
+//   4. that every fixture checked in today is already scrubbed.
+//
+// Every "real" identity below is invented for the test.
+//
+// Run:  node --test tests/hall_preview_scrub.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const FIXTURES = path.join(ROOT, 'scripts', 'hall-preview', 'fixtures');
+const {
+  createScrubber, isOwnAccountFixture, highestStandIn, rewriteScalars, GHOST_AVATAR_URL,
+} = require('../scripts/hall-preview/scrub-identity.js');
+const { refreshFixtures, scrubFixturesOnDisk } = require('../scripts/hall-preview/refresh-fixtures.js');
+
+const REAL_AVATAR = 'https://avatars.githubusercontent.com/u/87654321?v=4';
+const liveMe = () => ({
+  builder: {
+    id: '95', github_id: '87654321', github_login: 'Real-Person', display_name: 'Real Person',
+    avatar_url: REAL_AVATAR, total_credits: 4321, karma: 7, rank: 'metic', monthly_budget_usd: null,
+    anthropic_email: null,
+  },
+  cost: { spend_mtd_usd: 123.45, budget_mtd_usd: null },
+  active_claims: [{ task_id: '2167', title: 'Check in the hall preview harness', worktree_name: 'frontend-redesign-ux' }],
+});
+const liveDirectory = () => ({
+  builders: [
+    { id: '95', github_login: 'real-person', display_name: 'Real Person', avatar_url: REAL_AVATAR },
+    { id: '7', github_login: 'other-human', display_name: '', avatar_url: null, total_credits: 900 },
+  ],
+});
+const liveRequests = () => ({
+  requests: [{
+    id: '3', requested_by: '7', requested_by_login: 'other-human', requested_by_name: 'Other Human',
+    requested_by_avatar_url: 'https://avatars.githubusercontent.com/u/1234567?v=4',
+    needs_builder_login: null, needs_builder_name: null, needs_builder_avatar_url: null,
+    created_by: '1000025', worktree_name: 'keep-this-name',
+  }],
+  tasks: [{ id: '9', credits_reward: 30, sandbox_review: { by: 'Real-Person', at: '2026-09-01T00:00:00Z' } }],
+  gate: [{ number: 12, author: 'other-human', head_sha: 'abc123' }],
+  modules: [{ key: 'ideas', author: 'Cloud Bongos' }],
+});
+
+// Every string anywhere in a value, for "does this identity survive anywhere" checks.
+function allStrings(v, out = []) {
+  if (typeof v === 'string') out.push(v);
+  else if (Array.isArray(v)) v.forEach((x) => allStrings(x, out));
+  else if (v && typeof v === 'object') Object.values(v).forEach((x) => allStrings(x, out));
+  return out;
+}
+
+test('a person becomes ONE stand-in everywhere: login, name, avatar and GitHub id together', () => {
+  const s = createScrubber();
+  const me = s.scrub(liveMe(), { ownAccount: true });
+  const dir = s.scrub(liveDirectory());
+  const req = s.scrub(liveRequests());
+
+  assert.equal(me.builder.github_login, 'builder-1');
+  assert.equal(me.builder.display_name, 'Builder 1', 'the name travels with the login beside it');
+  assert.equal(me.builder.avatar_url, GHOST_AVATAR_URL);
+  assert.equal(me.builder.github_id, '1', 'a GitHub id follows its person, and keeps its type');
+  // The same person in another file, spelled with different case, is still person 1.
+  assert.equal(dir.builders[0].github_login, 'builder-1');
+  assert.equal(dir.builders[0].display_name, 'Builder 1');
+  // A second person, first met as a directory row, then as a requester.
+  assert.equal(dir.builders[1].github_login, 'builder-2');
+  assert.equal(req.requests[0].requested_by_login, 'builder-2');
+  assert.equal(req.requests[0].requested_by_name, 'Builder 2', 'a <who>_name pairs with <who>_login');
+  assert.equal(req.requests[0].requested_by_avatar_url, GHOST_AVATAR_URL);
+  // A login in a `by` field (who approved a staged change) and a PR author.
+  assert.equal(req.tasks[0].sandbox_review.by, 'builder-1');
+  assert.equal(req.gate[0].author, 'builder-2');
+
+  const leftovers = [me, dir, req].flatMap((d) => allStrings(d))
+    .filter((v) => /real-person|real person|other-human|other human|87654321|1234567/i.test(v));
+  assert.deepEqual(leftovers, [], 'no real identity survives anywhere in the output');
+});
+
+test('absence is preserved: null stays null and "" stays ""', () => {
+  const dir = createScrubber().scrub(liveDirectory());
+  assert.equal(dir.builders[1].display_name, '', 'the pages fall back to the login when a name is empty');
+  assert.equal(dir.builders[1].avatar_url, null, 'the pages draw initials when there is no avatar');
+  const req = createScrubber().scrub(liveRequests());
+  assert.equal(req.requests[0].needs_builder_login, null);
+  assert.equal(req.requests[0].needs_builder_avatar_url, null);
+});
+
+test("the account's own balance and spend become fixed values; other builders keep their numbers", () => {
+  const s = createScrubber();
+  const me = s.scrub(liveMe(), { ownAccount: true });
+  assert.equal(me.builder.total_credits, 1000);
+  assert.equal(me.builder.karma, 10);
+  assert.equal(me.cost.spend_mtd_usd, 42, 'month-to-date spend is private wherever it appears');
+  assert.equal(me.cost.budget_mtd_usd, null, 'an unset budget stays unset');
+  const totals = s.scrub({ handle: 'real-person', cross_project: { totals: { credits: 4890, karma: 6, projects: 2 } } }, { ownAccount: true });
+  assert.deepEqual(totals.cross_project.totals, { credits: 1000, karma: 10, projects: 2 });
+  // Not the account's own file: a stand-in's balance is nobody's, and the leaderboard
+  // preview needs real magnitudes to be worth looking at.
+  assert.equal(createScrubber().scrub(liveDirectory()).builders[1].total_credits, 900);
+});
+
+test('what is not a person is left exactly alone', () => {
+  const s = createScrubber();
+  const me = s.scrub(liveMe(), { ownAccount: true });
+  const req = s.scrub(liveRequests());
+  assert.equal(me.builder.id, '95', 'instance-local ids stay — the harness routes on them');
+  assert.equal(me.builder.rank, 'metic');
+  assert.deepEqual(me.active_claims, liveMe().active_claims, 'task ids, titles and worktree names are project content');
+  assert.equal(req.requests[0].worktree_name, 'keep-this-name', 'a <x>_name with no <x>_login is not a person');
+  assert.equal(req.requests[0].created_by, '1000025', 'a numeric *_by is a builder id, not a login');
+  assert.equal(req.tasks[0].credits_reward, 30, "a task's bounty is not anyone's balance");
+  assert.equal(req.modules[0].author, 'Cloud Bongos', "a module's author credit names an organisation");
+});
+
+test('scrubbing is a fixed point, and a new run numbers above the stand-ins already in use', () => {
+  const s = createScrubber();
+  const once = [s.scrub(liveMe(), { ownAccount: true }), s.scrub(liveDirectory()), s.scrub(liveRequests())];
+  const again = createScrubber();
+  const twice = [again.scrub(once[0], { ownAccount: true }), again.scrub(once[1]), again.scrub(once[2])];
+  assert.deepEqual(twice, once);
+
+  const texts = once.map((d) => JSON.stringify(d));
+  assert.equal(highestStandIn(texts), 2);
+  const later = createScrubber({ firstNumber: highestStandIn(texts) + 1 }).scrub({ github_login: 'a-newcomer' });
+  assert.equal(later.github_login, 'builder-3', 'a newcomer never collides with a stand-in on disk');
+});
+
+test('rewriteScalars replaces only the changed values and keeps a hand-written layout', () => {
+  const text = '{\n  "rows": [ { "github_login": "real-person", "tags": ["a", "b"] },\n            { "github_login": null } ],\n  "n": 3\n}\n';
+  const next = rewriteScalars(text, createScrubber().scrub(JSON.parse(text)));
+  assert.equal(next, text.replace('"real-person"', '"builder-1"'));
+});
+
+test('isOwnAccountFixture names the snapshotting account\'s own files', () => {
+  assert.equal(isOwnAccountFixture('me'), true);
+  assert.equal(isOwnAccountFixture('me__credits'), true);
+  assert.equal(isOwnAccountFixture('members'), false);
+  assert.equal(isOwnAccountFixture('leaderboard'), false);
+});
+
+test('the WRITER scrubs: refreshFixtures never puts the live identity on disk', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'hall-fixtures-'));
+  try {
+    const responses = { '/me': liveMe(), '/builders/directory': liveDirectory(), '/help-requests': liveRequests() };
+    const api = { request: async (_m, p) => (p in responses ? { ok: true, status: 200, data: responses[p] } : { ok: false, status: 404 }) };
+    const snapshots = [['me', 'me'], ['builders/directory', 'builders__directory'], ['help-requests', 'help-requests'], ['audit-log', 'audit-log']];
+    const wrote = await refreshFixtures({ api, dir, snapshots, log: () => {} });
+    assert.equal(wrote, 3, 'the 404 is skipped, as before');
+
+    const onDisk = fs.readdirSync(dir).map((f) => fs.readFileSync(path.join(dir, f), 'utf8')).join('\n');
+    for (const real of ['Real-Person', 'real-person', 'Real Person', 'other-human', 'Other Human', '87654321', '1234567', '4321', '123.45']) {
+      assert.ok(!onDisk.includes(real), `${real} must never reach the fixture directory`);
+    }
+    const me = JSON.parse(fs.readFileSync(path.join(dir, 'me.json'), 'utf8'));
+    assert.equal(me.builder.github_login, 'builder-1');
+    assert.equal(me.builder.total_credits, 1000, 'me.json is the account\'s own file');
+    const directory = JSON.parse(fs.readFileSync(path.join(dir, 'builders__directory.json'), 'utf8'));
+    assert.equal(directory.builders[0].github_login, 'builder-1', 'one run, one registry: the same person across files');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('--scrub-only rewrites a hand-written fixture in place, once', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'hall-fixtures-'));
+  try {
+    const file = path.join(dir, 'connections.json');
+    fs.writeFileSync(file, '{ "connections": [ { "handle": "other-human", "display_name": "Other Human", "avatar_url": "https://avatars.githubusercontent.com/u/1234567?v=4" } ] }\n');
+    assert.equal(scrubFixturesOnDisk({ dir, log: () => {} }), 1);
+    assert.equal(fs.readFileSync(file, 'utf8'),
+      `{ "connections": [ { "handle": "builder-1", "display_name": "Builder 1", "avatar_url": "${GHOST_AVATAR_URL}" } ] }\n`);
+    assert.equal(scrubFixturesOnDisk({ dir, log: () => {} }), 0, 'a second pass finds nothing to change');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('every committed fixture is already scrubbed — no real person is checked in', () => {
+  const files = fs.readdirSync(FIXTURES).filter((f) => f.endsWith('.json')).sort();
+  const texts = files.map((f) => fs.readFileSync(path.join(FIXTURES, f), 'utf8'));
+  const s = createScrubber({ firstNumber: highestStandIn(texts) + 1 });
+  const dirty = files.filter((file, i) => {
+    const data = JSON.parse(texts[i]);
+    try {
+      assert.deepEqual(s.scrub(data, { ownAccount: isOwnAccountFixture(file.slice(0, -5)) }), data);
+      return false;
+    } catch {
+      return true;
+    }
+  });
+  assert.deepEqual(dirty, [],
+    'these fixtures carry a real login, name, avatar, GitHub id or private figure — run '
+    + '`node scripts/hall-preview/refresh-fixtures.js --scrub-only` and commit the result');
+});