@bongos/core 1.21.175 → 1.21.177

package/scripts/bongos/conductor-dispatch.js

@@ -0,0 +1,535 @@
+#!/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/bongos/conductor-dispatch.js [hacker|narc|quality|efficiency|auto|all] [--base <ref>]
+//   node scripts/bongos/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/bongos/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/bongos/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/bongos/`, `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/bongos/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,
+};