@irythill/orq 0.3.0 → 0.5.0

package/dist/commands/agent.js

@@ -2,7 +2,7 @@
 // under its memory cap (src/process.ts), in a herdr tab, a tmux window or the background (src/terminal.ts).
 // Writes <prefix>.out.md (final answer) / .log / .id (session, for -R) / .pane / .done ("status=ok|fail rc=N at=...").
 // Returns at once; `orq wait <prefix>` blocks until .done. A conductor in herdr (HERDR_PANE_ID) also gets ONE line
-// "[HERDR-AGENT DONE] <title> status=... answer: <prefix>.out.md" typed into its pane by herdr-notify.
+// "[HERDR-AGENT DONE] <title> status=... answer: <prefix>.out.md" typed into its pane by src/notice.ts.
 // The launcher writes <prefix>.job.json and starts `orq agent --run <job>` on the terminal host; that runner does the rest.
 // -T (or machine.tui / HERDR_AGENT_TUI=1): the agent's own screen (its `tui` template) in a herdr tab or tmux window,
 // same cap and files. The agent calls `orq agent --turn <job> <kind>` at every end of turn, which writes .out.md/.id/
@@ -14,16 +14,18 @@ import { appendFileSync, copyFileSync, createWriteStream, existsSync, mkdirSync,
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { claudeAccounts } from "../accounts.js";
-import { agentDef, ALIASES, expandString, expandTemplate, FORMATS } from "../agents.js";
-import { loadConfig } from "../config.js";
+import { gateFor } from "../diagnose.js";
+import { argvModel, useThrowaway, agentDef, ALIASES, expandString, expandTemplate, FORMATS } from "../agents.js";
+import { getPath, loadConfig } from "../config.js";
 import { writeAtomic } from "../fsutil.js";
 import { m } from "../i18n.js";
 import { alive } from "../lock.js";
 import { stateDir } from "../paths.js";
 import { killTree, parseSize, resolveMode, runCapped } from "../process.js";
 import { closeOwnTab, detectHost, launch, screenOpen, shq, typeInto } from "../terminal.js";
+import { ackPrefix } from "../notice.js";
 import { dropWorktree, notify } from "../testrun.js";
-export const USAGE = "orq agent -a <agent> -t <title> -d <dir> -o <prefix> [-g group] [-m model] [-e effort] [-c account] [-i file]... [-b base] [-r] [-R session] [-T] -- <prompt.md>   run a child agent";
+export const USAGE = "orq agent -a <agent> -t <title> -d <dir> -o <prefix> [-g group] [-m model] [-e effort] [-c account] [-i file]... [-b base] [-r] [-R session [-F [-F]]] [-T] -- <prompt.md>   run a child agent";
 const CLI = fileURLToPath(new URL("../cli.js", import.meta.url));
 const PF = ".herdr-agent-prompt.md"; // prompt_in_dir file name (kept from herdr-agent)
 const git = (dir, ...a) => {
@@ -35,8 +37,8 @@ export async function agent(argv) {
         return runJob(argv[1]);
     if (argv[0] === "--turn")
         return turn(argv[1], argv[2], argv.slice(3));
-    let a = process.env.AGENT || "codex", g = "", t = "", d = "", o = "", model = "", effort = "", acc = "", resume = "", base = "";
-    let ro = false, tui = false, prompt;
+    let a = process.env.AGENT || "", g = "", t = "", d = "", o = "", model = "", effort = "", acc = "", resume = "", base = "";
+    let ro = false, tui = false, force = 0, prompt;
     const inc = [];
     for (let i = 0; i < argv.length; i++) {
         const x = argv[i], v = () => argv[++i] ?? "";
@@ -72,6 +74,8 @@ export async function agent(argv) {
             ro = true;
         else if (x === "-T")
             tui = true;
+        else if (x === "-F")
+            force++;
         else if (!x.startsWith("-") && prompt === undefined)
             prompt = x;
         else {
@@ -88,6 +92,11 @@ export async function agent(argv) {
             console.error(`${m("missing", "faltou")} -${f}`);
             return 2;
         }
+    // No default agent: an empty $(orq pick ...) means no candidate, and must not start anything.
+    if (!a) {
+        console.error(m("missing -a (if it came from orq pick, it found no candidate): nothing started", "faltou -a (se veio do orq pick, ele não achou candidato): nada foi iniciado"));
+        return 2;
+    }
     a = ALIASES[a] ?? a;
     const { cfg } = loadConfig();
     const def = agentDef(cfg, a);
@@ -121,6 +130,31 @@ export async function agent(argv) {
         return 2;
     }
     const repo = resolve(d), O = resolve(o);
+    // Fix rounds: every -R on the same session counts, whatever the prefix is called. policy.max_rounds is enforced here,
+    // not left to the conductor to remember (a 7-round fix loop is what burns the tokens). -F = the user said go on.
+    if (resume) {
+        const max = Number(getPath(cfg, "policy.max_rounds") ?? 2), cf = join(dirname(O), `.rounds-${resume}`);
+        let n = 0;
+        try {
+            n = Number(readFileSync(cf, "utf8")) || 0;
+        }
+        catch { /* first follow-up */ }
+        if (n >= max && !force) {
+            console.error(m(`round limit: session ${resume} already had ${n} follow-up(s) (policy.max_rounds = ${max}). Stop and tell the user; with their OK, run \`orq rounds <ID> --diagnose\`, then repeat with -F.`, `limite de rodadas: a sessão ${resume} já teve ${n} follow-up(s) (policy.max_rounds = ${max}). Pare e avise o usuário; com o OK dele, rode \`orq rounds <ID> --diagnose\` e repita com -F.`));
+            return 4;
+        }
+        // -F past the limit also needs the watchdog's diagnosis of this round count (-F -F skips it: the user's own call).
+        // The issue folder is the prefix's folder, .orquestra/<ID>/ (where the .rounds-<session> counter lives).
+        if (n >= max && force === 1 && basename(dirname(dirname(O))) === ".orquestra") {
+            const g = gateFor(dirname(O)), id = basename(dirname(O));
+            if (g.verdict !== "ok") {
+                console.error(m(`no current diagnosis: ${g.verdict === "stale" ? `diagnosis-${g.rounds}.md is older than the latest fix/review` : `diagnosis-${g.rounds}.md does not exist`}. Run \`orq rounds ${id} --diagnose\` first, read it, and ask the user. -F -F skips this check.`, `sem diagnóstico atual: ${g.verdict === "stale" ? `diagnosis-${g.rounds}.md é mais antigo que o último fix/revisão` : `diagnosis-${g.rounds}.md não existe`}. Rode \`orq rounds ${id} --diagnose\` antes, leia e consulte o usuário. -F -F pula esta checagem.`));
+                return 4;
+            }
+        }
+        mkdirSync(dirname(O), { recursive: true });
+        writeFileSync(cf, String(n + 1));
+    }
     let P = resolve(prompt);
     if (!existsSync(repo)) {
         console.error(m(`no folder ${repo}`, `pasta ${repo} não existe`));
@@ -158,6 +192,7 @@ export async function agent(argv) {
     }
     catch { /* first run or ended */ }
     if (tui && resume && alive(pid) && screenOpen(open)) {
+        ackPrefix(O); // a follow-up on the issue: its failure notices were seen
         for (const s of [".done", ".out.md"])
             rmSync(O + s, { force: true });
         typeInto(open, readFileSync(P, "utf8"));
@@ -166,7 +201,7 @@ export async function agent(argv) {
     }
     for (const s of [".done", ".out.md", ".pid"])
         rmSync(O + s, { force: true });
-    const throwaway = Boolean(def.throwaway && ro && !resume);
+    const throwaway = useThrowaway(def, ro, Boolean(resume), git(repo, "rev-parse", "--git-dir") !== undefined);
     const dir = throwaway ? `${repo}.review-${process.pid}` : repo;
     const gd = git(repo, "rev-parse", "--path-format=absolute", "--git-common-dir");
     const wg = git(repo, "rev-parse", "--absolute-git-dir");
@@ -199,7 +234,7 @@ export async function agent(argv) {
     const vars = {
         prompt: P, prompt_text: tpl.includes("{prompt_text}") ? readFileSync(P, "utf8") : "",
         prompt_hint: `Read the file ${PF} (in the current folder, with your file-reading tool): it holds your complete instructions for this task. Follow them. ${PF} is not part of the code: don't review or edit it.`,
-        out: `${O}.out.md`, dir, repo, title: t, model: model === "auto" ? "" : model, effort, session,
+        out: `${O}.out.md`, dir, repo, base, title: t, model: model === "auto" ? "" : model, effort, session,
         gitdir: gd ?? "", gitroots: roots, gitroots_json: JSON.stringify(roots), mode: [], opencode_config: JSON.stringify(ocCfg),
         hook_cmd: hook.map(shq).join(" "), hook_json: JSON.stringify(hook),
         hook_settings: JSON.stringify({ hooks: { Stop: [{ hooks: [{ type: "command", command: hook.map(shq).join(" ") }] }] } }),
@@ -229,11 +264,13 @@ export async function agent(argv) {
         swap: parseSize(mach.agent_swap_max), mode: mach.mem_enforce ?? "auto",
         throwaway, promptInDir: Boolean(def.prompt_in_dir), closeAfter,
         keep: process.env.HERDR_KEEP_TAB === "1" || process.env.ORQ_KEEP_TAB === "1" || closeAfter <= 0, tui,
+        okExit: def.ok_exit, filter: def.filter, noReview: def.no_review,
     };
     writeAtomic(`${O}.job.json`, JSON.stringify(job, null, 1));
     // Readable copy of the command (also what orq stats and herdr-board read).
     writeFileSync(`${O}.run.sh`, `#!/usr/bin/env bash\n# orq agent (generated; the run itself is \`orq agent --run ${O}.job.json\`) --unit=${unit} \n` +
         `cd ${shq(dir)}\n${Object.entries(env).map(([k, val]) => `${k}=${shq(val)} `).join("")}${cmd.map(shq).join(" ")}${job.stdin ? ` < ${shq(P)}` : ""}\n`);
+    ackPrefix(O); // starting work on the issue again: its failure notices were seen
     const where = launch(host, { group: g || "agents", title: t, dir: repo, argv: [process.execPath, CLI, "agent", "--run", `${O}.job.json`], id: unit, keep: job.keep });
     writeFileSync(`${O}.pane`, `${where}\n`);
     console.log(`[orq agent] ${t} → ${where}${tui ? " (TUI)" : ""}`);
@@ -303,10 +340,11 @@ function turn(file, kind, rest) {
         writeFileSync(`${O}.out.md`, answer);
         if (sid)
             writeFileSync(`${O}.id`, `${sid}\n`);
-        const st = /\S/.test(answer) ? "ok" : "fail";
+        const noReview = noReviewMatch(j.noReview, answer);
+        const st = /\S/.test(answer) && !noReview ? "ok" : "fail";
         writeAtomic(`${O}.done`, `status=${st} rc=0 at=${new Date().toISOString()} agent=${j.agent} mode=tui\n`);
         if (j.parent)
-            notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=${st} rc=0 answer: ${O}.out.md`, true);
+            notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=${st} rc=0 answer: ${O}.out.md`);
     }
     catch (e) {
         console.error(`orq agent --turn: ${e.message}`);
@@ -332,6 +370,27 @@ function lastClaudeText(transcript) {
     catch { /* no transcript */ }
     return text;
 }
+/** agents.<name>.no_review tested against the start of the answer (first line) or, for a short answer, the whole
+ *  thing — not anywhere in a long one, so a review that quotes the phrase while discussing real code doesn't match.
+ *  An invalid pattern is logged and ignored rather than killing the runner. */
+function noReviewMatch(pattern, answer) {
+    if (pattern === undefined)
+        return false;
+    if (typeof pattern !== "string" || !pattern.trim()) {
+        console.error(`orq agent: ignoring invalid agents.<name>.no_review ${JSON.stringify(pattern)}: expected a non-empty regex string`);
+        return false;
+    }
+    let re;
+    try {
+        re = new RegExp(pattern, "m");
+    }
+    catch (e) {
+        console.error(`orq agent: ignoring invalid agents.<name>.no_review pattern ${JSON.stringify(pattern)}: ${e.message}`);
+        return false;
+    }
+    const first = answer.split(/\r?\n/, 1)[0] ?? "";
+    return re.test(first) || (answer.trim().length <= 200 && re.test(answer));
+}
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /** Splits a stream into lines for `each`. */
 function lines(s, each) {
@@ -355,7 +414,7 @@ async function runJob(file) {
     const stateF = join(stateDir(), "agents", `${j.unit}.json`);
     const at = new Date().toISOString();
     const state = (extra = {}) => { try {
-        writeAtomic(stateF, JSON.stringify({ pid: process.pid, prefix: O, title: j.title, agent: j.agent, host: j.host, cap: j.cap, at, ...extra }));
+        writeAtomic(stateF, JSON.stringify({ pid: process.pid, prefix: O, title: j.title, agent: j.agent, model: argvModel(j.argv), host: j.host, cap: j.cap, at, ...extra }));
     }
     catch { /* best effort */ } };
     state();
@@ -408,7 +467,7 @@ async function runJob(file) {
             if (!existsSync(`${O}.done`)) {
                 writeAtomic(`${O}.done`, `status=fail rc=${code} at=${new Date().toISOString()} agent=${j.agent} mode=tui\n`);
                 if (j.parent)
-                    notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=fail rc=${code} answer: ${O}.out.md`, true);
+                    notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=fail rc=${code} answer: ${O}.out.md`);
             }
             rmSync(`${O}.pid`, { force: true });
             return ok ? "ok" : "fail";
@@ -500,12 +559,26 @@ async function runJob(file) {
         writeFileSync(`${O}.id`, `${sid}\n`);
     if (rc === 0 && res.rc)
         rc = res.rc;
+    // A review tool exits non-zero on findings: an ok_exit code is a verdict (rc stays in .done), not a failure.
+    let verdict = rc === 0 || (j.okExit ?? []).includes(rc);
+    if (j.filter && verdict) {
+        const f = spawnSync("sh", ["-c", j.filter], { cwd: j.dir, input: readFileSync(`${O}.out.md`, "utf8"), encoding: "utf8", maxBuffer: 1 << 30 });
+        if (f.status === 0)
+            writeFileSync(`${O}.out.md`, f.stdout);
+        else {
+            appendFileSync(`${O}.log`, `[orq agent] filter failed (exit ${f.status}): ${f.stderr}\n`);
+            verdict = false;
+        }
+    }
     let answer = "";
     try {
         answer = readFileSync(`${O}.out.md`, "utf8");
     }
     catch { /* none */ }
-    const st = rc === 0 && /\S/.test(answer) ? "ok" : "fail"; // whitespace-only answer = failure
+    // A reviewer whose answer says nothing was reviewed (agents.<name>.no_review) is not a verdict either: pick's
+    // fallback and the conductor must see it as not run, same as a whitespace-only answer.
+    const noReview = noReviewMatch(j.noReview, answer);
+    const st = verdict && !noReview && /\S/.test(answer) ? "ok" : "fail"; // whitespace-only answer = failure
     writeAtomic(`${O}.done`, `status=${st} rc=${rc} at=${new Date().toISOString()} agent=${j.agent}\n`);
     rmSync(`${O}.pid`, { force: true });
     state({ status: st, rc, end: new Date().toISOString() });

package/dist/commands/block.js

@@ -1,12 +1,16 @@
 // orq block — takes an agent (or account) out of orq-pick until a date. For quotas without a collector
 // (Antigravity, Copilot, MiniMax) or any outage you know about before the agent fails.
-// State in <state dir>/blocks.json ({name: {until: <epoch seconds>, reason}}), shared with orq-pick.
+// State in <state dir>/blocks.json ({name: {until: <epoch seconds>, reason, acct}}), shared with orq-pick. `acct` is the
+// login at block time (src/identity.ts): if the agent/account is logged into another one later, the block is dropped.
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { writeAtomic } from "../fsutil.js";
+import { loginId } from "../identity.js";
 import { m } from "../i18n.js";
 import { stateDir } from "../paths.js";
-export const USAGE = `orq block <agent|account> [--until YYYY-MM-DD[THH:MM] | --days N] [--reason "text"]   default: 7 days
+import { getPath, loadConfig } from "../config.js";
+import { collect } from "../quota.js";
+export const USAGE = `orq block <agent|account> [--until YYYY-MM-DD[THH:MM] | --days N | --quota] [--reason "text"]   default: 7 days; --quota: until the quota window resets
 orq block -r <agent|account>       unblock early
 orq block -l                       list active blocks (expired ones disappear by themselves)`;
 const file = () => join(stateDir(), "blocks.json");
@@ -19,7 +23,21 @@ export function load() {
         b = JSON.parse(readFileSync(file(), "utf8"));
     }
     catch { /* missing or broken: no blocks */ }
-    return Object.fromEntries(Object.entries(b).filter(([, v]) => (v?.until ?? 0) > now()));
+    const live = Object.fromEntries(Object.entries(b).filter(([, v]) => (v?.until ?? 0) > now()));
+    // A block made under another login (the account was switched) no longer applies: the new one has its own quota.
+    const kept = Object.fromEntries(Object.entries(live).filter(([k, v]) => {
+        if (!v.acct)
+            return true;
+        const cur = loginId(k);
+        return cur === undefined || cur === v.acct;
+    }));
+    if (Object.keys(kept).length !== Object.keys(live).length) {
+        try {
+            save(kept);
+        }
+        catch { /* best effort */ }
+    }
+    return kept;
 }
 const save = (b) => writeAtomic(file(), JSON.stringify(b, null, 2));
 /** "YYYY-MM-DD" or "YYYY-MM-DDTHH:MM" in local time (a bare date in JS would be UTC). */
@@ -29,7 +47,16 @@ export function parseLocal(s) {
         throw new Error(m(`invalid date: ${s}`, `data inválida: ${s}`));
     return d;
 }
-export function block(argv) {
+/** When a quota line's exhausted window resets, in epoch seconds: the week if it is used up, else the 5h window (the
+ *  reading can lag behind the limit: Codex's comes from its last session). undefined = no reset known. */
+export function quotaUntil(line) {
+    const reset = (k) => { const x = new RegExp(`\\b${k}=(\\d+)`).exec(line); return x ? Number(x[1]) : undefined; };
+    const week = /\bweek=(\d+)%/.exec(line);
+    if (week && Number(week[1]) >= 100 && reset("resetweek"))
+        return reset("resetweek");
+    return reset("reset5h") ?? reset("resetweek");
+}
+export async function block(argv) {
     const b = load();
     if (!argv.length || argv[0] === "-h" || argv[0] === "--help") {
         console.log(USAGE);
@@ -53,7 +80,7 @@ export function block(argv) {
         return 0;
     }
     const [name, ...rest] = argv;
-    let until = new Date(Date.now() + 7 * 86400_000), reason = "";
+    let until = new Date(Date.now() + 7 * 86400_000), reason = "", byQuota = false;
     while (rest.length) {
         const o = rest.shift();
         if (o === "--until")
@@ -62,12 +89,25 @@ export function block(argv) {
             until = new Date(Date.now() + Number(rest.shift()) * 86400_000);
         else if (o === "--reason")
             reason = rest.shift() ?? "";
+        else if (o === "--quota")
+            byQuota = true;
+    }
+    if (byQuota) {
+        const sources = (getPath(loadConfig().cfg, "quota") ?? {});
+        const line = (await collect(sources, [name])).find((l) => l.startsWith(`${name} `));
+        const r = line && quotaUntil(line);
+        if (!r) {
+            console.error(m(`${name}: no quota reset known; use --until or --days`, `${name}: sem horário de renovação da cota; use --until ou --days`));
+            return 1;
+        }
+        until = new Date(r * 1000);
     }
     if (Number.isNaN(until.getTime())) {
         console.error(USAGE);
         return 2;
     }
-    b[name] = { until: until.getTime() / 1000, reason };
+    const acct = loginId(name);
+    b[name] = { until: until.getTime() / 1000, reason, ...(acct ? { acct } : {}) };
     save(b);
     console.log(`${name} ${m("out of orq-pick until", "fora do orq-pick até")} ${fmt(until)}`);
     return 0;

package/dist/commands/board.js

@@ -7,20 +7,25 @@
 // Refreshes every --interval s on a TTY; otherwise (or with --once) prints once; --json for scripts.
 // Keys: q quits · r refreshes the quota · l language · t theme (ui.theme: gunmetal | chrome | lcd | terminal).
 import { execFile, spawn } from "node:child_process";
-import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, fstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync } from "node:fs";
 import { freemem, homedir, totalmem } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { colorMode } from "../banner.js";
+import { collectCi, collectedAt, loadCache as loadCiCache } from "../ci.js";
 import { getPath, loadConfig } from "../config.js";
 import { writeAtomic } from "../fsutil.js";
 import { m, setLang } from "../i18n.js";
+import { argvModel } from "../agents.js";
 import { alive, status as lockStatus } from "../lock.js";
 import { expand, stateDir } from "../paths.js";
 import { processTableAsync, treeMem } from "../process.js";
 import { collect } from "../quota.js";
+import { collectRounds, mark, roundsSig } from "../rounds.js";
 import { collectRuns, rows } from "../stats.js";
+import { pendingNotices, readLog } from "../notice.js";
 import { load as loadBlocks } from "./block.js";
+import { herdrNamesAsync, nameOf } from "./claim.js";
 import { setValue } from "./set.js";
 export const USAGE = "orq board [-w <workspace>]... [--once] [--json] [--interval S]   live board: queue, agents, conductors, quota";
 const CLI = fileURLToPath(new URL("../cli.js", import.meta.url));
@@ -32,19 +37,20 @@ catch {
     return "";
 } };
 const models = new Map();
-/** The model a run was started with, from its job file (-m / --model in the argv). */
-function modelOf(prefix) {
-    if (!models.has(prefix)) {
+/** The model of a run recorded before its state file had one, from its job file; a rerun on the same prefix
+ *  overwrites that file, so another unit's job says nothing about this run. */
+function modelOf(prefix, unit) {
+    if (!models.has(unit)) {
         let v;
         try {
-            const a = (JSON.parse(read(`${prefix}.job.json`)).argv ?? []);
-            const i = a.findIndex((x) => x === "-m" || x === "--model");
-            v = i >= 0 ? a[i + 1] : a.find((x) => x.startsWith("--model="))?.slice(8);
+            const j = JSON.parse(read(`${prefix}.job.json`));
+            if (!j.unit || j.unit === unit)
+                v = argvModel(j.argv ?? []);
         }
         catch { /* no job file */ }
-        models.set(prefix, v?.split("/").pop());
+        models.set(unit, v);
     }
-    return models.get(prefix);
+    return models.get(unit);
 }
 /** What the agent did last, from the tail of its log (stream JSON of claude/opencode, else the last text line). */
 export function activity(log) {
@@ -107,7 +113,7 @@ function agents(table, now) {
             continue;
         if ((st === "ok" || st === "fail") && now - (end ?? at) > RECENT_MS)
             continue;
-        const a = { unit: f.slice(0, -5), title: String(s.title ?? ""), agent: String(s.agent ?? "?"), model: modelOf(prefix),
+        const a = { unit: f.slice(0, -5), title: String(s.title ?? ""), agent: String(s.agent ?? "?"), model: typeof s.model === "string" ? s.model : modelOf(prefix, f.slice(0, -5)),
             host: s.host, pid, issue: basename(dirname(prefix)), label: basename(prefix), state: st,
             secs: Math.max(0, Math.round(((end ?? now) - at) / 1000)), cap: typeof s.cap === "number" ? s.cap : undefined };
         if (s.rc !== undefined)
@@ -124,16 +130,40 @@ function agents(table, now) {
 }
 const field = (t, k) => new RegExp(`${k}=(\\S+)`).exec(t)?.[1] ?? "";
 const herdrAlive = (id) => new Promise((res) => execFile("herdr", ["agent", "get", id], { timeout: 5000, windowsHide: true }, (e) => res(!e)));
+// The board redraws every few seconds: reread an issue's reviews only when its folder changed.
+const roundsCache = new Map();
+function cachedRounds(ws, id, max) {
+    const key = `${ws}\0${id}\0${max}`, sig = roundsSig(ws, id), hit = roundsCache.get(key);
+    if (hit && hit.sig === sig)
+        return hit.x;
+    const x = collectRounds(ws, id, max);
+    roundsCache.set(key, { sig, x });
+    return x;
+}
 async function conductors(wss) {
     const by = new Map();
     for (const ws of wss) {
         const O = join(ws, ".orquestra");
-        for (const id of existsSync(O) ? readdirSync(O) : []) {
+        const max = Number((() => { try {
+            return getPath(loadConfig(ws).cfg, "policy.max_rounds");
+        }
+        catch {
+            return undefined;
+        } })() ?? 2);
+        for (const id of existsSync(O) ? readdirSync(O).filter((x) => !x.startsWith(".")) : []) {
             const t = read(join(O, id, "owner")).trim();
             if (!t)
                 continue;
             const who = field(t, "pane"), at = Date.parse(field(t, "at")) || 0;
-            const c = by.get(who) ?? { id: who, kind: field(t, "kind") || "herdr", account: field(t, "account"), alive: false, issues: [], at };
+            const c = by.get(who) ?? { id: who, kind: field(t, "kind") || "herdr", account: field(t, "account"), alive: false, issues: [], at, name: nameOf(t) };
+            if (!c.name)
+                c.name = nameOf(t);
+            try {
+                const x = cachedRounds(ws, id, max);
+                if (x)
+                    (c.rounds ??= {})[id] = { rounds: x.rounds, max: x.max, level: x.level };
+            }
+            catch { /* unreadable issue folder: no marker */ }
             c.issues.push(id);
             c.at = Math.max(c.at, at);
             by.set(who, c);
@@ -141,7 +171,15 @@ async function conductors(wss) {
     }
     const ttl = Number(process.env.ORQ_CLAIM_TTL_H ?? 24) * 3600_000;
     const out = [...by.values()];
-    await Promise.all(out.map(async (c) => { c.alive = c.kind === "herdr" ? await herdrAlive(c.id) : Date.now() - c.at < ttl; }));
+    // One `herdr workspace list` per refresh, shared by every conductor (not 2 spawns each), off the event
+    // loop (execFile, not spawnSync) so a slow/busy herdr daemon delays only this redraw, never key handling.
+    const names = out.some((c) => c.kind === "herdr") ? await herdrNamesAsync(out.filter((c) => c.kind === "herdr").map((c) => c.id)) : new Map();
+    await Promise.all(out.map(async (c) => {
+        c.alive = c.kind === "herdr" ? await herdrAlive(c.id) : Date.now() - c.at < ttl;
+        // Alive herdr conductor: the workspace's current label (the user may have renamed it since the claim).
+        if (c.alive && c.kind === "herdr")
+            c.name = names.get(c.id) || c.name;
+    }));
     return out.filter((c) => c.alive).map(({ at: _, ...c }) => ({ ...c, issues: c.issues.sort() }));
 }
 // Quota: the board never waits for the network. A stale cache starts `orq board --collect-quota` detached.
@@ -149,8 +187,9 @@ const qdir = () => join(stateDir(), "board");
 const qfile = () => join(qdir(), "quota.txt");
 export function parseQuota(text) {
     return text.split(/\r?\n/).flatMap((l) => {
-        const r = /^(\S+) 5h=(\S+) week=(\S+)(?: \[(.*)\])?/.exec(l.trim());
-        return r ? [{ name: r[1], five: r[2], week: r[3], ...(r[4] ? { note: r[4] } : {}) }] : [];
+        const r = /^(\S+) 5h=(\S+) week=(\S+)(?: reset5h=(\d+))?(?: resetweek=(\d+))?(?: span5h=\d+)?(?: spanweek=\d+)?(?: \[(.*)\])?/.exec(l.trim());
+        return r ? [{ name: r[1], five: r[2], week: r[3], ...(r[4] ? { reset5h: Number(r[4]) } : {}),
+                ...(r[5] ? { resetWeek: Number(r[5]) } : {}), ...(r[6] ? { note: r[6] } : {}) }] : [];
     });
 }
 export function quota(now) {
@@ -179,6 +218,41 @@ async function collectQuota() {
     writeAtomic(qfile(), lines.join("\n") + "\n");
     return 0;
 }
+// CI: the same never-block-the-board rule as quota — a stale cache starts `orq board --collect-ci -w <ws>...`
+// detached, reusing this same timer instead of a new one; the board itself only ever reads the cache file.
+function startCollectCi(wss) {
+    const lock = join(qdir(), "ci.pid");
+    const pid = Number(read(lock));
+    if (pid > 0 && alive(pid))
+        return;
+    mkdirSync(qdir(), { recursive: true });
+    const c = spawn(process.execPath, [CLI, "board", ...wss.flatMap((w) => ["-w", w]), "--collect-ci"], { detached: true, stdio: "ignore", windowsHide: true });
+    if (c.pid)
+        writeAtomic(lock, String(c.pid));
+    c.unref();
+}
+// Age per requested workspace, not the shared cache file's mtime: ci.json holds every workspace's entries and
+// collectCi() rewrites the whole file on every run, so one workspace's collection would otherwise renew the
+// mtime for all of them and starve a second workspace that was never actually collected. collectedAt() reads a
+// per-workspace marker that collectCi() writes even when it finds zero entries (no claimed issue with a matching
+// worktree) — without it, a workspace with nothing to collect would look permanently stale (entries' own `at`
+// would never exist for it) and the board would relaunch the collector every redraw forever.
+function ci(wss, now) {
+    const entries = loadCiCache().filter((e) => wss.includes(e.ws));
+    const ages = wss.map((w) => { const at = collectedAt(w); return at === undefined ? undefined : now - at; });
+    const age = ages.some((a) => a === undefined) ? undefined : Math.max(...ages);
+    if (age === undefined || age > QTTL)
+        startCollectCi(wss);
+    return { entries, age };
+}
+// Detached (stdio: "ignore"): collectCi()'s default notice (console.log) would otherwise vanish into /dev/null,
+// so a non-herdr conductor's "CI failed" line is appended to a log file instead.
+function collectCiAll(wss) {
+    const notice = (l) => appendFileSync(join(qdir(), "ci.log"), `${l}\n`);
+    for (const ws of wss)
+        collectCi(ws, { notice });
+    return 0;
+}
 let sb;
 function scoreboard(ws, now) {
     if (!sb || sb.ws !== ws || now - sb.at > 60_000) {
@@ -197,7 +271,7 @@ export async function snapshot(wss, table) {
     return {
         at: new Date(now).toISOString(), mem: { used: totalmem() - freemem(), total: totalmem() }, workspaces: wss,
         queue: { holders: q.holders.map(item), waiters: q.waiters.map(item) }, agents: agents(table, now),
-        conductors: await conductors(wss), quota: quota(now), blocks: loadBlocks(), scoreboard: scoreboard(wss[0], now),
+        conductors: await conductors(wss), quota: quota(now), ci: ci(wss, now), blocks: loadBlocks(), scoreboard: scoreboard(wss[0], now), notices: pendingNotices(readLog(), now),
     };
 }
 // --- render -----------------------------------------------------------------------------------------------------
@@ -251,6 +325,15 @@ export function render(s, theme, cols, mode = colorMode()) {
     out.push(`${c.surf}${c.b}${c.acc} ORQ${c.b ? "\x1b[22m" : ""}${c.surf}${c.ink2}  ${ws}${" ".repeat(Math.max(1, W - left.length - right.length))}${c.mut}${right}`);
     const mp = Math.round(100 * s.mem.used / s.mem.total);
     out.push(` ${c.mut}MEM${c.r}  ${meter(mp, 24)} ${c.ink}${gb(s.mem.used)}${c.r} ${c.mut}/ ${gb(s.mem.total)}${c.r}`);
+    // Red line(s) first: a failure the conductor may not know about is what a person must see before anything else.
+    if (s.notices.length) {
+        const ago = (at) => dur(Math.max(0, Math.round((new Date(s.at).getTime() - at) / 1000)));
+        out.push(` ${c.err}${c.b}✗ ${m(`${s.notices.length} failure(s) the conductor may not know about`, `${s.notices.length} falha(s) que o conductor pode não saber`)}${c.r}`);
+        for (const n of s.notices.slice(0, 5)) {
+            const what = n.line.replace(/^\[[^\]]+\] /, "").replace(/ answer: .*/, "");
+            out.push(` ${c.err}  ${fit(n.issue ?? "-", 10)}${c.r} ${c.ink}${fit(what, Math.max(20, W - 44))}${c.r} ${c.err}${n.why === "undelivered" ? m("not delivered", "não entregue") : m("not acknowledged", "sem resposta")}${c.r} ${c.mut}${ago(n.at)}${m(" ago", " atrás")}${c.r}`);
+        }
+    }
     section("TRANSPORT", m("test queue", "fila de testes"));
     for (const h of s.queue.holders)
         out.push(` ${c.acc}▶ REC${c.r}  ${c.ink}${fit(h.label, 34)}${c.r} ${c.ok}${m("running", "rodando")}${c.r} ${c.ink}${dur(h.secs).padEnd(7)}${c.r} ${c.ink2}${gb(h.mem)}${c.r}`
@@ -261,7 +344,7 @@ export function render(s, theme, cols, mode = colorMode()) {
     section("TRACKS", m("agents", "agentes"));
     s.agents.forEach((a, i) => {
         const n = `${c.mut}${String(i + 1).padStart(2, "0")}${c.r}`, who = `${c.ink}${fit(a.issue, 9)}${c.r} ${c.ink2}${fit(a.label, 22)}${c.r} `
-            + `${c.ink}${fit(a.agent, 11)}${c.r}${c.mut}${fit(a.model ?? m("default", "padrão"), 17)}${c.r} ${c.ink}${dur(a.secs).padEnd(7)}${c.r}`;
+            + `${c.ink}${fit(a.agent, 11)}${c.r}${c.mut}${fit(a.model ?? m("default", "padrão"), 17)}${c.r} ${c.ink}${(a.state === "died" ? "?" : dur(a.secs)).padEnd(7)}${c.r}`; // died: when it stopped is unknown
         if (a.state === "running") {
             const pct = a.cap && a.mem ? Math.round(100 * a.mem / a.cap) : 0, used = 1 + 2 + 2 + 10 + 23 + 11 + 17 + 1 + 8 + 6 + 1 + 7 + 1;
             const warn = a.secs > 3 * 3600 ? ` ${c.err}⚠ ${m("for", "há")} ${dur(a.secs)}${c.r}` : "";
@@ -276,9 +359,15 @@ export function render(s, theme, cols, mode = colorMode()) {
         out.push(` ${c.mut}${m("none", "nenhum")}${c.r}`);
     section("MASTER", m("conductors", "conductors"));
     for (const k of s.conductors)
-        out.push(` ${c.ok}●${c.r} ${c.mut}${fit(k.id, 22)}${c.r} ${c.ink2}${fit(k.account || "-", 14)}${c.r} ${c.ink}${k.issues.join(" ")}${c.r}`);
+        out.push(` ${c.ok}●${c.r} ${c.mut}${fit(k.name || k.id, 22)}${c.r} ${c.ink2}${fit(k.account || "-", 14)}${c.r} ${c.ink}${k.issues.map((i) => (k.rounds?.[i] ? `${i} ${mark(k.rounds[i])}` : i)).join("  ")}${c.r}`);
     if (!s.conductors.length)
         out.push(` ${c.mut}${m("no claimed issues", "nenhuma issue reivindicada")}${c.r}`);
+    section("MONITOR", m("CI/CD", "CI/CD"));
+    const ciMark = { passed: `${c.ok}✓`, failed: `${c.err}✗`, running: `${c.acc}●`, queued: `${c.mut}‖`, none: `${c.mut}·` };
+    for (const e of s.ci.entries)
+        out.push(` ${ciMark[e.state]}${c.r} ${c.ink}${fit(e.issue, 10)}${c.r} ${c.ink2}${fit(e.repo, 14)}${c.r} ${c.mut}${fit(e.branch, 24)}${c.r} ${c.ink}${(e.pr ? `#${e.pr}` : "-").padEnd(6)}${c.r} ${c.ink2}${e.state}${c.r}`);
+    if (!s.ci.entries.length)
+        out.push(` ${c.mut}${s.ci.age === undefined ? m("collecting...", "coletando...") : m("no claimed issue has a PR", "nenhuma issue reivindicada tem PR")}${c.r}`);
     section("MIXER", m("quota", "cota"));
     const win = (v, tag) => {
         const n = /^(\d+)%?$/.exec(v)?.[1];
@@ -329,6 +418,8 @@ export async function board(argv) {
             interval = Math.max(1, Number(argv[++i]) || 3);
         else if (a === "--collect-quota")
             return collectQuota();
+        else if (a === "--collect-ci")
+            return collectCiAll(wss);
         else if (a === "-h" || a === "--help") {
             console.log(USAGE);
             return 0;

package/dist/commands/ci.js

@@ -0,0 +1,48 @@
+// orq ci [-w <workspace>]... [--json]   CI/CD signal per claimed issue with a PR: queued | running | passed |
+// failed | none. This is the one caller of src/ci.ts's collectCi() that runs it in the foreground (network and
+// all) instead of reading its cache — the user asked for CI status right now, so it collects right now; `orq
+// board`'s CI column is the one that stays off the network and only reads the cache this same collectCi() fills.
+import { resolve } from "node:path";
+import { collectCi } from "../ci.js";
+import { getPath, loadConfig } from "../config.js";
+import { m } from "../i18n.js";
+import { expand } from "../paths.js";
+export const USAGE = "orq ci [-w <workspace>]... [--json]   CI/CD status per claimed issue (queued|running|passed|failed|none)";
+const label = (s) => ({ queued: m("queued", "na fila"), running: m("running", "rodando"),
+    passed: m("passed", "passou"), failed: m("failed", "falhou"), none: m("none", "nenhum") })[s];
+export async function ci(argv) {
+    const wss = [];
+    let json = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-w")
+            wss.push(resolve(expand(argv[++i] ?? ".")));
+        else if (a === "--json")
+            json = true;
+        else if (a === "-h" || a === "--help") {
+            console.log(USAGE);
+            return 0;
+        }
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    if (!wss.length)
+        wss.push(getPath(loadConfig().cfg, "_workspace") ?? process.cwd());
+    // --json's stdout must be only the JSON: a non-herdr owner's notice goes to stderr instead of the default
+    // stdout, which would otherwise interleave a stray line in front of the JSON.
+    const hooks = json ? { notice: (line) => console.error(line) } : {};
+    const entries = wss.flatMap((ws) => collectCi(ws, hooks));
+    if (json) {
+        console.log(JSON.stringify(entries));
+        return 0;
+    }
+    if (!entries.length) {
+        console.log(m("no claimed issue has a PR", "nenhuma issue reivindicada tem PR"));
+        return 0;
+    }
+    for (const e of entries)
+        console.log(`${e.issue} ${e.repo} ${e.branch} ${e.pr ? `#${e.pr}` : "-"} ${label(e.state)}`);
+    return 0;
+}