@irythill/orq 0.2.0 → 0.4.0

package/dist/commands/agent.js

@@ -4,6 +4,10 @@
 // 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.
 // 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/
+// .done and notifies; the screen stays open (holding memory) until you close it. -T -R with the screen still open types
+// the follow-up into it; with the screen closed it reopens the session (tui_resume).
 import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { appendFileSync, copyFileSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
@@ -11,14 +15,15 @@ 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 { 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, shq } from "../terminal.js";
+import { closeOwnTab, detectHost, launch, screenOpen, shq, typeInto } from "../terminal.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] -- <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]] [-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) => {
@@ -28,8 +33,10 @@ const git = (dir, ...a) => {
 export async function agent(argv) {
     if (argv[0] === "--run")
         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, prompt;
+    let ro = false, tui = false, force = false, prompt;
     const inc = [];
     for (let i = 0; i < argv.length; i++) {
         const x = argv[i], v = () => argv[++i] ?? "";
@@ -63,10 +70,10 @@ export async function agent(argv) {
             v();
         else if (x === "-r")
             ro = true;
-        else if (x === "-T") {
-            console.error(m("-T (the agent's own TUI) only exists in herdr: use herdr-agent -T", "-T (a TUI do próprio agente) só existe no herdr: use herdr-agent -T"));
-            return 2;
-        }
+        else if (x === "-T")
+            tui = true;
+        else if (x === "-F")
+            force = true;
         else if (!x.startsWith("-") && prompt === undefined)
             prompt = x;
         else {
@@ -94,11 +101,44 @@ export async function agent(argv) {
         console.error(m(`-c only applies to agents with Claude accounts (claude)`, `-c só vale para agentes com contas Claude (claude)`));
         return 2;
     }
-    if (resume && !def.resume) {
+    const mach = (cfg.machine ?? {});
+    const host = detectHost(cfg);
+    // Screen by default (machine.tui, HERDR_AGENT_TUI=1) only where it can be: a terminal host and an agent with a screen.
+    if (!tui && (process.env.HERDR_AGENT_TUI === "1" || mach.tui === true) && host !== "plain" && def.tui && (!resume || def.tui_resume))
+        tui = true;
+    if (tui && !def.tui) {
+        console.error(m(`-T: ${a} has no screen mode (agents.${a}.tui)`, `-T: ${a} não tem modo tela (agents.${a}.tui)`));
+        return 2;
+    }
+    if (resume && !tui && !def.resume) {
         console.error(m(`${a} has no resume template (agents.${a}.resume)`, `${a} não tem template de resume (agents.${a}.resume)`));
         return 2;
     }
+    if (tui && resume && !def.tui_resume) {
+        console.error(m(`-T -R: ${a} has no tui_resume template`, `-T -R: ${a} não tem template tui_resume`));
+        return 2;
+    }
+    if (tui && host === "plain") {
+        console.error(m("-T shows the agent's own screen: it needs herdr or tmux (run inside one, or set ORQ_TERMINAL)", "-T mostra a tela do próprio agente: precisa do herdr ou do tmux (rode dentro de um, ou defina ORQ_TERMINAL)"));
+        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, 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, repita com -F.`));
+            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`));
@@ -119,9 +159,6 @@ export async function agent(argv) {
         writeFileSync(`${O}.diff`, r.stdout);
         inc.push(`${O}.diff`);
     }
-    // Follow-ups (-R) reuse the prefix: remove the previous round's result so ".done exists" means "this one finished".
-    for (const s of [".done", ".out.md", ".pid"])
-        rmSync(O + s, { force: true });
     if (inc.length) {
         let text = readFileSync(P, "utf8");
         for (const f of inc)
@@ -129,6 +166,24 @@ export async function agent(argv) {
         writeFileSync(`${O}.prompt.md`, text);
         P = `${O}.prompt.md`;
     }
+    // Follow-ups (-R) reuse the prefix: remove the previous round's result so ".done exists" means "this one finished".
+    // -T -R with the screen still open: the follow-up is typed into it (its runner, and .pid, carry on). Open = the agent
+    // is still running there, not just the pane: after it exits the pane may hold a shell, which must never get the text.
+    let open = "", pid = 0;
+    try {
+        open = readFileSync(`${O}.pane`, "utf8").trim();
+        pid = Number(readFileSync(`${O}.pid`, "utf8"));
+    }
+    catch { /* first run or ended */ }
+    if (tui && resume && alive(pid) && screenOpen(open)) {
+        for (const s of [".done", ".out.md"])
+            rmSync(O + s, { force: true });
+        typeInto(open, readFileSync(P, "utf8"));
+        console.log(`[orq agent] ${t} → ${open} ${m("(follow-up typed into the open screen)", "(follow-up digitado na tela aberta)")}`);
+        return 0;
+    }
+    for (const s of [".done", ".out.md", ".pid"])
+        rmSync(O + s, { force: true });
     const throwaway = Boolean(def.throwaway && ro && !resume);
     const dir = throwaway ? `${repo}.review-${process.pid}` : repo;
     const gd = git(repo, "rev-parse", "--path-format=absolute", "--git-common-dir");
@@ -140,22 +195,36 @@ export async function agent(argv) {
     }
     catch { /* none */ }
     const session = resume || (def.session === "uuid" ? randomUUID() : "");
+    const tpl = tui ? (resume ? def.tui_resume : def.tui) : resume ? def.resume : def.run;
+    // End of turn (-T): the agent runs `orq agent --turn <job> <kind>`; Claude gets it as a Stop hook, Codex as notify,
+    // OpenCode through a plugin orq writes next to the job.
+    const hook = [process.execPath, CLI, "agent", "--turn", `${O}.job.json`, def.turn_hook ?? "text"];
+    // OpenCode v2 drops a partial MCP entry without a word: each one turned off needs its type and command too.
+    const off = { type: "local", command: ["true"], enabled: false };
+    const ocCfg = {
+        mcp: { plane: off, shadcn: off, "linear-server": off },
+        permission: { bash: "allow", question: "deny", webfetch: "deny",
+            external_directory: { "*": "deny", ...(gd ? { [`${gd}/*`]: "allow" } : {}), "/tmp/*": "allow", ...(nm ? { [`${nm}/*`]: "allow" } : {}) },
+            edit: ro ? "deny" : "allow" },
+    };
+    if (tui && def.turn_hook === "opencode") {
+        mkdirSync(`${O}.opencode`, { recursive: true }); // a v2 plugin is a folder with index.js
+        writeFileSync(join(`${O}.opencode`, "index.js"), opencodePlugin(O, hook));
+        ocCfg.plugin = [`${O}.opencode`];
+        if (model && model !== "auto")
+            ocCfg.model = model; // the screen has no -m
+    }
     const vars = {
-        prompt: P, prompt_text: def.run.includes("{prompt_text}") || def.resume?.includes("{prompt_text}") ? readFileSync(P, "utf8") : "",
+        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,
-        gitdir: gd ?? "", gitroots: roots, gitroots_json: JSON.stringify(roots), mode: [],
-        opencode_config: JSON.stringify({
-            mcp: { plane: { enabled: false }, shadcn: { enabled: false }, "linear-server": { enabled: false } },
-            permission: { bash: "allow", question: "deny", webfetch: "deny",
-                external_directory: { "*": "deny", ...(gd ? { [`${gd}/*`]: "allow" } : {}), "/tmp/*": "allow", ...(nm ? { [`${nm}/*`]: "allow" } : {}) },
-                edit: ro ? "deny" : "allow" },
-        }),
+        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(" ") }] }] } }),
     };
     vars.mode = expandTemplate((ro ? def.readonly : def.write) || "", vars);
-    const tpl = resume ? def.resume : def.run;
     const cmd = expandTemplate(tpl, vars);
-    if (!tpl.includes("{mode}") && !resume)
+    if (!tpl.includes("{mode}") && !resume && !tui)
         cmd.push(...vars.mode);
     const env = {};
     for (const [k, val] of Object.entries(def.env ?? {}))
@@ -168,9 +237,7 @@ export async function agent(argv) {
         }
         env.CLAUDE_CONFIG_DIR = ac.dir;
     }
-    const mach = (cfg.machine ?? {});
     const closeAfter = Number(process.env.HERDR_CLOSE_DELAY ?? mach.close_tab_after ?? 20);
-    const host = detectHost(cfg);
     const unit = `herdr-agent-${Math.floor(Date.now() / 1000)}-${process.pid}`; // herdr-board lists herdr-agent-* scopes
     const job = {
         agent: a, title: t, repo, dir, prefix: O, prompt: P, argv: cmd, env, unset: def.unset_env ?? [], stdin: Boolean(def.stdin),
@@ -179,7 +246,8 @@ export async function agent(argv) {
         host, unit, cap: parseSize(def.mem_max ?? mach.agent_mem_max ?? "off"),
         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,
+        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).
@@ -187,9 +255,124 @@ export async function agent(argv) {
         `cd ${shq(dir)}\n${Object.entries(env).map(([k, val]) => `${k}=${shq(val)} `).join("")}${cmd.map(shq).join(" ")}${job.stdin ? ` < ${shq(P)}` : ""}\n`);
     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}`);
+    console.log(`[orq agent] ${t} → ${where}${tui ? " (TUI)" : ""}`);
     return 0;
 }
+/** OpenCode (v2) plugin for -T: when the main session's run ends, its last answer goes to `orq agent --turn`. */
+function opencodePlugin(O, hook) {
+    return `// orq agent -T end of turn (generated)
+import { writeFileSync } from "fs"; import { spawn } from "child_process";
+export default {
+  id: "orq-turn",
+  setup: async (ctx) => {
+    const sub = new Set(), text = new Map(); // child sessions (subagents); answer text per session
+    (async () => {
+      for await (const e of ctx.event.subscribe()) {
+        const d = e.data ?? {}, id = d.sessionID;
+        if (e.type === "session.created" && d.parentID) sub.add(id);
+        if (!id || sub.has(id)) continue;
+        if (e.type === "session.execution.started") text.set(id, { msg: "", parts: [] });
+        else if (e.type === "session.text.ended") {
+          const t = text.get(id) ?? { msg: "", parts: [] };
+          if (t.msg !== d.assistantMessageID) { t.msg = d.assistantMessageID; t.parts = []; } // only the last message
+          t.parts[d.ordinal ?? t.parts.length] = d.text ?? ""; text.set(id, t);
+        } else if (e.type.startsWith("session.execution.") && e.type !== "session.execution.started") {
+          const f = ${JSON.stringify(`${O}.turn.md`)};
+          writeFileSync(f, (text.get(id)?.parts ?? []).filter((x) => x !== undefined).join("\\n"));
+          spawn(${JSON.stringify(hook[0])}, [...${JSON.stringify(hook.slice(1))}, id, f], { detached: true, stdio: "ignore" }).unref();
+        }
+      }
+    })().catch(() => {});
+    return {};
+  },
+};
+`;
+}
+/** End of a turn on the agent's screen: answer, session and .done from the agent's own hook payload. Never fails the agent. */
+function turn(file, kind, rest) {
+    try {
+        const j = JSON.parse(readFileSync(file, "utf8")), O = j.prefix;
+        let answer = "", sid;
+        if (kind === "codex") {
+            const e = JSON.parse(rest[rest.length - 1] ?? "{}");
+            if (e.type !== "agent-turn-complete")
+                return 0;
+            answer = String(e["last-assistant-message"] ?? "");
+            sid = e["thread-id"];
+        }
+        else if (kind === "claude") {
+            const e = JSON.parse(readFileSync(0, "utf8"));
+            if (e.stop_hook_active)
+                return 0;
+            sid = e.session_id;
+            answer = String(e.last_assistant_message ?? "") || lastClaudeText(String(e.transcript_path ?? ""));
+        }
+        else if (kind === "opencode") {
+            sid = rest[0];
+            try {
+                answer = readFileSync(rest[1], "utf8");
+                rmSync(rest[1], { force: true });
+            }
+            catch { /* none */ }
+        }
+        else {
+            sid = rest[0];
+            answer = readFileSync(0, "utf8");
+        }
+        writeFileSync(`${O}.out.md`, answer);
+        if (sid)
+            writeFileSync(`${O}.id`, `${sid}\n`);
+        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);
+    }
+    catch (e) {
+        console.error(`orq agent --turn: ${e.message}`);
+    }
+    return 0;
+}
+/** The last text Claude wrote, from its transcript (older Stop hooks have no last_assistant_message). */
+function lastClaudeText(transcript) {
+    let text = "";
+    try {
+        for (const l of readFileSync(transcript, "utf8").split(/\r?\n/)) {
+            try {
+                const e = JSON.parse(l);
+                if (e.type !== "assistant")
+                    continue;
+                const t = (e.message?.content ?? []).filter((c) => c.type === "text").map((c) => c.text).join("\n");
+                if (t)
+                    text = t;
+            }
+            catch { /* not JSON */ }
+        }
+    }
+    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) {
@@ -218,7 +401,6 @@ async function runJob(file) {
     catch { /* best effort */ } };
     state();
     const fmt = FORMATS[j.format] ?? FORMATS.text;
-    const log = createWriteStream(`${O}.log`);
     let rc = 0, stdout = "", logText = "";
     const pre = () => {
         if (j.throwaway) {
@@ -254,6 +436,51 @@ async function runJob(file) {
         if (j.throwaway)
             dropWorktree(j.repo, j.dir);
     };
+    if (j.tui) {
+        // The agent's own screen: the terminal is its; answers come from the end-of-turn hook (`--turn`).
+        let ended = false;
+        const end = (code) => {
+            if (ended)
+                return "fail";
+            ended = true;
+            post();
+            // Closed before any turn ended (or mid follow-up): a failure, so `orq wait` doesn't hang.
+            const ok = /\bstatus=ok\b/.test(existsSync(`${O}.done`) ? readFileSync(`${O}.done`, "utf8") : "");
+            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);
+            }
+            rmSync(`${O}.pid`, { force: true });
+            return ok ? "ok" : "fail";
+        };
+        if (!pre())
+            rc = 2;
+        else {
+            const env = { ...process.env, ...j.env };
+            for (const k of j.unset)
+                delete env[k];
+            // Ctrl+C belongs to the agent (it reaches us too, as part of the terminal's foreground group). The screen going
+            // away (tab or tmux server closed) still ends the agent and cleans up.
+            let child;
+            process.on("SIGINT", () => { });
+            const gone = () => { if (child)
+                killTree(child, false); end(129); process.exit(0); };
+            for (const sig of ["SIGHUP", "SIGTERM"])
+                process.on(sig, gone);
+            rc = await runCapped(j.argv[0], j.argv.slice(1), { cap: j.cap, swap: j.swap, mode: j.mode, unit: j.unit, cwd: j.dir, env, quote: true, tty: true,
+                onSpawn: (c) => { child = c.pid; } });
+        }
+        const st = end(rc);
+        state({ status: st, rc, end: new Date().toISOString() });
+        console.log(`\n[${j.agent} (TUI) ${m("exited", "encerrado")}] ${m("answer", "resposta")}: ${O}.out.md`);
+        if (!j.keep) {
+            await sleep(j.closeAfter * 1000);
+            closeOwnTab(j.host);
+        }
+        return 0;
+    }
+    const log = createWriteStream(`${O}.log`);
     if (!pre())
         rc = 2;
     else {
@@ -314,12 +541,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,9 +1,11 @@
 // 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
@@ -19,7 +21,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). */
@@ -67,7 +83,8 @@ export function block(argv) {
         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,11 +7,12 @@
 // 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";
@@ -19,8 +20,10 @@ 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 { 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));
@@ -124,16 +127,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 +168,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 +184,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 +215,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 +268,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),
     };
 }
 // --- render -----------------------------------------------------------------------------------------------------
@@ -276,9 +347,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 +406,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;