@irythill/orq 0.5.0 → 0.6.1

package/dist/commands/gc.js

@@ -1,20 +1,28 @@
 // orq gc — find issue worktrees whose branch is already safe to remove.
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
-import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { existsSync, readdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { loadConfig } from "../config.js";
 import { m } from "../i18n.js";
+import { issueFromName, issuePattern, issuesWithLiveAgent } from "../issue.js";
+import { alive } from "../lock.js";
+import { stateDir } from "../paths.js";
 import { aliveOwner } from "./claim.js";
-export const USAGE = "orq gc [-w <workspace>] [--yes] [--days N] [--json]   remove merged issue worktrees";
+export const USAGE = "orq gc [-w <workspace>] [--yes] [--days N] [--json]   remove merged issue worktrees and stale agent state";
 const git = (cwd, ...args) => spawnSync("git", ["-C", cwd, ...args], { encoding: "utf8" });
 // Paths as git prints them can differ from ours (macOS /var → /private/var, Windows C:/ vs C:\): compare real paths.
-const real = (p) => { try {
-    return realpathSync.native(p);
-}
-catch {
-    return resolve(p);
-} };
-const inside = (dir, p) => { const r = relative(dir, p); return !!r && !r.startsWith("..") && !isAbsolute(r); };
+// A path that does not exist (yet) is resolved through its deepest existing ancestor, so both sides get the same prefix.
+const real = (p) => {
+    const abs = resolve(p);
+    try {
+        return realpathSync.native(abs);
+    }
+    catch { /* missing: resolve the parent */ }
+    const up = dirname(abs);
+    return up === abs ? abs : join(real(up), basename(abs));
+};
+const fold = (p) => (process.platform === "win32" ? p.toLowerCase() : p); // NTFS is case-insensitive
+const inside = (dir, p) => { const r = relative(fold(dir), fold(p)); return !!r && !r.startsWith("..") && !isAbsolute(r); };
 // ORQ_GH may be a .js file (tests: a fake gh that also runs on Windows).
 const gh = (cwd, args) => {
     const bin = process.env.ORQ_GH || "gh";
@@ -22,6 +30,30 @@ const gh = (cwd, args) => {
         : spawnSync(bin, args, { cwd, encoding: "utf8" });
 };
 const output = (cwd, ...args) => { const r = git(cwd, ...args); return r.status === 0 ? r.stdout.trim() : undefined; };
+/** Per-agent state files (<state>/agents/<unit>.json) of runs under `ws` that are finished or dead and older than `days`. */
+function staleAgentStates(ws, days, now) {
+    const dir = join(stateDir(), "agents"), out = [];
+    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 (!inside(real(ws), real(String(s.prefix ?? ""))))
+                continue;
+            const finished = s.status === "ok" || s.status === "fail" || s.status === "killed";
+            if (!finished && alive(Number(s.pid)))
+                continue;
+            const since = Date.parse(String(s.end ?? s.at));
+            if (now - since > days * 86400_000)
+                out.push(join(dir, f));
+        }
+        catch { /* unreadable state: leave it */ }
+    }
+    return out;
+}
 export async function gc(argv, clock = Date.now) {
     let ws = process.cwd(), yes = false, json = false, days = 14;
     for (let i = 0; i < argv.length; i++) {
@@ -38,10 +70,11 @@ export async function gc(argv, clock = Date.now) {
             return 2;
         }
     }
-    const { cfg } = loadConfig(ws), rows = [];
+    const { cfg } = loadConfig(ws), rows = [], issuePat = issuePattern(ws);
     let ghUnavailable = false, fetchWarned = false;
     const root = join(ws, ".worktrees");
     const orq = join(ws, ".orquestra");
+    const liveAgents = issuesWithLiveAgent();
     const issues = existsSync(orq) ? readdirSync(orq).filter((x) => !x.startsWith(".")) : [];
     for (const repoName of readdirSync(ws, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name)) {
         const repo = join(ws, repoName);
@@ -71,8 +104,8 @@ export async function gc(argv, clock = Date.now) {
             const branch = wt.branch?.replace(/^refs\/heads\//, "") ?? "";
             if (!branch)
                 continue;
-            // The branch carries the ID in lowercase (plane-abc-123); .orquestra/ keeps it as written (ABC-123).
-            const id = /^.*?plane-(.+)$/.exec(branch)?.[1];
+            // The branch carries the ID in lowercase (abc-123, maybe with a prefix or -suffix); .orquestra/ keeps it as written (ABC-123).
+            const id = issueFromName(branch, issuePat);
             const issue = id && issues.find((d) => d.toLowerCase() === id.toLowerCase());
             const status = output(path, "status", "--porcelain");
             const unpushed = output(repo, "rev-list", branch, "--not", "--remotes");
@@ -86,14 +119,10 @@ export async function gc(argv, clock = Date.now) {
                 verdict = "KEEP";
                 reason = m("issue has a live owner", "issue tem um responsável ativo");
             }
-            // A .pane/.id without a same-stem .done is treated as a running child.
-            const issueDir = issue && join(ws, ".orquestra", issue);
-            if (verdict !== "KEEP" && issueDir && existsSync(issueDir)) {
-                const files = readdirSync(issueDir), running = files.some((f) => /\.(pane|id)$/.test(f) && !existsSync(join(issueDir, `${f.replace(/\.(pane|id)$/, "")}.done`)));
-                if (running) {
-                    verdict = "KEEP";
-                    reason = m("child agent may still be running", "um agente filho pode estar em execução");
-                }
+            // A child agent of the issue whose state says running and whose pid is alive (the board's rule).
+            if (verdict !== "KEEP" && issue && liveAgents.has(issue)) {
+                verdict = "KEEP";
+                reason = m("child agent may still be running", "um agente filho pode estar em execução");
             }
             let merged = false;
             if (verdict !== "KEEP") {
@@ -153,6 +182,10 @@ export async function gc(argv, clock = Date.now) {
             }
             git(join(ws, row.repo), "worktree", "prune");
         }
+    const stale = staleAgentStates(ws, days, clock());
+    if (yes)
+        for (const f of stale)
+            rmSync(f, { force: true });
     if (json)
         console.log(JSON.stringify(rows));
     else {
@@ -160,5 +193,8 @@ export async function gc(argv, clock = Date.now) {
         const w = table[0].map((_, i) => Math.max(...table.map((t) => t[i].length)));
         console.log(table.map((t) => t.map((c, i) => i < t.length - 1 ? c.padEnd(w[i]) : c).join("  ")).join("\n"));
     }
+    if (stale.length && !json)
+        console.log(yes ? m(`pruned ${stale.length} stale agent state file(s)`, `${stale.length} arquivo(s) de estado de agente antigo(s) removido(s)`)
+            : m(`${stale.length} stale agent state file(s) (finished/dead, older than ${days} days): --yes removes them`, `${stale.length} arquivo(s) de estado de agente antigo(s) (terminados/mortos, mais de ${days} dias): --yes remove`));
     return failed ? 1 : 0;
 }

package/dist/commands/handoff.js

@@ -163,6 +163,7 @@ async function move(ws, c, to, dir, model, mark) {
         for (const id of c.issues)
             writeAtomic(join(ws, ".orquestra", id, "owner"), `pane=${pane} kind=herdr account=${basename(dir)} at=${new Date().toISOString()} name=${label}\n`);
         writeAtomic(handoffFile(c.pane), pane);
+        rmSync(handoffFile(pane), { force: true }); // the new pane is live: a leftover redirect out of it would make a cycle
         const regs = join(ws, ".orquestra", ".conductors");
         mkdirSync(regs, { recursive: true });
         writeAtomic(join(regs, pane.replace(/[^A-Za-z0-9_-]/g, "_")), `pane=${pane} kind=herdr account=${basename(dir)} at=${new Date().toISOString()} name=${label}\n`);

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

@@ -96,37 +96,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/wait.js

@@ -7,6 +7,7 @@ import { basename } from "node:path";
 import { m } from "../i18n.js";
 import { alive } from "../lock.js";
 import { ackPrefix } from "../notice.js";
+import { doneStatus } from "../process.js";
 export const USAGE = "orq wait [--any] [--timeout <s>] [--answer] <prefix>...   block until child agents finish (exit 1 = one failed)";
 const read = (f) => { try {
     return readFileSync(f, "utf8");
@@ -29,7 +30,10 @@ export function doneLine(prefix) {
     }
     catch { /* verify/baseline: no job */ }
     const answer = [`${prefix}.out.md`, `${prefix}.txt`].find(existsSync) ?? prefix;
-    return { line: `[ORQ AGENT DONE] ${title} ${done} answer: ${answer}`, ok: /\bstatus=ok\b/.test(done) };
+    const status = doneStatus(done);
+    if (status === "killed")
+        done = done.replace(/\bstatus=\S+/, "status=killed"); // legacy "status=ok rc=137"
+    return { line: `[ORQ AGENT DONE] ${title} ${done} answer: ${answer}`, ok: status === "ok" };
 }
 export async function wait(argv) {
     let any = false, timeout = 0, answer = false;

package/dist/config.js

@@ -15,6 +15,7 @@ export const DEFAULTS = {
         mem_enforce: "auto", // auto (kernel cap where possible, else watchdog) | kernel | watchdog | off
         test_slots: 1, // test suites in parallel on the machine
         close_tab_after: 20, // seconds until a finished child tab closes (0 = never)
+        tui_idle_close_min: 30, // minutes a finished -T agent waits for a follow-up before it is closed (0 = never)
         tui: false, // children in the agent's own screen (-T) by default
         terminal: "auto", // where children show their output: auto (herdr, else tmux, else plain) | herdr | tmux | plain
     },
@@ -27,10 +28,13 @@ export const DEFAULTS = {
         max_rounds: 2, // fix rounds before stopping and calling the user
         review: "other-vendor", // other-vendor | any
     },
-    ui: { lang: "auto", theme: "gunmetal", desktop_notify: true }, // lang: auto | en | pt · theme: gunmetal | chrome | lcd | terminal · desktop_notify: desktop popup for failures (Linux, notify-send)
+    ui: { lang: "auto", theme: "gunmetal", desktop_notify: true, board_hide_hours: 6 }, // board_hide_hours: finished/dead agents older than this leave `orq board` (still in --json) · lang: auto | en | pt · theme: gunmetal | chrome | lcd | terminal · desktop_notify: desktop popup for failures (Linux, notify-send)
     // 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/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/notice.js

@@ -9,7 +9,7 @@
 // if ui.desktop_notify allows, a desktop notification. Successes stay quiet: a plain herdr notification, nothing else.
 // `orq board` reads the same log to show failures that were not delivered or not yet acknowledged.
 import { spawn, spawnSync } from "node:child_process";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, statSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getPath, loadConfig } from "./config.js";
@@ -181,9 +181,24 @@ const exec = (cmd, args, timeoutMs = 15_000) => {
     return { status: r.error ? null : r.status, stdout: r.stdout ?? "", stderr: r.stderr || (r.error ? String(r.error.message) : "") };
 };
 const hasBin = (b) => spawnSync(process.platform === "win32" ? "where" : "which", [b], { stdio: "ignore" }).status === 0;
-/** Follow `orq handoff` redirects to the pane that now holds the conductor (stops at cycles and unreadable files). */
-export function currentPane(pane) {
-    const seen = new Set();
+/** Does herdr know this pane? true | false (herdr answered pane_not_found) | undefined (unreachable or unclear).
+ *  `pane get`, not `agent get`: a live pane whose agent exited has no agent but is still a place to type. */
+export function paneExists(pane, run = exec) {
+    const r = run("herdr", ["pane", "get", pane], 2_000);
+    if (r.status === 0)
+        return true;
+    if (r.status === null)
+        return undefined; // herdr is not installed / did not answer
+    return /"code"\s*:\s*"pane_not_found"/.test(`${r.stdout}\n${r.stderr}`) ? false : undefined;
+}
+/**
+ * Follow `orq handoff` redirects to the pane that now holds the conductor (stops at cycles and unreadable files).
+ * Walks the whole chain by files and returns the furthest pane that still exists, so a dead middle hop (A→B→C, B gone,
+ * C alive) does not strand the notice. The redirect out of that last live pane leads nowhere live: it is deleted (and
+ * logged). When herdr cannot be asked, a hop counts as live (the old behaviour: follow blindly).
+ */
+export function currentPane(pane, run = exec) {
+    const chain = [pane], seen = new Set();
     while (!seen.has(pane) && existsSync(handoffFile(pane))) {
         seen.add(pane);
         let next;
@@ -195,9 +210,22 @@ export function currentPane(pane) {
         }
         if (!next || next === pane)
             break;
+        chain.push(next);
         pane = next;
     }
-    return pane;
+    let last = 0;
+    for (let i = 1; i < chain.length; i++)
+        if (paneExists(chain[i], run) !== false)
+            last = i;
+    // A redirect out of the last live pane exists only when the chain went on to dead panes.
+    if (last < chain.length - 1 && existsSync(handoffFile(chain[last]))) {
+        try {
+            rmSync(handoffFile(chain[last]), { force: true });
+            append({ id: `redirect-${Date.now().toString(36)}`, ev: "redirect", pane: chain[last], detail: `stale handoff to closed ${chain[last + 1]} removed` });
+        }
+        catch { /* best effort */ }
+    }
+    return chain[last];
 }
 function realDeps(id, pane, issue) {
     let setting;

package/dist/pick.js

@@ -3,7 +3,8 @@
 //               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)
+//     − 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,
 // 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.
@@ -84,7 +85,37 @@ 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) takes a prompt; an agent that can't be resolved doesn't. */
 function takesPrompt(cfg, name) {
@@ -198,14 +229,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 +281,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

@@ -77,6 +77,13 @@ export function treePids(root, table = processTable()) {
 export function treeMem(root, table = processTable()) {
     return treePids(root, table).reduce((t, p) => t + (table.get(p)?.[1] ?? 0), 0);
 }
+/** An exit code of 128+signal (137 = SIGKILL): the process was killed, it did not finish. */
+export const killedRc = (rc) => rc !== undefined && rc > 128 && rc <= 128 + 64;
+/** "status=ok rc=137" (written before `killed` existed) is a kill, not a success: the status a done line really means. */
+export function doneStatus(line) {
+    const st = /\bstatus=(\S+)/.exec(line)?.[1], rc = /\brc=(\d+)/.exec(line)?.[1];
+    return st === "ok" && killedRc(rc === undefined ? undefined : Number(rc)) ? "killed" : st;
+}
 export function killTree(pid, group = true) {
     if (process.platform === "win32")
         spawnSync("taskkill", ["/T", "/F", "/PID", String(pid)], { stdio: "ignore" });