@irythill/orq 0.6.1 → 0.8.0

package/dist/pick.js

@@ -1,11 +1,11 @@
 // Picks agent, model, effort and account for a role (port of orq-pick, plus fixed roles).
 //   fixed role: the first agent of [agent, ...fallback] that passes the filters wins — no scoring, never swapped
 //               for an agent the user didn't list.
-//   auto role:  every pool agent that passes is scored:
+//   auto role:  every (agent, model) pair that passes is scored (a level may list several models):
 //     quality * delivery + tokens * economy + speed * quickness − rotation * (picks in the last `window`)
 //     − reserve (agents with reserve = true) + explore (fewer than `min_samples` runs, fading with n, none after
 //     `explore_streak` picks in a row). Each axis is (prior·k + observed·n)/(k + n), k = min_samples.
-// Filters: --exclude-agent, orq block, nobody reviews their own code (unless no other agent can), cross-vendor rule, a model for the role/level,
+// Filters: --exclude-agent, orq block, a CLI that doesn't resolve on PATH, nobody reviews their own code (unless no other agent can), cross-vendor rule, a model for the role/level,
 // quota under the limits: policy.quota_week (95) on the weekly window, and on the 5h one policy.quota_5h per level
 // (simple 90, medium 85, heavy 80): a heavy task needs more room left to finish.
 // An agent's `headroom` (points) lowers both limits for it: that share of its accounts stays for the conductors.
@@ -13,7 +13,7 @@
 // Pacing: an account whose usage, at the pace so far in a window (used ÷ elapsed share), projects past
 // that window's pick limit (the filter's) at its reset is passed over for another account under the limit when the agent has several,
 // and otherwise loses policy.pacing_penalty (default 0.3, 0 = off) of score — soft, never a drop.
-import { agentDef, usesPrompt } from "./agents.js";
+import { agentDef, baseCommit, usesPrompt } from "./agents.js";
 import { m } from "./i18n.js";
 import { humanReset } from "./quota.js";
 import { legacyRole, resolveRole, vendorOf } from "./roles.js";
@@ -73,17 +73,25 @@ export function limitsFor(pol, level) {
     const five = { ...FIVE, ...(pol.quota_5h ?? {}) };
     return [Math.min(Number(five[level] ?? five.medium), Number(pol.quota_limit ?? 90)), Number(pol.quota_week ?? 95)];
 }
-export function modelFor(a, role, level) {
-    if (a.models === undefined)
-        return ["", undefined]; // no models configured: the CLI's default
-    const models = a.models;
+/** The agent's models section for a role, with the same fallbacks as the roles (fix → impl, watchdog → opinion → review). */
+function roleModels(a, role) {
+    const models = (a.models ?? {});
     const lr = legacyRole(role);
-    const ms = models[lr] ?? (lr === "fix" ? models.impl : lr === "watchdog" ? models.opinion ?? models.review : undefined) ?? {};
-    const spec = ms[level] ?? ms.default ?? ms.medium ?? ms.simple;
-    if (!spec)
-        return undefined;
-    const [model, effort] = spec.split("@");
-    return [model, effort || undefined];
+    return models[lr] ?? (lr === "fix" ? models.impl : lr === "watchdog" ? models.opinion ?? models.review : undefined) ?? {};
+}
+const specList = (spec) => (Array.isArray(spec) ? spec : spec ? [spec] : []).map(String).filter(Boolean)
+    .map((x) => { const [model, effort] = x.split("@"); return [model, effort || undefined]; });
+/** Every candidate model for the role/level, in the order configured; undefined when none is. */
+export function modelsFor(a, role, level) {
+    if (a.models === undefined)
+        return [["", undefined]]; // no models configured: the CLI's default
+    const ms = roleModels(a, role);
+    const list = specList(ms[level] ?? ms.default ?? ms.medium ?? ms.simple);
+    return list.length ? list : undefined;
+}
+/** The first candidate model for the role/level. */
+export function modelFor(a, role, level) {
+    return modelsFor(a, role, level)?.[0];
 }
 // --- per-model quota ---------------------------------------------------------------------------------------------------
 // A collector may add lines "<account>/<model> 5h=.. week=.." (antigravity: one bucket per model group). The model a pick is about
@@ -98,25 +106,33 @@ export function modelKey(model, keys) {
 }
 /** The models of an agent's role section lighter than `level`, the closest first, without repeats of `tried`. */
 export function lighterModels(a, role, level, tried) {
-    const models = a.models;
-    if (!models)
+    if (!a.models)
         return [];
-    const lr = legacyRole(role);
-    const ms = models[lr] ?? (lr === "fix" ? models.impl : lr === "watchdog" ? models.opinion ?? models.review : undefined) ?? {};
+    const ms = roleModels(a, role);
     const rank = LEVEL_RANK[level] ?? 1, seen = new Set(tried);
     const out = [];
     for (const [, spec] of Object.entries(ms).filter(([lv]) => (LEVEL_RANK[lv] ?? 1) < rank)
         .sort((x, y) => (LEVEL_RANK[y[0]] ?? 1) - (LEVEL_RANK[x[0]] ?? 1))) {
-        const [model, effort] = spec.split("@");
-        if (seen.has(model))
-            continue;
-        seen.add(model);
-        out.push([model, effort || undefined]);
+        for (const [model, effort] of specList(spec)) {
+            if (seen.has(model))
+                continue;
+            seen.add(model);
+            out.push([model, effort]);
+        }
     }
     return out;
 }
 const WEIGHTS = { quality: 0.4, tokens: 0.45, speed: 0.15, rotation: 0.2, reserve: 0.3, explore: 0.1, explore_streak: 2, min_samples: 8, window: 6 };
 export const weights = (cfg) => ({ ...WEIGHTS, ...((cfg.policy ?? {}).weights ?? {}) });
+/** The merged definition (built-in + config) can review a commit base (agents.<name>.base_commit); an agent that can't be resolved can't. */
+function takesBaseCommit(cfg, name) {
+    try {
+        return baseCommit(agentDef(cfg, name));
+    }
+    catch {
+        return false;
+    }
+}
 /** The merged definition (built-in + config) takes a prompt; an agent that can't be resolved doesn't. */
 function takesPrompt(cfg, name) {
     try {
@@ -156,6 +172,11 @@ export function pick(inp) {
             out(name, m("blocked (orq block -l)", "bloqueado (orq block -l)"));
             continue;
         }
+        const gone = inp.missing?.get(name);
+        if (gone) {
+            out(name, gone);
+            continue;
+        }
         if ((role === "review" || role === "opinion" || role === "watchdog") && name === inp.implAgent && someoneElse) {
             out(name, m("it implemented this code", "foi quem implementou"));
             continue;
@@ -165,12 +186,16 @@ export function pick(inp) {
             out(name, m("same vendor as the implementer", "mesmo fornecedor do implementador"));
             continue;
         }
+        if (role === "review" && inp.commitBase && !takesBaseCommit(cfg, name)) {
+            out(name, m("can't review a commit base (base_commit = false)", "não revisa uma base que é commit (base_commit = false)"));
+            continue;
+        }
         if (role === "watchdog" && !takesPrompt(cfg, name)) {
             out(name, m("ignores prompts (a review tool)", "ignora prompts (ferramenta de revisão)"));
             continue;
         }
-        const mf = modelFor(a, role, level);
-        if (!mf) {
+        const mfs = modelsFor(a, role, level);
+        if (!mfs) {
             out(name, m(`no model for ${role}/${level}`, `sem modelo para ${role}/${level}`));
             continue;
         }
@@ -229,8 +254,8 @@ export function pick(inp) {
             return { pace: paces.length ? Math.max(...paces) : undefined,
                 hot: penalty > 0 && ((p5 !== undefined && p5 > limit5) || (pw !== undefined && pw > limitWeek)) };
         };
-        // The chosen account's per-model buckets: an exhausted model gives way to a lighter one of the same agent.
-        let mfx = mf;
+        // The chosen account's per-model buckets: an exhausted candidate drops out; with none left, a lighter model of the agent.
+        let mfx = mfs;
         const acc0 = usable.length ? [...usable].sort((x, y) => x[1] - y[1])[0][0] : undefined;
         const mkeys = acc0 ? Object.keys(inp.windows ?? {}).filter((k) => k.startsWith(`${acc0}/`)).map((k) => k.slice(acc0.length + 1)) : [];
         if (acc0 && mkeys.length) {
@@ -245,23 +270,25 @@ export function pick(inp) {
                 return `${model} ${five ? `5h ${q.five}%` : `${m("week", "semana")} ${q.week}%`}`
                     + (at.length ? ` (${m("back", "volta")} ${humanReset(Math.max(...at))})` : "");
             };
-            const tried = [], skipped = [];
-            let found;
-            for (const cand of [mf, ...lighterModels(a, role, level, [mf[0]])]) {
-                const why = over(cand[0]);
-                if (!why) {
-                    found = cand;
-                    break;
+            const skipped = [];
+            let found = mfs.filter((c) => { const why = over(c[0]); if (why)
+                skipped.push(why); return !why; });
+            if (!found.length) {
+                for (const cand of lighterModels(a, role, level, mfs.map((c) => c[0]))) {
+                    const why = over(cand[0]);
+                    if (!why) {
+                        found = [cand];
+                        break;
+                    }
+                    skipped.push(why);
                 }
-                tried.push(cand[0]);
-                skipped.push(why);
             }
-            if (!found) {
+            if (!found.length) {
                 out(name, `${m("every model over its quota", "todo modelo acima da cota")}: ${skipped.join(", ")}`);
                 continue;
             }
             if (skipped.length)
-                out(name, `${m("quota exhausted", "cota esgotada")}: ${skipped.join(", ")}; ${m("using", "usando")} ${found[0]}`);
+                out(name, `${m("quota exhausted", "cota esgotada")}: ${skipped.join(", ")}; ${m("using", "usando")} ${found.map((c) => c[0]).join(", ")}`);
             mfx = found;
         }
         const ranked = usable.map(([n, v]) => ({ n, v: v, ...paceOf(n) }))
@@ -269,9 +296,12 @@ export function pick(inp) {
         const chosen = ranked[0];
         const acct = qn.length > 1 ? chosen?.n : undefined;
         const statRole = role === "fix" || role === "worker" ? "impl" : role;
-        const stOf = (sr) => inp.stats.find((r) => r.role === sr && r.agent === name && r.model === (mfx[0].split("/").pop() || "default"));
-        const st = stOf(statRole) ?? (role === "watchdog" ? stOf("review") : undefined); // no watchdog runs yet: its review record
-        pass.push({ agent: name, model: mfx[0], effort: mfx[1], acct, a, st, pace: chosen?.pace, hot: Boolean(chosen?.hot) });
+        // One candidate per (agent, model) pair, each scored on its own stats row; a fixed role takes the first model.
+        for (const [model, effort] of res.mode === "fixed" ? mfx.slice(0, 1) : mfx) {
+            const stOf = (sr) => inp.stats.find((r) => r.role === sr && r.agent === name && r.model === (model.split("/").pop() || "default"));
+            const st = stOf(statRole) ?? (role === "watchdog" ? stOf("review") : undefined); // no watchdog runs yet: its review record
+            pass.push({ agent: name, model, effort, acct, a, st, pace: chosen?.pace, hot: Boolean(chosen?.hot) });
+        }
         if (res.mode === "fixed")
             break; // the first that passes wins
     }
@@ -306,9 +336,10 @@ export function pick(inp) {
         const t = axis(m("economy", "economia"), prior, c.st?.new && refTok ? Math.min(1, refTok / c.st.new) : undefined, n);
         const s = axis(m("speed", "rapidez"), prior, c.st?.min && refMin ? Math.min(1, refMin / Math.max(c.st.min, 0.1)) : undefined, n);
         const used = inp.recent.filter((p) => p.agent === c.agent).length;
-        // Exploration fades as samples come in and stops after explore_streak picks of the agent in a row.
+        // Exploration fades as samples come in and stops after explore_streak picks of the pair in a row (rotation stays per agent).
+        const same = (p) => p.agent === c.agent && (p.model === undefined || p.model === c.model);
         let streak = 0;
-        for (let i = inp.recent.length - 1; i >= 0 && inp.recent[i].agent === c.agent; i--)
+        for (let i = inp.recent.length - 1; i >= 0 && same(inp.recent[i]); i--)
             streak++;
         const capped = few(c.st) && streak >= w.explore_streak;
         const explore = few(c.st) && !capped ? w.explore * (k - n) / k : 0;

package/dist/process.js

@@ -104,6 +104,15 @@ export function killTree(pid, group = true) {
             }
             catch { /* gone */ } // no group of its own
 }
+/** Exit code when the command never started (spawn threw or emitted "error"). */
+export const SPAWN_FAILED = 127;
+/** Node throws some spawn errors synchronously (E2BIG, EINVAL...) and emits others (ENOENT): one path for both. */
+function startFailed(e, o) {
+    const err = e;
+    console.error(`orq: ${err.message}`);
+    o.onError?.(err);
+    return Promise.resolve(SPAWN_FAILED);
+}
 /** cmd.exe quoting for one argument (only used when Windows needs a shell). */
 export const winQuote = (a) => /[\s"&|<>^%()]/.test(a) || a === "" ? `"${a.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1")}"` : a;
 const gb = (b) => `${(b / 2 ** 30).toFixed(1)} GB`;
@@ -113,18 +122,30 @@ export function runCapped(cmd, args, o = {}) {
     if (mode === "kernel") {
         const sd = ["--user", "--scope", "-q", ...noExp(), ...(o.unit ? [`--unit=${o.unit}`] : []), "-p", `MemoryMax=${o.cap}`,
             ...(o.swap !== undefined ? ["-p", `MemorySwapMax=${o.swap}`] : []), "--", cmd, ...args];
-        const c = spawn("systemd-run", sd, { stdio: o.stdio ?? "inherit", cwd: o.cwd, env: o.env });
+        let c;
+        try {
+            c = spawn("systemd-run", sd, { stdio: o.stdio ?? "inherit", cwd: o.cwd, env: o.env });
+        }
+        catch (e) {
+            return startFailed(e, o);
+        }
         o.onSpawn?.(c);
-        return wait(c);
+        return wait(c, o);
     }
     const win = process.platform === "win32";
     // Own process group on Linux/macOS, so the whole tree can be killed at once (not for a screen: it needs the terminal).
     // Windows: a shell only for .cmd/.bat shims (npx, claude…); an .exe runs directly (paths with spaces stay intact).
     const shell = win && !/\.exe$/i.test(cmd), q = shell && o.quote;
-    const child = spawn(q ? winQuote(cmd) : cmd, q ? args.map(winQuote) : args, { stdio: o.stdio ?? "inherit", cwd: o.cwd, env: o.env, detached: !win && !o.tty, shell, windowsHide: true });
+    let child;
+    try {
+        child = spawn(q ? winQuote(cmd) : cmd, q ? args.map(winQuote) : args, { stdio: o.stdio ?? "inherit", cwd: o.cwd, env: o.env, detached: !win && !o.tty, shell, windowsHide: true });
+    }
+    catch (e) {
+        return startFailed(e, o);
+    }
     o.onSpawn?.(child);
     if (mode === "off" || !child.pid)
-        return wait(child);
+        return wait(child, o);
     const fwd = (sig) => () => { try {
         process.kill(-child.pid, sig);
     }
@@ -149,14 +170,14 @@ export function runCapped(cmd, args, o = {}) {
             killTree(child.pid, !o.tty);
         }
     }, o.intervalMs ?? 1000);
-    return wait(child).then((code) => {
+    return wait(child, o).then((code) => {
         clearInterval(timer);
         process.off("SIGINT", onInt);
         process.off("SIGTERM", onTerm);
         return killed ? 137 : code;
     });
 }
-const wait = (c) => new Promise((res) => {
-    c.on("error", (e) => { console.error(`orq: ${e.message}`); res(127); });
+const wait = (c, o = {}) => new Promise((res) => {
+    c.on("error", (e) => { startFailed(e, o).then(res); });
     c.on("exit", (code, sig) => res(code ?? (sig ? 128 + 9 : 1)));
 });

package/dist/rounds.js

@@ -14,6 +14,7 @@ export const SLOW_FACTOR = 2; // a round this many times slower than the median
 export const SLOW_MIN_SECS = 600; // ... but only if it also took at least this long
 export const REPEAT_WARN = 2; // a finding seen in this many reviews: warn
 export const REPEAT_STOP = 3; // ... in this many: stop (it came back after two fix rounds)
+export const FRESH_WARN = 2; // fix rounds whose review brings heavy findings never seen before: the branch is too big, split it
 export const HEAVY = new Set(["blocker", "major", "critical"]); // only these count towards repeats and the alert
 const read = (f) => { try {
     return readFileSync(f, "utf8");
@@ -40,7 +41,8 @@ const repoRel = (f) => f.replace(/\\/g, "/").replace(/^.*\.worktrees\/[^/]+\//,
 export function parseFindings(text, round) {
     const out = [];
     for (const line of text.split("\n")) {
-        const it = /^\s*(?:[-*+]|\d+[.)])\s+(.*)$/.exec(line);
+        // A list item, or a bare line that starts with a severity tag ("[blocker] src/a.ts:10 ...", as some reviewers write).
+        const it = /^\s*(?:[-*+]|\d+[.)])\s+(.*)$/.exec(line) ?? /^\s*(\[(?:blocker|major|minor|nit|suggestion|important|critical)\].*)$/i.exec(line);
         if (!it)
             continue;
         const sevOf = (w) => { const k = fold(w ?? ""); return Object.hasOwn(SEV, k) ? SEV[k] : undefined; };
@@ -60,6 +62,13 @@ export function parseFindings(text, round) {
     return out;
 }
 /** Same finding? Same file (when both name one) and enough shared words; without a file, a stricter overlap. */
+// An explicit "nothing to fix" verdict, PT or EN, on a line of its own or as a heading/label.
+const APPROVED = /^\s*(?:[#>*_`-]+\s*)*(?:verdict|veredito|status|resultado)?\s*[:—-]?\s*\**\s*(approved|approve|lgtm|aprovad[oa]|no (?:blocking )?(?:findings|issues|blockers)|nenhum (?:achado|problema|blocker|bloqueante)|sem (?:achados|bloqueantes|blockers))\b/im;
+/** Does a review answer carry a verdict: at least one finding with a severity, or an explicit approval?
+ *  "I'll start by exploring the repo..." (a reviewer that stopped before reviewing) has neither. */
+export function hasVerdict(text) {
+    return parseFindings(text, 0).length > 0 || APPROVED.test(text);
+}
 export function similar(a, b) {
     const wa = words(a.title), wb = words(b.title);
     if (!wa.size || !wb.size)
@@ -86,6 +95,14 @@ export function repeats(fs) {
     return groups.map((g) => ({ file: g[0].file, title: g[0].title, rounds: [...new Set(g.map((x) => x.round))] }))
         .filter((r) => r.rounds.length >= REPEAT_WARN);
 }
+/** Fix rounds (k ≥ 1) whose review raised a heavy finding not similar to any earlier one: a reviewer re-reading a big branch. */
+export function freshRounds(fs) {
+    const out = new Set();
+    for (const f of fs)
+        if (f.round > 0 && !fs.some((e) => e.round < f.round && similar(e, f)))
+            out.add(f.round);
+    return [...out].sort((a, b) => a - b);
+}
 const median = (xs) => { const s = [...xs].sort((a, b) => a - b), h = s.length >> 1; return s.length % 2 ? s[h] : (s[h - 1] + s[h]) / 2; };
 /** Fix rounds far above the median of the other fix rounds (round 0 is the implementation: never compared; needs 3 fix rounds). */
 export function slowRounds(all) {
@@ -96,7 +113,7 @@ export function slowRounds(all) {
 }
 /** The pure part: facts from the files → numbers, alert level and why. */
 export function metrics(issue, f) {
-    const reps = repeats(f.findings.filter((x) => HEAVY.has(x.severity))), reasons = [];
+    const heavy = f.findings.filter((x) => HEAVY.has(x.severity)), reps = repeats(heavy), reasons = [];
     let level = "ok";
     const raise = (l, why) => { reasons.push(why); if (l === "stop" || level === "ok")
         level = l; };
@@ -109,6 +126,9 @@ export function metrics(issue, f) {
         raise("stop", { code: "same_finding", n: worst });
     else if (reps.length)
         raise("warn", { code: "repeated", n: reps.length });
+    const fresh = freshRounds(heavy);
+    if (fresh.length >= FRESH_WARN)
+        raise("warn", { code: "fresh", n: fresh.length, rounds: fresh });
     const slow = slowRounds(f.perRound);
     if (slow.length)
         raise("warn", { code: "slow", n: slow.length, rounds: slow });
@@ -121,11 +141,25 @@ export function countRounds(dir, names) {
         const fx = /^fix-(\d+)\.md$/.exec(f);
         if (fx)
             n = Math.max(n, Number(fx[1]));
-        else if (f.startsWith(".rounds-"))
+        else if (f.startsWith(".rounds-") && !f.endsWith(".log"))
             n = Math.max(n, Number(read(join(dir, f))) || 0);
     }
     return n;
 }
+/** Follow-ups per reason (review|verify|unblock) from the .rounds-<session>.log files `orq agent -R` appends to. */
+export function roundReasons(dir, names) {
+    const out = {};
+    for (const f of names) {
+        if (!/^\.rounds-.+\.log$/.test(f))
+            continue;
+        for (const line of read(join(dir, f)).split("\n")) {
+            const r = line.split(" ")[1];
+            if (r)
+                out[r] = (out[r] ?? 0) + 1;
+        }
+    }
+    return out;
+}
 /** The impure part: read .orquestra/<issue>/. undefined when the issue has no fix or review files at all. */
 export function collectRounds(ws, issue, max) {
     const dir = join(ws, ".orquestra", issue);
@@ -160,7 +194,9 @@ export function collectRounds(ws, issue, max) {
         return { round: k, secs: Number.isNaN(s) || Number.isNaN(next) ? 0 : Math.max(0, Math.round((next - s) / 1000)) };
     });
     const findings = [...reviews].flatMap(([k, fs]) => fs.flatMap((n) => parseFindings(read(join(dir, n)), k)));
-    return metrics(issue, { rounds, max, perRound, findings, secs: Math.round((t1 - t0) / 1000) });
+    const x = metrics(issue, { rounds, max, perRound, findings, secs: Math.round((t1 - t0) / 1000) });
+    const fu = roundReasons(dir, names);
+    return Object.keys(fu).length ? { ...x, followups: fu } : x;
 }
 /** Cheap change signature of an issue folder (names + mtimes, no reads) for caching collectRounds between redraws. */
 export function roundsSig(ws, issue) {

package/dist/stats.js

@@ -3,9 +3,13 @@
 // duration, tokens. "New" tokens = excluding cache reads (what actually weighs on quota); Codex without a session
 // file only reports the total. Implementation delivery = the first review of the same repo in the issue said APPROVED.
 // Limitation: follow-ups (-R) reuse the implementation prefix, so the "impl" row shows the last round of that prefix.
+// Agent and model come from the job (<prefix>.job.json argv), then the pick (<prefix>.pick), then the log; a tool
+// without models (a review CLI) has model "-". Time runs to the first turn on a screen run (<prefix>.turns): later
+// turns wait on a person. Killed runs and older screen runs without .turns are counted but left out of the time median.
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
+import { argvModel, tokenize } from "./agents.js";
 import { doneStatus } from "./process.js";
 const ROLE = /^(impl|fix\d*|review\d*|[a-z]+-review\d*|watchdog\d*)-?/;
 const read = (f) => { try {
@@ -14,14 +18,40 @@ const read = (f) => { try {
 catch {
     return "";
 } };
-export function agentModel(run, log) {
-    const a = /\b(codex exec|codex resume|codex|claude -p|claude|opencode run|opencode|agy)\b/.exec(run);
-    const first = a ? a[1].split(" ")[0] : "?";
-    const agent = first === "agy" ? "antigravity" : first;
-    let model = /(?:\s-m|--model)\s+'?([^\s']+)/.exec(run)?.[1];
-    if (agent === "codex" && !model)
-        model = /^model: (\S+)/m.exec(log)?.[1] ?? "default";
-    return [agent, (model ?? "default").split("/").pop()];
+const BINS = /^(codex|claude|opencode|agy|copilot)$/;
+/** The model a log says was used: Claude's init event, Codex's banner, opencode's step events. */
+function logModel(log) {
+    return /"type"\s*:\s*"system"[^\n]*?"model"\s*:\s*"([^"]+)"/.exec(log)?.[1] ?? /^model: (\S+)/m.exec(log)?.[1]
+        ?? /"modelID"\s*:\s*"([^"]+)"/.exec(log)?.[1];
+}
+/** The argv of a generated .run.sh: its command, shell-tokenized (quotes span lines), without leading VAR=value words. */
+function runArgv(run) {
+    const body = run.split("\n").filter((l) => !l.startsWith("#") && !l.startsWith("cd ")).join("\n");
+    const words = tokenize(body.replace(/\s<\s\S+\s*$/, "")).map((w) => w.text);
+    while (words.length && /^\w+=/.test(words[0]))
+        words.shift();
+    return words;
+}
+/** [agent, model] of a run. `job` is <prefix>.job.json (argv + agent), `pick` the `-a … -m …` line it was dispatched with
+ *  (used only when it names the same agent). */
+export function agentModel(run, log, job, pick = "") {
+    let argv = job?.argv ?? runArgv(run);
+    const base = (w) => w.split(/[\\/]/).pop();
+    // Older runs wrap the agent (systemd-run …, git worktree … && codex): start at the first agent CLI found.
+    const at = job ? 0 : argv.findIndex((w) => BINS.test(base(w)));
+    if (at > 0)
+        argv = argv.slice(at);
+    const bin = base(argv[0] ?? "");
+    let agent = job?.agent || bin || "?";
+    if (agent === "agy")
+        agent = "antigravity";
+    const picked = / -a (\S+)/.exec(` ${pick}`)?.[1] === agent ? / -m (\S+)/.exec(pick)?.[1] : undefined;
+    // opencode's screen takes the model in its config env, not -m.
+    const envModel = /"model":"([^"]+)"/.exec(job?.env?.OPENCODE_CONFIG_CONTENT ?? "")?.[1];
+    const model = argvModel(argv) ?? envModel ?? picked ?? logModel(log);
+    if (model)
+        return [agent, model.split("/").pop()];
+    return [agent, /^(codex|claude|opencode|agy)$/.test(bin) ? "default" : "-"];
 }
 function codexSession(sid) {
     const root = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "sessions");
@@ -74,8 +104,10 @@ export function tokens(agent, log, sid = "") {
         }
         else if (agent === "opencode" && e.type === "step_finish") {
             const t = e.part?.tokens ?? {};
-            neu += (t.total ?? 0) - (t.cache?.read ?? 0);
-            tot += t.total ?? 0;
+            // Newer opencode has no total: input + output + reasoning + cache.
+            const all = t.total ?? (t.input ?? 0) + (t.output ?? 0) + (t.reasoning ?? 0) + (t.cache?.read ?? 0) + (t.cache?.write ?? 0);
+            neu += all - (t.cache?.read ?? 0);
+            tot += all;
         }
         else if (agent === "antigravity" && e.event === "result") {
             const u = e.result?.usage ?? {};
@@ -112,7 +144,16 @@ export function collectRuns(ws, days) {
             if (txt.includes("herdr-verify") || txt.includes("herdr-baseline"))
                 continue;
             const log = read(`${pre}.log`);
-            const [agent, model] = agentModel(txt, log);
+            let job;
+            try {
+                job = JSON.parse(read(`${pre}.job.json`));
+            }
+            catch { /* older run */ }
+            const [agent, model] = agentModel(txt, log, job, read(`${pre}.pick`));
+            const dt = read(done), turns = read(`${pre}.turns`).split("\n").filter(Boolean);
+            const first = turns.length ? Date.parse(turns[0]) : NaN;
+            const end = Number.isFinite(first) ? first : statSync(done).mtimeMs;
+            const timed = Number.isFinite(first) || (!/\bmode=tui\b/.test(dt) && doneStatus(dt) !== "killed");
             const name = basename(pre);
             const rm = ROLE.exec(name);
             const role = rm && rm[1].includes("review") ? "review"
@@ -121,8 +162,8 @@ export function collectRuns(ws, days) {
                         : name.startsWith("impl") ? "impl" : "other";
             const out = read(`${pre}.out.md`);
             const [neu, tot] = tokens(agent, log, read(`${pre}.id`).trim());
-            runs.push({ issue, name, agent, model, role, ok: doneStatus(read(done)) === "ok" && out.trim() !== "",
-                secs: Math.max(0, Math.floor((statSync(done).mtimeMs - rs.mtimeMs) / 1000)), new: neu, tot,
+            runs.push({ issue, name, agent, model, role, ok: doneStatus(dt) === "ok" && out.trim() !== "",
+                secs: Math.max(0, Math.floor((end - rs.mtimeMs) / 1000)), timed, new: neu, tot,
                 repo: name.includes("-") ? name.slice(name.indexOf("-") + 1) : "" });
         }
     }
@@ -153,7 +194,7 @@ export function rows(runs) {
         const withTok = rs.filter((r) => r.tot), appr = rs.filter((r) => r.approved !== undefined).map((r) => r.approved);
         return { role, agent, model, n: rs.length, ok: Math.round(100 * rs.filter((r) => r.ok).length / rs.length),
             approved: appr.length ? Math.round(100 * appr.filter(Boolean).length / appr.length) : null, n_appr: appr.length,
-            min: Math.round(median(rs.map((r) => r.secs)) / 6) / 10,
+            min: rs.some((r) => r.timed) ? Math.round(median(rs.filter((r) => r.timed).map((r) => r.secs)) / 6) / 10 : null,
             new: withTok.length ? Math.floor(median(withTok.map((r) => r.new))) : null,
             tot: withTok.length ? Math.floor(median(withTok.map((r) => r.tot))) : null };
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irythill/orq",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Orchestrate coding agents (Claude Code, Codex, OpenCode, Antigravity, Copilot) from one conductor.",
   "license": "MIT",
   "type": "module",
@@ -15,7 +15,7 @@
     "templates/conductor.instructions.md"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "repository": {
     "type": "git",
@@ -39,11 +39,11 @@
     "prepack": "tsc"
   },
   "dependencies": {
-    "@napi-rs/keyring": "^2.1.1",
+    "@napi-rs/keyring": "^2.1.2",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {
-    "@types/node": "^24.0.0",
+    "@types/node": "^22.20.5",
     "typescript": "^7.0.2"
   }
 }

package/skills/issue/SKILL.md

@@ -99,7 +99,8 @@ Always include:
   choice doesn't come back as a blocker.
 - **No tests in the child** (memory rule): "don't run jest/vitest; I run the related tests afterwards".
 - **Fresh branch:** "before your final answer: `git fetch origin <BASE> && git rebase origin/<BASE>`; on conflict stop
-  and report; after the rebase repeat lint/tsc". Codex has no network: for it, you fetch and check in step 5.
+  and report; after the rebase repeat lint/tsc". An agent without network (Codex) can't fetch: `orq agent` fetches before
+  the run and adds a note to its prompt, so it only rebases locally.
 
 **Base = the repo's base branch from the workspace `CLAUDE.md`, always from the updated remote (`origin/<BASE>`).**
 Worktree with `git worktree add` (not `herdr worktree create`: that opens a separate herdr workspace per worktree, and
@@ -128,7 +129,7 @@ orq agent $(cat $O/impl-<repo>.pick) -g <group> -t "<ID> impl <repo>" -d $WT -o
 ```
 - The Claude account (`-c`) already comes from `orq pick` (one under the limit whose pace stays within it, then the least used).
 - Full final answer in `$O/impl-<repo>.out.md`; log in `.log`; the agent's session id in `.id`.
-- Codex's sandbox has no network: `git fetch` is yours, beforehand (above). Push/PR: yours (step 7).
+- An agent without network (`network = false`, e.g. Codex): `orq agent` runs `git fetch origin` before a write run, so it can rebase locally. Push/PR: yours (step 7).
 - `orq agent` returns immediately (no need to background it); the child's pane is in `<prefix>.pane`
   (to peek: `<prefix>.log`; in herdr, `herdr pane read $(cat <prefix>.pane) --source recent`).
 - **No baseline in the issue flow:** don't run `orq baseline` before dispatching (the base moves with every merge and
@@ -157,7 +158,10 @@ Child with `status=ok` → run the tests related to the diff, in their own tab,
 `orq verify -w $WS -r <repo> -d $WT -b <BASE> -o $O/verify-<repo> -g <group>` → `$O/verify-<repo>.txt` with
 **new failures** and pre-existing ones: if any test fails, it runs the same test files on an updated
 `origin/<BASE>` (whatever fails there is pre-existing). You get the done line (`[HERDR-AGENT DONE]` / `[ORQ AGENT DONE]`) `verify ... new=N`.
-`new>0` → fix round with the list (step 6), no review. `new=0` → review.
+`new>0` → follow-up with the failing tests, no review: write `$O/verify-fix-<n>.md` (not `fix-<n>.md`) and add
+`--reason verify` to the `-R` call of step 6. `new=0` → review. A follow-up that only unblocks the child (files it
+couldn't fetch without network, a missing tool) uses `--reason unblock`. Only review rounds (the default `--reason
+review`) count towards `policy.max_rounds`.
 **Pre-existing failures get fixed too.** Any failure — tests listed as "already failing on origin/<BASE>", or a CI job
 (lint, biome, typecheck, shard, regression) failing on the PR or on the base — goes into a fix round on the issue's
 branch (separate `fix:`/`test:` commit naming the issue). Never close, move to In Review or call a PR done while
@@ -223,12 +227,19 @@ Then a new `orq verify` (4b) and the **round review** (step 5 with these changes
 - Same reviewer as the round before: `$(cat $O/review-<repo>.pick)`. Only if it is over quota, blocked or fails with
   no verdict → a new `orq pick review` (saved to the same file).
 - Extra attachments: `git -C $WT diff $(cat $O/round-<n>.sha)..HEAD > $O/fix-<n>.diff` → `-i $O/fix-<n>.md -i $O/fix-<n>.diff`
-  (the full `-b $BASE` diff stays, as context).
+  (the full `-b $BASE` diff stays, as context). **A review tool** gets `-b $(cat $O/round-<n>.sha)` instead of `-b $BASE`:
+  `{base}` becomes that commit, so it reviews only the round's delta, not the whole branch again. Pick the round reviewer with
+  `orq pick review --base $(cat $O/round-<n>.sha) ...`: a tool with `base_commit = false` is skipped. Dispatched anyway, `orq agent`
+  falls back to the branch base (`--base-branch $BASE`) and its answer says the review covers the whole branch.
 - The prompt asks a closed question: "for each item in fix-<n>.md: RESOLVED or NOT RESOLVED (why); then the fix diff:
   any regression it introduced, as `[blocker]`/`[suggestion]`. Outside the fix diff, report only a blocker you missed
-  before that would break production, and say why it wasn't in the first review". Anything else is a suggestion. A review tool can't answer that: it reviews the whole
-branch again, so you do the matching — a finding is a blocker this round only if it is inside `fix-<n>.diff` or is a
-NOT RESOLVED item of `fix-<n>.md`; one you already decided on (fixed, rejected or downgraded) stays decided. **Maximum: `orq config get policy.max_rounds` rounds** — `orq agent -R` refuses the next one (exit 4) and counts per session, so a renamed prefix doesn't reset it; on exit 4 stop and tell the user. With their OK run `orq rounds <ID> --diagnose` (a cheap independent agent, advisory: read its `RECOMMENDATION` — continue / split / change-implementer / ask-user — and tell the user), then `-F` (refused without a diagnosis newer than the last fix/review; `-F -F` skips that, only if the user says so); over it → `orq pick impl
+  before that would break production, and say why it wasn't in the first review". Anything else is a suggestion. If a review
+still names something outside `fix-<n>.diff`, you do the matching — a finding is a blocker this round only if it is inside
+`fix-<n>.diff` or is a NOT RESOLVED item of `fix-<n>.md`; one you already decided on (fixed, rejected or downgraded) stays decided.
+**A finding outside the fix diff never opens a round by itself**, however serious: it goes to a "deferred" list in the
+Plane comment (a follow-up issue). If it is a security or personal-data leak, stop and ask the user (fix in this branch
+or follow-up) instead of dispatching. `orq rounds <ID>` warns `fresh` when two fix rounds brought new heavy findings:
+the branch is too big — split, don't keep reviewing it whole. **Maximum: `orq config get policy.max_rounds` rounds** — `orq agent -R` refuses the next one (exit 4) and counts per session, so a renamed prefix doesn't reset it; on exit 4 stop and tell the user. With their OK run `orq rounds <ID> --diagnose` (a cheap independent agent, advisory: read its `RECOMMENDATION` — continue / split / change-implementer / ask-user — and tell the user), then `-F` (refused without a diagnosis newer than the last fix/review; `-F -F` skips that, only if the user says so); over it → `orq pick impl
 --exclude-agent <it> > $O/impl-<repo>.pick` only with the user's OK, or stop and report. Non-blocking suggestions go into the comment; they
 don't become a round.