@irythill/orq 0.1.0 → 0.2.0

package/dist/commands/completion.js

@@ -11,7 +11,7 @@ const DESC = {
     quota: "quota per agent/account", pick: "pick agent, model and account for a role", stats: "scoreboard per agent",
     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", claim: "issue owner among conductors", deps: "link node_modules into a worktree",
+    instructions: "write the /issue playbook", claim: "issue owner among conductors", deps: "link node_modules into a worktree", gc: "remove merged issue worktrees",
     block: "block an agent or account", completion: "shell completion script",
 };
 /** Fixed words after a subcommand. */
@@ -27,52 +27,52 @@ export function script(shell, cmds) {
     const all = cmds.join(" ");
     const cases = (fmt) => Object.entries(WORDS).filter(([c]) => cmds.includes(c)).map(([c, w]) => fmt(c, w.join(" "))).join("\n");
     switch (shell) {
-        case "bash": return `# orq completion (bash): eval "$(orq completion bash)" in ~/.bashrc
-_orq() {
-  local cur=\${COMP_WORDS[COMP_CWORD]}
-  if [ "$COMP_CWORD" -eq 1 ]; then COMPREPLY=($(compgen -W "${all}" -- "$cur")); return; fi
-  [ "$COMP_CWORD" -eq 2 ] || return
-  case \${COMP_WORDS[1]} in
-${cases((c, w) => `    ${c}) COMPREPLY=($(compgen -W "${w}" -- "$cur")) ;;`)}
-  esac
-}
-complete -o default -F _orq orq
+        case "bash": return `# orq completion (bash): eval "$(orq completion bash)" in ~/.bashrc
+_orq() {
+  local cur=\${COMP_WORDS[COMP_CWORD]}
+  if [ "$COMP_CWORD" -eq 1 ]; then COMPREPLY=($(compgen -W "${all}" -- "$cur")); return; fi
+  [ "$COMP_CWORD" -eq 2 ] || return
+  case \${COMP_WORDS[1]} in
+${cases((c, w) => `    ${c}) COMPREPLY=($(compgen -W "${w}" -- "$cur")) ;;`)}
+  esac
+}
+complete -o default -F _orq orq
 `;
-        case "zsh": return `# orq completion (zsh): eval "$(orq completion zsh)" in ~/.zshrc, after compinit
-_orq() {
-  if (( CURRENT == 2 )); then compadd -- ${all}; return; fi
-  if (( CURRENT == 3 )); then
-    case $words[2] in
-${cases((c, w) => `      ${c}) compadd -- ${w}; return ;;`)}
-    esac
-  fi
-  _files
-}
-compdef _orq orq
+        case "zsh": return `# orq completion (zsh): eval "$(orq completion zsh)" in ~/.zshrc, after compinit
+_orq() {
+  if (( CURRENT == 2 )); then compadd -- ${all}; return; fi
+  if (( CURRENT == 3 )); then
+    case $words[2] in
+${cases((c, w) => `      ${c}) compadd -- ${w}; return ;;`)}
+    esac
+  fi
+  _files
+}
+compdef _orq orq
 `;
-        case "fish": return `# orq completion (fish): orq completion fish > ~/.config/fish/completions/orq.fish
-complete -c orq -f -n __fish_use_subcommand
-${cmds.map((c) => `complete -c orq -n __fish_use_subcommand -a ${c}${DESC[c] ? ` -d ${qf(DESC[c])}` : ""}`).join("\n")}
-${cases((c, w) => `complete -c orq -n "__fish_seen_subcommand_from ${c}" -a ${qf(w)}`)}
+        case "fish": return `# orq completion (fish): orq completion fish > ~/.config/fish/completions/orq.fish
+complete -c orq -f -n __fish_use_subcommand
+${cmds.map((c) => `complete -c orq -n __fish_use_subcommand -a ${c}${DESC[c] ? ` -d ${qf(DESC[c])}` : ""}`).join("\n")}
+${cases((c, w) => `complete -c orq -n "__fish_seen_subcommand_from ${c}" -a ${qf(w)}`)}
 `;
         case "powershell":
-        case "pwsh": return `# orq completion (PowerShell): add to $PROFILE:  orq completion powershell | Out-String | Invoke-Expression
-Register-ArgumentCompleter -Native -CommandName orq -ScriptBlock {
-  param($word, $ast, $cursor)
-  $w = @($ast.CommandElements | ForEach-Object { $_.ToString() })
-  $n = $w.Count; if ($word -ne '') { $n-- }
-  $words = @{
-${Object.entries(WORDS).filter(([c]) => cmds.includes(c)).map(([c, w]) => `    ${q(c)} = @(${w.map(q).join(", ")})`).join("\n")}
-  }
-  $desc = @{
-${cmds.map((c) => `    ${q(c)} = ${q(DESC[c] ?? c)}`).join("\n")}
-  }
-  if ($n -eq 1) { $list = @(${cmds.map(q).join(", ")}) } elseif ($n -eq 2 -and $words.ContainsKey($w[1])) { $list = $words[$w[1]] } else { return }
-  $list | Where-Object { $_ -like "$word*" } | ForEach-Object {
-    $tip = if ($n -eq 1) { $desc[$_] } else { $_ }
-    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $tip)
-  }
-}
+        case "pwsh": return `# orq completion (PowerShell): add to $PROFILE:  orq completion powershell | Out-String | Invoke-Expression
+Register-ArgumentCompleter -Native -CommandName orq -ScriptBlock {
+  param($word, $ast, $cursor)
+  $w = @($ast.CommandElements | ForEach-Object { $_.ToString() })
+  $n = $w.Count; if ($word -ne '') { $n-- }
+  $words = @{
+${Object.entries(WORDS).filter(([c]) => cmds.includes(c)).map(([c, w]) => `    ${q(c)} = @(${w.map(q).join(", ")})`).join("\n")}
+  }
+  $desc = @{
+${cmds.map((c) => `    ${q(c)} = ${q(DESC[c] ?? c)}`).join("\n")}
+  }
+  if ($n -eq 1) { $list = @(${cmds.map(q).join(", ")}) } elseif ($n -eq 2 -and $words.ContainsKey($w[1])) { $list = $words[$w[1]] } else { return }
+  $list | Where-Object { $_ -like "$word*" } | ForEach-Object {
+    $tip = if ($n -eq 1) { $desc[$_] } else { $_ }
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $tip)
+  }
+}
 `;
         default: return undefined;
     }

package/dist/commands/config.js

@@ -5,8 +5,8 @@
 import { getPath, loadConfig } from "../config.js";
 import { expand } from "../paths.js";
 import { m } from "../i18n.js";
-export const USAGE = `orq config [-w <workspace>]                 everything, as JSON
-orq config [-w <workspace>] get <a.b.c>     one value (plain text if scalar; JSON if object/list)
+export const USAGE = `orq config [-w <workspace>]                 everything, as JSON
+orq config [-w <workspace>] get <a.b.c>     one value (plain text if scalar; JSON if object/list)
 orq config [-w <workspace>] files           which files were read`;
 export function config(argv) {
     let ws;

package/dist/commands/gc.js

@@ -0,0 +1,164 @@
+// orq gc — find issue worktrees whose branch is already safe to remove.
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
+import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { loadConfig } from "../config.js";
+import { m } from "../i18n.js";
+import { aliveOwner } from "./claim.js";
+export const USAGE = "orq gc [-w <workspace>] [--yes] [--days N] [--json]   remove merged issue worktrees";
+const git = (cwd, ...args) => spawnSync("git", ["-C", cwd, ...args], { encoding: "utf8" });
+// Paths as git prints them can differ from ours (macOS /var → /private/var, Windows C:/ vs C:\): compare real paths.
+const real = (p) => { try {
+    return realpathSync.native(p);
+}
+catch {
+    return resolve(p);
+} };
+const inside = (dir, p) => { const r = relative(dir, p); return !!r && !r.startsWith("..") && !isAbsolute(r); };
+// ORQ_GH may be a .js file (tests: a fake gh that also runs on Windows).
+const gh = (cwd, args) => {
+    const bin = process.env.ORQ_GH || "gh";
+    return bin.endsWith(".js") ? spawnSync(process.execPath, [bin, ...args], { cwd, encoding: "utf8" })
+        : spawnSync(bin, args, { cwd, encoding: "utf8" });
+};
+const output = (cwd, ...args) => { const r = git(cwd, ...args); return r.status === 0 ? r.stdout.trim() : undefined; };
+export async function gc(argv, clock = Date.now) {
+    let ws = process.cwd(), yes = false, json = false, days = 14;
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "-w" && argv[i + 1])
+            ws = resolve(argv[++i]);
+        else if (argv[i] === "--yes")
+            yes = true;
+        else if (argv[i] === "--json")
+            json = true;
+        else if (argv[i] === "--days" && argv[i + 1] && /^\d+$/.test(argv[i + 1]))
+            days = Number(argv[++i]);
+        else {
+            console.error(USAGE);
+            return 2;
+        }
+    }
+    const { cfg } = loadConfig(ws), rows = [];
+    let ghUnavailable = false, fetchWarned = false;
+    const root = join(ws, ".worktrees");
+    const orq = join(ws, ".orquestra");
+    const issues = existsSync(orq) ? readdirSync(orq) : [];
+    for (const repoName of readdirSync(ws, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name)) {
+        const repo = join(ws, repoName);
+        if (!existsSync(join(repo, ".git")))
+            continue;
+        const listings = output(repo, "worktree", "list", "--porcelain");
+        if (listings === undefined)
+            continue;
+        const worktrees = listings.split(/\n\n/).map((block) => Object.fromEntries(block.split("\n").map((line) => {
+            const i = line.indexOf(" ");
+            return [i < 0 ? line : line.slice(0, i), i < 0 ? "" : line.slice(i + 1)];
+        })));
+        const main = real(worktrees[0]?.worktree ?? repo);
+        const conf = cfg.repos?.[repoName];
+        const head = output(repo, "symbolic-ref", "refs/remotes/origin/HEAD")?.replace("refs/remotes/", "");
+        const prod = conf?.prod_ref || head || "origin/main";
+        const fetchRef = prod.replace(/^origin\//, "");
+        if (git(repo, "fetch", "origin", fetchRef).status !== 0 && !fetchWarned) {
+            console.error(m("WARNING: git fetch failed; using local refs", "AVISO: git fetch falhou; usando as refs locais"));
+            fetchWarned = true;
+        }
+        const prodTree = output(repo, "rev-parse", `${prod}^{tree}`);
+        for (const wt of worktrees) {
+            const path = real(wt.worktree ?? "");
+            if (!wt.worktree || path === main || !inside(real(root), path))
+                continue;
+            const branch = wt.branch?.replace(/^refs\/heads\//, "") ?? "";
+            if (!branch)
+                continue;
+            // The branch carries the ID in lowercase (plane-abc-123); .orquestra/ keeps it as written (ABC-123).
+            const id = /^.*?plane-(.+)$/.exec(branch)?.[1];
+            const issue = id && issues.find((d) => d.toLowerCase() === id.toLowerCase());
+            const status = output(path, "status", "--porcelain");
+            const unpushed = output(repo, "rev-list", branch, "--not", "--remotes");
+            let reason = "", verdict = "REMOVABLE";
+            if (status) {
+                verdict = "KEEP";
+                reason = m("uncommitted changes", "alterações não commitadas");
+            }
+            const ownerFile = issue && join(ws, ".orquestra", issue, "owner");
+            if (verdict !== "KEEP" && ownerFile && existsSync(ownerFile) && aliveOwner(readFileSync(ownerFile, "utf8"))) {
+                verdict = "KEEP";
+                reason = m("issue has a live owner", "issue tem um responsável ativo");
+            }
+            // A .pane/.id without a same-stem .done is treated as a running child.
+            const issueDir = issue && join(ws, ".orquestra", issue);
+            if (verdict !== "KEEP" && issueDir && existsSync(issueDir)) {
+                const files = readdirSync(issueDir), running = files.some((f) => /\.(pane|id)$/.test(f) && !existsSync(join(issueDir, `${f.replace(/\.(pane|id)$/, "")}.done`)));
+                if (running) {
+                    verdict = "KEEP";
+                    reason = m("child agent may still be running", "um agente filho pode estar em execução");
+                }
+            }
+            let merged = false;
+            if (verdict !== "KEEP") {
+                // Merged counts only if the PR's head is the local head: a commit made after the merge must not be lost.
+                const pr = gh(repo, ["pr", "list", "--head", branch, "--state", "merged", "--json", "number,headRefOid", "--limit", "1"]);
+                const local = output(repo, "rev-parse", branch);
+                if (pr.status === 0) {
+                    try {
+                        const p = JSON.parse(pr.stdout)[0];
+                        merged = !!p && (!p.headRefOid || p.headRefOid === local);
+                    }
+                    catch {
+                        ghUnavailable = true;
+                    }
+                }
+                else
+                    ghUnavailable = true;
+            }
+            const inBase = verdict !== "KEEP" && !!prodTree && output(repo, "merge-tree", "--write-tree", prod, branch) === prodTree;
+            if (verdict !== "KEEP" && unpushed && !merged && !inBase) {
+                verdict = "KEEP";
+                reason = m("commits not contained in remote refs", "commits fora das refs remotas");
+            }
+            else if (verdict !== "KEEP" && (merged || inBase)) {
+                verdict = "REMOVABLE";
+                reason = merged ? "PR merged" : m("content is in base", "conteúdo já está na base");
+            }
+            else if (verdict !== "KEEP") {
+                const closed = gh(repo, ["pr", "list", "--head", branch, "--state", "closed", "--json", "number", "--limit", "1"]);
+                const isClosed = closed?.status === 0 && (() => { try {
+                    return JSON.parse(closed.stdout).length > 0;
+                }
+                catch {
+                    return false;
+                } })();
+                const commit = output(repo, "log", "-1", "--format=%ct", branch), old = commit !== undefined && clock() - Number(commit) * 1000 > days * 86400_000;
+                verdict = "STALE";
+                reason = isClosed ? m("PR closed without merge", "PR fechada sem merge") : old ? m(`last commit is older than ${days} days`, `último commit tem mais de ${days} dias`) : m("not merged", "não integrado");
+            }
+            rows.push({ repo: repoName, worktree: basename(path), branch, verdict, reason, path });
+        }
+    }
+    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");
+        }
+    if (json)
+        console.log(JSON.stringify(rows));
+    else {
+        const table = [["REPO", "WORKTREE", "BRANCH", "VERDICT", "REASON"], ...rows.map((r) => [r.repo, r.worktree, r.branch, r.verdict, r.reason])];
+        const w = table[0].map((_, i) => Math.max(...table.map((t) => t[i].length)));
+        console.log(table.map((t) => t.map((c, i) => i < t.length - 1 ? c.padEnd(w[i]) : c).join("  ")).join("\n"));
+    }
+    return failed ? 1 : 0;
+}

package/dist/commands/instructions.js

@@ -15,13 +15,13 @@ const END = "<!-- orq:issue end -->";
 /** The playbook for harnesses without skills: no frontmatter, a trigger line, and how to wait without background tasks. */
 export function agentsBlock(skill) {
     const body = skill.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
-    return `${BEGIN}
-When the user says "/issue <ID>", "take issue X" or "run ABC-123", follow this playbook.
-If your harness cannot run a command in the background, wait for children with \`orq wait\` in the foreground
-(\`orq wait --any <prefix>...\`): it is the one allowed blocking wait.
-
-${body}
-${END}
+    return `${BEGIN}
+When the user says "/issue <ID>", "take issue X" or "run ABC-123", follow this playbook.
+If your harness cannot run a command in the background, wait for children with \`orq wait\` in the foreground
+(\`orq wait --any <prefix>...\`): it is the one allowed blocking wait.
+
+${body}
+${END}
 `;
 }
 /** Put the block into an existing AGENTS.md text: replace ours, or append it. */

package/dist/commands/lock.js

@@ -7,7 +7,7 @@ import { spawnSync } from "node:child_process";
 import { getPath, loadConfig } from "../config.js";
 import { m } from "../i18n.js";
 import { acquire, release, status } from "../lock.js";
-export const USAGE = `orq lock wait|release <name> [--pid P] [--label text]   test queue (slots = machine.test_slots)
+export const USAGE = `orq lock wait|release <name> [--pid P] [--label text]   test queue (slots = machine.test_slots)
 orq lock run <name> [--label text] -- <cmd>...  ·  orq lock status [<name>] [--json]`;
 const slots = () => Number(getPath(loadConfig().cfg, "machine.test_slots") ?? 1);
 const since = (at) => `${Math.round((Date.now() - at) / 1000)}s`;

package/dist/commands/pick.js

@@ -1,19 +1,21 @@
 // orq pick — agent, model, effort and account for a role, from [roles] (fixed or auto), the history, quota and blocks.
 // Prints the runner arguments (e.g. `-a codex -m gpt-6-sol -e low -c work`); each pick is recorded in
 // <state dir>/picks.jsonl (that feeds rotation). Exit 3 = no candidate: ask the user.
+// `orq pick fix --same <file>`: the implementer's saved pick, effort one level up (no choice, nothing recorded).
 import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { loadConfig } from "../config.js";
 import { m } from "../i18n.js";
-import { asArgs, parseQuota, pick as choose } from "../pick.js";
+import { asArgs, escalate, parseQuota, pick as choose } from "../pick.js";
 import { expand, stateDir } from "../paths.js";
 import { collect } from "../quota.js";
 import { PICK_ROLES, vendorOf } from "../roles.js";
 import { collectRuns, rows } from "../stats.js";
 import { load as loadBlocks } from "./block.js";
-export const USAGE = `orq pick <impl|fix|worker|review|opinion> [--level simple|medium|heavy] [--impl-vendor <v>|--impl-agent <a>]
-         [--exclude-agent <a>]... [-w <workspace>] [--explain] [--no-record]`;
+export const USAGE = `orq pick <impl|fix|worker|review|opinion> [--level simple|medium|heavy] [--impl-vendor <v>|--impl-agent <a>]
+         [--exclude-agent <a>]... [-w <workspace>] [--explain] [--no-record]
+orq pick fix --same <impl pick file>   same agent/model/account as the implementer, effort one level up`;
 // The board refreshes this file; fresher than 10 min → no new quota requests.
 const QCACHE = join(process.env.XDG_RUNTIME_DIR ?? tmpdir(), "herdr-board.quota");
 async function quotaText(cfg) {
@@ -27,6 +29,24 @@ export async function pick(argv) {
         console.error(USAGE);
         return 2;
     }
+    if (role === "fix" && argv[1] === "--same") {
+        const f = argv[2];
+        if (!f || argv.length > 3) {
+            console.error(USAGE);
+            return 2;
+        }
+        if (!existsSync(f)) {
+            console.error(`orq pick: ${m("no such file: ", "arquivo não existe: ")}${f}`);
+            return 2;
+        }
+        const prev = readFileSync(f, "utf8").trim();
+        if (!/(^|\s)-a \S/.test(prev)) {
+            console.error(`orq pick: ${m("not a pick: ", "não é um pick: ")}${f}`);
+            return 2;
+        }
+        console.log(escalate(prev));
+        return 0;
+    }
     let level = "medium", implVendor, implAgent, ws;
     let explain = false, record = true;
     const exclude = new Set();

package/dist/commands/quota.js

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

package/dist/commands/setup.js

@@ -18,7 +18,7 @@ import { m } from "../i18n.js";
 import { environment, installSkills, prepareWorkspace } from "../install.js";
 import { expand, userConfigFile } from "../paths.js";
 import { suggestRoles, toToml } from "../suggest.js";
-export const USAGE = `orq setup [--preset economy|quality|single-agent]   guided first configuration (roles, weights, memory)
+export const USAGE = `orq setup [--preset economy|quality|single-agent]   guided first configuration (roles, weights, memory)
 orq setup --detect | --answers <file|-> [--write] | --install | --workspace <dir> [--conductor <agent>]`;
 /** Agent name → its CLI and a cheap headless smoke test. */
 const CLIS = {
@@ -139,8 +139,8 @@ function workspace(dir, conductor) {
     for (const l of prepareWorkspace(d, c === "claude" ? "claude" : "agents"))
         console.log(l);
 }
-const next = () => console.log(m(`Next: fill in the workspace CLAUDE.md, open your conductor in that folder and say "/issue <ID>".
-Board: orq board · quota: orq quota · completion: orq completion <shell>`, `Próximo: preencha o CLAUDE.md do workspace, abra o seu conductor nessa pasta e diga "/issue <ID>".
+const next = () => console.log(m(`Next: fill in the workspace CLAUDE.md, open your conductor in that folder and say "/issue <ID>".
+Board: orq board · quota: orq quota · completion: orq completion <shell>`, `Próximo: preencha o CLAUDE.md do workspace, abra o seu conductor nessa pasta e diga "/issue <ID>".
 Painel: orq board · cota: orq quota · autocompletar: orq completion <shell>`));
 export async function setup(argv) {
     let preset, answers, doWrite = false, ws, conductor;

package/dist/config.js

@@ -27,7 +27,7 @@ export const DEFAULTS = {
     ui: { lang: "auto", theme: "gunmetal" }, // lang: auto | en | pt · theme: gunmetal | chrome | lcd | terminal
     // Where quota comes from, per agent: "builtin" | "none" | false | { command = "..." } (see src/quota.ts).
     // "claude" covers every account in claude-accounts.
-    quota: { claude: "builtin", codex: "builtin", opencode: "none", antigravity: "builtin", copilot: "builtin" },
+    quota: { claude: "builtin", codex: "builtin", opencode: "builtin", antigravity: "builtin", copilot: "builtin" },
     tracker: { kind: "none" }, // plane | none
     repos: {}, // defined by the workspace
 };

package/dist/pick.js

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

package/dist/quota.js

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