@irythill/orq 0.6.0 → 0.6.1

package/README.md

@@ -162,6 +162,9 @@ handoff_at = 85                          # % of the window → orq handoff moves
 max_per_account = 2                      # an account already holding this many conductors is never a handoff target
 reset_grace_min = 15                     # every window over the trigger resetting within this many minutes skips the move
 
+[git]
+issue_pattern = "(?<![a-z0-9])(?<issue>[a-z][a-z0-9]*-\\d+)(?![a-z0-9])"   # Branch/worktree name → issue ID, for `orq gc` and `orq ci` — default shown; regex, named group `issue` (else group 1)
+
 [policy]
 quota_week = 95                          # ≥ 95% of the week → agent out
 quota_5h = { simple = 90, medium = 85, heavy = 80 }  # same for the 5h window, by task level

package/README.pt-BR.md

@@ -156,6 +156,9 @@ handoff_at = 85                          # % da janela → o orq handoff move o
 max_per_account = 2                      # conta que já tem esse tanto de conductors nunca é alvo do handoff
 reset_grace_min = 15                     # toda janela acima do gatilho renova dentro desses minutos → pula a mudança
 
+[git]
+issue_pattern = "(?<![a-z0-9])(?<issue>[a-z][a-z0-9]*-\\d+)(?![a-z0-9])"   # Nome de branch/worktree → ID da issue, para `orq gc` e `orq ci` — padrão mostrado; regex, grupo nomeado `issue` (senão o grupo 1)
+
 [policy]
 quota_limit = 90                         # caps the 5h pick limit; also sets ! in `orq quota --line`
 pacing_penalty = 0.3                     # score penalty when usage at the current pace would pass the pick limit (5h by level, week: quota_week) by the reset (0 = off)

package/dist/agents.js

@@ -154,7 +154,14 @@ export function expandTemplate(t, vars) {
         if (g >= 0)
             while (j < words.length && words[j].group === g)
                 j++;
-        out.push(...expandWords(words.slice(i, j).map((w) => w.text), vars, g >= 0));
+        const got = expandWords(words.slice(i, j).map((w) => w.text), vars, g >= 0);
+        // `--flag {placeholder}` with the placeholder empty: drop the flag too, or it would swallow the next argument.
+        const ph = g < 0 ? /^\{(\w+)(?::[^}]*)?\}$/.exec(words[i].text) : null, prev = words[i - 1];
+        if (!got.length && ph && !Array.isArray(vars[ph[1]]) && prev && prev.group < 0 && /^-[^\s{]/.test(prev.text)
+            && out[out.length - 1] === prev.text)
+            out.pop();
+        else
+            out.push(...got);
         i = j;
     }
     return out;
@@ -255,11 +262,34 @@ export const FORMATS = {
             }
             if (errs.length)
                 answer += (answer ? "\n" : "") + errs.join("\n") + "\n";
-            return { session: lastOf(res.map((r) => r.conversation_id).filter(Boolean)), answer, rc: errs.length || wasDenied ? 3 : undefined,
+            const exhausted = agyExhausted(log, res);
+            return { exhausted, session: lastOf(res.map((r) => r.conversation_id).filter(Boolean)), answer, rc: errs.length || wasDenied ? 3 : undefined,
                 denied: wasDenied ? (denied.length ? denied : ["(command)"]) : undefined };
         },
     },
 };
+/** "Resets in 123h12m32s" → seconds (undefined without such a duration). */
+export function parseResetIn(text) {
+    const r = /Resets in\s+(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?/i.exec(text);
+    if (!r || !(r[1] || r[2] || r[3]))
+        return undefined;
+    return Number(r[1] ?? 0) * 3600 + Number(r[2] ?? 0) * 60 + Number(r[3] ?? 0);
+}
+/** agy's quota failure (RESOURCE_EXHAUSTED / "quota reached"), from the result's error or the AGY_ERROR line. */
+function agyExhausted(log, res) {
+    const msgs = res.filter((r) => r.status === "ERROR" || r.error).map((r) => String(r.error ?? ""));
+    for (const l of log.split(/\r?\n/)) {
+        if (!l.startsWith("AGY_ERROR:"))
+            continue;
+        const j = json(l.slice(10).trim());
+        if (j)
+            msgs.push(`${j.status ?? ""} ${j.short_error ?? ""}`);
+    }
+    const text = msgs.find((t) => /RESOURCE_EXHAUSTED|quota reached/i.test(t));
+    if (!text)
+        return undefined;
+    return { secs: parseResetIn(text), message: text.replace(/^.*?(?:\(code 429\):\s*)/, "").trim() };
+}
 /** The model in an agent's argv (-m / --model / --model=x), without the provider prefix. */
 export function argvModel(a) {
     const i = a.findIndex((x) => x === "-m" || x === "--model");

package/dist/ci.js

@@ -15,6 +15,7 @@ import { join } from "node:path";
 import { aliveOwner } from "./commands/claim.js";
 import { writeAtomic } from "./fsutil.js";
 import { m } from "./i18n.js";
+import { issueFromName, issuePattern } from "./issue.js";
 import { alive } from "./lock.js";
 import { stateDir } from "./paths.js";
 import { notify } from "./testrun.js";
@@ -93,11 +94,10 @@ export function listWorktrees(ws) {
     return out;
 }
 /** The repo + branch an issue's worktree carries, the same match `orq gc` uses: a worktree branch ending in
- *  "plane-<id, lowercase>" under <ws>/.worktrees. An issue can have one per repo (several repos in play).
+ *  the issue ID (git.issue_pattern; any "plane-" prefix or suffix is ignored) under <ws>/.worktrees. An issue can have one per repo (several repos in play).
  *  `all` lets a caller looping over several issues pass its own listWorktrees(ws) once instead of one per issue. */
-export function issueBranches(ws, issue, all = listWorktrees(ws)) {
-    const suffix = `plane-${issue.toLowerCase()}`;
-    return all.filter((b) => b.branch.toLowerCase().endsWith(suffix));
+export function issueBranches(ws, issue, all = listWorktrees(ws), pattern) {
+    return all.filter((b) => issueFromName(b.branch, pattern)?.toLowerCase() === issue.toLowerCase());
 }
 // GitHub's statusCheckRollup mixes CheckRun (status/conclusion, the GitHub Actions / Checks API shape) with the
 // legacy commit-status shape (StatusContext: just `state`, no status/conclusion at all) for repos whose CI still
@@ -204,8 +204,8 @@ function notifyDesktop(issue, repo, state) {
 export function collectCi(ws, hooks = {}) {
     // Detached: collectCi() must never block on a conductor stuck in a dialog (herdr-notify waits up to 30 min).
     const desktop = hooks.desktop ?? notifyDesktop, toOwner = hooks.owner ?? ((pane, line) => notify(pane, line)), notice = hooks.notice ?? ((l) => console.log(l));
-    const now = Date.now(), worktrees = listWorktrees(ws);
-    const found = claimedIssues(ws).flatMap(({ id, owner, kind }) => issueBranches(ws, id, worktrees).map(({ repo, branch }) => ({ id, owner, kind, repo, branch, ...prStatus(join(ws, repo), branch) })));
+    const now = Date.now(), worktrees = listWorktrees(ws), pattern = issuePattern(ws);
+    const found = claimedIssues(ws).flatMap(({ id, owner, kind }) => issueBranches(ws, id, worktrees, pattern).map(({ repo, branch }) => ({ id, owner, kind, repo, branch, ...prStatus(join(ws, repo), branch) })));
     const toNotify = [];
     const mine = withCacheLock(() => {
         const cache = loadCache(), mine = [];

package/dist/commands/agent.js

@@ -20,6 +20,7 @@ import { getPath, loadConfig } from "../config.js";
 import { writeAtomic } from "../fsutil.js";
 import { m } from "../i18n.js";
 import { alive } from "../lock.js";
+import { agyToken, humanReset, learnExhausted } from "../quota.js";
 import { stateDir } from "../paths.js";
 import { killedRc, killTree, parseSize, resolveMode, runCapped } from "../process.js";
 import { closeOwnTab, detectHost, launch, screenOpen, shq, typeInto } from "../terminal.js";
@@ -342,6 +343,12 @@ function turn(file, kind, rest) {
                 return 0;
             answer = String(e["last-assistant-message"] ?? "");
             sid = e["thread-id"];
+            // Codex also runs internal turns (e.g. generating the tab title) and notifies for them: only the main thread counts.
+            const known = existsSync(`${O}.id`) ? readFileSync(`${O}.id`, "utf8").trim() : "";
+            if (known && sid && sid !== known)
+                return 0;
+            if (isTitleOnly(answer))
+                return 0;
         }
         else if (kind === "claude") {
             const e = JSON.parse(readFileSync(0, "utf8"));
@@ -376,6 +383,16 @@ function turn(file, kind, rest) {
     }
     return 0;
 }
+/** The `{"title": "..."}` answer of Codex's session-title turn (a JSON object whose only key is `title`). */
+function isTitleOnly(answer) {
+    try {
+        const o = JSON.parse(answer);
+        return typeof o === "object" && o !== null && !Array.isArray(o) && Object.keys(o).length === 1 && "title" in o;
+    }
+    catch {
+        return false;
+    }
+}
 /** The last text Claude wrote, from its transcript (older Stop hooks have no last_assistant_message). */
 function lastClaudeText(transcript) {
     let text = "";
@@ -647,6 +664,19 @@ async function runJob(file) {
         else
             res.answer = `${res.answer ?? ""}\nNo changes were made in the worktree.\n`;
     }
+    // Out of quota: not a code failure. Learn the model's bucket (orq quota / pick see it) and say why, so the conductor re-picks.
+    if (res.exhausted) {
+        const model = argvModel(j.argv);
+        let until = "";
+        if (res.exhausted.secs !== undefined) {
+            const at = Date.now() + res.exhausted.secs * 1000;
+            if (model)
+                learnExhausted("antigravity", model, res.exhausted.secs, agyToken()?.acct);
+            until = ` ${m("until", "até")} ${humanReset(Math.floor(at / 1000))} (${new Date(at).toISOString()})`;
+        }
+        res.answer = `quota exhausted: ${model ?? j.agent}${until}\n\n${res.exhausted.message}\n`;
+        res.rc = res.rc || 3;
+    }
     if (j.answer !== "file")
         writeFileSync(`${O}.out.md`, res.answer ?? "");
     const sid = j.fromLog ? new RegExp(j.fromLog, "m").exec(logText)?.[1] : res.session ?? j.session;

package/dist/commands/gc.js

@@ -4,6 +4,7 @@ import { existsSync, readdirSync, readFileSync, realpathSync, rmSync } from "nod
 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";
@@ -69,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);
@@ -102,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");
@@ -117,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") {

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/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/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,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/quota.js

@@ -24,6 +24,7 @@ import { writeAtomic } from "./fsutil.js";
 import { readSecret } from "./keyring.js";
 import { stateDir } from "./paths.js";
 import { m } from "./i18n.js";
+import { modelKey } from "./pick.js";
 const show = (p) => (typeof p === "number" ? `${Math.floor(p)}%` : p);
 // reset5h/resetweek (epoch seconds) sit between the windows and the note: parseQuota/parseWindows only look at the
 // first three words, so old cached lines (no reset fields) and lines with them both parse the same way.
@@ -50,9 +51,9 @@ const resetOf = (w) => {
 };
 // `acct` identifies the login behind a reading (antigravity: one login per machine, swapped by the user): a cache
 // written under another login must never stand in for this one.
-function remember(name, five, week, acct) {
+function remember(name, five, week, acct, buckets) {
     try {
-        writeAtomic(cacheFile(name), JSON.stringify({ five, week, at: Date.now(), ...(acct ? { acct } : {}) }));
+        writeAtomic(cacheFile(name), JSON.stringify({ five, week, at: Date.now(), ...(acct ? { acct } : {}), ...(buckets ? { buckets } : {}) }));
     }
     catch { /* best effort */ }
     const r5 = resetOf(five), rw = resetOf(week);
@@ -195,23 +196,83 @@ export function codexQuota() {
     return { name: "codex", ...pcts, ...(span5 ? { span5h: span5 } : {}), ...(span ? { spanWeek: span } : {}), note: (d ? m(`${d}-day window in the week slot; `, `janela de ${d} dias no lugar da semana; `) : "")
             + m(`from the last session, ${age} min ago`, `da última sessão, há ${age} min`) };
 }
-/** Worst usage per window across models: a reset within 6 h belongs to the 5h window, a later one to the week. */
+/** Per-model buckets, and the agent's own pair: its least used bucket (the agent still has quota while any
+ *  model does; `orq pick` checks the model it is about to choose against that model's own bucket). */
 export function antigravityFromModels(models, now = Date.now()) {
     const five = { pct: "-" }, week = { pct: "-" };
-    for (const { quotaInfo: q } of Object.values(models ?? {})) {
-        if (typeof q?.remainingFraction !== "number" || !q.resetTime)
+    const buckets = {};
+    for (const [id, { quotaInfo: q } = {}] of Object.entries(models ?? {})) {
+        if (!q?.resetTime)
             continue;
         const at = Date.parse(q.resetTime);
         if (Number.isNaN(at))
             continue;
-        const w = at - now <= 6 * 3600_000 ? five : week;
-        const used = Math.round((1 - q.remainingFraction) * 100);
-        if (w.pct === "-" || used > w.pct) {
-            w.pct = used;
-            w.resetsAt = q.resetTime;
+        const left = typeof q.remainingFraction === "number" ? q.remainingFraction : 0;
+        const used = Math.min(100, Math.max(0, Math.round((1 - left) * 100)));
+        const isWeek = at - now > 6 * 3600_000;
+        buckets[id] = { used, resetsAt: q.resetTime, week: isWeek };
+    }
+    // The agent's pair is its least used bucket overall, in that bucket's window (the other stays "-"): a weekly cap on
+    // one model must not read as the whole agent being out.
+    const best = Object.values(buckets).sort((x, y) => x.used - y.used || Number(x.week) - Number(y.week))[0];
+    if (best)
+        Object.assign(best.week ? week : five, { pct: best.used, resetsAt: best.resetsAt });
+    return { five, week, buckets };
+}
+/** One quota line per model, named "<agent>/<model>", with its bucket in the 5h or the week slot and "-" in the other. */
+export function modelLines(name, buckets, now = Date.now(), note) {
+    const out = [];
+    for (const [id, b] of Object.entries(buckets)) {
+        const at = Date.parse(b.resetsAt);
+        if (Number.isNaN(at) || at <= now)
+            continue; // reset since the reading: no figure to stand on
+        const reset = Math.floor(at / 1000);
+        out.push({ name: `${name}/${id}`, five: b.week ? "-" : b.used, week: b.week ? b.used : "-",
+            ...(b.week ? { resetWeek: reset } : { reset5h: reset }), ...(note ? { note } : {}) });
+    }
+    return out;
+}
+/** Learned exhausted buckets (from a run that hit the limit) outlive API readings until their reset, unless the API
+ *  returns that model with something left. The API's own bucket for the model stands in when it also says exhausted. */
+export function mergeLearned(api, learned, now = Date.now()) {
+    const out = { ...api };
+    for (const [id, b] of Object.entries(learned)) {
+        if (!b.learned || Date.parse(b.resetsAt) <= now)
+            continue;
+        const key = modelKey(id, Object.keys(api));
+        if (key && api[key].used < 100)
+            continue; // the API says it has quota again
+        out[id] = b;
+    }
+    return out;
+}
+/** Record that a run found `model` out of quota for `secs` more seconds (best effort; keeps the cached reading). */
+export function learnExhausted(name, model, secs, acct, now = Date.now()) {
+    const at = now + secs * 1000;
+    const b = { used: 100, resetsAt: new Date(at).toISOString(), week: at - now > 6 * 3600_000, learned: true };
+    try {
+        let c = { five: { pct: "-" }, week: { pct: "-" }, at: now };
+        try {
+            c = JSON.parse(readFileSync(cacheFile(name), "utf8"));
         }
+        catch { /* none yet */ }
+        if (acct !== undefined && c.acct !== undefined && c.acct !== acct)
+            c = { five: { pct: "-" }, week: { pct: "-" }, at: now };
+        const buckets = { ...(c.buckets ?? {}), [model]: b };
+        writeAtomic(cacheFile(name), JSON.stringify({ ...c, ...(acct ? { acct } : {}), buckets }));
+    }
+    catch { /* best effort */ }
+    return b;
+}
+/** The per-model buckets of the last good reading, when it was this login's. */
+function cachedBuckets(name, acct) {
+    try {
+        const c = JSON.parse(readFileSync(cacheFile(name), "utf8"));
+        return acct !== undefined && c.acct !== acct ? {} : c.buckets ?? {};
+    }
+    catch {
+        return {};
     }
-    return { five, week };
 }
 export function agyToken() {
     // agy (go-keyring) keeps {"token": {access_token, expiry, ...}} under service "gemini", user "antigravity"
@@ -242,13 +303,17 @@ export async function antigravityQuota() {
     const name = "antigravity";
     const t = agyToken();
     if (!t?.access)
-        return noData(name, m("no agy login in the keyring", "sem login do agy no chaveiro"));
+        return [noData(name, m("no agy login in the keyring", "sem login do agy no chaveiro"))];
     // Never refresh it here (that is agy's login). The access token lives 1h and agy renews it only when it runs, so a
     // passed expiry with a refresh token is just idle (a note, not an expired login); without one, "run agy once".
     const expired = m("login expired: run `agy models`", "login expirado: rode `agy models`");
+    const stale = (why) => {
+        const line = fromCache(name, why, undefined, t.acct);
+        return [line, ...modelLines(name, cachedBuckets(name, t.acct), Date.now(), line.note)];
+    };
     const note = agyNote(t);
     if (note)
-        return fromCache(name, note, undefined, t.acct);
+        return stale(note);
     try {
         const r = await fetch("https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels", {
             method: "POST", body: "{}",
@@ -257,15 +322,16 @@ export async function antigravityQuota() {
             signal: AbortSignal.timeout(15_000),
         });
         if (r.status === 401)
-            return fromCache(name, expired, undefined, t.acct);
+            return stale(expired);
         if (!r.ok)
-            return fromCache(name, `HTTP ${r.status}`, undefined, t.acct);
+            return stale(`HTTP ${r.status}`);
         const j = await r.json();
-        const { five, week } = antigravityFromModels(j.models ?? {});
-        return remember(name, five, week, t.acct);
+        const { five, week, buckets: api } = antigravityFromModels(j.models ?? {});
+        const buckets = mergeLearned(api, cachedBuckets(name, t.acct));
+        return [remember(name, five, week, t.acct, buckets), ...modelLines(name, buckets)];
     }
     catch (e) {
-        return fromCache(name, m("collector failed", "coletor falhou") + `: ${e.message}`, undefined, t.acct);
+        return stale(m("collector failed", "coletor falhou") + `: ${e.message}`);
     }
 }
 // --- copilot --------------------------------------------------------------------------------------------------------
@@ -385,7 +451,7 @@ export async function collect(sources, want = []) {
         if (name === "codex")
             return wanted(name) ? [format(codexQuota())] : [];
         if (name === "antigravity")
-            return wanted(name) ? [format(await antigravityQuota())] : [];
+            return wanted(name) ? (await antigravityQuota()).map(format) : [];
         if (name === "copilot")
             return wanted(name) ? [format(copilotQuota())] : [];
         if (name === "opencode" || name === "minimax")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irythill/orq",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Orchestrate coding agents (Claude Code, Codex, OpenCode, Antigravity, Copilot) from one conductor.",
   "license": "MIT",
   "type": "module",
@@ -11,7 +11,8 @@
     "dist",
     "!dist/**/*.test.js",
     "skills",
-    "templates/workspace.CLAUDE.md"
+    "templates/workspace.CLAUDE.md",
+    "templates/conductor.instructions.md"
   ],
   "engines": {
     "node": ">=20"

package/templates/conductor.instructions.md

@@ -0,0 +1,31 @@
+# Conductor "{{NAME}}" — {{NAME}} ecosystem
+
+You orchestrate agents in the `{{WORKSPACE}}` ecosystem, in herdr (`HERDR_ENV=1`) or in any other terminal.
+Don't write code yourself. Opened by `orq conductor`. Talk to the user in the user's language.
+1. Read `{{WORKSPACE}}/CLAUDE.md` (repos, groups, base branch, Plane, issue standard, MCP limitations).
+2. For every Plane issue, follow the `/issue <ID>` skill.
+3. Never push, open a PR, merge or deploy unless the user asks. When unsure about scope or cost, ask.
+4. **Children only through `orq agent`** (implementer, fix, review), with the agent chosen by `orq pick`; tests through
+   `orq verify` (it checks the base by itself; no `orq baseline` in the flow), as the skill says. NEVER
+   `herdr agent start` for children (no memory cap, no answer file); to watch the agent's own screen, `orq agent -T` (herdr or tmux).
+5. **Completion = one single signal:** in herdr, the line `[HERDR-AGENT DONE] <title> status=ok|fail ... answer: <file>`
+   arriving in your pane; elsewhere, `orq wait <prefix>` (as a background task) printing
+   `[ORQ AGENT DONE] <title> status=ok|fail ... answer: <file>` (plus the `<prefix>.done` file either way). When it
+   arrives: read the answer file and act. Nothing else means done.
+6. **"Is it still running?"** is answered by the file only: `<prefix>.done` exists → finished; it doesn't → running;
+   check `<prefix>.log` (last write time) or, in herdr, peek at the pane: `herdr pane read $(cat <prefix>.pane) --source recent`.
+   NEVER `pgrep`/`ps` (they match their own command line).
+7. **Never block waiting** (`herdr agent wait`, `pane wait-output`, `sleep`): dispatch, report in one line and end
+   your turn (outside herdr: `orq wait` in the background, never in the foreground unless your harness has no background tasks).
+8. Worktrees always from `origin/<repo base>`, created with `git worktree add` (never `herdr worktree create`).
+9. Between batches of unrelated issues, suggest `/clear` to the user: state lives in Plane and in `.orquestra/`.
+
+## How you are used
+- **Dispatcher, not consultant.** Your job: issue → dispatch → report → PR/cleanup. Long questions about architecture,
+  infrastructure (DNS, email, deploy, webhooks) or business decisions: answer in at most 3 lines and suggest "take it
+  to a design session; come back with the decision recorded in the issue".
+- **The issue is the source.** A decision made in chat → record it in Plane (description or comment) before
+  dispatching; the child's prompt comes from the issue, not from the conversation.
+- **Context:** past ~150k tokens or after closing a batch of related issues → suggest `/clear` (state in Plane and in
+  `.orquestra/`).
+- 1–3 line answers. Final issue report: 3–5 lines + the PR link.