@mmerterden/multi-agent-pipeline 16.27.0 → 16.29.0

package/pipeline/scripts/council-view.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// council-view.mjs  -  what each reviewer found, and what triage did with it.
+//
+// Phase 4 dispatches three reviewers, anonymizes their findings so the judge
+// cannot mark its own homework, and reports the verdict. Everything needed to
+// answer "which model found this, and was it kept" is already on the state -
+// reviewers[].findings, anonymizationMap.labelToModel, triage.accepted -  and
+// nothing ever renders it. run-metrics.mjs reduces it to a ratio; the rows
+// behind the ratio are not visible anywhere.
+//
+// This is the panel view llm-council shows as its stage-1 tabs, built from
+// state that already exists. No model call, no new field, no new phase.
+//
+// De-anonymization is deliberate and safe here: the map is read AFTER triage
+// has ruled, so nothing this prints can bias the judgement it describes. The
+// map never goes into a prompt; this is a report.
+//
+// Usage:
+//   council-view.mjs <agent-state.json> [--json] [--iteration N]
+//
+// Exit codes: 0 rendered, 2 nothing to render (no review iterations), 64 usage.
+
+import { readFileSync } from "node:fs";
+
+const argv = process.argv.slice(2);
+const JSON_OUT = argv.includes("--json");
+const iterFlag = argv.indexOf("--iteration");
+const ONLY = iterFlag !== -1 ? Number(argv[iterFlag + 1]) : null;
+const file = argv.find((a) => !a.startsWith("--") && a !== String(ONLY));
+// `--iteration` with nothing after it made ONLY NaN, and `it.iteration === NaN`
+// is never true, so a state full of iterations exited 2 - which /multi-agent:log
+// is told to read as "the run never reached Phase 4" and quietly omit. A usage
+// error has to look like one.
+const BAD_ITERATION = iterFlag !== -1 && !Number.isInteger(ONLY);
+
+function die(msg, code) {
+  process.stderr.write(msg + "\n");
+  process.exitCode = code;
+}
+
+function verdictOf(triage, fingerprint, issue, fileName) {
+  for (const bucket of ["accepted", "deferred", "rejected"]) {
+    for (const entry of Array.isArray(triage?.[bucket]) ? triage[bucket] : []) {
+      // Only `accepted[]` is a flat finding. triage-output.schema.json defines a
+      // deferred or rejected item as `{ finding, reason }` - the reason is the
+      // point of those buckets - so reading the id off the wrapper made every
+      // ruled-out finding render as `unruled`, which is exactly the column this
+      // view exists to show.
+      const f = entry?.finding ?? entry;
+      if (fingerprint && f?.fingerprint === fingerprint) return bucket;
+      if (!fingerprint && f?.file === fileName && f?.issue === issue) return bucket;
+    }
+  }
+  return "unruled";
+}
+
+function main() {
+  if (!file) return die("usage: council-view.mjs <agent-state.json> [--json] [--iteration N]", 64);
+  if (BAD_ITERATION) return die("council-view: --iteration needs an integer", 64);
+  let state;
+  try {
+    state = JSON.parse(readFileSync(file, "utf8"));
+  } catch (e) {
+    return die(`council-view: cannot read ${file}: ${e.message}`, 64);
+  }
+
+  const iterations = Array.isArray(state?.reviewIterations) ? state.reviewIterations : [];
+  const wanted = ONLY == null ? iterations : iterations.filter((it) => it?.iteration === ONLY);
+  if (wanted.length === 0) return die("council-view: no review iterations on this state", 2);
+
+  const out = [];
+  for (const it of wanted) {
+    // Absent map is the normal state for a run written before anonymization,
+    // and for one where every reviewer timed out. Say "unknown" rather than
+    // guessing a model, the same way run-metrics.mjs degrades.
+    const map = it?.anonymizationMap?.labelToModel || {};
+    const triage = it?.triage || {};
+    const rows = [];
+    for (const r of Array.isArray(it?.reviewers) ? it.reviewers : []) {
+      const model = typeof r?.model === "string" && r.model ? r.model : "unknown";
+      for (const f of Array.isArray(r?.findings) ? r.findings : []) {
+        rows.push({
+          model,
+          severity: f?.severity || "",
+          file: f?.file || "",
+          line: f?.line ?? "",
+          issue: f?.issue || "",
+          fingerprint: f?.fingerprint || null,
+          corroboration: f?.corroboration?.count ?? null,
+          of: f?.corroboration?.of ?? null,
+          verdict: verdictOf(triage, f?.fingerprint, f?.issue, f?.file),
+        });
+      }
+    }
+    out.push({
+      iteration: it?.iteration ?? null,
+      reviewers: Object.keys(map).length ? map : null,
+      findings: rows,
+    });
+  }
+
+  if (JSON_OUT) {
+    process.stdout.write(JSON.stringify(out, null, 2) + "\n");
+    return;
+  }
+
+  const lines = [];
+  for (const block of out) {
+    lines.push(`## Council view  -  iteration ${block.iteration ?? "?"}`);
+    lines.push("");
+    if (block.findings.length === 0) {
+      lines.push("No reviewer returned a finding in this iteration.");
+      lines.push("");
+      continue;
+    }
+    // Per-model totals first: the ratio is the summary, the rows are the evidence.
+    const byModel = new Map();
+    for (const r of block.findings) {
+      const e = byModel.get(r.model) || { raw: 0, accepted: 0 };
+      e.raw += 1;
+      if (r.verdict === "accepted") e.accepted += 1;
+      byModel.set(r.model, e);
+    }
+    lines.push("| Reviewer | Raised | Accepted |");
+    lines.push("| -------- | ------ | -------- |");
+    for (const [m, e] of byModel) lines.push(`| ${m} | ${e.raw} | ${e.accepted} |`);
+    lines.push("");
+    lines.push("| Reviewer | Severity | Where | Finding | Seen by | Triage |");
+    lines.push("| -------- | -------- | ----- | ------- | ------- | ------ |");
+    for (const r of block.findings) {
+      const seen = r.corroboration == null ? "-" : `${r.corroboration}/${r.of}`;
+      const where = r.file ? `${r.file}:${r.line}` : "-";
+      lines.push(
+        `| ${r.model} | ${r.severity} | ${where} | ${r.issue.replace(/\|/g, "\\|")} | ${seen} | ${r.verdict} |`,
+      );
+    }
+    lines.push("");
+  }
+  // `process.exitCode`, never `process.exit()`: stdout to a pipe is async and
+  // exiting on the next line truncates a long table at the pipe buffer.
+  process.stdout.write(lines.join("\n"));
+}
+
+main();