@irythill/orq 0.3.0 → 0.4.0

package/dist/commands/agent.js

@@ -15,7 +15,7 @@ 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";
@@ -23,7 +23,7 @@ import { stateDir } from "../paths.js";
 import { killTree, parseSize, resolveMode, runCapped } from "../process.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] [-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]] [-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) => {
@@ -36,7 +36,7 @@ export async function agent(argv) {
     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 ro = false, tui = false, force = false, prompt;
     const inc = [];
     for (let i = 0; i < argv.length; i++) {
         const x = argv[i], v = () => argv[++i] ?? "";
@@ -72,6 +72,8 @@ export async function agent(argv) {
             ro = true;
         else if (x === "-T")
             tui = true;
+        else if (x === "-F")
+            force = true;
         else if (!x.startsWith("-") && prompt === undefined)
             prompt = x;
         else {
@@ -121,6 +123,22 @@ 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, 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`));
@@ -199,7 +217,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,6 +247,7 @@ 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).
@@ -303,7 +322,8 @@ 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);
@@ -332,6 +352,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) {
@@ -500,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;

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;
+}

package/dist/commands/claim.js

@@ -1,36 +1,112 @@
 // orq claim — owner of each issue among conductors of the same workspace (port of herdr-claim).
-// .orquestra/<ID>/owner = "pane=<conductor id> account=<a> at=<iso>". Another conductor is refused while the owner is
-// alive; a dead owner is taken over automatically.
+// .orquestra/<ID>/owner = "pane=<conductor id> kind=<k> account=<a> at=<iso> name=<what the user calls it>". Another
+// conductor is refused while the owner is alive; a dead owner is taken over automatically.
+//   name: the herdr workspace's label (the sidebar name, e.g. "emp: orq-cms-dsgn"), else ORQ_CONDUCTOR_ID. It is the
+//   last field and may hold spaces. `--from <name>` finds a conductor's issues by any part of that name (or its pane).
 //   conductor id: HERDR_PANE_ID (alive = `herdr agent get` answers) or ORQ_CONDUCTOR_ID (alive = claimed or refreshed
 //   in the last ORQ_CLAIM_TTL_H hours, default 24 — any conductor, any terminal); neither → <user>@<host>.
-import { spawnSync } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { homedir, hostname, userInfo } from "node:os";
 import { basename, join, resolve } from "node:path";
 import { writeAtomic } from "../fsutil.js";
 import { m } from "../i18n.js";
 import { acquire, release } from "../lock.js";
-export const USAGE = `orq claim [-w <workspace>] <ID> | -f <ID> | -r <ID> | -l   issue owner among conductors (exit 1 = someone else's)`;
+export const USAGE = `orq claim [-w <workspace>] <ID> | -f <ID> | -r <ID> | -l | --register   issue owner among conductors (exit 1 = someone else's)
+orq claim [-w <workspace>] --from <name> [-f]   a conductor's issues by its name (part of it is enough); -f takes them all`;
 const field = (text, k) => new RegExp(`${k}=(\\S+)`).exec(text)?.[1] ?? "";
+export const nameOf = (text) => / name=(.*)$/m.exec(text)?.[1].trim() ?? "";
+const herdrList = (args) => {
+    const r = spawnSync("herdr", args, { encoding: "utf8", timeout: 5_000 });
+    try {
+        return JSON.parse(r.stdout).result;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** pane_id -> the label of the herdr workspace holding it (the name the user sees), for every live pane. One
+ *  `pane list` + one `workspace list` call, however many panes are being looked up. */
+export function herdrNames() {
+    const panes = herdrList(["pane", "list"])?.panes;
+    const workspaces = herdrList(["workspace", "list"])?.workspaces;
+    const labelOf = new Map((workspaces ?? []).map((w) => [w.workspace_id, w.label ?? ""]));
+    const out = new Map();
+    for (const p of panes ?? []) {
+        const label = p.workspace_id ? labelOf.get(p.workspace_id) : undefined;
+        if (label)
+            out.set(p.pane_id, label);
+    }
+    return out;
+}
+/** The label of the herdr workspace holding `pane` (the name the user sees), or "". */
+export function herdrName(pane) {
+    return herdrNames().get(pane) ?? "";
+}
+const herdrListAsync = (args) => new Promise((res) => execFile("herdr", args, { timeout: 5_000, windowsHide: true }, (_e, stdout) => {
+    try {
+        res(JSON.parse(stdout).result);
+    }
+    catch {
+        res(undefined);
+    }
+}));
+/** Same as herdrNames() for the given pane ids, but off the event loop (execFile, not spawnSync) — for a live,
+ *  repeatedly-redrawn caller like the board, where blocking would freeze the whole UI while herdr answers. One
+ *  `workspace list` is enough when the ids carry their workspace ("w8K:p1" -> "w8K"); `pane list` is only the
+ *  fallback for ids that don't. */
+export async function herdrNamesAsync(ids) {
+    const workspaces = (await herdrListAsync(["workspace", "list"]))?.workspaces;
+    const labelOf = new Map((workspaces ?? []).map((w) => [w.workspace_id, w.label ?? ""]));
+    const out = new Map();
+    const rest = [];
+    for (const id of ids) {
+        const label = labelOf.get(id.split(":")[0]);
+        if (label)
+            out.set(id, label);
+        else
+            rest.push(id);
+    }
+    if (rest.length) {
+        const panes = (await herdrListAsync(["pane", "list"]))?.panes;
+        for (const p of panes ?? []) {
+            const label = p.workspace_id ? labelOf.get(p.workspace_id) : undefined;
+            if (label && rest.includes(p.pane_id))
+                out.set(p.pane_id, label);
+        }
+    }
+    return out;
+}
+/** A `herdr agent get` result → owner alive. A timeout (busy daemon, slow herdr) must not read as a dead owner:
+ *  only a clean non-zero exit means "not found". */
+export function ownerAlive(r) {
+    if (r.error?.code === "ETIMEDOUT")
+        return true;
+    return r.status === 0;
+}
 export function aliveOwner(text) {
     const id = field(text, "pane"), kind = field(text, "kind") || "herdr";
     if (kind === "herdr")
-        return spawnSync("herdr", ["agent", "get", id], { stdio: "ignore" }).status === 0;
+        return ownerAlive(spawnSync("herdr", ["agent", "get", id], { stdio: "ignore", timeout: 15_000 }));
     const ttl = Number(process.env.ORQ_CLAIM_TTL_H ?? 24) * 3600_000;
     return Date.now() - Date.parse(field(text, "at")) < ttl;
 }
 export async function claim(argv) {
-    let ws = process.cwd(), mode = "claim", id;
+    let ws = process.cwd(), mode = "claim", id, from;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
         if (a === "-w")
             ws = resolve(argv[++i]);
+        else if (a === "--from")
+            from = argv[++i];
         else if (a === "-f")
             mode = "force";
         else if (a === "-r")
             mode = "release";
         else if (a === "-l")
             mode = "list";
+        else if (a === "--register")
+            mode = "register";
         else if (!a.startsWith("-"))
             id = a;
         else {
@@ -40,21 +116,82 @@ export async function claim(argv) {
     }
     const O = join(ws, ".orquestra");
     if (mode === "list") {
-        for (const d of existsSync(O) ? readdirSync(O) : []) {
+        const names = herdrNames(); // one herdr lookup for every issue in this listing, not one per issue
+        for (const d of existsSync(O) ? readdirSync(O).filter((x) => !x.startsWith(".")) : []) {
             const f = join(O, d, "owner");
             if (!existsSync(f))
                 continue;
             const t = readFileSync(f, "utf8").trim();
-            console.log(`${d} ${t} (${aliveOwner(t) ? "alive" : "dead"})`);
+            const alive = aliveOwner(t);
+            // The herdr workspace's current label while the pane is alive; the name stored at claim time otherwise
+            // (the user may have renamed the workspace since, or it may not be a herdr conductor at all).
+            const n = (alive && (field(t, "kind") || "herdr") === "herdr" ? names.get(field(t, "pane")) ?? "" : "") || nameOf(t);
+            console.log(`${d} ${n ? `"${n}" ` : ""}${t.replace(/ name=.*$/, "")} (${alive ? "alive" : "dead"})`);
         }
         return 0;
     }
+    const kind = process.env.HERDR_PANE_ID ? "herdr" : "id";
+    const me = process.env.HERDR_PANE_ID || process.env.ORQ_CONDUCTOR_ID || `${userInfo().username}@${hostname()}`;
+    const myName = (kind === "herdr" ? herdrName(me) : "") || process.env.ORQ_CONDUCTOR_ID || "";
+    const account = basename(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"));
+    const ownerLine = () => `pane=${me} kind=${kind} account=${account} at=${new Date().toISOString()}`
+        + (myName ? ` name=${myName}` : "") + "\n";
+    if (mode === "register") {
+        if (kind !== "herdr")
+            return 0;
+        const dir = join(O, ".conductors");
+        mkdirSync(dir, { recursive: true });
+        writeAtomic(join(dir, me.replace(/[^A-Za-z0-9_-]/g, "_")), `pane=${me} kind=herdr account=${account} at=${new Date().toISOString()} name=${myName || me}\n`);
+        return 0;
+    }
+    if (from !== undefined) {
+        if (!from) {
+            console.error(USAGE);
+            return 2;
+        }
+        const q = from.toLowerCase();
+        const liveNames = herdrNames(); // one herdr lookup for every issue being searched, not one per issue
+        const hits = (existsSync(O) ? readdirSync(O).filter((x) => !x.startsWith(".")) : []).flatMap((d) => {
+            const f = join(O, d, "owner");
+            if (!existsSync(f))
+                return [];
+            const t = readFileSync(f, "utf8").trim(), pane = field(t, "pane"), alive = aliveOwner(t);
+            const live = alive && (field(t, "kind") || "herdr") === "herdr" ? liveNames.get(pane) ?? "" : "";
+            const stored = nameOf(t), name = live || stored;
+            const names = [live, stored].filter(Boolean);
+            return pane !== me && (names.some((n) => n.toLowerCase().includes(q)) || pane.toLowerCase().includes(q))
+                ? [{ id: d, f, pane, name, alive }] : [];
+        });
+        if (!hits.length) {
+            console.log(m(`no issue owned by a conductor matching "${from}"`, `nenhuma issue de um conductor que bata com "${from}"`));
+            return 1;
+        }
+        const owners = [...new Set(hits.map((h) => h.pane))];
+        if (owners.length > 1) {
+            console.log(m(`"${from}" matches more than one conductor; be more specific:`, `"${from}" bate com mais de um conductor; seja mais específico:`));
+            for (const o of owners)
+                console.log(`  ${hits.find((h) => h.pane === o).name || o} (${o})`);
+            return 3;
+        }
+        for (const h of hits)
+            console.log(`${h.id} "${h.name || h.pane}" (${h.alive ? "alive" : "dead"})`);
+        if (mode !== "force")
+            return 0;
+        await acquire("claims", process.pid, `claim --from ${from}`);
+        try {
+            for (const h of hits)
+                writeAtomic(h.f, ownerLine());
+        }
+        finally {
+            release("claims", process.pid);
+        }
+        console.log(m(`taken over: ${hits.map((h) => h.id).join(" ")} (now ${myName || me})`, `assumidas: ${hits.map((h) => h.id).join(" ")} (agora ${myName || me})`));
+        return 0;
+    }
     if (!id) {
         console.error(m("give the issue ID", "informe o ID da issue"));
         return 2;
     }
-    const kind = process.env.HERDR_PANE_ID ? "herdr" : "id";
-    const me = process.env.HERDR_PANE_ID || process.env.ORQ_CONDUCTOR_ID || `${userInfo().username}@${hostname()}`;
     mkdirSync(join(O, id), { recursive: true });
     const F = join(O, id, "owner");
     await acquire("claims", process.pid, `claim ${id}`); // one claim at a time
@@ -77,8 +214,7 @@ export async function claim(argv) {
             }
             console.log(m(`previous owner (${owner}) is gone; taking over ${id}`, `o dono anterior (${owner}) não existe mais; assumindo ${id}`));
         }
-        const account = basename(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"));
-        writeAtomic(F, `pane=${me} kind=${kind} account=${account} at=${new Date().toISOString()}\n`);
+        writeAtomic(F, ownerLine());
         console.log(cur && owner === me && mode === "claim" ? m(`${id} is already yours`, `${id} já é sua`) : m(`${id} is yours (${me})`, `${id} é sua (${me})`));
         return 0;
     }

package/dist/commands/completion.js

@@ -8,10 +8,10 @@
 export const USAGE = "orq completion bash|zsh|fish|powershell   print the shell completion script (see docs)";
 const DESC = {
     setup: "guided first configuration", config: "show the merged config", set: "write one config value", lang: "language of orq's messages",
-    quota: "quota per agent/account", pick: "pick agent, model and account for a role", stats: "scoreboard per agent",
+    quota: "quota per agent/account", pick: "pick agent, model and account for a role", stats: "scoreboard per agent", rounds: "rounds, time and repeated findings of an issue",
     board: "live board", lock: "test queue", run: "run a command under a memory cap", agent: "run a child agent",
     wait: "wait for child agents", verify: "tests of a diff", baseline: "tests already failing on the base",
-    instructions: "write the /issue playbook", claim: "issue owner among conductors", deps: "link node_modules into a worktree", gc: "remove merged issue worktrees",
+    instructions: "write the /issue playbook", claim: "issue owner among conductors", deps: "link node_modules into a worktree", gc: "remove merged issue worktrees", ci: "CI/CD status per claimed issue", handoff: "move a conductor low on quota to another account",
     block: "block an agent or account", completion: "shell completion script",
 };
 /** Fixed words after a subcommand. */
@@ -20,6 +20,7 @@ export const WORDS = {
     config: ["get", "files", "-w"], lang: ["pt", "en", "auto", "toggle"], lock: ["wait", "release", "run", "status"],
     pick: ["impl", "fix", "worker", "review", "opinion"], instructions: ["claude", "agents"], board: ["--once", "--json", "-w"],
     completion: ["bash", "zsh", "fish", "powershell"], stats: ["--days", "--json", "-w"], wait: ["--any", "--timeout", "--answer"],
+    ci: ["--json", "-w"], rounds: ["--json", "-w"],
 };
 const q = (s) => `'${s.replace(/'/g, "''")}'`; // PowerShell single quotes
 const qf = (s) => `'${s.replace(/[\\']/g, "\\$&")}'`; // fish single quotes