@bongos/core 1.19.1036 → 1.19.1038

package/modules/grading/grader-model.js

@@ -8,7 +8,7 @@
 
 'use strict';
 
-const { ASSUMED_BUILDER_MODEL, DEFAULT_GRADER_MODEL, WORKER_MODEL_TIERS, api } = require('./grader-config.js');
+const { ASSUMED_BUILDER_MODEL, DEFAULT_GRADER_MODEL, V4, WORKER_MODEL_TIERS, api } = require('./grader-config.js');
 
 function r1(n) {
   return Math.round(Number(n) * 10) / 10;
@@ -93,12 +93,14 @@ function isTrivialDiff({ changedFiles, diffStats } = {}) {
 // misconfiguration it guarded. Unknown ids now warn loudly and grade on
 // DEFAULT_GRADER_MODEL; the id still reaches signals.builder_model_assumed,
 // so /grader-health can spot the drift.
+//
+// task 1002840 (ADR 0089 §3): the Claude-only if/else is now DATA — the judge
+// table below, first matching row wins, in the old branch order.
 function selectGraderModel({ builderModel } = {}) {
   const bm = (builderModel || ASSUMED_BUILDER_MODEL).toLowerCase();
-  if (bm.includes('fable') || bm.includes('mythos')) return 'claude-sonnet-5';
-  if (bm.includes('opus')) return 'claude-sonnet-5';
-  if (bm.includes('sonnet')) return 'claude-opus-5';
-  if (bm.includes('haiku')) return 'claude-opus-5';
+  for (const row of JUDGE_TABLE) {
+    if (row.builder_families.some((f) => bm.includes(f))) return row.judge_model;
+  }
   console.error(
     `selectGraderModel: unrecognized builder model ${JSON.stringify(builderModel)} — ` +
     `no 'fable'/'mythos'/'opus'/'sonnet'/'haiku' token; grading on the default ` +
@@ -112,6 +114,46 @@ function selectGraderModel({ builderModel } = {}) {
 // back to graderModel) when it lands on the BUILDER's own family: tiering is
 // a cost lever, never a hole in the ADR 0024 cross-model guarantee.
 const MODEL_FAMILY_TOKENS = ['fable', 'mythos', 'opus', 'sonnet', 'haiku'];
+
+// task 1002840: the judge table — which grader model each builder family gets.
+// Read from the rubric (v4.judge_by_builder_family) and VALIDATED at load. A
+// row is refused when its judge shares a family with a builder it serves (the
+// ADR 0024 cross-model guarantee: no resolution may land the judge in the
+// builder's own family) or is not a plain Claude model id — the GATING panel
+// stays on Claude, the quality floor ADR 0089 keeps; an open model joins only as
+// an advisory judge (task 1003858). A table that fails is replaced WHOLE by the
+// built-in one below, which is the mapping the old if/else hard-coded, so a bad
+// rubric edit degrades to today's behaviour instead of to a throw at grade time.
+const BUILTIN_JUDGE_TABLE = Object.freeze([
+  Object.freeze({ builder_families: Object.freeze(['fable', 'mythos', 'opus']), judge_model: 'claude-sonnet-5' }),
+  Object.freeze({ builder_families: Object.freeze(['sonnet', 'haiku']), judge_model: 'claude-opus-5' }),
+]);
+
+function judgeTableProblems(table) {
+  if (!Array.isArray(table) || table.length === 0) return ['judge_by_builder_family must be a non-empty array'];
+  const problems = [];
+  table.forEach((row, i) => {
+    const fams = row && Array.isArray(row.builder_families) ? row.builder_families : null;
+    const judge = row && typeof row.judge_model === 'string' ? row.judge_model.toLowerCase() : null;
+    if (!fams || fams.length === 0 || !fams.every((f) => MODEL_FAMILY_TOKENS.includes(f))) {
+      problems.push(`row ${i}: builder_families must list family tokens (${MODEL_FAMILY_TOKENS.join('/')})`);
+      return;
+    }
+    const judgeFamily = judge && !judge.includes(':') ? MODEL_FAMILY_TOKENS.find((t) => judge.includes(t)) : null;
+    if (!judgeFamily) problems.push(`row ${i}: judge_model must be a plain Claude model id (the gating panel stays on Claude)`);
+    else if (fams.includes(judgeFamily)) problems.push(`row ${i}: judge '${row.judge_model}' is in the '${judgeFamily}' family it would grade (ADR 0024)`);
+  });
+  return problems;
+}
+
+function resolveJudgeTable(table) {
+  const problems = judgeTableProblems(table);
+  if (problems.length === 0) return table;
+  console.error(`grader: rubric v4.judge_by_builder_family refused (${problems.join('; ')}) — grading on the built-in judge table`);
+  return BUILTIN_JUDGE_TABLE;
+}
+const JUDGE_TABLE = resolveJudgeTable(V4.judge_by_builder_family);
+
 function workerModelFor(kind, graderModel, builderModel) {
   const tier = WORKER_MODEL_TIERS[kind];
   if (!tier) return graderModel;
@@ -137,12 +179,15 @@ const LLM_PROJECT = (() => {
 
 
 module.exports = {
+  BUILTIN_JUDGE_TABLE,
+  JUDGE_TABLE,
   LLM_PROJECT,
   MODEL_FAMILY_TOKENS,
   TRIVIAL_MAX_FILES,
   TRIVIAL_MAX_LINES,
   clamp,
   isTrivialDiff,
+  judgeTableProblems,
   median,
   r1,
   selectGraderModel,

package/modules/grading/grader-no-artifact.js

@@ -47,8 +47,9 @@
 
 const { LLM_PROJECT, selectGraderModel } = require('./grader-model.js');
 const { ASSUMED_BUILDER_MODEL, THRESHOLD, VERSION } = require('./grader-config.js');
-const { runOneShot } = require('./grader-subagent.js');
-const { aggregateShots } = require('./grader-score.js');
+const { extractAssistantResult, runSubagent } = require('./grader-subagent.js');
+const { validateAndScore } = require('./grader-score.js');
+const { median, r1 } = require('./grader-model.js');
 // SR-15 / #995. Every input this prompt carries is builder-controlled, and this
 // species is the HIGHEST-stakes place in the grader to leave that unfenced — see the
 // note above buildNoArtifactPrompt.
@@ -56,6 +57,228 @@ const { NOFOLLOW_PREAMBLE, fenceBlock } = require('./grader-workers/fence.js');
 
 const GRADER_KIND = 'subagent-no-artifact';
 
+// ---------- the generalist shot: one prompt, N independent readings ----------
+//
+// task 1002842 moved these two here from grader-subagent.js / grader-score.js. They
+// began as the v3 multi-shot grader's plumbing; the v3 GENERATION is retired, but
+// this species (and the trivial-diff fast path in grader.js, which still runs one
+// generalist shot) is built on them, so they live with their newest caller rather
+// than as a leftover of the generation that introduced them. Behaviour unchanged —
+// tests/grader.mjs pins aggregateShots and this file's tests pin the wiring.
+
+// Run one shot end-to-end: build the prompt (caller did this), spawn the
+// subagent at the requested model, parse + validate. Returns a per-shot
+// grade-result; subprocess failures become passed=false per-shot results so
+// aggregateShots can still produce a final verdict.
+async function runOneShot({ prompt, model, shotIndex, runOpts }) {
+  try {
+    const { stdout, run_ms, exit_code, cost_usd } = await runSubagent({
+      prompt,
+      opts: { ...runOpts, model },
+    });
+    const assistantResult = extractAssistantResult(stdout);
+    const scored = validateAndScore(assistantResult, {
+      run_ms,
+      exit_code,
+      raw_chars: stdout.length,
+      model,
+      shot_index: shotIndex,
+    });
+    // #486 (ADR 0028 path 1): carry this shot's own subprocess cost so the
+    // trivial-diff path (gradeSubagentV3MultiShot → aggregateShots) can sum it
+    // into panel_cost_usd just like the full panel does.
+    scored.cost_usd = cost_usd ?? null;
+    return scored;
+  } catch (err) {
+    return {
+      score: 0,
+      passed: false,
+      threshold: THRESHOLD,
+      grader_kind: 'subagent',
+      grader_version: VERSION,
+      rubric_scores: {},
+      signals: {
+        grader_kind: 'subagent',
+        grader_version: VERSION,
+        model,
+        threshold: THRESHOLD,
+        shot_index: shotIndex,
+        run_ms: err.run_ms ?? null,
+        exit_code: err.exit_code ?? null,
+        subprocess_error: err.code || 'UNKNOWN',
+        stderr_tail: (err.stderr || '').slice(-500),
+      },
+      notes_md: `Shot ${shotIndex}: subprocess failed (${err.code || 'UNKNOWN'}: ${err.message}).`,
+      issues: [],
+    };
+  }
+}
+
+// Collapses N per-shot grade-results into the final v3 grade-result.
+// Pass requires unanimous PASS on all shots; anything else (any FAIL, any
+// error, any disagreement) → not passed. Issues are deduped across shots
+// by (file, summary). Displayed rubric_scores use the median across shots
+// so the trend dashboard stays one-number-per-task.
+function aggregateShots(shotResults, meta = {}) {
+  const N = shotResults.length;
+  const verdicts = shotResults.map((s) => ({
+    passed: s.passed,
+    ff: s.rubric_scores?.functional_fidelity ?? null,
+    cq: s.rubric_scores?.code_quality ?? null,
+    economy: s.rubric_scores?.economy ?? null,
+    cq_effective: s.rubric_scores?.code_quality_effective ?? null,
+    confidence: s.signals?.confidence ?? null,
+    model: s.signals?.model ?? null,
+    run_ms: s.signals?.run_ms ?? null,
+    shot_index: s.signals?.shot_index ?? null,
+    notes_md: s.notes_md,
+    issues: s.issues || [],
+    error:
+      s.signals?.parse_error
+        ? 'parse_error'
+        : s.signals?.schema_error
+          ? 'schema_error'
+          : s.signals?.subprocess_error || null,
+  }));
+
+  const ff = median(verdicts.map((v) => v.ff));
+  const cq = median(verdicts.map((v) => v.cq));
+  const economy = median(verdicts.map((v) => v.economy));
+  const cqEffective = median(verdicts.map((v) => v.cq_effective));
+  // NB (task 1003318): this v3 multi-shot path still collapses a null axis to
+  // 0 — it serves the trivial-diff single shot, which cannot overflow a window;
+  // the panel path's lens-outage handling lives in validateAndScore.
+  const blended = ff != null && cq != null ? r1((ff + cq) / 2) : 0;
+  // Top-level aggregated confidence = median of per-shot confidences. Without
+  // this, ship.js forwards a null top-level confidence to /tasks/:id/grade,
+  // and the server's validateAndScore (re-running on the POST body) hits the
+  // Number(null)=0 trap → FAIL even though every shot independently passed.
+  // Caught on the MAS Phase 1 self-ship (#395).
+  //
+  // Computed UNROUNDED (no r1()) — confidence sits near a 0.4 gate cap so
+  // rounding to one decimal could nudge a borderline value across the cap
+  // in either direction. Per-shot confidences are already 0-1 floats.
+  const confVals = verdicts
+    .map((v) => v.confidence)
+    .filter((n) => Number.isFinite(n))
+    .sort((a, b) => a - b);
+  const confidenceMedian = confVals.length === 0
+    ? null
+    : confVals.length % 2
+      ? confVals[(confVals.length - 1) / 2]
+      : (confVals[confVals.length / 2 - 1] + confVals[confVals.length / 2]) / 2;
+
+  // Dedupe issues across shots by (file, summary). Keep first-seen severity.
+  const seen = new Set();
+  const issues = [];
+  for (const v of verdicts) {
+    for (const it of v.issues) {
+      if (!it || typeof it !== 'object') continue;
+      const key = `${it.file ?? ''}::${(it.summary ?? '').trim()}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      issues.push(it);
+    }
+  }
+
+  const passCount = verdicts.filter((v) => v.passed === true).length;
+  const failCount = verdicts.filter((v) => v.passed === false && !v.error).length;
+  const errorCount = verdicts.filter((v) => v.error).length;
+  const allPassed = N > 0 && passCount === N;
+
+  let verdict;
+  let passed;
+  let aggregationKind;
+  if (errorCount > 0) {
+    passed = false;
+    verdict = `FAIL — ${errorCount}/${N} shot(s) errored`;
+    aggregationKind = 'errored';
+  } else if (allPassed) {
+    passed = true;
+    verdict = `PASS — ${N}/${N} shots unanimous`;
+    aggregationKind = 'unanimous_pass';
+  } else if (passCount === 0) {
+    passed = false;
+    verdict = `FAIL — ${failCount}/${N} shots`;
+    aggregationKind = 'unanimous_fail';
+  } else {
+    passed = false;
+    verdict = `FAIL — ${passCount} pass, ${failCount} fail (no unanimous pass)`;
+    aggregationKind = 'disagreement';
+  }
+
+  const lines = [];
+  lines.push(`Subagent grader ${VERSION} (multi-shot, ${N}× shots) — ${verdict}`);
+  lines.push(`  functional_fidelity (median): ${ff ?? '?'}/10`);
+  lines.push(`  code_quality (median):        ${cq ?? '?'}/10`);
+  if (economy != null) {
+    lines.push(`  economy (advisory, median):   ${economy}/10`);
+  }
+  lines.push(`  blended (median):             ${blended}/10  (threshold ${THRESHOLD}, both axes must clear on EVERY shot)`);
+  lines.push('');
+  lines.push('Per-shot:');
+  for (let i = 0; i < verdicts.length; i++) {
+    const v = verdicts[i];
+    const status = v.error ? 'ERROR' : v.passed === true ? 'PASS' : 'FAIL';
+    const ffStr = v.ff != null ? `${v.ff}` : '?';
+    const cqStr = v.cq != null ? `${v.cq}` : '?';
+    const confStr = v.confidence != null ? `  conf=${v.confidence}` : '';
+    const errStr = v.error ? `  (${v.error})` : '';
+    lines.push(`  shot[${i}] ${status}  ff=${ffStr}  cq=${cqStr}${confStr}  ${v.model ?? '?'}${errStr}`);
+  }
+  if (issues.length > 0) {
+    lines.push('');
+    lines.push(`Issues (${issues.length} unique across shots):`);
+    for (const it of issues.slice(0, 20)) {
+      const sev = String(it.severity || '?').padEnd(7);
+      const file = String(it.file || '?');
+      const summary = String(it.summary || '').replace(/\s+/g, ' ').trim();
+      lines.push(`  [${sev}] ${file} — ${summary}`);
+    }
+    if (issues.length > 20) {
+      lines.push(`  ... ${issues.length - 20} more (full set in signals.shots[].issues)`);
+    }
+  }
+
+  // #486 (ADR 0028 path 1): sum each shot's own subprocess cost (envelope
+  // total_cost_usd) so the trivial-diff path reports panel_cost_usd the same way
+  // the full panel does. The single-shot trivial path is the common case here.
+  const panelCostUsd = shotResults.reduce((s, r) => s + (Number(r.cost_usd) || 0), 0);
+
+  return {
+    score: blended,
+    passed,
+    threshold: THRESHOLD,
+    grader_kind: 'subagent-multishot',
+    grader_version: VERSION,
+    panel_cost_usd: panelCostUsd, // #486: panel's own API spend (USD)
+    rubric_scores: {
+      functional_fidelity: ff,
+      code_quality: cq,
+      economy,
+      code_quality_effective: cqEffective,
+    },
+    signals: {
+      grader_kind: 'subagent-multishot',
+      grader_version: VERSION,
+      threshold: THRESHOLD,
+      // Top-level confidence = median across shots. ship.js forwards this to
+      // POST /tasks/:id/grade so the server-side re-validation has a real
+      // number rather than null (see Number(null)=0 fix in validateAndScore).
+      confidence: confidenceMedian,
+      shots: verdicts,
+      shot_count: N,
+      pass_count: passCount,
+      fail_count: failCount,
+      error_count: errorCount,
+      shot_aggregation: aggregationKind,
+      ...meta,
+    },
+    notes_md: lines.join('\n'),
+    issues,
+  };
+}
+
 // How much of the builder's prose the grader is shown. Handoff notes are the
 // EVIDENCE here rather than context around it, so the cap is generous — but it is a
 // cap, because an unbounded field reaches the model as an unbounded prompt.
@@ -339,9 +562,11 @@ async function gradeNoArtifact({ task, valueSummary, notes, builderModel, runOpt
 // which is the thing worth asserting on anyway.
 module.exports = {
   GRADER_KIND,
+  aggregateShots,
   NOTES_CHAR_CAP,
   SHOTS,
   buildNoArtifactPrompt,
   collapseUnanimous,
   gradeNoArtifact,
+  runOneShot,
 };

package/modules/grading/grader-prompt.js

@@ -9,7 +9,7 @@
 'use strict';
 
 const path = require('node:path');
-const { V3, generatedProvenance, workers } = require('./grader-config.js');
+const { generatedProvenance, workers } = require('./grader-config.js');
 const { LLM_PROJECT } = require('./grader-model.js');
 // The written role responsibilities, through the doorway (task 1003732). Lazy on
 // the api object, so requiring it here costs nothing until a prompt is built.

package/modules/grading/grader-providers.neutral.json

@@ -0,0 +1,4 @@
+{
+  "_comment": "The core's neutral starter for grader model providers (task 1002840, ADR 0089 §3): NONE, so a vanilla instance grades on Claude alone. An instance declares its own in config/grader-providers.json at the instance root. Each entry is { kind: 'openai-compatible', base_url: https://…, api_key_env: <ENV VAR NAME, never the key>, price_per_mtok: { <model>: { input, output } } }. Declaring one is an owner decision: it sends the diff under review to that vendor and costs money per call.",
+  "providers": {}
+}

package/modules/grading/grader-rubric.json

@@ -2,7 +2,7 @@
   "current_version": "v4",
   "threshold": 6.0,
   "version": "v4.0",
-  "_top_level_alias_note": "`threshold` and `version` mirror the current_version's threshold + version so consumers that still read grader.RUBRIC.threshold (e.g. routes/public.js, scripts/gds/audit-ships.js) keep working. Update all three (current_version, top-level threshold, top-level version) when promoting a new grader version.",
+  "_top_level_alias_note": "`threshold` and `version` mirror the current_version's threshold + version so consumers that still read grader.RUBRIC.threshold (e.g. routes/public.js) keep working. Update all three (current_version, top-level threshold, top-level version) when promoting a new grader version.",
   "v4": {
     "version": "v4.0",
     "grader_kind": "subagent-panel",
@@ -14,6 +14,11 @@
     "active_panel": ["narc", "quality", "hacker", "efficiency"],
     "worker_model_tiers": { "quality": "claude-sonnet-5", "reader": "claude-sonnet-5" },
     "worker_model_tiers_note": "task 1002660: per-worker cost tiering. Quality was 41% of panel spend with 75% nit findings — its cq/economy lens ran on the haiku tier. task 1003318: moved to claude-sonnet-5 — haiku 4.5's 200k window overflows on any diff over ~150 KB (`Prompt is too long`, deterministic; tasks 1003297 and 1003298 each lost three ~$5 panel runs to it) and a Quality worker that never starts is missing signal on a GATING lens. For fable/opus builders the panel model is already claude-sonnet-5, so the tier coincides with default_model and acts as a floor — a future default_model bump must not pin Quality back onto a smaller window; it stays a live cost lever only for haiku builders (whose panel runs on opus-5). workerModelFor refuses an override that lands on the builder's own model family (the ADR 0024 cross-model guarantee outranks the cost lever); gate semantics unchanged — Quality's verdict still gates identically. task 1003977: the READER is pinned to claude-sonnet-5 for the same task-1003318 reason — it is Read-heavy by construction (the voice guide, then the render paths that decide whether a string is user-facing), and a small window fails deterministically with PROMPT_TOO_LONG. For a NON-GATING worker that means silently reading no copy at all on exactly the biggest copy diffs, with nothing blocking to reveal it.",
+    "judge_by_builder_family": [
+      { "builder_families": ["fable", "mythos", "opus"], "judge_model": "claude-sonnet-5" },
+      { "builder_families": ["sonnet", "haiku"], "judge_model": "claude-opus-5" }
+    ],
+    "judge_by_builder_family_note": "task 1002840 (ADR 0089 §3): the cross-family judge choice selectGraderModel used to hard-code as an if/else — the first row whose family token appears in the builder's model id wins. Validated at load (grader-model.js judgeTableProblems): a judge in the family it grades (ADR 0024) or anything but a plain Claude id is refused and the whole table falls back to the built-in copy of exactly these two rows. An unmatched builder still grades on default_model with a warning (task 1002659).",
     "fallthrough_confidence": 0.3,
     "low_confidence_threshold": 0.4,
     "rationale": "GDS-V3 task #410 (MAS Phase 2.0), 2026-05-29. Supersedes v3 (single-prompt 3-shot generalist). Phase 1 calibration showed minimal between-shot disagreement on the same prompt — the strict gate fired correctly but the diversity signal was weak. v4 trades sampling-variance for lens-specialization: replace 3 identical-prompt shots with N workers (each a distinct prompt focused on one axis). Phase 2.0 ships 2 of the 3 planned workers (narc for completion, quality for cq + advisory economy) — keeps the gate at the same strictness while the framework calibrates. Phase 2.1 adds hacker (security; wraps /builder-redteam as a CI gate). Phase 2.2 adds efficiency_monger.",
@@ -76,90 +81,5 @@
     },
     "rubric_scores_audit_trail": "task_grades.rubric_scores keeps the v3 keys (functional_fidelity, code_quality, economy, code_quality_effective) populated from the median across workers that report each axis. Narc reports ff; Quality reports cq + economy. Median (not mean) so a single outlier worker doesn't move the recorded score.",
     "server_compat_note": "The grade POST body (POST /api/bongos/tasks/:id/grade) keeps the v3 shape (functional_fidelity, code_quality, economy, confidence, notes_md, issues) so the server's existing validateAndScore re-validation works without modification. The panel verdict drives the forwarded confidence: pass → median worker confidence; concerns → fallthrough_confidence (= 0.3); fail → 0. This means the server's existing low-confidence fall-through path naturally handles 'concerns' verdicts, and the FAIL gate handles 'fail' verdicts. Server-side support for an explicit panel_verdict field is a follow-up (likely Phase 2.5)."
-  },
-  "v3": {
-    "version": "v3.0",
-    "grader_kind": "subagent-multishot",
-    "threshold": 6.0,
-    "status": "DEPRECATED — superseded by v4 in GDS-V3 task #410 (2026-05-29). The 3-shot single-prompt path is kept reachable via grader.gradeSubagentV3MultiShot for explicit single-generalist-prompt diagnostics, but is not the active gate.",
-    "gate": "Both axes (functional_fidelity AND code_quality) must clear threshold on EVERY shot (3-shot unanimous-PASS gate) for confirmed→credits. Any single FAIL, any disagreement between shots, or any low-confidence shot keeps the task at completed; builder can manual-confirm via POST /tasks/:id/confirm if they think the grade is wrong (calibration release-valve — see ADR 0024).",
-    "default_model": "claude-sonnet-4-6",
-    "assumed_builder_model": "claude-opus-4-7",
-    "shots": 3,
-    "shot_aggregation": "unanimous_pass",
-    "rationale": "GDS-V3 task #395 (MAS Phase 1), 2026-05-29. Supersedes v2 (single-shot Opus on assumed-Opus builder, default-pass framing) which suffered from three structural leniencies: (1) same-family judge inflation ~10-15% per Zheng et al. 2023 and Chiang & Lee 2023; (2) no disagreement signal — one inflated score = pass; (3) default-pass prompt framing biased the grader toward 'find a score' over 'find what's wrong'. v3 fixes all three: (1) switches the default grader model to Sonnet 4.6 (cross-family from assumed-Opus builder); (2) runs 3 independent shots and requires unanimous PASS; (3) rewrites the prompt to default-fail (issues enumerated first, pass only if no material problems remain). See ADR 0024 (multi-agent system architecture) for full context and the calibration plan.",
-    "rubric_axes": {
-      "functional_fidelity": {
-        "scale": "0-10",
-        "doc": "Did the diff implement what the description scoped? Scope gaps, half-implementations, hardcoded shortcuts, TODOs left in, dummy/demo code that lies — all drag this down. 10 = every acceptance criterion in the description is satisfied by code (or explicitly out-of-scope per the description). 6 = mostly there with one named gap. 0 = the diff does not implement the described work or implements something else."
-      },
-      "code_quality": {
-        "scale": "0-10",
-        "doc": "Idiomatic for THIS codebase, readable, tested where new logic warrants tests, no dead code introduced, doesn't break invariants (e.g. methodology rules in CLAUDE.md, cross-verified Python/JS autotile lookups, ground-vs-object cell split per ADR 0012, the 'every change is backed by a claimed GDS task' rule, etc.). 10 = production-quality, would-merge-without-comment. 6 = ships but with a clear improvement the reviewer would suggest. 0 = obviously broken, hostile to maintenance."
-      },
-      "economy": {
-        "scale": "0-10",
-        "doc": "ADVISORY (carried from v2 / ADR 0017). Economy of the change: is the diff as small and simple as the task warrants? Penalize unnecessary abstraction, premature generalization, duplicated or dead code, and diffs larger than the work needs. Advisory: recorded in rubric_scores and blended into an advisory code_quality_effective signal, but does NOT independently hard-block. Promotion to a third both-must-pass axis remains a follow-up after calibration."
-      }
-    },
-    "shot_aggregation_doc": "v3 runs 3 independent grader subagents in parallel against the same prompt. Pass requires ALL THREE shots to report PASS (functional_fidelity >= threshold AND code_quality >= threshold AND confidence >= low_confidence_threshold). Any FAIL, any disagreement, or any low-confidence shot → fall through to completed state and existing manual-confirm endpoint. Per-shot results are persisted in task_grades.signals.shots[]; displayed rubric_scores use the median across shots (so the trend dashboard stays one-number-per-task). The blended task_grades.score is the median (ff+cq)/2 across shots.",
-    "cross_family_doc": "v3's default grader model (Sonnet 4.6) is intentionally different from the assumed builder model (Opus 4.7). This carves out from CLAUDE.md §2's 'default to Opus' rule — that rule covers subagents that produce work that ships (research → code); grading is *verification*, where adversarial cross-family perspective beats raw capability. When per-builder model preferences land (ADR 0021 follow-up), the grader's selectGraderModel(builderModel) function generalizes this: builder Opus → grader Sonnet; builder Sonnet → grader Opus; builder Haiku → grader Opus. The panel composition (3× Sonnet) was chosen over a mixed panel (Sonnet/Opus/Haiku) to keep grading-scale consistent across shots; if 3× Sonnet shows insufficient disagreement signal during calibration, Phase 1.5 mixes the panel.",
-    "economy_gate_note": "Carried over from v2 (V3.R92 #353). Economy remains ADVISORY in v3. The hard gate stays functional_fidelity >= threshold AND code_quality >= threshold, each on its own raw score, unanimous across shots. Economy nudges code_quality_effective DOWN only, never gates by itself. Hardening economy into a third both-must-pass axis remains deferred until calibration data exists.",
-    "economy_blend": "code_quality_effective = code_quality - max(0, (THRESHOLD - economy) / 2), clamped to [0,10]. Applied per-shot; the displayed median uses median(code_quality_effective) for the trend dashboard. Not used by the pass gate.",
-    "output_schema": {
-      "type": "object",
-      "required": ["functional_fidelity", "code_quality", "notes_md", "issues", "confidence"],
-      "properties": {
-        "functional_fidelity": { "type": "number", "minimum": 0, "maximum": 10 },
-        "code_quality":        { "type": "number", "minimum": 0, "maximum": 10 },
-        "economy":             { "type": "number", "minimum": 0, "maximum": 10, "doc": "ADVISORY. Recorded and blended into code_quality_effective; does NOT hard-block. Optional for back-compat: absent → recorded as null, no penalty." },
-        "security_score":      { "type": "number", "minimum": 0, "maximum": 10, "doc": "ADVISORY (MAS Phase 2.5 #423). Reported by Hacker (Phase 2.1). Recorded in rubric_scores for audit + trend; does NOT hard-block server-side — Hacker's per-worker verdict drives the panel gate via confidence-forwarding. Optional for back-compat: absent → recorded as null, no penalty." },
-        "efficiency_score":    { "type": "number", "minimum": 0, "maximum": 10, "doc": "ADVISORY (MAS Phase 2.5 #423). Reported by Efficiency Monger (Phase 2.2). Recorded in rubric_scores for audit + trend; does NOT hard-block server-side — Efficiency Monger's per-worker verdict drives the panel gate via confidence-forwarding. Optional for back-compat: absent → recorded as null, no penalty." },
-        "notes_md":            { "type": "string" },
-        "confidence":          { "type": "number", "minimum": 0, "maximum": 1, "doc": "Self-reported confidence (0-1). Low confidence (<0.4) on ANY shot causes a fall-through to manual /tasks/:id/confirm." },
-        "issues": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "required": ["severity", "file", "summary"],
-            "properties": {
-              "severity": { "type": "string", "enum": ["blocker", "major", "minor", "nit"] },
-              "file":     { "type": "string" },
-              "summary":  { "type": "string" }
-            }
-          }
-        }
-      }
-    },
-    "low_confidence_threshold": 0.4,
-    "blended_score_for_audit_trail": "We blend the two axes 50/50 (median across shots) into the task_grades.score column so the existing trend dashboard and view (task_grades_with_context) keep working. The gate, though, requires BOTH axes >= threshold ON EVERY SHOT — a median of 7.5 across shots does NOT pass if any individual shot was below 6.0."
-  },
-  "v1": {
-    "version": "v1.1",
-    "grader_kind": "auto",
-    "threshold": 6.0,
-    "status": "DEPRECATED — superseded by v2 in GDS-V3 task #209 (2026-05-13). The v1 entry points still exist in modules/grading/grader.js (gradeDeterministic + per-criterion helpers) because scripts/gds/audit-ships.js (the retroactive #204 audit) imports them. v1 is no longer invoked at ship time.",
-    "rationale": "Raised from 5.0 → 6.0 on 2026-05-12 (PMS-V2 #207) after the retroactive audit of #204 graded 92 ships and found 0 failures, median 6.2, floor 5.2. At threshold 5.0 the gate was structurally incapable of failing a shipped task because value_summary + scanner_smoke alone delivered ~5.2 even with everything else zeroed.",
-    "weights": {
-      "common": {
-        "est_actual_band":   { "weight": 0.25, "doc": "actual_minutes / est_minutes ratio. 10 in [0.5, 2.0], drops linearly outside, 0 below 0.1 or above 10." },
-        "value_summary":     { "weight": 0.25, "doc": "0 if empty, 5 if <40 chars, 8 if 40-120 chars, 10 if 120+ chars and contains a verb." },
-        "diff_hygiene":      { "weight": 0.20, "doc": "10 if 1-50 files changed and lines_added+lines_removed > 0. 5 if files_changed > 50 (too broad). 0 if zero diff (phantom ship)." },
-        "scanner_smoke":     { "weight": 0.10, "doc": "Constant 10 at grader time (already hard-gated upstream). Recorded for audit trail." },
-        "scoping_signal":    { "weight": 0.20, "doc": "Reads tasks.scoping_confidence: 0=2/10, 1=4, 2=6, 3=7, 4=8, 5=10. NULL=6 (neutral)." }
-      },
-      "kind_specific": {
-        "cleanup": {
-          "loc_net_negative": { "weight": 0.20, "doc": "Bonus criterion that REPLACES diff_hygiene weight for cleanup tasks. 10 if lines_removed > lines_added. 5 if net-zero. 0 if cleanup increased LOC." }
-        },
-        "learning-capture": {
-          "learning_row":     { "weight": 0.20, "doc": "Bonus criterion that REPLACES diff_hygiene for learning-capture. 10 if a learnings row exists for the task and body_md > 100 chars. 5 if row exists but body short. 0 if no row." }
-        },
-        "art-pipeline": {
-          "art_rubric_avg":   { "weight": 0.30, "doc": "Bonus criterion. Average of art rubric scores from local art/iterations/<task>/summary.json. Passed up by ship.js in signals.art_rubric_avg. Skipped if absent." }
-        }
-      }
-    },
-    "shape_note": "Common weights sum to 1.0. Kind-specific bonus weights are merged in by REPLACING the matching common weight name where applicable; otherwise additive then renormalized so total stays 1.0."
   }
 }