@irythill/orq 0.0.0-stage → 0.2.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;
+}

package/dist/commands/verify.js

@@ -0,0 +1,123 @@
+// orq verify — tests related to what changed in a worktree (port of herdr-verify), run by the conductor and not by the
+// child (the child hits its 4 GB cap with jest/vitest). One suite at a time on the machine (the "verify" queue,
+// machine.test_slots) under its own memory cap (machine.test_mem_max, or $VERIFY_MEM_MAX). Returns at once: the run goes
+// to a herdr tab, a tmux window or the background (src/terminal.ts); -x runs it here, in the foreground.
+//   output: <prefix>.txt — NEW failures and failures that already exist on the base; <prefix>.done "status=ok|fail new=N".
+//   status=ok only with no new failure. On-demand base check: only if some test fails, the SAME test files run in a
+//   temporary worktree at origin/<base> (fetched right then); whatever fails there is pre-existing.
+// Same protocol as orq agent: `orq wait <prefix>`, or "[HERDR-AGENT DONE] verify <repo> ..." in the conductor's herdr pane.
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { getPath, loadConfig } from "../config.js";
+import { m } from "../i18n.js";
+import { dropWorktree, failures, git, inJob, JS_EXT, launchJob, linkModules, runnerArgs, runnerOf, runTests, testCap, today, unsupported } from "../testrun.js";
+export const USAGE = "orq verify -w <workspace> -r <repo> -d <worktree> -b <base> -o <prefix> [-g group] [-x]   tests of the diff, new vs pre-existing failures";
+export async function verify(argv) {
+    if (argv[0] === "--run")
+        return run(JSON.parse(readFileSync(argv[1], "utf8")));
+    const o = {};
+    let here = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-x")
+            here = true;
+        else if (/^-[wrdbog]$/.test(a) && i + 1 < argv.length)
+            o[a[1]] = argv[++i];
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    for (const f of "wrdbo")
+        if (!o[f]) {
+            console.error(`${m("missing", "faltou")} -${f}\n${USAGE}`);
+            return 2;
+        }
+    const out = resolve(o.o);
+    mkdirSync(dirname(out), { recursive: true });
+    rmSync(`${out}.done`, { force: true });
+    rmSync(`${out}.txt`, { force: true });
+    // Title "<ID> verify <repo>" (ID = the prefix's folder, .orquestra/<ID>/) so closing the issue finds the tab.
+    const j = { cmd: "verify", title: `${basename(dirname(out))} verify ${o.r}`, ws: resolve(o.w), repo: o.r, wt: resolve(o.d), base: o.b, out };
+    const { cfg } = loadConfig(j.ws);
+    if (here)
+        return run({ ...j, parent: process.env.HERDR_NOTIFY_PANE ?? "", host: "plain", closeAfter: 0, keep: true });
+    console.log(`[orq verify] ${j.title} → ${launchJob(cfg, j, o.g || "agents")}`);
+    return 0;
+}
+async function run(j) {
+    const O = j.out, R = j.repo, B = j.base, WT = j.wt;
+    const { cfg } = loadConfig(j.ws);
+    let NEW = 0;
+    return inJob(j, `verify ${basename(dirname(O))} ${R}`, Number(getPath(cfg, "machine.test_slots") ?? 1), async (c) => {
+        const diff = git(WT, "diff", "--name-only", "--diff-filter=d", `origin/${B}...HEAD`);
+        if (diff === undefined)
+            throw new Error(m(`git diff against origin/${B} failed in ${WT}`, `o git diff contra origin/${B} falhou em ${WT}`));
+        const files = diff.split(/\r?\n/).filter((f) => JS_EXT.test(f));
+        const head = git(WT, "rev-parse", "--short", "HEAD") ?? "?";
+        if (!files.length) {
+            writeFileSync(`${O}.txt`, `# verify ${R} ${head}: no JS/TS file changed relative to origin/${B}\n`);
+            return true;
+        }
+        const { runner, script } = runnerOf(WT);
+        if (!runner)
+            throw new Error(unsupported(script));
+        const cap = testCap(cfg);
+        // One run → "<file> :: <test>" for each failure (undefined = the runner left no JSON report).
+        const tests = async (dir, mode, list) => {
+            const json = join(tmpdir(), `orq-verify-${process.pid}-${Date.now()}.json`);
+            try {
+                await runTests(dir, runner, runnerArgs(runner, mode, list, json), cap, c);
+                const r = failures(json, dir);
+                if (!r)
+                    c.say(m(`no JSON result in ${dir} (did the runner die? see ${O}.log)`, `sem resultado JSON em ${dir} (o runner morreu? veja ${O}.log)`));
+                return r;
+            }
+            finally {
+                rmSync(json, { force: true });
+            }
+        };
+        const mine = await tests(WT, "related", files);
+        if (!mine)
+            throw new Error(m("the test run failed", "a execução dos testes falhou"));
+        const failed = mine.failed;
+        let baseFailed = [], baseInfo = "no failure on the branch: base not checked";
+        if (failed.length)
+            baseInfo = await onBase(j, c, failed, async (dir, list) => (await tests(dir, "files", list))?.failed, (f) => { baseFailed = f; });
+        const newList = failed.filter((f) => !baseFailed.includes(f)), oldList = failed.filter((f) => baseFailed.includes(f));
+        NEW = newList.length;
+        const text = [`# verify ${R} ${head} ${today()}: ${mine.total} tests related to ${files.length} changed files`, `# base: ${baseInfo}`,
+            "", `## New failures (${NEW})`, ...(newList.length ? newList : ["none"]),
+            "", `## Already failing on origin/${B}`, ...(oldList.length ? oldList : ["none"])].join("\n") + "\n";
+        writeFileSync(`${O}.txt`, text);
+        process.stdout.write(text);
+        return NEW === 0;
+    }, (st) => ({ fields: `status=${st} new=${NEW}`, notice: `verify ${R} status=${st} new=${NEW} answer: ${O}.txt` }));
+}
+/** The failing test files again, on a fresh origin/<base> in a temporary worktree (only those that exist there). */
+async function onBase(j, c, failed, tests, set) {
+    const REPO = join(j.ws, j.repo), B = j.base, BWT = join(j.ws, ".worktrees", `verifybase-${j.repo}-${process.pid}`);
+    if (git(REPO, "fetch", "-q", "origin", B) === undefined)
+        c.say(m(`WARNING: fetching origin/${B} failed; using the local origin/${B}`, `AVISO: o fetch de origin/${B} falhou; usando o origin/${B} local`));
+    if (git(REPO, "worktree", "add", "-q", "--detach", BWT, `origin/${B}`) === undefined)
+        return `WARNING: could not create a worktree at origin/${B}; every failure counts as new`;
+    const drop = () => dropWorktree(REPO, BWT);
+    c.cleanup.push(drop);
+    try {
+        linkModules(REPO, BWT);
+        const files = [...new Set(failed.map((f) => f.replace(/ :: .*/, "")))].filter((f) => existsSync(join(BWT, f)));
+        const info = `${files.length} failing file(s) run on origin/${B} ${git(REPO, "rev-parse", "--short", `origin/${B}`) ?? "?"}`;
+        if (!files.length)
+            return info;
+        const base = await tests(BWT, files);
+        if (!base)
+            return `WARNING: the base run failed (see ${j.out}.log); every failure counts as new`;
+        set(base);
+        return info;
+    }
+    finally {
+        c.cleanup.splice(c.cleanup.indexOf(drop), 1);
+        drop();
+    }
+}

package/dist/commands/wait.js

@@ -0,0 +1,81 @@
+// orq wait — Notifier for any conductor: block until children started by `orq agent` (or orq verify/baseline) write
+// <prefix>.done, then print one line each: "[ORQ AGENT DONE] <title> status=ok rc=0 ... answer: <file>".
+// Exit 0 = all ok, 1 = some failed (or its runner died without .done), 124 = timeout. With --any, returns at the first.
+// Claude Code: run it as a background task; it wakes the conductor when it exits.
+import { existsSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { m } from "../i18n.js";
+import { alive } from "../lock.js";
+export const USAGE = "orq wait [--any] [--timeout <s>] [--answer] <prefix>...   block until child agents finish (exit 1 = one failed)";
+const read = (f) => { try {
+    return readFileSync(f, "utf8");
+}
+catch {
+    return undefined;
+} };
+/** Finished? → its summary line and whether it went well. */
+export function doneLine(prefix) {
+    let done = read(`${prefix}.done`)?.trim();
+    if (done === undefined) {
+        const pid = Number(read(`${prefix}.pid`));
+        if (!pid || alive(pid) || existsSync(`${prefix}.done`))
+            return undefined;
+        done = `status=died ${m("(the runner exited without writing .done)", "(o runner saiu sem escrever .done)")}`;
+    }
+    let title = basename(prefix);
+    try {
+        title = JSON.parse(read(`${prefix}.job.json`) ?? "").title || title;
+    }
+    catch { /* verify/baseline: no job */ }
+    const answer = [`${prefix}.out.md`, `${prefix}.txt`].find(existsSync) ?? prefix;
+    return { line: `[ORQ AGENT DONE] ${title} ${done} answer: ${answer}`, ok: /\bstatus=ok\b/.test(done) };
+}
+export async function wait(argv) {
+    let any = false, timeout = 0, answer = false;
+    const pending = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--any")
+            any = true;
+        else if (a === "--answer")
+            answer = true;
+        else if (a === "--timeout")
+            timeout = Number(argv[++i]);
+        else if (!a.startsWith("-"))
+            pending.push(a.replace(/\.(done|out\.md)$/, ""));
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    if (!pending.length || Number.isNaN(timeout)) {
+        console.error(USAGE);
+        return 2;
+    }
+    const end = timeout > 0 ? Date.now() + timeout * 1000 : Infinity;
+    let failed = false;
+    for (;;) {
+        for (const p of [...pending]) {
+            const d = doneLine(p);
+            if (!d)
+                continue;
+            pending.splice(pending.indexOf(p), 1);
+            console.log(d.line);
+            if (answer) {
+                const t = read(`${p}.out.md`);
+                if (t)
+                    console.log(t.trimEnd());
+            }
+            failed ||= !d.ok;
+            if (any)
+                return d.ok ? 0 : 1;
+        }
+        if (!pending.length)
+            return failed ? 1 : 0;
+        if (Date.now() > end) {
+            console.log(m(`still running: ${pending.join(" ")}`, `ainda rodando: ${pending.join(" ")}`));
+            return 124;
+        }
+        await new Promise((r) => setTimeout(r, 1000));
+    }
+}

package/dist/config.js

@@ -0,0 +1,93 @@
+// The orq configuration, merged in layers (each overrides the previous, key by key):
+//   1. built-in defaults (DEFAULTS, below)
+//   2. personal:  $ORQ_CONFIG, or <config dir>/config.toml | config.json
+//   3. workspace: <workspace>/.orq/workspace.toml | workspace.json  (searched from -w or the current folder, upwards)
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { configDir, expand } from "./paths.js";
+import { m } from "./i18n.js";
+export const DEFAULTS = {
+    machine: {
+        agent_mem_max: "4G", // memory cap per agent
+        agent_swap_max: "1G",
+        test_mem_max: "6G", // cap per test suite (orq verify, orq baseline)
+        mem_enforce: "auto", // auto (kernel cap where possible, else watchdog) | kernel | watchdog | off
+        test_slots: 1, // test suites in parallel on the machine
+        close_tab_after: 20, // seconds until a finished child tab closes (0 = never)
+        tui: false, // children in the agent's own screen (-T) by default
+        terminal: "auto", // where children show their output: auto (herdr, else tmux, else plain) | herdr | tmux | plain
+    },
+    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
+        max_rounds: 2, // fix rounds before stopping and calling the user
+        review: "other-vendor", // other-vendor | any
+    },
+    ui: { lang: "auto", theme: "gunmetal" }, // lang: auto | en | pt · theme: gunmetal | chrome | lcd | terminal
+    // Where quota comes from, per agent: "builtin" | "none" | false | { command = "..." } (see src/quota.ts).
+    // "claude" covers every account in claude-accounts.
+    quota: { claude: "builtin", codex: "builtin", opencode: "builtin", antigravity: "builtin", copilot: "builtin" },
+    tracker: { kind: "none" }, // plane | none
+    repos: {}, // defined by the workspace
+};
+export class ConfigError extends Error {
+}
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+export function merge(base, over) {
+    const out = { ...base };
+    for (const [k, v] of Object.entries(over))
+        out[k] = isObj(v) && isObj(out[k]) ? merge(out[k], v) : v;
+    return out;
+}
+function expandAll(v) {
+    if (Array.isArray(v))
+        return v.map(expandAll);
+    if (isObj(v))
+        return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, expandAll(x)]));
+    return typeof v === "string" ? expand(v) : v;
+}
+export function loadFile(path) {
+    const text = readFileSync(path, "utf8");
+    try {
+        return (path.endsWith(".json") ? JSON.parse(text) : parseToml(text));
+    }
+    catch (e) {
+        throw new ConfigError(m(`orq config: error reading ${path}: ${e.message}`, `orq config: erro lendo ${path}: ${e.message}`));
+    }
+}
+const firstFile = (...c) => c.find((f) => f && existsSync(f));
+export function findWorkspace(start) {
+    for (let d = resolve(start);; d = dirname(d)) {
+        const file = firstFile(join(d, ".orq", "workspace.toml"), join(d, ".orq", "workspace.json"));
+        if (file)
+            return { root: d, file };
+        if (dirname(d) === d)
+            return {};
+    }
+}
+export function loadConfig(workspace) {
+    const user = firstFile(process.env.ORQ_CONFIG && expand(process.env.ORQ_CONFIG), join(configDir(), "config.toml"), join(configDir(), "config.json"));
+    const ws = findWorkspace(workspace ?? process.cwd());
+    let cfg = DEFAULTS;
+    const files = [];
+    for (const f of [user, ws.file]) {
+        if (!f)
+            continue;
+        cfg = merge(cfg, loadFile(f));
+        files.push(f);
+    }
+    cfg = expandAll(cfg);
+    cfg._workspace = ws.root ?? null;
+    return { cfg, files };
+}
+/** Value at a dotted path (a.b.c), or undefined. */
+export function getPath(cfg, path) {
+    let v = cfg;
+    for (const part of path.split(".")) {
+        if (!isObj(v) || !(part in v))
+            return undefined;
+        v = v[part];
+    }
+    return v;
+}

package/dist/fsutil.js

@@ -0,0 +1,9 @@
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/** Write via a temp file + rename, so a reader never sees a half-written file. */
+export function writeAtomic(path, text) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, text, "utf8");
+    renameSync(tmp, path);
+}

package/dist/i18n.js

@@ -0,0 +1,21 @@
+export function systemLang() {
+    const e = process.env;
+    const loc = e.LC_ALL || e.LC_MESSAGES || e.LANG || Intl.DateTimeFormat().resolvedOptions().locale || "";
+    return loc.toLowerCase().startsWith("pt") ? "pt" : "en";
+}
+export function detectLang(cfgLang, useEnv = true) {
+    const v = useEnv ? process.env.ORQ_LANG : undefined;
+    if (v === "en" || v === "pt")
+        return v;
+    if (cfgLang === "en" || cfgLang === "pt")
+        return cfgLang;
+    return systemLang();
+}
+let current;
+export function setLang(l) {
+    current = l;
+}
+export function m(en, pt) {
+    current ??= detectLang();
+    return current === "pt" && pt !== undefined ? pt : en;
+}