@irythill/orq 0.2.0 → 0.4.0

package/dist/commands/quota.js

@@ -1,25 +1,49 @@
-// orq quota [name...]   quota of each source in [quota] (default: all) — lines "<name> 5h=NN% week=NN% [note]"
+// orq quota [name...]   quota of each source in [quota] (default: all) — lines "<name> 5h=NN% week=NN% [note]", with
+//                       reset5h=/resetweek= epochs shown as human times at the end (e.g. "5h=92% week=40% (5h resets 14:30)")
 // orq quota --line      one line for a status bar (herdr's tab_bar_right command entry): the board's cache, never
 //                       the network — a stale cache starts the board's background collection, like the board does.
 import { getPath, loadConfig } from "../config.js";
 import { m } from "../i18n.js";
-import { collect } from "../quota.js";
+import { limitsFor } from "../pick.js";
+import { collect, humanReset } from "../quota.js";
 import { quota as cached } from "./board.js";
 import { load as loadBlocks } from "./block.js";
 export const USAGE = `orq quota [name...]                   quota per agent/account ([quota] in the config)
 orq quota --line                      one line for a status bar, from the board's cache (e.g. herdr tab_bar_right)`;
 const pct = (p) => (/^\d+%$/.test(p) ? Number(p.slice(0, -1)) : undefined);
-/** "work 64 · home 93! · codex 81 · minimax ?": the tighter of the two windows per source; ! at or over the pick
- *  limit, ⊘ blocked (orq block), ? no data; sources with no window at all ("-" and "-") are left out. */
-export function quotaLine(lines, limit, blocked, age) {
+/** A "name 5h=.. reset5h=<epoch> week=.. resetweek=<epoch> [note]" line → the same "name 5h=.. week=.." kept intact,
+ *  with the raw epoch fields dropped and human reset times ("resets 14:30") moved to the end of the line, before
+ *  any [note]. */
+export function humanizeQuotaLine(line, now = Date.now()) {
+    const r5 = /reset5h=(\d+)/.exec(line), rw = /resetweek=(\d+)/.exec(line);
+    if (!r5 && !rw)
+        return line.replace(/ span5h=\d+/, "").replace(/ spanweek=\d+/, "");
+    let out = line.replace(/ reset5h=\d+/, "").replace(/ resetweek=\d+/, "")
+        .replace(/ span5h=\d+/, "").replace(/ spanweek=\d+/, "");
+    const parts = [];
+    if (r5)
+        parts.push(`${m("5h", "5h")} ${m("resets", "renova")} ${humanReset(Number(r5[1]), now)}`);
+    if (rw)
+        parts.push(`${m("week", "semana")} ${m("resets", "renova")} ${humanReset(Number(rw[1]), now)}`);
+    const reset = `(${parts.join(", ")})`;
+    const note = /(\[.*\])$/.exec(out);
+    return note ? `${out.slice(0, note.index).trimEnd()} ${reset} ${note[1]}` : `${out.trimEnd()} ${reset}`;
+}
+/** "work 64 · home 93! · codex 81 · minimax ?": the tighter of the two windows per source; ! when either window is
+ *  at or over the medium-task pick limit for that window (5h: `policy.quota_5h.medium`/`quota_limit`, week:
+ *  `policy.quota_week`) — the same thresholds `orq pick` applies for an unspecified task level; ⊘ blocked
+ *  (orq block), ? no data; sources with no window at all ("-" and "-") are left out. */
+export function quotaLine(lines, limit5, limitWeek, blocked, age) {
     const parts = lines.filter((q) => q.five !== "-" || q.week !== "-").map((q) => {
         if (blocked.has(q.name))
             return `${q.name} ⊘`;
-        const ns = [pct(q.five), pct(q.week)].filter((n) => n !== undefined);
+        const five = pct(q.five), week = pct(q.week);
+        const ns = [five, week].filter((n) => n !== undefined);
         if (!ns.length)
             return `${q.name} ?`;
         const top = Math.max(...ns);
-        return `${q.name} ${top}${top >= limit ? "!" : ""}`;
+        const over = (five !== undefined && five >= limit5) || (week !== undefined && week >= limitWeek);
+        return `${q.name} ${top}${over ? "!" : ""}`;
     });
     if (!parts.length)
         return age === undefined ? m("quota: collecting...", "cota: coletando...") : "";
@@ -30,11 +54,12 @@ export async function quota(argv) {
     const { cfg } = loadConfig();
     if (argv[0] === "--line") {
         const q = cached(Date.now());
-        console.log(quotaLine(q.lines, Number(getPath(cfg, "policy.quota_limit") ?? 90), new Set(Object.keys(loadBlocks())), q.age));
+        const [limit5, limitWeek] = limitsFor((getPath(cfg, "policy") ?? {}), "medium");
+        console.log(quotaLine(q.lines, limit5, limitWeek, new Set(Object.keys(loadBlocks())), q.age));
         return 0;
     }
     const sources = (getPath(cfg, "quota") ?? {});
     for (const l of await collect(sources, argv))
-        console.log(l);
+        console.log(humanizeQuotaLine(l));
     return 0;
 }

package/dist/commands/rounds.js

@@ -0,0 +1,58 @@
+// orq rounds <ID> [-w <workspace>] [--json]   per-issue round metrics from .orquestra/<ID>/ (src/rounds.ts), no LLM
+import { getPath, loadConfig } from "../config.js";
+import { m } from "../i18n.js";
+import { expand } from "../paths.js";
+import { collectRounds, mark } from "../rounds.js";
+export const USAGE = "orq rounds <ID> [-w <workspace>] [--json]   rounds vs max_rounds, time per round, repeated findings, alert level";
+const dur = (s) => (s >= 3600 ? `${Math.floor(s / 3600)}h${String(Math.floor(s / 60) % 60).padStart(2, "0")}m` : s >= 60 ? `${Math.floor(s / 60)}m${String(s % 60).padStart(2, "0")}s` : `${s}s`);
+const why = (r) => ({
+    over_max: m(`rounds ${r.n} > max_rounds ${r.max}`, `rodadas ${r.n} > max_rounds ${r.max}`),
+    at_max: m(`rounds ${r.n} = max_rounds ${r.max}`, `rodadas ${r.n} = max_rounds ${r.max}`),
+    same_finding: m(`same finding in ${r.n} reviews`, `mesmo achado em ${r.n} revisões`),
+    repeated: m(`${r.n} repeated finding(s)`, `${r.n} achado(s) repetido(s)`),
+    slow: m(`round ${r.rounds?.join(", ")} much slower than the others`, `rodada ${r.rounds?.join(", ")} bem mais lenta que as outras`),
+})[r.code];
+export function rounds(argv) {
+    let ws, id, json = false;
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "-w") {
+            if (!argv[i + 1]) {
+                console.error(USAGE);
+                return 2;
+            }
+            ws = expand(argv[++i]);
+        }
+        else if (argv[i] === "--json")
+            json = true;
+        else if (!id && !argv[i].startsWith("-"))
+            id = argv[i];
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    if (!id) {
+        console.error(USAGE);
+        return 2;
+    }
+    ws ??= getPath(loadConfig().cfg, "_workspace") ?? process.cwd();
+    const { cfg } = loadConfig(ws); // the workspace's own policy.max_rounds
+    const x = collectRounds(ws, id, Number(getPath(cfg, "policy.max_rounds") ?? 2));
+    if (!x) {
+        console.error(m(`no rounds recorded for ${id} in ${ws}/.orquestra`, `nenhuma rodada registrada para ${id} em ${ws}/.orquestra`));
+        return 1;
+    }
+    if (json) {
+        console.log(JSON.stringify(x, null, 2));
+        return 0;
+    }
+    console.log(`${id}  ${mark(x)}  ${m("alert", "alerta")}: ${x.level}${x.reasons.length ? ` (${x.reasons.map(why).join("; ")})` : ""}`);
+    console.log(m(`rounds ${x.rounds} of max ${x.max}; total time ${dur(x.secs)}; ${x.findings} finding(s) across reviews`, `rodadas ${x.rounds} de no máx. ${x.max}; tempo total ${dur(x.secs)}; ${x.findings} achado(s) nas revisões`));
+    for (const r of x.perRound)
+        console.log(`  ${r.round === 0 ? m("impl + review", "impl + revisão") : m(`fix ${r.round} + review`, `fix ${r.round} + revisão`)}: ${dur(r.secs)}`);
+    if (x.repeats.length)
+        console.log(m("repeated findings:", "achados repetidos:"));
+    for (const r of x.repeats)
+        console.log(`  [${m("rounds", "rodadas")} ${r.rounds.join(",")}] ${r.title.slice(0, 100)}`);
+    return 0;
+}

package/dist/config.js

@@ -20,7 +20,10 @@ export const DEFAULTS = {
     },
     agents: {}, // only agents declared here are available; run templates: built in for 5 (src/agents.ts), or `run = ...`
     policy: {
-        quota_limit: 90, // quota % from which an agent/account is skipped
+        quota_limit: 90, // also caps the 5h pick limit; marks ! in `orq quota --line`
+        pacing_penalty: 0.3, // score penalty when usage at the current pace would pass the pick limit by the window's reset (0 = off)
+        quota_week: 95, // weekly % from which an agent/account is skipped
+        quota_5h: { simple: 90, medium: 85, heavy: 80 }, // same for the 5h window, per task level
         max_rounds: 2, // fix rounds before stopping and calling the user
         review: "other-vendor", // other-vendor | any
     },

package/dist/identity.js

@@ -0,0 +1,55 @@
+// Who is logged in behind an agent or account name — only to tell that the login CHANGED. `orq block` records it, and a
+// block made for one login is dropped once another is there (a new account has its own quota). Ids are short hashes of
+// something stable per login (never the secret itself); undefined = cannot tell, so the block stays until its date.
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { claudeAccounts } from "./accounts.js";
+import { agyToken, minimaxKey } from "./quota.js";
+const hash = (s) => createHash("sha256").update(s).digest("hex").slice(0, 16);
+const json = (f) => { try {
+    return JSON.parse(readFileSync(f, "utf8"));
+}
+catch {
+    return undefined;
+} };
+/** Claude Code keeps the logged-in account in .claude.json: inside the config dir, or in ~ for the default ~/.claude. */
+function claudeId(dir) {
+    const files = [join(dir, ".claude.json"), ...(resolve(dir) === join(homedir(), ".claude") ? [join(homedir(), ".claude.json")] : [])];
+    for (const f of files) {
+        const id = json(f)?.oauthAccount?.accountUuid;
+        if (id)
+            return String(id);
+    }
+    return undefined;
+}
+function copilotId() {
+    const r = spawnSync("gh", ["api", "/user", "-q", ".id"], { encoding: "utf8", timeout: 15_000 });
+    return r.status === 0 && r.stdout.trim() ? r.stdout.trim() : undefined;
+}
+/** The login id for a block name (an agent, or a Claude account), or undefined when it cannot be told. */
+export function loginId(name) {
+    const accs = claudeAccounts();
+    const acc = accs.find((a) => a.name === name);
+    if (acc)
+        return claudeId(acc.dir);
+    if (name === "claude") { // the whole vendor: any account changing counts
+        const ids = accs.map((a) => claudeId(a.dir));
+        return ids.every(Boolean) ? hash(ids.sort().join(",")) : undefined;
+    }
+    if (name === "codex") {
+        const t = json(join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "auth.json"))?.tokens;
+        return t?.account_id ?? undefined;
+    }
+    if (name === "antigravity" || name === "agy")
+        return agyToken()?.acct;
+    if (name === "copilot")
+        return copilotId();
+    if (name === "opencode" || name === "minimax") {
+        const k = minimaxKey();
+        return k ? hash(k) : undefined;
+    }
+    return undefined;
+}

package/dist/pick.js

@@ -1,4 +1,5 @@
 import { m } from "./i18n.js";
+import { humanReset } from "./quota.js";
 import { legacyRole, resolveRole, vendorOf } from "./roles.js";
 /** "<name> 5h=NN% week=NN% [note]" lines → QuotaMap (same reading as the old orq-pick). */
 export function parseQuota(text) {
@@ -17,6 +18,45 @@ export function parseQuota(text) {
     }
     return out;
 }
+/** The same lines → each window's %, plus its reset time (epoch seconds) when the line carries one. */
+export function parseWindows(text) {
+    const out = {};
+    const num = (v) => (v && /^\d+%$/.test(v) ? Number(v.slice(0, -1)) : undefined);
+    for (const l of text.split(/\r?\n/)) {
+        const r = /^(\S+) 5h=(\S+) week=(\S+)(?: reset5h=(\d+))?(?: resetweek=(\d+))?(?: span5h=(\d+))?(?: spanweek=(\d+))?/.exec(l.trim());
+        if (!r)
+            continue;
+        // "[login expired: run `agy models`; last reading, 5 min ago]" → the part before the first ";" (the fix to show)
+        const note = /\[([^\]]*)\]\s*$/.exec(l)?.[1].split(";")[0].trim();
+        out[r[1]] = { five: num(r[2]), week: num(r[3]), ...(r[4] ? { resetFive: Number(r[4]) } : {}),
+            ...(r[5] ? { resetWeek: Number(r[5]) } : {}), ...(r[6] ? { spanFive: Number(r[6]) } : {}),
+            ...(r[7] ? { spanWeek: Number(r[7]) } : {}), ...(note && EXPIRED.test(note) ? { expired: note } : note ? { note } : {}) };
+    }
+    return out;
+}
+// Both languages orq writes these notes in (the collectors' not-logged-in and expired-login texts).
+/** agy's idle-token note (collector text, both languages). */
+const IDLE = /token idle|token ocioso/i;
+const EXPIRED = /login expired|login expirado|not logged in|no agy login|sem login/i;
+/** Window lengths in seconds, unless the quota line publishes another (span5h/spanweek, minutes). */
+const WINDOW_S = { five: 5 * 3600, week: 7 * 86400 };
+/** Usage at the window's reset if the pace so far continues (used ÷ elapsed share); undefined when it can't be told:
+ *  no figure or reset time, or under 10% of the window elapsed (too early to project). */
+export function projected(pct, reset, size, now) {
+    if (pct === undefined || pct < 0 || reset === undefined)
+        return undefined;
+    const left = reset - now;
+    if (left <= 0 || left > size)
+        return undefined;
+    const elapsed = (size - left) / size;
+    return elapsed < 0.1 ? undefined : pct / elapsed;
+}
+const FIVE = { simple: 90, medium: 85, heavy: 80 };
+/** [5h limit, weekly limit] for a task level; an unknown level counts as medium. */
+export function limitsFor(pol, level) {
+    const five = { ...FIVE, ...(pol.quota_5h ?? {}) };
+    return [Math.min(Number(five[level] ?? five.medium), Number(pol.quota_limit ?? 90)), Number(pol.quota_week ?? 95)];
+}
 export function modelFor(a, role, level) {
     if (a.models === undefined)
         return ["", undefined]; // no models configured: the CLI's default
@@ -35,13 +75,18 @@ export function pick(inp) {
     const { cfg, role, level } = inp;
     const agents = (cfg.agents ?? {});
     const pol = (cfg.policy ?? {});
-    const limit = Number(pol.quota_limit ?? 90);
+    const [base5, baseWeek] = limitsFor(pol, level);
     const w = weights(cfg);
+    const now = inp.now ?? Date.now() / 1000;
+    const penalty = Number(pol.pacing_penalty ?? 0.3);
     const res = resolveRole(cfg, role);
     const names = res.mode === "fixed" ? res.order : res.pool;
     const notes = [];
     const out = (n, why) => { notes.push(`${n}: ${why}`); };
     const pass = [];
+    // Only with someone else to ask: a single agent must still be able to review.
+    const someoneElse = names.some((n) => n !== inp.implAgent && agents[n]);
+    const otherVendor = names.some((n) => n !== inp.implAgent && agents[n] && vendorOf(n, agents[n]) !== inp.implVendor);
     for (const name of names) {
         const a = agents[name];
         if (!a) {
@@ -56,7 +101,11 @@ export function pick(inp) {
             out(name, m("blocked (orq block -l)", "bloqueado (orq block -l)"));
             continue;
         }
-        if ((role === "review" || role === "opinion") && res.rule === "other-vendor" && inp.implVendor
+        if ((role === "review" || role === "opinion") && name === inp.implAgent && someoneElse) {
+            out(name, m("it implemented this code", "foi quem implementou"));
+            continue;
+        }
+        if ((role === "review" || role === "opinion") && res.rule === "other-vendor" && inp.implVendor && otherVendor
             && vendorOf(name, a) === inp.implVendor) {
             out(name, m("same vendor as the implementer", "mesmo fornecedor do implementador"));
             continue;
@@ -66,22 +115,68 @@ export function pick(inp) {
             out(name, m(`no model for ${role}/${level}`, `sem modelo para ${role}/${level}`));
             continue;
         }
-        // Quota: an agent with several accounts (claude) uses the least used one under the limit.
+        // Quota: an agent with several accounts (claude) prefers one not projecting past the limit, then the least used.
         const qn = a.quota ?? [];
+        const headroom = Math.max(0, Number(a.headroom ?? 0));
+        const limit5 = base5 - headroom, limitWeek = baseWeek - headroom;
         const accs = qn.filter((n) => !inp.blocks.has(n)).map((n) => [n, n in inp.quota ? inp.quota[n] : -1]);
         if (qn.length && !accs.length) {
             out(name, m("all accounts blocked", "todas as contas bloqueadas"));
             continue;
         }
-        const usable = accs.filter(([, v]) => v !== null && v < limit);
+        const fix = accs.map(([n]) => inp.windows?.[n]?.expired).filter((x) => Boolean(x));
+        if (accs.length && fix.length === accs.length) {
+            out(name, fix[0]);
+            continue;
+        }
+        // An idle agy token with nothing cached: the fix is one agy run, not a quota number.
+        const noRead = m("no reading yet: run `agy models` once", "sem leitura ainda: rode `agy models` uma vez");
+        const idleNoData = ([n, v]) => v === null && IDLE.test(inp.windows?.[n]?.note ?? "");
+        if (accs.length && accs.every(idleNoData)) {
+            out(name, noRead);
+            continue;
+        }
+        const under = ([n, v]) => {
+            const q = inp.windows?.[n];
+            return !q?.expired && v !== null && (q?.five ?? (q ? -1 : v)) < limit5 && (q?.week ?? (q ? -1 : v)) < limitWeek;
+        };
+        const usable = accs.filter(under);
         if (accs.length && !usable.length) {
-            out(name, `${m("quota", "cota")} >= ${limit}% ${m("or no data", "ou sem dados")} (${accs.map(([n, v]) => `${n}=${v}`).join(", ")})`);
+            const detail = accs.map(([n, v]) => {
+                const q = inp.windows?.[n], vn = v ?? -1;
+                if (q?.expired)
+                    return `${n}: ${q.expired}`;
+                if (idleNoData([n, v]))
+                    return `${n}: ${noRead}`;
+                const five = q?.five ?? (q ? -1 : vn), week = q?.week ?? (q ? -1 : vn);
+                const fiveOver = five >= limit5, weekOver = week >= limitWeek;
+                // The account is usable again only once every over-limit window has reset: the latest of their reset times.
+                // If one of them has no reset time, that time can't be promised at all.
+                const known = [fiveOver ? q?.resetFive : undefined, weekOver ? q?.resetWeek : undefined]
+                    .filter((t) => t !== undefined);
+                const allKnown = (fiveOver || weekOver) && (!fiveOver || q?.resetFive !== undefined) && (!weekOver || q?.resetWeek !== undefined);
+                return `${n}=${v}` + (q?.note ? ` (${q.note})` : "") + (allKnown ? ` (${m("back", "volta")} ${humanReset(Math.max(...known))})` : "");
+            }).join(", ");
+            out(name, `${m("quota", "cota")} >= 5h ${limit5}% / ${m("week", "semana")} ${limitWeek}% ${m("or no data", "ou sem dados")}`
+                + (headroom ? ` (headroom ${headroom})` : "") + ` (${detail})`);
             continue;
         }
-        const acct = accs.length > 1 ? [...usable].sort((x, y) => x[1] - y[1])[0][0] : undefined;
+        const paceOf = (n) => {
+            const q = inp.windows?.[n];
+            const p5 = projected(q?.five, q?.resetFive, (q?.spanFive ? q.spanFive * 60 : WINDOW_S.five), now);
+            const pw = projected(q?.week, q?.resetWeek, (q?.spanWeek ? q.spanWeek * 60 : WINDOW_S.week), now);
+            const paces = [p5, pw].filter((x) => x !== undefined);
+            // Hot: past the same per-window limit the filter uses (5h by level, week), headroom included, when pacing is on.
+            return { pace: paces.length ? Math.max(...paces) : undefined,
+                hot: penalty > 0 && ((p5 !== undefined && p5 > limit5) || (pw !== undefined && pw > limitWeek)) };
+        };
+        const ranked = usable.map(([n, v]) => ({ n, v: v, ...paceOf(n) }))
+            .sort((x, y) => Number(x.hot) - Number(y.hot) || x.v - y.v);
+        const chosen = ranked[0];
+        const acct = qn.length > 1 ? chosen?.n : undefined;
         const statRole = role === "fix" || role === "worker" ? "impl" : role;
         const st = inp.stats.find((r) => r.role === statRole && r.agent === name && r.model === (mf[0].split("/").pop() || "default"));
-        pass.push({ agent: name, model: mf[0], effort: mf[1], acct, a, st });
+        pass.push({ agent: name, model: mf[0], effort: mf[1], acct, a, st, pace: chosen?.pace, hot: Boolean(chosen?.hot) });
         if (res.mode === "fixed")
             break; // the first that passes wins
     }
@@ -102,11 +197,13 @@ export function pick(inp) {
         const t = few(c.st) || !c.st?.new || !toks.length ? prior : Math.min(...toks) / c.st.new;
         const s = few(c.st) || !c.st?.min || !mins.length ? prior : Math.min(...mins) / Math.max(c.st.min, 0.1);
         const used = inp.recent.filter((p) => p.agent === c.agent).length;
+        const hot = Boolean(c.hot) && penalty > 0;
         const score = w.quality * d + w.tokens * t + w.speed * s - w.rotation * used
-            - (reserve ? w.reserve : 0) + (few(c.st) ? w.explore : 0);
+            - (reserve ? w.reserve : 0) + (few(c.st) ? w.explore : 0) - (hot ? penalty : 0);
         const why = `${m("delivery", "entrega")}=${d.toFixed(2)} ${m("economy", "economia")}=${t.toFixed(2)} `
             + `${m("speed", "rapidez")}=${s.toFixed(2)} ${m("rotation", "rodízio")}=-${used} `
-            + (reserve ? m("reserve ", "reserva ") : "") + (few(c.st) ? `${m("few samples", "poucos dados")}(n=${n})` : `n=${n}`);
+            + (reserve ? m("reserve ", "reserva ") : "")
+            + (hot ? `${m("pace", "ritmo")}=${Math.round(c.pace)}%→-${penalty} ` : "") + (few(c.st) ? `${m("few samples", "poucos dados")}(n=${n})` : `n=${n}`);
         return { agent: c.agent, model: c.model, effort: c.effort, acct: c.acct, score, why };
     }).sort((x, y) => y.score - x.score);
     return { mode: "auto", best: cands[0], cands, notes };

package/dist/process.js

@@ -58,27 +58,29 @@ function parseTable(text) {
     }
     return t;
 }
-/** Total memory of `root` and all its descendants. */
-export function treeMem(root, table = processTable()) {
+/** `root` and all its descendants. */
+export function treePids(root, table = processTable()) {
     const kids = new Map();
     for (const [pid, [ppid]] of table)
         kids.set(ppid, [...(kids.get(ppid) ?? []), pid]);
-    let total = 0;
     const seen = new Set(), todo = [root];
     while (todo.length) {
         const p = todo.pop();
         if (seen.has(p))
             continue;
         seen.add(p);
-        total += table.get(p)?.[1] ?? 0;
         todo.push(...(kids.get(p) ?? []));
     }
-    return total;
+    return [...seen];
+}
+/** Total memory of `root` and all its descendants. */
+export function treeMem(root, table = processTable()) {
+    return treePids(root, table).reduce((t, p) => t + (table.get(p)?.[1] ?? 0), 0);
 }
-export function killTree(pid) {
+export function killTree(pid, group = true) {
     if (process.platform === "win32")
         spawnSync("taskkill", ["/T", "/F", "/PID", String(pid)], { stdio: "ignore" });
-    else
+    else if (group)
         try {
             process.kill(-pid, "SIGKILL");
         }
@@ -88,6 +90,12 @@ export function killTree(pid) {
             }
             catch { /* gone */ }
         }
+    else
+        for (const p of treePids(pid))
+            try {
+                process.kill(p, "SIGKILL");
+            }
+            catch { /* gone */ } // no group of its own
 }
 /** cmd.exe quoting for one argument (only used when Windows needs a shell). */
 export const winQuote = (a) => /[\s"&|<>^%()]/.test(a) || a === "" ? `"${a.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1")}"` : a;
@@ -103,10 +111,10 @@ export function runCapped(cmd, args, o = {}) {
         return wait(c);
     }
     const win = process.platform === "win32";
-    // Own process group on Linux/macOS, so the whole tree can be killed at once.
+    // Own process group on Linux/macOS, so the whole tree can be killed at once (not for a screen: it needs the terminal).
     // Windows: a shell only for .cmd/.bat shims (npx, claude…); an .exe runs directly (paths with spaces stay intact).
     const shell = win && !/\.exe$/i.test(cmd), q = shell && o.quote;
-    const child = spawn(q ? winQuote(cmd) : cmd, q ? args.map(winQuote) : args, { stdio: o.stdio ?? "inherit", cwd: o.cwd, env: o.env, detached: !win, shell, windowsHide: true });
+    const child = spawn(q ? winQuote(cmd) : cmd, q ? args.map(winQuote) : args, { stdio: o.stdio ?? "inherit", cwd: o.cwd, env: o.env, detached: !win && !o.tty, shell, windowsHide: true });
     o.onSpawn?.(child);
     if (mode === "off" || !child.pid)
         return wait(child);
@@ -117,7 +125,7 @@ export function runCapped(cmd, args, o = {}) {
         child.kill(sig);
     } };
     const onInt = fwd("SIGINT"), onTerm = fwd("SIGTERM");
-    if (!win) {
+    if (!win && !o.tty) {
         process.on("SIGINT", onInt);
         process.on("SIGTERM", onTerm);
     }
@@ -131,7 +139,7 @@ export function runCapped(cmd, args, o = {}) {
         if (used > o.cap && !killed) {
             killed = true;
             console.error(m(`orq: memory ${gb(used)} over the cap (${gb(o.cap)}): killing the process tree`, `orq: memória ${gb(used)} acima do limite (${gb(o.cap)}): encerrando a árvore de processos`));
-            killTree(child.pid);
+            killTree(child.pid, !o.tty);
         }
     }, o.intervalMs ?? 1000);
     return wait(child).then((code) => {