@irythill/orq 0.7.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).
@@ -135,7 +135,7 @@ roles  = ["impl", "fix", "review"]
 quota  = ["codex"]                       # name in agent-quota's output
 [agents.codex.models.impl]
 simple = "gpt-6-sol@low"                 # model@effort, per issue level
-medium = "gpt-6-sol@medium"
+medium = ["gpt-6-sol@medium", "gpt-6-luna@medium"]  # several: each (agent, model) pair is scored on its own history
 heavy  = "gpt-6.1-sol@high"
 [agents.codex.models.review]
 simple  = "gpt-6-sol@low"                # reviews scale with the issue too
@@ -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).
 
@@ -138,7 +138,7 @@ roles  = ["impl", "fix", "review"]
 quota  = ["codex"]                       # name in agent-quota's output
 [agents.codex.models.impl]
 simple = "gpt-6-sol@low"                 # model@effort, per issue level
-medium = "gpt-6-sol@medium"
+medium = ["gpt-6-sol@medium", "gpt-6-luna@medium"]  # several: each (agent, model) pair is scored on its own history
 heavy  = "gpt-6.1-sol@high"
 [agents.codex.models.review]
 simple  = "gpt-6-sol@low"                # reviews scale with the issue too
@@ -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)