@bongos/core 1.21.175 → 1.21.176

package/scripts/gds/conductor-dispatch.js

@@ -1,535 +1,7 @@
 #!/usr/bin/env node
-// MAS Phase 4 (#439) — Conductor dispatcher.
-//
-// Runs one or more grader specialists on the CURRENT working diff — the
-// mid-flight counterpart to the ship-time panel. It REUSES the exact
-// grader-workers/* machinery (same prompts, same cross-family model, same
-// verdict logic), so a mid-flight Hacker review and a ship-time Hacker review
-// are literally the same code. This is the "dispatch" capability the Conductor
-// points at: when you've touched a security surface, you (or the Conductor's
-// directive) run this to bring the Hacker in NOW instead of waiting for ship.
-//
-// Dispatch mode is SESSION-MEDIATED (ADR 0024 Phase 4): the specialist-on-diff
-// modes below run inside the builder's session, visibly. The Conductor hook
-// recommends running it; the session executes it.
-//
-// Phase 4.5 (ADR 0024 — the one deferred MAS leg) adds the AUTONOMOUS path:
-// `auto-dispatch` selects the next claimable autonomous task WITHOUT a human
-// prompt and emits a dispatch directive (the `/builder-claim` command) for a
-// runner to execute. It still "proposes, never disposes" — this entry point
-// SELECTS + EMITS; it does not itself spawn a build session or land code (that
-// stays the runner/ship-pipeline's job, where ADR 0016's DB-enforced gates and
-// the grader still bite). It is gated by the same $0 deterministic
-// `autonomy-gate` precheck the nightly routines use, so it is INERT until
-// OTB_AUTONOMY_ENABLED=1 and respects the MTD spend brake + no-signal skips.
-// The claimable feed is the protected-path-filtered `fit:'autonomous'` view, so
-// the permission/methodology/deploy core can never be auto-selected (SR-12).
-//
-// Usage:
-//   node scripts/gds/conductor-dispatch.js [hacker|narc|quality|efficiency|auto|all] [--base <ref>]
-//   node scripts/gds/conductor-dispatch.js auto-dispatch [--json]
-//
-//   auto  (default) → pick specialists by what changed (Hacker if a security
-//                     surface is in the diff; nothing otherwise → suggests `all`)
-//   all             → run the full 4-worker panel on the current diff
-//   <name>          → run just that specialist
-//   auto-dispatch   → Phase 4.5: autonomous selection. Gate → pick the top
-//                     claimable autonomous task → emit its claim directive.
-//
-// Diff = everything different from origin/main right now: committed-on-branch
-// PLUS uncommitted, via `git diff <merge-base HEAD origin/main>`.
-//
-// Exit code: 0 if no worker returned verdict 'fail'; 1 if any did (so it can
-// gate a script). Informational findings print regardless. For auto-dispatch:
-// 0 when a task was selected (a directive was emitted), 1 on a NO-GO / no work.
-
-const { execFileSync } = require('node:child_process');
-// basename(cwd) is the worktree name a claim is bound to (task 1003834) — the
-// same value claim.js records via --worktree.
-const path = require('node:path');
-const { cliClient } = require('./cli-lib');
-const grader = require('../../modules/grading/grader');
-// Phase 4.5: reuse the $0 deterministic autonomy precheck (the same gate the
-// nightly routines run as Step 0). It owns the master kill-switch, the MTD
-// spend brake, and the no-signal skip — autonomous dispatch must not re-invent
-// any of them. Built INERT (OTB_AUTONOMY_ENABLED off) → precheck returns GO but
-// gatherSignals isn't paid for; selection below still runs but the runner that
-// consumes the directive is what actually spends.
-const autonomyGate = require('./autonomy-gate');
-// Single source of truth shared with the Conductor hook — see
-// src/bongos/sensitive-surfaces.js. (The Phase 4 dogfood flagged the prior
-// hand-copied pattern set in this file as a drift risk vs. the hook.)
-const { isSensitive } = require('../../src/bongos/sensitive-surfaces');
-// Canonical touches[] matcher — the same one ship.js's scanner + the Conductor
-// hook use. (#439 first-ship: the panel flagged that bestMatchingClaim had
-// re-hand-rolled this coverage logic — the exact drift this PR fixed for the
-// sensitive-surface set. Route through the one matcher instead.)
-const { matchOne } = require('../../src/bongos/path-match');
-// The worktree→claim rule, shared with .claude/hooks/conductor.js — the third
-// member of this file's "one definition, both conductors" set (task 1003837).
-const { claimForWorktree } = require('../../src/bongos/claim-attribution');
-
-const GRADER_DIFF_CHAR_CAP = 250_000;
-const GRADER_TIMEOUT_MS = 240_000;
-
-// --- pure: which specialists does `auto` pick for a given changed-file set? ---
-// Phase 4 auto-dispatch is deliberately security-focused: Hacker is the
-// highest-value mid-flight check and the one cleanly triggered by file paths.
-// Efficiency Monger needs perf-context paths don't reveal; Narc/Quality want
-// a finished task to grade against — all three remain available explicitly.
-function pickSpecialists(changedFiles) {
-  const picks = [];
-  if ((changedFiles || []).some((f) => isSensitive(f))) {
-    picks.push('hacker');
-  }
-  return picks;
-}
-
-// --- pure: Phase 4.5 autonomous task selection ---
-// Given a GO/NO-GO gate result and the already-fetched claimable-autonomous
-// feed, pick the work to dispatch and shape the directive. Pure (no I/O) so the
-// selection contract is unit-testable; the live gate + feed are gathered in
-// autoDispatch() below.
-//
-// Contract:
-//   - gate.decision !== 'go'           → { ok:false, reason } (no work dispatched)
-//   - empty/absent feed                → { ok:false, reason:'no claimable…' }
-//   - otherwise                        → { ok:true, task, command, directive }
-//
-// The feed is ALREADY ordered by priority then calibrated-estimate then
-// created_at (listClaimableTasks) and ALREADY protected-path filtered for the
-// autonomous fit (SR-12), so "the top row" is the right pick — we don't
-// re-rank, we take rows[0]. command is the exact `/builder-claim` a runner
-// runs; the entry point proposes it, the runner disposes.
-function selectAutonomousDispatch(gate, claimable) {
-  if (!gate || gate.decision !== 'go') {
-    return { ok: false, reason: gate ? gate.reason : 'no gate decision' };
-  }
-  const rows = Array.isArray(claimable) ? claimable : [];
-  if (rows.length === 0) {
-    return { ok: false, reason: 'no claimable autonomous tasks — nothing to dispatch' };
-  }
-  const t = rows[0];
-  const task = {
-    id: t.id,
-    title: t.title || '(untitled)',
-    version_id: t.version_id,
-    est_minutes: t.est_minutes_calibrated != null ? t.est_minutes_calibrated : t.est_minutes,
-    discipline: t.discipline || null,
-  };
-  const command = `node scripts/gds/claim.js ${task.id}`;
-  return {
-    ok: true,
-    task,
-    command,
-    directive: `Autonomously dispatch task #${task.id} — ${task.title}. Run \`${command}\`, build it, then \`/builder-ship\`.`,
-  };
-}
-
-// --- git diff plumbing (mirrors scripts/gds/ship.js's computation) ---
-
-function git(args) {
-  try {
-    return execFileSync('git', args, { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
-  } catch (_) {
-    return '';
-  }
-}
-
-function repoRoot() {
-  const top = git(['rev-parse', '--show-toplevel']).trim();
-  return top || process.cwd();
-}
-
-function resolveBase(explicit) {
-  if (explicit) return explicit;
-  const mb = git(['merge-base', 'HEAD', 'origin/main']).trim();
-  // Fallback when origin/main can't be resolved (offline / fresh clone): diff
-  // against HEAD. NOTE this only surfaces UNCOMMITTED work — committed-on-branch
-  // changes are relative to a base we couldn't compute, so they're dropped in
-  // this degraded mode. Untracked files are still picked up separately.
-  return mb || 'HEAD';
-}
-
-function untrackedFiles() {
-  // `git diff` shows only TRACKED changes — brand-new files are invisible to
-  // it. A security/quality reviewer must not be blind to a new route file, so
-  // we list untracked files explicitly (mirrors the hook's status-based
-  // collection). The worker has a Read tool + cwd=repo root, so naming them is
-  // enough — it can Read the contents.
-  const out = git(['ls-files', '--others', '--exclude-standard']);
-  return out.split('\n').map((s) => s.trim()).filter(Boolean);
-}
-
-// `untracked` is computed once in main() and threaded through, so we don't
-// spawn `git ls-files` twice per dispatch (Efficiency Monger flagged the
-// double-spawn on the Phase 4 dogfood).
-function changedFilesSince(base, untracked) {
-  // `git diff --name-only <base>` = tracked changes (committed + uncommitted)
-  // vs base. Union with untracked so new files are included.
-  const tracked = git(['diff', '--name-only', base]).split('\n').map((s) => s.trim()).filter(Boolean);
-  return [...new Set([...tracked, ...untracked])];
-}
-
-function diffTextSince(base, untracked) {
-  let diff = git(['diff', '--no-color', '-M', base]);
-  // Note untracked files at the tail so the worker knows to Read them (their
-  // content isn't in the tracked diff).
-  if (untracked.length) {
-    diff += `\n\n[untracked new files — not shown in the diff above; Read them for content]\n${untracked.map((f) => `  + ${f}`).join('\n')}\n`;
-  }
-  if (!diff.trim()) return '';
-  if (diff.length > GRADER_DIFF_CHAR_CAP) {
-    return `${diff.slice(0, GRADER_DIFF_CHAR_CAP)}\n\n[diff truncated — original ${diff.length} chars. The worker can Read any file for full context.]`;
-  }
-  return diff;
-}
-
-function diffStatsSince(base, untracked) {
-  const s = git(['diff', '--shortstat', base]);
-  const f = /(\d+)\s+files?\s+changed/.exec(s);
-  const i = /(\d+)\s+insertions?\(\+\)/.exec(s);
-  const d = /(\d+)\s+deletions?\(-\)/.exec(s);
-  // Untracked new files aren't in `git diff` shortstat; add them to the file
-  // count so the worker's diff-size context isn't undercounted. (Their line
-  // counts aren't computed — the worker has the file list + a Read tool.)
-  const untrackedCount = Array.isArray(untracked) ? untracked.length : 0;
-  return {
-    files_changed: (f ? Number(f[1]) : 0) + untrackedCount,
-    lines_added: i ? Number(i[1]) : 0,
-    lines_removed: d ? Number(d[1]) : 0,
-  };
-}
-
-// THE WORKTREE IS THE ANSWER, when there is one (task 1003834).
-//
-// A claim BINDS to a dedicated worktree — one claim per session, one worktree
-// per claim (task 1642, ADR 0097) — and `claim.js --worktree` records that
-// worktree's leaf-folder name on the claim row, which is exactly
-// `path.basename(process.cwd())`. So when this dispatch runs inside a claimed
-// worktree there is no inference to do: that worktree's claim IS the task being
-// worked on. Everything below it is a heuristic; this is a fact.
-//
-// Claims from before the column existed carry a null worktree_name and are
-// simply not matched here — the heuristic still covers them.
-//
-// The rule itself moved to src/bongos/claim-attribution.js in task 1003837, so
-// the conductor HOOK can answer the same question the same way without pulling
-// this module (and cli-lib, and the grader) into a per-prompt hook. Re-exported
-// below, so every existing importer and test is unchanged.
-
-// Pick the active claim whose touches[] best overlap the changed files — the
-// claim the current diff most plausibly belongs to. With multiple (possibly
-// stale) claims, blindly taking claims[0] grades the diff against the wrong
-// task: the Phase 4 dogfood's Narc FAILed because it graded Conductor code
-// against an unrelated stale offsite-backup claim. Best-overlap fixes that.
-//
-// SPECIFICITY, NOT VOLUME (task 1003834). A raw count of matched files rewards
-// BREADTH, so the more honestly a claim declares its touches[] the more likely
-// it loses. Observed 2026-09-10: reviewing task 1003829's diff, its own claim
-// declared three exact files (`modules/hall-ui/public/studio.{js,html,css}`) and
-// could therefore score at most 3, while a concurrent rename claim declaring
-// `scripts/gds/`, `src/bongos/`, `modules/`, `clients/` matched most of the
-// same diff and won — so the reviewer was briefed on an unrelated task. A
-// pattern like `modules/` covers almost any diff in this repo and must not
-// out-vote an exact path.
-//
-// So each matched file is worth the SPECIFICITY of the pattern that matched it:
-// its path-segment depth, plus a bonus when the pattern is the file itself.
-// Volume still counts — a genuinely broad claim matching fifty files beats a
-// narrow one sharing a single file — but depth breaks the tie the right way.
-function patternWeight(pattern, file) {
-  const p = String(pattern || '');
-  const depth = p.replace(/\/+$/, '').split('/').filter(Boolean).length;
-  return depth + (p === file ? EXACT_MATCH_BONUS : 0);
-}
-const EXACT_MATCH_BONUS = 1;
-
-function claimOverlapScore(claim, files) {
-  let score = 0;
-  for (const f of files) {
-    const hit = matchOne(f, (claim && claim.touches) || []);
-    if (hit !== null) score += patternWeight(hit, f);
-  }
-  return score;
-}
-
-function bestMatchingClaim(claims, changedFiles) {
-  if (!Array.isArray(claims) || claims.length === 0) return null;
-  const files = Array.isArray(changedFiles) ? changedFiles : [];
-  let best = claims[0];
-  let bestScore = -1;
-  for (const c of claims) {
-    // Use the canonical matcher; ties keep the earlier claim (strict >).
-    const score = claimOverlapScore(c, files);
-    if (score > bestScore) { bestScore = score; best = c; }
-  }
-  return best;
-}
-
-// The claim this diff belongs to, and HOW that was decided — because the two
-// answers deserve very different trust. 'worktree' is a fact; 'overlap' is a
-// guess, and a guess that must be visible so a reader can discount a review
-// that argues from the brief rather than from the diff.
-//
-// A claim with an EMPTY touches[] scores zero against any diff, which is most
-// tasks in this repo — another reason the worktree signal leads rather than
-// merely breaking ties.
-function attributeClaim(claims, changedFiles, worktreeName) {
-  const byWorktree = claimForWorktree(claims, worktreeName);
-  if (byWorktree) return { claim: byWorktree, signal: 'worktree', worktree: worktreeName };
-  const byOverlap = bestMatchingClaim(claims, changedFiles);
-  if (!byOverlap) return { claim: null, signal: 'none', worktree: worktreeName || null };
-  const score = claimOverlapScore(byOverlap, Array.isArray(changedFiles) ? changedFiles : []);
-  return { claim: byOverlap, signal: score > 0 ? 'overlap' : 'fallback', worktree: worktreeName || null };
-}
-
-// --- task context (best-effort) ---
-// Workers grade a diff against a task. For a mid-flight review we use the
-// best-matching active claim's task; otherwise we synthesize a minimal
-// context so the specialist judges the diff on its own merits.
-async function resolveTaskContext(changedFiles) {
-  try {
-    const api = await cliClient();
-    const me = await api.me.getMe();
-    if (me.ok) {
-      const claims = me.data.active_claims || (me.data.active_claim ? [me.data.active_claim] : []);
-      if (claims.length > 0) {
-        // The worktree this dispatch was invoked in decides it when it can
-        // (task 1003834); the touches[] heuristic is the fallback, and which
-        // one answered is reported to the reader rather than hidden.
-        const attribution = attributeClaim(claims, changedFiles, path.basename(process.cwd()));
-        const c = attribution.claim;
-        // attributeClaim's documented { claim: null, signal: 'none' } return —
-        // not dead defensive code, and not a crash path: the throw is caught by
-        // this function's own catch below, which is where the no-claim context
-        // is synthesized. Unreachable only because the caller happens to check
-        // claims.length first; it states the seam's contract rather than relying
-        // on that. (Task 1003834's grade panel read it as a dead branch and
-        // filed it as a nit; kept, with this sentence, per task 1003837.)
-        if (!c) throw new Error('no claim attributed');
-        // Pull the full description for richer context (best-effort). Coerce
-        // task_id to an integer before interpolating it into the URL path —
-        // it's a trusted internal value, but a guard costs nothing and closes
-        // the theoretical path-injection the Hacker noted.
-        let description = '';
-        const taskId = Number(c.task_id);
-        if (Number.isInteger(taskId)) {
-          try {
-            const t = await api.tasks.getTasksId({ id: taskId });
-            if (t.ok && t.data.task) description = t.data.task.description || '';
-          } catch (_) { /* fall through to title-only */ }
-        }
-        return {
-          id: c.task_id,
-          title: c.title || '(active claim)',
-          description: description || '(no description fetched — mid-flight review; judge the diff on its own merits)',
-          kind: 'unclassified',
-          version_id: c.version_id,
-          // How this task was attributed to this diff, carried so the header can
-          // say it (task 1003834). 'worktree' is a fact; anything else is a
-          // guess the reader should weigh.
-          attribution: attribution.signal,
-          claim_count: claims.length,
-        };
-      }
-    }
-  } catch (_) { /* offline / no session */ }
-  return {
-    id: null,
-    title: '(mid-flight review — no active claim)',
-    description: 'Conductor mid-flight dispatch. No formal task/acceptance context; review the current working changes for this specialist\'s concern and judge the diff on its own merits.',
-    kind: 'unclassified',
-  };
-}
-
-// --- rendering ---
-
-// Say how the task context was chosen, but only when saying it changes what a
-// reader should do (task 1003834). Attribution by WORKTREE is certain, and a
-// single claim leaves nothing to confuse, so both stay silent. A guess made
-// while several claims were open is the case that misled a reader before, and
-// it says so out loud.
-function attributionNote(task) {
-  if (!task || !task.id) return '';
-  const n = Number(task.claim_count) || 0;
-  if (task.attribution === 'worktree' || n < 2) return '';
-  const how = task.attribution === 'overlap'
-    ? 'guessed from touches[] overlap'
-    : 'no signal at all — first claim taken';
-  return `\n   ⚠ attribution: ${how}, across ${n} open claims. This worktree is bound to no claim, so the brief`
-    + '\n     may belong to different work: weigh findings about the FILES, discount findings about intent.';
-}
-
-function renderWorker(w) {
-  const lines = [];
-  const status = w.error ? `ERROR (${w.error})` : w.verdict.toUpperCase();
-  const scores = Object.entries(w.scores || {})
-    .filter(([, v]) => Number.isFinite(v))
-    .map(([k, v]) => `${k}=${v}`)
-    .join('  ');
-  lines.push(`── ${w.name} — ${status}${scores ? '  ·  ' + scores : ''}${w.confidence != null ? `  ·  conf=${w.confidence}` : ''}`);
-  if (Array.isArray(w.issues) && w.issues.length) {
-    for (const it of w.issues) {
-      const sev = String(it.severity || '?').padEnd(7);
-      lines.push(`   [${sev}] ${it.file || '?'} — ${String(it.summary || '').replace(/\s+/g, ' ').trim()}`);
-    }
-  }
-  // First substantive line of the worker's own notes, for a human-readable
-  // gist. The worker's notes_md always opens with a "<Name> — VERDICT (...)"
-  // header line we've already rendered (status/scores above), so drop line 0
-  // and take the next non-empty line — robust regardless of its content.
-  const noteLines = (w.notes_md || '').split('\n').slice(1);
-  const note = noteLines.find((l) => l.trim());
-  if (note) lines.push(`   ${note.trim()}`);
-  return lines.join('\n');
-}
-
-// --- Phase 4.5: autonomous background dispatch ---
-// Gate (deterministic, $0) → select the top claimable autonomous task → emit
-// the claim directive. No git diff, no grader, no model spend in this path: it
-// is the SELECTOR, and the runner that consumes the directive is what spends.
-// Deps are injectable so the live wiring stays a thin shell over pure logic.
-async function autoDispatch(deps = {}) {
-  const ROUTINE = 'conductor-auto-dispatch';
-  const precheck = deps.precheck || autonomyGate.precheck;
-  // The same protected-path-filtered autonomous feed the gate itself counts.
-  // Required lazily (a module require) so `require()`-ing this file for its pure
-  // exports never pulls the lifecycle data layer / a DB pool.
-  const listClaimable = deps.listClaimableTasks
-    || ((opts) => require('../../modules/lifecycle/db').listClaimableTasks(opts));
-
-  const gate = await precheck(ROUTINE).catch((e) => ({ decision: 'no-go', reason: `gate error: ${e && e.message}` }));
-  // Only pay for the feed when the gate said GO.
-  let claimable = [];
-  if (gate.decision === 'go') {
-    claimable = await listClaimable({ fit: 'autonomous' }).catch(() => []);
-  }
-  const result = selectAutonomousDispatch(gate, claimable);
-  return { routine: ROUTINE, gate, ...result };
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-
-  // Phase 4.5 — autonomous dispatch is its own mode (no diff/grader machinery).
-  if (args.includes('auto-dispatch')) {
-    const out = await autoDispatch();
-    if (args.includes('--json')) {
-      console.log(JSON.stringify(out, null, 2));
-    } else {
-      console.log(`🎼 Conductor auto-dispatch — gate: ${out.gate.decision.toUpperCase()} (${out.gate.reason})`);
-      if (out.ok) {
-        console.log(`   → selected task #${out.task.id}: ${out.task.title}`);
-        console.log(`   → ${out.directive}`);
-      } else {
-        console.log(`   → no dispatch: ${out.reason}`);
-      }
-    }
-    process.exit(out.ok ? 0 : 1);
-  }
-
-  const baseArg = (() => { const i = args.indexOf('--base'); return i >= 0 ? args[i + 1] : null; })();
-  // --base is passed to git as an array arg (no shell), but reject anything
-  // that isn't a plausible ref so a malformed value can't silently produce a
-  // misleading review scope (dev-tool surface, but cheap to validate).
-  // Reject anything that isn't a plausible git ref (first char not '-', so a
-  // value like '--format=...' can't masquerade as a ref).
-  if (baseArg && !/^[\w.@~^{}/][\w./@~^{}-]*$/.test(baseArg)) {
-    console.error(`Invalid --base ref '${baseArg}'. Expected a git ref (commit/branch/tag).`);
-    process.exit(2);
-  }
-  const target = (args.find((a) => !a.startsWith('--') && a !== baseArg) || 'auto').toLowerCase();
-
-  const root = repoRoot();
-  process.chdir(root); // so workers' Read tool resolves repo-relative paths
-  const base = resolveBase(baseArg);
-  const untracked = untrackedFiles(); // computed once, threaded through
-  const files = changedFilesSince(base, untracked);
-  const diff = diffTextSince(base, untracked);
-  const stats = diffStatsSince(base, untracked);
-
-  if (files.length === 0) {
-    console.log('Conductor dispatch: no changes vs origin/main — nothing to review.');
-    process.exit(0);
-  }
-
-  // Resolve which specialists to run.
-  const REGISTRY = grader.WORKERS.REGISTRY;
-  let kinds;
-  if (target === 'all') {
-    kinds = grader.WORKERS.DEFAULT_PANEL.slice();
-  } else if (target === 'auto') {
-    kinds = pickSpecialists(files);
-    if (kinds.length === 0) {
-      console.log(`Conductor dispatch (auto): ${files.length} file(s) changed, none on a security surface — nothing auto-triggers.`);
-      console.log('For a full mid-flight review of all four lenses, run:  node scripts/gds/conductor-dispatch.js all');
-      process.exit(0);
-    }
-  } else if (Object.hasOwn(REGISTRY, target)) {
-    // hasOwn, not truthiness — a target of '__proto__'/'constructor' would
-    // otherwise resolve off Object.prototype rather than a real worker.
-    kinds = [target];
-  } else {
-    console.error(`Unknown specialist '${target}'. Use one of: ${Object.keys(REGISTRY).join(', ')}, auto, all.`);
-    process.exit(2);
-  }
-
-  const task = await resolveTaskContext(files);
-  const model = grader.selectGraderModel({});
-  const valueSummary = '(work in progress — Conductor mid-flight dispatch; no final value summary yet)';
-
-  // Deterministic route-rank pre-pass (#475) — same helper the ship-time
-  // grader uses. Findings feed the Hacker as input; its pseudo-worker result
-  // is appended below so the dispatch verdict reflects it. Runs only when a
-  // route file is in the diff (zero cost otherwise).
-  const routeRank = grader.routeRankPrePass(files);
-
-  console.log(`🎼 Conductor dispatch → ${kinds.join(', ')}  (model=${model}, ${files.length} changed file(s), base=${base.slice(0, 8)})`);
-  console.log(`   task context: ${task.id ? '#' + task.id + ' ' + task.title : task.title}${attributionNote(task)}`);
-  if (routeRank) console.log('   + deterministic route-rank check (route file in diff)');
-  console.log('');
-
-  const results = await Promise.all(kinds.map((k) => grader.WORKERS.runWorker(REGISTRY[k], {
-    task,
-    valueSummary,
-    diff,
-    changedFiles: files,
-    diffStats: stats,
-    model,
-    runOpts: { timeoutMs: GRADER_TIMEOUT_MS, cwd: root },
-    runSubagentFn: grader.runSubagent,
-    extractAssistantResultFn: grader.extractAssistantResult,
-    deterministicFindings: routeRank ? routeRank.findings : null,
-  })));
-  // Append the deterministic pseudo-worker so a write-route 'unknown' fails the
-  // dispatch on its own, even if the requested specialist set excludes Hacker.
-  if (routeRank) results.push(routeRank.workerResult);
-
-  for (const w of results) {
-    console.log(renderWorker(w));
-    console.log('');
-  }
-
-  const anyFail = results.some((w) => w.verdict === 'fail');
-  const anyConcerns = results.some((w) => w.verdict === 'concerns');
-  const summary = anyFail ? 'FAIL — at least one specialist flagged a blocker'
-    : anyConcerns ? 'CONCERNS — review the flagged items'
-      : 'CLEAR — no blocking findings';
-  console.log(`Conductor dispatch verdict: ${summary}`);
-  process.exit(anyFail ? 1 : 0);
-}
-
-if (require.main === module) {
-  main().catch((err) => {
-    console.error('Conductor dispatch error:', err && err.message ? err.message : err);
-    process.exit(2);
-  });
-}
-
-module.exports = {
-  pickSpecialists, bestMatchingClaim, selectAutonomousDispatch, autoDispatch,
-  // task 1003834 — the attribution layer, exported so its decisions are pinned
-  // rather than only observed through a dispatch run.
-  claimForWorktree, claimOverlapScore, attributeClaim, attributionNote,
-};
+// scripts/gds/conductor-dispatch.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/conductor-dispatch.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
+'use strict';
+require('../bongos/forwarder.js').forward(module, 'conductor-dispatch.js');