@irythill/orq 0.3.0 → 0.5.0

package/dist/pick.js

@@ -1,4 +1,20 @@
+// Picks agent, model, effort and account for a role (port of orq-pick, plus fixed roles).
+//   fixed role: the first agent of [agent, ...fallback] that passes the filters wins — no scoring, never swapped
+//               for an agent the user didn't list.
+//   auto role:  every pool agent that passes is scored:
+//     quality * delivery + tokens * economy + speed * quickness − rotation * (picks in the last `window`)
+//     − reserve (agents with reserve = true) + explore (fewer than `min_samples` runs)
+// Filters: --exclude-agent, orq block, nobody reviews their own code (unless no other agent can), cross-vendor rule, a model for the role/level,
+// quota under the limits: policy.quota_week (95) on the weekly window, and on the 5h one policy.quota_5h per level
+// (simple 90, medium 85, heavy 80): a heavy task needs more room left to finish.
+// An agent's `headroom` (points) lowers both limits for it: that share of its accounts stays for the conductors.
+// An account whose quota reading says the login expired is skipped, with the fix command in the note.
+// Pacing: an account whose usage, at the pace so far in a window (used ÷ elapsed share), projects past
+// that window's pick limit (the filter's) at its reset is passed over for another account under the limit when the agent has several,
+// and otherwise loses policy.pacing_penalty (default 0.3, 0 = off) of score — soft, never a drop.
+import { agentDef, usesPrompt } from "./agents.js";
 import { m } from "./i18n.js";
+import { humanReset } from "./quota.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) {
@@ -17,12 +33,51 @@ export function parseQuota(text) {
     }
     return out;
 }
+/** The same lines → each window's %, plus its reset time (epoch seconds) when the line carries one. */
+export function parseWindows(text) {
+    const out = {};
+    const num = (v) => (v && /^\d+%$/.test(v) ? Number(v.slice(0, -1)) : undefined);
+    for (const l of text.split(/\r?\n/)) {
+        const r = /^(\S+) 5h=(\S+) week=(\S+)(?: reset5h=(\d+))?(?: resetweek=(\d+))?(?: span5h=(\d+))?(?: spanweek=(\d+))?/.exec(l.trim());
+        if (!r)
+            continue;
+        // "[login expired: run `agy models`; last reading, 5 min ago]" → the part before the first ";" (the fix to show)
+        const note = /\[([^\]]*)\]\s*$/.exec(l)?.[1].split(";")[0].trim();
+        out[r[1]] = { five: num(r[2]), week: num(r[3]), ...(r[4] ? { resetFive: Number(r[4]) } : {}),
+            ...(r[5] ? { resetWeek: Number(r[5]) } : {}), ...(r[6] ? { spanFive: Number(r[6]) } : {}),
+            ...(r[7] ? { spanWeek: Number(r[7]) } : {}), ...(note && EXPIRED.test(note) ? { expired: note } : note ? { note } : {}) };
+    }
+    return out;
+}
+// Both languages orq writes these notes in (the collectors' not-logged-in and expired-login texts).
+/** agy's idle-token note (collector text, both languages). */
+const IDLE = /token idle|token ocioso/i;
+const EXPIRED = /login expired|login expirado|not logged in|no agy login|sem login/i;
+/** Window lengths in seconds, unless the quota line publishes another (span5h/spanweek, minutes). */
+const WINDOW_S = { five: 5 * 3600, week: 7 * 86400 };
+/** Usage at the window's reset if the pace so far continues (used ÷ elapsed share); undefined when it can't be told:
+ *  no figure or reset time, or under 10% of the window elapsed (too early to project). */
+export function projected(pct, reset, size, now) {
+    if (pct === undefined || pct < 0 || reset === undefined)
+        return undefined;
+    const left = reset - now;
+    if (left <= 0 || left > size)
+        return undefined;
+    const elapsed = (size - left) / size;
+    return elapsed < 0.1 ? undefined : pct / elapsed;
+}
+const FIVE = { simple: 90, medium: 85, heavy: 80 };
+/** [5h limit, weekly limit] for a task level; an unknown level counts as medium. */
+export function limitsFor(pol, level) {
+    const five = { ...FIVE, ...(pol.quota_5h ?? {}) };
+    return [Math.min(Number(five[level] ?? five.medium), Number(pol.quota_limit ?? 90)), Number(pol.quota_week ?? 95)];
+}
 export function modelFor(a, role, level) {
     if (a.models === undefined)
         return ["", undefined]; // no models configured: the CLI's default
     const models = a.models;
     const lr = legacyRole(role);
-    const ms = models[lr] ?? (lr === "fix" ? models.impl : undefined) ?? {};
+    const ms = models[lr] ?? (lr === "fix" ? models.impl : lr === "watchdog" ? models.opinion ?? models.review : undefined) ?? {};
     const spec = ms[level] ?? ms.default ?? ms.medium ?? ms.simple;
     if (!spec)
         return undefined;
@@ -31,17 +86,31 @@ export function modelFor(a, role, level) {
 }
 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 ?? {}) });
+/** The merged definition (built-in + config) takes a prompt; an agent that can't be resolved doesn't. */
+function takesPrompt(cfg, name) {
+    try {
+        return usesPrompt(agentDef(cfg, name));
+    }
+    catch {
+        return false;
+    }
+}
 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 [base5, baseWeek] = limitsFor(pol, level);
     const w = weights(cfg);
+    const now = inp.now ?? Date.now() / 1000;
+    const penalty = Number(pol.pacing_penalty ?? 0.3);
     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 = [];
+    // Only with someone else to ask: a single agent must still be able to review.
+    const someoneElse = names.some((n) => n !== inp.implAgent && agents[n]);
+    const otherVendor = names.some((n) => n !== inp.implAgent && agents[n] && vendorOf(n, agents[n]) !== inp.implVendor);
     for (const name of names) {
         const a = agents[name];
         if (!a) {
@@ -56,32 +125,87 @@ export function pick(inp) {
             out(name, m("blocked (orq block -l)", "bloqueado (orq block -l)"));
             continue;
         }
-        if ((role === "review" || role === "opinion") && res.rule === "other-vendor" && inp.implVendor
+        if ((role === "review" || role === "opinion" || role === "watchdog") && name === inp.implAgent && someoneElse) {
+            out(name, m("it implemented this code", "foi quem implementou"));
+            continue;
+        }
+        if ((role === "review" || role === "opinion" || role === "watchdog") && res.rule === "other-vendor" && inp.implVendor && otherVendor
             && vendorOf(name, a) === inp.implVendor) {
             out(name, m("same vendor as the implementer", "mesmo fornecedor do implementador"));
             continue;
         }
+        if (role === "watchdog" && !takesPrompt(cfg, name)) {
+            out(name, m("ignores prompts (a review tool)", "ignora prompts (ferramenta de revisão)"));
+            continue;
+        }
         const mf = modelFor(a, role, level);
         if (!mf) {
             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.
+        // Quota: an agent with several accounts (claude) prefers one not projecting past the limit, then the least used.
         const qn = a.quota ?? [];
+        const headroom = Math.max(0, Number(a.headroom ?? 0));
+        const limit5 = base5 - headroom, limitWeek = baseWeek - headroom;
         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);
+        const fix = accs.map(([n]) => inp.windows?.[n]?.expired).filter((x) => Boolean(x));
+        if (accs.length && fix.length === accs.length) {
+            out(name, fix[0]);
+            continue;
+        }
+        // An idle agy token with nothing cached: the fix is one agy run, not a quota number.
+        const noRead = m("no reading yet: run `agy models` once", "sem leitura ainda: rode `agy models` uma vez");
+        const idleNoData = ([n, v]) => v === null && IDLE.test(inp.windows?.[n]?.note ?? "");
+        if (accs.length && accs.every(idleNoData)) {
+            out(name, noRead);
+            continue;
+        }
+        const under = ([n, v]) => {
+            const q = inp.windows?.[n];
+            return !q?.expired && v !== null && (q?.five ?? (q ? -1 : v)) < limit5 && (q?.week ?? (q ? -1 : v)) < limitWeek;
+        };
+        const usable = accs.filter(under);
         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(", ")})`);
+            const detail = accs.map(([n, v]) => {
+                const q = inp.windows?.[n], vn = v ?? -1;
+                if (q?.expired)
+                    return `${n}: ${q.expired}`;
+                if (idleNoData([n, v]))
+                    return `${n}: ${noRead}`;
+                const five = q?.five ?? (q ? -1 : vn), week = q?.week ?? (q ? -1 : vn);
+                const fiveOver = five >= limit5, weekOver = week >= limitWeek;
+                // The account is usable again only once every over-limit window has reset: the latest of their reset times.
+                // If one of them has no reset time, that time can't be promised at all.
+                const known = [fiveOver ? q?.resetFive : undefined, weekOver ? q?.resetWeek : undefined]
+                    .filter((t) => t !== undefined);
+                const allKnown = (fiveOver || weekOver) && (!fiveOver || q?.resetFive !== undefined) && (!weekOver || q?.resetWeek !== undefined);
+                return `${n}=${v}` + (q?.note ? ` (${q.note})` : "") + (allKnown ? ` (${m("back", "volta")} ${humanReset(Math.max(...known))})` : "");
+            }).join(", ");
+            out(name, `${m("quota", "cota")} >= 5h ${limit5}% / ${m("week", "semana")} ${limitWeek}% ${m("or no data", "ou sem dados")}`
+                + (headroom ? ` (headroom ${headroom})` : "") + ` (${detail})`);
             continue;
         }
-        const acct = accs.length > 1 ? [...usable].sort((x, y) => x[1] - y[1])[0][0] : undefined;
+        const paceOf = (n) => {
+            const q = inp.windows?.[n];
+            const p5 = projected(q?.five, q?.resetFive, (q?.spanFive ? q.spanFive * 60 : WINDOW_S.five), now);
+            const pw = projected(q?.week, q?.resetWeek, (q?.spanWeek ? q.spanWeek * 60 : WINDOW_S.week), now);
+            const paces = [p5, pw].filter((x) => x !== undefined);
+            // Hot: past the same per-window limit the filter uses (5h by level, week), headroom included, when pacing is on.
+            return { pace: paces.length ? Math.max(...paces) : undefined,
+                hot: penalty > 0 && ((p5 !== undefined && p5 > limit5) || (pw !== undefined && pw > limitWeek)) };
+        };
+        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 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 });
+        const stOf = (sr) => inp.stats.find((r) => r.role === sr && r.agent === name && r.model === (mf[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) });
         if (res.mode === "fixed")
             break; // the first that passes wins
     }
@@ -102,11 +226,13 @@ export function pick(inp) {
         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 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);
+            - (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} `
-            + (reserve ? m("reserve ", "reserva ") : "") + (few(c.st) ? `${m("few samples", "poucos dados")}(n=${n})` : `n=${n}`);
+            + (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}`);
         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

@@ -10,9 +10,12 @@
 //   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]".
+// Output line (read by orq-pick and the board): "<name> 5h=NN% week=NN% [reset5h=epoch] [resetweek=epoch] [note]".
 //   -  = the plan has no such window (not limiting);  ? = no data (expired login, collector failed).
+//   reset5h/resetweek (epoch seconds, optional) sit between the windows and the note: whichever window's reset time
+//   the collector could read, when it's known.
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir, userInfo } from "node:os";
 import { join } from "node:path";
@@ -22,21 +25,45 @@ 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}]` : ""}`;
+// 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.
+export const format = (q) => `${q.name} 5h=${show(q.five)} week=${show(q.week)}`
+    + (q.reset5h !== undefined ? ` reset5h=${q.reset5h}` : "") + (q.resetWeek !== undefined ? ` resetweek=${q.resetWeek}` : "")
+    + (q.span5h !== undefined ? ` span5h=${q.span5h}` : "") + (q.spanWeek !== undefined ? ` spanweek=${q.spanWeek}` : "")
+    + (q.note ? ` [${q.note}]` : "");
 const noData = (name, note) => ({ name, five: "?", week: "?", note });
+const WD = [["Sun", "dom"], ["Mon", "seg"], ["Tue", "ter"], ["Wed", "qua"], ["Thu", "qui"], ["Fri", "sex"], ["Sat", "sáb"]];
+/** A reset epoch (seconds) as "14:30" when it falls today, else weekday + time. */
+export function humanReset(epochSec, now = Date.now()) {
+    const d = new Date(epochSec * 1000), n = new Date(now);
+    const hhmm = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+    if (d.toDateString() === n.toDateString())
+        return hhmm;
+    const [en, pt] = WD[d.getDay()];
+    return `${m(en, pt)} ${hhmm}`;
+}
 const KEEP_MS = 5 * 3600_000;
 const cacheFile = (name) => join(stateDir(), "quota", `${name}.json`);
-function remember(name, five, week) {
+const resetOf = (w) => {
+    const t = w.resetsAt ? Date.parse(w.resetsAt) : NaN;
+    return Number.isNaN(t) ? undefined : Math.floor(t / 1000);
+};
+// `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) {
     try {
-        writeAtomic(cacheFile(name), JSON.stringify({ five, week, at: Date.now() }));
+        writeAtomic(cacheFile(name), JSON.stringify({ five, week, at: Date.now(), ...(acct ? { acct } : {}) }));
     }
     catch { /* best effort */ }
-    return { name, five: five.pct, week: week.pct };
+    const r5 = resetOf(five), rw = resetOf(week);
+    return { name, five: five.pct, week: week.pct, ...(r5 !== undefined ? { reset5h: r5 } : {}), ...(rw !== undefined ? { resetWeek: rw } : {}) };
 }
 /** 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()) {
+export function fromCache(name, why, now = Date.now(), acct) {
     try {
         const c = JSON.parse(readFileSync(cacheFile(name), "utf8"));
+        if (acct !== undefined && c.acct !== acct)
+            return noData(name, why); // another login's reading
         const still = (w) => {
             if (w.resetsAt) {
                 const t = Date.parse(w.resetsAt);
@@ -48,7 +75,10 @@ export function fromCache(name, why, now = Date.now()) {
         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`) };
+            const r5 = resetOf(c.five), rw = resetOf(c.week);
+            return { name, five, week, ...(r5 !== undefined && r5 * 1000 > now ? { reset5h: r5 } : {}),
+                ...(rw !== undefined && rw * 1000 > now ? { resetWeek: rw } : {}),
+                note: `${why}; ` + m(`last reading, ${min} min ago`, `última leitura, há ${min} min`) };
         }
     }
     catch { /* no cache */ }
@@ -143,10 +173,14 @@ export function codexFromSession(text, nowSec) {
         return undefined;
     const ws = [last.primary, last.secondary].filter((w) => !!w);
     const pct = (w) => !w ? "-" : (w.resets_at ?? 0) < nowSec ? 0 : Math.floor(w.used_percent ?? 0);
+    const reset = (w) => w?.resets_at !== undefined && w.resets_at >= nowSec ? w.resets_at : undefined;
     const short = ws.find((x) => (x.window_minutes ?? 0) <= 360);
     const long = ws.filter((x) => (x.window_minutes ?? 0) > 360).sort((a, b) => b.window_minutes - a.window_minutes)[0];
     const span = long && long.window_minutes !== 10080 ? long.window_minutes : undefined;
-    return { five: pct(short), week: pct(long), ...(span ? { span } : {}) };
+    const r5 = reset(short), rw = reset(long);
+    const span5 = short && short.window_minutes && short.window_minutes !== 300 ? short.window_minutes : undefined;
+    return { five: pct(short), week: pct(long), ...(span ? { span } : {}), ...(span5 ? { span5 } : {}), ...(r5 !== undefined ? { reset5h: r5 } : {}),
+        ...(rw !== undefined ? { resetWeek: rw } : {}) };
 }
 export function codexQuota() {
     const f = latestCodexSession();
@@ -156,9 +190,9 @@ export function codexQuota() {
     if (!q)
         return noData("codex", m("no limit data", "sem dados de limite"));
     const age = Math.round((Date.now() - statSync(f).mtimeMs) / 60_000);
-    const { span, ...pcts } = q;
+    const { span, span5, ...pcts } = q;
     const d = span && Math.round(span / 1440);
-    return { name: "codex", ...pcts, note: (d ? m(`${d}-day window in the week slot; `, `janela de ${d} dias no lugar da semana; `) : "")
+    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. */
@@ -179,7 +213,7 @@ export function antigravityFromModels(models, now = Date.now()) {
     }
     return { five, week };
 }
-function agyToken() {
+export 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");
@@ -187,21 +221,34 @@ function agyToken() {
         return undefined;
     try {
         const t = JSON.parse(raw).token;
-        return { access: t?.access_token, expiry: t?.expiry };
+        // The refresh token is stable for a login and differs between accounts (the access token rotates hourly).
+        const id = t?.refresh_token ?? t?.id_token;
+        return { access: t?.access_token, expiry: t?.expiry, refresh: !!t?.refresh_token,
+            ...(id ? { acct: createHash("sha256").update(String(id)).digest("hex").slice(0, 16) } : {}) };
     }
     catch {
         return undefined;
     }
 }
+/** Why the stored agy token can't be used as is: idle (expired, agy renews it on its next run) or login expired (no refresh token). */
+export function agyNote(t, now = Date.now()) {
+    const at = t.expiry ? Date.parse(t.expiry) : NaN;
+    if (Number.isNaN(at) || at >= now)
+        return undefined;
+    return t.refresh ? m("token idle (agy refreshes on next run)", "token ocioso (o agy renova no próximo uso)")
+        : m("login expired: run `agy models`", "login expirado: rode `agy models`");
+}
 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).
+    // 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`");
-    if (t.expiry && Date.parse(t.expiry) < Date.now())
-        return fromCache(name, expired);
+    const note = agyNote(t);
+    if (note)
+        return fromCache(name, note, undefined, t.acct);
     try {
         const r = await fetch("https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels", {
             method: "POST", body: "{}",
@@ -210,30 +257,45 @@ export async function antigravityQuota() {
             signal: AbortSignal.timeout(15_000),
         });
         if (r.status === 401)
-            return fromCache(name, expired);
+            return fromCache(name, expired, undefined, t.acct);
         if (!r.ok)
-            return fromCache(name, `HTTP ${r.status}`);
+            return fromCache(name, `HTTP ${r.status}`, undefined, t.acct);
         const j = await r.json();
         const { five, week } = antigravityFromModels(j.models ?? {});
-        return remember(name, five, week);
+        return remember(name, five, week, t.acct);
     }
     catch (e) {
-        return fromCache(name, m("collector failed", "coletor falhou") + `: ${e.message}`);
+        return fromCache(name, m("collector failed", "coletor falhou") + `: ${e.message}`, undefined, t.acct);
     }
 }
 // --- copilot --------------------------------------------------------------------------------------------------------
+/** The same moment one calendar month earlier; a day the month lacks (31 Mar → Feb) clamps to its last day. */
+export function monthBefore(d) {
+    const out = new Date(d);
+    out.setDate(1);
+    out.setMonth(out.getMonth() - 1);
+    out.setDate(Math.min(d.getDate(), new Date(out.getFullYear(), out.getMonth() + 1, 0).getDate()));
+    return out;
+}
 /** 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"));
+    // A bare date ("2026-11-01") would parse as UTC midnight: local midnight matches the date the note itself shows
+    // (same fix as parseLocal in commands/block.ts).
+    const at = u.quota_reset_date
+        ? Date.parse(/^\d{4}-\d{2}-\d{2}$/.test(u.quota_reset_date) ? `${u.quota_reset_date}T00:00` : u.quota_reset_date)
+        : NaN;
+    const prev = Number.isNaN(at) ? new Date(NaN) : monthBefore(new Date(at));
+    const resetWeek = Number.isNaN(at) ? {} : { resetWeek: Math.floor(at / 1000), spanWeek: Math.round((at - prev.getTime()) / 60_000) };
     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),
+    return { name: "copilot", five: "-", week: Math.max(0, 100 - p.percent_remaining), ...resetWeek,
         note: m("monthly premium requests", "requisições premium do mês") + reset };
 }
 export function copilotQuota() {
@@ -266,7 +328,7 @@ export function minimaxFromRemains(j) {
     return { five: worst("current_interval_remaining_percent", "end_time"),
         week: worst("current_weekly_remaining_percent", "weekly_end_time") };
 }
-function minimaxKey() {
+export function minimaxKey() {
     if (process.env.MINIMAX_API_KEY)
         return process.env.MINIMAX_API_KEY;
     const data = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");

package/dist/roles.js

@@ -1,7 +1,7 @@
 /** What the conductor asks for (orq pick <role>) → the [roles] section that answers it. */
-export const PICK_ROLES = ["impl", "fix", "worker", "review", "opinion"];
+export const PICK_ROLES = ["impl", "fix", "worker", "review", "opinion", "watchdog"];
 const SECTION = {
-    impl: ["primary"], fix: ["primary"], worker: ["workers", "primary"], review: ["reviewer"], opinion: ["opinion"],
+    impl: ["primary"], fix: ["primary"], worker: ["workers", "primary"], review: ["reviewer"], opinion: ["opinion"], watchdog: ["watchdog"],
 };
 /** The role name used in the old agents.<name>.roles lists. */
 export const legacyRole = (r) => (r === "worker" ? "impl" : r);
@@ -10,7 +10,16 @@ export const BUILTIN_VENDORS = {
     claude: "anthropic", codex: "openai", antigravity: "google", copilot: "github",
 };
 export const vendorOf = (name, a) => a?.vendor ?? BUILTIN_VENDORS[name];
+const count = (r) => (r.mode === "fixed" ? r.order : r.pool).length;
+/** The watchdog (orq rounds --diagnose) uses its own role when something declares it, else the opinion pool, else the review one. */
 export function resolveRole(cfg, role) {
+    const own = direct(cfg, role);
+    if (role !== "watchdog" || count(own))
+        return own;
+    const op = direct(cfg, "opinion");
+    return count(op) ? op : direct(cfg, "review");
+}
+function direct(cfg, role) {
     const agents = (cfg.agents ?? {});
     const roles = (cfg.roles ?? {});
     const policyRule = String((cfg.policy ?? {}).review ?? "other-vendor");

package/dist/rounds.js

@@ -0,0 +1,176 @@
+// Watchdog layer 1: per-issue round metrics from the files already in .orquestra/<ID>/, no LLM and no extra recording.
+//   fix-<n>.md                    the blockers sent to the implementer in fix round n (its mtime = the round started)
+//   review-<repo>.out.md          the first review (round 0);  review-<repo>-<n>.out.md  the review after fix round n
+// Rounds = highest fix-<n> (or the .rounds-<session> counter `orq agent -R` keeps). Findings are the tagged list items
+// of each review ("- [blocker] src/a.ts:10 title", or a leading bold severity word in PT/EN: "1. **Bloqueante** — ...",
+// "- **Sugestão — `a.ts:7–8`:** ..."; "**Critério 1**" is not one). Files may be markdown links; a ".worktrees/<dir>/" prefix is
+// stripped so a file matches across rounds. A finding "repeats" when a later review has one on the same file
+// with similar words (token overlap, see similar()).
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+export const SIMILAR_FILE = 0.4; // token overlap needed when both findings name the same file
+export const SIMILAR_LOOSE = 0.6; // ... when a file is missing on either side
+export const SLOW_FACTOR = 2; // a round this many times slower than the median of the others is flagged
+export const SLOW_MIN_SECS = 600; // ... but only if it also took at least this long
+export const REPEAT_WARN = 2; // a finding seen in this many reviews: warn
+export const REPEAT_STOP = 3; // ... in this many: stop (it came back after two fix rounds)
+export const HEAVY = new Set(["blocker", "major", "critical"]); // only these count towards repeats and the alert
+const read = (f) => { try {
+    return readFileSync(f, "utf8");
+}
+catch {
+    return "";
+} };
+const STOP = new Set(["the", "a", "an", "of", "in", "on", "to", "is", "are", "and", "or", "for", "with", "not", "no", "this", "that", "it",
+    "de", "do", "da", "o", "os", "as", "um", "uma", "em", "no", "na", "para", "com", "que", "se", "não"]);
+const words = (s) => new Set(s.toLowerCase().replace(/[^\p{L}\p{N}_]+/gu, " ").split(" ").filter((w) => w.length > 2 && !STOP.has(w)));
+const SEV = {
+    bloqueante: "blocker", bloqueador: "blocker", blocker: "blocker", critico: "critical", critical: "critical",
+    importante: "major", important: "major", major: "major", menor: "minor", minor: "minor",
+    sugestao: "suggestion", suggestion: "suggestion", nit: "nit",
+};
+const fold = (w) => w.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase();
+const URL = /^[a-z][a-z0-9+.-]*:\/\//i;
+// GitHub-style ".../blob/<ref>/<path>" → "<path>" (no query, no #L4), so URL mentions match plain-path mentions.
+const blobPath = (u) => /^[a-z][a-z0-9+.-]*:\/\/[^/]+\/[^/]+\/[^/]+\/blob\/[^/]+\/([^#?\s)]+)/i.exec(u)?.[1];
+const LINK = /\[([^\]]*)\]\(([^)\s]*)\)/g;
+// Reviews run in a different worktree per round (".worktrees/<repo>-<id>.review-<pid>/"): drop it so the same file matches across rounds.
+const repoRel = (f) => f.replace(/\\/g, "/").replace(/^.*\.worktrees\/[^/]+\//, "");
+/** One review-list item → finding. Only items carrying a severity (a "[blocker]" tag or a leading bold "**Bloqueante**") count. */
+export function parseFindings(text, round) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        const it = /^\s*(?:[-*+]|\d+[.)])\s+(.*)$/.exec(line);
+        if (!it)
+            continue;
+        const sevOf = (w) => { const k = fold(w ?? ""); return Object.hasOwn(SEV, k) ? SEV[k] : undefined; };
+        let m0 = /^\*\*\s*(\p{L}+)/u.exec(it[1]); // a leading bold severity wins over a [tag]
+        if (!sevOf(m0?.[1]))
+            m0 = /\[(blocker|major|minor|nit|suggestion|important|critical)\]/i.exec(it[1]);
+        const sev = sevOf(m0?.[1]);
+        if (!m0 || !sev)
+            continue;
+        const rest = it[1].replace(m0[0], " ");
+        const byTarget = rest.replace(LINK, (_, t, p) => ` ${URL.test(p) ? blobPath(p) ?? t : repoRel(p)} `)
+            .replace(/[a-z][a-z0-9+.-]*:\/\/\S+/gi, (u) => ` ${blobPath(u) ?? ""} `);
+        const m = /([\w@./\\-]+\.\w+)(?::\d+(?:[-\u2013]\d+)?)?/.exec(byTarget);
+        const file = m ? repoRel(m[1]) : "";
+        out.push({ round, severity: sev, file, title: rest.replace(LINK, "$1").replace(/[`*_]/g, "").replace(/\s+/g, " ").trim() });
+    }
+    return out;
+}
+/** Same finding? Same file (when both name one) and enough shared words; without a file, a stricter overlap. */
+export function similar(a, b) {
+    const wa = words(a.title), wb = words(b.title);
+    if (!wa.size || !wb.size)
+        return false;
+    let inter = 0;
+    for (const w of wa)
+        if (wb.has(w))
+            inter++;
+    const j = inter / (wa.size + wb.size - inter), both = a.file && b.file;
+    if (both && a.file !== b.file)
+        return false;
+    return j >= (both ? SIMILAR_FILE : SIMILAR_LOOSE);
+}
+/** Findings that reappear in more than one round. Each group is matched against its first member. */
+export function repeats(fs) {
+    const groups = [];
+    for (const f of [...fs].sort((a, b) => a.round - b.round)) {
+        const g = groups.find((x) => similar(x[0], f));
+        if (g)
+            g.push(f);
+        else
+            groups.push([f]);
+    }
+    return groups.map((g) => ({ file: g[0].file, title: g[0].title, rounds: [...new Set(g.map((x) => x.round))] }))
+        .filter((r) => r.rounds.length >= REPEAT_WARN);
+}
+const median = (xs) => { const s = [...xs].sort((a, b) => a - b), h = s.length >> 1; return s.length % 2 ? s[h] : (s[h - 1] + s[h]) / 2; };
+/** Fix rounds far above the median of the other fix rounds (round 0 is the implementation: never compared; needs 3 fix rounds). */
+export function slowRounds(all) {
+    const per = all.filter((r) => r.round > 0);
+    if (per.length < 3)
+        return [];
+    return per.filter((r) => r.secs >= SLOW_MIN_SECS && r.secs > SLOW_FACTOR * median(per.filter((x) => x !== r).map((x) => x.secs))).map((r) => r.round);
+}
+/** The pure part: facts from the files → numbers, alert level and why. */
+export function metrics(issue, f) {
+    const reps = repeats(f.findings.filter((x) => HEAVY.has(x.severity))), reasons = [];
+    let level = "ok";
+    const raise = (l, why) => { reasons.push(why); if (l === "stop" || level === "ok")
+        level = l; };
+    if (f.rounds > f.max)
+        raise("stop", { code: "over_max", n: f.rounds, max: f.max });
+    else if (f.rounds >= f.max && f.max > 0)
+        raise("warn", { code: "at_max", n: f.rounds, max: f.max });
+    const worst = Math.max(0, ...reps.map((r) => r.rounds.length));
+    if (worst >= REPEAT_STOP)
+        raise("stop", { code: "same_finding", n: worst });
+    else if (reps.length)
+        raise("warn", { code: "repeated", n: reps.length });
+    const slow = slowRounds(f.perRound);
+    if (slow.length)
+        raise("warn", { code: "slow", n: slow.length, rounds: slow });
+    return { issue, rounds: f.rounds, max: f.max, secs: f.secs, perRound: f.perRound, findings: f.findings.length, repeats: reps, level, reasons };
+}
+/** Rounds of an issue folder: the highest .rounds-<session> counter or fix-<n>.md. Shared by `orq rounds` and the -F gate. */
+export function countRounds(dir, names) {
+    let n = 0;
+    for (const f of names) {
+        const fx = /^fix-(\d+)\.md$/.exec(f);
+        if (fx)
+            n = Math.max(n, Number(fx[1]));
+        else if (f.startsWith(".rounds-"))
+            n = Math.max(n, Number(read(join(dir, f))) || 0);
+    }
+    return n;
+}
+/** The impure part: read .orquestra/<issue>/. undefined when the issue has no fix or review files at all. */
+export function collectRounds(ws, issue, max) {
+    const dir = join(ws, ".orquestra", issue);
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return undefined;
+    }
+    const mt = (n) => statSync(join(dir, n)).mtimeMs;
+    const fixes = new Map(), reviews = new Map();
+    for (const n of names) {
+        const fx = /^fix-(\d+)\.md$/.exec(n);
+        if (fx)
+            fixes.set(Number(fx[1]), mt(n));
+    }
+    for (const n of names) {
+        // A trailing -<n> is a round only when fix-<n>.md exists; otherwise it is part of the repo name (round 0).
+        const rv = /^review-(.+?)(?:-(\d+))?\.out\.md$/.exec(n), k = rv && rv[2] !== undefined && fixes.has(Number(rv[2])) ? Number(rv[2]) : 0;
+        if (rv)
+            reviews.set(k, [...(reviews.get(k) ?? []), n]);
+    }
+    if (!reviews.size && !fixes.size)
+        return undefined;
+    const rounds = countRounds(dir, names);
+    const all = names.filter((n) => !n.startsWith(".") && !/^(diagnosis|watchdog)-/.test(n)).map(mt), t0 = Math.min(...all), t1 = Math.max(...all);
+    // Round k runs from fix-k.md (round 0: the oldest file) to the next fix, the last one to the newest file.
+    const starts = [t0, ...Array.from({ length: rounds }, (_, i) => fixes.get(i + 1) ?? NaN)];
+    const perRound = starts.map((s, k) => {
+        const next = k < rounds ? starts[k + 1] : t1;
+        return { round: k, secs: Number.isNaN(s) || Number.isNaN(next) ? 0 : Math.max(0, Math.round((next - s) / 1000)) };
+    });
+    const findings = [...reviews].flatMap(([k, fs]) => fs.flatMap((n) => parseFindings(read(join(dir, n)), k)));
+    return metrics(issue, { rounds, max, perRound, findings, secs: Math.round((t1 - t0) / 1000) });
+}
+/** Cheap change signature of an issue folder (names + mtimes, no reads) for caching collectRounds between redraws. */
+export function roundsSig(ws, issue) {
+    const dir = join(ws, ".orquestra", issue);
+    try {
+        return readdirSync(dir).filter((n) => /^(fix-\d+\.md|review-.+\.out\.md|\.rounds-.+)$/.test(n)).map((n) => `${n}:${statSync(join(dir, n)).mtimeMs}`).join("|");
+    }
+    catch {
+        return "";
+    }
+}
+/** Board marker: "r2/2 ⚠", "r3/2 ✗"; just "r1/2" when ok. */
+export const mark = (x) => `r${x.rounds}/${x.max}${x.level === "warn" ? " ⚠" : x.level === "stop" ? " ✗" : ""}`;