@agentsdance/codejury 0.1.0 → 0.1.1

package/README.md

@@ -21,6 +21,13 @@ head commit, reviews an isolated temporary checkout, and pushes accepted fixes
 back to the source branch. It is safe to invoke from `master` or from outside
 the target repository; the caller's working tree is not switched or modified.
 
+GitLab and compatible self-hosted services are supported through
+`/merge_requests/<id>` URLs. Jury clones with Git and fetches the standard
+`refs/merge-requests/<id>/head` ref, so existing Git credentials are used. If
+the source branch is not uniquely visible on the target remote (commonly a
+fork), use `--no-push` for a read-only review or check out the source branch
+locally and pass `--dir`.
+
 Node 20 or newer. The reviewers are separate CLIs you install yourself — `jury` spawns whatever you
 have and skips the rest:
 
@@ -34,6 +41,17 @@ used. The former `cr.config.json` and `macr.config.json` names remain readable f
 
 The former `cr` command remains available as a compatibility alias.
 
+## Working and state directory
+
+With no `--dir`, Jury keeps the current directory when it is a Git worktree. From anywhere else it
+uses `~/.jury` and creates that directory automatically. An explicitly empty `--dir ""` also selects
+`~/.jury`; a non-empty explicit path always wins. `~` is expanded consistently for review, web,
+runs, findings, and reply commands.
+
+Run records live in `<dir>/runs`. For example, `jury runs --dir ""` and `jury web --dir ""` read
+`~/.jury/runs`, while a review launched from a repository continues to use that repository's
+`runs` directory.
+
 ## The loop
 
 ```
@@ -76,12 +94,21 @@ standalone, against runs that already exist.
 
 ## Who writes, and who only reads
 
-Exactly one agent has role `main` — **Claude Code**, the session driving the loop. It owns the working
-tree and the commit, triages every finding, and is the only writer. Its registry entry carries an
-empty `argv` because it is never spawned; `jury agents` shows it as in-process:
+Exactly one agent has role `main`; it is the default **judge**. The built-in default is Claude Code.
+The judge owns the working tree and commit, triages every finding, and is the only writer. Choose a
+different enabled agent for one run with `--judge`; without that flag Claude remains the default:
+
+```bash
+jury https://github.com/owner/repo/pull/1                 # Claude judges
+jury --judge codex https://github.com/owner/repo/pull/1   # Codex judges
+```
+
+`--judge` accepts exactly one agent name. The selected judge is removed from that run's reviewer
+pool, so it never reviews its own work.
+`jury agents` shows the configured roles:
 
 ```
-ok      claude   main     (in-process)
+ok      claude   main     /usr/local/bin/claude
 ok      codex    reviewer /usr/local/bin/codex
 ok      agy      reviewer /usr/local/bin/agy
 ```
@@ -89,7 +116,7 @@ ok      agy      reviewer /usr/local/bin/agy
 Reviewers only read and report. A registry with two `main` entries is refused outright — two agents
 both believing they own the commit corrupts a run rather than merely failing it.
 
-The main agent then holds **one conversation per reviewer**, concurrently, each about that reviewer's
+The judge then holds **one conversation per reviewer**, concurrently, each about that reviewer's
 own findings and nothing else:
 
 ```

package/bin/jury.js

@@ -10,16 +10,17 @@ import { execFile } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { promisify } from "node:util";
 import path from "node:path";
-import { loadConfig, reviewers, mainAgent } from "../lib/config.js";
+import { loadConfig, reviewers, judgeAgent } from "../lib/config.js";
 import { runAgent, probe } from "../lib/agents.js";
 import { threadFor, buildReply, replyArgv } from "../lib/reply.js";
 import { buildPrompt } from "../lib/prompt.js";
 import { serve } from "../lib/server.js";
 import { appendEvent, writeRun, readEvents, foldEvents, slugFor, attemptStamp, runsDir, writeArtifact, openArtifact } from "../lib/store.js";
 import { findingsIn, gate, settledList, VERDICTS } from "../lib/findings.js";
-import { MAX_TURNS, turnsFor, outstanding, deadlocked, refreshSettled, replyRound, record, sessionsIn, openFindings } from "../lib/loop.js";
+import { MAX_TURNS, turnsFor, outstanding, deadlocked, refreshSettled, replyRound, record, sessionsIn, openFindings, currentJudge } from "../lib/loop.js";
 import { triageOne } from "../lib/triage.js";
-import { assertPrCheckout, resolvePrCheckout } from "../lib/repository.js";
+import { assertPrCheckout, repositoryFromPrUrl, resolvePrCheckout } from "../lib/repository.js";
+import { resolveJuryDirectory } from "../lib/directories.js";
 import * as st from "../lib/style.js";
 
 const run = promisify(execFile);
@@ -50,8 +51,10 @@ const USAGE = `jury — run a pull request past several AI reviewers until they
 
 Common flags
 
+  --dir <path>             working/state root      (default: Git cwd or ~/.jury)
   --rounds <n>             stop after n rounds            (default 10)
   --agents codex,grok      only these reviewers           (default: all installed)
+  --judge codex            one agent that triages and fixes       (default: claude)
   --no-push                fix locally, do not push
   --dry-run                exercise the pipeline, spawn nothing
 
@@ -67,7 +70,7 @@ Other commands
 
 const USAGE_FULL = `jury — multi-agent code review
 
-  jury <pr-url>             review a PR: rounds until convergence, one conversation per reviewer
+  jury <pr-url>             review a PR until every reviewer approves, one conversation per reviewer
   jury review-once [flags]  a single round, no triage or reply
   jury web [flags]          serve the console (default http://127.0.0.1:3080)
   jury finding <cmd>        list | reproduce | resolve | settled — appends events, enforces the gate
@@ -80,13 +83,14 @@ review                           (drives itself; no operator between rounds)
   jury https://github.com/owner/repo/pull/1
   jury --rounds 3                  the current branch, no PR
 
-  --dir <path>       repo/worktree                            (default .)
+  --dir <path>       repo/worktree      (default: cwd if Git, otherwise ~/.jury)
   --pr <url>         same as the positional argument
   --trunk <branch>   diff base branch          (default: the remote's own HEAD)
   --title <text>     what the change does         (default: read from the PR)
   --summary <text>   intent, passed to reviewers  (default: the PR description)
   --rounds <n>       maximum rounds                           (default 10)
   --agents a,b       only these reviewers            (default: all installed)
+  --judge <agent>    one agent that triages and fixes       (default: claude)
   --resume <slug>    continue an existing run instead of starting a new one
   --web              open the console on this run          (stays up when it ends)
   --port <n>         console port, with --web              (default 3080)
@@ -94,25 +98,30 @@ review                           (drives itself; no operator between rounds)
   --dry-run          exercise the pipeline, spawn nothing
 
 review-once flags
-  --dir <path>       repo/worktree the reviewers read        (default .)
+  --dir <path>       repo/worktree       (default: cwd if Git, otherwise ~/.jury)
   --pr <url>         pull request URL, recorded on the run
   --title <text>     what the change does, shown in the console
   --summary <text>   a few lines of intent, passed to reviewers
   --trunk <branch>   diff base branch                        (default master)
   --round <n>        round number                            (default: next)
   --agents a,b       only these reviewers                    (default: all enabled)
-  --max-rounds <n>   keep going until convergence, at most n (default 1)
+  --max-rounds <n>   keep going until every reviewer approves, at most n (default 1)
   --dry-run          do not spawn anything; exercise the pipeline
 
 web flags
+  --dir <path>       run-state root       (default: cwd if Git, otherwise ~/.jury)
   --port <n>         default 3080, walks forward if busy
   --open             open a browser
 
-finding commands                                (--run <slug> picks the run)
+finding commands                     (--dir picks state root; --run picks run)
   jury finding list
   jury finding reproduce <id> --evidence <text> [--test <text>]
   jury finding resolve <id> --verdict <${VERDICTS.join("|")}> [--reason <text>] [--test <text>]
   jury finding settled                          print the regenerated settled list
+
+state commands
+  jury runs [--dir <path>]
+  jury reply [--dir <path>] [--run <slug>]
 `;
 
 let [, , cmd, ...rest] = process.argv;
@@ -147,7 +156,7 @@ try {
     case "web": await cmdWeb(rest); break;
     case "finding": case "findings": await cmdFinding(rest); break;
     case "reply": await cmdReply(rest); break;
-    case "runs": await cmdRuns(); break;
+    case "runs": await cmdRuns(rest); break;
     case "agents": await cmdAgents(); break;
     case "version": case "-v": case "--version": console.log(`jury ${VERSION}`); break;
     case "help": case "-h": case "--help": case undefined:
@@ -168,11 +177,49 @@ try {
   process.exit(1);
 }
 
+/** Resolve an explicit reviewer list or explain each ineligible name. */
+function selectReviewers(cfg, requested, judge = null) {
+  const eligible = reviewers(cfg).filter((a) => a.name !== judge);
+  if (!requested) return eligible;
+
+  const names = [...new Set(requested.split(",").map((s) => s.trim()).filter(Boolean))];
+  if (!names.length) throw new Error("--agents needs at least one reviewer name");
+
+  const byName = new Map(cfg.agents.map((a) => [a.name, a]));
+  const allowed = new Set(eligible.map((a) => a.name));
+  const problems = names.filter((name) => !allowed.has(name)).map((name) => {
+    const agent = byName.get(name);
+    if (name === judge) return `"${name}" is the selected judge and cannot review its own work`;
+    if (agent) return `"${name}" has role "${agent.role ?? "reviewer"}", not "reviewer"`;
+    return `"${name}" is not configured or is disabled`;
+  });
+  if (problems.length) {
+    const available = eligible.map((a) => a.name).join(", ") || "none";
+    throw new Error(
+      `requested reviewer ${problems.join("; ")}. Add or enable it with role "reviewer" in ${path.basename(cfg.configFile)}. Available enabled reviewers: ${available}`,
+    );
+  }
+  return eligible.filter((a) => names.includes(a.name));
+}
+
+async function commandDirectory(value) {
+  return resolveJuryDirectory(value, {
+    isUsable: async (dir) => {
+      try {
+        await run("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"]);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  });
+}
+
 async function cmdReview(argv) {
   const { values } = parseArgs({
     args: argv, allowPositionals: false,
     options: {
-      dir: { type: "string", default: "." },
+      dir: { type: "string" },
       pr: { type: "string" },
       title: { type: "string" },
       summary: { type: "string", default: "" },
@@ -189,14 +236,9 @@ async function cmdReview(argv) {
     throw new Error("--max-rounds must be a positive integer");
   }
 
-  const worktree = path.resolve(values.dir);
+  const worktree = await commandDirectory(values.dir);
   const cfg = await loadConfig(worktree);
-  let pool = reviewers(cfg);
-  if (values.agents) {
-    const want = new Set(values.agents.split(",").map((s) => s.trim()));
-    pool = pool.filter((a) => want.has(a.name));
-    if (!pool.length) throw new Error(`no configured reviewer matches "${values.agents}"`);
-  }
+  const pool = selectReviewers(cfg, values.agents);
 
   const git = await describe(worktree, values.trunk);
   if (values.pr) assertPrCheckout(values.pr, git.remote, worktree);
@@ -214,7 +256,7 @@ async function cmdReview(argv) {
     stateNote: "",
   };
 
-  const dir = path.join(runsDir(), slugFor(target));
+  const dir = path.join(runsDir(worktree), slugFor(target));
   const prior = await readEvents(dir);
   const firstRound = values.round
     ? Number(values.round)
@@ -223,7 +265,7 @@ async function cmdReview(argv) {
   console.log(`target   ${target.repo} ${target.id}`);
   console.log(`worktree ${worktree} @ ${git.sha}`);
   console.log(`agents   ${pool.map((a) => a.name).join(", ")}${values["dry-run"] ? "  (dry run)" : ""}`);
-  if (maxRounds > 1) console.log(`rounds   ${firstRound}..${firstRound + maxRounds - 1} (until convergence)`);
+  if (maxRounds > 1) console.log(`rounds   ${firstRound}..${firstRound + maxRounds - 1} (until every reviewer approves)`);
   console.log("");
 
   for (let i = 0; i < maxRounds; i++) {
@@ -243,7 +285,7 @@ async function cmdReview(argv) {
 }
 
 /** One round: prompt, launch every reviewer, record what they said. */
-async function runRound({ dir, round, pool, cfg, target, worktree, values, sha }) {
+async function runRound({ dir, round, pool, cfg, target, worktree, values, sha, announceCompletion = true }) {
   const git = { sha };
   console.log(st.info(st.bold(`round ${round}`)));
 
@@ -384,13 +426,17 @@ async function runRound({ dir, round, pool, cfg, target, worktree, values, sha }
   // The state the run was launched with says "review", which stops being true
   // the moment the round ends. Restate it, or the console keeps asserting a
   // review is running after it converged.
-  const state = errored.length ? "human" : clean ? "converged" : "review";
+  const state = errored.length ? "human" : clean && announceCompletion ? "converged" : "review";
   const stateNote = errored.length
     ? `${errored.length} reviewer(s) failed to run`
     : clean
-      ? `converged on ${git.sha}`
+      ? announceCompletion ? "Review complete" : `round ${round} clean — checking outstanding findings`
       : `round ${round} — ${raised || "unparsed"} finding(s) to triage`;
-  await appendEvent(dir, { t: "target", target: { ...target, state, stateNote } });
+  const reviewedCommit = clean && !errored.length && announceCompletion ? git.sha : "";
+  await appendEvent(dir, {
+    t: "target",
+    target: { ...target, state, stateNote, ...(reviewedCommit ? { reviewedCommit } : {}) },
+  });
   await appendEvent(dir, { t: "round.end", n: round });
   await publish();
 
@@ -410,8 +456,10 @@ async function runRound({ dir, round, pool, cfg, target, worktree, values, sha }
     console.log(st.bad(`${st.count(errored.length, "reviewer")} failed to run — see the reports below.`));
   }
   console.log(clean && !errored.length
-    ? st.ok(`CONVERGED — every reviewer emitted the stop token on ${git.sha}.`)
-    : st.warn(`NOT converged. Triage, fix what reproduces, push, then round ${round + 1}.`));
+    ? announceCompletion
+      ? `${st.ok("REVIEW COMPLETE — every reviewer approved.")}\n${st.muted(`Reviewed commit ${git.sha}.`)}`
+      : `${st.ok("ROUND CLEAN — every reviewer approved this commit.")}\n${st.muted(`Reviewed commit ${git.sha}.`)}`
+    : st.warn(`REVIEW INCOMPLETE — triage findings, fix what reproduces, push, then run round ${round + 1}.`));
   console.log(st.muted(`recorded: ${path.relative(process.cwd(), dir)}`));
 
   // Every reviewer's report, including the clean ones: a sign-off still says
@@ -446,16 +494,19 @@ async function runRound({ dir, round, pool, cfg, target, worktree, values, sha }
  *   the round cap      --rounds, default 10
  */
 async function cmdAgent(argv) {
+  const judgeFlags = argv.filter((a) => a === "--judge" || a.startsWith("--judge="));
+  if (judgeFlags.length > 1) throw new Error("--judge accepts exactly one agent");
   const { values, positionals } = parseArgs({
     args: argv, allowPositionals: true,
     options: {
-      dir: { type: "string", default: "." },
+      dir: { type: "string" },
       pr: { type: "string" },
       title: { type: "string" },
       summary: { type: "string" },
       trunk: { type: "string" },
       rounds: { type: "string", default: "10" },
       agents: { type: "string" },
+      judge: { type: "string" },
       push: { type: "boolean", default: true },
       "no-push": { type: "boolean", default: false },
       resume: { type: "string" },
@@ -464,6 +515,7 @@ async function cmdAgent(argv) {
       port: { type: "string", default: "3080" },
     },
   });
+  if (values.judge?.includes(",")) throw new Error("--judge accepts exactly one agent, not a list");
 
   // The PR link is the argument. `--pr` still works, but a flag for the one
   // thing every invocation names is ceremony: `jury agent <url>` is what
@@ -481,7 +533,7 @@ async function cmdAgent(argv) {
   }
 
   values.push = values.push && !values["no-push"];
-  const requestedWorktree = path.resolve(values.dir);
+  const requestedWorktree = await commandDirectory(values.dir);
   const resolved = values.pr
     ? await resolvePrCheckout(values.pr, { allowPush: values.push })
     : null;
@@ -491,21 +543,6 @@ async function cmdAgent(argv) {
   // A local ignored config belongs to the requested checkout. An automatic
   // clone intentionally starts from the repository's committed/default config.
   const cfg = await loadConfig(resolved ? worktree : requestedWorktree);
-  const main = mainAgent(cfg);
-  if (!main) {
-    // A run with no main agent has no one to triage or fix — every finding
-    // would stay open and every round would re-raise it. Better to say so than
-    // to burn ten rounds discovering it.
-    throw new Error('no agent has role "main" — the loop has nobody to triage or fix');
-  }
-
-  let pool = reviewers(cfg);
-  if (values.agents) {
-    const want = new Set(values.agents.split(",").map((s) => s.trim()));
-    pool = pool.filter((a) => want.has(a.name));
-  }
-  if (!pool.length) throw new Error("no reviewers configured — nothing would review anything");
-
   const git = await describe(worktree);
 
   // Both asked for rather than assumed: the trunk from the remote's own HEAD,
@@ -550,20 +587,41 @@ async function cmdAgent(argv) {
   // into rounds 1-5 of a single run, and a killed run's open rounds interleaved
   // with the next one's.
   target.attempt = values.resume ? "" : attemptStamp();
+  const stateBase = runsDir(requestedWorktree);
   const dir = values.resume
-    ? path.join(runsDir(), path.basename(values.resume))
-    : path.join(runsDir(), slugFor(target));
+    ? path.join(stateBase, path.basename(values.resume))
+    : path.join(stateBase, slugFor(target));
   const prior = await readEvents(dir);
   if (values.resume && !prior.length) {
-    throw new Error(`no run at ${path.relative(process.cwd(), dir)} — check \`jury runs\``);
+    throw new Error(
+      `no run at ${dir} — pass --dir <root-that-contains-runs>, then check \`jury runs --dir <root>\``,
+    );
+  }
+  const priorJudge = [...prior].reverse()
+    .find((e) => e.t === "target" && e.target?.judge)?.target.judge;
+  const requestedJudge = values.judge ?? (values.resume ? priorJudge : null);
+  const judge = judgeAgent(cfg, requestedJudge);
+  if (!judge) {
+    const available = cfg.agents.map((a) => a.name).join(", ") || "none";
+    if (requestedJudge) {
+      throw new Error(`judge "${requestedJudge}" is not an enabled configured agent — available: ${available}`);
+    }
+    throw new Error('no agent has role "main" — configure one or pass --judge <agent>');
   }
+  target.judge = judge.name;
+
+  // A judge cannot independently review its own work. Other configured main
+  // agents stay out of the pool rather than being silently demoted to writers
+  // with a read-only prompt.
+  const pool = selectReviewers(cfg, values.agents, judge.name);
+  if (!pool.length) throw new Error("no reviewers configured after excluding the judge");
   const first = Math.max(0, ...prior.filter((e) => e.t === "round.start").map((e) => e.n)) + 1;
 
   console.log(st.field("target", `${target.repo} ${st.bold(target.id)}`));
   console.log(st.field("worktree", st.muted(`${worktree} @ ${git.sha} (${resolved?.branch ?? git.branch})`)));
   console.log(st.field("trunk", `${trunk}${trunkGiven ? st.muted("  (detected)") : ""}`));
   if (target.title) console.log(st.field("title", target.title.slice(0, 72)));
-  console.log(st.field("main", st.agent(main.name)));
+  console.log(st.field("judge", st.agent(judge.name)));
   console.log(st.field("agents", pool.map((a) => st.agent(a.name)).join(", ")
     + (values["dry-run"] ? st.warn("  (dry run)") : "")));
   console.log(st.field("rounds", st.muted(`${first}..${first + maxRounds - 1}, ${MAX_TURNS} turns per finding`)));
@@ -594,6 +652,9 @@ async function cmdAgent(argv) {
     const head = await describe(worktree, values.trunk);
     const converged = await runRound({
       dir, round, pool, cfg, target, worktree, values, sha: head.sha,
+      // A clean round is not necessarily a complete review: an earlier finding
+      // can still be open. This loop announces completion only after checking.
+      announceCompletion: false,
     });
     if (converged) {
       // Clean is not enough on its own. A finding left open by the previous
@@ -605,7 +666,11 @@ async function cmdAgent(argv) {
       // convergence.
       const open = await openFindings(dir);
       if (!open.length) {
-        console.log(st.ok(`\nCONVERGED after ${st.count(round - first + 1, "round")}.`));
+        console.log(st.ok(`\nREVIEW COMPLETE after ${st.count(round - first + 1, "round")}.`));
+        console.log(st.muted(`Reviewed commit ${head.sha}.`));
+        await publishRun(dir, {
+          ...target, state: "converged", stateNote: "Review complete", reviewedCommit: head.sha,
+        });
         return;
       }
       console.log(st.warn(`\nevery reviewer is clean, but ${st.count(open.length, "finding")} from earlier ${open.length === 1 ? "is" : "are"} still open.`));
@@ -625,7 +690,7 @@ async function cmdAgent(argv) {
       return;
     }
 
-    console.log(`\n${st.rule(`triage · ${st.count(todo.length, "finding")} → ${main.name}`)}`);
+    console.log(`\n${st.rule(`triage · ${st.count(todo.length, "finding")} → ${judge.name}`)}`);
     let fixed = 0;
     for (const f of todo) {
       // The turn limit ends an argument the loop cannot win. Both positions are
@@ -635,6 +700,7 @@ async function cmdAgent(argv) {
         const r = await record(dir, findings, f.id, {
           verdict: "deferred",
           reason: `argued ${MAX_TURNS} turns without agreement; both positions are in the log`,
+          who: judge.name,
         });
         console.log(`  ${st.muted(f.id)}  ${st.verdict("deferred")} ${st.muted(`(turn limit)${r.ok ? "" : ` — ${r.why}`}`)}`);
         continue;
@@ -648,10 +714,10 @@ async function cmdAgent(argv) {
       // Tagged with the reviewer whose finding this is: threads are per
       // reviewer, and a heartbeat filed under "claude" opened a claude thread
       // of its own, splitting one conversation in two.
-      const heart = beat(dir, main.name, round, f.agent);
+      const heart = beat(dir, judge.name, round, f.agent);
       let v;
       try {
-        v = await triageOne(main, f, {
+        v = await triageOne(judge, f, {
           worktree, trunk, stopToken: cfg.stopToken, dryRun: values["dry-run"],
           onLog: (m) => console.log(`          ${st.muted(m)}`),
         });
@@ -672,6 +738,7 @@ async function cmdAgent(argv) {
       if (v.reproduced) {
         await appendEvent(dir, {
           t: "finding.reproduced", id: f.id, evidence: v.reproduced, test: v.test ?? null,
+          who: judge.name,
         });
       }
       // Refold BEFORE recording, not after. gate() checks the finding it is
@@ -681,7 +748,7 @@ async function cmdAgent(argv) {
       // described the right order; the code did not implement it.
       findings = await findingsIn(dir);
       const res = await record(dir, findings, f.id, {
-        verdict: v.verdict, reason: v.reason, test: v.test,
+        verdict: v.verdict, reason: v.reason, test: v.test, who: judge.name,
       });
       if (!res.ok) {
         // The gate refusing is the gate working. Downgrade rather than crash:
@@ -698,6 +765,7 @@ async function cmdAgent(argv) {
       if (c?.sha) {
         await appendEvent(dir, {
           t: "commit.pushed", sha: c.sha, pushed: c.pushed, subject: `round ${round} fixes`,
+          who: judge.name,
         });
         console.log(`commit   ${c.sha}${
           c.pushed === null ? "" : c.pushed ? ` → pushed to ${pushTarget.branch}` : "  (NOT pushed)"}`);
@@ -712,7 +780,7 @@ async function cmdAgent(argv) {
     // concede or push back.
     const after = await findingsIn(dir);
     const answers = await replyRound({
-      dir, pool, cfg, worktree, sha: head.sha, round, findings: after,
+      dir, pool, cfg, worktree, sha: head.sha, round, findings: after, judge: judge.name,
       sessions: sessionsIn(await readEvents(dir)),
       dryRun: values["dry-run"],
       // Prefixed like the launch line: without a name this printed a bare
@@ -739,17 +807,18 @@ async function cmdAgent(argv) {
     const stillOpen = [...settled.values()].filter((f) => f.status === "open");
     const broke = answers.filter((a) => a.failed);
     if (answers.every((a) => a.clean) && !stillOpen.length && !broke.length && !pushFailed) {
-      console.log(st.ok(st.bold(`\nCONVERGED — every reviewer signed off after round ${round}.`)));
+      console.log(st.ok(st.bold(`\nREVIEW COMPLETE — every reviewer approved after round ${round}.`)));
+      console.log(st.muted(`Reviewed commit ${head.sha}.`));
       await publishRun(dir, {
-        ...target, state: "converged", stateNote: `converged after round ${round}`,
+        ...target, state: "converged", stateNote: "Review complete", reviewedCommit: head.sha,
       });
       return;
     }
     if (stillOpen.length) {
-      console.log(st.warn(`\n${st.count(stillOpen.length, "finding")} still open — not convergence.`));
+      console.log(st.warn(`\n${st.count(stillOpen.length, "finding")} still open — review incomplete.`));
     }
     if (broke.length) {
-      console.log(st.bad(`${broke.map((a) => a.agent).join(", ")} could not run — this run cannot converge.`));
+      console.log(st.bad(`${broke.map((a) => a.agent).join(", ")} could not run — this review cannot complete.`));
     }
     if (pushFailed) {
       console.log(st.bad("a push failed — the reviewers are reading code the PR does not have."));
@@ -826,11 +895,16 @@ async function cleanupResolvedCheckout() {
 async function cmdWeb(argv) {
   const { values } = parseArgs({
     args: argv, allowPositionals: false,
-    options: { port: { type: "string", default: "3080" }, open: { type: "boolean", default: false } },
+    options: {
+      dir: { type: "string" },
+      port: { type: "string", default: "3080" },
+      open: { type: "boolean", default: false },
+    },
   });
-  const { url, port } = await serve({ port: Number(values.port) });
+  const root = await commandDirectory(values.dir);
+  const { url, port } = await serve({ port: Number(values.port), cwd: root });
   console.log(`console: ${url}`);
-  console.log(`runs:    ${path.relative(process.cwd(), runsDir()) || "runs"}/`);
+  console.log(`runs:    ${runsDir(root)}/`);
   if (values.open) openBrowser(url);
   process.on("SIGINT", () => { console.log("\nstopped"); process.exit(0); });
   return new Promise(() => {}); // serve until interrupted
@@ -854,6 +928,7 @@ async function cmdFinding(argv) {
     args: rest, allowPositionals: true,
     options: {
       run: { type: "string" },
+      dir: { type: "string" },
       evidence: { type: "string" },
       test: { type: "string" },
       verdict: { type: "string" },
@@ -861,7 +936,10 @@ async function cmdFinding(argv) {
     },
   });
 
-  const dir = await resolveRun(values.run);
+  const root = await commandDirectory(values.dir);
+  const dir = await resolveRun(values.run, root);
+  const events = await readEvents(dir);
+  const judge = currentJudge(events);
   const findings = await findingsIn(dir);
   const id = positionals[0];
 
@@ -881,7 +959,7 @@ async function cmdFinding(argv) {
       if (!findings.has(id)) throw new Error(`no such finding: ${id}`);
       if (!values.evidence) throw new Error("--evidence is required: what demonstrated the finding");
       await appendEvent(dir, {
-        t: "finding.reproduced", id, evidence: values.evidence, test: values.test,
+        t: "finding.reproduced", id, evidence: values.evidence, test: values.test, who: judge,
       });
       await republish(dir);
       console.log(`${id}: reproduction recorded`);
@@ -895,7 +973,7 @@ async function cmdFinding(argv) {
       // survives the operator deciding to skip it.
       if (why) throw new Error(`refused: ${why}`);
       await appendEvent(dir, {
-        t: "finding.resolved", id, verdict: values.verdict, reason: values.reason ?? "", test: values.test,
+        t: "finding.resolved", id, verdict: values.verdict, reason: values.reason ?? "", test: values.test, who: judge,
       });
       await republish(dir);
       console.log(`${id}: ${values.verdict}`);
@@ -927,23 +1005,21 @@ async function cmdReply(argv) {
     args: argv, allowPositionals: false,
     options: {
       run: { type: "string" },
-      dir: { type: "string", default: "." },
+      dir: { type: "string" },
       agents: { type: "string" },
       "dry-run": { type: "boolean", default: false },
     },
   });
 
-  const cfg = await loadConfig();
-  const dir = await resolveRun(values.run);
+  const worktree = await commandDirectory(values.dir);
+  const cfg = await loadConfig(worktree);
+  const dir = await resolveRun(values.run, worktree);
+  const events = await readEvents(dir);
+  const judge = currentJudge(events);
   const findings = await findingsIn(dir);
-  const worktree = path.resolve(values.dir);
   const { sha } = await describe(worktree, "master");
 
-  let pool = reviewers(cfg);
-  if (values.agents) {
-    const want = new Set(values.agents.split(",").map((s) => s.trim()));
-    pool = pool.filter((a) => want.has(a.name));
-  }
+  let pool = selectReviewers(cfg, values.agents, judge);
   // Only reviewers that actually said something, and only once you have
   // answered them: a reply that says "still open" for every item is noise.
   pool = pool.filter((a) => {
@@ -952,8 +1028,7 @@ async function cmdReply(argv) {
   });
   if (!pool.length) throw new Error("nothing to reply about — resolve some findings first");
 
-  const main = mainAgent(cfg);
-  console.log(`main     ${main?.name ?? "(unset)"}`);
+  console.log(`judge    ${judge}`);
   console.log(`replying ${pool.map((a) => a.name).join(", ")}  (separate conversations)`);
   console.log("");
 
@@ -976,7 +1051,7 @@ async function cmdReply(argv) {
 
     if (values["dry-run"]) return;
 
-    await appendEvent(dir, { t: "reply.sent", agent: a.name, sha, resumed: resumable, promptFile: file });
+    await appendEvent(dir, { t: "reply.sent", agent: a.name, sha, resumed: resumable, promptFile: file, who: judge });
     const spec = { ...a, argv: replyArgv(a, { promptText: text, worktree }).argv };
     const replyRaw = `reply.${a.name}.stdout.txt`;
     const sink = await openArtifact(dir, replyRaw);
@@ -996,8 +1071,8 @@ async function cmdReply(argv) {
 }
 
 /** Which run a finding command applies to; unambiguous by default. */
-async function resolveRun(slug) {
-  const base = runsDir();
+async function resolveRun(slug, root = process.cwd()) {
+  const base = runsDir(root);
   if (slug) return path.join(base, slug);
   const { readdir } = await import("node:fs/promises");
   let dirs = [];
@@ -1020,9 +1095,14 @@ async function republish(dir) {
  * optional, so there has to be a way to see the slugs that does not require
  * triggering the ambiguity error to find them out.
  */
-async function cmdRuns() {
+async function cmdRuns(argv) {
+  const { values } = parseArgs({
+    args: argv, allowPositionals: false,
+    options: { dir: { type: "string" } },
+  });
+  const root = await commandDirectory(values.dir);
   const { listRuns } = await import("../lib/store.js");
-  const { runs, skipped } = await listRuns(runsDir());
+  const { runs, skipped } = await listRuns(runsDir(root));
   if (!runs.length) {
     // Report the unreadable ones even when nothing succeeded: "no runs yet"
     // over a directory full of broken runs is a lie that reads as "nothing was
@@ -1139,7 +1219,7 @@ async function describe(dir, trunk) {
 // Declarations, not const arrows: the dispatch switch above runs at module
 // top level, so anything it reaches must be hoisted.
 function repoFromUrl(u) {
-  return u.match(/\/([^/]+\/[^/]+)\/(?:merge_requests|pull)\//)?.[1] ?? "";
+  return repositoryFromPrUrl(u)?.path ?? "";
 }
 
 function idFromUrl(u) {

package/lib/config.js

@@ -147,8 +147,9 @@ export async function loadConfig(dir = process.cwd()) {
   };
 }
 
-/** The agent that owns the working tree and the commit. Never spawned. */
-export function mainAgent(cfg) {
+/** Select the agent that judges findings and owns the working tree. */
+export function judgeAgent(cfg, name) {
+  if (name) return cfg.agents.find((a) => a.name === name) ?? null;
   return cfg.main ?? null;
 }
 

package/lib/directories.js

@@ -0,0 +1,27 @@
+// One directory policy for every command. An explicit path wins; an empty path
+// or an unsuitable implicit cwd falls back to ~/.jury and creates it.
+import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+
+export function expandDirectory(value, { cwd = process.cwd(), home = homedir() } = {}) {
+  const raw = String(value ?? "").trim();
+  if (raw === "~") return home;
+  if (/^~[\\/]/.test(raw)) return path.join(home, raw.slice(2));
+  return path.resolve(cwd, raw);
+}
+
+export async function resolveJuryDirectory(
+  value,
+  { cwd = process.cwd(), home = homedir(), isUsable = async () => true } = {},
+) {
+  if (typeof value === "string" && value.trim()) {
+    return expandDirectory(value, { cwd, home });
+  }
+
+  if (value === undefined && await isUsable(cwd)) return path.resolve(cwd);
+
+  const fallback = path.join(home, ".jury");
+  await mkdir(fallback, { recursive: true });
+  return fallback;
+}

package/lib/findings.js

@@ -11,8 +11,12 @@ export const VERDICTS = ["accepted", "deferred", "rejected", "superseded"];
 /** Fold the log down to one record per finding id. */
 export async function findingsIn(dir) {
   const byId = new Map();
+  let judge = "claude"; // Backward compatibility for runs without judge metadata.
   for (const e of await readEvents(dir)) {
     switch (e.t) {
+      case "target":
+        judge = e.target?.judge ?? judge;
+        break;
       case "finding.raised":
         byId.set(e.id, {
           id: e.id, round: e.round, agent: e.agent, claim: e.claim,
@@ -56,7 +60,7 @@ export async function findingsIn(dir) {
           f.turns = (f.turns ?? 0) + 1;
           // Only a reviewer pushing back re-opens the argument; our own turn in
           // the thread is not a rebuttal against ourselves.
-          if (e.who && e.who !== "claude") f.contested = true;
+          if (e.who && e.who !== judge) f.contested = true;
         }
         break;
       }

package/lib/loop.js

@@ -23,6 +23,15 @@ import { appendEvent, writeArtifact } from "./store.js";
 // recorded rather than resolved by fiat.
 export const MAX_TURNS = 3;
 
+/** The judge in force at the end of a run, with a legacy-run fallback. */
+export function currentJudge(events) {
+  let judge = "claude";
+  for (const e of events) {
+    if (e.t === "target" && e.target?.judge) judge = e.target.judge;
+  }
+  return judge;
+}
+
 /**
  * One finding's state across the whole run, which is what decides whether the
  * loop may stop. `turns` counts round-trips on this specific claim, not rounds.
@@ -70,9 +79,13 @@ export function conversation(events) {
     return t;
   };
   const claims = new Map();
+  let judge = "claude"; // Runs created before --judge existed were Claude-led.
 
   for (const e of events) {
     switch (e.t) {
+      case "target":
+        judge = e.target?.judge ?? judge;
+        break;
       case "finding.raised":
         // Deliberately NOT a turn of its own. The reviewer already said this in
         // its report, verbatim and in its own shape; a parsed copy underneath
@@ -87,14 +100,14 @@ export function conversation(events) {
         break;
       case "finding.reproduced":
         thread(claims.get(e.id)?.agent ?? "?").turns.push({
-          who: "claude", kind: "reproduced", id: e.id,
+          who: e.who ?? judge, kind: "reproduced", id: e.id,
           claim: claims.get(e.id)?.claim ?? "",
           text: typeof e.evidence === "string" ? e.evidence : "reproduced", ts: e.ts,
         });
         break;
       case "finding.resolved":
         thread(claims.get(e.id)?.agent ?? "?").turns.push({
-          who: "claude", kind: "verdict", id: e.id,
+          who: e.who ?? judge, kind: "verdict", id: e.id,
           claim: claims.get(e.id)?.claim ?? "",
           verdict: e.verdict, text: e.reason ?? "", test: e.test ?? "", ts: e.ts,
         });
@@ -116,7 +129,7 @@ export function conversation(events) {
             who, kind: "rebuttal", id: e.id,
             claim: claims.get(e.id)?.claim ?? "", ts: e.ts,
           };
-          if (who === "claude") turn.text = e.text ?? "";
+          if (who === judge) turn.text = e.text ?? "";
           thread(claims.get(e.id)?.agent ?? e.agent ?? "?").turns.push(turn);
         }
         break;
@@ -179,7 +192,7 @@ export function conversation(events) {
         break;
       case "reply.sent":
         thread(e.agent).turns.push({
-          who: "claude", kind: "reply", text: e.text ?? "", resumed: e.resumed, ts: e.ts,
+          who: e.who ?? judge, kind: "reply", text: e.text ?? "", resumed: e.resumed, ts: e.ts,
         });
         break;
       case "reply.answered":
@@ -190,7 +203,7 @@ export function conversation(events) {
         break;
       case "commit.pushed":
         for (const t of threads.values()) {
-          t.turns.push({ who: "claude", kind: "commit", sha: e.sha, text: e.subject ?? "", ts: e.ts });
+          t.turns.push({ who: e.who ?? judge, kind: "commit", sha: e.sha, text: e.subject ?? "", ts: e.ts });
         }
         break;
     }
@@ -208,7 +221,7 @@ export function conversation(events) {
  * records the reproduction attempt *before* the verdict, so an "accepted" with
  * nothing behind it is refused by findings.gate rather than believed.
  */
-export async function triage(finding, { ask, dir, worktree, round }) {
+export async function triage(finding, { ask, dir, worktree, round, judge }) {
   const verdict = await ask({ kind: "triage", finding, worktree, round });
   // Order matters. gate() reads the folded log, so the reproduction has to be
   // on disk before the resolve is checked against it.
@@ -216,6 +229,7 @@ export async function triage(finding, { ask, dir, worktree, round }) {
     await appendEvent(dir, {
       t: "finding.reproduced", id: finding.id,
       evidence: verdict.reproduced, test: verdict.test ?? null,
+      ...(judge ? { who: judge } : {}),
     });
   }
   return verdict;
@@ -229,11 +243,11 @@ export async function triage(finding, { ask, dir, worktree, round }) {
  * open finding again, which the next round will re-raise. Crashing here would
  * throw away a whole round of reviewer time over one badly-formed answer.
  */
-export async function record(dir, findings, id, { verdict, reason, test }) {
+export async function record(dir, findings, id, { verdict, reason, test, who }) {
   const f = findings.get(id);
   const why = gate(f, { verdict, test });
   if (why) return { ok: false, why };
-  await appendEvent(dir, { t: "finding.resolved", id, verdict, reason: reason ?? "", test: test ?? null });
+  await appendEvent(dir, { t: "finding.resolved", id, verdict, reason: reason ?? "", test: test ?? null, ...(who ? { who } : {}) });
   return { ok: true };
 }
 
@@ -278,7 +292,7 @@ export async function refreshSettled(dir) {
  * not, and its rebuttal is recorded against the findings it concerns so the
  * turn counter can eventually end the argument.
  */
-export async function replyRound({ dir, pool, cfg, worktree, sha, round, findings, sessions, dryRun, onLog, onChunk }) {
+export async function replyRound({ dir, pool, cfg, worktree, sha, round, findings, sessions, dryRun, judge, onLog, onChunk }) {
   const names = pool.map((a) => a.name);
   const out = await Promise.all(pool.map(async (a) => {
     const thread = threadFor(a.name, findings);
@@ -298,7 +312,7 @@ export async function replyRound({ dir, pool, cfg, worktree, sha, round, finding
     // lands in that conversation rather than whichever ran most recently.
     const sessionId = sessions?.get(a.name) ?? null;
     const { argv, resumed } = replyArgv(a, { promptText: text, worktree, sha, sessionId });
-    await appendEvent(dir, { t: "reply.sent", agent: a.name, resumed, sessionId, text });
+    await appendEvent(dir, { t: "reply.sent", agent: a.name, resumed, sessionId, text, ...(judge ? { who: judge } : {}) });
 
     const r = await runAgent({ ...a, argv }, {
       worktree, prompt: text, stopToken: cfg.stopToken, dryRun,

package/lib/repository.js

@@ -89,6 +89,81 @@ function githubNumber(prUrl) {
   }
 }
 
+function mergeRequestNumber(prUrl) {
+  try {
+    const parts = new URL(prUrl).pathname.split("/").filter(Boolean);
+    const marker = parts.indexOf("merge_requests");
+    return marker >= 0 && /^\d+$/.test(parts[marker + 1] ?? "") ? parts[marker + 1] : null;
+  } catch {
+    return null;
+  }
+}
+
+function cloneUrlForMergeRequest(prUrl, repoPath) {
+  const url = new URL(prUrl);
+  url.pathname = `/${repoPath}.git`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+
+function branchAtHead(stdout, sha) {
+  const branches = String(stdout ?? "").split("\n").flatMap((line) => {
+    const [hash, ref] = line.trim().split(/\s+/, 2);
+    return hash === sha && ref?.startsWith("refs/heads/") ? [ref.slice(11)] : [];
+  });
+  return branches.length === 1 ? branches[0] : null;
+}
+
+class MergeRequestCheckoutError extends Error {}
+
+async function resolveMergeRequestCheckout(prUrl, target, number, {
+  allowPush, exec, makeTemp, remove,
+}) {
+  const worktree = await makeTemp(path.join(tmpdir(), `jury-mr-${number}-`));
+  try {
+    await exec("git", ["clone", "--quiet", "--no-checkout", cloneUrlForMergeRequest(prUrl, target.path), worktree]);
+    await exec("git", ["fetch", "--quiet", "origin", `refs/merge-requests/${number}/head`], { cwd: worktree });
+    await exec("git", ["checkout", "--quiet", "-b", `jury-mr-${number}`, "FETCH_HEAD"], { cwd: worktree });
+
+    const { stdout: actualOut } = await exec("git", ["rev-parse", "HEAD"], { cwd: worktree });
+    const sha = actualOut.trim();
+    const { stdout: trunkOut } = await exec(
+      "git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], { cwd: worktree },
+    );
+    const trunk = trunkOut.trim().replace(/^origin\//, "");
+    if (!trunk) throw new MergeRequestCheckoutError(
+      `merge request !${number} repository has no default branch`,
+    );
+
+    const { stdout: headsOut } = await exec("git", ["ls-remote", "--heads", "origin"], { cwd: worktree });
+    const branch = branchAtHead(headsOut, sha);
+    if (allowPush && !branch) {
+      throw new MergeRequestCheckoutError(
+        `resolved merge request !${number}, but its source branch is not uniquely available on origin — ` +
+        "use --no-push for a read-only review, or check out the source branch and pass --dir",
+      );
+    }
+
+    return {
+      worktree,
+      state: "OPEN",
+      trunk,
+      branch: branch ?? `merge-request/${number}`,
+      sha,
+      pushTarget: branch ? { remote: "origin", branch } : null,
+      cleanup: () => remove(worktree),
+    };
+  } catch (err) {
+    await remove(worktree);
+    if (err instanceof MergeRequestCheckoutError) throw err;
+    throw new Error(
+      `could not resolve ${target.display} merge request !${number}: ${String(err.message).split("\n")[0]} — ` +
+      "check Git authentication and refs/merge-requests support, or check out the source branch and pass --dir",
+    );
+  }
+}
+
 function remoteForRepository(origin, repoPath) {
   const scp = String(origin).match(/^((?:[^@/\s]+@)?[^:/\s]+):(.+)$/);
   if (scp && !/^[a-z][a-z\d+.-]*:\/\//i.test(origin)) return `${scp[1]}:${repoPath}.git`;
@@ -100,7 +175,7 @@ function remoteForRepository(origin, repoPath) {
 }
 
 /**
- * Resolve a GitHub PR to an isolated checkout of its exact head.
+ * Resolve a GitHub PR or GitLab-style MR to an isolated checkout of its exact head.
  *
  * The checkout is a clone rather than a mutation of the caller's repository:
  * running `jury <url>` from master (or from an unrelated repo) must not switch
@@ -115,10 +190,17 @@ export async function resolvePrCheckout(prUrl, {
 } = {}) {
   const target = repositoryFromPrUrl(prUrl);
   const number = githubNumber(prUrl);
+  const mrNumber = mergeRequestNumber(prUrl);
+  if (target && mrNumber) {
+    return resolveMergeRequestCheckout(prUrl, target, mrNumber, {
+      allowPush, exec, makeTemp, remove,
+    });
+  }
   if (!target || !number) {
     throw new Error(
       `cannot resolve the PR head from "${prUrl}" automatically — ` +
-      "run from its checked-out branch with --dir, or use a GitHub pull request URL",
+      "supported URL forms are GitHub /pull/<id> and GitLab-style /merge_requests/<id>; " +
+      "otherwise run from its checked-out branch with --dir",
     );
   }
 

package/lib/store.js

@@ -183,6 +183,9 @@ export function foldEvents(events, seed = {}) {
   const lanes = new Map(); // agent -> lane, kept in launch order
   let t0 = null;
   let lastMin = 0;
+  // Events are replayed in order. Starting from the seed's latest judge would
+  // misattribute old Claude turns when a resumed run switches judges.
+  let judge = "claude";
 
   const laneFor = (agent) => {
     let lane = lanes.get(agent);
@@ -248,7 +251,7 @@ export function foldEvents(events, seed = {}) {
       case "reply.sent":
         for (const f of findings.values()) {
           if (f.with === e.agent && f.res !== "open") {
-            f.turns.push({ who: "claude", kind: "reply", resumed: e.resumed, at: min });
+            f.turns.push({ who: e.who ?? judge, kind: "reply", resumed: e.resumed, at: min });
           }
         }
         break;
@@ -268,6 +271,7 @@ export function foldEvents(events, seed = {}) {
       }
       case "target":
         run.target = { ...run.target, ...e.target };
+        judge = e.target?.judge ?? judge;
         break;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsdance/codejury",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Independent AI reviewers that iterate until your pull request is clean.",
   "keywords": [
     "code-review",

package/web/index.html

@@ -1,5 +1,5 @@
 <!doctype html>
-<title>Code Jury — Convergence Console</title>
+<title>Code Jury — Review Console</title>
 <style>
   :root {
     --ground:#F4F6F8; --surface:#FFFFFF; --surface-alt:#EDF0F4;
@@ -237,7 +237,7 @@
   .io { background:var(--t-bg); border:1px solid var(--t-line); border-radius:6px;
         overflow:hidden; box-shadow:var(--shadow); font-family:var(--mono); }
   .io-body { padding:13px 16px 18px; font-size:12.6px; line-height:1.6; color:var(--t-fg);
-             max-height:640px; overflow:auto; }
+             overflow-x:auto; }
 
   /* One column per reviewer. They are side by side to make the independence
      legible at a glance; below the breakpoint they stack, which is the same
@@ -258,7 +258,6 @@
   .convo-switch .pr-chip[aria-pressed="true"]:hover { color:#fff; }
   .convo-switch .pr-chip[aria-pressed="false"] { opacity:.7; }
   .convo-note { margin:0 0 10px; font-size:12.5px; color:var(--muted); }
-  .convo .io-body { max-height:none; }
   /* A long unbroken report must scroll inside its own column rather than
      widening the grid and pushing the other conversation off-screen. */
   .convo .stream { white-space:pre-wrap; overflow-wrap:anywhere; }
@@ -362,12 +361,12 @@
   .convo > header .d { width:8px; height:8px; border-radius:50%; background:var(--ok); flex:none; }
   .convo > header .d[data-live="1"] { background:var(--warn); animation:blip 1.4s ease-in-out infinite; }
   @keyframes blip { 0%,100%{opacity:1} 50%{opacity:.25} }
-  /* The thread is what this page exists to show, so it gets real height: tall
-     enough to read in, with a floor so a short conversation still reads as the
-     main surface rather than a strip under the timeline. */
+  /* Completed threads grow with their content. The page owns vertical
+     scrolling; neither the thread nor an individual message hides findings in
+     a nested scroll region. */
   .msgs { padding:14px 16px; display:flex; flex-direction:column; gap:10px;
-    overflow-y:auto; max-height:82vh; min-height:min(34em, 58vh); }
-  .convo-grid[data-stack="1"] .msgs { max-height:56vh; min-height:0; }
+    min-height:min(34em, 58vh); }
+  .convo-grid[data-stack="1"] .msgs { min-height:0; }
   /* Wider than before: bubbles now carry the reviewer's report in full, and a
      narrow column turns a report into a ribbon. */
   .msg { max-width:min(88%, 940px); display:flex; flex-direction:column; gap:4px; min-width:0; }
@@ -437,9 +436,8 @@
   .bub[data-k="streaming"]::after {
     content:"▍"; animation:blip 1s steps(2) infinite; color:var(--accent);
   }
-  /* A long message keeps all of its text and gives up height instead. The
-     inset shadows are the affordance: they say "there is more above/below"
-     without a control to click. */
+  /* Only a live transcript is compact. Once the report completes, it is
+     rendered directly in the conversation at full height. */
   .bub .tall { max-height:26em; overflow-y:auto; overscroll-behavior:contain;
     scrollbar-width:thin; border-radius:3px;
     background:
@@ -522,7 +520,8 @@ let RUN = {
     url: "https://github.com/acme/worker-pool/pull/128",
     title: "Grow the CreateSandbox retry wait on repeated failures",
     branch: "fix/sandbox-manager-create-backoff", trunk: "master",
-    diffstat: "2 files · +418 −13", state: "merged", stateNote: "merged · converged on ae473ab",
+    judge: "claude",
+    diffstat: "2 files · +418 −13", state: "merged", stateNote: "Merged", reviewedCommit: "ae473ab",
     summary: "Two reviewers — codex and droid — read each pushed commit independently. The main agent triages what they find, fixes what survives verification, answers every finding including the ones it rejects, and pushes again. Three rounds until both reported nothing new."
   },
   totalMin: 100,
@@ -594,7 +593,7 @@ let RUN = {
         { who:"codex", ts:"round 1 · T+51m", body:"Accepted. The producer reservation code is byte-for-byte outside this commit's diff, so the issue is pre-existing. The new backoff does not materially widen the concurrent-producer window; cancellation-aware worker exit arguably reduces old/new manager overlap. I agree it belongs in a separate PR." } ] }
   ],
   ship: [
-    { n:"3",  k:"rounds",       s:"to convergence" },
+    { n:"3",  k:"rounds",       s:"until complete" },
     { n:"5",  k:"exchanges",    s:"3 fixed · 1 deferred · 1 rejected" },
     { n:"11", k:"turns",        s:"every finding answered" },
     { n:"0",  k:"prod bugs",    s:"found in these 3 rounds" },
@@ -760,7 +759,7 @@ function draw(){
       ${(x.turns ?? []).map(tt => `
         <div class="ln" data-who="${tt.who}">
           <span class="at">${when(tt)}</span>
-          <span class="nm">${icon(tt.who)}${esc(tt.who)}</span>
+          <span class="nm"${tt.who === judgeName() ? ' style="color:var(--t-claude)"' : ""}>${icon(tt.who)}${esc(tt.who)}</span>
           <span class="say">${rich(tt.body)}
             ${tt.quote ? `<div class="q">${esc(tt.quote)}</div>` : ""}
             ${tt.ask ? `<div class="ask">${esc(tt.ask)}</div>` : ""}
@@ -796,7 +795,7 @@ function draw(){
         return `
           <div class="xgroup">
             <div class="rule" data-who="${esc(agent)}">
-              <span class="lbl">${icon(agent)}claude ⇄ ${esc(agent)}</span><i></i>
+              <span class="lbl">${icon(agent)}${esc(judgeName())} ⇄ ${esc(agent)}</span><i></i>
               <span class="rt">${mine.length} of ${shown} finding(s)</span>
             </div>
             ${mine.map(card).join("")}
@@ -845,9 +844,11 @@ function renderHeader(){
   const branch = t.branch ? `<span>${esc(t.branch)} → ${esc(t.trunk ?? "master")}</span>` : "";
   const stat = t.diffstat ? `<span>${esc(t.diffstat)}</span>` : "";
   const cls = BADGE[t.state] ?? "badge-mute";
+  const commit = reviewedCommit(t);
   const badge = t.state
-    ? `<span class="${cls}"><span class="d"></span>${esc(t.stateNote || t.state)}</span>` : "";
-  $("t-meta").innerHTML = [link, branch, stat, badge].filter(Boolean).join("");
+    ? `<span class="${cls}"><span class="d"></span>${esc(statusLabel(t))}</span>` : "";
+  const reviewed = commit ? `<span>Reviewed commit <code>${esc(commit)}</code></span>` : "";
+  $("t-meta").innerHTML = [link, branch, stat, badge, reviewed].filter(Boolean).join("");
 
   // Only worth showing when there is something to switch between.
   //
@@ -934,7 +935,7 @@ function runSummary(r) {
   const t = r.target ?? {};
   if (isLive(r) && t.stateNote) return t.stateNote;
   const n = (r.exchanges ?? []).length;
-  if (t.state === "converged") return "converged";
+  if (t.state === "converged") return "Review complete";
   const found = n ? `${n} finding${n === 1 ? "" : "s"}` : "";
   // A stale "review" is a run that stopped without finishing. Saying "review"
   // would repeat the claim that misled the grouping in the first place.
@@ -942,6 +943,17 @@ function runSummary(r) {
   return found || t.stateNote || t.state || "";
 }
 
+function reviewedCommit(t) {
+  if (t?.reviewedCommit) return t.reviewedCommit;
+  return (t?.stateNote?.match(/\bconverged on ([0-9a-f]{7,40})\b/i)?.[1] ?? "").toLowerCase();
+}
+
+function statusLabel(t) {
+  if (t?.state === "converged") return "Review complete";
+  if (t?.state === "merged" && /converged/i.test(t.stateNote ?? "")) return "Merged";
+  return t?.stateNote || t?.state || "";
+}
+
 function drawSwitcher() {
   const el = $("switcher");
   if (!el) return;
@@ -1125,14 +1137,15 @@ function render(){
    folded run; a conversation needs the events in the order they were spoken,
    and folding throws that order away.
 
-   Side is fixed by speaker, never by turn order: claude left, reviewer right.
+   Side is fixed by speaker, never by turn order: judge left, reviewer right.
    A reader should be able to tell who is talking from across the room. */
 let THREADS = [];        // [{agent, turns:[…]}]
 let CONVO_STACK = false; // one thread full width, or every thread stacked
 let CONVO_PICK = null;   // which thread, when not stacked
 const CONVO_SHUT = new Set(); // collapsed threads, by agent, while stacked
 
-const SIDE = (who) => (who === "claude" ? "l" : "r");
+const judgeName = () => RUN.target?.judge ?? "claude";
+const SIDE = (who) => (who === judgeName() ? "l" : "r");
 
 // A stable colour per agent. codex and droid have tokens already; anything else
 // is hashed to a hue so a five-reviewer run does not render five identical
@@ -1155,22 +1168,12 @@ const VERDICT_TEXT = {
   superseded: "Superseded",
 };
 
-// Long reports collapse. A twenty-minute reviewer turn can be thousands of
-// lines, and an un-collapsed one buries every exchange after it.
+// A live transcript can be thousands of lines before it becomes a completed
+// report. Keep only that in-progress state compact; completed messages expand.
 const CLAMP = 700;
-/* The collapsing half of a bubble, on its own so that bubbles which lead with a
-   header — a verdict, a named claim — can clamp their body without clamping the
-   header along with it. */
 /**
- * Every message in full, always. Nothing is truncated and nothing hides behind
- * a button: reading a review should not mean clicking through it.
- *
- * The reason a clamp existed is still real — evidence arrives verbatim from
- * `jury finding reproduce --evidence` and is routinely thousands of lines, and
- * one such turn inlined at full height buries every turn after it. So a long
- * message scrolls WITHIN ITS OWN BOX instead of being cut: the whole text is in
- * the DOM, selectable and searchable with the browser's own find, while the
- * thread below it stays reachable. Bounded height, not bounded content.
+ * Compact an in-progress transcript without truncating its DOM content.
+ * Completed reports bypass this helper and expand to their full height.
  */
 function clamped(text) {
   const t = text ?? "";
@@ -1179,7 +1182,7 @@ function clamped(text) {
     aria-label="long message, ${bytes(t.length)}, scrollable">${esc(t)}</div>`;
 }
 function bubble(text, k, attrs = "") {
-  return `<div class="bub" data-k="${k}" ${attrs}>${clamped(text)}</div>`;
+  return `<div class="bub" data-k="${k}" ${attrs}>${esc(text ?? "")}</div>`;
 }
 /** m:ss, or h:mm:ss once a reviewer has been going that long. */
 function hms(sec) {
@@ -1235,19 +1238,17 @@ function stampFor(t) {
 
 function turnHTML(t, agent) {
   const side = SIDE(t.who);
-  const nm = t.who === "claude" ? "claude" : agent;
+  const nm = t.who === judgeName() ? judgeName() : agent;
   let body = "";
   switch (t.kind) {
     case "finding":
       body = `<div class="bub" data-k="finding"><span class="hd">${esc(t.claim ?? "")}</span
-        >${t.loc ? `<span class="loc">${esc(t.loc)}</span>\n` : ""}${esc((t.body ?? "").slice(0, CLAMP))}</div>`;
+        >${t.loc ? `<span class="loc">${esc(t.loc)}</span>\n` : ""}${esc(t.body ?? "")}</div>`;
       break;
     case "reproduced":
-      // Evidence is whatever the reviewer passed to `finding reproduce
-      // --evidence`, which is routinely a wall of captured command output. It
-      // collapses, or one reproduction buries every turn below it.
+      // Evidence is shown inline in full once reproduction has completed.
       body = `<div class="bub" data-k="reproduced"
-        >${t.claim ? `<span class="re">${esc(t.claim)}</span>\n` : ""}Reproduced. ${clamped(t.text ?? "")}</div>`;
+        >${t.claim ? `<span class="re">${esc(t.claim)}</span>\n` : ""}Reproduced. ${esc(t.text ?? "")}</div>`;
       break;
     case "verdict":
       // The claim is named here because the findings are no longer bubbles of
@@ -1262,7 +1263,7 @@ function turnHTML(t, agent) {
       // being re-argued, so it names the claim and leaves the words to the
       // report. Claude's turn in the thread does carry text, and shows it.
       body = `<div class="bub" data-k="rebuttal"
-        ><span class="hd">${t.who === "claude" ? "still open" : "not convinced"}</span
+        ><span class="hd">${t.who === judgeName() ? "still open" : "not convinced"}</span
         >${t.claim ? `<span class="re">${esc(t.claim)}</span>` : ""}${t.text ? `\n${esc(t.text)}` : ""}</div>`;
       break;
     case "commit":
@@ -1299,7 +1300,7 @@ function turnHTML(t, agent) {
       body = bubble(t.text ?? "", esc(t.kind ?? "turn"));
   }
   return `<div class="msg" data-side="${side}"><span class="nm"
-    ><span class="ic" style="color:${nm === "claude" ? "var(--main-hue)" : hueFor(nm)}">${icon(nm)}</span>${esc(nm)}${stampFor(t)}</span>${body}</div>`;
+    ><span class="ic" style="color:${nm === judgeName() ? "var(--main-hue)" : hueFor(nm)}">${icon(nm)}</span>${esc(nm)}${stampFor(t)}</span>${body}</div>`;
 }
 
 /**
@@ -1380,7 +1381,7 @@ function drawConvo() {
     return `<div class="convo" data-a="${esc(t.agent)}" data-open="${open ? 1 : 0}">
       <header data-fold-agent="${esc(t.agent)}"><span class="tw">${open ? "▾" : "▸"}</span
         ><span class="d" data-live="${l ? 1 : 0}"></span>
-        <span class="who"><span class="ic" style="color:var(--main-hue)">${icon("claude")}</span>claude
+        <span class="who"><span class="ic" style="color:var(--main-hue)">${icon(judgeName())}</span>${esc(judgeName())}
           <span class="sw">⇄</span>
           <span class="ic" style="color:${hueFor(t.agent)}">${icon(t.agent)}</span>${esc(t.agent)}</span>
         <span class="st">${t.turns.length} turn${t.turns.length === 1 ? "" : "s"}${l ? " · live" : ""}</span>
@@ -1502,8 +1503,12 @@ function foldConversation(events) {
   };
   const owner = new Map();
   const claimOf = new Map();
+  let judge = "claude";
   for (const e of events) {
     switch (e.t) {
+      case "target":
+        judge = e.target?.judge ?? judge;
+        break;
       case "finding.raised":
         owner.set(e.id, e.agent);
         // Deliberately NOT a turn of its own. The reviewer already said this in
@@ -1518,12 +1523,12 @@ function foldConversation(events) {
         thread(e.agent);
         break;
       case "finding.reproduced":
-        thread(owner.get(e.id) ?? "?").turns.push({ who: "claude", kind: "reproduced",
+        thread(owner.get(e.id) ?? "?").turns.push({ who: e.who ?? judge, kind: "reproduced",
           id: e.id, claim: claimOf.get(e.id) ?? "",
           text: typeof e.evidence === "string" ? e.evidence : "", ts: e.ts });
         break;
       case "finding.resolved":
-        thread(owner.get(e.id) ?? "?").turns.push({ who: "claude", kind: "verdict",
+        thread(owner.get(e.id) ?? "?").turns.push({ who: e.who ?? judge, kind: "verdict",
           id: e.id, claim: claimOf.get(e.id) ?? "",
           verdict: e.verdict, text: e.reason ?? "", test: e.test ?? "", ts: e.ts });
         break;
@@ -1532,12 +1537,12 @@ function foldConversation(events) {
         // and that reply is already rendered whole as its `answer` turn — so the
         // text is deliberately dropped, exactly as a raised finding's is. What
         // survives is the linkage: which claim is being re-argued, and by whom.
-        // Claude's own turn is the exception: it is not an excerpt of anything
+        // The judge's own turn is the exception: it is not an excerpt of anything
         // shown elsewhere, so dropping its text would lose it entirely.
         const who = e.who ?? "?";
         const turn = { who, kind: "rebuttal", id: e.id,
           claim: claimOf.get(e.id) ?? "", ts: e.ts };
-        if (who === "claude") turn.text = e.text ?? "";
+        if (who === judge) turn.text = e.text ?? "";
         thread(owner.get(e.id) ?? e.agent ?? "?").turns.push(turn);
         break;
       }
@@ -1589,7 +1594,7 @@ function foldConversation(events) {
         break;
       }
       case "reply.sent":
-        thread(e.agent).turns.push({ who: "claude", kind: "reply", text: e.text ?? "", ts: e.ts });
+        thread(e.agent).turns.push({ who: e.who ?? judge, kind: "reply", text: e.text ?? "", ts: e.ts });
         break;
       case "reply.answered":
         thread(e.agent).turns.push({ who: e.agent, kind: "answer",
@@ -1597,7 +1602,7 @@ function foldConversation(events) {
         break;
       case "commit.pushed":
         for (const t of threads.values()) {
-          t.turns.push({ who: "claude", kind: "commit", sha: e.sha, text: e.subject ?? "", ts: e.ts });
+          t.turns.push({ who: e.who ?? judge, kind: "commit", sha: e.sha, text: e.subject ?? "", ts: e.ts });
         }
         break;
     }