@irythill/orq 0.5.0 → 0.6.1

package/dist/quota.js

@@ -24,6 +24,7 @@ import { writeAtomic } from "./fsutil.js";
 import { readSecret } from "./keyring.js";
 import { stateDir } from "./paths.js";
 import { m } from "./i18n.js";
+import { modelKey } from "./pick.js";
 const show = (p) => (typeof p === "number" ? `${Math.floor(p)}%` : p);
 // reset5h/resetweek (epoch seconds) sit between the windows and the note: parseQuota/parseWindows only look at the
 // first three words, so old cached lines (no reset fields) and lines with them both parse the same way.
@@ -50,9 +51,9 @@ const resetOf = (w) => {
 };
 // `acct` identifies the login behind a reading (antigravity: one login per machine, swapped by the user): a cache
 // written under another login must never stand in for this one.
-function remember(name, five, week, acct) {
+function remember(name, five, week, acct, buckets) {
     try {
-        writeAtomic(cacheFile(name), JSON.stringify({ five, week, at: Date.now(), ...(acct ? { acct } : {}) }));
+        writeAtomic(cacheFile(name), JSON.stringify({ five, week, at: Date.now(), ...(acct ? { acct } : {}), ...(buckets ? { buckets } : {}) }));
     }
     catch { /* best effort */ }
     const r5 = resetOf(five), rw = resetOf(week);
@@ -195,23 +196,83 @@ export function codexQuota() {
     return { name: "codex", ...pcts, ...(span5 ? { span5h: span5 } : {}), ...(span ? { spanWeek: span } : {}), note: (d ? m(`${d}-day window in the week slot; `, `janela de ${d} dias no lugar da semana; `) : "")
             + m(`from the last session, ${age} min ago`, `da última sessão, há ${age} min`) };
 }
-/** Worst usage per window across models: a reset within 6 h belongs to the 5h window, a later one to the week. */
+/** Per-model buckets, and the agent's own pair: its least used bucket (the agent still has quota while any
+ *  model does; `orq pick` checks the model it is about to choose against that model's own bucket). */
 export function antigravityFromModels(models, now = Date.now()) {
     const five = { pct: "-" }, week = { pct: "-" };
-    for (const { quotaInfo: q } of Object.values(models ?? {})) {
-        if (typeof q?.remainingFraction !== "number" || !q.resetTime)
+    const buckets = {};
+    for (const [id, { quotaInfo: q } = {}] of Object.entries(models ?? {})) {
+        if (!q?.resetTime)
             continue;
         const at = Date.parse(q.resetTime);
         if (Number.isNaN(at))
             continue;
-        const w = at - now <= 6 * 3600_000 ? five : week;
-        const used = Math.round((1 - q.remainingFraction) * 100);
-        if (w.pct === "-" || used > w.pct) {
-            w.pct = used;
-            w.resetsAt = q.resetTime;
+        const left = typeof q.remainingFraction === "number" ? q.remainingFraction : 0;
+        const used = Math.min(100, Math.max(0, Math.round((1 - left) * 100)));
+        const isWeek = at - now > 6 * 3600_000;
+        buckets[id] = { used, resetsAt: q.resetTime, week: isWeek };
+    }
+    // The agent's pair is its least used bucket overall, in that bucket's window (the other stays "-"): a weekly cap on
+    // one model must not read as the whole agent being out.
+    const best = Object.values(buckets).sort((x, y) => x.used - y.used || Number(x.week) - Number(y.week))[0];
+    if (best)
+        Object.assign(best.week ? week : five, { pct: best.used, resetsAt: best.resetsAt });
+    return { five, week, buckets };
+}
+/** One quota line per model, named "<agent>/<model>", with its bucket in the 5h or the week slot and "-" in the other. */
+export function modelLines(name, buckets, now = Date.now(), note) {
+    const out = [];
+    for (const [id, b] of Object.entries(buckets)) {
+        const at = Date.parse(b.resetsAt);
+        if (Number.isNaN(at) || at <= now)
+            continue; // reset since the reading: no figure to stand on
+        const reset = Math.floor(at / 1000);
+        out.push({ name: `${name}/${id}`, five: b.week ? "-" : b.used, week: b.week ? b.used : "-",
+            ...(b.week ? { resetWeek: reset } : { reset5h: reset }), ...(note ? { note } : {}) });
+    }
+    return out;
+}
+/** Learned exhausted buckets (from a run that hit the limit) outlive API readings until their reset, unless the API
+ *  returns that model with something left. The API's own bucket for the model stands in when it also says exhausted. */
+export function mergeLearned(api, learned, now = Date.now()) {
+    const out = { ...api };
+    for (const [id, b] of Object.entries(learned)) {
+        if (!b.learned || Date.parse(b.resetsAt) <= now)
+            continue;
+        const key = modelKey(id, Object.keys(api));
+        if (key && api[key].used < 100)
+            continue; // the API says it has quota again
+        out[id] = b;
+    }
+    return out;
+}
+/** Record that a run found `model` out of quota for `secs` more seconds (best effort; keeps the cached reading). */
+export function learnExhausted(name, model, secs, acct, now = Date.now()) {
+    const at = now + secs * 1000;
+    const b = { used: 100, resetsAt: new Date(at).toISOString(), week: at - now > 6 * 3600_000, learned: true };
+    try {
+        let c = { five: { pct: "-" }, week: { pct: "-" }, at: now };
+        try {
+            c = JSON.parse(readFileSync(cacheFile(name), "utf8"));
         }
+        catch { /* none yet */ }
+        if (acct !== undefined && c.acct !== undefined && c.acct !== acct)
+            c = { five: { pct: "-" }, week: { pct: "-" }, at: now };
+        const buckets = { ...(c.buckets ?? {}), [model]: b };
+        writeAtomic(cacheFile(name), JSON.stringify({ ...c, ...(acct ? { acct } : {}), buckets }));
+    }
+    catch { /* best effort */ }
+    return b;
+}
+/** The per-model buckets of the last good reading, when it was this login's. */
+function cachedBuckets(name, acct) {
+    try {
+        const c = JSON.parse(readFileSync(cacheFile(name), "utf8"));
+        return acct !== undefined && c.acct !== acct ? {} : c.buckets ?? {};
+    }
+    catch {
+        return {};
     }
-    return { five, week };
 }
 export function agyToken() {
     // agy (go-keyring) keeps {"token": {access_token, expiry, ...}} under service "gemini", user "antigravity"
@@ -242,13 +303,17 @@ export async function antigravityQuota() {
     const name = "antigravity";
     const t = agyToken();
     if (!t?.access)
-        return noData(name, m("no agy login in the keyring", "sem login do agy no chaveiro"));
+        return [noData(name, m("no agy login in the keyring", "sem login do agy no chaveiro"))];
     // Never refresh it here (that is agy's login). The access token lives 1h and agy renews it only when it runs, so a
     // passed expiry with a refresh token is just idle (a note, not an expired login); without one, "run agy once".
     const expired = m("login expired: run `agy models`", "login expirado: rode `agy models`");
+    const stale = (why) => {
+        const line = fromCache(name, why, undefined, t.acct);
+        return [line, ...modelLines(name, cachedBuckets(name, t.acct), Date.now(), line.note)];
+    };
     const note = agyNote(t);
     if (note)
-        return fromCache(name, note, undefined, t.acct);
+        return stale(note);
     try {
         const r = await fetch("https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels", {
             method: "POST", body: "{}",
@@ -257,15 +322,16 @@ export async function antigravityQuota() {
             signal: AbortSignal.timeout(15_000),
         });
         if (r.status === 401)
-            return fromCache(name, expired, undefined, t.acct);
+            return stale(expired);
         if (!r.ok)
-            return fromCache(name, `HTTP ${r.status}`, undefined, t.acct);
+            return stale(`HTTP ${r.status}`);
         const j = await r.json();
-        const { five, week } = antigravityFromModels(j.models ?? {});
-        return remember(name, five, week, t.acct);
+        const { five, week, buckets: api } = antigravityFromModels(j.models ?? {});
+        const buckets = mergeLearned(api, cachedBuckets(name, t.acct));
+        return [remember(name, five, week, t.acct, buckets), ...modelLines(name, buckets)];
     }
     catch (e) {
-        return fromCache(name, m("collector failed", "coletor falhou") + `: ${e.message}`, undefined, t.acct);
+        return stale(m("collector failed", "coletor falhou") + `: ${e.message}`);
     }
 }
 // --- copilot --------------------------------------------------------------------------------------------------------
@@ -385,7 +451,7 @@ export async function collect(sources, want = []) {
         if (name === "codex")
             return wanted(name) ? [format(codexQuota())] : [];
         if (name === "antigravity")
-            return wanted(name) ? [format(await antigravityQuota())] : [];
+            return wanted(name) ? (await antigravityQuota()).map(format) : [];
         if (name === "copilot")
             return wanted(name) ? [format(copilotQuota())] : [];
         if (name === "opencode" || name === "minimax")

package/dist/stats.js

@@ -6,6 +6,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
+import { doneStatus } from "./process.js";
 const ROLE = /^(impl|fix\d*|review\d*|[a-z]+-review\d*|watchdog\d*)-?/;
 const read = (f) => { try {
     return readFileSync(f, "utf8");
@@ -120,7 +121,7 @@ export function collectRuns(ws, days) {
                         : name.startsWith("impl") ? "impl" : "other";
             const out = read(`${pre}.out.md`);
             const [neu, tot] = tokens(agent, log, read(`${pre}.id`).trim());
-            runs.push({ issue, name, agent, model, role, ok: read(done).includes("status=ok") && out.trim() !== "",
+            runs.push({ issue, name, agent, model, role, ok: doneStatus(read(done)) === "ok" && out.trim() !== "",
                 secs: Math.max(0, Math.floor((statSync(done).mtimeMs - rs.mtimeMs) / 1000)), new: neu, tot,
                 repo: name.includes("-") ? name.slice(name.indexOf("-") + 1) : "" });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irythill/orq",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Orchestrate coding agents (Claude Code, Codex, OpenCode, Antigravity, Copilot) from one conductor.",
   "license": "MIT",
   "type": "module",
@@ -11,7 +11,8 @@
     "dist",
     "!dist/**/*.test.js",
     "skills",
-    "templates/workspace.CLAUDE.md"
+    "templates/workspace.CLAUDE.md",
+    "templates/conductor.instructions.md"
   ],
   "engines": {
     "node": ">=20"

package/skills/issue/SKILL.md

@@ -1,36 +1,36 @@
 ---
 name: issue
-description: Runs a Plane issue end to end by orchestrating coding agents in herdr or any terminal (herdr-agent / orq agent + orq wait) — implementer and cross-vendor reviewer picked by orq pick, tests by herdr-verify / orq verify, comment and status in Plane. Use when the user says "/issue <ID>", "take issue X", "run ABC-123", or asks to check/create issues in the conductor's ecosystem.
+description: Runs a Plane issue end to end by orchestrating coding agents in herdr or any terminal (orq agent + orq wait) — implementer and cross-vendor reviewer picked by orq pick, tests by orq verify, comment and status in Plane. Use when the user says "/issue <ID>", "take issue X", "run ABC-123", or asks to check/create issues in the conductor's ecosystem.
 ---
 
-# /issue <ID> — conductor playbook (herdr or any terminal)
+# /issue <ID> — conductor playbook
 
 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
-the repositories and their groups (= herdr workspace, `-g`), **each repo's base branch**, verification commands,
+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.
-**Inside herdr** (`HERDR_ENV=1`): children open in herdr tabs and their notices reach your pane — the flow below.
-**Outside herdr** (any terminal, tmux, any OS): the same flow with these swaps —
-- `herdr-agent ...` → `orq agent ...` (same flags; it is the same program). Children run in tmux windows inside tmux,
-  else in the background (their screen goes to a log; the answer is still `<prefix>.out.md`). `-T` needs tmux.
-- `herdr-claim` → `orq claim` (set `ORQ_CONDUCTOR_ID` to a fixed name per conductor), `herdr-deps` → `orq deps`.
-- **Completion signal:** no line arrives in your pane. After dispatching, run `orq wait <prefix>` **as a background
+**Terminal:** the flow is the same in herdr, tmux or a plain terminal, on any OS. Children open in herdr tabs inside
+herdr (`HERDR_ENV=1`), in tmux windows inside tmux, else in the background (their screen goes to a log; the answer is
+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
-  `[ORQ AGENT DONE] <title> status=ok|fail ... answer: <file>` — treat it exactly like `[HERDR-AGENT DONE]`. 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.
-- `herdr-verify` → `orq verify`, `herdr-baseline` → `orq baseline` (same flags). They run in a tmux window or in
-  the background like children, and you wait for them the same way: `orq wait $O/verify-<repo>`.
-- Peeking at a child: `<prefix>.log` (not `herdr pane read`).
+  `[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 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`).
 Issue artifacts (prompts, notes) live in `$WS/.orquestra/<ID>/`.
 
 ## 1. Read the issue
-- **First, claim it:** `herdr-claim -w $WS <ID>`. Exit 1 = another conductor owns it: **stop** and tell the user
+- **First, claim it:** `orq claim -w $WS <ID>`. Exit 1 = another conductor owns it: **stop** and tell the user
   (don't read it, don't dispatch anything). Taking it over (e.g. switching accounts) only with the user's OK:
-  `herdr-claim -w $WS -f <ID>`. Several conductors may share a workspace; `herdr-claim -w $WS -l` lists who has what,
+  `orq claim -w $WS -f <ID>`. Several conductors may share a workspace; `orq claim -w $WS -l` lists who has what,
   with each conductor's name (its herdr workspace label, e.g. "emp: orq-cms-dsgn"; outside herdr, `ORQ_CONDUCTOR_ID`).
 - **The user names another conductor** ("take over orq-cms-dsgn's work"): never guess a pane id. Run
   `orq claim -w $WS --from "<what they said>"` (any part of the name works). It lists that conductor's issues; exit 3 =
@@ -71,19 +71,19 @@ orq pick opinion --impl-agent <agent that implemented>             # second opin
 ```
 More than one agent eligible for `review`/`opinion` (declared, not excluded or blocked, with a model for the role; quota is not considered) and neither `--impl-agent` nor `--impl-vendor` given → exit 2:
 always pass one of them (`--no-record`/`--explain` do not change this).
-The output goes straight into `herdr-agent` (`herdr-agent $(orq pick ...) -g ... -t ... -d ... -o ... -- prompt.md`).
+The output goes straight into `orq agent` (`orq agent $(orq pick ...) -g ... -t ... -d ... -o ... -- prompt.md`).
 - Exit 3 = no candidate (quota exhausted, no agent with that role): **stop and ask the user**.
 - Implementer failed review twice (step 6) → pick again without it: `orq pick impl --level <level> --exclude-agent <agent>`.
 - `--exclude-agent` never "sticks": every `orq pick` call decides again, with only that dispatch's exclusions.
 - The conductor's own model (e.g. Opus) as implementer: only with the user's OK, never through `orq pick`.
 - Want to understand a choice? `orq pick ... --explain --no-record` (score of each candidate; not counted in rotation).
 
-**Every child runs through `herdr-agent`** (agent from `orq pick`): headless (`claude -p` / `codex exec` /
-`opencode run` / `agy -p` / `copilot -p`) in a herdr tab (workspace = group `-g`, tab = title) with live output.
-When it finishes it writes `<prefix>.done` and sends ONE line `[HERDR-AGENT DONE] <title> status=ok|fail ...` to your
-pane; no MCP, and a **4 GB memory cap per agent** (own cgroup: if it blows up, only it dies). NEVER `herdr agent start`
+**Every child runs through `orq agent`** (agent from `orq pick`): headless (`claude -p` / `codex exec` /
+`opencode run` / `agy -p` / `copilot -p`) in a herdr tab (workspace = group `-g`, tab = title), a tmux window or the
+background, with a log. When it finishes it writes `<prefix>.done` and signals you (see the completion signal above:
+`[HERDR-AGENT DONE] <title> status=ok|fail ...` in herdr, `orq wait` elsewhere); no MCP, and a **4 GB memory cap per agent** (own cgroup: if it blows up, only it dies). NEVER `herdr agent start`
 for children (no memory cap, no answer file). **Screen mode (`-T`, or `HERDR_AGENT_TUI=1`; herdr or tmux):** the tab
-shows the agent's own TUI instead of the log; same cap, same files, same signal (end-of-turn hook). The screen stays
+or window shows the agent's own TUI instead of the log; same cap, same files, same signal (end-of-turn hook). The screen stays
 open after the turn (it holds memory until the tab closes); `-R` with the tab open types the follow-up into it. Use it
 when the user wants to watch. The repo must already be trusted in Codex/Claude (otherwise the TUI stops at the "trust this
 folder?" dialog — tell the user, don't approve it for them).
@@ -115,7 +115,7 @@ git -C $WT log -1 --format='%h %s'                    # check HEAD == origin/$BA
 on a modest disk that saturates I/O and memory and freezes the machine). The worktree uses a **link** to the main
 repo's `node_modules`:
 ```bash
-herdr-deps -r $R -b $BASE -w $WT     # link; stale deps → fast-forward + ONE install in $R (per-repo lock across conductors)
+orq deps -r $R -b $BASE -w $WT     # link; stale deps → fast-forward + ONE install in $R (per-repo lock across conductors)
 ```
 Exit 3 = stale deps and `$R` dirty or not on `$BASE` → **ask the user**. If another conductor is installing in the
 same repo, the command waits its turn (never install by hand).
@@ -124,39 +124,39 @@ tell me".
 **Dispatch** (no MCP; memory cap; writes in automatic mode — that is why implementation only happens in a worktree):
 ```bash
 orq pick impl --level <level> > $O/impl-<repo>.pick    # the fix rounds reuse it (step 6)
-herdr-agent $(cat $O/impl-<repo>.pick) -g <group> -t "<ID> impl <repo>" -d $WT -o $O/impl-<repo> -- $O/impl-<repo>.md
+orq agent $(cat $O/impl-<repo>.pick) -g <group> -t "<ID> impl <repo>" -d $WT -o $O/impl-<repo> -- $O/impl-<repo>.md
 ```
 - The Claude account (`-c`) already comes from `orq pick` (one under the limit whose pace stays within it, then the least used).
 - Full final answer in `$O/impl-<repo>.out.md`; log in `.log`; the agent's session id in `.id`.
 - Codex's sandbox has no network: `git fetch` is yours, beforehand (above). Push/PR: yours (step 7).
-- `herdr-agent` returns immediately (no need to background it); the child's pane is in `<prefix>.pane`
-  (`herdr pane read $(cat <prefix>.pane) --source recent` to peek).
-- **No baseline in the issue flow:** don't run `herdr-baseline` before dispatching (the base moves with every merge and
-  the full suite blocks every conductor's test queue). `herdr-verify` checks the base on demand (step 4b).
+- `orq agent` returns immediately (no need to background it); the child's pane is in `<prefix>.pane`
+  (to peek: `<prefix>.log`; in herdr, `herdr pane read $(cat <prefix>.pane) --source recent`).
+- **No baseline in the issue flow:** don't run `orq baseline` before dispatching (the base moves with every merge and
+  the full suite blocks every conductor's test queue). `orq verify` checks the base on demand (step 4b).
 - **Children start WITHOUT MCP** (Plane is yours; each MCP costs ~150–200 MB per session and `systemd-oomd` kills the
-  whole herdr server when memory runs out) — `herdr-agent` takes care of it.
+  whole herdr server when memory runs out) — `orq agent` takes care of it.
 - 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
   "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 `herdr-baseline` if the user asks).
+  Full suite only in CI (or a manual `orq baseline` if the user asks).
 - An issue that changes an API contract: **API first**; consumers afterwards, with the new contract in the prompt.
 - **A red board line / `✗` pane title = a failure you may have missed.** If you see one (or the user says notices aren't
   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. Dispatch, report in one line and end your turn. "Done yet?" = `<prefix>.done`
+  `[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`
   exists (never `pgrep`).
-- Investigation only (no code): "READ ONLY" prompt, in the repo itself, no worktree. `herdr-agent -r` (Claude:
+- 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).
 
 ## 4b. Tests (yours, not the child's)
 Child with `status=ok` → run the tests related to the diff, in their own tab, one at a time on the machine (queue):
-`herdr-verify -w $WS -r <repo> -d $WT -b <BASE> -o $O/verify-<repo> -g <group>` → `$O/verify-<repo>.txt` with
+`orq verify -w $WS -r <repo> -d $WT -b <BASE> -o $O/verify-<repo> -g <group>` → `$O/verify-<repo>.txt` with
 **new failures** and pre-existing ones: if any test fails, it runs the same test files on an updated
-`origin/<BASE>` (whatever fails there is pre-existing). You get `[HERDR-AGENT DONE] verify ... new=N`.
+`origin/<BASE>` (whatever fails there is pre-existing). You get the done line (`[HERDR-AGENT DONE]` / `[ORQ AGENT DONE]`) `verify ... new=N`.
 `new>0` → fix round with the list (step 6), no review. `new=0` → review.
 **Pre-existing failures get fixed too.** Any failure — tests listed as "already failing on origin/<BASE>", or a CI job
 (lint, biome, typecheck, shard, regression) failing on the PR or on the base — goes into a fix round on the issue's
@@ -165,12 +165,12 @@ 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
-`[HERDR-AGENT DONE] ... verify ...` and end your turn until then.
+the `... verify ...` done line and end your turn until then.
 
 ## 5. Cross review (always another vendor)
 ```bash
 orq pick review --level <level> --impl-agent <who implemented> > $O/review-<repo>.pick   # round 2+ reuses it
-herdr-agent $(cat $O/review-<repo>.pick) -b $BASE \
+orq agent $(cat $O/review-<repo>.pick) -b $BASE \
   -g <group> -t "<ID> review <repo>" -d $WT -o $O/review-<repo> -r -i $O/impl-<repo>.md -i $O/impl-<repo>.out.md \
   -i $O/verify-<repo>.txt \
   -- $O/review-<repo>.md
@@ -211,7 +211,7 @@ repo checklist.
 only restates a `## Decisions` choice, counts as a suggestion; when you downgrade one, say why in the Plane comment.
 No blockers left → APPROVED, even with suggestions.
 Blocking problems → write the list (blockers only) to `$O/fix-<n>.md` (always this name; reviews `$O/review-<repo>-<n>`, never `fix<n>-<repo>` or other variants — a later conductor counts rounds by these files) and continue the implementer's session (any agent):
-`herdr-agent $(orq pick fix --same $O/impl-<repo>.pick) -g <group> -t "<ID> fix<n> <repo>" -d $WT -o $O/impl-<repo> -R $(cat $O/impl-<repo>.id) -- $O/fix-<n>.md`.
+`orq agent $(orq pick fix --same $O/impl-<repo>.pick) -g <group> -t "<ID> fix<n> <repo>" -d $WT -o $O/impl-<repo> -R $(cat $O/impl-<repo>.id) -- $O/fix-<n>.md`.
 A fix is a continuation: same agent, model, account and session, effort one level up (`--same` reads the implementer's
 pick; never a new `orq pick`, never `-a` alone — without `-m` the session resumes on the CLI's default model, which
 loses the prompt cache and hands the work to a weaker model). `fix-<n>.md` = the numbered blockers + these rules: "fix only
@@ -219,7 +219,7 @@ these items, with the smallest diff that does it; don't refactor, rename or refo
 each blocker add or adjust a test that fails without the fix, when the code is testable (say so when it isn't); if an
 item is wrong or conflicts with a criterion, don't fix it: say why"; and it ends with "update the `## Decisions`
 section of your final answer for the whole branch". **Before dispatching the fix:** `git -C $WT rev-parse HEAD > $O/round-<n>.sha`.
-Then a new `herdr-verify` (4b) and the **round review** (step 5 with these changes):
+Then a new `orq verify` (4b) and the **round review** (step 5 with these changes):
 - Same reviewer as the round before: `$(cat $O/review-<repo>.pick)`. Only if it is over quota, blocked or fails with
   no verdict → a new `orq pick review` (saved to the same file).
 - Extra attachments: `git -C $WT diff $(cat $O/round-<n>.sha)..HEAD > $O/fix-<n>.diff` → `-i $O/fix-<n>.md -i $O/fix-<n>.diff`
@@ -258,9 +258,9 @@ rules live) commits and writes the PR. Find and cite in the prompt, by path, wha
   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.
-- Move it to **In Review** (finished child tabs close by themselves; close any leftover with
+- Move it to **In Review** (finished child tabs close by themselves; in herdr, close any leftover with
   `herdr tab list | jq -r '.result.tabs[]|select(.label|startswith("<ID> "))|.tab_id' | xargs -rn1 herdr tab close`)
-  and **release the issue**: `herdr-claim -w $WS -r <ID>`. The worktree stays until the merge.
+  and **release the issue**: `orq claim -w $WS -r <ID>`. The worktree stays until the merge.
 - **After the merge** (when the user confirms): run `orq gc -w $WS` and show the list. If this issue's worktree is
   listed as removable, run `orq gc -w $WS --yes`; anything else → ask the user.
 - **Never** push, PR, merge or deploy unless the user asks. Report to the user in 3–5 lines.

package/templates/conductor.instructions.md

@@ -0,0 +1,31 @@
+# Conductor "{{NAME}}" — {{NAME}} ecosystem
+
+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.
+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.
+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).
+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/`.
+
+## How you are used
+- **Dispatcher, not consultant.** Your job: issue → dispatch → report → PR/cleanup. Long questions about architecture,
+  infrastructure (DNS, email, deploy, webhooks) or business decisions: answer in at most 3 lines and suggest "take it
+  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
+  `.orquestra/`).
+- 1–3 line answers. Final issue report: 3–5 lines + the PR link.

package/templates/workspace.CLAUDE.md

@@ -5,11 +5,12 @@ rules — read the repo's own before touching it. This file only holds the map a
 
 ## Orchestration (read by the `/issue` skill)
 - **Workspace:** `{{WORKSPACE}}`
-- **Conductor (herdr):** opened with `herdr-conductor [account] [model] [-r <session-id>]` in a herdr pane, in this folder
-  (instructions in `.orquestra-conductor.md`); the **Group** in the table below is the herdr workspace (`-g`).
-  Tests from the Verification column (jest/vitest) **don't run in the child**: the conductor runs `herdr-verify` (`orq verify`
-  outside herdr; one at a time on the machine); the child does lint + `tsc` (`NODE_OPTIONS=--max-old-space-size=2048`).
-- **Agents:** chosen by `orq-pick` from each developer's `~/.config/orq/config.toml` — nothing about models here.
+- **Conductor:** opened with `orq conductor [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`
+  (one at a time on the machine); the child does lint + `tsc` (`NODE_OPTIONS=--max-old-space-size=2048`).
+- **Agents:** chosen by `orq pick` from each developer's `~/.config/orq/config.toml` — nothing about models here.
 
 ## Scope
 - Before dispatching, split big issues into sub-issues or sequential batches (one PR, one implementer each) when they touch