@irythill/orq 0.0.0-stage → 0.1.0

package/dist/commands/deps.js

@@ -0,0 +1,82 @@
+// orq deps — the worktree's node_modules is a LINK to the main repo's (never install in a worktree: ~1 GB and tens of
+// thousands of files per copy). If the main repo's deps are behind origin/<base> and it is clean and on <base>:
+// fast-forward + ONE install there. One install per repo at a time (orq lock); the second waits, then only links.
+// Windows: a directory junction (no admin rights needed); elsewhere a symlink.
+//   orq deps -r <main repo> -b <base> -w <worktree>     exit 0 = linked · 3 = main repo dirty or not on <base>: ASK THE USER
+import { spawnSync } from "node:child_process";
+import { appendFileSync, existsSync, lstatSync, readFileSync, rmSync, symlinkSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { m } from "../i18n.js";
+import { acquire, release } from "../lock.js";
+export const USAGE = "orq deps -r <main repo> -b <base> -w <worktree>   link node_modules into a worktree (exit 3 = ask the user)";
+const git = (cwd, ...a) => spawnSync("git", ["-C", cwd, ...a], { encoding: "utf8" });
+export function installer(repo) {
+    const has = (f) => existsSync(join(repo, f));
+    if (has("bun.lock") || has("bun.lockb"))
+        return ["bun", "install"];
+    if (has("pnpm-lock.yaml"))
+        return ["pnpm", "install"];
+    if (has("yarn.lock"))
+        return ["yarn", "install"];
+    return ["npm", "install"];
+}
+export function link(target, at) {
+    try {
+        if (lstatSync(at))
+            rmSync(at, { recursive: true, force: true });
+    }
+    catch { /* not there */ }
+    symlinkSync(target, at, process.platform === "win32" ? "junction" : "dir");
+}
+export async function deps(argv) {
+    let R = "", B = "", WT = "";
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "-r")
+            R = resolve(argv[++i]);
+        else if (argv[i] === "-b")
+            B = argv[++i];
+        else if (argv[i] === "-w")
+            WT = resolve(argv[++i]);
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    if (!R || !B || !WT) {
+        console.error(USAGE);
+        return 2;
+    }
+    const gd = git(R, "rev-parse", "--path-format=absolute", "--git-common-dir").stdout.trim();
+    const ex = join(gd, "info", "exclude");
+    if (!(existsSync(ex) ? readFileSync(ex, "utf8") : "").split(/\r?\n/).includes("node_modules"))
+        appendFileSync(ex, "node_modules\n");
+    const name = `deps-${basename(R)}`;
+    await acquire(name, process.pid, `deps ${basename(R)}`, 1, () => console.log(m(`another conductor is installing dependencies in ${basename(R)}; waiting...`, `outro conductor está instalando dependências em ${basename(R)}; aguardando...`)));
+    try {
+        git(R, "fetch", "-q", "origin", B);
+        const locks = ["package.json", "bun.lock", "bun.lockb", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"]
+            .filter((f) => existsSync(join(R, f)));
+        const stale = git(R, "diff", "--quiet", "HEAD", `origin/${B}`, "--", ...locks).status !== 0;
+        if (stale || !existsSync(join(R, "node_modules"))) {
+            const br = git(R, "branch", "--show-current").stdout.trim();
+            if (br !== B || git(R, "status", "--porcelain", "--untracked-files=no").stdout.trim()) {
+                console.log(m(`deps are stale, but ${basename(R)} is on '${br}' or has changes: not touching it. Ask the user.`, `deps defasadas, mas ${basename(R)} está em '${br}' ou com alterações: não mexo. Pergunte ao usuário.`));
+                return 3;
+            }
+            git(R, "merge", "-q", "--ff-only", `origin/${B}`);
+            const cmd = installer(R);
+            console.log(`${m("installing dependencies in", "instalando dependências em")} ${basename(R)} (${cmd.join(" ")})...`);
+            const r = spawnSync(cmd[0], cmd.slice(1), { cwd: R, stdio: "ignore", shell: process.platform === "win32" });
+            if (r.status !== 0) {
+                console.error(`${cmd.join(" ")}: exit ${r.status}`);
+                return 1;
+            }
+        }
+        link(join(R, "node_modules"), join(WT, "node_modules"));
+        console.log(`ok: ${join(WT, "node_modules")} -> ${join(R, "node_modules")}`);
+        return 0;
+    }
+    finally {
+        release(name, process.pid);
+    }
+}

package/dist/commands/instructions.js

@@ -0,0 +1,66 @@
+// orq instructions — the /issue playbook (skills/issue/SKILL.md, one source) in the conductor's own format:
+//   claude   <workspace>/.claude/skills/issue/SKILL.md   (Claude Code loads it as the /issue skill)
+//   agents   <workspace>/AGENTS.md                        (Codex, OpenCode and others that read AGENTS.md)
+// AGENTS.md may hold the user's own text: orq only replaces its block between the orq:issue markers.
+//   orq instructions claude|agents [-w <workspace>] [--print]
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeAtomic } from "../fsutil.js";
+import { m } from "../i18n.js";
+export const USAGE = "orq instructions claude|agents [-w <workspace>] [--print]   write the /issue playbook for the conductor";
+const SRC = fileURLToPath(new URL("../../skills/issue/SKILL.md", import.meta.url));
+const BEGIN = "<!-- orq:issue begin (generated by `orq instructions agents`; edits inside are overwritten) -->";
+const END = "<!-- orq:issue end -->";
+/** The playbook for harnesses without skills: no frontmatter, a trigger line, and how to wait without background tasks. */
+export function agentsBlock(skill) {
+    const body = skill.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
+    return `${BEGIN}
+When the user says "/issue <ID>", "take issue X" or "run ABC-123", follow this playbook.
+If your harness cannot run a command in the background, wait for children with \`orq wait\` in the foreground
+(\`orq wait --any <prefix>...\`): it is the one allowed blocking wait.
+
+${body}
+${END}
+`;
+}
+/** Put the block into an existing AGENTS.md text: replace ours, or append it. */
+export function mergeBlock(cur, block) {
+    const a = cur.indexOf(BEGIN), b = cur.indexOf(END);
+    if (a >= 0 && b > a)
+        return cur.slice(0, a) + block.trimEnd() + cur.slice(b + END.length);
+    return cur ? `${cur.trimEnd()}\n\n${block}` : block;
+}
+export async function instructions(argv) {
+    let ws = process.cwd(), print = false, fmt;
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "-w")
+            ws = resolve(argv[++i]);
+        else if (argv[i] === "--print")
+            print = true;
+        else if (argv[i] === "claude" || argv[i] === "agents")
+            fmt = argv[i];
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    if (!fmt) {
+        console.error(USAGE);
+        return 2;
+    }
+    if (!existsSync(SRC)) {
+        console.error(m(`playbook not found: ${SRC}`, `playbook não encontrado: ${SRC}`));
+        return 2;
+    }
+    const skill = readFileSync(SRC, "utf8");
+    const file = fmt === "claude" ? join(ws, ".claude", "skills", "issue", "SKILL.md") : join(ws, "AGENTS.md");
+    const text = fmt === "claude" ? skill : mergeBlock(existsSync(file) ? readFileSync(file, "utf8") : "", agentsBlock(skill));
+    if (print) {
+        process.stdout.write(text);
+        return 0;
+    }
+    writeAtomic(file, text);
+    console.log(m(`wrote ${file}`, `escrito ${file}`));
+    return 0;
+}

package/dist/commands/lang.js

@@ -0,0 +1,35 @@
+// orq lang                 show the current language
+// orq lang pt|en|auto      set it (auto = system locale)
+// orq lang toggle          switch between en and pt
+// --notify                 also show a herdr pop-up (used by the herdr key binding)
+// Applies to whatever starts afterwards (board, notices, orq pick...); running agents keep their language.
+import { spawnSync } from "node:child_process";
+import { getPath, loadConfig } from "../config.js";
+import { detectLang } from "../i18n.js";
+import { setValue } from "./set.js";
+export const USAGE = "orq lang [pt|en|auto|toggle] [--notify]";
+const cfgLang = () => getPath(loadConfig().cfg, "ui.lang");
+export function lang(argv) {
+    let notify = false, arg = "";
+    for (const a of argv) {
+        if (a === "--notify")
+            notify = true;
+        else if (["pt", "en", "auto", "toggle"].includes(a))
+            arg = a;
+        else {
+            console.error(`usage: ${USAGE}`);
+            return 2;
+        }
+    }
+    const cur = detectLang(cfgLang(), false); // effective language, ignoring $ORQ_LANG
+    if (!arg) {
+        console.log(`${cur} (ui.lang = ${cfgLang() ?? "auto"})`);
+        return 0;
+    }
+    setValue("ui", "lang", arg === "toggle" ? (cur === "pt" ? "en" : "pt") : arg);
+    const msg = detectLang(cfgLang(), false) === "pt" ? "Idioma do orq: Português" : "orq language: English";
+    console.log(msg);
+    if (notify)
+        spawnSync("herdr", ["notification", "show", msg], { stdio: "ignore" });
+    return 0;
+}

package/dist/commands/lock.js

@@ -0,0 +1,69 @@
+// orq lock — the portable test queue (src/lock.ts). Scripts hold a slot for their own pid:
+//   orq lock wait verify --pid $$ --label "verify ABC-1 api"   blocks until it holds a slot (slots: machine.test_slots)
+//   orq lock release verify --pid $$                         (also freed by itself when that process dies)
+//   orq lock run verify [--label t] -- <cmd> [args]          runs a command holding a slot
+//   orq lock status [verify] [--json]                        holders and waiters, in order
+import { spawnSync } from "node:child_process";
+import { getPath, loadConfig } from "../config.js";
+import { m } from "../i18n.js";
+import { acquire, release, status } from "../lock.js";
+export const USAGE = `orq lock wait|release <name> [--pid P] [--label text]   test queue (slots = machine.test_slots)
+orq lock run <name> [--label text] -- <cmd>...  ·  orq lock status [<name>] [--json]`;
+const slots = () => Number(getPath(loadConfig().cfg, "machine.test_slots") ?? 1);
+const since = (at) => `${Math.round((Date.now() - at) / 1000)}s`;
+export async function lock(argv) {
+    const [sub, name = "verify", ...rest] = argv;
+    let pid = process.ppid, label = "", json = false;
+    const dd = rest.indexOf("--");
+    const opts = dd >= 0 ? rest.slice(0, dd) : rest, cmd = dd >= 0 ? rest.slice(dd + 1) : [];
+    for (let i = 0; i < opts.length; i++) {
+        if (opts[i] === "--pid")
+            pid = Number(opts[++i]);
+        else if (opts[i] === "--label")
+            label = opts[++i];
+        else if (opts[i] === "--json")
+            json = true;
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    const waitMsg = () => console.log(m("another verification is running; waiting for my turn...", "outra verificação em andamento; aguardando a vez..."));
+    switch (sub) {
+        case "wait":
+            await acquire(name, pid, label, slots(), waitMsg);
+            return 0;
+        case "release":
+            release(name, pid);
+            return 0;
+        case "run": {
+            if (!cmd.length) {
+                console.error(USAGE);
+                return 2;
+            }
+            await acquire(name, process.pid, label || cmd.join(" "), slots(), waitMsg);
+            try {
+                return spawnSync(cmd[0], cmd.slice(1), { stdio: "inherit", shell: process.platform === "win32" }).status ?? 1;
+            }
+            finally {
+                release(name, process.pid);
+            }
+        }
+        case "status": {
+            const s = status(name);
+            if (json) {
+                console.log(JSON.stringify(s));
+                return 0;
+            }
+            for (const e of s.holders)
+                console.log(`▶ ${e.pid} ${e.label} (${since(e.at)})`);
+            s.waiters.forEach((e, i) => console.log(`${i + 1}. ${e.pid} ${e.label} (${m("waiting", "aguardando")} ${since(e.at)})`));
+            if (!s.holders.length && !s.waiters.length)
+                console.log(m("queue empty", "fila vazia"));
+            return 0;
+        }
+        default:
+            console.error(USAGE);
+            return 2;
+    }
+}

package/dist/commands/pick.js

@@ -0,0 +1,91 @@
+// orq pick — agent, model, effort and account for a role, from [roles] (fixed or auto), the history, quota and blocks.
+// Prints the runner arguments (e.g. `-a codex -m gpt-6-sol -e low -c work`); each pick is recorded in
+// <state dir>/picks.jsonl (that feeds rotation). Exit 3 = no candidate: ask the user.
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadConfig } from "../config.js";
+import { m } from "../i18n.js";
+import { asArgs, parseQuota, pick as choose } from "../pick.js";
+import { expand, stateDir } from "../paths.js";
+import { collect } from "../quota.js";
+import { PICK_ROLES, vendorOf } from "../roles.js";
+import { collectRuns, rows } from "../stats.js";
+import { load as loadBlocks } from "./block.js";
+export const USAGE = `orq pick <impl|fix|worker|review|opinion> [--level simple|medium|heavy] [--impl-vendor <v>|--impl-agent <a>]
+         [--exclude-agent <a>]... [-w <workspace>] [--explain] [--no-record]`;
+// The board refreshes this file; fresher than 10 min → no new quota requests.
+const QCACHE = join(process.env.XDG_RUNTIME_DIR ?? tmpdir(), "herdr-board.quota");
+async function quotaText(cfg) {
+    if (existsSync(QCACHE) && Date.now() - statSync(QCACHE).mtimeMs < 600_000)
+        return readFileSync(QCACHE, "utf8");
+    return (await collect((cfg.quota ?? {}))).join("\n");
+}
+export async function pick(argv) {
+    const role = argv[0];
+    if (!PICK_ROLES.includes(role)) {
+        console.error(USAGE);
+        return 2;
+    }
+    let level = "medium", implVendor, implAgent, ws;
+    let explain = false, record = true;
+    const exclude = new Set();
+    for (let i = 1; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--level")
+            level = argv[++i];
+        else if (a === "--impl-vendor")
+            implVendor = argv[++i];
+        else if (a === "--impl-agent")
+            implAgent = argv[++i];
+        else if (a === "--exclude-agent")
+            exclude.add(argv[++i]);
+        else if (a === "-w")
+            ws = expand(argv[++i]);
+        else if (a === "--explain")
+            explain = true;
+        else if (a === "--no-record")
+            record = false;
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    const { cfg } = loadConfig(ws);
+    const agents = (cfg.agents ?? {});
+    if (implAgent && !implVendor)
+        implVendor = vendorOf(implAgent, agents[implAgent]);
+    const w = (cfg.policy ?? {});
+    const stats = rows(collectRuns((ws ?? cfg._workspace ?? process.cwd()), Number(w.history_days ?? 30)));
+    const picksF = join(stateDir(), "picks.jsonl");
+    const window = Number(((w.weights ?? {}).window) ?? 6);
+    const recent = (existsSync(picksF) ? readFileSync(picksF, "utf8").split("\n").filter(Boolean).slice(-200) : [])
+        .map((l) => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return {};
+    } })
+        .filter((p) => p.role === role).slice(-window);
+    const res = choose({ cfg, role, level, implVendor, exclude, stats, quota: parseQuota(await quotaText(cfg)),
+        blocks: new Set(Object.keys(loadBlocks())), recent });
+    if (!res.best) {
+        console.error(`orq pick: ${m("no candidate for ", "nenhum candidato para ")}${role}`
+            + (res.notes.length ? `; ${res.notes.join("; ")}` : ""));
+        return 3;
+    }
+    if (explain) {
+        for (const c of res.cands)
+            console.error(`${c === res.best ? "→" : " "} ${res.mode === "fixed" ? "  fixed" : (c.score >= 0 ? "+" : "") + c.score.toFixed(3)}  `
+                + `${c.agent.padEnd(12)} ${c.model.padEnd(24)} ${c.why}`);
+        for (const n of res.notes)
+            console.error(`  ${m("out", "fora")}: ${n}`);
+    }
+    if (record) {
+        mkdirSync(stateDir(), { recursive: true });
+        appendFileSync(picksF, JSON.stringify({ t: Math.floor(Date.now() / 1000), role, level, agent: res.best.agent,
+            model: res.best.model }) + "\n");
+    }
+    console.log(asArgs(res.best));
+    return 0;
+}

package/dist/commands/quota.js

@@ -0,0 +1,10 @@
+// orq quota [name...]   quota of each source in [quota] (default: all) — lines "<name> 5h=NN% week=NN% [note]"
+import { getPath, loadConfig } from "../config.js";
+import { collect } from "../quota.js";
+export const USAGE = "orq quota [name...]                   quota per agent/account ([quota] in the config)";
+export async function quota(argv) {
+    const sources = (getPath(loadConfig().cfg, "quota") ?? {});
+    for (const l of await collect(sources, argv))
+        console.log(l);
+    return 0;
+}

package/dist/commands/run.js

@@ -0,0 +1,46 @@
+// orq run — run a command under a memory cap on any OS (src/process.ts).
+//   orq run [--agent <name> | --test] [--mem 4G|off] [--swap 1G] [--mode auto|kernel|watchdog|off] [--unit name] -- <cmd>...
+// Cap: --mem, else agents.<name>.mem_max (with --agent), else machine.test_mem_max (--test) or machine.agent_mem_max.
+// Mode: --mode, else machine.mem_enforce. Exit code = the command's; 137 = killed for memory.
+import { loadConfig } from "../config.js";
+import { parseSize, resolveMode, runCapped } from "../process.js";
+export const USAGE = "orq run [--agent <a> | --test] [--mem 4G|off] [--mode auto|kernel|watchdog|off] -- <cmd>...   memory-capped run";
+export async function run(argv) {
+    const dd = argv.indexOf("--");
+    if (dd < 0 || dd === argv.length - 1) {
+        console.error(USAGE);
+        return 2;
+    }
+    const opts = argv.slice(0, dd), cmd = argv.slice(dd + 1);
+    let agent, test = false, mem, swap;
+    let mode, unit, explain = false;
+    for (let i = 0; i < opts.length; i++) {
+        const a = opts[i];
+        if (a === "--agent")
+            agent = opts[++i];
+        else if (a === "--test")
+            test = true;
+        else if (a === "--mem")
+            mem = opts[++i];
+        else if (a === "--swap")
+            swap = opts[++i];
+        else if (a === "--mode")
+            mode = opts[++i];
+        else if (a === "--unit")
+            unit = opts[++i];
+        else if (a === "--explain")
+            explain = true;
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    const { cfg } = loadConfig();
+    const mach = (cfg.machine ?? {});
+    const agentCap = agent ? (cfg.agents ?? {})[agent]?.mem_max : undefined;
+    const cap = parseSize(mem ?? agentCap ?? String((test ? mach.test_mem_max : mach.agent_mem_max) ?? "off"));
+    const m = mode ?? mach.mem_enforce ?? "auto";
+    if (explain)
+        console.error(`orq run: cap=${cap ?? "off"} mode=${resolveMode(m, cap)}`);
+    return runCapped(cmd[0], cmd.slice(1), { cap, mode: m, unit, swap: parseSize(swap ?? mach.agent_swap_max) });
+}

package/dist/commands/set.js

@@ -0,0 +1,27 @@
+// orq set <section> <key> <value> — writes one string value into your orq config, atomically.
+// TOML: replaces `key = ...` inside [section], adds the key or the section if missing; everything else is kept.
+import { existsSync, readFileSync } from "node:fs";
+import { writeAtomic } from "../fsutil.js";
+import { userConfigFile } from "../paths.js";
+import { setTomlString } from "../toml-set.js";
+export const USAGE = "orq set <section> <key> <value>       e.g.  orq set ui theme lcd";
+export function setValue(section, key, value) {
+    const f = userConfigFile();
+    const text = existsSync(f) ? readFileSync(f, "utf8") : "";
+    if (f.endsWith(".json")) {
+        const j = text.trim() ? JSON.parse(text) : {};
+        j[section] = { ...(j[section] ?? {}), [key]: value };
+        writeAtomic(f, JSON.stringify(j, null, 2) + "\n");
+    }
+    else {
+        writeAtomic(f, setTomlString(text, section, key, value));
+    }
+}
+export function set(argv) {
+    if (argv.length !== 3) {
+        console.error(USAGE);
+        return 2;
+    }
+    setValue(argv[0], argv[1], argv[2]);
+    return 0;
+}

package/dist/commands/setup.js

@@ -0,0 +1,187 @@
+// orq setup — guided first configuration: detect agent CLIs, ask what the user knows, suggest roles (src/suggest.ts),
+// and do what a fresh `npm i -g @irythill/orq` still needs (src/install.ts): skills for Claude Code, a conductor workspace.
+//   orq setup                               interactive, in any terminal
+//   orq setup --detect                      installed agent CLIs, as JSON (for a conductor driving the setup)
+//   orq setup --answers <file|-> [--write]  proposal from answers JSON (see Answers in src/suggest.ts); --write saves it
+//   orq setup --install                     no questions: what orq found, and the skills linked for Claude Code
+//   orq setup --workspace <dir> [--conductor <agent>]   .orquestra, CLAUDE.md map, /issue playbook in its format
+//   --preset economy|quality|single-agent
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, readFileSync } from "node:fs";
+import { homedir, totalmem } from "node:os";
+import { delimiter, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { writeAtomic } from "../fsutil.js";
+import { banner, infoLines } from "../banner.js";
+import { getPath, loadConfig } from "../config.js";
+import { m } from "../i18n.js";
+import { environment, installSkills, prepareWorkspace } from "../install.js";
+import { expand, userConfigFile } from "../paths.js";
+import { suggestRoles, toToml } from "../suggest.js";
+export const USAGE = `orq setup [--preset economy|quality|single-agent]   guided first configuration (roles, weights, memory)
+orq setup --detect | --answers <file|-> [--write] | --install | --workspace <dir> [--conductor <agent>]`;
+/** Agent name → its CLI and a cheap headless smoke test. */
+const CLIS = {
+    claude: { bin: "claude", test: 'claude -p "reply ok"' },
+    codex: { bin: "codex", test: 'codex exec --skip-git-repo-check "reply ok"' },
+    opencode: { bin: "opencode", test: 'opencode run "reply ok"' },
+    antigravity: { bin: "agy", test: 'agy -p "reply ok"' },
+    copilot: { bin: "copilot", test: 'copilot -p "reply ok" -s' },
+};
+/** Is `bin` on PATH? (PATHEXT on Windows: claude.cmd, codex.exe…) */
+export function onPath(bin) {
+    const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+    return (process.env.PATH ?? "").split(delimiter).some((d) => d && exts.some((e) => existsSync(join(d, bin + e))));
+}
+export const detect = () => Object.keys(CLIS).filter((n) => onPath(CLIS[n].bin));
+function write(toml) {
+    const f = userConfigFile();
+    if (existsSync(f)) {
+        const bak = `${f}.bak-${new Date().toISOString().replace(/\D/g, "").slice(0, 14)}`;
+        copyFileSync(f, bak);
+        console.log(m(`previous config saved as ${bak}`, `config anterior salvo em ${bak}`));
+    }
+    writeAtomic(f, toml);
+    return f;
+}
+function show(a) {
+    const p = suggestRoles(a), toml = toToml(p);
+    console.log(toml);
+    return toml;
+}
+async function interactive(preset) {
+    process.stdout.write(banner([...infoLines({}).slice(0, 3), m("setup — let's build your orchestra", "setup — vamos montar sua orquestra")]));
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    // Input closed mid-question (Ctrl+D, empty stdin): cancel cleanly instead of hanging.
+    const closed = new Promise((_, rej) => rl.once("close", () => rej(new Error("closed"))));
+    closed.catch(() => { });
+    const ask = async (q, def = "") => ((await Promise.race([rl.question(def ? `${q} [${def}] ` : `${q} `), closed])).trim() || def);
+    const yes = async (q, def = "n") => /^[ysYS]/.test(await ask(`${q} (y/n)`, def));
+    try {
+        env();
+        const found = detect();
+        if (!found.length) {
+            console.log(m("No agent CLI found (claude, codex, opencode, agy, copilot). Install one and run orq setup again.", "Nenhuma CLI de agente encontrada (claude, codex, opencode, agy, copilot). Instale uma e rode orq setup de novo."));
+            return 1;
+        }
+        console.log(m(`Found: ${found.join(", ")}`, `Encontrados: ${found.join(", ")}`));
+        const agents = {};
+        for (const n of found) {
+            if (await yes(m(`Smoke-test ${n}? (costs a few tokens)`, `Testar ${n}? (gasta alguns tokens)`))) {
+                const r = spawnSync(CLIS[n].test, { shell: true, encoding: "utf8", timeout: 120_000 });
+                const ok = r.status === 0;
+                console.log(ok ? "  ok" : m("  failed — probably not logged in", "  falhou — provavelmente sem login"));
+                if (!ok && !(await yes(m(`Keep ${n} anyway?`, `Manter ${n} mesmo assim?`))))
+                    continue;
+            }
+            else if (!(await yes(m(`Use ${n}?`, `Usar ${n}?`), "y")))
+                continue;
+            const plan = await ask(m(`${n} plan: free | small (Pro, Copilot Pro) | large (Max, high tiers) | payg`, `Plano do ${n}: free | small (Pro, Copilot Pro) | large (Max, planos altos) | payg (pague-por-uso)`), "large");
+            agents[n] = { plan: (["free", "small", "large", "payg"].includes(plan) ? plan : "large") };
+        }
+        const names = Object.keys(agents);
+        if (!names.length)
+            return 1;
+        const trust = await ask(m(`Which do you trust most to write code? (${names.join(", ")}, or empty)`, `Em qual você mais confia para escrever código? (${names.join(", ")}, ou vazio)`));
+        if (agents[trust])
+            agents[trust].trust = true;
+        const conductor = await ask(m(`Where will you talk to orq (the conductor)? (${names.join(", ")}, other)`, `Onde você vai conversar com o orq (o conductor)? (${names.join(", ")}, other)`), names.includes("claude") ? "claude" : names[0]);
+        const parallel = Number(await ask(m("How many tasks do you usually run at once?", "Quantas tarefas você costuma rodar ao mesmo tempo?"), "2")) || 2;
+        const ramGB = Number(await ask(m("RAM agents may use, in GB", "RAM que os agentes podem usar, em GB"), String(Math.round(totalmem() / 2 ** 30)))) || 8;
+        const toml = show({ agents, conductor, parallel, ramGB, preset });
+        if (await yes(m(`Write this to ${userConfigFile()}?`, `Gravar em ${userConfigFile()}?`)))
+            console.log(m(`written: ${write(toml)}`, `gravado: ${write(toml)}`));
+        if (names.includes("claude") || existsSync(join(homedir(), ".claude")))
+            skills();
+        const ws = await ask(m("Folder that groups your repos, for the conductor (empty = later: orq setup --workspace <dir>)", "Pasta que agrupa seus repos, para o conductor (vazio = depois: orq setup --workspace <pasta>)"));
+        if (ws)
+            workspace(ws, conductor);
+        next();
+        return 0;
+    }
+    catch (e) {
+        if (e.message !== "closed")
+            throw e;
+        console.log("\n" + m("setup cancelled — nothing was written", "setup cancelado — nada foi gravado"));
+        return 1;
+    }
+    finally {
+        rl.close();
+    }
+}
+function env() {
+    console.log(m("Environment", "Ambiente"));
+    let cfg = {};
+    try {
+        cfg = loadConfig().cfg;
+    }
+    catch { /* a broken config is reported by orq config */ }
+    for (const l of environment(cfg))
+        console.log(l);
+}
+function skills() {
+    console.log(m("Skills for Claude Code (/issue, /orq-setup, /orq-status)", "Skills do Claude Code (/issue, /orq-setup, /orq-status)"));
+    for (const l of installSkills())
+        console.log(l);
+}
+/** claude → .claude/skills/issue/SKILL.md; any other conductor → AGENTS.md. */
+function workspace(dir, conductor) {
+    let c = conductor;
+    if (!c) {
+        try {
+            c = getPath(loadConfig().cfg, "roles.conductor.agent");
+        }
+        catch { /* none */ }
+    }
+    c ??= onPath("claude") ? "claude" : "agents";
+    const d = expand(dir); // typed at the prompt: ~ is not expanded by any shell
+    console.log(`Workspace ${d}`);
+    for (const l of prepareWorkspace(d, c === "claude" ? "claude" : "agents"))
+        console.log(l);
+}
+const next = () => console.log(m(`Next: fill in the workspace CLAUDE.md, open your conductor in that folder and say "/issue <ID>".
+Board: orq board · quota: orq quota · completion: orq completion <shell>`, `Próximo: preencha o CLAUDE.md do workspace, abra o seu conductor nessa pasta e diga "/issue <ID>".
+Painel: orq board · cota: orq quota · autocompletar: orq completion <shell>`));
+export async function setup(argv) {
+    let preset, answers, doWrite = false, ws, conductor;
+    let install = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--detect") {
+            console.log(JSON.stringify(detect()));
+            return 0;
+        }
+        if (a === "--preset")
+            preset = argv[++i];
+        else if (a === "--answers")
+            answers = argv[++i];
+        else if (a === "--write")
+            doWrite = true;
+        else if (a === "--install")
+            install = true;
+        else if (a === "--workspace" && argv[i + 1])
+            ws = argv[++i];
+        else if (a === "--conductor" && argv[i + 1])
+            conductor = argv[++i];
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    if (install || ws) {
+        if (install) {
+            env();
+            skills();
+        }
+        if (ws)
+            workspace(ws, conductor);
+        return 0;
+    }
+    if (!answers)
+        return interactive(preset);
+    const a = JSON.parse(readFileSync(answers === "-" ? 0 : answers, "utf8"));
+    const toml = show({ ...a, preset: preset ?? a.preset });
+    if (doWrite)
+        console.error(m(`written: ${write(toml)}`, `gravado: ${write(toml)}`));
+    return 0;
+}

package/dist/commands/stats.js

@@ -0,0 +1,41 @@
+// orq stats [-w <workspace>] [--days N] [--json]   agent scoreboard from the .orquestra/ history (src/stats.ts)
+import { getPath, loadConfig } from "../config.js";
+import { m } from "../i18n.js";
+import { expand } from "../paths.js";
+import { collectRuns, rows } from "../stats.js";
+export const USAGE = "orq stats [-w <workspace>] [--days N] [--json]   scoreboard: delivery, time and tokens per agent";
+const k = (n) => (n === null ? "-" : n >= 1000 ? `${Math.round(n / 1000)}k` : String(n));
+const ORDER = ["impl", "fix", "review", "other"];
+export function stats(argv) {
+    let ws, days = 30, json = false;
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "-w")
+            ws = expand(argv[++i]);
+        else if (argv[i] === "--days")
+            days = Number(argv[++i]);
+        else if (argv[i] === "--json")
+            json = true;
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    // Default workspace: the config's (nearest .orq/ upwards), else the current folder.
+    ws ??= getPath(loadConfig().cfg, "_workspace") ?? process.cwd();
+    const runs = collectRuns(ws, days), rs = rows(runs);
+    if (json) {
+        console.log(JSON.stringify(rs, null, 2));
+        return 0;
+    }
+    console.log(m(`Scoreboard for the last ${days} days in ${ws} (${runs.length} runs; medians per run)`, `Placar dos últimos ${days} dias em ${ws} (${runs.length} execuções; medianas por execução)`) + "\n");
+    const hdr = `${m("role", "papel").padEnd(7)} ${m("agent", "agente").padEnd(12)} ${m("model", "modelo").padEnd(22)} ${"n".padStart(4)} `
+        + `${"ok%".padStart(5)} ${m("approved%", "aprov%").padStart(12)} ${"min".padStart(6)} ${m("new tok", "tok novos").padStart(10)} `
+        + `${m("total tok", "tok total").padStart(10)}`;
+    console.log(hdr + "\n" + "-".repeat(hdr.length));
+    for (const x of [...rs].sort((a, b) => ORDER.indexOf(a.role) - ORDER.indexOf(b.role) || b.n - a.n)) {
+        const ap = x.approved !== null ? `${x.approved}% (${x.n_appr})` : "-";
+        console.log(`${x.role.padEnd(7)} ${x.agent.padEnd(12)} ${x.model.slice(0, 22).padEnd(22)} ${String(x.n).padStart(4)} `
+            + `${String(x.ok).padStart(5)} ${ap.padStart(12)} ${String(x.min).padStart(6)} ${k(x.new).padStart(10)} ${k(x.tot).padStart(10)}`);
+    }
+    return 0;
+}