@irythill/orq 0.8.0 → 0.9.0

package/README.md

@@ -4,7 +4,7 @@
 
 # orq — orchestrating coding agents
 
-You describe the work in a Plane issue. A **conductor** (Claude, ideally Opus) reads it, picks the right agent for
+You describe the work in a Plane issue. A **conductor** (any agent that can run commands) reads it, picks the right agent for
 each step, dispatches the **implementer**, the **tests** and a **cross-vendor review** (each in its own tab or window
 in [herdr](https://herdr.dev) or tmux, or in the background), and hands the issue back *In Review* with a summary in
 Plane. Merge, PR and deploy stay with you.
@@ -20,7 +20,7 @@ that lives in your config.
 ## How it works
 
 ```
-You ── "/issue DEMO-123" ──► conductor (Claude, in any terminal)
+You ── "/issue DEMO-123" ──► conductor (any agent CLI, in any terminal)
                                 │  orq pick impl ──► which agent/model implements (config + history + quota)
                                 ├─► implementer   orq agent  own tab/window or background · worktree from origin/<base> · memory cap
                                 ├─► tests         orq verify  only the diff's tests · queue of one suite at a time
@@ -47,9 +47,9 @@ You ── "/issue DEMO-123" ──► conductor (Claude, in any terminal)
 
 | Agent | CLI | Possible roles | Notes |
 |---|---|---|---|
-| Claude Code | `claude` | conductor, implement, review | several accounts (`claude-accounts`); Opus as conductor |
-| Codex | `codex` | implement, review | sandbox without network: orq runs `git fetch` before a write run (`network = false`); quota from its session files (the free plan's 30-day window included) |
-| OpenCode | `opencode` | implement, review | any provider (e.g. MiniMax); on MiniMax, quota from the Token Plan API with your key |
+| Claude Code | `claude` | conductor, implement, review | several accounts (`claude-accounts`); Claude as conductor |
+| Codex | `codex` | conductor, implement, review | sandbox without network: orq runs `git fetch` before a write run (`network = false`); quota from its session files (the free plan's 30-day window included) |
+| OpenCode | `opencode` | conductor, implement, review | any provider (e.g. MiniMax); on MiniMax, quota from the Token Plan API with your key |
 | Antigravity | `agy` | review (implement with an allowlist) | headless denies commands outside its allowlist: it reviews by reading the attached diff; it can't commit, so orq commits its write runs (`commit = false`) |
 | GitHub Copilot | `copilot` | second opinion | small allowances on some plans: occasional use |
 
@@ -70,7 +70,7 @@ orq setup
 `orq setup` shows what it found (git, terminal, how memory is capped, keyring, your shell), links orq's skills into
 `~/.claude/skills/` and each account folder in `claude-accounts` (a junction on Windows; never over a folder of
 yours), asks about your agents and plans, writes `~/.config/orq/config.toml` (`%APPDATA%\orq\config.toml` on Windows)
-and prepares the folder that groups your repos for the conductor: `.orquestra/`, the map `CLAUDE.md` and the
+and prepares the folder that groups your repos for the conductor: `.orquestra/`, the map `ORQ.md` and the
 `/issue` playbook in the conductor's format. Pieces on their own: `orq setup --install` (no questions),
 `orq setup --workspace <folder> --conductor <agent>`. Inside Claude, **`/orq-setup`** does the same as a
 conversation and also fills in the repo table. Plane: [docs/plane.md](docs/plane.md).
@@ -172,7 +172,7 @@ issue_pattern = "(?<![a-z0-9])(?<issue>[a-z][a-z0-9]*-\\d+)(?![a-z0-9])"   # Bra
 quota_week = 95                          # ≥ 95% of the week → agent out
 quota_5h = { simple = 90, medium = 85, heavy = 80 }  # same for the 5h window, by task level
 pacing_penalty = 0.3                     # score penalty when usage at the current pace would pass the pick limit (5h by level, week: quota_week) by the reset (0 = off)
-# [agents.claude] headroom = 25          # points kept for conductors: children leave the account at limit − 25
+# [conductor] headroom = 25             # points kept for the active conductor: children stop at limit − 25
 [policy.weights]
 quality  = 0.40                          # did it deliver? (impl: approved on the first review)
 tokens   = 0.45                          # did it spend little?
@@ -187,7 +187,7 @@ rotation = 0.20                          # penalty for having been picked recent
    the least used.
 2. **Scores:** `quality × delivery + tokens × economy + speed × quickness − rotation × recent picks`. The numbers come
    from the history (`orq stats`); an agent with few runs uses the config's `prior` and gets an exploration bonus.
-3. **`reserve = true` agents** (e.g. Claude, which shares quota with the conductor) only come in when nothing else fits.
+3. **Reserved agents** (`reserve = true`, or the active conductor by default) receive a score penalty to keep quota for orchestration.
 
 ```bash
 orq pick review --impl-agent codex --explain     # every candidate's score and who was left out, and why
@@ -215,8 +215,37 @@ Whatever is already running keeps its language. Conductors always talk to you in
 
 Open the conductor in any terminal, in your workspace folder (the one `orq setup` prepared):
 ```bash
-cd ~/Code/<workspace> && orq conductor [account] [model]   # any terminal: loads the conductor instructions, the workspace CLAUDE.md and the /issue skill
+cd ~/Code/<workspace> && orq conductor [agent] [account|-] [model]   # any terminal: loads the conductor instructions, the workspace ORQ.md and the /issue skill
 ```
+Choose the conductor with `orq setup --workspace <folder> --conductor codex`, then run `orq conductor` in that folder.
+`orq conductor codex - <model>` overrides the choice for one session; `-r <id>` resumes it. Claude Code is also a
+tested conductor; the old `orq conductor <Claude account> <model>` syntax still works. If an account and an agent
+have the same name, use `--agent <name>` to select the agent explicitly. The `herdr-conductor` wrapper keeps opening Claude.
+
+`ORQ.md` holds the workspace map. Setup preserves an existing `CLAUDE.md`, copying it into `ORQ.md` on migration;
+otherwise it creates a `CLAUDE.md` pointer. `AGENTS.md` points to the map and holds the generated issue playbook,
+preserving text outside the generated block. Edit `ORQ.md` after migration. With no background commands, the conductor
+uses `orq wait` in the foreground. `orq handoff` still moves Claude accounts only.
+
+Defaults live in `[roles.conductor]` (`agent`, `account`, `model`). Interactive templates are separate from worker
+templates, keeping MCPs and normal permission prompts enabled. Override any built-in or add another CLI:
+
+```toml
+[agents.codex.conductor]
+run = "codex [-m {model}] -C {dir} {prompt_text}"
+resume = "codex resume {session} [-m {model}] -C {dir} {prompt_text}"
+models = { fast = "your-model-id" }
+accounts = { work = { CODEX_HOME = "/path/to/codex-work" } }
+
+[conductor]
+headroom = 25 # percentage points kept for whichever agent conducts
+```
+
+Templates accept `{dir}`, `{instructions}` (file path), `{prompt_text}` (read-instructions prompt), `{model}`,
+`{account}`, `{session}` and `{name}`. Account entries and `env` are environment-variable maps. The running conductor
+exports `ORQ_CONDUCTOR_AGENT`, so `orq pick` applies the reserve penalty and `[conductor].headroom` to that agent,
+even after a session override. Explicit `agents.<name>.reserve` and `headroom` take precedence.
+
 With several conductors, give each a fixed name (`export ORQ_CONDUCTOR_ID=<name>`; in herdr, the workspace label is
 used) so `orq claim` can tell them apart: the Claude session is named `conductor-<workspace>:<name>`, and
 `orq claim -l` ends each line with that `session=`, so conductors can message each other.
@@ -279,7 +308,7 @@ Day to day, shortcuts and several issues at once: [docs/herdr.md](docs/herdr.md)
 | `orq wait <prefix>...` | Blocks until those agents finish; prints `status=` and the answer file (any conductor, any terminal) |
 | `orq verify ...` (`herdr-verify`) | Tests related to the diff, queued and memory-capped; failures that also fail on the base count as pre-existing |
 | `orq board` (`herdr-board`) | Live board: queue, agents, conductors, quota, blocks, scoreboard |
-| `orq conductor [account] [model] [-r <id>]` (`herdr-conductor`) | Opens the conductor (Claude) in the current terminal with its instructions, account and model; `-r` resumes a session |
+| `orq conductor [agent] [account|-] [model] [-r <id>]` (`herdr-conductor`) | Opens the configured conductor in the current terminal with its instructions, account and model; `-r` resumes a session |
 | `orq claim` (`herdr-claim`) | Owner of each issue among conductors |
 | `orq deps` (`herdr-deps`) | Links the worktree's dependencies to the main repo's (no reinstall) |
 | `orq baseline ...` (`herdr-baseline`) | Manual snapshot of the tests failing on the base (outside the flow) |

package/README.pt-BR.md

@@ -4,7 +4,7 @@
 
 # orq — orquestrando agentes de código
 
-Você descreve o trabalho numa issue do Plane. Um **conductor** (Claude, de preferência Opus) lê a issue, escolhe o
+Você descreve o trabalho numa issue do Plane. Um **conductor** (qualquer agente que execute comandos) lê a issue, escolhe o
 agente certo para cada etapa, despacha o **implementador**, os **testes** e uma **review cross-vendor** (cada um
 em sua própria aba ou janela no [herdr](https://herdr.dev) ou no tmux, ou em segundo plano), e devolve a issue
 *In Review* com um resumo no Plane. Merge, PR e deploy continuam com você.
@@ -20,7 +20,7 @@ trabalhar. Tudo isso fica na sua config.
 ## Como funciona
 
 ```
-You ── "/issue DEMO-123" ──► conductor (Claude, in any terminal)
+You ── "/issue DEMO-123" ──► conductor (any agent CLI, in any terminal)
                                 │  orq pick impl ──► which agent/model implements (config + history + quota)
                                 ├─► implementer   orq agent  own tab/window or background · worktree from origin/<base> · memory cap
                                 ├─► tests         orq verify  only the diff's tests · queue of one suite at a time
@@ -49,9 +49,9 @@ You ── "/issue DEMO-123" ──► conductor (Claude, in any terminal)
 
 | Agente | CLI | Papéis possíveis | Observações |
 |---|---|---|---|
-| Claude Code | `claude` | conductor, implement, review | várias contas (`claude-accounts`); Opus como conductor |
-| Codex | `codex` | implement, review | sandbox sem rede: o orq roda o `git fetch` antes de uma execução de escrita (`network = false`); cota lida dos arquivos de sessão (inclusive a janela de 30 dias do plano free) |
-| OpenCode | `opencode` | implement, review | qualquer provider (ex.: MiniMax); na MiniMax, cota pela API do Token Plan com a sua chave |
+| Claude Code | `claude` | conductor, implement, review | várias contas (`claude-accounts`); Claude como conductor |
+| Codex | `codex` | conductor, implement, review | sandbox sem rede: o orq roda o `git fetch` antes de uma execução de escrita (`network = false`); cota lida dos arquivos de sessão (inclusive a janela de 30 dias do plano free) |
+| OpenCode | `opencode` | conductor, implement, review | qualquer provider (ex.: MiniMax); na MiniMax, cota pela API do Token Plan com a sua chave |
 | Antigravity | `agy` | review (implement com allowlist) | em modo headless nega comandos fora da allowlist: faz a review lendo o diff anexado; não consegue commitar, então o orq commita as execuções de escrita dele (`commit = false`) |
 | GitHub Copilot | `copilot` | segunda opinião | cota pequena em alguns planos: uso ocasional |
 
@@ -73,7 +73,7 @@ O `orq setup` mostra o que encontrou (git, terminal, como a memória é limitada
 do orq em `~/.claude/skills/` e em cada pasta de conta do `claude-accounts` (uma junction no Windows; nunca por cima
 de uma pasta sua), pergunta sobre seus agentes e planos, escreve o `~/.config/orq/config.toml`
 (`%APPDATA%\orq\config.toml` no Windows) e prepara a pasta que agrupa seus repos para o conductor: `.orquestra/`, o
-mapa `CLAUDE.md` e o playbook do `/issue` no formato do conductor. Partes avulsas: `orq setup --install` (sem
+mapa `ORQ.md` e o playbook do `/issue` no formato do conductor. Partes avulsas: `orq setup --install` (sem
 perguntas), `orq setup --workspace <pasta> --conductor <agente>`. Dentro do Claude, o **`/orq-setup`** faz o mesmo
 como conversa e ainda preenche a tabela de repos. Plane: [docs/pt-BR/plane.md](docs/pt-BR/plane.md).
 
@@ -175,7 +175,7 @@ issue_pattern = "(?<![a-z0-9])(?<issue>[a-z][a-z0-9]*-\\d+)(?![a-z0-9])"   # Nom
 quota_week = 95                          # ≥ 95% of the week → agent out
 quota_5h = { simple = 90, medium = 85, heavy = 80 }  # same for the 5h window, by task level
 pacing_penalty = 0.3                     # score penalty when usage at the current pace would pass the pick limit (5h by level, week: quota_week) by the reset (0 = off)
-# [agents.claude] headroom = 25          # points kept for conductors: children leave the account at limit − 25
+# [conductor] headroom = 25             # pontos reservados para o conductor ativo: filhos param em limite − 25
 [policy.weights]
 quality  = 0.40                          # did it deliver? (impl: approved on the first review)
 tokens   = 0.45                          # did it spend little?
@@ -190,7 +190,7 @@ rotation = 0.20                          # penalty for having been picked recent
    desempate, a menos usada.
 2. **Pontuação:** `quality × delivery + tokens × economy + speed × quickness − rotation × recent picks`. Os números vêm
    do histórico (`orq stats`); um agente com poucas execuções usa o `prior` da config e ganha um bônus de exploração.
-3. **Agentes com `reserve = true`** (ex.: Claude, que divide quota com o conductor) só entram quando nada mais serve.
+3. **Agentes reservados** (`reserve = true`, ou o conductor ativo por padrão) recebem uma penalidade na pontuação para preservar cota para a orquestração.
 
 ```bash
 orq pick review --impl-agent codex --explain     # every candidate's score and who was left out, and why
@@ -217,8 +217,37 @@ O que já está rodando continua no idioma em que começou. Os conductors sempre
 
 Abra o conductor em qualquer terminal, na pasta do seu workspace (a que o `orq setup` preparou):
 ```bash
-cd ~/Code/<workspace> && orq conductor [conta] [modelo]   # qualquer terminal: carrega as instruções do conductor, o CLAUDE.md do workspace e a skill /issue
+cd ~/Code/<workspace> && orq conductor [agente] [conta|-] [modelo]   # qualquer terminal: carrega as instruções do conductor, o ORQ.md do workspace e a skill /issue
 ```
+Escolha o conductor com `orq setup --workspace <pasta> --conductor codex` e rode `orq conductor` nessa pasta.
+`orq conductor codex - <modelo>` troca o agente só nessa sessão; `-r <id>` a retoma. Claude Code também é um
+conductor testado; a sintaxe antiga `orq conductor <conta Claude> <modelo>` continua funcionando. Se uma conta e um
+agente têm o mesmo nome, use `--agent <nome>` para selecionar o agente explicitamente. O wrapper `herdr-conductor` continua abrindo Claude.
+
+`ORQ.md` guarda o mapa do workspace. O setup preserva um `CLAUDE.md` existente e copia seu conteúdo para `ORQ.md`
+na migração; se ele não existe, cria um `CLAUDE.md` apontando para o mapa. `AGENTS.md` aponta para o mapa e contém o
+playbook gerado, preservando o texto fora do bloco gerado. Depois da migração, edite `ORQ.md`. Sem comandos em segundo
+plano, o conductor usa `orq wait` em primeiro plano. `orq handoff` continua transferindo apenas contas Claude.
+
+Os padrões ficam em `[roles.conductor]` (`agent`, `account`, `model`). Os templates interativos são separados dos
+templates dos filhos, mantendo MCPs e os pedidos normais de permissão. Sobrescreva um agente embutido ou adicione outra CLI:
+
+```toml
+[agents.codex.conductor]
+run = "codex [-m {model}] -C {dir} {prompt_text}"
+resume = "codex resume {session} [-m {model}] -C {dir} {prompt_text}"
+models = { fast = "id-do-seu-modelo" }
+accounts = { work = { CODEX_HOME = "/caminho/codex-work" } }
+
+[conductor]
+headroom = 25 # pontos percentuais reservados para o agente que estiver conduzindo
+```
+
+Os templates aceitam `{dir}`, `{instructions}` (caminho do arquivo), `{prompt_text}` (prompt para ler as instruções),
+`{model}`, `{account}`, `{session}` e `{name}`. Contas e `env` são mapas de variáveis de ambiente. O conductor exporta
+`ORQ_CONDUCTOR_AGENT`, então o `orq pick` aplica a penalidade de reserva e `[conductor].headroom` ao agente em uso,
+inclusive após uma troca só nessa sessão. Valores explícitos de `agents.<nome>.reserve` e `headroom` têm precedência.
+
 Com vários conductors, dê a cada um um nome fixo (`export ORQ_CONDUCTOR_ID=<nome>`; no herdr, vale o label do
 workspace) para o `orq claim` distingui-los: a sessão do Claude se chama `conductor-<workspace>:<nome>`, e o
 `orq claim -l` termina cada linha com esse `session=`, para os conductors conseguirem se falar.
@@ -283,7 +312,7 @@ Dia a dia, atalhos e várias issues ao mesmo tempo: [docs/pt-BR/herdr.md](docs/p
 | `orq wait <prefixo>...` | Bloqueia até esses agentes terminarem; imprime `status=` e o arquivo da resposta (qualquer conductor, qualquer terminal) |
 | `orq verify ...` (`herdr-verify`) | Testes relacionados ao diff, em fila e com limite de memória; falhas que também falham na base contam como pré-existentes |
 | `orq board` (`herdr-board`) | Painel ao vivo: fila, agentes, conductors, cota, bloqueios, placar |
-| `orq conductor [conta] [modelo] [-r <id>]` (`herdr-conductor`) | Abre o conductor (Claude) no terminal atual com as instruções, conta e modelo; `-r` retoma uma sessão |
+| `orq conductor [agente] [conta|-] [modelo] [-r <id>]` (`herdr-conductor`) | Abre o conductor configurado no terminal atual com as instruções, conta e modelo; `-r` retoma uma sessão |
 | `orq claim` (`herdr-claim`) | Dono de cada issue entre os conductors |
 | `orq deps` (`herdr-deps`) | Liga as dependências do worktree às do repo principal (sem reinstalar) |
 | `orq baseline ...` (`herdr-baseline`) | Snapshot manual dos testes que falham na base (fora do fluxo) |

package/dist/commands/claim.js

@@ -141,7 +141,9 @@ export async function claim(argv) {
     const kind = process.env.HERDR_PANE_ID ? "herdr" : "id";
     const me = process.env.HERDR_PANE_ID || process.env.ORQ_CONDUCTOR_ID || `${userInfo().username}@${hostname()}`;
     const myName = (kind === "herdr" ? herdrName(me) : "") || process.env.ORQ_CONDUCTOR_ID || "";
-    const account = basename(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"));
+    const account = process.env.ORQ_CONDUCTOR_AGENT && process.env.ORQ_CONDUCTOR_AGENT !== "claude"
+        ? `${process.env.ORQ_CONDUCTOR_AGENT}:${process.env.ORQ_CONDUCTOR_ACCOUNT || "default"}`
+        : basename(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"));
     const ownerLine = () => `pane=${me} kind=${kind} account=${account} at=${new Date().toISOString()}`
         + (myName ? ` name=${myName}` : "") + "\n";
     if (mode === "register") {

package/dist/commands/completion.js

@@ -11,12 +11,13 @@ const DESC = {
     quota: "quota per agent/account", pick: "pick agent, model and account for a role", stats: "scoreboard per agent", rounds: "rounds, time and repeated findings of an issue",
     board: "live board", lock: "test queue", run: "run a command under a memory cap", agent: "run a child agent",
     wait: "wait for child agents", verify: "tests of a diff", baseline: "tests already failing on the base",
-    instructions: "write the /issue playbook", conductor: "open the conductor (Claude) in this terminal", claim: "issue owner among conductors", deps: "link node_modules into a worktree", gc: "remove merged issue worktrees", ci: "CI/CD status per claimed issue", handoff: "move a conductor low on quota to another account",
+    instructions: "write the /issue playbook", conductor: "open the configured conductor in this terminal", claim: "issue owner among conductors", deps: "link node_modules into a worktree", gc: "remove merged issue worktrees", ci: "CI/CD status per claimed issue", handoff: "move a conductor low on quota to another account",
     block: "block an agent or account", completion: "shell completion script",
 };
 /** Fixed words after a subcommand. */
 export const WORDS = {
-    setup: ["--preset", "--detect", "--answers", "--write", "--install", "--workspace"],
+    setup: ["--preset", "--detect", "--answers", "--write", "--install", "--workspace", "--conductor"],
+    conductor: ["claude", "codex", "opencode", "antigravity", "copilot", "--agent", "-r", "--help"],
     config: ["get", "files", "-w"], lang: ["pt", "en", "auto", "toggle"], lock: ["wait", "release", "run", "status"],
     pick: ["impl", "fix", "worker", "review", "opinion", "watchdog"], instructions: ["claude", "agents"], board: ["--once", "--json", "-w"],
     completion: ["bash", "zsh", "fish", "powershell"], stats: ["--days", "--json", "-w"], wait: ["--any", "--timeout", "--answer"],

package/dist/commands/conductor.js

@@ -1,32 +1,62 @@
-// orq conductor — opens the conductor (Claude Code) in the current terminal, with the workspace's conductor
+// orq conductor — opens the configured agent in the current terminal, with the workspace's conductor
 // instructions, the chosen account and model (port of setup/herdr-conductor, for any terminal and OS).
-//   orq conductor [account|-] [model] [-r <session>]
+//   orq conductor [agent] [account|-] [model] [-r <session>]
 // Workspace: the current folder if it has .orquestra-conductor.md, else $CONDUCTOR_WS. $CONDUCTOR_FILE overrides the
 // instructions file. The session is named conductor-<workspace folder>:<herdr label or ORQ_CONDUCTOR_ID> (see sessionName).
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { claudeAccounts } from "../accounts.js";
+import { ALIASES, expandTemplate, expandString, onPath } from "../agents.js";
+import { getPath, loadConfig } from "../config.js";
 import { m } from "../i18n.js";
 import { runCapped } from "../process.js";
 import { claim, herdrName, sessionName } from "./claim.js";
-export const USAGE = `orq conductor [account|-] [model] [-r <session>]   open the conductor (Claude) here: instructions, account, model
-  model: sonnet | opus | haiku | a full id; "-" as account = default account; -r resumes that conversation`;
+import { instructions } from "./instructions.js";
+export const USAGE = `orq conductor [agent] [account|-] [model] [-r <session>]   open the configured conductor here
+  defaults: roles.conductor.agent/account/model; without config: claude
+  legacy: orq conductor <Claude account|-> [model]; -r resumes that conversation
+  --agent <name> disambiguates an agent from a Claude account with the same name
+  templates: agents.<agent>.conductor.run/resume/models/accounts/env`;
 export const MODELS = {
     sonnet: "claude-sonnet-5",
     opus: "claude-opus-5-5",
     haiku: "claude-haiku-4-5-20251001",
 };
 export const modelId = (alias) => MODELS[alias] ?? alias;
-/** [account|-] [model] [-r|--resume <id>]; further positionals are ignored (as herdr-conductor did). */
-export function parseArgs(argv) {
+/** Interactive launch templates retain the conductor's MCPs and normal permission prompts. */
+export const CONDUCTORS = {
+    claude: {
+        run: "claude -n {name} [--model {model}] --append-system-prompt-file {instructions}",
+        resume: "claude --resume {session} -n {name} [--model {model}] --append-system-prompt-file {instructions}",
+        models: MODELS,
+    },
+    codex: { run: "codex [-m {model}] -C {dir} {prompt_text}",
+        resume: "codex resume {session} [-m {model}] -C {dir} {prompt_text}" },
+    opencode: { run: "opencode [-m {model}] --prompt {prompt_text} {dir}",
+        resume: "opencode -s {session} [-m {model}] --prompt {prompt_text} {dir}" },
+    copilot: { run: "copilot -C {dir} [--model {model}] -i {prompt_text}",
+        resume: "copilot -C {dir} --resume={session} [--model {model}] -i {prompt_text}" },
+    antigravity: { run: "agy [--model {model}] -i {prompt_text}",
+        resume: "agy --conversation {session} [--model {model}] -i {prompt_text}" },
+};
+/** Optional agent, then [account|-] [model] [-r|--resume <id>]; old Claude positionals still parse. */
+export function parseArgs(argv, names = Object.keys(CONDUCTORS), accounts = []) {
     const out = { account: "", model: "", resume: "", help: false };
     const pos = [];
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
-        if (a === "-r" || a === "--resume") {
+        if (a === "--agent") {
             const v = argv[++i];
-            if (!v) {
+            if (!v || v.startsWith("-")) {
+                out.error = USAGE;
+                return out;
+            }
+            out.agent = ALIASES[v] ?? v;
+        }
+        else if (a === "-r" || a === "--resume") {
+            const v = argv[++i];
+            if (!v || v.startsWith("-")) {
                 out.error = m("give the session id", "informe o id da sessão");
                 return out;
             }
@@ -37,9 +67,53 @@ export function parseArgs(argv) {
         else
             pos.push(a);
     }
+    if (!out.agent && pos.length === 2 && pos[1] !== "-" && accounts.includes(pos[0])) {
+        out.agent = "claude";
+    }
+    else if (!out.agent && pos.length && names.includes(ALIASES[pos[0]] ?? pos[0])) {
+        const agent = pos.shift();
+        out.agent = ALIASES[agent] ?? agent;
+    }
     [out.account = "", out.model = ""] = pos;
+    if (pos.length > 2)
+        out.error = USAGE;
     return out;
 }
+/** Resolve a conductor without reusing worker templates (which disable MCPs and permissions). */
+export function launch(cfg, a, ws, file, name = "") {
+    const agent = a.agent ?? String(getPath(cfg, "roles.conductor.agent") ?? "claude");
+    const user = (getPath(cfg, `agents.${agent}.conductor`) ?? {});
+    const base = CONDUCTORS[agent];
+    const def = { ...base, ...user, models: { ...base?.models, ...user.models } };
+    const template = a.resume ? def.resume : def.run;
+    if (!template)
+        throw new Error(`orq conductor: ${agent} needs agents.${agent}.conductor.${a.resume ? "resume" : "run"}`);
+    const same = !a.agent || a.agent === getPath(cfg, "roles.conductor.agent");
+    const account = a.account || (same ? String(getPath(cfg, "roles.conductor.account") ?? "") : "");
+    const model = a.model || (same ? String(getPath(cfg, "roles.conductor.model") ?? "") : "");
+    const vars = { dir: ws, instructions: file, name: sessionName(ws, name), session: a.resume,
+        account: account === "-" ? "" : account, model: def.models[model] ?? model,
+        prompt_text: `Read ${JSON.stringify(file)} for your conductor instructions and follow them. Read AGENTS.md for the issue playbook. Read ORQ.md for the workspace map; in an older workspace without ORQ.md, read CLAUDE.md.` };
+    const env = { ...process.env };
+    for (const [k, v] of Object.entries(def.env ?? {}))
+        env[k] = expandString(v, vars);
+    if (account && account !== "-") {
+        const custom = def.accounts?.[account];
+        if (custom)
+            Object.assign(env, custom);
+        else if (agent === "claude") {
+            const accounts = claudeAccounts(), found = accounts.find((x) => x.name === account);
+            if (!found)
+                throw new Error(`account '${account}' does not exist. Accounts: ${accounts.map((x) => `${x.name} ${x.dir}`).join(", ")}`);
+            env.CLAUDE_CONFIG_DIR = found.dir;
+        }
+        else
+            throw new Error(`orq conductor: account '${account}' needs agents.${agent}.conductor.accounts.${account}`);
+    }
+    env.ORQ_CONDUCTOR_AGENT = agent;
+    env.ORQ_CONDUCTOR_ACCOUNT = account && account !== "-" ? account : "default";
+    return { agent, argv: expandTemplate(template, vars), env };
+}
 /** The workspace folder: cwd when it holds .orquestra-conductor.md, else $CONDUCTOR_WS (resolved); undefined if neither. */
 export function findWorkspace(cwd, env, exists = existsSync) {
     if (exists(join(cwd, ".orquestra-conductor.md")))
@@ -53,7 +127,13 @@ export function claudeArgs(ws, a, file, name = "") {
         ...(a.model ? ["--model", modelId(a.model)] : []), "--append-system-prompt-file", file];
 }
 export async function conductor(argv) {
-    const a = parseArgs(argv);
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(USAGE);
+        return 0;
+    }
+    const ws = findWorkspace(process.cwd(), process.env);
+    const { cfg } = loadConfig(ws);
+    const a = parseArgs(argv, [...Object.keys(CONDUCTORS), ...Object.keys((cfg.agents ?? {}))], claudeAccounts().map((a) => a.name));
     if (a.help) {
         console.log(USAGE);
         return 0;
@@ -62,7 +142,6 @@ export async function conductor(argv) {
         console.error(a.error);
         return 2;
     }
-    const ws = findWorkspace(process.cwd(), process.env);
     if (!ws) {
         console.error(m("no .orquestra-conductor.md here: cd into a workspace (orq setup --workspace <dir>) or set CONDUCTOR_WS", "não há .orquestra-conductor.md aqui: entre num workspace (orq setup --workspace <pasta>) ou defina CONDUCTOR_WS"));
         return 2;
@@ -72,34 +151,45 @@ export async function conductor(argv) {
         console.error(`${m("conductor instructions not found", "instruções do conductor não encontradas")}: ${file}`);
         return 2;
     }
-    const env = { ...process.env };
-    if (a.account && a.account !== "-") {
-        const accounts = claudeAccounts(), found = accounts.find((x) => x.name === a.account);
-        if (!found) {
-            console.error(m(`account '${a.account}' does not exist. Accounts:`, `a conta '${a.account}' não existe. Contas:`));
-            for (const x of accounts)
-                console.error(`${x.name} ${x.dir}`);
-            return 1;
-        }
-        env.CLAUDE_CONFIG_DIR = found.dir;
+    const name = (process.env.HERDR_PANE_ID ? herdrName(process.env.HERDR_PANE_ID) : "") || process.env.ORQ_CONDUCTOR_ID || "";
+    let command;
+    try {
+        command = launch(cfg, a, ws, file, name);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 1;
     }
+    const { env } = command;
+    if (!command.argv.length || !onPath(command.argv[0])) {
+        console.error(`orq conductor: executable not found: ${command.argv[0] ?? "(empty template)"}`);
+        return 1;
+    }
+    if (command.agent !== "claude")
+        await instructions(["agents", "-w", ws]);
     if (process.env.HERDR_ENV === "1" && process.env.HERDR_PANE_ID)
         spawnSync("herdr", ["pane", "rename", process.env.HERDR_PANE_ID, "conductor"], { stdio: "ignore", timeout: 5_000 });
     process.chdir(ws);
     // Registration (.orquestra/.conductors) is a herdr thing (keyed by pane id; `claim --register` does nothing elsewhere),
     // so only inside herdr. claim reads the account from this process's env (best effort, silent).
-    const saved = process.env.CLAUDE_CONFIG_DIR;
-    if (env.CLAUDE_CONFIG_DIR)
-        process.env.CLAUDE_CONFIG_DIR = env.CLAUDE_CONFIG_DIR;
-    if (process.env.HERDR_PANE_ID)
-        try {
-            await claim(["-w", ws, "--register"]);
+    const keys = ["CLAUDE_CONFIG_DIR", "ORQ_CONDUCTOR_AGENT", "ORQ_CONDUCTOR_ACCOUNT"];
+    const saved = keys.map((k) => process.env[k]);
+    try {
+        for (const k of keys) {
+            if (env[k] === undefined)
+                delete process.env[k];
+            else
+                process.env[k] = env[k];
         }
-        catch { /* best effort */ }
-    if (saved === undefined)
-        delete process.env.CLAUDE_CONFIG_DIR;
-    else
-        process.env.CLAUDE_CONFIG_DIR = saved;
-    const name = (process.env.HERDR_PANE_ID ? herdrName(process.env.HERDR_PANE_ID) : "") || process.env.ORQ_CONDUCTOR_ID || "";
-    return runCapped("claude", claudeArgs(ws, a, file, name), { mode: "off", env, cwd: ws, quote: true, tty: true });
+        if (process.env.HERDR_PANE_ID)
+            await claim(["-w", ws, "--register"]);
+    }
+    catch { /* best effort */ }
+    finally {
+        keys.forEach((k, i) => { if (saved[i] === undefined)
+            delete process.env[k];
+        else
+            process.env[k] = saved[i]; });
+    }
+    return runCapped(command.argv[0], command.argv.slice(1), { mode: "off", env, cwd: ws, quote: true, tty: true });
 }

package/dist/commands/gc.js

@@ -7,6 +7,7 @@ import { m } from "../i18n.js";
 import { issueFromName, issuePattern, issuesWithLiveAgent } from "../issue.js";
 import { alive } from "../lock.js";
 import { stateDir } from "../paths.js";
+import { describe, stopWorktreeProcesses, worktreeProcesses } from "../worktree-processes.js";
 import { aliveOwner } from "./claim.js";
 export const USAGE = "orq gc [-w <workspace>] [--yes] [--days N] [--json]   remove merged issue worktrees and stale agent state";
 const git = (cwd, ...args) => spawnSync("git", ["-C", cwd, ...args], { encoding: "utf8" });
@@ -168,20 +169,24 @@ export async function gc(argv, clock = Date.now) {
     if (ghUnavailable)
         console.error(m("NOTE: gh unavailable or failed; PR signals were skipped", "NOTA: gh indisponível ou falhou; sinais de PR ignorados"));
     let failed = false;
-    if (yes)
-        for (const row of rows.filter((r) => r.verdict === "REMOVABLE")) {
-            const removed = git(join(ws, row.repo), "worktree", "remove", row.path);
-            if (removed.status !== 0) {
-                failed = true;
-                row.reason += `; ${m("worktree removal failed", "falha ao remover worktree")}`;
-                continue;
-            }
-            if (git(join(ws, row.repo), "branch", "-D", row.branch).status !== 0) {
-                failed = true;
-                row.reason += `; ${m("branch deletion failed", "falha ao excluir branch")}`;
-            }
-            git(join(ws, row.repo), "worktree", "prune");
+    for (const row of rows.filter((r) => r.verdict === "REMOVABLE")) {
+        const pids = yes ? stopWorktreeProcesses(row.path) : worktreeProcesses(row.path).map(describe);
+        if (pids.length)
+            row.reason += `; ${yes ? m("stopped processes", "processos encerrados") : m("processes to stop", "processos a encerrar")}: ${pids.join(", ")}`;
+        if (!yes)
+            continue;
+        const removed = git(join(ws, row.repo), "worktree", "remove", row.path);
+        if (removed.status !== 0) {
+            failed = true;
+            row.reason += `; ${m("worktree removal failed", "falha ao remover worktree")}`;
+            continue;
         }
+        if (git(join(ws, row.repo), "branch", "-D", row.branch).status !== 0) {
+            failed = true;
+            row.reason += `; ${m("branch deletion failed", "falha ao excluir branch")}`;
+        }
+        git(join(ws, row.repo), "worktree", "prune");
+    }
     const stale = staleAgentStates(ws, days, clock());
     if (yes)
         for (const f of stale)

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

@@ -145,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);
@@ -201,7 +203,7 @@ export function pick(inp) {
         }
         // 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) {
@@ -329,7 +331,7 @@ 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);

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.8.0",
+  "version": "0.9.0",
   "description": "Orchestrate coding agents (Claude Code, Codex, OpenCode, Antigravity, Copilot) from one conductor.",
   "license": "MIT",
   "type": "module",

package/skills/issue/SKILL.md

@@ -8,7 +8,7 @@ description: Runs a Plane issue end to end by orchestrating coding agents in her
 You are the **orchestrator**: you plan, dispatch, follow up and report. **Do not implement anything yourself** (it
 burns the conductor's model). Talk to the user in the user's language.
 
-**Ecosystem configuration:** the **workspace** `CLAUDE.md` (the folder named in your conductor instructions) defines
+**Ecosystem configuration:** in the folder named in your conductor instructions, read `ORQ.md` (legacy: `CLAUDE.md`). It defines
 the repositories and their groups (= herdr workspace or just a label, `-g`), **each repo's base branch**, verification commands,
 Plane projects (identifier → project_id), default assignee, labels/modules and MCP limitations. Read it before you
 start. Below, `$WS` = workspace.
@@ -17,11 +17,17 @@ herdr (`HERDR_ENV=1`), in tmux windows inside tmux, else in the background (thei
 still `<prefix>.out.md`; `-T`, the agent's own screen, needs herdr or tmux). Set `ORQ_CONDUCTOR_ID` to a fixed name per
 conductor outside herdr.
 - **Completion signal:** in herdr, one line `[HERDR-AGENT DONE] <title> status=ok|fail ... answer: <file>` is typed into
-  your pane after each child. Anywhere else no line arrives: after dispatching, run `orq wait <prefix>` **as a background
-  task** (Claude Code: Bash with `run_in_background`); its exit wakes you and its output is the line
+  your pane after each child. Anywhere else no line arrives: `orq wait <prefix>` prints
   `[ORQ AGENT DONE] <title> status=ok|fail ... answer: <file>`. Treat both lines the same. Several children in parallel:
-  `orq wait --any <prefix1> <prefix2>` (one wake-up per finish; wait again for the rest). No background tasks in your
-  harness → run `orq wait` in the foreground; that is the one allowed blocking wait.
+  `orq wait --any <prefix1> <prefix2>` (one finish per call; wait again for the rest).
+- **Waiting strategy** (your conductor instructions name it; `orq instructions strategy` shows it). It depends on what
+  your harness can do, not on whether it can start a background process:
+  - *background task* — only when a finished background task starts a new turn by itself (Claude Code: Bash with
+    `run_in_background`): run `orq wait --any ...` that way and end your turn.
+  - *foreground loop* — every other harness (Codex, OpenCode, ...): stay active. Run
+    `orq wait --any --timeout <s> <pending prefixes>` in the foreground; exit 124 = nothing finished yet → one-line
+    status to the user and run it again (never re-dispatch on a timeout). Don't end your turn expecting a wake-up; if
+    you must, tell the user you won't continue until they message you.
 - `orq verify` and `orq baseline` run like children (herdr tab, tmux window or background) and you wait for them the same
   way, e.g. `orq wait $O/verify-<repo>`.
 - Peeking at a child: `<prefix>.log` (in herdr also `herdr pane read $(cat <prefix>.pane) --source recent`).
@@ -42,7 +48,7 @@ Issue artifacts (prompts, notes) live in `$WS/.orquestra/<ID>/`.
 - `mcp__plane__workitem` `retrieve_by_identifier` with `workitem_identifier: "<ID>"`; then `workitem_comment list`.
 - Extract: goal, **acceptance criteria**, affected repos, links. No acceptance criteria → write a short proposal and
   **ask the user** before dispatching.
-- Issue missing assignee, priority, labels or module → **fill them in** following the workspace `CLAUDE.md` "Issue
+- Issue missing assignee, priority, labels or module → **fill them in** following the workspace `ORQ.md` "Issue
   standard". The same standard applies to any new issue you create.
 - Move it to **In Progress** (`workitem update` with the state_id from `state list`).
 
@@ -93,7 +99,7 @@ Write the prompt to `$WS/.orquestra/<ID>/impl-<repo>.md` (short: goal, acceptanc
 verification commands, "base: origin/<BASE>; don't rebase/merge other branches; local commits, no push; commit
 messages following <path of the repo's commit conventions, see step 7>").
 Always include:
-- **Repo checklist:** copy the repo's "Checklist" column from the workspace `CLAUDE.md`.
+- **Repo checklist:** copy the repo's "Checklist" column from the workspace `ORQ.md`.
 - **Decisions:** "end your final answer with a `## Decisions` section, at most 10 lines: what you chose and what you
   ruled out, trade-offs, and what you left out on purpose and why". The reviewer reads it (step 5), so a deliberate
   choice doesn't come back as a blocker.
@@ -102,7 +108,7 @@ Always include:
   and report; after the rebase repeat lint/tsc". An agent without network (Codex) can't fetch: `orq agent` fetches before
   the run and adds a note to its prompt, so it only rebases locally.
 
-**Base = the repo's base branch from the workspace `CLAUDE.md`, always from the updated remote (`origin/<BASE>`).**
+**Base = the repo's base branch from the workspace `ORQ.md`, always from the updated remote (`origin/<BASE>`).**
 Worktree with `git worktree add` (not `herdr worktree create`: that opens a separate herdr workspace per worktree, and
 children are grouped by the repo's `-g`).
 ```bash
@@ -139,7 +145,7 @@ orq agent $(cat $O/impl-<repo>.pick) -g <group> -t "<ID> impl <repo>" -d $WT -o
 - Every child prompt ends with: "Don't try to talk to the conductor or use herdr; finish with your complete final
   answer (that is what I read)."
 - **Verification in the child: lint and tsc only, one command at a time** (the cap is 4 GB per agent and jest/vitest
-  blow it; tests are yours, step 4b): use the Verification column of the workspace `CLAUDE.md` and put in the prompt
+  blow it; tests are yours, step 4b): use the Verification column of the workspace `ORQ.md` and put in the prompt
   "verify sequentially, never in parallel or watch mode: (1) lint only the changed files (`git diff --name-only
   origin/<BASE>...HEAD`); (2) `NODE_OPTIONS=--max-old-space-size=2048 tsc --noEmit` for the project. Don't run tests".
   Full suite only in CI (or a manual `orq baseline` if the user asks).
@@ -148,7 +154,7 @@ orq agent $(cat $O/impl-<repo>.pick) -g <group> -t "<ID> impl <repo>" -d $WT -o
   arriving), run `orq notice` (delivery log) and `<prefix>.done` for that issue, then handle the failure; running
   `orq wait`, `orq verify` or `orq agent` for the issue acknowledges it.
 - **Never block waiting** (`herdr agent wait`, `pane wait-output`, `sleep`, `timeout`): completion arrives as a
-  `[HERDR-AGENT DONE]` line in your pane (herdr) or through the background `orq wait`. Dispatch, report in one line and end your turn. "Done yet?" = `<prefix>.done`
+  `[HERDR-AGENT DONE]` line in your pane (herdr) or through `orq wait` per your waiting strategy. Dispatch, report in one line, then end your turn (herdr / background task) or keep looping (foreground loop). "Done yet?" = `<prefix>.done`
   exists (never `pgrep`).
 - Investigation only (no code): "READ ONLY" prompt, in the repo itself, no worktree. `orq agent -r` (Claude:
   `--permission-mode plan`; the others: throwaway worktree, no editing).
@@ -169,7 +175,7 @@ something is red, new or old, and never widen a baseline or allowlist to silence
 outside the issue's domain: ask the user first (then it ships as its own PR, not as a note).
 **Mandatory order every round (impl and each fix): child `ok` → verify → review.** Never dispatch the review (or an
 "early" fix) while this round's verify is pending, even if it is queued behind another verify: wait for
-the `... verify ...` done line and end your turn until then.
+the `... verify ...` done line (end your turn or keep looping, per your waiting strategy).
 
 ## 5. Cross review (always another vendor)
 ```bash
@@ -265,7 +271,7 @@ rules live) commits and writes the PR. Find and cite in the prompt, by path, wha
   high severity, `file:line` and a concrete failure, not already decided in the rounds, goes into a fix round (it
   counts towards `policy.max_rounds`); the rest goes into the Plane comment or a follow-up issue. Don't re-request the
   bot's review to "get it clean".
-- **CI after every push:** `gh pr checks <n>` (no `--watch`; if pending, end your turn and check on the next notice).
+- **CI after every push:** `gh pr checks <n>` (no `--watch`; if pending, check again on the next notice or loop iteration).
   Red → `gh run view <id> --log-failed | tail -40`: error from the diff → fix round; error already on the base → create
   a Plane issue (workspace standard) and tell the user. "Ready to merge" only with green checks or an explained failure
   + issue.
@@ -279,4 +285,4 @@ rules live) commits and writes the PR. Find and cite in the prompt, by path, wha
 ## Saving tokens
 Short prompts (never paste the whole `CLAUDE.md` — the agent reads the repo's own). Reviews judge only the diff, but the prompt must say the reviewer **may open files for context** (cat, rg, git
 show — read only): Codex read "review only the diff" as "use only the attached diff" and returned an empty review. Don't re-read
-the whole issue at every step. Respect the MCP limitations listed in the workspace `CLAUDE.md`.
+the whole issue at every step. Respect the MCP limitations listed in the workspace `ORQ.md`.

package/skills/orq-setup/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: orq-setup
-description: Guided first-time setup of orq for a new developer — detects and smoke-tests the installed agent CLIs, asks which agents take which roles, models, Claude accounts and pick weights, writes ~/.config/orq/config.toml, then prepares a conductor workspace (orq setup --workspace + workspace CLAUDE.md) and checks Plane. Use when the user says "/orq-setup", "set up orq", "configure orq" or just installed orq (npm i -g @irythill/orq, or install.sh).
+description: Guided first-time setup of orq for a new developer — detects and smoke-tests the installed agent CLIs, asks which agents take which roles, models, Claude accounts and pick weights, writes ~/.config/orq/config.toml, then prepares a conductor workspace (orq setup --workspace + workspace ORQ.md) and checks Plane. Use when the user says "/orq-setup", "set up orq", "configure orq" or just installed orq (npm i -g @irythill/orq, or install.sh).
 ---
 
 # /orq-setup — configure orq for this developer
@@ -85,10 +85,10 @@ Explain simply, then suggest the example's values and ask if they want to change
 ## 6. Workspace
 - Ask for the folder that groups their repos (e.g. `~/Code/acme-platform`). After the OK:
   `orq setup --workspace <folder> --conductor <the conductor agent>` — `.orquestra/`, `.worktrees/`, the map
-  `<folder>/CLAUDE.md` from the template (never overwrites one) and the `/issue` playbook in the conductor's format
+  `<folder>/ORQ.md` from the template (never overwrites one) and the `/issue` playbook in the conductor's format
   (`.claude/skills/issue/SKILL.md` for Claude Code, `AGENTS.md` for the others). Conductor in herdr (clone only):
   `$ORQ/setup/new-conductor.sh <name> <folder>` also writes its instructions and permissions.
-- Fill the repo table in `<folder>/CLAUDE.md` by inspecting each git repo inside it:
+- Fill the repo table in `<folder>/ORQ.md` by inspecting each git repo inside it:
   - base branch: `git -C <repo> symbolic-ref --short refs/remotes/origin/HEAD` (strip `origin/`); ask if the team
     branches from another one (e.g. `dev`).
   - group: the repo folder name in lower case (the herdr workspace or tmux group for its children).

package/templates/conductor.instructions.md

@@ -2,23 +2,26 @@
 
 You orchestrate agents in the `{{WORKSPACE}}` ecosystem, in herdr (`HERDR_ENV=1`) or in any other terminal.
 Don't write code yourself. Opened by `orq conductor`. Talk to the user in the user's language.
-1. Read `{{WORKSPACE}}/CLAUDE.md` (repos, groups, base branch, Plane, issue standard, MCP limitations).
-2. For every Plane issue, follow the `/issue <ID>` skill.
+1. Read `{{WORKSPACE}}/ORQ.md` (repos, groups, base branch, Plane, issue standard, MCP limitations).
+   In an older workspace without `ORQ.md`, read `{{WORKSPACE}}/CLAUDE.md`.
+2. For every Plane issue, follow the `/issue <ID>` playbook (a skill or the generated block in `AGENTS.md`).
 3. Never push, open a PR, merge or deploy unless the user asks. When unsure about scope or cost, ask.
 4. **Children only through `orq agent`** (implementer, fix, review), with the agent chosen by `orq pick`; tests through
    `orq verify` (it checks the base by itself; no `orq baseline` in the flow), as the skill says. NEVER
    `herdr agent start` for children (no memory cap, no answer file); to watch the agent's own screen, `orq agent -T` (herdr or tmux).
 5. **Completion = one single signal:** in herdr, the line `[HERDR-AGENT DONE] <title> status=ok|fail ... answer: <file>`
-   arriving in your pane; elsewhere, `orq wait <prefix>` (as a background task) printing
-   `[ORQ AGENT DONE] <title> status=ok|fail ... answer: <file>` (plus the `<prefix>.done` file either way). When it
-   arrives: read the answer file and act. Nothing else means done.
+   arriving in your pane; elsewhere, `orq wait` printing `[ORQ AGENT DONE] <title> status=ok|fail ... answer: <file>`
+   (plus the `<prefix>.done` file either way), run as the **Waiting strategy** below says. When it arrives: read the
+   answer file and act. Nothing else means done.
 6. **"Is it still running?"** is answered by the file only: `<prefix>.done` exists → finished; it doesn't → running;
    check `<prefix>.log` (last write time) or, in herdr, peek at the pane: `herdr pane read $(cat <prefix>.pane) --source recent`.
    NEVER `pgrep`/`ps` (they match their own command line).
-7. **Never block waiting** (`herdr agent wait`, `pane wait-output`, `sleep`): dispatch, report in one line and end
-   your turn (outside herdr: `orq wait` in the background, never in the foreground unless your harness has no background tasks).
+7. **Never block waiting** (`herdr agent wait`, `pane wait-output`, `sleep`) except through `orq wait` as the Waiting
+   strategy below says. End your turn after dispatching only when that strategy gives you a wake-up.
 8. Worktrees always from `origin/<repo base>`, created with `git worktree add` (never `herdr worktree create`).
-9. Between batches of unrelated issues, suggest `/clear` to the user: state lives in Plane and in `.orquestra/`.
+9. Between batches of unrelated issues, suggest a fresh conversation: state lives in Plane and in `.orquestra/`.
+
+{{WAIT_STRATEGY}}
 
 ## How you are used
 - **Dispatcher, not consultant.** Your job: issue → dispatch → report → PR/cleanup. Long questions about architecture,
@@ -26,6 +29,6 @@ Don't write code yourself. Opened by `orq conductor`. Talk to the user in the us
   to a design session; come back with the decision recorded in the issue".
 - **The issue is the source.** A decision made in chat → record it in Plane (description or comment) before
   dispatching; the child's prompt comes from the issue, not from the conversation.
-- **Context:** past ~150k tokens or after closing a batch of related issues → suggest `/clear` (state in Plane and in
+- **Context:** past ~150k tokens or after closing a batch of related issues → suggest a fresh conversation (state in Plane and in
   `.orquestra/`).
 - 1–3 line answers. Final issue report: 3–5 lines + the PR link.

package/templates/workspace.CLAUDE.md

@@ -1,11 +1,11 @@
-# CLAUDE.md — {{NAME}} ecosystem ({{WORKSPACE}})
+# ORQ.md — {{NAME}} ecosystem ({{WORKSPACE}})
 
 This folder groups the ecosystem's repositories. Each repo has its own `CLAUDE.md`/`AGENTS.md` with commands and
 rules — read the repo's own before touching it. This file only holds the map and the orchestration settings.
 
 ## Orchestration (read by the `/issue` skill)
 - **Workspace:** `{{WORKSPACE}}`
-- **Conductor:** opened with `orq conductor [account] [model] [-r <session-id>]` in this folder, in any terminal (inside a
+- **Conductor:** opened with `orq conductor [agent] [account|-] [model] [-r <session-id>]` in this folder, in any terminal (inside a
   herdr pane too; `herdr-conductor` still works there). Instructions in `.orquestra-conductor.md`; the **Group** in the
   table below is the herdr workspace (`-g`) or just a label outside herdr.
   Tests from the Verification column (jest/vitest) **don't run in the child**: the conductor runs `orq verify`