@irythill/orq 0.6.0 → 0.7.0

package/dist/commands/pick.js

@@ -5,6 +5,7 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { isCommitBase, missingBinary } from "../agents.js";
 import { loadConfig } from "../config.js";
 import { m } from "../i18n.js";
 import { asArgs, escalate, parseQuota, modelFor, parseWindows, pick as choose } from "../pick.js";
@@ -14,7 +15,7 @@ import { PICK_ROLES, resolveRole, vendorOf } from "../roles.js";
 import { collectRuns, rows } from "../stats.js";
 import { load as loadBlocks } from "./block.js";
 export const USAGE = `orq pick <impl|fix|worker|review|opinion|watchdog> [--level simple|medium|heavy] [--impl-vendor <v>|--impl-agent <a>]
-         [--exclude-agent <a>]... [-w <workspace>] [--explain] [--no-record]
+         [--exclude-agent <a>]... [-w <workspace>] [--base <ref>] [--explain] [--no-record]
 orq pick fix --same <impl pick file>   same agent/model/account as the implementer, effort one level up`;
 // The board refreshes this file; fresher than 10 min → no new quota requests.
 const QCACHE = join(process.env.XDG_RUNTIME_DIR ?? tmpdir(), "herdr-board.quota");
@@ -48,7 +49,7 @@ export async function pick(argv) {
         return 0;
     }
     let level = "medium", implVendor, implAgent, ws;
-    let explain = false, record = true;
+    let explain = false, record = true, base;
     const exclude = new Set();
     for (let i = 1; i < argv.length; i++) {
         const a = argv[i];
@@ -62,6 +63,8 @@ export async function pick(argv) {
             exclude.add(argv[++i]);
         else if (a === "-w")
             ws = expand(argv[++i]);
+        else if (a === "--base")
+            base = argv[++i];
         else if (a === "--explain")
             explain = true;
         else if (a === "--no-record")
@@ -83,7 +86,7 @@ export async function pick(argv) {
         // Eligible, not just declared: an agent that is excluded, blocked or has no model for this role/level can't be picked.
         const blocked = loadBlocks();
         const declared = r.mode === "auto"
-            ? r.pool.filter((n) => agents[n] && !exclude.has(n) && !(n in blocked) && modelFor(agents[n], role, level)) : [];
+            ? r.pool.filter((n) => agents[n] && !exclude.has(n) && !(n in blocked) && !missingBinary(cfg, n) && modelFor(agents[n], role, level)) : [];
         if (declared.length > 1) {
             console.error(`orq pick: ${m(`more than one agent eligible for ${role} (${declared.join(", ")}) before quota checks: pass --impl-agent or --impl-vendor`, `mais de um agente elegível para ${role} (${declared.join(", ")}) antes da checagem de quota: informe --impl-agent ou --impl-vendor`)}`);
             return 2;
@@ -102,7 +105,16 @@ export async function pick(argv) {
     } })
         .filter((p) => p.role === role).slice(-window);
     const qt = await quotaText(cfg);
-    const res = choose({ cfg, role, level, implVendor, implAgent, exclude, stats, quota: parseQuota(qt), windows: parseWindows(qt),
+    // A review of a commit base (a round delta) leaves out agents that can't diff against one (agents.<name>.base_commit).
+    const commitBase = role === "review" && Boolean(base) && isCommitBase((ws ?? cfg._workspace ?? process.cwd()), base);
+    const r0 = resolveRole(cfg, role);
+    const missing = new Map();
+    for (const n of r0.mode === "fixed" ? r0.order : r0.pool) {
+        const why = agents[n] && missingBinary(cfg, n);
+        if (why)
+            missing.set(n, why);
+    }
+    const res = choose({ cfg, role, level, implVendor, implAgent, exclude, commitBase, missing, stats, quota: parseQuota(qt), windows: parseWindows(qt),
         blocks: new Set(Object.keys(loadBlocks())), recent });
     if (!res.best) {
         console.error(`orq pick: ${m("no candidate for ", "nenhum candidato para ")}${role}`

package/dist/commands/quota.js

@@ -34,7 +34,7 @@ export function humanizeQuotaLine(line, now = Date.now()) {
  *  `policy.quota_week`) — the same thresholds `orq pick` applies for an unspecified task level; ⊘ blocked
  *  (orq block), ? no data; sources with no window at all ("-" and "-") are left out. */
 export function quotaLine(lines, limit5, limitWeek, blocked, age) {
-    const parts = lines.filter((q) => q.five !== "-" || q.week !== "-").map((q) => {
+    const parts = lines.filter((q) => !q.name.includes("/") && (q.five !== "-" || q.week !== "-")).map((q) => {
         if (blocked.has(q.name))
             return `${q.name} ⊘`;
         const five = pct(q.five), week = pct(q.week);

package/dist/commands/rounds.js

@@ -23,6 +23,7 @@ const why = (r) => ({
     at_max: m(`rounds ${r.n} = max_rounds ${r.max}`, `rodadas ${r.n} = max_rounds ${r.max}`),
     same_finding: m(`same finding in ${r.n} reviews`, `mesmo achado em ${r.n} revisões`),
     repeated: m(`${r.n} repeated finding(s)`, `${r.n} achado(s) repetido(s)`),
+    fresh: m(`new heavy findings in fix rounds ${r.rounds?.join(", ")}: split the issue`, `achados graves novos nas rodadas ${r.rounds?.join(", ")}: divida a issue`),
     slow: m(`round ${r.rounds?.join(", ")} much slower than the others`, `rodada ${r.rounds?.join(", ")} bem mais lenta que as outras`),
 })[r.code];
 export async function rounds(argv) {
@@ -65,6 +66,8 @@ export async function rounds(argv) {
     }
     console.log(`${id}  ${mark(x)}  ${m("alert", "alerta")}: ${x.level}${x.reasons.length ? ` (${x.reasons.map(why).join("; ")})` : ""}`);
     console.log(m(`rounds ${x.rounds} of max ${x.max}; total time ${dur(x.secs)}; ${x.findings} finding(s) across reviews`, `rodadas ${x.rounds} de no máx. ${x.max}; tempo total ${dur(x.secs)}; ${x.findings} achado(s) nas revisões`));
+    if (x.followups)
+        console.log(m("follow-ups (only review counts): ", "follow-ups (só review conta): ") + Object.entries(x.followups).map(([k, n]) => `${k} ${n}`).join(", "));
     for (const r of x.perRound)
         console.log(`  ${r.round === 0 ? m("impl + review", "impl + revisão") : m(`fix ${r.round} + review`, `fix ${r.round} + revisão`)}: ${dur(r.secs)}`);
     if (x.repeats.length)
@@ -96,37 +99,64 @@ async function diagnoseIssue(ws, id, x) {
     }
     const ev = evidence(dir);
     writeFileSync(`${prefix}.md`, buildPrompt(x, ev.fixes, ev.reviews));
-    const p = orq("pick", "watchdog", "--level", "simple", "-w", ws, ...(implPick ? ["--impl-agent", implPick] : []));
-    if (p.status !== 0) {
-        console.error(p.stderr.trim() || `orq pick watchdog: exit ${p.status}`);
-        return p.status ?? 1;
-    }
-    const picked = p.stdout.trim().split(/\s+/);
-    // The agent runs in a scratch folder (everything it needs is in the prompt): it can't touch the issue files, even write sandboxed.
-    const scratch = mkdtempSync(join(tmpdir(), "orq-watchdog-"));
+    // A failed watchdog (e.g. a model catalog timeout) gets one retry with the next candidate, never the same agent.
+    const excluded = [];
+    let first;
+    const scratches = [];
     try {
-        const a = orq("agent", ...picked, "-r", "-t", `${id} watchdog`, "-d", scratch, "-g", "watchdog", "-o", prefix, "--", `${prefix}.md`);
-        process.stderr.write(a.stderr);
-        process.stdout.write(a.stdout);
-        if (a.status !== 0)
-            return a.status ?? 1;
-        return await finish(await wait(["--timeout", String(WATCHDOG_TIMEOUT), prefix]), prefix, out);
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const p = orq("pick", "watchdog", "--level", "simple", "-w", ws, ...(implPick ? ["--impl-agent", implPick] : []), ...excluded.flatMap((e) => ["--exclude-agent", e]));
+            if (p.status !== 0) {
+                if (first) {
+                    console.error(m("the watchdog agent failed; no diagnosis written", "o agente watchdog falhou; diagnóstico não gravado"));
+                    return first.rc;
+                }
+                console.error(p.stderr.trim() || `orq pick watchdog: exit ${p.status}`);
+                return p.status ?? 1;
+            }
+            const picked = p.stdout.trim().split(/\s+/), agent = /(?:^|\s)-a (\S+)/.exec(p.stdout)?.[1];
+            // The agent runs in a scratch folder (everything it needs is in the prompt): it can't touch the issue files, even write sandboxed.
+            const scratch = mkdtempSync(join(tmpdir(), "orq-watchdog-"));
+            scratches.push(scratch);
+            const run = `${prefix}-${attempt}`;
+            {
+                writeFileSync(`${run}.md`, readFileSync(`${prefix}.md`));
+                const a = orq("agent", ...picked, "-r", "-t", `${id} watchdog`, "-d", scratch, "-g", "watchdog", "-o", run, "--", `${run}.md`);
+                process.stderr.write(a.stderr);
+                process.stdout.write(a.stdout);
+                const rc = a.status !== 0 ? a.status ?? 1 : await finish(await wait(["--timeout", String(WATCHDOG_TIMEOUT), run]), run, out, agent, attempt === 1 || !agent);
+                if (rc === 0 || rc === 124 || !agent)
+                    return rc;
+                if (attempt === 0)
+                    console.error(m(`watchdog ${agent} failed; retrying with another agent`, `watchdog ${agent} falhou; tentando com outro agente`));
+                first = { rc };
+                excluded.push(agent);
+            }
+        }
+        return first?.rc ?? 1;
+        // Removed only after every attempt, and best-effort: on Windows a just-finished agent can still hold its cwd (EPERM/EBUSY).
     }
     finally {
-        rmSync(scratch, { recursive: true, force: true });
+        for (const s of scratches) {
+            try {
+                rmSync(s, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+            }
+            catch { /* temp dir: the OS cleans it */ }
+        }
     }
 }
-async function finish(rc, prefix, out) {
+async function finish(rc, prefix, out, agent, final = true) {
     if (rc === 124) {
         console.error(m(`diagnosis not written: the watchdog agent did not finish in ${WATCHDOG_TIMEOUT}s`, `diagnóstico não gravado: o agente watchdog não terminou em ${WATCHDOG_TIMEOUT}s`));
         return 124;
     }
     if (rc !== 0 || !existsSync(`${prefix}.out.md`)) {
-        console.error(m("the watchdog agent failed; no diagnosis written", "o agente watchdog falhou; diagnóstico não gravado"));
+        if (final)
+            console.error(m("the watchdog agent failed; no diagnosis written", "o agente watchdog falhou; diagnóstico não gravado"));
         return 1;
     }
     copyFileSync(`${prefix}.out.md`, out);
-    console.log(m(`diagnosis saved to ${out}`, `diagnóstico gravado em ${out}`));
+    console.log(m(`diagnosis saved to ${out}${agent ? ` (by ${agent})` : ""}`, `diagnóstico gravado em ${out}${agent ? ` (por ${agent})` : ""}`));
     console.log(recommendation(readFileSync(out, "utf8")) ?? m("(no RECOMMENDATION line in the answer)", "(sem linha RECOMMENDATION na resposta)"));
     return 0;
 }

package/dist/commands/setup.js

@@ -9,8 +9,9 @@
 import { spawnSync } from "node:child_process";
 import { copyFileSync, existsSync, readFileSync } from "node:fs";
 import { homedir, totalmem } from "node:os";
-import { delimiter, join } from "node:path";
+import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
+import { onPath } from "../agents.js";
 import { writeAtomic } from "../fsutil.js";
 import { banner, infoLines } from "../banner.js";
 import { getPath, loadConfig } from "../config.js";
@@ -28,11 +29,6 @@ const CLIS = {
     antigravity: { bin: "agy", test: 'agy -p "reply ok"' },
     copilot: { bin: "copilot", test: 'copilot -p "reply ok" -s' },
 };
-/** Is `bin` on PATH? (PATHEXT on Windows: claude.cmd, codex.exe…) */
-export function onPath(bin) {
-    const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
-    return (process.env.PATH ?? "").split(delimiter).some((d) => d && exts.some((e) => existsSync(join(d, bin + e))));
-}
 export const detect = () => Object.keys(CLIS).filter((n) => onPath(CLIS[n].bin));
 function write(toml) {
     const f = userConfigFile();

package/dist/commands/stats.js

@@ -3,7 +3,7 @@ import { getPath, loadConfig } from "../config.js";
 import { m } from "../i18n.js";
 import { expand } from "../paths.js";
 import { collectRuns, rows } from "../stats.js";
-export const USAGE = "orq stats [-w <workspace>] [--days N] [--json]   scoreboard: delivery, time and tokens per agent";
+export const USAGE = "orq stats [-w <workspace>] [--days N] [--json]   scoreboard per agent and model: delivery, time, tokens";
 const k = (n) => (n === null ? "-" : n >= 1000 ? `${Math.round(n / 1000)}k` : String(n));
 const ORDER = ["impl", "fix", "review", "watchdog", "other"];
 export function stats(argv) {
@@ -35,7 +35,7 @@ export function stats(argv) {
     for (const x of [...rs].sort((a, b) => ORDER.indexOf(a.role) - ORDER.indexOf(b.role) || b.n - a.n)) {
         const ap = x.approved !== null ? `${x.approved}% (${x.n_appr})` : "-";
         console.log(`${x.role.padEnd(7)} ${x.agent.padEnd(12)} ${x.model.slice(0, 22).padEnd(22)} ${String(x.n).padStart(4)} `
-            + `${String(x.ok).padStart(5)} ${ap.padStart(12)} ${String(x.min).padStart(6)} ${k(x.new).padStart(10)} ${k(x.tot).padStart(10)}`);
+            + `${String(x.ok).padStart(5)} ${ap.padStart(12)} ${String(x.min ?? "-").padStart(6)} ${k(x.new).padStart(10)} ${k(x.tot).padStart(10)}`);
     }
     return 0;
 }

package/dist/config.js

@@ -32,6 +32,9 @@ export const DEFAULTS = {
     // Where quota comes from, per agent: "builtin" | "none" | false | { command = "..." } (see src/quota.ts).
     // "claude" covers every account in claude-accounts.
     quota: { claude: "builtin", codex: "builtin", opencode: "builtin", antigravity: "builtin", copilot: "builtin" },
+    // Issue ID in a branch/worktree name (orq gc, orq ci): case-insensitive regex, the named group "issue" (else group 1) is the ID.
+    // The default finds <LETTERS>-<DIGITS> anywhere (feature/ABC-123, abc-123-fix, plane-abc-123-api-2); suffixes are ignored.
+    git: { issue_pattern: "(?<![a-z0-9])(?<issue>[a-z][a-z0-9]*-\\d+)(?![a-z0-9])" },
     tracker: { kind: "none" }, // plane | none
     repos: {}, // defined by the workspace
 };

package/dist/diagnose.js

@@ -18,6 +18,7 @@ const reason = (r) => ({
     at_max: `rounds ${r.n} reached max_rounds ${r.max}`,
     same_finding: `the same heavy finding came back in ${r.n} reviews`,
     repeated: `${r.n} heavy finding(s) repeated across reviews`,
+    fresh: `the reviews of fix rounds ${r.rounds?.join(", ")} raised new heavy findings outside what was fixed (scope too big?)`,
     slow: `round ${r.rounds?.join(", ")} was much slower than the others`,
 })[r.code];
 const mins = (s) => `${Math.round(s / 60)} min`;
@@ -39,7 +40,8 @@ export function buildPrompt(x, fixes, reviews, cap = DIAG_CAP) {
         `## What to decide`,
         `Look for the real cause, for example: reviewer and implementer disagree about the requirement or the style; the scope is too big for one`,
         `branch; a flaky or environment-dependent test; an ambiguous spec or acceptance criterion; fixes that fix the symptom of each review and`,
-        `introduce the next one; a reviewer that keeps raising new things instead of checking the previous ones.`,
+        `introduce the next one; a reviewer that keeps raising new things instead of checking the previous ones (re-reading the whole branch every
+round: findings outside the fix diff don't make a round, they go to a follow-up list — recommend split, not continue).`,
         ``,
         `## Answer format`,
         `A short diagnosis (at most 15 lines): the cause, with the evidence (which round, which file or finding). Then, as the LAST line, exactly:`,

package/dist/install.js

@@ -89,6 +89,11 @@ export function prepareWorkspace(dir, fmt, name = basename(resolve(dir))) {
     }
     else
         out.push(m(`  ok      ${map} (kept)`, `  ok      ${map} (mantido)`));
+    // The conductor's instructions (what `orq conductor` looks for): regenerated on every run.
+    const ci = join(ws, ".orquestra-conductor.md");
+    const t = readFileSync(join(PKG, "templates", "conductor.instructions.md"), "utf8");
+    writeAtomic(ci, t.split("{{WORKSPACE}}").join(ws).split("{{NAME}}").join(name));
+    out.push(`  ${m("wrote", "escrevi")}   ${ci}`);
     const r = spawnSync(process.execPath, [join(PKG, "dist", "cli.js"), "instructions", fmt, "-w", ws], { encoding: "utf8" });
     out.push(`  ${(r.stdout || r.stderr).trim()}`);
     return out;

package/dist/issue.js

@@ -0,0 +1,47 @@
+// The issue a branch or worktree belongs to, and which issues have an agent really running.
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { getPath, loadConfig } from "./config.js";
+import { alive } from "./lock.js";
+import { stateDir } from "./paths.js";
+/** Finds "<LETTERS>-<DIGITS>" anywhere in the name, as its own token; anything after the number is a suffix. */
+export const DEFAULT_ISSUE_PATTERN = "(?<![a-z0-9])(?<issue>[a-z][a-z0-9]*-\\d+)(?![a-z0-9])";
+/** The issue ID (as written in the name) from a branch or worktree name like "me/plane-proj-68-api-2" or
+ *  "feature/ABC-123". `pattern` is [git] issue_pattern: a case-insensitive regex whose named group "issue"
+ *  (else group 1, else the whole match) is the ID. */
+export function issueFromName(name, pattern = DEFAULT_ISSUE_PATTERN) {
+    let re;
+    try {
+        re = new RegExp(pattern, "i");
+    }
+    catch (e) {
+        throw new Error(`git.issue_pattern: ${e.message}`);
+    }
+    const r = re.exec(name);
+    return r ? (r.groups?.issue ?? r[1] ?? r[0]) : undefined;
+}
+/** [git] issue_pattern of the workspace's merged config (default when unset). */
+export function issuePattern(ws) {
+    const v = getPath(loadConfig(ws).cfg, "git.issue_pattern");
+    return typeof v === "string" && v ? v : DEFAULT_ISSUE_PATTERN;
+}
+/** Issue directories (basename of the run prefix's folder) with an agent whose state says running and whose pid is
+ *  alive: the same rule the board uses for "running". */
+export function issuesWithLiveAgent() {
+    const dir = join(stateDir(), "agents"), out = new Set();
+    let files = [];
+    try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+    }
+    catch { /* no runs yet */ }
+    for (const f of files) {
+        try {
+            const s = JSON.parse(readFileSync(join(dir, f), "utf8"));
+            if (s.status === "ok" || s.status === "fail" || s.status === "killed" || !alive(Number(s.pid)))
+                continue;
+            out.add(basename(dirname(String(s.prefix ?? ""))));
+        }
+        catch { /* unreadable state: ignore */ }
+    }
+    return out;
+}

package/dist/pick.js

@@ -3,8 +3,9 @@
 //               for an agent the user didn't list.
 //   auto role:  every pool agent that passes is scored:
 //     quality * delivery + tokens * economy + speed * quickness − rotation * (picks in the last `window`)
-//     − reserve (agents with reserve = true) + explore (fewer than `min_samples` runs)
-// Filters: --exclude-agent, orq block, nobody reviews their own code (unless no other agent can), cross-vendor rule, a model for the role/level,
+//     − 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, 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.
@@ -12,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";
@@ -84,8 +85,47 @@ export function modelFor(a, role, level) {
     const [model, effort] = spec.split("@");
     return [model, effort || undefined];
 }
-const WEIGHTS = { quality: 0.4, tokens: 0.45, speed: 0.15, rotation: 0.2, reserve: 0.3, explore: 0.1, min_samples: 8, window: 6 };
+// --- per-model quota ---------------------------------------------------------------------------------------------------
+// A collector may add lines "<account>/<model> 5h=.. week=.." (antigravity: one bucket per model group). The model a pick is about
+// to choose is checked against its own line, and an exhausted one gives way to a lighter model the agent has configured.
+const LEVEL_RANK = { simple: 0, medium: 1, default: 1, heavy: 2 };
+/** The quota line key for a configured model: the exact id, else the id without its -low/-medium/-high suffix, plain or
+ *  as "<base>-tiered" (one bucket serves all three efforts of a tiered model). */
+export function modelKey(model, keys) {
+    const id = model.split("/").pop() ?? model;
+    const base = id.replace(/-(low|medium|high)$/, "");
+    return [id, base, `${base}-tiered`].find((k) => keys.includes(k));
+}
+/** 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)
+        return [];
+    const lr = legacyRole(role);
+    const ms = models[lr] ?? (lr === "fix" ? models.impl : lr === "watchdog" ? models.opinion ?? models.review : undefined) ?? {};
+    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]);
+    }
+    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 {
@@ -125,6 +165,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;
@@ -134,6 +179,10 @@ 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;
@@ -198,14 +247,49 @@ 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;
+        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) {
+            const over = (model) => {
+                const k = modelKey(model, mkeys), q = k ? inp.windows?.[`${acc0}/${k}`] : undefined;
+                if (!q)
+                    return undefined;
+                const five = (q.five ?? -1) >= limit5, week = (q.week ?? -1) >= limitWeek;
+                if (!five && !week)
+                    return undefined;
+                const at = [five ? q.resetFive : undefined, week ? q.resetWeek : undefined].filter((t) => t !== undefined);
+                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;
+                }
+                tried.push(cand[0]);
+                skipped.push(why);
+            }
+            if (!found) {
+                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]}`);
+            mfx = found;
+        }
         const ranked = usable.map(([n, v]) => ({ n, v: v, ...paceOf(n) }))
             .sort((x, y) => Number(x.hot) - Number(y.hot) || x.v - y.v);
         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 === (mf[0].split("/").pop() || "default"));
+        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: mf[0], effort: mf[1], acct, a, st, pace: chosen?.pace, hot: Boolean(chosen?.hot) });
+        pass.push({ agent: name, model: mfx[0], effort: mfx[1], acct, a, st, pace: chosen?.pace, hot: Boolean(chosen?.hot) });
         if (res.mode === "fixed")
             break; // the first that passes wins
     }
@@ -215,24 +299,46 @@ export function pick(inp) {
             why: m(`fixed by [roles.${res.section}]`, `fixo em [roles.${res.section}]`) };
         return { mode: "fixed", best, cands: best ? [best] : [], notes };
     }
-    const few = (st) => (st?.n ?? 0) < w.min_samples;
-    const toks = pass.filter((c) => c.st?.new && !few(c.st)).map((c) => c.st.new);
-    const mins = pass.filter((c) => c.st?.min && !few(c.st)).map((c) => c.st.min);
+    // Each axis blends the agent's prior with what was measured, (prior·k + observed·n) / (k + n) with k = min_samples,
+    // so a couple of runs already move the score instead of being ignored until the threshold.
+    const k = Math.max(0, w.min_samples);
+    const few = (st) => (st?.n ?? 0) < k;
+    const blend = (prior, obs, n) => obs === undefined || k + n <= 0 ? prior : (prior * k + obs * n) / (k + n);
+    // The reference cost/time is the best of the well-sampled agents, or of everyone measured when none is.
+    const best = (vals) => {
+        const solid = vals.filter((x) => x.solid);
+        const use = solid.length ? solid : vals;
+        return use.length ? Math.min(...use.map((x) => x.v)) : undefined;
+    };
+    const refTok = best(pass.filter((c) => c.st?.new).map((c) => ({ v: c.st.new, solid: !few(c.st) })));
+    const refMin = best(pass.filter((c) => c.st?.min).map((c) => ({ v: Math.max(c.st.min, 0.1), solid: !few(c.st) })));
+    const axis = (label, prior, obs, n) => {
+        const v = blend(prior, obs, n);
+        return { v, txt: `${label}=${v.toFixed(2)}` + (obs === undefined ? "" : `(${prior.toFixed(2)}→${obs.toFixed(2)})`) };
+    };
     const cands = pass.map((c) => {
         const prior = Number(c.a.prior ?? 0.6), n = c.st?.n ?? 0, reserve = Boolean(c.a.reserve);
-        const deliv = role === "impl" && c.st?.approved != null && c.st.n_appr >= 3 ? c.st.approved / 100
-            : c.st ? c.st.ok / 100 : undefined;
-        const d = few(c.st) || deliv === undefined ? prior : deliv;
-        const t = few(c.st) || !c.st?.new || !toks.length ? prior : Math.min(...toks) / c.st.new;
-        const s = few(c.st) || !c.st?.min || !mins.length ? prior : Math.min(...mins) / Math.max(c.st.min, 0.1);
+        const appr = role === "impl" && c.st?.approved != null && c.st.n_appr >= 3;
+        const deliv = appr ? c.st.approved / 100 : c.st ? c.st.ok / 100 : undefined;
+        const d = axis(m("delivery", "entrega"), prior, deliv, appr ? c.st.n_appr : n);
+        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.
+        let streak = 0;
+        for (let i = inp.recent.length - 1; i >= 0 && inp.recent[i].agent === c.agent; i--)
+            streak++;
+        const capped = few(c.st) && streak >= w.explore_streak;
+        const explore = few(c.st) && !capped ? w.explore * (k - n) / k : 0;
         const hot = Boolean(c.hot) && penalty > 0;
-        const score = w.quality * d + w.tokens * t + w.speed * s - w.rotation * used
-            - (reserve ? w.reserve : 0) + (few(c.st) ? w.explore : 0) - (hot ? penalty : 0);
-        const why = `${m("delivery", "entrega")}=${d.toFixed(2)} ${m("economy", "economia")}=${t.toFixed(2)} `
-            + `${m("speed", "rapidez")}=${s.toFixed(2)} ${m("rotation", "rodízio")}=-${used} `
+        const score = w.quality * d.v + w.tokens * t.v + w.speed * s.v - w.rotation * used
+            - (reserve ? w.reserve : 0) + explore - (hot ? penalty : 0);
+        const why = `${d.txt} ${t.txt} ${s.txt} ${m("rotation", "rodízio")}=-${used} `
             + (reserve ? m("reserve ", "reserva ") : "")
-            + (hot ? `${m("pace", "ritmo")}=${Math.round(c.pace)}%→-${penalty} ` : "") + (few(c.st) ? `${m("few samples", "poucos dados")}(n=${n})` : `n=${n}`);
+            + (hot ? `${m("pace", "ritmo")}=${Math.round(c.pace)}%→-${penalty} ` : "")
+            + (explore ? `${m("explore", "explorar")}=+${explore.toFixed(2)} ` : "")
+            + (capped ? `${m("explore capped", "exploração limitada")}(${streak}x) ` : "")
+            + (few(c.st) ? `${m("few samples", "poucos dados")}(n=${n})` : `n=${n}`);
         return { agent: c.agent, model: c.model, effort: c.effort, acct: c.acct, score, why };
     }).sort((x, y) => y.score - x.score);
     return { mode: "auto", best: cands[0], cands, notes };

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)));
 });