@irythill/orq 0.0.0-stage → 0.1.0

package/dist/pick.js

@@ -0,0 +1,115 @@
+import { m } from "./i18n.js";
+import { legacyRole, resolveRole, vendorOf } from "./roles.js";
+/** "<name> 5h=NN% week=NN% [note]" lines → QuotaMap (same reading as the old orq-pick). */
+export function parseQuota(text) {
+    const out = {};
+    for (const line of text.split(/\r?\n/)) {
+        const p = line.split(/\s+/);
+        if (p.length < 3)
+            continue;
+        const vals = p.slice(1, 3).map((x) => x.replace(/.*=/, ""));
+        if (vals.some((v) => v.startsWith("?"))) {
+            out[p[0]] = null;
+            continue;
+        }
+        const nums = vals.map((v) => v.replace(/%$/, "")).filter((v) => /^\d+$/.test(v)).map(Number);
+        out[p[0]] = nums.length ? Math.max(...nums) : -1;
+    }
+    return out;
+}
+export function modelFor(a, role, level) {
+    if (a.models === undefined)
+        return ["", undefined]; // no models configured: the CLI's default
+    const models = a.models;
+    const lr = legacyRole(role);
+    const ms = models[lr] ?? (lr === "fix" ? models.impl : undefined) ?? {};
+    const spec = ms[level] ?? ms.default ?? ms.medium ?? ms.simple;
+    if (!spec)
+        return undefined;
+    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 };
+export const weights = (cfg) => ({ ...WEIGHTS, ...((cfg.policy ?? {}).weights ?? {}) });
+export function pick(inp) {
+    const { cfg, role, level } = inp;
+    const agents = (cfg.agents ?? {});
+    const pol = (cfg.policy ?? {});
+    const limit = Number(pol.quota_limit ?? 90);
+    const w = weights(cfg);
+    const res = resolveRole(cfg, role);
+    const names = res.mode === "fixed" ? res.order : res.pool;
+    const notes = [];
+    const out = (n, why) => { notes.push(`${n}: ${why}`); };
+    const pass = [];
+    for (const name of names) {
+        const a = agents[name];
+        if (!a) {
+            out(name, m("not declared in [agents]", "não declarado em [agents]"));
+            continue;
+        }
+        if (inp.exclude.has(name)) {
+            out(name, m("excluded (--exclude-agent)", "excluído (--exclude-agent)"));
+            continue;
+        }
+        if (inp.blocks.has(name)) {
+            out(name, m("blocked (orq block -l)", "bloqueado (orq block -l)"));
+            continue;
+        }
+        if ((role === "review" || role === "opinion") && res.rule === "other-vendor" && inp.implVendor
+            && vendorOf(name, a) === inp.implVendor) {
+            out(name, m("same vendor as the implementer", "mesmo fornecedor do implementador"));
+            continue;
+        }
+        const mf = modelFor(a, role, level);
+        if (!mf) {
+            out(name, m(`no model for ${role}/${level}`, `sem modelo para ${role}/${level}`));
+            continue;
+        }
+        // Quota: an agent with several accounts (claude) uses the least used one under the limit.
+        const qn = a.quota ?? [];
+        const accs = qn.filter((n) => !inp.blocks.has(n)).map((n) => [n, n in inp.quota ? inp.quota[n] : -1]);
+        if (qn.length && !accs.length) {
+            out(name, m("all accounts blocked", "todas as contas bloqueadas"));
+            continue;
+        }
+        const usable = accs.filter(([, v]) => v !== null && v < limit);
+        if (accs.length && !usable.length) {
+            out(name, `${m("quota", "cota")} >= ${limit}% ${m("or no data", "ou sem dados")} (${accs.map(([n, v]) => `${n}=${v}`).join(", ")})`);
+            continue;
+        }
+        const acct = accs.length > 1 ? [...usable].sort((x, y) => x[1] - y[1])[0][0] : undefined;
+        const statRole = role === "fix" || role === "worker" ? "impl" : role;
+        const st = inp.stats.find((r) => r.role === statRole && r.agent === name && r.model === (mf[0].split("/").pop() || "default"));
+        pass.push({ agent: name, model: mf[0], effort: mf[1], acct, a, st });
+        if (res.mode === "fixed")
+            break; // the first that passes wins
+    }
+    if (res.mode === "fixed") {
+        const c = pass[0];
+        const best = c && { agent: c.agent, model: c.model, effort: c.effort, acct: c.acct, score: 0,
+            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);
+    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 used = inp.recent.filter((p) => p.agent === c.agent).length;
+        const score = w.quality * d + w.tokens * t + w.speed * s - w.rotation * used
+            - (reserve ? w.reserve : 0) + (few(c.st) ? w.explore : 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} `
+            + (reserve ? m("reserve ", "reserva ") : "") + (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 };
+}
+/** The arguments for the agent runner, e.g. "-a codex -m gpt-6-sol -e low -c work". */
+export const asArgs = (c) => `-a ${c.agent}` + (c.model ? ` -m ${c.model}` : "") + (c.effort ? ` -e ${c.effort}` : "") + (c.acct ? ` -c ${c.acct}` : "");

package/dist/process.js

@@ -0,0 +1,147 @@
+// ProcessHost — run a command under a memory cap, on any OS.
+//   kernel    Linux with a systemd user session: `systemd-run --user --scope -p MemoryMax=` (the kernel kills only
+//             that command, as orq always did)
+//   watchdog  everywhere else (macOS, Windows, Linux without systemd): orq samples the command's process tree every
+//             few seconds and kills the whole tree above the cap
+//   off       no cap
+// mode "auto" = kernel when available, else watchdog. (Windows Job Objects need a native addon: later, if the
+// watchdog proves too coarse.)
+import { execFile, spawn, spawnSync } from "node:child_process";
+import { m } from "./i18n.js";
+/** "4G", "512M", "1.5G", "off" → bytes (undefined = no cap). */
+export function parseSize(s) {
+    if (s === undefined || s === "" || s === "off" || s === false)
+        return undefined;
+    if (typeof s === "number")
+        return s;
+    const r = /^(\d+(?:\.\d+)?)\s*([KMGT]?)i?B?$/i.exec(s.trim());
+    if (!r)
+        throw new Error(m(`invalid size: ${s} (e.g. 4G, 512M, off)`, `tamanho inválido: ${s} (ex.: 4G, 512M, off)`));
+    return Math.round(Number(r[1]) * 1024 ** "BKMGT".indexOf((r[2] || "B").toUpperCase()));
+}
+let kernelOk;
+export function hasKernelCap() {
+    if (process.platform !== "linux")
+        return false;
+    kernelOk ??= spawnSync("systemd-run", ["--user", "--scope", "-q", "--", "true"], { stdio: "ignore", timeout: 10_000 }).status === 0;
+    return kernelOk;
+}
+// systemd-run expands ${...} in its arguments (the prompt!) unless told not to; the flag exists in systemd >= 254.
+let noExpand;
+const noExp = () => noExpand ??= /--expand-environment/.test(spawnSync("systemd-run", ["--help"], { encoding: "utf8" }).stdout ?? "")
+    ? ["--expand-environment=no"] : [];
+export function resolveMode(mode, cap) {
+    if (cap === undefined || mode === "off")
+        return "off";
+    if (mode === "kernel" || (mode === "auto" && hasKernelCap()))
+        return "kernel";
+    return "watchdog";
+}
+const LIST = process.platform === "win32"
+    ? ["powershell", ["-NoProfile", "-NonInteractive", "-Command",
+            "Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,WorkingSetSize | ForEach-Object { \"$($_.ProcessId) $($_.ParentProcessId) $($_.WorkingSetSize)\" }"]]
+    : ["ps", ["-A", "-o", "pid=,ppid=,rss="]];
+/** pid → [ppid, bytes] for every process (ps on Linux/macOS, CIM on Windows). */
+export function processTable() {
+    return parseTable(spawnSync(LIST[0], LIST[1], { encoding: "utf8", timeout: 15_000 }).stdout ?? "");
+}
+/** Same, without blocking: PowerShell takes seconds on Windows and the watchdog must keep running meanwhile. */
+export function processTableAsync() {
+    return new Promise((res) => execFile(LIST[0], LIST[1], { encoding: "utf8", timeout: 15_000, windowsHide: true }, (_e, out) => res(parseTable(out ?? ""))));
+}
+function parseTable(text) {
+    const t = new Map();
+    for (const line of text.split(/\r?\n/)) {
+        const [pid, ppid, mem] = line.trim().split(/\s+/).map(Number);
+        if (pid)
+            t.set(pid, [ppid, process.platform === "win32" ? mem : mem * 1024]);
+    }
+    return t;
+}
+/** Total memory of `root` and all its descendants. */
+export function treeMem(root, table = processTable()) {
+    const kids = new Map();
+    for (const [pid, [ppid]] of table)
+        kids.set(ppid, [...(kids.get(ppid) ?? []), pid]);
+    let total = 0;
+    const seen = new Set(), todo = [root];
+    while (todo.length) {
+        const p = todo.pop();
+        if (seen.has(p))
+            continue;
+        seen.add(p);
+        total += table.get(p)?.[1] ?? 0;
+        todo.push(...(kids.get(p) ?? []));
+    }
+    return total;
+}
+export function killTree(pid) {
+    if (process.platform === "win32")
+        spawnSync("taskkill", ["/T", "/F", "/PID", String(pid)], { stdio: "ignore" });
+    else
+        try {
+            process.kill(-pid, "SIGKILL");
+        }
+        catch {
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch { /* gone */ }
+        }
+}
+/** 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`;
+/** Run `cmd args` with stdio inherited, under the cap; resolves to the exit code (137 = killed for memory). */
+export function runCapped(cmd, args, o = {}) {
+    const mode = resolveMode(o.mode ?? "auto", o.cap);
+    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 });
+        o.onSpawn?.(c);
+        return wait(c);
+    }
+    const win = process.platform === "win32";
+    // Own process group on Linux/macOS, so the whole tree can be killed at once.
+    // 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, shell, windowsHide: true });
+    o.onSpawn?.(child);
+    if (mode === "off" || !child.pid)
+        return wait(child);
+    const fwd = (sig) => () => { try {
+        process.kill(-child.pid, sig);
+    }
+    catch {
+        child.kill(sig);
+    } };
+    const onInt = fwd("SIGINT"), onTerm = fwd("SIGTERM");
+    if (!win) {
+        process.on("SIGINT", onInt);
+        process.on("SIGTERM", onTerm);
+    }
+    let killed = false, sampling = false;
+    const timer = setInterval(async () => {
+        if (sampling || killed)
+            return; // a slow sample (Windows) never overlaps the next
+        sampling = true;
+        const used = treeMem(child.pid, await processTableAsync());
+        sampling = false;
+        if (used > o.cap && !killed) {
+            killed = true;
+            console.error(m(`orq: memory ${gb(used)} over the cap (${gb(o.cap)}): killing the process tree`, `orq: memória ${gb(used)} acima do limite (${gb(o.cap)}): encerrando a árvore de processos`));
+            killTree(child.pid);
+        }
+    }, o.intervalMs ?? 1000);
+    return wait(child).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); });
+    c.on("exit", (code, sig) => res(code ?? (sig ? 128 + 9 : 1)));
+});

package/dist/quota.js

@@ -0,0 +1,276 @@
+// Quota per agent/account, from the sources in the [quota] config section:
+//   "builtin"            claude: the account's usage (Anthropic OAuth usage endpoint, same login Claude Code uses)
+//                        codex:  the rate_limits Codex writes into its latest session file
+//                        antigravity: per-model quota from Cloud Code (fetchAvailableModels), with the login agy keeps
+//                                 in the OS keyring (src/keyring.ts: Secret Service, Keychain, Credential Manager)
+//                        copilot: premium requests left this month (`gh api /copilot_internal/user`; a monthly
+//                                 allowance, shown in the week slot)
+//   false                left out of the list entirely
+//   "none"               no collector: never skipped for quota; use `orq block` when it runs out
+//   { command = "..." }  any command printing lines "<name> 5h=NN% week=NN% [note]"
+// Output line (read by orq-pick and the board): "<name> 5h=NN% week=NN% [note]".
+//   -  = the plan has no such window (not limiting);  ? = no data (expired login, collector failed).
+import { spawnSync } from "node:child_process";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir, userInfo } from "node:os";
+import { join } from "node:path";
+import { claudeAccounts } from "./accounts.js";
+import { writeAtomic } from "./fsutil.js";
+import { readSecret } from "./keyring.js";
+import { stateDir } from "./paths.js";
+import { m } from "./i18n.js";
+const show = (p) => (typeof p === "number" ? `${Math.floor(p)}%` : p);
+export const format = (q) => `${q.name} 5h=${show(q.five)} week=${show(q.week)}${q.note ? ` [${q.note}]` : ""}`;
+const noData = (name, note) => ({ name, five: "?", week: "?", note });
+const KEEP_MS = 5 * 3600_000;
+const cacheFile = (name) => join(stateDir(), "quota", `${name}.json`);
+function remember(name, five, week) {
+    try {
+        writeAtomic(cacheFile(name), JSON.stringify({ five, week, at: Date.now() }));
+    }
+    catch { /* best effort */ }
+    return { name, five: five.pct, week: week.pct };
+}
+/** The cached reading (its age in the note), window by window; nothing usable → the "no data" line. */
+export function fromCache(name, why, now = Date.now()) {
+    try {
+        const c = JSON.parse(readFileSync(cacheFile(name), "utf8"));
+        const still = (w) => {
+            if (w.resetsAt) {
+                const t = Date.parse(w.resetsAt);
+                if (!Number.isNaN(t))
+                    return t > now ? w.pct : 0;
+            }
+            return now - c.at < KEEP_MS ? w.pct : undefined;
+        };
+        const five = still(c.five), week = still(c.week);
+        if (five !== undefined && week !== undefined) {
+            const min = Math.round((now - c.at) / 60_000);
+            return { name, five, week, note: `${why}; ` + m(`last reading, ${min} min ago`, `última leitura, há ${min} min`) };
+        }
+    }
+    catch { /* no cache */ }
+    return noData(name, why);
+}
+function claudeToken(dir) {
+    try {
+        return JSON.parse(readFileSync(join(dir, ".credentials.json"), "utf8")).claudeAiOauth;
+    }
+    catch { /* not in a file: macOS keeps it in the Keychain */ }
+    if (process.platform !== "darwin")
+        return undefined;
+    try {
+        return JSON.parse(readSecret("Claude Code-credentials", userInfo().username) ?? "").claudeAiOauth;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function claudeQuota(name, dir) {
+    const t = claudeToken(dir);
+    if (!t?.accessToken)
+        return noData(name, m("not logged in", "sem login"));
+    // Never refresh the token here (that would rotate Claude Code's login): an expired one just means "open claude".
+    if (t.expiresAt && t.expiresAt < Date.now())
+        return noData(name, m("login expired: open claude once", "login expirado: abra o claude uma vez"));
+    try {
+        const r = await fetch("https://api.anthropic.com/api/oauth/usage", {
+            headers: { Authorization: `Bearer ${t.accessToken}`, "anthropic-beta": "oauth-2025-04-20" },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (r.status === 401)
+            return noData(name, m("login expired: open claude once", "login expirado: abra o claude uma vez"));
+        if (!r.ok)
+            return fromCache(name, `HTTP ${r.status}`);
+        const j = await r.json();
+        const win = (w) => ({ pct: typeof w?.utilization === "number" ? w.utilization : "-",
+            ...(typeof w?.resets_at === "string" ? { resetsAt: w.resets_at } : {}) });
+        return remember(name, win(j.five_hour), win(j.seven_day));
+    }
+    catch (e) {
+        return fromCache(name, m("collector failed", "coletor falhou") + `: ${e.message}`);
+    }
+}
+// --- codex ----------------------------------------------------------------------------------------------------------
+function latestCodexSession() {
+    const root = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "sessions");
+    let best;
+    const walk = (d, depth) => {
+        let entries;
+        try {
+            entries = readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const p = join(d, e.name);
+            if (e.isDirectory() && depth < 3)
+                walk(p, depth + 1);
+            else if (e.isFile() && e.name.endsWith(".jsonl")) {
+                const t = statSync(p).mtimeMs;
+                if (!best || t > best.t)
+                    best = { f: p, t };
+            }
+        }
+    };
+    walk(root, 0);
+    return best?.f;
+}
+/** The last rate_limits in a Codex session (.jsonl): 300-min window = 5h, 10080 = week; a window already reset → 0. */
+export function codexFromSession(text, nowSec) {
+    let last;
+    for (const line of text.split("\n")) {
+        if (!line.includes('"rate_limits"'))
+            continue;
+        try {
+            const find = (o) => {
+                if (o && typeof o === "object") {
+                    const r = o.rate_limits;
+                    if (r && typeof r === "object")
+                        last = r;
+                    Object.values(o).forEach(find);
+                }
+            };
+            find(JSON.parse(line));
+        }
+        catch { /* partial line */ }
+    }
+    if (!last)
+        return undefined;
+    const ws = [last.primary, last.secondary].filter((w) => !!w);
+    const win = (mins) => {
+        const w = ws.find((x) => x.window_minutes === mins);
+        if (!w)
+            return "-";
+        return (w.resets_at ?? 0) < nowSec ? 0 : Math.floor(w.used_percent ?? 0);
+    };
+    return { five: win(300), week: win(10080) };
+}
+export function codexQuota() {
+    const f = latestCodexSession();
+    if (!f)
+        return noData("codex", m("no Codex session yet", "nenhuma sessão do Codex ainda"));
+    const q = codexFromSession(readFileSync(f, "utf8"), Date.now() / 1000);
+    if (!q)
+        return noData("codex", m("no limit data", "sem dados de limite"));
+    const age = Math.round((Date.now() - statSync(f).mtimeMs) / 60_000);
+    return { name: "codex", ...q, note: 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. */
+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)
+            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;
+        }
+    }
+    return { five, week };
+}
+function agyToken() {
+    // agy (go-keyring) keeps {"token": {access_token, expiry, ...}} under service "gemini", user "antigravity"
+    // (on Windows go-keyring names the credential "gemini:antigravity").
+    const raw = readSecret("gemini", "antigravity", "gemini:antigravity");
+    if (!raw)
+        return undefined;
+    try {
+        const t = JSON.parse(raw).token;
+        return { access: t?.access_token, expiry: t?.expiry };
+    }
+    catch {
+        return undefined;
+    }
+}
+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"));
+    // Never refresh it here (that is agy's login): an expired one just means "run agy once" (`agy models` is enough).
+    const expired = m("login expired: run `agy models`", "login expirado: rode `agy models`");
+    if (t.expiry && Date.parse(t.expiry) < Date.now())
+        return fromCache(name, expired);
+    try {
+        const r = await fetch("https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels", {
+            method: "POST", body: "{}",
+            // The endpoint answers 403 without a client User-Agent.
+            headers: { Authorization: `Bearer ${t.access}`, "Content-Type": "application/json", "User-Agent": "antigravity" },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (r.status === 401)
+            return fromCache(name, expired);
+        if (!r.ok)
+            return fromCache(name, `HTTP ${r.status}`);
+        const j = await r.json();
+        const { five, week } = antigravityFromModels(j.models ?? {});
+        return remember(name, five, week);
+    }
+    catch (e) {
+        return fromCache(name, m("collector failed", "coletor falhou") + `: ${e.message}`);
+    }
+}
+// --- copilot --------------------------------------------------------------------------------------------------------
+/** Premium requests used this month, from the snapshot `gh api /copilot_internal/user` returns. No 5h window. */
+export function copilotFromUser(j) {
+    const u = j;
+    const p = u?.quota_snapshots?.premium_interactions;
+    if (!p)
+        return noData("copilot", m("no premium request data", "sem dados de requisições premium"));
+    if (p.unlimited)
+        return { name: "copilot", five: "-", week: "-", note: m("unlimited", "ilimitado") };
+    if (typeof p.percent_remaining !== "number")
+        return noData("copilot", m("no premium request data", "sem dados de requisições premium"));
+    const reset = u.quota_reset_date ? m(`, resets ${u.quota_reset_date}`, `, renova em ${u.quota_reset_date}`) : "";
+    return { name: "copilot", five: "-", week: Math.max(0, 100 - p.percent_remaining),
+        note: m("monthly premium requests", "requisições premium do mês") + reset };
+}
+export function copilotQuota() {
+    const r = spawnSync("gh", ["api", "/copilot_internal/user"], { encoding: "utf8", timeout: 15_000 });
+    if (r.error || r.status !== 0)
+        return noData("copilot", m("gh api failed (gh auth login?)", "gh api falhou (gh auth login?)"));
+    try {
+        return copilotFromUser(JSON.parse(r.stdout));
+    }
+    catch {
+        return noData("copilot", m("collector failed", "coletor falhou"));
+    }
+}
+// --- command ----------------------------------------------------------------------------------------------------------
+function commandQuota(name, cmd) {
+    const r = spawnSync(cmd, { shell: true, encoding: "utf8", timeout: 30_000 });
+    const lines = (r.stdout ?? "").split(/\r?\n/).filter((l) => /\S+ 5h=\S+ week=\S+/.test(l));
+    return lines.length ? lines : [format(noData(name, m("collector failed", "coletor falhou")))];
+}
+// --- all --------------------------------------------------------------------------------------------------------------
+/** One or more output lines per configured source, in config order. `want` filters by line name. */
+export async function collect(sources, want = []) {
+    const wanted = (n) => !want.length || want.includes(n);
+    const jobs = Object.entries(sources).map(async ([name, src]) => {
+        if (src === false)
+            return [];
+        if (src === "none")
+            return wanted(name) ? [format({ name, five: "-", week: "-", note: m("no quota collector", "sem coletor de cota") })] : [];
+        if (typeof src === "object" && src && "command" in src)
+            return commandQuota(name, src.command).filter((l) => wanted(l.split(" ")[0]));
+        if (name === "claude") {
+            const accs = claudeAccounts().filter((a) => wanted(a.name) || (want.includes("claude")));
+            return (await Promise.all(accs.map((a) => claudeQuota(a.name, a.dir)))).map(format);
+        }
+        if (name === "codex")
+            return wanted(name) ? [format(codexQuota())] : [];
+        if (name === "antigravity")
+            return wanted(name) ? [format(await antigravityQuota())] : [];
+        if (name === "copilot")
+            return wanted(name) ? [format(copilotQuota())] : [];
+        return wanted(name) ? [format(noData(name, m("no builtin collector: use \"none\" or a command", "sem coletor embutido: use \"none\" ou um comando")))] : [];
+    });
+    return (await Promise.all(jobs)).flat();
+}

package/dist/roles.js

@@ -0,0 +1,28 @@
+/** What the conductor asks for (orq pick <role>) → the [roles] section that answers it. */
+export const PICK_ROLES = ["impl", "fix", "worker", "review", "opinion"];
+const SECTION = {
+    impl: ["primary"], fix: ["primary"], worker: ["workers", "primary"], review: ["reviewer"], opinion: ["opinion"],
+};
+/** The role name used in the old agents.<name>.roles lists. */
+export const legacyRole = (r) => (r === "worker" ? "impl" : r);
+/** Vendors of the built-in agents, so a config may leave `vendor` out. */
+export const BUILTIN_VENDORS = {
+    claude: "anthropic", codex: "openai", antigravity: "google", copilot: "github",
+};
+export const vendorOf = (name, a) => a?.vendor ?? BUILTIN_VENDORS[name];
+export function resolveRole(cfg, role) {
+    const agents = (cfg.agents ?? {});
+    const roles = (cfg.roles ?? {});
+    const policyRule = String((cfg.policy ?? {}).review ?? "other-vendor");
+    const section = SECTION[role].find((s) => roles[s]);
+    const r = section ? roles[section] : undefined;
+    const rule = String(r?.rule ?? policyRule);
+    if (r && typeof r.agent === "string")
+        return { mode: "fixed", order: [r.agent, ...(r.fallback ?? [])], rule, section: section };
+    if (r && Array.isArray(r.pool))
+        return { mode: "auto", pool: r.pool, rule, section };
+    const legacy = legacyRole(role);
+    const pool = Object.entries(agents).filter(([, a]) => (a.roles ?? []).includes(legacy))
+        .map(([n]) => n);
+    return { mode: "auto", pool, rule, section };
+}