@irythill/orq 0.7.0 → 0.9.0

package/dist/commands/instructions.js

@@ -2,23 +2,28 @@
 //   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]
+//   orq instructions claude|agents [-w <workspace>] [--conductor <agent>] [--print]
+//   orq instructions strategy [-w <workspace>] [--conductor <agent>] [--json]   which wait/resume strategy applies (#119)
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { writeAtomic } from "../fsutil.js";
+import { getPath, loadConfig } from "../config.js";
+import { capabilities, loopTimeout, strategy, strategyText } from "../harness.js";
 import { m } from "../i18n.js";
-export const USAGE = "orq instructions claude|agents [-w <workspace>] [--print]   write the /issue playbook for the conductor";
+export const USAGE = `orq instructions claude|agents [-w <workspace>] [--conductor <agent>] [--print]   write the /issue playbook for the conductor
+orq instructions strategy [-w <workspace>] [--conductor <agent>] [--json]   show the conductor's wait/resume strategy`;
 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) {
+/** The playbook for harnesses without skills: no frontmatter, a trigger line, and the conductor's waiting strategy. */
+export function agentsBlock(skill, waiting = strategyText("unknown", capabilities("unknown"))) {
     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.
+Read \`ORQ.md\` for the workspace map and orchestration settings (legacy workspaces: \`CLAUDE.md\`).
+
+${waiting}
 
 ${body}
 ${END}
@@ -31,15 +36,30 @@ export function mergeBlock(cur, block) {
         return cur.slice(0, a) + block.trimEnd() + cur.slice(b + END.length);
     return cur ? `${cur.trimEnd()}\n\n${block}` : block;
 }
+/** Conductor agent: --conductor, else roles.conductor.agent, else claude. */
+function conductorOf(cfg, flag) {
+    return flag || String(getPath(cfg, "roles.conductor.agent") ?? "claude");
+}
+/** AGENTS.md is read by non-Claude harnesses: a Claude conductor's wake-up must not leak into it unless asked for. */
+function agentsWaiting(agent, caps, cfg, flag) {
+    if (agent === "claude" && !flag)
+        return strategyText("AGENTS.md harness", capabilities("unknown", cfg, process.env));
+    return strategyText(agent, caps);
+}
 export async function instructions(argv) {
-    let ws = process.cwd(), print = false, fmt;
+    let ws = process.cwd(), print = false, json = false, fmt, who;
     for (let i = 0; i < argv.length; i++) {
-        if (argv[i] === "-w")
+        const a = argv[i];
+        if (a === "-w")
             ws = resolve(argv[++i]);
-        else if (argv[i] === "--print")
+        else if (a === "--print")
             print = true;
-        else if (argv[i] === "claude" || argv[i] === "agents")
-            fmt = argv[i];
+        else if (a === "--json")
+            json = true;
+        else if (a === "--conductor" && argv[i + 1])
+            who = argv[++i];
+        else if (a === "claude" || a === "agents" || a === "strategy")
+            fmt = a;
         else {
             console.error(USAGE);
             return 2;
@@ -49,13 +69,35 @@ export async function instructions(argv) {
         console.error(USAGE);
         return 2;
     }
+    let cfg = {};
+    try {
+        cfg = loadConfig(ws).cfg;
+    }
+    catch { /* no config: built-in defaults */ }
+    const agent = conductorOf(cfg, who), caps = capabilities(agent, cfg, process.env), s = strategy(caps);
+    if (fmt === "strategy") {
+        const fallback = s === "background-task" ? "foreground-loop" : "none";
+        if (json) {
+            console.log(JSON.stringify({ conductor: agent, strategy: s, fallback, waitTimeout: loopTimeout(caps), capabilities: caps }));
+            return 0;
+        }
+        console.log(`conductor ${agent}: ${s}`);
+        console.log(`  background=${caps.background} resume_on_completion=${caps.resumeOnCompletion} foreground_wait=${caps.foregroundWait} prompt_delivery=${caps.promptDelivery} foreground_timeout=${caps.foregroundTimeout}s`);
+        console.log(s === "background-task"
+            ? m("  ends its turn after dispatch; orq wait in the background wakes it (fallback: foreground loop)", "  encerra o turno após o dispatch; o orq wait em background o acorda (fallback: loop em foreground)")
+            : s === "manual"
+                ? m("  cannot continue by itself: reports pending prefixes and waits for the user's message", "  não continua sozinho: informa os prefixos pendentes e espera a mensagem do usuário")
+                : m(`  stays active: orq wait --any --timeout ${loopTimeout(caps)} in a loop; it does NOT resume by itself after ending a turn`, `  fica ativo: orq wait --any --timeout ${loopTimeout(caps)} em loop; NÃO retoma sozinho depois de encerrar o turno`));
+        console.log(m(`  override: agents.${agent}.conductor.capabilities`, `  ajuste: agents.${agent}.conductor.capabilities`));
+        return 0;
+    }
     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));
+    const text = fmt === "claude" ? skill : mergeBlock(existsSync(file) ? readFileSync(file, "utf8") : "", agentsBlock(skill, agentsWaiting(agent, caps, cfg, who)));
     if (print) {
         process.stdout.write(text);
         return 0;

package/dist/commands/pick.js

@@ -75,6 +75,8 @@ export async function pick(argv) {
         }
     }
     const { cfg } = loadConfig(ws);
+    if (process.env.ORQ_CONDUCTOR_AGENT)
+        cfg._conductorAgent = process.env.ORQ_CONDUCTOR_AGENT;
     const agents = (cfg.agents ?? {});
     if (implAgent && !implVendor)
         implVendor = vendorOf(implAgent, agents[implAgent]);

package/dist/commands/setup.js

@@ -4,7 +4,7 @@
 //   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
+//   orq setup --workspace <dir> [--conductor <agent>]   .orquestra, ORQ.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";
@@ -18,6 +18,7 @@ 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 { setTomlString } from "../toml-set.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>]`;
@@ -125,18 +126,30 @@ function workspace(dir, conductor) {
     let c = conductor;
     if (!c) {
         try {
-            c = getPath(loadConfig().cfg, "roles.conductor.agent");
+            c = getPath(loadConfig(expand(dir)).cfg, "roles.conductor.agent");
         }
         catch { /* none */ }
     }
-    c ??= onPath("claude") ? "claude" : "agents";
+    c ??= detect()[0] ?? "claude";
     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"))
+    for (const l of prepareWorkspace(d, c === "claude" ? "claude" : "agents", undefined, c))
         console.log(l);
+    if (c !== "agents") {
+        const toml = join(d, ".orq", "workspace.toml"), json = join(d, ".orq", "workspace.json");
+        const file = existsSync(toml) || !existsSync(json) ? toml : json;
+        const text = existsSync(file) ? readFileSync(file, "utf8") : "";
+        if (file.endsWith(".json")) {
+            const cfg = text ? JSON.parse(text) : {};
+            cfg.roles = { ...cfg.roles, conductor: { ...cfg.roles?.conductor, agent: c } };
+            writeAtomic(file, JSON.stringify(cfg, null, 2) + "\n");
+        }
+        else
+            writeAtomic(file, setTomlString(text, "roles.conductor", "agent", c));
+    }
 }
-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 ORQ.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 ORQ.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/harness.js

@@ -0,0 +1,69 @@
+// Conductor harness capabilities and the wait/resume strategy they allow (#119).
+// A harness is where the conductor talks to the user (Claude Code, Codex, OpenCode...). Being able to start a process in
+// the background is not the same as being woken up when it ends: only `resume_on_completion` lets the conductor end its
+// turn after dispatching. Everything else keeps an active, bounded `orq wait --timeout` loop.
+// Config (any field optional, overrides the built-in): agents.<agent>.conductor.capabilities =
+//   { background, resume_on_completion, foreground_wait, foreground_timeout, prompt_delivery }
+import { getPath } from "./config.js";
+const LOOP = { background: false, resumeOnCompletion: false, foregroundWait: true, foregroundTimeout: 240, promptDelivery: false };
+/** Built-in knowledge. Unknown harnesses get the conservative loop: never promise a wake-up nobody verified. */
+export const BUILTIN_CAPABILITIES = {
+    claude: { background: true, resumeOnCompletion: true, foregroundWait: true, foregroundTimeout: 540, promptDelivery: false },
+    codex: { ...LOOP },
+    opencode: { ...LOOP },
+    copilot: { ...LOOP },
+    antigravity: { ...LOOP },
+};
+const bool = (v, d) => typeof v === "boolean" ? v : d;
+/** Capabilities of `agent` as conductor: built-in, then agents.<agent>.conductor.capabilities, then the environment. */
+export function capabilities(agent, cfg = {}, env = {}) {
+    const base = BUILTIN_CAPABILITIES[agent] ?? LOOP;
+    const u = (getPath(cfg, `agents.${agent}.conductor.capabilities`) ?? {});
+    const t = Number(u.foreground_timeout);
+    return {
+        background: bool(u.background, base.background),
+        resumeOnCompletion: bool(u.resume_on_completion, base.resumeOnCompletion),
+        foregroundWait: bool(u.foreground_wait, base.foregroundWait),
+        foregroundTimeout: Number.isFinite(t) && t > 0 ? Math.floor(t) : base.foregroundTimeout,
+        promptDelivery: bool(u.prompt_delivery, base.promptDelivery || env.HERDR_ENV === "1"),
+    };
+}
+/** Ending the turn after dispatch is only allowed with a channel that wakes the conductor. */
+export function strategy(c) {
+    if (c.background && c.resumeOnCompletion)
+        return "background-task";
+    return c.foregroundWait ? "foreground-loop" : "manual";
+}
+/** Timeout for `orq wait` inside one foreground call: leave a margin under the harness limit. */
+export const loopTimeout = (c) => Math.max(30, c.foregroundTimeout - 30);
+/** The "Waiting strategy" section embedded in the generated conductor instructions. */
+export function strategyText(agent, c) {
+    const herdr = "In herdr (`HERDR_ENV=1`) the done line is typed into your pane by herdr: that is your wake-up; dispatch, report in one line and end your turn.";
+    if (strategy(c) === "background-task")
+        return `## Waiting strategy: background task (${agent})
+${herdr}
+Elsewhere: after dispatching, run \`orq wait --any <prefix>...\` as a **background task** of your harness and end your
+turn. Its exit starts your next turn; its output is the done line. Wait again for the prefixes still pending.`;
+    if (strategy(c) === "manual")
+        return `## Waiting strategy: manual (${agent})
+${herdr}
+Elsewhere your harness can neither wake you when a child ends nor keep a foreground wait open, so you cannot continue
+by yourself. After dispatching, tell the user plainly: which prefixes are pending, that you will **not** continue on
+your own, and that they resume you by messaging you (e.g. "status") once \`orq wait --any <pending prefixes>\` has
+returned. On that message, check \`<prefix>.done\` and act; never dispatch a child again just because it is still running.`;
+    const t = loopTimeout(c);
+    return `## Waiting strategy: foreground loop (${agent})
+${herdr}
+Elsewhere your harness does **not** resume you when a background process ends, so never end your turn expecting a
+wake-up. After dispatching, report in one line, then loop:
+1. Run \`orq wait --any --timeout ${t} <every pending prefix>\` in the **foreground** (if your shell tool has a timeout
+   setting, give it more than ${t} s; if the tool still kills the command, use a shorter \`--timeout\`). If the tool
+   returns a running session/process id instead of an exit code, keep polling **that same** session until it exits;
+   don't start another \`orq wait\` while it runs.
+2. Exit 0/1 = a done line: act on it (verify, review, fix) and keep looping over what is still pending.
+3. Exit 124 = nothing finished yet: give the user a one-line status and go back to 1. A timeout is not a failure:
+   never dispatch the same child again because of it (\`<prefix>.done\` missing = still running).
+The loop is the one allowed blocking wait. If the user writes in between, answer, then resume the loop. If you must end
+your turn with children still pending, say plainly that you will **not** continue by yourself and that the user has to
+message you (e.g. "status") to resume.`;
+}

package/dist/install.js

@@ -2,7 +2,7 @@
 //   skills      orq's skills (skills/*/SKILL.md, shipped in the package) linked into ~/.claude/skills and each Claude
 //               account's skills folder — a junction on Windows (no admin rights), a copy if linking fails. A real
 //               folder, or a link to another live copy (a clone of the repo), is never touched.
-//   workspace   <folder>/.orquestra, .worktrees, CLAUDE.md from the template (only if missing) and the /issue playbook
+//   workspace   <folder>/.orquestra, .worktrees, ORQ.md map, pointers and the /issue playbook
 //               in the conductor's format (orq instructions)
 //   environment what orq found: git, terminal host, memory cap, keyring, the shell's completion line
 import { spawnSync } from "node:child_process";
@@ -11,7 +11,9 @@ import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { claudeAccounts } from "./accounts.js";
+import { loadConfig } from "./config.js";
 import { writeAtomic } from "./fsutil.js";
+import { capabilities, strategyText } from "./harness.js";
 import { m } from "./i18n.js";
 import { backend } from "./keyring.js";
 import { hasKernelCap } from "./process.js";
@@ -77,25 +79,39 @@ export function installSkills(roots = skillRoots()) {
     return out;
 }
 /** Prepare a conductor's workspace folder; `fmt` = claude (SKILL.md) | agents (AGENTS.md). */
-export function prepareWorkspace(dir, fmt, name = basename(resolve(dir))) {
+export function prepareWorkspace(dir, fmt, name = basename(resolve(dir)), conductor = fmt === "claude" ? "claude" : "unknown") {
     const ws = resolve(dir), out = [];
     for (const d of [".orquestra", ".worktrees"])
         mkdirSync(join(ws, d), { recursive: true });
-    const map = join(ws, "CLAUDE.md");
+    const map = join(ws, "ORQ.md"), legacy = join(ws, "CLAUDE.md");
     if (!existsSync(map)) {
-        const t = readFileSync(join(PKG, "templates", "workspace.CLAUDE.md"), "utf8");
-        writeAtomic(map, t.split("{{WORKSPACE}}").join(ws).split("{{NAME}}").join(name));
+        const t = existsSync(legacy) ? readFileSync(legacy, "utf8") :
+            readFileSync(join(PKG, "templates", "workspace.CLAUDE.md"), "utf8").split("{{WORKSPACE}}").join(ws).split("{{NAME}}").join(name);
+        writeAtomic(map, t);
         out.push(m(`  created ${map} — fill in repos, group, base branch, Plane and issue standard`, `  criado ${map} — preencha repos, grupo, branch base, Plane e padrão de issue`));
     }
     else
         out.push(m(`  ok      ${map} (kept)`, `  ok      ${map} (mantido)`));
+    if (!existsSync(legacy))
+        writeAtomic(legacy, "# orq workspace\n\nRead `ORQ.md` for the workspace map and orchestration settings.\n");
     // The conductor's instructions (what `orq conductor` looks for): regenerated on every run.
     const ci = join(ws, ".orquestra-conductor.md");
     const t = readFileSync(join(PKG, "templates", "conductor.instructions.md"), "utf8");
-    writeAtomic(ci, t.split("{{WORKSPACE}}").join(ws).split("{{NAME}}").join(name));
+    let cfg = {};
+    try {
+        cfg = loadConfig(ws).cfg;
+    }
+    catch { /* no config yet */ }
+    const waiting = strategyText(conductor, capabilities(conductor, cfg, process.env));
+    writeAtomic(ci, t.split("{{WORKSPACE}}").join(ws).split("{{NAME}}").join(name).split("{{WAIT_STRATEGY}}").join(waiting));
     out.push(`  ${m("wrote", "escrevi")}   ${ci}`);
-    const r = spawnSync(process.execPath, [join(PKG, "dist", "cli.js"), "instructions", fmt, "-w", ws], { encoding: "utf8" });
-    out.push(`  ${(r.stdout || r.stderr).trim()}`);
+    for (const format of fmt === "claude" ? ["agents", "claude"] : ["agents"]) {
+        const r = spawnSync(process.execPath, [join(PKG, "dist", "cli.js"), "instructions", format, "-w", ws,
+            ...(format === "agents" && conductor !== "claude" && conductor !== "unknown" ? ["--conductor", conductor] : [])], { encoding: "utf8" });
+        if (r.status !== 0)
+            throw new Error(r.stderr || `orq instructions ${format} failed`);
+        out.push(`  ${r.stdout.trim()}`);
+    }
     return out;
 }
 const SHELLS = ["bash", "zsh", "fish", "powershell"];

package/dist/pick.js

@@ -1,7 +1,7 @@
 // Picks agent, model, effort and account for a role (port of orq-pick, plus fixed roles).
 //   fixed role: the first agent of [agent, ...fallback] that passes the filters wins — no scoring, never swapped
 //               for an agent the user didn't list.
-//   auto role:  every pool agent that passes is scored:
+//   auto role:  every (agent, model) pair that passes is scored (a level may list several models):
 //     quality * delivery + tokens * economy + speed * quickness − rotation * (picks in the last `window`)
 //     − reserve (agents with reserve = true) + explore (fewer than `min_samples` runs, fading with n, none after
 //     `explore_streak` picks in a row). Each axis is (prior·k + observed·n)/(k + n), k = min_samples.
@@ -73,17 +73,25 @@ export function limitsFor(pol, level) {
     const five = { ...FIVE, ...(pol.quota_5h ?? {}) };
     return [Math.min(Number(five[level] ?? five.medium), Number(pol.quota_limit ?? 90)), Number(pol.quota_week ?? 95)];
 }
-export function modelFor(a, role, level) {
-    if (a.models === undefined)
-        return ["", undefined]; // no models configured: the CLI's default
-    const models = a.models;
+/** The agent's models section for a role, with the same fallbacks as the roles (fix → impl, watchdog → opinion → review). */
+function roleModels(a, role) {
+    const models = (a.models ?? {});
     const lr = legacyRole(role);
-    const ms = models[lr] ?? (lr === "fix" ? models.impl : lr === "watchdog" ? models.opinion ?? models.review : undefined) ?? {};
-    const spec = ms[level] ?? ms.default ?? ms.medium ?? ms.simple;
-    if (!spec)
-        return undefined;
-    const [model, effort] = spec.split("@");
-    return [model, effort || undefined];
+    return models[lr] ?? (lr === "fix" ? models.impl : lr === "watchdog" ? models.opinion ?? models.review : undefined) ?? {};
+}
+const specList = (spec) => (Array.isArray(spec) ? spec : spec ? [spec] : []).map(String).filter(Boolean)
+    .map((x) => { const [model, effort] = x.split("@"); return [model, effort || undefined]; });
+/** Every candidate model for the role/level, in the order configured; undefined when none is. */
+export function modelsFor(a, role, level) {
+    if (a.models === undefined)
+        return [["", undefined]]; // no models configured: the CLI's default
+    const ms = roleModels(a, role);
+    const list = specList(ms[level] ?? ms.default ?? ms.medium ?? ms.simple);
+    return list.length ? list : undefined;
+}
+/** The first candidate model for the role/level. */
+export function modelFor(a, role, level) {
+    return modelsFor(a, role, level)?.[0];
 }
 // --- per-model quota ---------------------------------------------------------------------------------------------------
 // A collector may add lines "<account>/<model> 5h=.. week=.." (antigravity: one bucket per model group). The model a pick is about
@@ -98,20 +106,19 @@ export function modelKey(model, keys) {
 }
 /** The models of an agent's role section lighter than `level`, the closest first, without repeats of `tried`. */
 export function lighterModels(a, role, level, tried) {
-    const models = a.models;
-    if (!models)
+    if (!a.models)
         return [];
-    const lr = legacyRole(role);
-    const ms = models[lr] ?? (lr === "fix" ? models.impl : lr === "watchdog" ? models.opinion ?? models.review : undefined) ?? {};
+    const ms = roleModels(a, role);
     const rank = LEVEL_RANK[level] ?? 1, seen = new Set(tried);
     const out = [];
     for (const [, spec] of Object.entries(ms).filter(([lv]) => (LEVEL_RANK[lv] ?? 1) < rank)
         .sort((x, y) => (LEVEL_RANK[y[0]] ?? 1) - (LEVEL_RANK[x[0]] ?? 1))) {
-        const [model, effort] = spec.split("@");
-        if (seen.has(model))
-            continue;
-        seen.add(model);
-        out.push([model, effort || undefined]);
+        for (const [model, effort] of specList(spec)) {
+            if (seen.has(model))
+                continue;
+            seen.add(model);
+            out.push([model, effort]);
+        }
     }
     return out;
 }
@@ -138,6 +145,8 @@ function takesPrompt(cfg, name) {
 export function pick(inp) {
     const { cfg, role, level } = inp;
     const agents = (cfg.agents ?? {});
+    const conductor = String(cfg._conductorAgent ?? cfg.roles?.conductor?.agent ?? "");
+    const conductorHeadroom = Number(cfg.conductor?.headroom ?? 0);
     const pol = (cfg.policy ?? {});
     const [base5, baseWeek] = limitsFor(pol, level);
     const w = weights(cfg);
@@ -187,14 +196,14 @@ export function pick(inp) {
             out(name, m("ignores prompts (a review tool)", "ignora prompts (ferramenta de revisão)"));
             continue;
         }
-        const mf = modelFor(a, role, level);
-        if (!mf) {
+        const mfs = modelsFor(a, role, level);
+        if (!mfs) {
             out(name, m(`no model for ${role}/${level}`, `sem modelo para ${role}/${level}`));
             continue;
         }
         // Quota: an agent with several accounts (claude) prefers one not projecting past the limit, then the least used.
         const qn = a.quota ?? [];
-        const headroom = Math.max(0, Number(a.headroom ?? 0));
+        const headroom = Math.max(0, Number(a.headroom ?? (name === conductor ? conductorHeadroom : 0)));
         const limit5 = base5 - headroom, limitWeek = baseWeek - headroom;
         const accs = qn.filter((n) => !inp.blocks.has(n)).map((n) => [n, n in inp.quota ? inp.quota[n] : -1]);
         if (qn.length && !accs.length) {
@@ -247,8 +256,8 @@ export function pick(inp) {
             return { pace: paces.length ? Math.max(...paces) : undefined,
                 hot: penalty > 0 && ((p5 !== undefined && p5 > limit5) || (pw !== undefined && pw > limitWeek)) };
         };
-        // The chosen account's per-model buckets: an exhausted model gives way to a lighter one of the same agent.
-        let mfx = mf;
+        // The chosen account's per-model buckets: an exhausted candidate drops out; with none left, a lighter model of the agent.
+        let mfx = mfs;
         const acc0 = usable.length ? [...usable].sort((x, y) => x[1] - y[1])[0][0] : undefined;
         const mkeys = acc0 ? Object.keys(inp.windows ?? {}).filter((k) => k.startsWith(`${acc0}/`)).map((k) => k.slice(acc0.length + 1)) : [];
         if (acc0 && mkeys.length) {
@@ -263,23 +272,25 @@ export function pick(inp) {
                 return `${model} ${five ? `5h ${q.five}%` : `${m("week", "semana")} ${q.week}%`}`
                     + (at.length ? ` (${m("back", "volta")} ${humanReset(Math.max(...at))})` : "");
             };
-            const tried = [], skipped = [];
-            let found;
-            for (const cand of [mf, ...lighterModels(a, role, level, [mf[0]])]) {
-                const why = over(cand[0]);
-                if (!why) {
-                    found = cand;
-                    break;
+            const skipped = [];
+            let found = mfs.filter((c) => { const why = over(c[0]); if (why)
+                skipped.push(why); return !why; });
+            if (!found.length) {
+                for (const cand of lighterModels(a, role, level, mfs.map((c) => c[0]))) {
+                    const why = over(cand[0]);
+                    if (!why) {
+                        found = [cand];
+                        break;
+                    }
+                    skipped.push(why);
                 }
-                tried.push(cand[0]);
-                skipped.push(why);
             }
-            if (!found) {
+            if (!found.length) {
                 out(name, `${m("every model over its quota", "todo modelo acima da cota")}: ${skipped.join(", ")}`);
                 continue;
             }
             if (skipped.length)
-                out(name, `${m("quota exhausted", "cota esgotada")}: ${skipped.join(", ")}; ${m("using", "usando")} ${found[0]}`);
+                out(name, `${m("quota exhausted", "cota esgotada")}: ${skipped.join(", ")}; ${m("using", "usando")} ${found.map((c) => c[0]).join(", ")}`);
             mfx = found;
         }
         const ranked = usable.map(([n, v]) => ({ n, v: v, ...paceOf(n) }))
@@ -287,9 +298,12 @@ export function pick(inp) {
         const chosen = ranked[0];
         const acct = qn.length > 1 ? chosen?.n : undefined;
         const statRole = role === "fix" || role === "worker" ? "impl" : role;
-        const stOf = (sr) => inp.stats.find((r) => r.role === sr && r.agent === name && r.model === (mfx[0].split("/").pop() || "default"));
-        const st = stOf(statRole) ?? (role === "watchdog" ? stOf("review") : undefined); // no watchdog runs yet: its review record
-        pass.push({ agent: name, model: mfx[0], effort: mfx[1], acct, a, st, pace: chosen?.pace, hot: Boolean(chosen?.hot) });
+        // One candidate per (agent, model) pair, each scored on its own stats row; a fixed role takes the first model.
+        for (const [model, effort] of res.mode === "fixed" ? mfx.slice(0, 1) : mfx) {
+            const stOf = (sr) => inp.stats.find((r) => r.role === sr && r.agent === name && r.model === (model.split("/").pop() || "default"));
+            const st = stOf(statRole) ?? (role === "watchdog" ? stOf("review") : undefined); // no watchdog runs yet: its review record
+            pass.push({ agent: name, model, effort, acct, a, st, pace: chosen?.pace, hot: Boolean(chosen?.hot) });
+        }
         if (res.mode === "fixed")
             break; // the first that passes wins
     }
@@ -317,16 +331,17 @@ export function pick(inp) {
         return { v, txt: `${label}=${v.toFixed(2)}` + (obs === undefined ? "" : `(${prior.toFixed(2)}→${obs.toFixed(2)})`) };
     };
     const cands = pass.map((c) => {
-        const prior = Number(c.a.prior ?? 0.6), n = c.st?.n ?? 0, reserve = Boolean(c.a.reserve);
+        const prior = Number(c.a.prior ?? 0.6), n = c.st?.n ?? 0, reserve = Boolean(c.a.reserve ?? c.agent === conductor);
         const appr = role === "impl" && c.st?.approved != null && c.st.n_appr >= 3;
         const deliv = appr ? c.st.approved / 100 : c.st ? c.st.ok / 100 : undefined;
         const d = axis(m("delivery", "entrega"), prior, deliv, appr ? c.st.n_appr : n);
         const t = axis(m("economy", "economia"), prior, c.st?.new && refTok ? Math.min(1, refTok / c.st.new) : undefined, n);
         const s = axis(m("speed", "rapidez"), prior, c.st?.min && refMin ? Math.min(1, refMin / Math.max(c.st.min, 0.1)) : undefined, n);
         const used = inp.recent.filter((p) => p.agent === c.agent).length;
-        // Exploration fades as samples come in and stops after explore_streak picks of the agent in a row.
+        // Exploration fades as samples come in and stops after explore_streak picks of the pair in a row (rotation stays per agent).
+        const same = (p) => p.agent === c.agent && (p.model === undefined || p.model === c.model);
         let streak = 0;
-        for (let i = inp.recent.length - 1; i >= 0 && inp.recent[i].agent === c.agent; i--)
+        for (let i = inp.recent.length - 1; i >= 0 && same(inp.recent[i]); i--)
             streak++;
         const capped = few(c.st) && streak >= w.explore_streak;
         const explore = few(c.st) && !capped ? w.explore * (k - n) / k : 0;

package/dist/suggest.js

@@ -98,7 +98,7 @@ export function toToml(p) {
         if (a.quota)
             out.push(`quota  = ${list(a.quota)}`);
         if (a.reserve)
-            out.push("reserve = true");
+            out.push("# reserve follows roles.conductor.agent (or the running conductor)");
         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)) {

package/dist/testrun.js

@@ -12,6 +12,7 @@ import { acquire, release } from "./lock.js";
 import { handoffFile, notify } from "./notice.js";
 import { killTree, parseSize, runCapped } from "./process.js";
 import { closeOwnTab, detectHost, launch } from "./terminal.js";
+import { stopWorktreeProcesses } from "./worktree-processes.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 });
@@ -109,6 +110,7 @@ export function linkModules(from, to) {
  * (and must never walk into the main clone's node_modules through it).
  */
 export function dropWorktree(repo, dir) {
+    stopWorktreeProcesses(dir);
     const nm = join(dir, "node_modules");
     try {
         if (lstatSync(nm).isSymbolicLink() || process.platform === "win32")

package/dist/worktree-processes.js

@@ -0,0 +1,102 @@
+// Stop processes whose current working directory is inside a worktree before git removes its files.
+import { readFileSync, readdirSync, readlinkSync, realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+function inside(dir, path) {
+    const rel = relative(dir, path);
+    return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function stat(pid) {
+    try {
+        return readFileSync(`/proc/${pid}/stat`, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** orq itself and every ancestor (the shell or tmux pane that launched it), which must never be stopped. */
+function ownChain() {
+    const chain = new Set();
+    for (let pid = process.pid; pid > 1 && !chain.has(pid);) {
+        chain.add(pid);
+        const ppid = Number(/\) \S+ (\d+)/.exec(stat(pid) ?? "")?.[1]);
+        if (!ppid)
+            break;
+        pid = ppid;
+    }
+    return chain;
+}
+/** Processes whose cwd is under `dir`, excluding orq and its ancestors; other platforms skip this check. */
+export function worktreeProcesses(dir) {
+    if (process.platform !== "linux")
+        return [];
+    let root;
+    try {
+        root = realpathSync(dir);
+    }
+    catch {
+        root = resolve(dir);
+    }
+    let entries;
+    try {
+        entries = readdirSync("/proc");
+    }
+    catch {
+        return [];
+    }
+    const skip = ownChain(), pids = [];
+    for (const entry of entries) {
+        if (!/^\d+$/.test(entry))
+            continue;
+        const pid = Number(entry);
+        if (skip.has(pid))
+            continue;
+        try {
+            if (inside(root, resolve(readlinkSync(`/proc/${entry}/cwd`))))
+                pids.push(pid);
+        }
+        catch { /* process exited or inaccessible */ }
+    }
+    return pids;
+}
+/** `pid (name)` for output, so the user sees what is (or would be) stopped. */
+export function describe(pid) {
+    try {
+        return `${pid} (${readFileSync(`/proc/${pid}/comm`, "utf8").trim()})`;
+    }
+    catch {
+        return String(pid);
+    }
+}
+/** SIGTERM matching processes, wait up to five seconds, then SIGKILL survivors. Returns `describe`d entries. */
+export function stopWorktreeProcesses(dir) {
+    const pids = worktreeProcesses(dir), names = pids.map(describe);
+    for (const pid of pids)
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch { /* already exited */ }
+    const deadline = Date.now() + 5_000;
+    while (Date.now() < deadline && pids.some(alive))
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+    for (const pid of pids)
+        if (alive(pid))
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch { /* already exited */ }
+    return names;
+}
+function alive(pid) {
+    if (process.platform === "linux") {
+        const s = stat(pid);
+        if (s === undefined || /^\d+ \(.*\) Z /.test(s))
+            return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irythill/orq",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Orchestrate coding agents (Claude Code, Codex, OpenCode, Antigravity, Copilot) from one conductor.",
   "license": "MIT",
   "type": "module",