@irythill/orq 0.5.0 → 0.6.0

package/dist/commands/agent.js

@@ -10,7 +10,7 @@
 // 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";
+import { appendFileSync, copyFileSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { claudeAccounts } from "../accounts.js";
@@ -21,7 +21,7 @@ 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 { killedRc, 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";
@@ -130,6 +130,22 @@ export async function agent(argv) {
         return 2;
     }
     const repo = resolve(d), O = resolve(o);
+    // A live run on this prefix owns its files: a second agent on the same files (and its .done) is how a false DONE happens.
+    // Only a -T -R follow-up typed into that run's own open screen may reuse it.
+    let open = "", pid = 0;
+    try {
+        open = readFileSync(`${O}.pane`, "utf8").trim();
+    }
+    catch { /* first run */ }
+    try {
+        pid = Number(readFileSync(`${O}.pid`, "utf8"));
+    }
+    catch { /* none or ended */ }
+    const typed = tui && resume && alive(pid) && screenOpen(open);
+    if (!typed && runLive(O, pid)) {
+        console.error(m(`${basename(O)} still has a live run (${pid ? `pid ${pid}` : "unit active"}): wait for it (orq wait ${O}) or stop it, or use another prefix. Nothing started.`, `${basename(O)} ainda tem uma execução viva (${pid ? `pid ${pid}` : "unit ativa"}): espere (orq wait ${O}) ou pare, ou use outro prefixo. Nada foi iniciado.`));
+        return 3;
+    }
     // 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) {
@@ -185,13 +201,7 @@ export async function agent(argv) {
     // 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)) {
+    if (typed) {
         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 });
@@ -264,7 +274,8 @@ 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,
+        okExit: def.ok_exit, filter: def.filter, noReview: def.no_review, ro,
+        idleCloseMin: tui ? Number(mach.tui_idle_close_min ?? 30) : undefined,
     };
     writeAtomic(`${O}.job.json`, JSON.stringify(job, null, 1));
     // Readable copy of the command (also what orq stats and herdr-board read).
@@ -276,6 +287,20 @@ export async function agent(argv) {
     console.log(`[orq agent] ${t} → ${where}${tui ? " (TUI)" : ""}`);
     return 0;
 }
+/** The previous run on prefix `O` is still going: its runner pid is alive, or (no pid file yet / runner gone) its systemd scope is. */
+function runLive(O, pid) {
+    if (alive(pid))
+        return true;
+    if (existsSync(`${O}.done`) || process.platform !== "linux")
+        return false; // finished (or no systemd): the pid said it all
+    try {
+        const unit = JSON.parse(readFileSync(`${O}.job.json`, "utf8")).unit;
+        return Boolean(unit) && spawnSync("systemctl", ["--user", "is-active", "--quiet", `${unit}.scope`], { timeout: 5_000 }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
 /** 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)
@@ -392,6 +417,26 @@ function noReviewMatch(pattern, answer) {
     return re.test(first) || (answer.trim().length <= 200 && re.test(answer));
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** A -T agent is idle when its turn ended (.done exists) and, for `idleMs`, nothing touched .done (a follow-up removes
+ *  it, a turn's end rewrites it) and the screen was not seen busy (`busyAt`, epoch ms, from herdr's agent status). */
+export function idleExpired(done, idleMs, now = Date.now(), busyAt = 0) {
+    try {
+        return idleMs > 0 && now - Math.max(statSync(done).mtimeMs, busyAt) >= idleMs;
+    }
+    catch {
+        return false;
+    }
+}
+/** herdr's view of the agent on a pane: working | blocked | idle | done | unknown; undefined when it can't be read. */
+function paneStatus(pane) {
+    const r = spawnSync("herdr", ["pane", "get", pane], { encoding: "utf8", timeout: 5_000 });
+    try {
+        return r.status === 0 ? JSON.parse(r.stdout).result?.pane?.agent_status : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Splits a stream into lines for `each`. */
 function lines(s, each) {
     return new Promise((res) => {
@@ -420,6 +465,8 @@ async function runJob(file) {
     state();
     const fmt = FORMATS[j.format] ?? FORMATS.text;
     let rc = 0, stdout = "", logText = "";
+    // State of the worktree before the run, to tell what this run changed (a -R on a dirty tree is not progress).
+    const headBefore = j.throwaway ? undefined : git(j.dir, "rev-parse", "HEAD"), statusBefore = j.throwaway ? undefined : git(j.dir, "status", "--porcelain");
     const pre = () => {
         if (j.throwaway) {
             // Throwaway worktree: detached copy of HEAD with the repo's node_modules linked; removed at the end.
@@ -457,20 +504,26 @@ async function runJob(file) {
     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) => {
+        const end = (code, killed = false) => {
             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`)) {
+            const ok = !killed && /\bstatus=ok\b/.test(existsSync(`${O}.done`) ? readFileSync(`${O}.done`, "utf8") : "");
+            if (killed) {
+                // SIGKILL & co: whatever an earlier turn wrote, the screen did not end normally.
+                writeAtomic(`${O}.done`, `status=killed rc=${code} at=${new Date().toISOString()} agent=${j.agent} mode=tui\n`);
+                if (j.parent)
+                    notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=killed rc=${code} answer: ${O}.out.md`);
+            }
+            else 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`);
             }
             rmSync(`${O}.pid`, { force: true });
-            return ok ? "ok" : "fail";
+            return killed ? "killed" : ok ? "ok" : "fail";
         };
         if (!pre())
             rc = 2;
@@ -480,16 +533,46 @@ async function runJob(file) {
                 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;
+            let child, idleT, idleClosed = false;
             process.on("SIGINT", () => { });
+            // The screen going away or being killed from outside: end the agent, and close the tab too (a dead tab stayed open).
             const gone = () => { if (child)
-                killTree(child, false); end(129); process.exit(0); };
+                killTree(child, false); end(129); closeOwnTab(j.host); 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; } });
+                onSpawn: (c) => {
+                    child = c.pid;
+                    // A finished agent waits for a follow-up forever and holds its memory: after the idle timeout without a new
+                    // turn, kill it; the normal end below cleans up and closes the tab. "New turn" = .done removed (`-R` typed
+                    // into the screen removes it) or rewritten (the next end of turn), so idle = .done untouched that long.
+                    const idleMs = (j.idleCloseMin ?? 0) * 60_000;
+                    if (idleMs > 0 && !j.keep) {
+                        // On herdr the pane's agent status also catches a turn typed straight into the screen (.done only changes
+                        // when it ends). Elsewhere (tmux) only .done tells: a turn typed directly into the screen that runs longer
+                        // than the timeout can still be closed.
+                        let busyAt = 0;
+                        const pane = j.host === "herdr" ? process.env.HERDR_PANE_ID : undefined;
+                        idleT = setInterval(() => {
+                            const st = pane ? paneStatus(pane) : undefined;
+                            if (st === "working" || st === "blocked")
+                                busyAt = Date.now();
+                            if (!idleExpired(`${O}.done`, idleMs, Date.now(), busyAt))
+                                return;
+                            clearInterval(idleT);
+                            console.log(m(`[orq agent] no follow-up for ${j.idleCloseMin} min: closing the finished agent`, `[orq agent] sem follow-up há ${j.idleCloseMin} min: fechando o agente que terminou`));
+                            idleClosed = true;
+                            if (child)
+                                killTree(child, false);
+                        }, Math.min(30_000, Math.max(1_000, idleMs / 2)));
+                        idleT.unref();
+                    }
+                } });
+            clearInterval(idleT);
+            if (idleClosed)
+                rc = 0; // closed on purpose after a finished turn: not a kill
         }
-        const st = end(rc);
+        const st = end(rc, killedRc(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) {
@@ -552,12 +635,24 @@ async function runJob(file) {
     await new Promise((r) => log.end(r));
     post();
     const res = fmt.finish(logText, stdout);
+    // Denied commands do not sink a write run that did work: keep the diff and report ok with the denied list in the answer.
+    let recovered = false;
+    if (res.denied?.length && !j.ro && !j.throwaway && existsSync(j.dir)) {
+        const status = git(j.dir, "status", "--porcelain"), head = git(j.dir, "rev-parse", "HEAD");
+        if (status !== statusBefore || head !== headBefore) {
+            const stat = (headBefore && git(j.dir, "diff", "--stat", headBefore)) || status || `HEAD ${headBefore?.slice(0, 7)} -> ${head?.slice(0, 7)}`;
+            recovered = true;
+            res.answer = `${res.answer ?? ""}\n## Worktree\nSome commands were denied, but the worktree changes are kept (review them before accepting):\n\`\`\`\n${stat}\n\`\`\`\n`;
+        }
+        else
+            res.answer = `${res.answer ?? ""}\nNo changes were made in the worktree.\n`;
+    }
     if (j.answer !== "file")
         writeFileSync(`${O}.out.md`, res.answer ?? "");
     const sid = j.fromLog ? new RegExp(j.fromLog, "m").exec(logText)?.[1] : res.session ?? j.session;
     if (sid)
         writeFileSync(`${O}.id`, `${sid}\n`);
-    if (rc === 0 && res.rc)
+    if (rc === 0 && res.rc && !recovered)
         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);
@@ -578,7 +673,8 @@ async function runJob(file) {
     // 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
+    // killed (SIGKILL, memory cap...) is its own status: never ok, even if an ok_exit list or a leftover answer says otherwise.
+    const st = killedRc(rc) ? "killed" : 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/board.js

@@ -19,7 +19,7 @@ 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 { killedRc, processTableAsync, treeMem, treePids } from "../process.js";
 import { collect } from "../quota.js";
 import { collectRounds, mark, roundsSig } from "../rounds.js";
 import { collectRuns, rows } from "../stats.js";
@@ -29,7 +29,7 @@ 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));
-const QTTL = 300_000, RECENT_MS = 30 * 60_000, ORPHAN_MS = 24 * 3600_000;
+const QTTL = 300_000, HIDE_H = 6; // finished/dead rows older than ui.board_hide_hours (default 6) are folded into a count
 const read = (f) => { try {
     return readFileSync(f, "utf8");
 }
@@ -91,9 +91,47 @@ function tail(file, bytes = 16_384) {
             closeSync(fd);
     }
 }
+// --- idle detection -----------------------------------------------------------------------------------------------
+// An interactive (-T) agent that finished keeps its screen, and its pid, open: "running" for hours. Its tree's CPU time
+// (/proc/<pid>/stat, utime+stime) barely moves while it only waits. Samples persist in <state>/board/cpu.json so a
+// one-shot board and a restarted one see the same history: per unit, the CPU reading when it last did real work.
+const IDLE_MIN = 30, ACTIVE_TICKS = 200; // 2 s of CPU (at 100 ticks/s) since the baseline counts as work
+/** utime+stime, in clock ticks, summed over `pids` (Linux; undefined elsewhere or when nothing is readable). */
+export function cpuTicks(pids) {
+    if (process.platform !== "linux")
+        return undefined;
+    let sum;
+    for (const p of pids) {
+        // comm (field 2) may hold spaces and parens: fields resume after the last ")"; state is field 3, utime/stime 14/15.
+        const raw = read(`/proc/${p}/stat`), f = raw.slice(raw.lastIndexOf(")") + 2).split(" ");
+        const t = Number(f[11]) + Number(f[12]);
+        if (!Number.isNaN(t))
+            sum = (sum ?? 0) + t;
+    }
+    return sum;
+}
+/** Seconds `unit` has been idle (no real CPU work since its baseline), or 0 while it is not; updates `base` in place. */
+export function idleFor(base, unit, ticks, now, idleMin = IDLE_MIN) {
+    const b = base[unit];
+    if (!b || ticks < b.ticks || ticks - b.ticks >= ACTIVE_TICKS) {
+        base[unit] = { ticks, at: now };
+        return 0;
+    } // new, restarted tree, or worked
+    return now - b.at >= idleMin * 60_000 ? Math.round((now - b.at) / 1000) : 0;
+}
+const cpuFile = () => join(qdir(), "cpu.json");
+function idleMinutes() {
+    const v = Number(getPath(loadConfig().cfg, "ui.board_idle_min") ?? IDLE_MIN);
+    return v > 0 ? v : IDLE_MIN;
+}
 function agents(table, now) {
-    const d = join(stateDir(), "agents"), out = [];
-    let files = [];
+    const d = join(stateDir(), "agents"), out = [], running = new Set(), cpu = (() => { try {
+        return JSON.parse(read(cpuFile()));
+    }
+    catch {
+        return {};
+    } })();
+    let idleMin, files = [];
     try {
         files = readdirSync(d).filter((f) => f.endsWith(".json"));
     }
@@ -108,24 +146,43 @@ function agents(table, now) {
         }
         const pid = Number(s.pid), at = Date.parse(String(s.at)), end = s.end ? Date.parse(String(s.end)) : undefined;
         const prefix = String(s.prefix ?? "");
-        const st = s.status === "ok" || s.status === "fail" ? s.status : alive(pid) ? "running" : "died";
-        if (st === "died" && now - at > ORPHAN_MS)
-            continue;
-        if ((st === "ok" || st === "fail") && now - (end ?? at) > RECENT_MS)
-            continue;
+        const st = s.status === "ok" && killedRc(Number(s.rc)) ? "killed" : s.status === "ok" || s.status === "fail" || s.status === "killed" ? s.status : alive(pid) ? "running" : "died";
         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 };
+            secs: Math.max(0, Math.round(((end ?? now) - at) / 1000)), age: Math.max(0, Math.round((now - (end ?? at)) / 1000)), cap: typeof s.cap === "number" ? s.cap : undefined };
         if (s.rc !== undefined)
             a.rc = Number(s.rc);
         if (st === "running") {
-            if (table)
+            if (table) {
                 a.mem = treeMem(pid, table);
+                const t = cpuTicks(treePids(pid, table));
+                if (t !== undefined) {
+                    running.add(a.unit);
+                    const i = idleFor(cpu, a.unit, t, now, idleMin ??= idleMinutes());
+                    if (i) {
+                        a.state = "idle";
+                        a.idleSecs = i;
+                    }
+                }
+            }
             a.activity = activity(tail(`${prefix}.log`))?.replace(/\s+/g, " ").replace(homedir(), "~").slice(0, 60);
         }
         out.push(a);
     }
-    const rank = { running: 0, died: 1, fail: 2, ok: 3 };
+    if (table) { // keep baselines of units still running; the rest are done or gone
+        for (const u of Object.keys(cpu))
+            if (!running.has(u))
+                delete cpu[u];
+        const text = JSON.stringify(cpu);
+        if (text !== read(cpuFile())) {
+            try {
+                mkdirSync(qdir(), { recursive: true });
+                writeAtomic(cpuFile(), text);
+            }
+            catch { /* best effort */ }
+        }
+    }
+    const rank = { running: 0, idle: 1, died: 1, killed: 2, fail: 2, ok: 3 };
     return out.sort((x, y) => rank[x.state] - rank[y.state] || y.secs - x.secs);
 }
 const field = (t, k) => new RegExp(`${k}=(\\S+)`).exec(t)?.[1] ?? "";
@@ -310,7 +367,12 @@ const when = (sec) => {
 };
 const gb = (b) => (b ? `${(b / 2 ** 30).toFixed(1)} GB` : "-");
 const fit = (s, n) => (s.length > n ? s.slice(0, Math.max(0, n - 1)) + "…" : s.padEnd(n));
-export function render(s, theme, cols, mode = colorMode()) {
+/** Hours after which finished/dead agents leave the board (they stay in --json). */
+export function hideHours() {
+    const v = Number(getPath(loadConfig().cfg, "ui.board_hide_hours") ?? HIDE_H);
+    return v > 0 ? v : HIDE_H;
+}
+export function render(s, theme, cols, mode = colorMode(), hideH = HIDE_H) {
     const c = inks(theme, mode), W = Math.max(60, cols), out = [];
     const meter = (pct, n) => {
         const f = Math.min(n, Math.round(Math.max(0, pct) * n / 100)), k = pct >= 90 ? c.err : pct >= 70 ? c.wrn : c.ok;
@@ -342,21 +404,29 @@ export function render(s, theme, cols, mode = colorMode()) {
     if (!s.queue.holders.length && !s.queue.waiters.length)
         out.push(` ${c.mut}${m("empty", "vazia")}${c.r}`);
     section("TRACKS", m("agents", "agentes"));
-    s.agents.forEach((a, i) => {
+    // A finished or dead agent stops being news after a while; running ones always show. age = since its end (a
+    // died row's end is unknown: since its start).
+    const old = (a) => a.state !== "running" && a.state !== "idle" && a.age > hideH * 3600;
+    const shownAgents = s.agents.filter((a) => !old(a)), hidden = s.agents.length - shownAgents.length;
+    shownAgents.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}${(a.state === "died" ? "?" : dur(a.secs)).padEnd(7)}${c.r}`; // died: when it stopped is unknown
-        if (a.state === "running") {
+        if (a.state === "running" || a.state === "idle") {
             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}` : "";
-            out.push(` ${c.acc}●${c.r} ${n}  ${who} ${meter(pct, 4)} ${c.ink2}${gb(a.mem).padEnd(6)}${c.r} ${c.mut}${fit(a.activity ?? "", Math.max(0, W - used - 2)).trimEnd()}${c.r}${warn}`);
+            const idle = a.state === "idle", mark = idle ? `${c.wrn}◌` : `${c.acc}●`;
+            const warn = !idle && a.secs > 3 * 3600 ? ` ${c.err}⚠ ${m("for", "há")} ${dur(a.secs)}${c.r}` : "";
+            const what = idle ? `${c.wrn}${m("idle", "ocioso")} ${dur(a.idleSecs ?? 0)}` : fit(a.activity ?? "", Math.max(0, W - used - 2)).trimEnd();
+            out.push(` ${mark}${c.r} ${n}  ${who} ${meter(pct, 4)} ${c.ink2}${gb(a.mem).padEnd(6)}${c.r} ${c.mut}${what}${c.r}${warn}`);
         }
         else if (a.state === "died")
             out.push(` ${c.err}●${c.r} ${n}  ${who} ${c.err}${m("runner gone without finishing", "runner sumiu sem terminar")}${c.r}`);
         else
             out.push(` ${a.state === "ok" ? c.ok : c.err}${a.state === "ok" ? "✓" : "✗"}${c.r} ${n}  ${c.mut}${a.issue.padEnd(9).slice(0, 9)} ${fit(a.label, 22)} ${fit(a.agent, 11)}${fit(a.model ?? "", 17)} ${dur(a.secs).padEnd(7)} ${a.state} rc=${a.rc ?? "?"}${c.r}`);
     });
-    if (!s.agents.length)
+    if (!shownAgents.length)
         out.push(` ${c.mut}${m("none", "nenhum")}${c.r}`);
+    if (hidden)
+        out.push(` ${c.mut}${m(`+${hidden} older finished hidden`, `+${hidden} antigos finalizados ocultos`)}${c.r}`);
     section("MASTER", m("conductors", "conductors"));
     for (const k of s.conductors)
         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}`);
@@ -441,7 +511,7 @@ export async function board(argv) {
     }
     const tty = Boolean(process.stdout.isTTY);
     if (once || !tty) {
-        const lines = render(await snapshot(wss, await processTableAsync()), theme, process.stdout.columns ?? 100);
+        const lines = render(await snapshot(wss, await processTableAsync()), theme, process.stdout.columns ?? 100, colorMode(), hideHours());
         const c = inks(theme);
         process.stdout.write(lines.map((l) => c.base + l + (c.base ? "\x1b[K" : "")).join("\n") + (c.base ? "\x1b[0m" : "") + "\n");
         return 0;
@@ -457,7 +527,7 @@ export async function board(argv) {
         }
         drawing = true;
         try {
-            const c = inks(theme), lines = render(await snapshot(wss, table), theme, out.columns ?? 100);
+            const c = inks(theme), lines = render(await snapshot(wss, table), theme, out.columns ?? 100, colorMode(), hideHours());
             out.write(`${c.base}\x1b[H` + lines.map((l) => c.base + l + "\x1b[K").join("\n") + `${c.base}\x1b[J`);
         }
         finally {

package/dist/commands/claim.js

@@ -12,6 +12,7 @@ import { basename, join, resolve } from "node:path";
 import { writeAtomic } from "../fsutil.js";
 import { m } from "../i18n.js";
 import { acquire, release } from "../lock.js";
+import { handoffFile } from "../notice.js";
 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] ?? "";
@@ -139,6 +140,7 @@ export async function claim(argv) {
     if (mode === "register") {
         if (kind !== "herdr")
             return 0;
+        rmSync(handoffFile(me), { force: true }); // this pane is a live conductor again: drop a stale `orq handoff` redirect out of it
         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`);

package/dist/commands/completion.js

@@ -11,7 +11,7 @@ const DESC = {
     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", ci: "CI/CD status per claimed issue", handoff: "move a conductor low on quota to another account",
+    instructions: "write the /issue playbook", conductor: "open the conductor (Claude) in this terminal", 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. */

package/dist/commands/conductor.js

@@ -0,0 +1,104 @@
+// orq conductor — opens the conductor (Claude Code) in the current terminal, with the workspace's conductor
+// instructions, the chosen account and model (port of setup/herdr-conductor, for any terminal and OS).
+//   orq conductor [account|-] [model] [-r <session>]
+// Workspace: the current folder if it has .orquestra-conductor.md, else $CONDUCTOR_WS. $CONDUCTOR_FILE overrides the
+// instructions file. The session is named conductor-<workspace folder>.
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { claudeAccounts } from "../accounts.js";
+import { m } from "../i18n.js";
+import { runCapped } from "../process.js";
+import { claim } from "./claim.js";
+export const USAGE = `orq conductor [account|-] [model] [-r <session>]   open the conductor (Claude) here: instructions, account, model
+  model: sonnet | opus | haiku | a full id; "-" as account = default account; -r resumes that conversation`;
+export const MODELS = {
+    sonnet: "claude-sonnet-5",
+    opus: "claude-opus-5-5",
+    haiku: "claude-haiku-4-5-20251001",
+};
+export const modelId = (alias) => MODELS[alias] ?? alias;
+/** [account|-] [model] [-r|--resume <id>]; further positionals are ignored (as herdr-conductor did). */
+export function parseArgs(argv) {
+    const out = { account: "", model: "", resume: "", help: false };
+    const pos = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-r" || a === "--resume") {
+            const v = argv[++i];
+            if (!v) {
+                out.error = m("give the session id", "informe o id da sessão");
+                return out;
+            }
+            out.resume = v;
+        }
+        else if (a === "-h" || a === "--help")
+            out.help = true;
+        else
+            pos.push(a);
+    }
+    [out.account = "", out.model = ""] = pos;
+    return out;
+}
+/** The workspace folder: cwd when it holds .orquestra-conductor.md, else $CONDUCTOR_WS (resolved); undefined if neither. */
+export function findWorkspace(cwd, env, exists = existsSync) {
+    if (exists(join(cwd, ".orquestra-conductor.md")))
+        return cwd;
+    return env.CONDUCTOR_WS ? resolve(cwd, env.CONDUCTOR_WS) : undefined;
+}
+export const instructionsFile = (ws, env) => env.CONDUCTOR_FILE ? resolve(env.CONDUCTOR_FILE) : join(ws, ".orquestra-conductor.md");
+/** The claude command line (without the executable). The instructions go by file, so no shell ever sees their text. */
+export function claudeArgs(ws, a, file) {
+    return [...(a.resume ? ["--resume", a.resume] : []), "-n", `conductor-${basename(ws)}`,
+        ...(a.model ? ["--model", modelId(a.model)] : []), "--append-system-prompt-file", file];
+}
+export async function conductor(argv) {
+    const a = parseArgs(argv);
+    if (a.help) {
+        console.log(USAGE);
+        return 0;
+    }
+    if (a.error) {
+        console.error(a.error);
+        return 2;
+    }
+    const ws = findWorkspace(process.cwd(), process.env);
+    if (!ws) {
+        console.error(m("no .orquestra-conductor.md here: cd into a workspace (orq setup --workspace <dir>) or set CONDUCTOR_WS", "não há .orquestra-conductor.md aqui: entre num workspace (orq setup --workspace <pasta>) ou defina CONDUCTOR_WS"));
+        return 2;
+    }
+    const file = instructionsFile(ws, process.env);
+    if (!existsSync(file)) {
+        console.error(`${m("conductor instructions not found", "instruções do conductor não encontradas")}: ${file}`);
+        return 2;
+    }
+    const env = { ...process.env };
+    if (a.account && a.account !== "-") {
+        const accounts = claudeAccounts(), found = accounts.find((x) => x.name === a.account);
+        if (!found) {
+            console.error(m(`account '${a.account}' does not exist. Accounts:`, `a conta '${a.account}' não existe. Contas:`));
+            for (const x of accounts)
+                console.error(`${x.name} ${x.dir}`);
+            return 1;
+        }
+        env.CLAUDE_CONFIG_DIR = found.dir;
+    }
+    if (process.env.HERDR_ENV === "1" && process.env.HERDR_PANE_ID)
+        spawnSync("herdr", ["pane", "rename", process.env.HERDR_PANE_ID, "conductor"], { stdio: "ignore", timeout: 5_000 });
+    process.chdir(ws);
+    // Registration (.orquestra/.conductors) is a herdr thing (keyed by pane id; `claim --register` does nothing elsewhere),
+    // so only inside herdr. claim reads the account from this process's env (best effort, silent).
+    const saved = process.env.CLAUDE_CONFIG_DIR;
+    if (env.CLAUDE_CONFIG_DIR)
+        process.env.CLAUDE_CONFIG_DIR = env.CLAUDE_CONFIG_DIR;
+    if (process.env.HERDR_PANE_ID)
+        try {
+            await claim(["-w", ws, "--register"]);
+        }
+        catch { /* best effort */ }
+    if (saved === undefined)
+        delete process.env.CLAUDE_CONFIG_DIR;
+    else
+        process.env.CLAUDE_CONFIG_DIR = saved;
+    return runCapped("claude", claudeArgs(ws, a, file), { mode: "off", env, cwd: ws, quote: true, tty: true });
+}

package/dist/commands/gc.js

@@ -1,20 +1,27 @@
 // orq gc — find issue worktrees whose branch is already safe to remove.
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
-import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { existsSync, readdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { loadConfig } from "../config.js";
 import { m } from "../i18n.js";
+import { alive } from "../lock.js";
+import { stateDir } from "../paths.js";
 import { aliveOwner } from "./claim.js";
-export const USAGE = "orq gc [-w <workspace>] [--yes] [--days N] [--json]   remove merged issue worktrees";
+export const USAGE = "orq gc [-w <workspace>] [--yes] [--days N] [--json]   remove merged issue worktrees and stale agent state";
 const git = (cwd, ...args) => spawnSync("git", ["-C", cwd, ...args], { encoding: "utf8" });
 // Paths as git prints them can differ from ours (macOS /var → /private/var, Windows C:/ vs C:\): compare real paths.
-const real = (p) => { try {
-    return realpathSync.native(p);
-}
-catch {
-    return resolve(p);
-} };
-const inside = (dir, p) => { const r = relative(dir, p); return !!r && !r.startsWith("..") && !isAbsolute(r); };
+// A path that does not exist (yet) is resolved through its deepest existing ancestor, so both sides get the same prefix.
+const real = (p) => {
+    const abs = resolve(p);
+    try {
+        return realpathSync.native(abs);
+    }
+    catch { /* missing: resolve the parent */ }
+    const up = dirname(abs);
+    return up === abs ? abs : join(real(up), basename(abs));
+};
+const fold = (p) => (process.platform === "win32" ? p.toLowerCase() : p); // NTFS is case-insensitive
+const inside = (dir, p) => { const r = relative(fold(dir), fold(p)); return !!r && !r.startsWith("..") && !isAbsolute(r); };
 // ORQ_GH may be a .js file (tests: a fake gh that also runs on Windows).
 const gh = (cwd, args) => {
     const bin = process.env.ORQ_GH || "gh";
@@ -22,6 +29,30 @@ const gh = (cwd, args) => {
         : spawnSync(bin, args, { cwd, encoding: "utf8" });
 };
 const output = (cwd, ...args) => { const r = git(cwd, ...args); return r.status === 0 ? r.stdout.trim() : undefined; };
+/** Per-agent state files (<state>/agents/<unit>.json) of runs under `ws` that are finished or dead and older than `days`. */
+function staleAgentStates(ws, days, now) {
+    const dir = join(stateDir(), "agents"), out = [];
+    let files = [];
+    try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+    }
+    catch { /* no runs yet */ }
+    for (const f of files) {
+        try {
+            const s = JSON.parse(readFileSync(join(dir, f), "utf8"));
+            if (!inside(real(ws), real(String(s.prefix ?? ""))))
+                continue;
+            const finished = s.status === "ok" || s.status === "fail" || s.status === "killed";
+            if (!finished && alive(Number(s.pid)))
+                continue;
+            const since = Date.parse(String(s.end ?? s.at));
+            if (now - since > days * 86400_000)
+                out.push(join(dir, f));
+        }
+        catch { /* unreadable state: leave it */ }
+    }
+    return out;
+}
 export async function gc(argv, clock = Date.now) {
     let ws = process.cwd(), yes = false, json = false, days = 14;
     for (let i = 0; i < argv.length; i++) {
@@ -153,6 +184,10 @@ export async function gc(argv, clock = Date.now) {
             }
             git(join(ws, row.repo), "worktree", "prune");
         }
+    const stale = staleAgentStates(ws, days, clock());
+    if (yes)
+        for (const f of stale)
+            rmSync(f, { force: true });
     if (json)
         console.log(JSON.stringify(rows));
     else {
@@ -160,5 +195,8 @@ export async function gc(argv, clock = Date.now) {
         const w = table[0].map((_, i) => Math.max(...table.map((t) => t[i].length)));
         console.log(table.map((t) => t.map((c, i) => i < t.length - 1 ? c.padEnd(w[i]) : c).join("  ")).join("\n"));
     }
+    if (stale.length && !json)
+        console.log(yes ? m(`pruned ${stale.length} stale agent state file(s)`, `${stale.length} arquivo(s) de estado de agente antigo(s) removido(s)`)
+            : m(`${stale.length} stale agent state file(s) (finished/dead, older than ${days} days): --yes removes them`, `${stale.length} arquivo(s) de estado de agente antigo(s) (terminados/mortos, mais de ${days} dias): --yes remove`));
     return failed ? 1 : 0;
 }