@irythill/orq 0.4.0 → 0.6.0

package/dist/commands/agent.js

@@ -2,7 +2,7 @@
 // under its memory cap (src/process.ts), in a herdr tab, a tmux window or the background (src/terminal.ts).
 // Writes <prefix>.out.md (final answer) / .log / .id (session, for -R) / .pane / .done ("status=ok|fail rc=N at=...").
 // Returns at once; `orq wait <prefix>` blocks until .done. A conductor in herdr (HERDR_PANE_ID) also gets ONE line
-// "[HERDR-AGENT DONE] <title> status=... answer: <prefix>.out.md" typed into its pane by herdr-notify.
+// "[HERDR-AGENT DONE] <title> status=... answer: <prefix>.out.md" typed into its pane by src/notice.ts.
 // The launcher writes <prefix>.job.json and starts `orq agent --run <job>` on the terminal host; that runner does the rest.
 // -T (or machine.tui / HERDR_AGENT_TUI=1): the agent's own screen (its `tui` template) in a herdr tab or tmux window,
 // same cap and files. The agent calls `orq agent --turn <job> <kind>` at every end of turn, which writes .out.md/.id/
@@ -10,20 +10,22 @@
 // the follow-up into it; with the screen closed it reopens the session (tui_resume).
 import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { appendFileSync, copyFileSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, copyFileSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { claudeAccounts } from "../accounts.js";
-import { agentDef, ALIASES, expandString, expandTemplate, FORMATS } from "../agents.js";
+import { gateFor } from "../diagnose.js";
+import { argvModel, useThrowaway, agentDef, ALIASES, expandString, expandTemplate, FORMATS } from "../agents.js";
 import { getPath, loadConfig } from "../config.js";
 import { writeAtomic } from "../fsutil.js";
 import { m } from "../i18n.js";
 import { alive } from "../lock.js";
 import { stateDir } from "../paths.js";
-import { killTree, parseSize, resolveMode, runCapped } from "../process.js";
+import { killedRc, killTree, parseSize, resolveMode, runCapped } from "../process.js";
 import { closeOwnTab, detectHost, launch, screenOpen, shq, typeInto } from "../terminal.js";
+import { ackPrefix } from "../notice.js";
 import { dropWorktree, notify } from "../testrun.js";
-export const USAGE = "orq agent -a <agent> -t <title> -d <dir> -o <prefix> [-g group] [-m model] [-e effort] [-c account] [-i file]... [-b base] [-r] [-R session [-F]] [-T] -- <prompt.md>   run a child agent";
+export const USAGE = "orq agent -a <agent> -t <title> -d <dir> -o <prefix> [-g group] [-m model] [-e effort] [-c account] [-i file]... [-b base] [-r] [-R session [-F [-F]]] [-T] -- <prompt.md>   run a child agent";
 const CLI = fileURLToPath(new URL("../cli.js", import.meta.url));
 const PF = ".herdr-agent-prompt.md"; // prompt_in_dir file name (kept from herdr-agent)
 const git = (dir, ...a) => {
@@ -35,8 +37,8 @@ export async function agent(argv) {
         return runJob(argv[1]);
     if (argv[0] === "--turn")
         return turn(argv[1], argv[2], argv.slice(3));
-    let a = process.env.AGENT || "codex", g = "", t = "", d = "", o = "", model = "", effort = "", acc = "", resume = "", base = "";
-    let ro = false, tui = false, force = false, prompt;
+    let a = process.env.AGENT || "", g = "", t = "", d = "", o = "", model = "", effort = "", acc = "", resume = "", base = "";
+    let ro = false, tui = false, force = 0, prompt;
     const inc = [];
     for (let i = 0; i < argv.length; i++) {
         const x = argv[i], v = () => argv[++i] ?? "";
@@ -73,7 +75,7 @@ export async function agent(argv) {
         else if (x === "-T")
             tui = true;
         else if (x === "-F")
-            force = true;
+            force++;
         else if (!x.startsWith("-") && prompt === undefined)
             prompt = x;
         else {
@@ -90,6 +92,11 @@ export async function agent(argv) {
             console.error(`${m("missing", "faltou")} -${f}`);
             return 2;
         }
+    // No default agent: an empty $(orq pick ...) means no candidate, and must not start anything.
+    if (!a) {
+        console.error(m("missing -a (if it came from orq pick, it found no candidate): nothing started", "faltou -a (se veio do orq pick, ele não achou candidato): nada foi iniciado"));
+        return 2;
+    }
     a = ALIASES[a] ?? a;
     const { cfg } = loadConfig();
     const def = agentDef(cfg, a);
@@ -123,6 +130,22 @@ export async function agent(argv) {
         return 2;
     }
     const repo = resolve(d), O = resolve(o);
+    // A live run on this prefix owns its files: a second agent on the same files (and its .done) is how a false DONE happens.
+    // Only a -T -R follow-up typed into that run's own open screen may reuse it.
+    let open = "", pid = 0;
+    try {
+        open = readFileSync(`${O}.pane`, "utf8").trim();
+    }
+    catch { /* first run */ }
+    try {
+        pid = Number(readFileSync(`${O}.pid`, "utf8"));
+    }
+    catch { /* none or ended */ }
+    const typed = tui && resume && alive(pid) && screenOpen(open);
+    if (!typed && runLive(O, pid)) {
+        console.error(m(`${basename(O)} still has a live run (${pid ? `pid ${pid}` : "unit active"}): wait for it (orq wait ${O}) or stop it, or use another prefix. Nothing started.`, `${basename(O)} ainda tem uma execução viva (${pid ? `pid ${pid}` : "unit ativa"}): espere (orq wait ${O}) ou pare, ou use outro prefixo. Nada foi iniciado.`));
+        return 3;
+    }
     // Fix rounds: every -R on the same session counts, whatever the prefix is called. policy.max_rounds is enforced here,
     // not left to the conductor to remember (a 7-round fix loop is what burns the tokens). -F = the user said go on.
     if (resume) {
@@ -133,9 +156,18 @@ export async function agent(argv) {
         }
         catch { /* first follow-up */ }
         if (n >= max && !force) {
-            console.error(m(`round limit: session ${resume} already had ${n} follow-up(s) (policy.max_rounds = ${max}). Stop and tell the user; with their OK, repeat with -F.`, `limite de rodadas: a sessão ${resume} já teve ${n} follow-up(s) (policy.max_rounds = ${max}). Pare e avise o usuário; com o OK dele, repita com -F.`));
+            console.error(m(`round limit: session ${resume} already had ${n} follow-up(s) (policy.max_rounds = ${max}). Stop and tell the user; with their OK, run \`orq rounds <ID> --diagnose\`, then repeat with -F.`, `limite de rodadas: a sessão ${resume} já teve ${n} follow-up(s) (policy.max_rounds = ${max}). Pare e avise o usuário; com o OK dele, rode \`orq rounds <ID> --diagnose\` e repita com -F.`));
             return 4;
         }
+        // -F past the limit also needs the watchdog's diagnosis of this round count (-F -F skips it: the user's own call).
+        // The issue folder is the prefix's folder, .orquestra/<ID>/ (where the .rounds-<session> counter lives).
+        if (n >= max && force === 1 && basename(dirname(dirname(O))) === ".orquestra") {
+            const g = gateFor(dirname(O)), id = basename(dirname(O));
+            if (g.verdict !== "ok") {
+                console.error(m(`no current diagnosis: ${g.verdict === "stale" ? `diagnosis-${g.rounds}.md is older than the latest fix/review` : `diagnosis-${g.rounds}.md does not exist`}. Run \`orq rounds ${id} --diagnose\` first, read it, and ask the user. -F -F skips this check.`, `sem diagnóstico atual: ${g.verdict === "stale" ? `diagnosis-${g.rounds}.md é mais antigo que o último fix/revisão` : `diagnosis-${g.rounds}.md não existe`}. Rode \`orq rounds ${id} --diagnose\` antes, leia e consulte o usuário. -F -F pula esta checagem.`));
+                return 4;
+            }
+        }
         mkdirSync(dirname(O), { recursive: true });
         writeFileSync(cf, String(n + 1));
     }
@@ -169,13 +201,8 @@ export async function agent(argv) {
     // Follow-ups (-R) reuse the prefix: remove the previous round's result so ".done exists" means "this one finished".
     // -T -R with the screen still open: the follow-up is typed into it (its runner, and .pid, carry on). Open = the agent
     // is still running there, not just the pane: after it exits the pane may hold a shell, which must never get the text.
-    let open = "", pid = 0;
-    try {
-        open = readFileSync(`${O}.pane`, "utf8").trim();
-        pid = Number(readFileSync(`${O}.pid`, "utf8"));
-    }
-    catch { /* first run or ended */ }
-    if (tui && resume && alive(pid) && screenOpen(open)) {
+    if (typed) {
+        ackPrefix(O); // a follow-up on the issue: its failure notices were seen
         for (const s of [".done", ".out.md"])
             rmSync(O + s, { force: true });
         typeInto(open, readFileSync(P, "utf8"));
@@ -184,7 +211,7 @@ export async function agent(argv) {
     }
     for (const s of [".done", ".out.md", ".pid"])
         rmSync(O + s, { force: true });
-    const throwaway = Boolean(def.throwaway && ro && !resume);
+    const throwaway = useThrowaway(def, ro, Boolean(resume), git(repo, "rev-parse", "--git-dir") !== undefined);
     const dir = throwaway ? `${repo}.review-${process.pid}` : repo;
     const gd = git(repo, "rev-parse", "--path-format=absolute", "--git-common-dir");
     const wg = git(repo, "rev-parse", "--absolute-git-dir");
@@ -247,17 +274,33 @@ export async function agent(argv) {
         swap: parseSize(mach.agent_swap_max), mode: mach.mem_enforce ?? "auto",
         throwaway, promptInDir: Boolean(def.prompt_in_dir), closeAfter,
         keep: process.env.HERDR_KEEP_TAB === "1" || process.env.ORQ_KEEP_TAB === "1" || closeAfter <= 0, tui,
-        okExit: def.ok_exit, filter: def.filter, noReview: def.no_review,
+        okExit: def.ok_exit, filter: def.filter, noReview: def.no_review, ro,
+        idleCloseMin: tui ? Number(mach.tui_idle_close_min ?? 30) : undefined,
     };
     writeAtomic(`${O}.job.json`, JSON.stringify(job, null, 1));
     // Readable copy of the command (also what orq stats and herdr-board read).
     writeFileSync(`${O}.run.sh`, `#!/usr/bin/env bash\n# orq agent (generated; the run itself is \`orq agent --run ${O}.job.json\`) --unit=${unit} \n` +
         `cd ${shq(dir)}\n${Object.entries(env).map(([k, val]) => `${k}=${shq(val)} `).join("")}${cmd.map(shq).join(" ")}${job.stdin ? ` < ${shq(P)}` : ""}\n`);
+    ackPrefix(O); // starting work on the issue again: its failure notices were seen
     const where = launch(host, { group: g || "agents", title: t, dir: repo, argv: [process.execPath, CLI, "agent", "--run", `${O}.job.json`], id: unit, keep: job.keep });
     writeFileSync(`${O}.pane`, `${where}\n`);
     console.log(`[orq agent] ${t} → ${where}${tui ? " (TUI)" : ""}`);
     return 0;
 }
+/** The previous run on prefix `O` is still going: its runner pid is alive, or (no pid file yet / runner gone) its systemd scope is. */
+function runLive(O, pid) {
+    if (alive(pid))
+        return true;
+    if (existsSync(`${O}.done`) || process.platform !== "linux")
+        return false; // finished (or no systemd): the pid said it all
+    try {
+        const unit = JSON.parse(readFileSync(`${O}.job.json`, "utf8")).unit;
+        return Boolean(unit) && spawnSync("systemctl", ["--user", "is-active", "--quiet", `${unit}.scope`], { timeout: 5_000 }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
 /** OpenCode (v2) plugin for -T: when the main session's run ends, its last answer goes to `orq agent --turn`. */
 function opencodePlugin(O, hook) {
     return `// orq agent -T end of turn (generated)
@@ -326,7 +369,7 @@ function turn(file, kind, rest) {
         const st = /\S/.test(answer) && !noReview ? "ok" : "fail";
         writeAtomic(`${O}.done`, `status=${st} rc=0 at=${new Date().toISOString()} agent=${j.agent} mode=tui\n`);
         if (j.parent)
-            notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=${st} rc=0 answer: ${O}.out.md`, true);
+            notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=${st} rc=0 answer: ${O}.out.md`);
     }
     catch (e) {
         console.error(`orq agent --turn: ${e.message}`);
@@ -374,6 +417,26 @@ function noReviewMatch(pattern, answer) {
     return re.test(first) || (answer.trim().length <= 200 && re.test(answer));
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** A -T agent is idle when its turn ended (.done exists) and, for `idleMs`, nothing touched .done (a follow-up removes
+ *  it, a turn's end rewrites it) and the screen was not seen busy (`busyAt`, epoch ms, from herdr's agent status). */
+export function idleExpired(done, idleMs, now = Date.now(), busyAt = 0) {
+    try {
+        return idleMs > 0 && now - Math.max(statSync(done).mtimeMs, busyAt) >= idleMs;
+    }
+    catch {
+        return false;
+    }
+}
+/** herdr's view of the agent on a pane: working | blocked | idle | done | unknown; undefined when it can't be read. */
+function paneStatus(pane) {
+    const r = spawnSync("herdr", ["pane", "get", pane], { encoding: "utf8", timeout: 5_000 });
+    try {
+        return r.status === 0 ? JSON.parse(r.stdout).result?.pane?.agent_status : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Splits a stream into lines for `each`. */
 function lines(s, each) {
     return new Promise((res) => {
@@ -396,12 +459,14 @@ async function runJob(file) {
     const stateF = join(stateDir(), "agents", `${j.unit}.json`);
     const at = new Date().toISOString();
     const state = (extra = {}) => { try {
-        writeAtomic(stateF, JSON.stringify({ pid: process.pid, prefix: O, title: j.title, agent: j.agent, host: j.host, cap: j.cap, at, ...extra }));
+        writeAtomic(stateF, JSON.stringify({ pid: process.pid, prefix: O, title: j.title, agent: j.agent, model: argvModel(j.argv), host: j.host, cap: j.cap, at, ...extra }));
     }
     catch { /* best effort */ } };
     state();
     const fmt = FORMATS[j.format] ?? FORMATS.text;
     let rc = 0, stdout = "", logText = "";
+    // State of the worktree before the run, to tell what this run changed (a -R on a dirty tree is not progress).
+    const headBefore = j.throwaway ? undefined : git(j.dir, "rev-parse", "HEAD"), statusBefore = j.throwaway ? undefined : git(j.dir, "status", "--porcelain");
     const pre = () => {
         if (j.throwaway) {
             // Throwaway worktree: detached copy of HEAD with the repo's node_modules linked; removed at the end.
@@ -439,20 +504,26 @@ async function runJob(file) {
     if (j.tui) {
         // The agent's own screen: the terminal is its; answers come from the end-of-turn hook (`--turn`).
         let ended = false;
-        const end = (code) => {
+        const end = (code, killed = false) => {
             if (ended)
                 return "fail";
             ended = true;
             post();
             // Closed before any turn ended (or mid follow-up): a failure, so `orq wait` doesn't hang.
-            const ok = /\bstatus=ok\b/.test(existsSync(`${O}.done`) ? readFileSync(`${O}.done`, "utf8") : "");
-            if (!existsSync(`${O}.done`)) {
+            const ok = !killed && /\bstatus=ok\b/.test(existsSync(`${O}.done`) ? readFileSync(`${O}.done`, "utf8") : "");
+            if (killed) {
+                // SIGKILL & co: whatever an earlier turn wrote, the screen did not end normally.
+                writeAtomic(`${O}.done`, `status=killed rc=${code} at=${new Date().toISOString()} agent=${j.agent} mode=tui\n`);
+                if (j.parent)
+                    notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=killed rc=${code} answer: ${O}.out.md`);
+            }
+            else if (!existsSync(`${O}.done`)) {
                 writeAtomic(`${O}.done`, `status=fail rc=${code} at=${new Date().toISOString()} agent=${j.agent} mode=tui\n`);
                 if (j.parent)
-                    notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=fail rc=${code} answer: ${O}.out.md`, true);
+                    notify(j.parent, `[HERDR-AGENT DONE] ${j.title} status=fail rc=${code} answer: ${O}.out.md`);
             }
             rmSync(`${O}.pid`, { force: true });
-            return ok ? "ok" : "fail";
+            return killed ? "killed" : ok ? "ok" : "fail";
         };
         if (!pre())
             rc = 2;
@@ -462,16 +533,46 @@ async function runJob(file) {
                 delete env[k];
             // Ctrl+C belongs to the agent (it reaches us too, as part of the terminal's foreground group). The screen going
             // away (tab or tmux server closed) still ends the agent and cleans up.
-            let child;
+            let child, idleT, idleClosed = false;
             process.on("SIGINT", () => { });
+            // The screen going away or being killed from outside: end the agent, and close the tab too (a dead tab stayed open).
             const gone = () => { if (child)
-                killTree(child, false); end(129); process.exit(0); };
+                killTree(child, false); end(129); closeOwnTab(j.host); process.exit(0); };
             for (const sig of ["SIGHUP", "SIGTERM"])
                 process.on(sig, gone);
             rc = await runCapped(j.argv[0], j.argv.slice(1), { cap: j.cap, swap: j.swap, mode: j.mode, unit: j.unit, cwd: j.dir, env, quote: true, tty: true,
-                onSpawn: (c) => { child = c.pid; } });
+                onSpawn: (c) => {
+                    child = c.pid;
+                    // A finished agent waits for a follow-up forever and holds its memory: after the idle timeout without a new
+                    // turn, kill it; the normal end below cleans up and closes the tab. "New turn" = .done removed (`-R` typed
+                    // into the screen removes it) or rewritten (the next end of turn), so idle = .done untouched that long.
+                    const idleMs = (j.idleCloseMin ?? 0) * 60_000;
+                    if (idleMs > 0 && !j.keep) {
+                        // On herdr the pane's agent status also catches a turn typed straight into the screen (.done only changes
+                        // when it ends). Elsewhere (tmux) only .done tells: a turn typed directly into the screen that runs longer
+                        // than the timeout can still be closed.
+                        let busyAt = 0;
+                        const pane = j.host === "herdr" ? process.env.HERDR_PANE_ID : undefined;
+                        idleT = setInterval(() => {
+                            const st = pane ? paneStatus(pane) : undefined;
+                            if (st === "working" || st === "blocked")
+                                busyAt = Date.now();
+                            if (!idleExpired(`${O}.done`, idleMs, Date.now(), busyAt))
+                                return;
+                            clearInterval(idleT);
+                            console.log(m(`[orq agent] no follow-up for ${j.idleCloseMin} min: closing the finished agent`, `[orq agent] sem follow-up há ${j.idleCloseMin} min: fechando o agente que terminou`));
+                            idleClosed = true;
+                            if (child)
+                                killTree(child, false);
+                        }, Math.min(30_000, Math.max(1_000, idleMs / 2)));
+                        idleT.unref();
+                    }
+                } });
+            clearInterval(idleT);
+            if (idleClosed)
+                rc = 0; // closed on purpose after a finished turn: not a kill
         }
-        const st = end(rc);
+        const st = end(rc, killedRc(rc));
         state({ status: st, rc, end: new Date().toISOString() });
         console.log(`\n[${j.agent} (TUI) ${m("exited", "encerrado")}] ${m("answer", "resposta")}: ${O}.out.md`);
         if (!j.keep) {
@@ -534,12 +635,24 @@ async function runJob(file) {
     await new Promise((r) => log.end(r));
     post();
     const res = fmt.finish(logText, stdout);
+    // Denied commands do not sink a write run that did work: keep the diff and report ok with the denied list in the answer.
+    let recovered = false;
+    if (res.denied?.length && !j.ro && !j.throwaway && existsSync(j.dir)) {
+        const status = git(j.dir, "status", "--porcelain"), head = git(j.dir, "rev-parse", "HEAD");
+        if (status !== statusBefore || head !== headBefore) {
+            const stat = (headBefore && git(j.dir, "diff", "--stat", headBefore)) || status || `HEAD ${headBefore?.slice(0, 7)} -> ${head?.slice(0, 7)}`;
+            recovered = true;
+            res.answer = `${res.answer ?? ""}\n## Worktree\nSome commands were denied, but the worktree changes are kept (review them before accepting):\n\`\`\`\n${stat}\n\`\`\`\n`;
+        }
+        else
+            res.answer = `${res.answer ?? ""}\nNo changes were made in the worktree.\n`;
+    }
     if (j.answer !== "file")
         writeFileSync(`${O}.out.md`, res.answer ?? "");
     const sid = j.fromLog ? new RegExp(j.fromLog, "m").exec(logText)?.[1] : res.session ?? j.session;
     if (sid)
         writeFileSync(`${O}.id`, `${sid}\n`);
-    if (rc === 0 && res.rc)
+    if (rc === 0 && res.rc && !recovered)
         rc = res.rc;
     // A review tool exits non-zero on findings: an ok_exit code is a verdict (rc stays in .done), not a failure.
     let verdict = rc === 0 || (j.okExit ?? []).includes(rc);
@@ -560,7 +673,8 @@ async function runJob(file) {
     // A reviewer whose answer says nothing was reviewed (agents.<name>.no_review) is not a verdict either: pick's
     // fallback and the conductor must see it as not run, same as a whitespace-only answer.
     const noReview = noReviewMatch(j.noReview, answer);
-    const st = verdict && !noReview && /\S/.test(answer) ? "ok" : "fail"; // whitespace-only answer = failure
+    // killed (SIGKILL, memory cap...) is its own status: never ok, even if an ok_exit list or a leftover answer says otherwise.
+    const st = killedRc(rc) ? "killed" : verdict && !noReview && /\S/.test(answer) ? "ok" : "fail"; // whitespace-only answer = failure
     writeAtomic(`${O}.done`, `status=${st} rc=${rc} at=${new Date().toISOString()} agent=${j.agent}\n`);
     rmSync(`${O}.pid`, { force: true });
     state({ status: st, rc, end: new Date().toISOString() });

package/dist/commands/block.js

@@ -8,7 +8,9 @@ import { writeAtomic } from "../fsutil.js";
 import { loginId } from "../identity.js";
 import { m } from "../i18n.js";
 import { stateDir } from "../paths.js";
-export const USAGE = `orq block <agent|account> [--until YYYY-MM-DD[THH:MM] | --days N] [--reason "text"]   default: 7 days
+import { getPath, loadConfig } from "../config.js";
+import { collect } from "../quota.js";
+export const USAGE = `orq block <agent|account> [--until YYYY-MM-DD[THH:MM] | --days N | --quota] [--reason "text"]   default: 7 days; --quota: until the quota window resets
 orq block -r <agent|account>       unblock early
 orq block -l                       list active blocks (expired ones disappear by themselves)`;
 const file = () => join(stateDir(), "blocks.json");
@@ -45,7 +47,16 @@ export function parseLocal(s) {
         throw new Error(m(`invalid date: ${s}`, `data inválida: ${s}`));
     return d;
 }
-export function block(argv) {
+/** When a quota line's exhausted window resets, in epoch seconds: the week if it is used up, else the 5h window (the
+ *  reading can lag behind the limit: Codex's comes from its last session). undefined = no reset known. */
+export function quotaUntil(line) {
+    const reset = (k) => { const x = new RegExp(`\\b${k}=(\\d+)`).exec(line); return x ? Number(x[1]) : undefined; };
+    const week = /\bweek=(\d+)%/.exec(line);
+    if (week && Number(week[1]) >= 100 && reset("resetweek"))
+        return reset("resetweek");
+    return reset("reset5h") ?? reset("resetweek");
+}
+export async function block(argv) {
     const b = load();
     if (!argv.length || argv[0] === "-h" || argv[0] === "--help") {
         console.log(USAGE);
@@ -69,7 +80,7 @@ export function block(argv) {
         return 0;
     }
     const [name, ...rest] = argv;
-    let until = new Date(Date.now() + 7 * 86400_000), reason = "";
+    let until = new Date(Date.now() + 7 * 86400_000), reason = "", byQuota = false;
     while (rest.length) {
         const o = rest.shift();
         if (o === "--until")
@@ -78,6 +89,18 @@ export function block(argv) {
             until = new Date(Date.now() + Number(rest.shift()) * 86400_000);
         else if (o === "--reason")
             reason = rest.shift() ?? "";
+        else if (o === "--quota")
+            byQuota = true;
+    }
+    if (byQuota) {
+        const sources = (getPath(loadConfig().cfg, "quota") ?? {});
+        const line = (await collect(sources, [name])).find((l) => l.startsWith(`${name} `));
+        const r = line && quotaUntil(line);
+        if (!r) {
+            console.error(m(`${name}: no quota reset known; use --until or --days`, `${name}: sem horário de renovação da cota; use --until ou --days`));
+            return 1;
+        }
+        until = new Date(r * 1000);
     }
     if (Number.isNaN(until.getTime())) {
         console.error(USAGE);