@bongos/core 1.19.1032 → 1.19.1034

package/tests/grade_engine.mjs

@@ -0,0 +1,249 @@
+// tests/grade_engine.mjs — the central grading engine (task 1002839, ADR 0089 §1).
+//
+// Pins the four things the extraction promised: (1) the pipeline is NAMED and
+// runs in the ADR's order; (2) there is a registry with two doors — the grading
+// module's own work-types and any other module's, through the seam port
+// grader.workType.<key> — and the code panel is registered in it as the default;
+// (3) the deterministic pre-passes and the veto belong to the ENGINE, so a
+// work-type whose own aggregate would pass a protected-path fail still fails;
+// (4) the code panel graded through the engine is wired exactly as gradeSubagent
+// was — same judges, models, timeouts, prompts and record — including through the
+// real default model call (a fake `claude` binary; POSIX only).
+//
+// Run:  node --test tests/grade_engine.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';
+
+const require = createRequire(import.meta.url);
+const grader = require('../modules/grading/grader.js');
+const engine = grader.gradeEngine;
+const api = require('../src/module-api');
+const llmCache = require('../src/bongos/llm-cache.js');
+
+const TASK = { id: 4242, title: 'Fixture task', description: 'Add helper X. Acceptance: X exported.', kind: 'feature', discipline: 'engineer', version_id: 'BONGOS-V2', est_minutes: 60 };
+const DIFF = 'diff --git a/modules/example/a.js b/modules/example/a.js\n--- a/modules/example/a.js\n+++ b/modules/example/a.js\n@@ -1 +1 @@\n-const a = 1;\n+const a = 2; // changed value here\n';
+const DS = { files_changed: 1, lines_added: 1, lines_removed: 1 };
+
+// Which judge a prompt belongs to — every worker prompt opens with its identity.
+const KIND_MARKS = [['**Narc**', 'narc'], ['**Quality**', 'quality'], ['**Hacker**', 'hacker'], ['**Efficiency Monger**', 'efficiency'], ['**Reader**', 'reader']];
+const kindOf = (prompt) => (KIND_MARKS.find(([m]) => prompt.slice(0, 400).includes(m)) || [null, 'unknown'])[1];
+const PASSING = {
+  narc: { functional_fidelity: 9, confidence: 0.8, issues: [], ac_checklist: [{ ac: 'X exported', status: 'satisfied' }] },
+  quality: { code_quality: 8, economy: 8, confidence: 0.8, issues: [] },
+  hacker: { security_score: 9, confidence: 0.8, issues: [] },
+  efficiency: { efficiency_score: 9, confidence: 0.8, issues: [] },
+};
+const envelope = (payload) => JSON.stringify({ type: 'result', result: JSON.stringify(payload), total_cost_usd: 0.01 });
+
+// An injected model call that records what each judge was asked.
+function recordingRunner(replies = PASSING) {
+  const calls = [];
+  const run = async ({ prompt, opts }) => {
+    const kind = kindOf(prompt);
+    calls.push({ kind, prompt, opts });
+    return { stdout: envelope(replies[kind] || {}), stderr: '', run_ms: 1, exit_code: 0, cost_usd: 0.01 };
+  };
+  return { run, calls };
+}
+
+// A work-type with every hook, whose aggregate PASSES no matter what it is handed —
+// the shape a careless or hostile module could register.
+function alwaysPassWorkType(seen = {}) {
+  return {
+    key: 'always-pass',
+    resolveJudges: () => ['judge-a'],
+    modelFor: () => 'model-x',
+    runJudge: async (judge, ctx) => { seen.ctx = ctx; return { kind: judge, verdict: 'pass', scores: {}, issues: [], confidence: 1, model: 'model-x' }; },
+    aggregate: (results) => { seen.results = results; return { passed: true, score: 10, signals: { panel_outcome: 'pass', confidence: 1 }, notes_md: 'always pass', issues: [] }; },
+    unavailable: ({ reason }) => ({ passed: false, signals: { panel_outcome: 'unavailable', reason } }),
+  };
+}
+
+test('the pipeline is named, in ADR 0089 §1 order', () => {
+  assert.deepEqual(engine.PIPELINE_STAGES, ['select', 'pre_pass', 'evidence', 'fan_out', 'aggregate', 'gate', 'persist']);
+});
+
+test('the code panel is registered as work-type #1 and is the default', () => {
+  assert.ok(engine.listWorkTypes().includes('code'));
+  const code = engine.resolveWorkType({ workType: 'code' });
+  assert.equal(code.key, 'code');
+  assert.equal(code.aggregate, grader.aggregatePanel, 'the code work-type aggregates with the v4 panel gate');
+  assert.equal(code.unavailable, grader.graderUnavailableResult);
+  assert.equal(code.cacheTaskType, 'grade_worker', 'kept at the pre-engine value so cached worker replies stay hits');
+  // Everything that is not a registered key lands on the default rather than
+  // throwing inside the grade step (the task 1002659 posture).
+  assert.equal(engine.resolveWorkType({}), code);
+  assert.equal(engine.resolveWorkType({ workType: 'no-such-type' }), code);
+  assert.equal(engine.resolveWorkType({ task: { discipline: 'engineer', kind: 'feature' } }), code);
+});
+
+test('registerWorkType refuses a malformed or conflicting work-type at registration', () => {
+  assert.throws(() => engine.registerWorkType({ ...alwaysPassWorkType(), key: 'Bad Key' }), /must match/);
+  const { aggregate, ...noAggregate } = alwaysPassWorkType();
+  assert.throws(() => engine.registerWorkType({ ...noAggregate, key: 'half-built' }), /missing hook\(s\): aggregate/);
+  assert.throws(() => engine.registerWorkType({ ...alwaysPassWorkType(), key: 'bad-optional', gatherEvidence: 'not a function' }), /gatherEvidence/);
+  const code = engine.resolveWorkType({ workType: 'code' });
+  assert.equal(engine.registerWorkType(code), code, 'the same definition again is a no-op');
+  assert.throws(() => engine.registerWorkType({ ...code }), /already registered/, 'a second definition for a key is a wiring bug');
+});
+
+test('another module contributes a work-type through the seam port, and a broken one degrades to the default', () => {
+  const def = { ...alwaysPassWorkType(), key: 'test-seam-art' };
+  api.registerProvider(engine.workTypePort('test-seam-art'), def);
+  assert.equal(engine.resolveWorkType({ task: { discipline: 'test-seam-art' } }), def, 'resolved by the task discipline');
+  assert.ok(engine.listWorkTypes().includes('test-seam-art'));
+
+  api.registerProvider(engine.workTypePort('test-seam-broken'), { key: 'test-seam-broken', aggregate: () => ({}) });
+  const logged = [];
+  const orig = console.error;
+  console.error = (...a) => { logged.push(a.join(' ')); };
+  try {
+    assert.equal(engine.resolveWorkType({ workType: 'test-seam-broken' }).key, 'code');
+  } finally { console.error = orig; }
+  assert.match(logged.join('\n'), /ignoring invalid work-type on port grader\.workType\.test-seam-broken/);
+  assert.ok(!engine.listWorkTypes().includes('test-seam-broken'));
+
+  // Tests reset the seam registry; the grading module's own default must survive it.
+  require('../src/module-seams')._reset();
+  assert.equal(engine.resolveWorkType({}).key, 'code', 'a seam reset cannot lose the default work-type');
+  assert.deepEqual(engine.listWorkTypes(), ['code']);
+});
+
+test('the ENGINE owns the pre-passes: a work-type that never names them still gets them, in order', async () => {
+  const seen = {};
+  await engine.runGrade({
+    workType: alwaysPassWorkType(seen), task: TASK, diff: DIFF, diffStats: DS,
+    changedFiles: ['src/bongos/routes/x.js', 'src/bongos/auth.js'], builderRank: 'thetes',
+  });
+  assert.deepEqual(seen.results.map((r) => r.kind), ['judge-a', 'route-rank', 'permission-path'],
+    'deterministic pseudo-judges join after the model judges, route-rank first');
+  assert.ok(seen.ctx.deterministicFindings.length > 0, 'the judges are handed the pre-pass findings');
+});
+
+test('the gate: no verdict upgrades a deterministic fail — whatever the work-type aggregate said', async () => {
+  const r = await engine.runGrade({
+    workType: alwaysPassWorkType(), task: TASK, diff: DIFF, diffStats: DS,
+    changedFiles: ['src/bongos/auth.js'], builderRank: 'xenos',
+  });
+  assert.equal(r.passed, false);
+  assert.equal(r.signals.panel_outcome, 'fail');
+  assert.equal(r.signals.confidence, 0, 'forwarded confidence 0 → the server gate fails it too');
+  assert.deepEqual(r.signals.deterministic_veto, ['permission-path']);
+  assert.match(r.notes_md, /DETERMINISTIC VETO/);
+
+  // The veto enforces the deterministic checks and nothing else: with no
+  // protected path touched, the work-type's own pass stands.
+  const clean = await engine.runGrade({
+    workType: alwaysPassWorkType(), task: TASK, diff: DIFF, diffStats: DS,
+    changedFiles: ['modules/example/a.js'], builderRank: 'xenos',
+  });
+  assert.equal(clean.passed, true);
+  assert.equal(clean.signals.deterministic_veto, undefined);
+});
+
+test('replay rebuilds the pre-passes from the recorded pseudo-judges, so its gate judges what the live gate judged', () => {
+  const recorded = [
+    { kind: 'judge-a', verdict: 'pass', scores: {}, issues: [], model: 'model-x' },
+    { kind: 'permission-path', verdict: 'fail', scores: {}, issues: [{ severity: 'blocker', file: 'src/bongos/auth.js', summary: 'x' }], model: 'deterministic' },
+  ];
+  const r = engine.replayRecorded({ signals: { workers: recorded }, workType: alwaysPassWorkType() });
+  assert.equal(r.passed, false);
+  assert.deepEqual(r.signals.deterministic_veto, ['permission-path']);
+  // A judge merely NAMED like a pre-pass, but produced by a model, is not one.
+  const forged = [{ ...recorded[1], model: 'claude-sonnet-5' }];
+  assert.equal(engine.replayRecorded({ signals: { workers: forged }, workType: alwaysPassWorkType() }).passed, true);
+});
+
+test('the gate returns an already-failed aggregate UNTOUCHED — why it is a no-op for the code panel', () => {
+  const failed = { passed: false, signals: { panel_outcome: 'fail', confidence: 0 }, notes_md: 'x' };
+  const prePass = { findings: [], workerResult: { kind: 'permission-path', verdict: 'fail', model: 'deterministic' } };
+  assert.equal(engine.applyDeterministicGate(failed, [prePass]), failed);
+  const passed = { passed: true, signals: { panel_outcome: 'pass' } };
+  assert.equal(engine.applyDeterministicGate(passed, []), passed, 'nothing to enforce → the same object');
+});
+
+test('the code panel through the engine: same judges, models, timeouts, prompts and record as gradeSubagent', async () => {
+  const { run, calls } = recordingRunner();
+  const prior = { round: 2, findings_md: '- [major] x', response_md: 'fixed in abc', interim_md: '1 file' };
+  const r = await engine.runGrade({
+    workType: 'code', task: TASK, valueSummary: 'Adds X.', diff: DIFF, diffStats: DS,
+    changedFiles: ['src/bongos/auth.js'], builderRank: 'xenos', priorRound: prior,
+    runOpts: { cwd: process.cwd(), timeoutMs: 1234 },
+  }, { runSubagent: run });
+
+  assert.deepEqual(calls.map((c) => c.kind).sort(), ['efficiency', 'hacker', 'narc', 'quality']);
+  for (const c of calls) {
+    assert.equal(c.opts.model, grader.workerModelFor(c.kind, grader.selectGraderModel({}), undefined));
+    assert.equal(c.opts.timeoutMs, 360000, `${c.kind}: the per-worker budget overrides runOpts.timeoutMs`);
+    assert.equal(c.opts.cwd, process.cwd());
+    assert.match(c.prompt, /## Prior panel round \(this is re-grade round 2\)/, `${c.kind} sees the prior round`);
+    assert.match(c.prompt, /## Post-change file contents \(1 of 1 changed files, bundled\)/, `${c.kind} sees the bundle`);
+  }
+  const hacker = calls.find((c) => c.kind === 'hacker');
+  assert.match(hacker.prompt, /## Deterministic route-rank pre-check/, 'the Hacker is handed the permission-path findings');
+
+  assert.deepEqual(r.signals.workers.map((w) => w.kind), ['narc', 'quality', 'hacker', 'efficiency', 'permission-path']);
+  assert.equal(r.signals.panel_outcome, 'fail', 'a sub-Metic protected-path edit fails the code panel on its own gate');
+  assert.equal(r.signals.deterministic_veto, undefined, 'aggregatePanel already failed it — the engine veto had nothing to do');
+  const keys = Object.keys(r.signals);
+  assert.deepEqual(keys.slice(-4), ['builder_model_assumed', 'grader_model', 'total_ms', 'context_bundle'],
+    'the run meta lands last, exactly where aggregatePanel put it when handed the meta directly');
+  assert.equal(r.signals.builder_model_assumed, grader.ASSUMED_BUILDER_MODEL);
+  assert.equal(r.signals.context_bundle.read_root, path.resolve(process.cwd()));
+  assert.deepEqual(r.signals.context_bundle.bundled.map((b) => b.file), ['src/bongos/auth.js']);
+  assert.equal(r.panel_cost_usd, 0.04);
+});
+
+test('bypass short-circuits BEFORE any judge is asked (#943)', async () => {
+  const { run, calls } = recordingRunner();
+  const r = await engine.runGrade({ workType: 'code', task: TASK, diff: DIFF, changedFiles: ['a.js'], judges: ['narc', 'no-such-worker'], runOpts: { bypass: true } }, { runSubagent: run });
+  assert.equal(calls.length, 0);
+  assert.equal(r.signals.panel_outcome, 'unavailable');
+  assert.equal(r.signals.grader_unavailable_reason, 'bypass_requested');
+});
+
+test('gradeSubagent grades through the engine\'s DEFAULT model call — a fake claude binary end to end',
+  { skip: process.platform === 'win32' && 'the fake CLI is a shebang script; spawn runs it through cmd.exe on win32' },
+  async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'grade-engine-'));
+    const bin = path.join(dir, 'claude');
+    fs.writeFileSync(bin, `#!/usr/bin/env node
+let s = '';
+process.stdin.on('data', (d) => { s += d; }).on('end', () => {
+  const replies = ${JSON.stringify(PASSING)};
+  const kinds = ${JSON.stringify(KIND_MARKS)};
+  const hit = kinds.find(([m]) => s.slice(0, 400).includes(m));
+  const argv = process.argv.slice(2);
+  const payload = { ...(hit ? replies[hit[1]] : {}), notes_md: 'model=' + argv[argv.indexOf('--model') + 1] };
+  process.stdout.write(JSON.stringify({ type: 'result', result: JSON.stringify(payload), total_cost_usd: 0.02 }));
+});
+`);
+    fs.chmodSync(bin, 0o755);
+    // The cache is exercised for its KEY (task_type) but never touches a database.
+    const origWithCache = llmCache.withCache;
+    const origSpec = llmCache.makeCacheSpec;
+    const taskTypes = [];
+    llmCache.makeCacheSpec = (args) => { taskTypes.push(args.task_type); return origSpec(args); };
+    llmCache.withCache = async (spec, producer) => ({ ...(await producer()), cached: false });
+    try {
+      const r = await grader.gradeSubagent({
+        task: TASK, valueSummary: 'Adds X.', diff: DIFF, diffStats: DS, changedFiles: ['modules/example/a.js'],
+        runOpts: { claudeBin: bin, cwd: process.cwd() },
+      });
+      assert.equal(r.signals.panel_outcome, 'pass', r.notes_md);
+      assert.equal(r.passed, true);
+      assert.deepEqual(r.signals.workers.map((w) => w.kind), ['narc', 'quality', 'hacker', 'efficiency']);
+      for (const w of r.signals.workers) assert.match(w.notes_md, new RegExp(`model=${w.model}$`), 'the spawned CLI got the worker model');
+      assert.deepEqual(taskTypes, ['grade_worker', 'grade_worker', 'grade_worker', 'grade_worker']);
+      assert.equal(r.panel_cost_usd, 0.08);
+    } finally {
+      llmCache.withCache = origWithCache;
+      llmCache.makeCacheSpec = origSpec;
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });

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