@irythill/orq 0.0.0-stage → 0.1.0

package/dist/stats.js

@@ -0,0 +1,159 @@
+// Agent scoreboard from the .orquestra/ history: what each agent delivered and what it cost (port of orq-stats).
+// Per run (<prefix>.run.sh + .log + .done + .out.md): agent, model, role (impl | fix | review | other), status,
+// duration, tokens. "New" tokens = excluding cache reads (what actually weighs on quota); Codex without a session
+// file only reports the total. Implementation delivery = the first review of the same repo in the issue said APPROVED.
+// Limitation: follow-ups (-R) reuse the implementation prefix, so the "impl" row shows the last round of that prefix.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+const ROLE = /^(impl|fix\d*|review\d*|[a-z]+-review\d*)-?/;
+const read = (f) => { try {
+    return readFileSync(f, "utf8");
+}
+catch {
+    return "";
+} };
+export function agentModel(run, log) {
+    const a = /\b(codex exec|codex resume|codex|claude -p|claude|opencode run|opencode|agy)\b/.exec(run);
+    const first = a ? a[1].split(" ")[0] : "?";
+    const agent = first === "agy" ? "antigravity" : first;
+    let model = /(?:\s-m|--model)\s+'?([^\s']+)/.exec(run)?.[1];
+    if (agent === "codex" && !model)
+        model = /^model: (\S+)/m.exec(log)?.[1] ?? "default";
+    return [agent, (model ?? "default").split("/").pop()];
+}
+function codexSession(sid) {
+    const root = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "sessions");
+    const ls = (d) => { try {
+        return readdirSync(d);
+    }
+    catch {
+        return [];
+    } };
+    for (const y of ls(root))
+        for (const mo of ls(join(root, y)))
+            for (const d of ls(join(root, y, mo))) {
+                const f = ls(join(root, y, mo, d)).find((x) => x.startsWith("rollout-") && x.endsWith(`-${sid}.jsonl`));
+                if (f)
+                    return join(root, y, mo, d, f);
+            }
+}
+/** [new, total] — new excludes cache reads. */
+export function tokens(agent, log, sid = "") {
+    let neu = 0, tot = 0;
+    if (agent === "codex") {
+        const f = sid && codexSession(sid);
+        if (f) {
+            const last = read(f).split("\n").filter((l) => l.includes('"total_token_usage"')).pop();
+            const u = last && /"total_token_usage":(\{[^}]*\})/.exec(last);
+            if (u) {
+                const j = JSON.parse(u[1]);
+                return [j.total_tokens - (j.cached_input_tokens ?? 0), j.total_tokens];
+            }
+        }
+        const all = [...log.matchAll(/tokens used\s*\n\s*([\d,]+)/g)];
+        if (all.length)
+            tot = neu = Number(all[all.length - 1][1].replace(/,/g, ""));
+        return [neu, tot];
+    }
+    for (const line of log.split("\n")) {
+        if (!line.startsWith("{"))
+            continue;
+        let e;
+        try {
+            e = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (agent === "claude" && e.type === "result") {
+            const u = e.usage ?? {};
+            const n = (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.output_tokens ?? 0);
+            [neu, tot] = [n, n + (u.cache_read_input_tokens ?? 0)];
+        }
+        else if (agent === "opencode" && e.type === "step_finish") {
+            const t = e.part?.tokens ?? {};
+            neu += (t.total ?? 0) - (t.cache?.read ?? 0);
+            tot += t.total ?? 0;
+        }
+        else if (agent === "antigravity" && e.event === "result") {
+            const u = e.result?.usage ?? {};
+            [neu, tot] = [u.total_tokens ?? 0, (u.total_tokens ?? 0) + (u.cache_read_tokens ?? 0)]; // agy's total excludes cache
+        }
+    }
+    return [neu, tot];
+}
+export function collectRuns(ws, days) {
+    const cutoff = Date.now() - days * 86400_000;
+    const base = join(ws, ".orquestra");
+    const runs = [];
+    const dirs = (() => { try {
+        return readdirSync(base);
+    }
+    catch {
+        return [];
+    } })();
+    for (const issue of dirs) {
+        let files;
+        try {
+            files = readdirSync(join(base, issue));
+        }
+        catch {
+            continue;
+        }
+        for (const f of files.filter((x) => x.endsWith(".run.sh"))) {
+            const pre = join(base, issue, f.slice(0, -".run.sh".length));
+            const runF = `${pre}.run.sh`, done = `${pre}.done`;
+            const rs = statSync(runF);
+            if (rs.mtimeMs < cutoff || !existsSync(done))
+                continue;
+            const txt = read(runF);
+            if (txt.includes("herdr-verify") || txt.includes("herdr-baseline"))
+                continue;
+            const log = read(`${pre}.log`);
+            const [agent, model] = agentModel(txt, log);
+            const name = basename(pre);
+            const rm = ROLE.exec(name);
+            const role = rm && rm[1].includes("review") ? "review"
+                : name.startsWith("fix") || txt.includes("-R ") || txt.includes(" resume ") || txt.includes("--resume") ? "fix"
+                    : name.startsWith("impl") ? "impl" : "other";
+            const out = read(`${pre}.out.md`);
+            const [neu, tot] = tokens(agent, log, read(`${pre}.id`).trim());
+            runs.push({ issue, name, agent, model, role, ok: read(done).includes("status=ok") && out.trim() !== "",
+                secs: Math.max(0, Math.floor((statSync(done).mtimeMs - rs.mtimeMs) / 1000)), new: neu, tot,
+                repo: name.includes("-") ? name.slice(name.indexOf("-") + 1) : "" });
+        }
+    }
+    // Implementation delivery: the first review of the same repo in the issue.
+    for (const r of runs.filter((x) => x.role === "impl")) {
+        const rv = join(base, r.issue, `review-${r.repo}.out.md`);
+        if (!existsSync(rv))
+            continue;
+        // "non-blocking suggestion" shows up in approved reviews: the verdict is the word APPROVED (APROVADO in older runs).
+        const t = read(rv).slice(0, 4000).toUpperCase();
+        r.approved = (t.includes("APPROVED") || t.includes("APROVADO")) &&
+            !["NOT APPROVED", "REPROVADO", "NÃO APROVADO"].some((x) => t.includes(x));
+    }
+    return runs;
+}
+const median = (xs) => {
+    const s = [...xs].sort((a, b) => a - b), h = s.length >> 1;
+    return s.length % 2 ? s[h] : (s[h - 1] + s[h]) / 2;
+};
+export function rows(runs) {
+    const groups = new Map();
+    for (const r of runs) {
+        const k = JSON.stringify([r.role, r.agent, r.model]);
+        groups.set(k, [...(groups.get(k) ?? []), r]);
+    }
+    return [...groups.keys()].sort().map((k) => {
+        const rs = groups.get(k), [role, agent, model] = JSON.parse(k);
+        const withTok = rs.filter((r) => r.tot), appr = rs.filter((r) => r.approved !== undefined).map((r) => r.approved);
+        return { role, agent, model, n: rs.length, ok: Math.round(100 * rs.filter((r) => r.ok).length / rs.length),
+            approved: appr.length ? Math.round(100 * appr.filter(Boolean).length / appr.length) : null, n_appr: appr.length,
+            min: Math.round(median(rs.map((r) => r.secs)) / 6) / 10,
+            new: withTok.length ? Math.floor(median(withTok.map((r) => r.new))) : null,
+            tot: withTok.length ? Math.floor(median(withTok.map((r) => r.tot))) : null };
+    });
+}
+export const scoreboard = (ws, days) => rows(collectRuns(ws, days));

package/dist/suggest.js

@@ -0,0 +1,121 @@
+// Guided setup: turns what a user knows (plans, trust, parallel tasks, RAM) into roles, weights and memory caps,
+// with a reason for each choice. The rules are the ones the case study found by hand (docs/case-study.md):
+//   shares quota with the conductor          → reserve
+//   small plan / monthly allowance           → opinion only
+//   pay-as-you-go                            → reviewer pool, not primary
+//   no free shell when headless (agy)        → reviewer only, diff attached
+//   trusted, else largest plan, not conductor → primary
+//   vendor ≠ primary's                       → reviewer (cross review)
+import { m } from "./i18n.js";
+import { BUILTIN_VENDORS } from "./roles.js";
+/** Agents that only read when headless (their CLI denies commands outside an allowlist). */
+const READ_ONLY = new Set(["antigravity"]);
+const RANK = { large: 3, free: 2, payg: 1, small: 0 };
+export function suggestRoles(a) {
+    const names = Object.keys(a.agents);
+    if (!names.length)
+        throw new Error(m("no agent to set up", "nenhum agente para configurar"));
+    const vendor = (n) => a.agents[n].vendor ?? BUILTIN_VENDORS[n] ?? n;
+    const reasons = [], notices = [];
+    const isConductor = (n) => n === a.conductor;
+    const canImpl = (n) => !READ_ONLY.has(n);
+    const single = a.preset === "single-agent" || names.length === 1;
+    // Primary: the trusted one, else the largest plan; avoid the conductor's quota, small plans and pay-as-you-go.
+    const implCands = names.filter(canImpl);
+    const byPlan = (xs) => [...xs].sort((x, y) => Number(Boolean(a.agents[y].trust)) - Number(Boolean(a.agents[x].trust))
+        || Number(isConductor(x)) - Number(isConductor(y))
+        || RANK[a.agents[y].plan] - RANK[a.agents[x].plan]);
+    const primary = byPlan(implCands.length ? implCands : names)[0];
+    const why = a.agents[primary].trust ? m("the one you trust most", "o que você mais confia")
+        : m("largest plan apart from the conductor's", "maior plano fora o do conductor");
+    reasons.push(`primary = ${primary}: ${why}`);
+    if (!canImpl(primary))
+        notices.push(m(`${primary} only reads when headless: it can't implement well`, `${primary} só lê no modo headless: não implementa bem`));
+    const workers = implCands.filter((n) => n !== primary && !["small", "payg"].includes(a.agents[n].plan));
+    const opinion = names.filter((n) => n !== primary && a.agents[n].plan === "small");
+    const otherVendor = names.filter((n) => vendor(n) !== vendor(primary) && !opinion.includes(n));
+    let reviewers = otherVendor.length ? otherVendor : names.filter((n) => !opinion.includes(n));
+    const rule = otherVendor.length && !single ? "other-vendor" : "any";
+    if (single)
+        reviewers = [primary];
+    if (single) {
+        notices.push(m("One agent does everything; reviews run in a fresh session. Cross-vendor review catches more — consider a second agent.", "Um agente faz tudo; a revisão roda numa sessão nova. Revisão entre fornecedores pega mais erros — considere um segundo agente."));
+    }
+    else if (!otherVendor.length) {
+        notices.push(m(`All agents are from ${vendor(primary)}: cross-vendor review is off (rule = "any"); review uses another session/model.`, `Todos os agentes são de ${vendor(primary)}: revisão entre fornecedores desligada (rule = "any"); a revisão usa outra sessão/modelo.`));
+    }
+    else {
+        reasons.push(`reviewer = ${reviewers.join(", ")}: ` + m(`vendor different from ${primary}'s (cross review)`, `fornecedor diferente do de ${primary} (revisão cruzada)`));
+    }
+    const agents = {};
+    for (const n of names) {
+        const ans = a.agents[n], roles = [];
+        if (n === primary || (!single && workers.includes(n)))
+            roles.push("impl", "fix");
+        if (reviewers.includes(n))
+            roles.push("review");
+        if (opinion.includes(n) && !single)
+            roles.push("opinion");
+        agents[n] = { vendor: vendor(n), roles, ...(ans.quota ? { quota: ans.quota } : {}) };
+        if (isConductor(n) && n !== primary && !single) {
+            agents[n].reserve = true;
+            reasons.push(`${n}: reserve — ` + m("shares quota with the conductor", "divide cota com o conductor"));
+        }
+        if (ans.plan === "small" && !single)
+            reasons.push(`${n}: opinion — ` + m("small plan or monthly allowance", "plano pequeno ou franquia mensal"));
+        if (ans.plan === "payg" && n !== primary)
+            reasons.push(`${n}: ` + m("pay-as-you-go → reviews (few tokens)", "pague-por-uso → revisa (poucos tokens)"));
+        if (READ_ONLY.has(n) && n !== primary)
+            reasons.push(`${n}: ` + m("reviews only (reads when headless, diff attached)", "só revisa (só lê no headless, diff anexado)"));
+    }
+    const roles = {
+        conductor: { agent: a.conductor },
+        primary: { agent: primary, ...(workers.length ? { fallback: workers } : {}) },
+        reviewer: { pick: "auto", pool: reviewers, rule },
+    };
+    if (workers.length)
+        roles.workers = { pick: "auto", pool: [primary, ...workers] };
+    if (opinion.length && !single)
+        roles.opinion = { pick: "auto", pool: opinion };
+    const quality = a.preset === "quality" || (a.preset !== "economy" && a.parallel <= 2);
+    const weights = quality ? { quality: 0.55, tokens: 0.3, speed: 0.15 } : { quality: 0.4, tokens: 0.45, speed: 0.15 };
+    reasons.push(quality ? m("weights favor quality (few tasks at once)", "pesos priorizam qualidade (poucas tarefas por vez)")
+        : m("weights favor tokens (several tasks at once)", "pesos priorizam tokens (várias tarefas por vez)"));
+    // Memory: ~60 % of RAM for agents; rarely more than two peak at once, so it is split by min(parallel, 2); 2–8 GB
+    // each. Tests get a bit more, up to 40 % of RAM.
+    const per = Math.max(2, Math.min(8, Math.floor((a.ramGB * 0.6) / Math.min(Math.max(1, a.parallel), 2))));
+    const test = Math.max(2, Math.min(per + 2, Math.floor(a.ramGB * 0.4)));
+    return { agents, roles, weights, machine: { agent_mem_max: `${per}G`, test_mem_max: `${test}G` }, reasons, notices };
+}
+const q = (s) => JSON.stringify(s);
+const list = (xs) => `[${xs.map(q).join(", ")}]`;
+/** The proposal as a commented config.toml (new installs; agent models are left to the CLI defaults). */
+export function toToml(p) {
+    const out = ["# Written by `orq setup`. Edit freely: everything here is a suggestion (docs/portability.md §4).", "",
+        "[machine]", `agent_mem_max = ${q(p.machine.agent_mem_max)}`, `test_mem_max  = ${q(p.machine.test_mem_max)}`, ""];
+    for (const [n, a] of Object.entries(p.agents)) {
+        out.push(`[agents.${n}]`, `vendor = ${q(a.vendor)}`, `roles  = ${list(a.roles)}`);
+        if (a.quota)
+            out.push(`quota  = ${list(a.quota)}`);
+        if (a.reserve)
+            out.push("reserve = true");
+        out.push("# models.<role>.<level> = \"model[@effort]\" — without models, the CLI's default model is used", "");
+    }
+    for (const [r, v] of Object.entries(p.roles)) {
+        out.push(`[roles.${r}]`);
+        if (v.agent)
+            out.push(`agent = ${q(v.agent)}`);
+        if (v.fallback)
+            out.push(`fallback = ${list(v.fallback)}`);
+        if (v.pick)
+            out.push(`pick = ${q(v.pick)}`);
+        if (v.pool)
+            out.push(`pool = ${list(v.pool)}`);
+        if (v.rule)
+            out.push(`rule = ${q(v.rule)}`);
+        out.push("");
+    }
+    out.push("[policy.weights]", `quality = ${p.weights.quality}`, `tokens  = ${p.weights.tokens}`, `speed   = ${p.weights.speed}`, "");
+    out.push("# Why:", ...p.reasons.map((r) => `#   ${r}`), ...p.notices.map((n) => `# ! ${n}`), "");
+    return out.join("\n");
+}

package/dist/terminal.js

@@ -0,0 +1,83 @@
+// TerminalHost — where a child agent's live output goes. machine.terminal (or $ORQ_TERMINAL): auto | herdr | tmux | plain.
+//   herdr  a tab in the herdr workspace named after the group (created if missing), without stealing focus (herdr-tab)
+//   tmux   a background window in the current tmux session
+//   plain  a detached background process; its screen output goes to <state dir>/agents/<run>.log
+// auto = herdr inside a herdr pane (HERDR_PANE_ID), else tmux inside tmux (TMUX), else plain.
+import { spawn, spawnSync } from "node:child_process";
+import { closeSync, mkdirSync, openSync } from "node:fs";
+import { join } from "node:path";
+import { m } from "./i18n.js";
+import { stateDir } from "./paths.js";
+export function detectHost(cfg) {
+    const want = String(process.env.ORQ_TERMINAL || (cfg.machine ?? {}).terminal || "auto");
+    if (want === "herdr" || want === "tmux" || want === "plain")
+        return want;
+    if (want !== "auto")
+        throw new Error(m(`unknown terminal: ${want} (auto | herdr | tmux | plain)`, `terminal desconhecido: ${want} (auto | herdr | tmux | plain)`));
+    if (process.env.HERDR_PANE_ID && spawnSync("herdr", ["status", "server"], { stdio: "ignore" }).status === 0)
+        return "herdr";
+    if (process.env.TMUX)
+        return "tmux";
+    return "plain";
+}
+/** POSIX shell quoting (herdr and tmux type the command into a shell). */
+export const shq = (s) => /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+function herdr(args) {
+    const r = spawnSync("herdr", args, { encoding: "utf8" });
+    if (r.status !== 0)
+        throw new Error(`herdr ${args.slice(0, 2).join(" ")}: ${(r.stderr || r.stdout || "").trim()}`);
+    try {
+        return JSON.parse(r.stdout || "{}");
+    }
+    catch {
+        return {};
+    }
+}
+/** Start `argv` on the host; returns where it runs (pane id, tmux pane, or pid:<n>). */
+export function launch(host, l) {
+    const line = l.argv.map(shq).join(" ");
+    if (host === "herdr") {
+        if (spawnSync("herdr", ["status", "server"], { stdio: "ignore" }).status !== 0)
+            throw new Error(m("the herdr server is not running (systemctl --user start herdr)", "o servidor do herdr não está rodando (systemctl --user start herdr)"));
+        const ws = (herdr(["workspace", "list"]).result?.workspaces ?? []);
+        const w = ws.find((x) => x.label === l.group)?.workspace_id;
+        let r;
+        if (!w) {
+            r = herdr(["workspace", "create", "--cwd", l.dir, "--label", l.group, "--no-focus"]).result;
+            spawnSync("herdr", ["tab", "rename", String(r?.tab?.tab_id), l.title], { stdio: "ignore" });
+        }
+        else
+            r = herdr(["tab", "create", "--workspace", w, "--cwd", l.dir, "--label", l.title, "--no-focus"]).result;
+        const pane = r?.root_pane?.pane_id;
+        if (!pane)
+            throw new Error(m("herdr returned no pane", "o herdr não devolveu um pane"));
+        spawnSync("herdr", ["pane", "rename", pane, l.title], { stdio: "ignore" });
+        herdr(["pane", "run", pane, line]);
+        return pane;
+    }
+    if (host === "tmux") {
+        const cmd = l.keep ? `${line}; exec "\${SHELL:-sh}"` : line;
+        const r = spawnSync("tmux", ["new-window", "-d", "-P", "-F", "#{pane_id}", "-n", l.title, "-c", l.dir, cmd], { encoding: "utf8" });
+        if (r.status !== 0)
+            throw new Error(`tmux new-window: ${(r.stderr || "").trim()}`);
+        return `tmux:${r.stdout.trim()}`;
+    }
+    mkdirSync(join(stateDir(), "agents"), { recursive: true });
+    const fd = openSync(join(stateDir(), "agents", `${l.id}.log`), "a");
+    const c = spawn(l.argv[0], l.argv.slice(1), { cwd: l.dir, detached: true, stdio: ["ignore", fd, fd], windowsHide: true });
+    c.unref();
+    closeSync(fd);
+    return `pid:${c.pid}`;
+}
+/** After a run: close our own herdr tab (the result stays in the files). tmux windows close when the runner exits. */
+export function closeOwnTab(host) {
+    const p = process.env.HERDR_PANE_ID;
+    if (host !== "herdr" || !p)
+        return;
+    try {
+        const tab = herdr(["pane", "get", p]).result?.pane?.tab_id;
+        if (tab)
+            spawnSync("herdr", ["tab", "close", tab], { stdio: "ignore" });
+    }
+    catch { /* already gone */ }
+}

package/dist/testrun.js

@@ -0,0 +1,203 @@
+// Test runs for orq verify / orq baseline: detect jest or vitest from package.json "test", run it under the test
+// memory cap (src/process.ts) and read its JSON report into "<file relative to the repo> :: <full test name>" lines.
+// The runner's own bin (node_modules/<runner>/package.json "bin") runs with this node, so Windows needs no shell;
+// without it, npx as before. Also the background job both share (launch on a TerminalHost, queue, .pid/.done, notify).
+import { spawnSync } from "node:child_process";
+import { createWriteStream, existsSync, lstatSync, readFileSync, realpathSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeAtomic } from "./fsutil.js";
+import { m } from "./i18n.js";
+import { acquire, release } from "./lock.js";
+import { killTree, parseSize, runCapped } from "./process.js";
+import { closeOwnTab, detectHost, launch } from "./terminal.js";
+export const JS_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/;
+export const git = (dir, ...a) => {
+    const r = spawnSync("git", ["-C", dir, ...a], { encoding: "utf8", maxBuffer: 1 << 28 });
+    return r.status === 0 ? r.stdout.trim() : undefined;
+};
+/** jest | vitest from the "test" script (vitest first, as herdr-verify did). */
+export function runnerOf(dir) {
+    let script = "";
+    try {
+        script = String(JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).scripts?.test ?? "");
+    }
+    catch { /* none */ }
+    return { runner: script.includes("vitest") ? "vitest" : script.includes("jest") ? "jest" : undefined, script };
+}
+/** Runner arguments: "related" = tests related to these sources, "files" = these test files, "all" = full suite. */
+export function runnerArgs(runner, mode, files, json) {
+    const some = mode !== "all";
+    if (runner === "vitest")
+        return [mode === "related" ? "related" : "run", ...files, ...(some ? ["--run", "--passWithNoTests"] : []),
+            "--reporter=json", `--outputFile=${json}`, "--maxWorkers=2"];
+    return [...(mode === "related" ? ["--findRelatedTests"] : mode === "files" ? ["--runTestsByPath"] : []), ...files,
+        ...(some ? ["--passWithNoTests"] : []), "--json", `--outputFile=${json}`, "--maxWorkers=2", "--workerIdleMemoryLimit=1G"];
+}
+/** The runner's own JS entry in <dir>/node_modules, if any. */
+export function localBin(dir, runner) {
+    try {
+        const pj = join(dir, "node_modules", runner, "package.json");
+        const bin = JSON.parse(readFileSync(pj, "utf8")).bin;
+        const rel = typeof bin === "string" ? bin : bin?.[runner];
+        return rel && existsSync(join(dirname(pj), rel)) ? join(dirname(pj), rel) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Memory cap for a test suite: $VERIFY_MEM_MAX, else machine.test_mem_max. */
+export function testCap(cfg) {
+    const mach = (cfg.machine ?? {});
+    return { cap: parseSize(process.env.VERIFY_MEM_MAX || String(mach.test_mem_max ?? "off")), mode: mach.mem_enforce ?? "auto" };
+}
+/** Run the runner in `dir` under the cap; its output goes to the screen and log (unless !show). Resolves to the exit code. */
+export function runTests(dir, runner, args, cap, c, show = true) {
+    const bin = localBin(dir, runner);
+    const [cmd, argv] = bin ? [process.execPath, [bin, ...args]] : ["npx", [runner, ...args]];
+    return runCapped(cmd, argv, {
+        ...cap, cwd: dir, quote: true, stdio: show ? ["ignore", "pipe", "pipe"] : "ignore",
+        onSpawn: (p) => {
+            c.child = p.pid;
+            if (show)
+                for (const s of [p.stdout, p.stderr])
+                    s?.setEncoding("utf8").on("data", (d) => { for (const l of d.replace(/\r?\n$/, "").split(/\r?\n/))
+                        c.say(l); });
+        },
+    }).finally(() => { c.child = undefined; });
+}
+/** A test file path from the report, relative to the repo folder (forward slashes, as on Linux). */
+export function relTo(dir, file) {
+    const dirs = [dir];
+    try {
+        dirs.push(realpathSync(dir));
+    }
+    catch { /* gone */ }
+    for (const d of dirs) {
+        const r = relative(d, file);
+        if (r && !r.startsWith("..") && !isAbsolute(r))
+            return r.split("\\").join("/");
+    }
+    return file.split("\\").join("/");
+}
+/** Failed tests in a jest/vitest JSON report → sorted unique "<file> :: <test>" lines, plus numTotalTests. */
+export function failures(report, dir) {
+    let j;
+    try {
+        j = JSON.parse(readFileSync(report, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    const failed = new Set();
+    for (const f of j.testResults ?? [])
+        for (const a of f.assertionResults ?? [])
+            if (a.status === "failed")
+                failed.add(`${relTo(dir, f.name)} :: ${a.fullName}`);
+    return { failed: [...failed].sort(), total: j.numTotalTests ?? 0 };
+}
+/** node_modules of the main clone into a temporary worktree (a junction on Windows: no admin rights needed). */
+export function linkModules(from, to) {
+    try {
+        symlinkSync(realpathSync(join(from, "node_modules")), join(to, "node_modules"), process.platform === "win32" ? "junction" : "dir");
+    }
+    catch { /* none */ }
+}
+/**
+ * Remove a temporary worktree. The node_modules link goes first, by itself: git on Windows can't remove a junction
+ * (and must never walk into the main clone's node_modules through it).
+ */
+export function dropWorktree(repo, dir) {
+    const nm = join(dir, "node_modules");
+    try {
+        if (lstatSync(nm).isSymbolicLink() || process.platform === "win32")
+            unlinkSync(nm);
+    }
+    catch {
+        try {
+            rmdirSync(nm);
+        }
+        catch { /* none */ }
+    }
+    if (git(repo, "worktree", "remove", "--force", dir) === undefined && existsSync(dir)) {
+        rmSync(dir, { recursive: true, force: true });
+        git(repo, "worktree", "prune");
+    }
+}
+/** "2026-10-27" in local time (date -I). */
+export const today = () => {
+    const d = new Date(), p = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+};
+/** A line to both the screen and the run's log. */
+export const teller = (log) => (l) => { process.stdout.write(`${l}\n`); log.write(`${l}\n`); };
+export const unsupported = (script) => m(`unsupported runner: '${script}' (jest or vitest)`, `runner não suportado: '${script}' (jest ou vitest)`);
+const CLI = fileURLToPath(new URL("./cli.js", import.meta.url));
+/** Write <out>.job.json and start `orq <cmd> --run <job>` on the host (herdr tab, tmux window or background). */
+export function launchJob(cfg, j, group) {
+    const mach = (cfg.machine ?? {});
+    const closeAfter = Number(process.env.HERDR_CLOSE_DELAY ?? mach.close_tab_after ?? 20);
+    const job = { ...j, parent: process.env.HERDR_PANE_ID ?? "", host: detectHost(cfg), closeAfter,
+        keep: process.env.HERDR_KEEP_TAB === "1" || process.env.ORQ_KEEP_TAB === "1" || closeAfter <= 0 };
+    writeAtomic(`${j.out}.job.json`, JSON.stringify(job, null, 1));
+    return launch(job.host, { group, title: j.title, dir: j.cmd === "verify" ? j.wt : j.repo, keep: job.keep,
+        argv: [process.execPath, CLI, j.cmd, "--run", `${j.out}.job.json`], id: `${j.cmd}-${Math.floor(Date.now() / 1000)}-${process.pid}` });
+}
+/**
+ * Run `body` as the job's runner: holds a slot in the "verify" queue (label shown by orq board), writes <out>.pid
+ * meanwhile and <out>.done after (`done(status)` gives its fields), notifies the conductor's herdr pane, closes its
+ * own tab. A signal (tab closed, Ctrl+C) still frees the slot, removes temporary worktrees and writes .done.
+ */
+export async function inJob(j, label, slots, body, done) {
+    const O = j.out;
+    writeFileSync(`${O}.pid`, String(process.pid));
+    const log = createWriteStream(`${O}.log`), say = teller(log);
+    const c = { say, slots, cleanup: [] };
+    let st = "fail", ended = false;
+    const finish = () => {
+        if (ended)
+            return;
+        ended = true;
+        for (const f of c.cleanup.splice(0))
+            try {
+                f();
+            }
+            catch { /* best effort */ }
+        release("verify", process.pid);
+        const { fields, notice } = done(st);
+        writeAtomic(`${O}.done`, `${fields} at=${new Date().toISOString()}\n`);
+        rmSync(`${O}.pid`, { force: true });
+        if (j.parent)
+            notify(j.parent, `[HERDR-AGENT DONE] ${notice}`);
+        say(`[${j.cmd} ${m("finished", "terminou")}: ${fields}] ${notice.replace(/.* answer: /, "")}`);
+    };
+    const stop = () => { if (c.child)
+        killTree(c.child); finish(); process.exit(130); };
+    const sigs = process.platform === "win32" ? ["SIGINT", "SIGBREAK", "SIGHUP"] : ["SIGINT", "SIGTERM", "SIGHUP"];
+    for (const s of sigs)
+        process.on(s, stop);
+    try {
+        await acquire("verify", process.pid, label, slots, () => say(m("another verification is running; waiting for my turn...", "outra verificação em andamento; aguardando a vez...")));
+        if (await body(c))
+            st = "ok";
+    }
+    catch (e) {
+        say(`orq ${j.cmd}: ${e.message}`);
+    }
+    finally {
+        finish();
+        for (const s of sigs)
+            process.off(s, stop);
+    }
+    await new Promise((r) => log.end(r));
+    if (j.host !== "plain" && !j.keep) {
+        await new Promise((r) => setTimeout(r, j.closeAfter * 1000));
+        closeOwnTab(j.host);
+    }
+    return st === "ok" ? 0 : 1;
+}
+/** The conductor is a herdr pane: type the line into it (herdr-notify waits for it to leave a dialog). */
+export function notify(pane, line) {
+    const local = join(dirname(CLI), "..", "setup", "herdr-notify");
+    spawnSync(existsSync(local) ? local : "herdr-notify", [pane, line], { stdio: "inherit" });
+}

package/dist/toml-set.js

@@ -0,0 +1,46 @@
+// Writes `key = "value"` into [section] of a TOML text, keeping everything else (comments, order, blank lines).
+// Replaces the key if present, adds it at the end of the section, or adds the section at the end of the file.
+// Same behaviour as the awk in the old setup/orq-set.
+export function setTomlString(text, section, key, value) {
+    const header = `[${section}]`;
+    const line = `${key} = ${JSON.stringify(value)}`;
+    const keyRe = new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*=`);
+    const lines = text === "" ? [] : text.replace(/\r?\n$/, "").split(/\r?\n/);
+    const out = [];
+    let inSec = false, done = false, blanks = 0;
+    const flush = () => { for (; blanks > 0; blanks--)
+        out.push(""); };
+    for (const l of lines) {
+        if (l.startsWith("[")) {
+            if (inSec && !done) {
+                out.push(line);
+                done = true;
+            }
+            flush();
+            inSec = l.trim() === header;
+            out.push(l);
+            continue;
+        }
+        if (inSec && l.trim() === "") {
+            blanks++;
+            continue;
+        } // hold blank lines inside the section
+        if (inSec && keyRe.test(l)) {
+            flush();
+            out.push(line);
+            done = true;
+            continue;
+        }
+        flush();
+        out.push(l);
+    }
+    if (!done) {
+        if (!inSec) {
+            flush();
+            out.push("", header);
+        }
+        out.push(line);
+    }
+    flush();
+    return out.join("\n") + "\n";
+}

package/package.json

@@ -1,6 +1,27 @@
-{
-  "name": "@irythill/orq",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@irythill/orq",
+  "version": "0.1.0",
+  "description": "Orchestrate coding agents (Claude Code, Codex, OpenCode, Antigravity, Copilot) from one conductor.",
+  "license": "MIT",
+  "type": "module",
+  "bin": { "orq": "dist/cli.js" },
+  "files": ["dist", "!dist/**/*.test.js", "skills", "templates/workspace.CLAUDE.md"],
+  "engines": { "node": ">=20" },
+  "repository": { "type": "git", "url": "git+https://github.com/irythill/orq.git" },
+  "homepage": "https://github.com/irythill/orq#readme",
+  "keywords": ["agents", "orchestration", "claude-code", "codex", "opencode", "cli"],
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc && node --test dist/orq.test.js",
+    "prepack": "tsc"
+  },
+  "dependencies": {
+    "@napi-rs/keyring": "^2.1.1",
+    "smol-toml": "^1.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^7.0.2"
+  }
+}