@irythill/orq 0.1.0 → 0.3.0

package/dist/commands/instructions.js

@@ -15,13 +15,13 @@ 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}
+    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. */

package/dist/commands/lock.js

@@ -7,7 +7,7 @@ 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)
+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`;

package/dist/commands/pick.js

@@ -1,19 +1,21 @@
 // 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.
+// `orq pick fix --same <file>`: the implementer's saved pick, effort one level up (no choice, nothing recorded).
 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 { asArgs, escalate, 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]`;
+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]
+orq pick fix --same <impl pick file>   same agent/model/account as the implementer, effort one level up`;
 // 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) {
@@ -27,6 +29,24 @@ export async function pick(argv) {
         console.error(USAGE);
         return 2;
     }
+    if (role === "fix" && argv[1] === "--same") {
+        const f = argv[2];
+        if (!f || argv.length > 3) {
+            console.error(USAGE);
+            return 2;
+        }
+        if (!existsSync(f)) {
+            console.error(`orq pick: ${m("no such file: ", "arquivo não existe: ")}${f}`);
+            return 2;
+        }
+        const prev = readFileSync(f, "utf8").trim();
+        if (!/(^|\s)-a \S/.test(prev)) {
+            console.error(`orq pick: ${m("not a pick: ", "não é um pick: ")}${f}`);
+            return 2;
+        }
+        console.log(escalate(prev));
+        return 0;
+    }
     let level = "medium", implVendor, implAgent, ws;
     let explain = false, record = true;
     const exclude = new Set();

package/dist/commands/quota.js

@@ -1,9 +1,39 @@
 // orq quota [name...]   quota of each source in [quota] (default: all) — lines "<name> 5h=NN% week=NN% [note]"
+// orq quota --line      one line for a status bar (herdr's tab_bar_right command entry): the board's cache, never
+//                       the network — a stale cache starts the board's background collection, like the board does.
 import { getPath, loadConfig } from "../config.js";
+import { m } from "../i18n.js";
 import { collect } from "../quota.js";
-export const USAGE = "orq quota [name...]                   quota per agent/account ([quota] in the config)";
+import { quota as cached } from "./board.js";
+import { load as loadBlocks } from "./block.js";
+export const USAGE = `orq quota [name...]                   quota per agent/account ([quota] in the config)
+orq quota --line                      one line for a status bar, from the board's cache (e.g. herdr tab_bar_right)`;
+const pct = (p) => (/^\d+%$/.test(p) ? Number(p.slice(0, -1)) : undefined);
+/** "work 64 · home 93! · codex 81 · minimax ?": the tighter of the two windows per source; ! at or over the pick
+ *  limit, ⊘ blocked (orq block), ? no data; sources with no window at all ("-" and "-") are left out. */
+export function quotaLine(lines, limit, blocked, age) {
+    const parts = lines.filter((q) => q.five !== "-" || q.week !== "-").map((q) => {
+        if (blocked.has(q.name))
+            return `${q.name} ⊘`;
+        const ns = [pct(q.five), pct(q.week)].filter((n) => n !== undefined);
+        if (!ns.length)
+            return `${q.name} ?`;
+        const top = Math.max(...ns);
+        return `${q.name} ${top}${top >= limit ? "!" : ""}`;
+    });
+    if (!parts.length)
+        return age === undefined ? m("quota: collecting...", "cota: coletando...") : "";
+    const old = age !== undefined && age > 15 * 60_000 ? ` (${Math.round(age / 60_000)} min)` : "";
+    return parts.join(" · ") + old;
+}
 export async function quota(argv) {
-    const sources = (getPath(loadConfig().cfg, "quota") ?? {});
+    const { cfg } = loadConfig();
+    if (argv[0] === "--line") {
+        const q = cached(Date.now());
+        console.log(quotaLine(q.lines, Number(getPath(cfg, "policy.quota_limit") ?? 90), new Set(Object.keys(loadBlocks())), q.age));
+        return 0;
+    }
+    const sources = (getPath(cfg, "quota") ?? {});
     for (const l of await collect(sources, argv))
         console.log(l);
     return 0;

package/dist/commands/setup.js

@@ -18,7 +18,7 @@ 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)
+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 = {
@@ -139,8 +139,8 @@ function workspace(dir, conductor) {
     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>".
+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;

package/dist/config.js

@@ -27,7 +27,7 @@ export const DEFAULTS = {
     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: "none", antigravity: "builtin", copilot: "builtin" },
+    quota: { claude: "builtin", codex: "builtin", opencode: "builtin", antigravity: "builtin", copilot: "builtin" },
     tracker: { kind: "none" }, // plane | none
     repos: {}, // defined by the workspace
 };

package/dist/pick.js

@@ -111,5 +111,16 @@ export function pick(inp) {
     }).sort((x, y) => y.score - x.score);
     return { mode: "auto", best: cands[0], cands, notes };
 }
+const EFFORTS = ["low", "medium", "high"];
+/** A fix continues the implementer's session: the same runner arguments (agent, model, account) with the effort one
+ *  level up, capped at high. Keeping the model keeps the session's prompt cache; an unknown or absent effort stays. */
+export function escalate(args) {
+    const p = args.trim().split(/\s+/);
+    const i = p.indexOf("-e");
+    const at = i >= 0 ? EFFORTS.indexOf(p[i + 1]) : -1;
+    if (at >= 0)
+        p[i + 1] = EFFORTS[Math.min(at + 1, EFFORTS.length - 1)];
+    return p.join(" ");
+}
 /** The arguments for the agent runner, e.g. "-a codex -m gpt-6-sol -e low -c work". */
 export const asArgs = (c) => `-a ${c.agent}` + (c.model ? ` -m ${c.model}` : "") + (c.effort ? ` -e ${c.effort}` : "") + (c.acct ? ` -c ${c.acct}` : "");

package/dist/process.js

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

package/dist/quota.js

@@ -3,6 +3,8 @@
 //                        codex:  the rate_limits Codex writes into its latest session file
 //                        antigravity: per-model quota from Cloud Code (fetchAvailableModels), with the login agy keeps
 //                                 in the OS keyring (src/keyring.ts: Secret Service, Keychain, Credential Manager)
+//                        opencode: the MiniMax Token Plan (/v1/token_plan/remains) with $MINIMAX_API_KEY or the key
+//                                 OpenCode keeps in its auth.json; $MINIMAX_API_HOST for the China region
 //                        copilot: premium requests left this month (`gh api /copilot_internal/user`; a monthly
 //                                 allowance, shown in the week slot)
 //   false                left out of the list entirely
@@ -117,7 +119,8 @@ function latestCodexSession() {
     walk(root, 0);
     return best?.f;
 }
-/** The last rate_limits in a Codex session (.jsonl): 300-min window = 5h, 10080 = week; a window already reset → 0. */
+/** The last rate_limits in a Codex session (.jsonl): a window up to 6 h = 5h; the longest one over that (10080 = week,
+ *  43200 on the free plan = 30 days) fills the week slot, with `span` (minutes) when it isn't a week; reset → 0. */
 export function codexFromSession(text, nowSec) {
     let last;
     for (const line of text.split("\n")) {
@@ -139,13 +142,11 @@ export function codexFromSession(text, nowSec) {
     if (!last)
         return undefined;
     const ws = [last.primary, last.secondary].filter((w) => !!w);
-    const win = (mins) => {
-        const w = ws.find((x) => x.window_minutes === mins);
-        if (!w)
-            return "-";
-        return (w.resets_at ?? 0) < nowSec ? 0 : Math.floor(w.used_percent ?? 0);
-    };
-    return { five: win(300), week: win(10080) };
+    const pct = (w) => !w ? "-" : (w.resets_at ?? 0) < nowSec ? 0 : Math.floor(w.used_percent ?? 0);
+    const short = ws.find((x) => (x.window_minutes ?? 0) <= 360);
+    const long = ws.filter((x) => (x.window_minutes ?? 0) > 360).sort((a, b) => b.window_minutes - a.window_minutes)[0];
+    const span = long && long.window_minutes !== 10080 ? long.window_minutes : undefined;
+    return { five: pct(short), week: pct(long), ...(span ? { span } : {}) };
 }
 export function codexQuota() {
     const f = latestCodexSession();
@@ -155,7 +156,10 @@ export function codexQuota() {
     if (!q)
         return noData("codex", m("no limit data", "sem dados de limite"));
     const age = Math.round((Date.now() - statSync(f).mtimeMs) / 60_000);
-    return { name: "codex", ...q, note: m(`from the last session, ${age} min ago`, `da última sessão, há ${age} min`) };
+    const { span, ...pcts } = q;
+    const d = span && Math.round(span / 1440);
+    return { name: "codex", ...pcts, note: (d ? m(`${d}-day window in the week slot; `, `janela de ${d} dias no lugar da semana; `) : "")
+            + m(`from the last session, ${age} min ago`, `da última sessão, há ${age} min`) };
 }
 /** Worst usage per window across models: a reset within 6 h belongs to the 5h window, a later one to the week. */
 export function antigravityFromModels(models, now = Date.now()) {
@@ -243,6 +247,58 @@ export function copilotQuota() {
         return noData("copilot", m("collector failed", "coletor falhou"));
     }
 }
+/** Worst usage per window across the plan's models (remaining % → used %); resets from the windows' end times. */
+export function minimaxFromRemains(j) {
+    const ms = j?.model_remains ?? [];
+    if (!ms.length)
+        return undefined;
+    const worst = (pct, end) => {
+        let w = { pct: "-" };
+        for (const x of ms) {
+            if (typeof x[pct] !== "number")
+                continue;
+            const used = 100 - x[pct];
+            if (w.pct === "-" || used > w.pct)
+                w = { pct: used, ...(typeof x[end] === "number" ? { resetsAt: new Date(x[end]).toISOString() } : {}) };
+        }
+        return w;
+    };
+    return { five: worst("current_interval_remaining_percent", "end_time"),
+        week: worst("current_weekly_remaining_percent", "weekly_end_time") };
+}
+function minimaxKey() {
+    if (process.env.MINIMAX_API_KEY)
+        return process.env.MINIMAX_API_KEY;
+    const data = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+    try {
+        return JSON.parse(readFileSync(join(data, "opencode", "auth.json"), "utf8")).minimax?.key;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function minimaxQuota(name) {
+    const key = minimaxKey();
+    // OpenCode may run another provider: without a MiniMax key there is nothing to limit.
+    if (!key)
+        return { name, five: "-", week: "-", note: m("no MiniMax key", "sem chave da MiniMax") };
+    try {
+        const host = process.env.MINIMAX_API_HOST ?? "api.minimax.io";
+        const r = await fetch(`https://${host}/v1/token_plan/remains`, {
+            headers: { Authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(15_000)
+        });
+        if (!r.ok)
+            return fromCache(name, `HTTP ${r.status}`);
+        const j = await r.json();
+        if (j.base_resp?.status_code)
+            return fromCache(name, `MiniMax ${j.base_resp.status_code}: ${j.base_resp.status_msg ?? ""}`.trim());
+        const q = minimaxFromRemains(j);
+        return q ? remember(name, q.five, q.week) : noData(name, m("no plan data", "sem dados do plano"));
+    }
+    catch (e) {
+        return fromCache(name, m("collector failed", "coletor falhou") + `: ${e.message}`);
+    }
+}
 // --- command ----------------------------------------------------------------------------------------------------------
 function commandQuota(name, cmd) {
     const r = spawnSync(cmd, { shell: true, encoding: "utf8", timeout: 30_000 });
@@ -270,6 +326,8 @@ export async function collect(sources, want = []) {
             return wanted(name) ? [format(await antigravityQuota())] : [];
         if (name === "copilot")
             return wanted(name) ? [format(copilotQuota())] : [];
+        if (name === "opencode" || name === "minimax")
+            return wanted(name) ? [format(await minimaxQuota(name))] : [];
         return wanted(name) ? [format(noData(name, m("no builtin collector: use \"none\" or a command", "sem coletor embutido: use \"none\" ou um comando")))] : [];
     });
     return (await Promise.all(jobs)).flat();

package/dist/terminal.js

@@ -3,6 +3,7 @@
 //   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.
+// The agent's own screen (-T) needs herdr or tmux; follow-ups are typed into it while it is open.
 import { spawn, spawnSync } from "node:child_process";
 import { closeSync, mkdirSync, openSync } from "node:fs";
 import { join } from "node:path";
@@ -69,6 +70,31 @@ export function launch(host, l) {
     closeSync(fd);
     return `pid:${c.pid}`;
 }
+/** Is the screen `launch` returned still open? (herdr pane or tmux pane; a background pid has no screen) */
+export function screenOpen(where) {
+    if (where.startsWith("tmux:"))
+        return spawnSync("tmux", ["display-message", "-p", "-t", where.slice(5), "#{pane_id}"], { stdio: "ignore" }).status === 0;
+    if (!where || where.startsWith("pid:"))
+        return false;
+    return spawnSync("herdr", ["pane", "get", where], { stdio: "ignore" }).status === 0;
+}
+/** Type `text` into an open screen and submit it (a follow-up to an agent's own TUI). */
+export function typeInto(where, text) {
+    if (where.startsWith("tmux:")) {
+        // A bracketed paste keeps a multi-line prompt as one message; then Enter sends it.
+        const t = where.slice(5), run = (a, input) => {
+            const r = spawnSync("tmux", a, { input, encoding: "utf8" });
+            if (r.status !== 0)
+                throw new Error(`tmux ${a[0]}: ${(r.stderr || "").trim()}`);
+        };
+        run(["load-buffer", "-b", "orq-prompt", "-"], text);
+        run(["paste-buffer", "-p", "-d", "-b", "orq-prompt", "-t", t]);
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 300); // let the TUI take the paste before Enter
+        run(["send-keys", "-t", t, "Enter"]);
+        return;
+    }
+    herdr(["agent", "prompt", where, text]);
+}
 /** 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;

package/dist/testrun.js

@@ -2,7 +2,7 @@
 // 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 { spawn, 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";
@@ -196,8 +196,12 @@ export async function inJob(j, label, slots, body, done) {
     }
     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" });
+/** The conductor is a herdr pane: type the line into it (herdr-notify waits for it to leave a dialog). In the
+ * background when the caller must not wait for that (an agent's end-of-turn hook holds its screen meanwhile). */
+export function notify(pane, line, background = false) {
+    const local = join(dirname(CLI), "..", "setup", "herdr-notify"), cmd = existsSync(local) ? local : "herdr-notify";
+    if (background)
+        spawn(cmd, [pane, line], { detached: true, stdio: "ignore" }).unref();
+    else
+        spawnSync(cmd, [pane, line], { stdio: "inherit" });
 }

package/package.json

@@ -1,27 +1,48 @@
-{
-  "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"
-  }
-}
+{
+  "name": "@irythill/orq",
+  "version": "0.3.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"
+  }
+}