@irythill/orq 0.2.0 → 0.3.0

package/README.md

@@ -206,7 +206,7 @@ off the same issue. Details, shortcuts and scenarios: [docs/herdr.md](docs/herdr
 
 | Command | What it does |
 |---|---|
-| `orq agent -a <agent> ...` (`herdr-agent`) | Runs an agent with a memory cap in a herdr tab, a tmux window or the background; `-r` read only, `-R <id>` continue the session, `-i` attach a file, `-b <base>` attach the diff, `-T` the agent's own screen (herdr only) |
+| `orq agent -a <agent> ...` (`herdr-agent`) | Runs an agent with a memory cap in a herdr tab, a tmux window or the background; `-r` read only, `-R <id>` continue the session, `-i` attach a file, `-b <base>` attach the diff, `-T` the agent's own screen (herdr or tmux; `-R` with it open types the follow-up into it) |
 | `orq instructions claude\|agents` | Writes the `/issue` playbook as `SKILL.md` (Claude Code) or into `AGENTS.md` (Codex, OpenCode…) |
 | `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 |

package/README.pt-BR.md

@@ -207,7 +207,7 @@ dois conductors peguem a mesma issue. Detalhes, atalhos e cenários: [docs/pt-BR
 
 | Comando | O que faz |
 |---|---|
-| `orq agent -a <agent> ...` (`herdr-agent`) | Roda um agente com limite de memória numa aba do herdr, numa janela do tmux ou em segundo plano; `-r` só leitura, `-R <id>` continua a sessão, `-i` anexa um arquivo, `-b <base>` anexa o diff, `-T` a tela do próprio agente (só herdr) |
+| `orq agent -a <agent> ...` (`herdr-agent`) | Roda um agente com limite de memória numa aba do herdr, numa janela do tmux ou em segundo plano; `-r` só leitura, `-R <id>` continua a sessão, `-i` anexa um arquivo, `-b <base>` anexa o diff, `-T` a tela do próprio agente (herdr ou tmux; `-R` com ela aberta digita o follow-up nela) |
 | `orq instructions claude\|agents` | Escreve o playbook do `/issue` como `SKILL.md` (Claude Code) ou dentro do `AGENTS.md` (Codex, OpenCode…) |
 | `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 |

package/dist/agents.js

@@ -1,6 +1,7 @@
 import { m } from "./i18n.js";
 const NOMCP_CODEX = "-c mcp_servers.plane.enabled=false -c mcp_servers.shadcn.enabled=false";
 const CLAUDE = "claude -p --strict-mcp-config --output-format stream-json --verbose [--model {model}] --effort {effort:low}";
+const CLAUDE_TUI = "claude --strict-mcp-config [--model {model}] --effort {effort:low}";
 const OPENCODE = "opencode run --standalone --format json [-m {model}]"; // v2: effort goes in the model, "provider/model#variant"
 const AGY = "agy --output-format stream-json --sandbox [--model {model}] [--effort {effort}]";
 const COPILOT = "-s -C {dir} --disable-builtin-mcps --disable-mcp-server plane --allow-tool 'shell(git diff:*)' " +
@@ -14,6 +15,8 @@ export const BUILTIN_AGENTS = {
         run: `${CLAUDE} --session-id {session} {mode}`, resume: `${CLAUDE} --resume {session} {mode}`,
         readonly: "--permission-mode plan", write: "--permission-mode auto --add-dir {gitdir}",
         stdin: true, format: "claude", session: "uuid", accounts: true, unset_env: ["HERDR_PANE_ID"],
+        tui: `${CLAUDE_TUI} --session-id {session} {mode} --settings {hook_settings} {prompt_text}`,
+        tui_resume: `${CLAUDE_TUI} --resume {session} {mode} --settings {hook_settings} {prompt_text}`, turn_hook: "claude",
     },
     codex: {
         // Codex treats any .git inside a writable root as read only: the folders a commit needs are granted one by one.
@@ -23,12 +26,21 @@ export const BUILTIN_AGENTS = {
         resume: `codex exec resume {session} -c model_reasoning_effort={effort:low} ` +
             `-c sandbox_workspace_write.writable_roots={gitroots_json} ${NOMCP_CODEX} -o {out} -`,
         readonly: "", write: "[--add-dir {gitroots}]", stdin: true, format: "codex", answer: "file", throwaway: true,
+        // The screen: no approvals (nobody to approve), the same sandbox as exec; notify = end of turn.
+        tui: `codex [-m {model}] -c model_reasoning_effort={effort:low} -s workspace-write -a never -C {dir} {mode} ` +
+            `${NOMCP_CODEX} -c notify={hook_json} {prompt_text}`,
+        tui_resume: `codex resume {session} -c model_reasoning_effort={effort:low} -s workspace-write -a never ` +
+            `-c sandbox_workspace_write.writable_roots={gitroots_json} ${NOMCP_CODEX} -c notify={hook_json} {prompt_text}`,
+        turn_hook: "codex",
     },
     opencode: {
         // Permissions and MCPs off via OPENCODE_CONFIG_CONTENT. Headless has nobody to approve, so write = --auto (only
         // ever in a worktree) and read only = throwaway worktree with the edit tool denied.
         run: `${OPENCODE} {mode} {prompt_text}`, resume: `${OPENCODE} -s {session} {mode} {prompt_text}`, readonly: "", write: "--auto",
         format: "opencode", throwaway: true, env: { OPENCODE_CONFIG_CONTENT: "{opencode_config}" },
+        // The screen: no --auto ("ask" shows up for you); the model and orq's end-of-turn plugin go in the config.
+        tui: "opencode --standalone --prompt {prompt_text} {dir}", tui_resume: "opencode --standalone -s {session} --prompt {prompt_text} {dir}",
+        turn_hook: "opencode",
     },
     antigravity: {
         // --sandbox + accept-edits (no skip-permissions); headless denies commands outside agy's allowlist, so in practice

package/dist/commands/agent.js

@@ -4,6 +4,10 @@
 // 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.
 // 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/
+// .done and notifies; the screen stays open (holding memory) until you close it. -T -R with the screen still open types
+// 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";
@@ -14,11 +18,12 @@ import { agentDef, ALIASES, expandString, expandTemplate, FORMATS } from "../age
 import { 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 { closeOwnTab, detectHost, launch, shq } from "../terminal.js";
+import { closeOwnTab, detectHost, launch, screenOpen, shq, typeInto } from "../terminal.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] -- <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] [-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) => {
@@ -28,8 +33,10 @@ const git = (dir, ...a) => {
 export async function agent(argv) {
     if (argv[0] === "--run")
         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, prompt;
+    let ro = false, tui = false, prompt;
     const inc = [];
     for (let i = 0; i < argv.length; i++) {
         const x = argv[i], v = () => argv[++i] ?? "";
@@ -63,10 +70,8 @@ export async function agent(argv) {
             v();
         else if (x === "-r")
             ro = true;
-        else if (x === "-T") {
-            console.error(m("-T (the agent's own TUI) only exists in herdr: use herdr-agent -T", "-T (a TUI do próprio agente) só existe no herdr: use herdr-agent -T"));
-            return 2;
-        }
+        else if (x === "-T")
+            tui = true;
         else if (!x.startsWith("-") && prompt === undefined)
             prompt = x;
         else {
@@ -94,10 +99,27 @@ export async function agent(argv) {
         console.error(m(`-c only applies to agents with Claude accounts (claude)`, `-c só vale para agentes com contas Claude (claude)`));
         return 2;
     }
-    if (resume && !def.resume) {
+    const mach = (cfg.machine ?? {});
+    const host = detectHost(cfg);
+    // Screen by default (machine.tui, HERDR_AGENT_TUI=1) only where it can be: a terminal host and an agent with a screen.
+    if (!tui && (process.env.HERDR_AGENT_TUI === "1" || mach.tui === true) && host !== "plain" && def.tui && (!resume || def.tui_resume))
+        tui = true;
+    if (tui && !def.tui) {
+        console.error(m(`-T: ${a} has no screen mode (agents.${a}.tui)`, `-T: ${a} não tem modo tela (agents.${a}.tui)`));
+        return 2;
+    }
+    if (resume && !tui && !def.resume) {
         console.error(m(`${a} has no resume template (agents.${a}.resume)`, `${a} não tem template de resume (agents.${a}.resume)`));
         return 2;
     }
+    if (tui && resume && !def.tui_resume) {
+        console.error(m(`-T -R: ${a} has no tui_resume template`, `-T -R: ${a} não tem template tui_resume`));
+        return 2;
+    }
+    if (tui && host === "plain") {
+        console.error(m("-T shows the agent's own screen: it needs herdr or tmux (run inside one, or set ORQ_TERMINAL)", "-T mostra a tela do próprio agente: precisa do herdr ou do tmux (rode dentro de um, ou defina ORQ_TERMINAL)"));
+        return 2;
+    }
     const repo = resolve(d), O = resolve(o);
     let P = resolve(prompt);
     if (!existsSync(repo)) {
@@ -119,9 +141,6 @@ export async function agent(argv) {
         writeFileSync(`${O}.diff`, r.stdout);
         inc.push(`${O}.diff`);
     }
-    // Follow-ups (-R) reuse the prefix: remove the previous round's result so ".done exists" means "this one finished".
-    for (const s of [".done", ".out.md", ".pid"])
-        rmSync(O + s, { force: true });
     if (inc.length) {
         let text = readFileSync(P, "utf8");
         for (const f of inc)
@@ -129,6 +148,24 @@ export async function agent(argv) {
         writeFileSync(`${O}.prompt.md`, text);
         P = `${O}.prompt.md`;
     }
+    // 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)) {
+        for (const s of [".done", ".out.md"])
+            rmSync(O + s, { force: true });
+        typeInto(open, readFileSync(P, "utf8"));
+        console.log(`[orq agent] ${t} → ${open} ${m("(follow-up typed into the open screen)", "(follow-up digitado na tela aberta)")}`);
+        return 0;
+    }
+    for (const s of [".done", ".out.md", ".pid"])
+        rmSync(O + s, { force: true });
     const throwaway = Boolean(def.throwaway && ro && !resume);
     const dir = throwaway ? `${repo}.review-${process.pid}` : repo;
     const gd = git(repo, "rev-parse", "--path-format=absolute", "--git-common-dir");
@@ -140,22 +177,36 @@ export async function agent(argv) {
     }
     catch { /* none */ }
     const session = resume || (def.session === "uuid" ? randomUUID() : "");
+    const tpl = tui ? (resume ? def.tui_resume : def.tui) : resume ? def.resume : def.run;
+    // End of turn (-T): the agent runs `orq agent --turn <job> <kind>`; Claude gets it as a Stop hook, Codex as notify,
+    // OpenCode through a plugin orq writes next to the job.
+    const hook = [process.execPath, CLI, "agent", "--turn", `${O}.job.json`, def.turn_hook ?? "text"];
+    // OpenCode v2 drops a partial MCP entry without a word: each one turned off needs its type and command too.
+    const off = { type: "local", command: ["true"], enabled: false };
+    const ocCfg = {
+        mcp: { plane: off, shadcn: off, "linear-server": off },
+        permission: { bash: "allow", question: "deny", webfetch: "deny",
+            external_directory: { "*": "deny", ...(gd ? { [`${gd}/*`]: "allow" } : {}), "/tmp/*": "allow", ...(nm ? { [`${nm}/*`]: "allow" } : {}) },
+            edit: ro ? "deny" : "allow" },
+    };
+    if (tui && def.turn_hook === "opencode") {
+        mkdirSync(`${O}.opencode`, { recursive: true }); // a v2 plugin is a folder with index.js
+        writeFileSync(join(`${O}.opencode`, "index.js"), opencodePlugin(O, hook));
+        ocCfg.plugin = [`${O}.opencode`];
+        if (model && model !== "auto")
+            ocCfg.model = model; // the screen has no -m
+    }
     const vars = {
-        prompt: P, prompt_text: def.run.includes("{prompt_text}") || def.resume?.includes("{prompt_text}") ? readFileSync(P, "utf8") : "",
+        prompt: P, prompt_text: tpl.includes("{prompt_text}") ? readFileSync(P, "utf8") : "",
         prompt_hint: `Read the file ${PF} (in the current folder, with your file-reading tool): it holds your complete instructions for this task. Follow them. ${PF} is not part of the code: don't review or edit it.`,
         out: `${O}.out.md`, dir, repo, title: t, model: model === "auto" ? "" : model, effort, session,
-        gitdir: gd ?? "", gitroots: roots, gitroots_json: JSON.stringify(roots), mode: [],
-        opencode_config: JSON.stringify({
-            mcp: { plane: { enabled: false }, shadcn: { enabled: false }, "linear-server": { enabled: false } },
-            permission: { bash: "allow", question: "deny", webfetch: "deny",
-                external_directory: { "*": "deny", ...(gd ? { [`${gd}/*`]: "allow" } : {}), "/tmp/*": "allow", ...(nm ? { [`${nm}/*`]: "allow" } : {}) },
-                edit: ro ? "deny" : "allow" },
-        }),
+        gitdir: gd ?? "", gitroots: roots, gitroots_json: JSON.stringify(roots), mode: [], opencode_config: JSON.stringify(ocCfg),
+        hook_cmd: hook.map(shq).join(" "), hook_json: JSON.stringify(hook),
+        hook_settings: JSON.stringify({ hooks: { Stop: [{ hooks: [{ type: "command", command: hook.map(shq).join(" ") }] }] } }),
     };
     vars.mode = expandTemplate((ro ? def.readonly : def.write) || "", vars);
-    const tpl = resume ? def.resume : def.run;
     const cmd = expandTemplate(tpl, vars);
-    if (!tpl.includes("{mode}") && !resume)
+    if (!tpl.includes("{mode}") && !resume && !tui)
         cmd.push(...vars.mode);
     const env = {};
     for (const [k, val] of Object.entries(def.env ?? {}))
@@ -168,9 +219,7 @@ export async function agent(argv) {
         }
         env.CLAUDE_CONFIG_DIR = ac.dir;
     }
-    const mach = (cfg.machine ?? {});
     const closeAfter = Number(process.env.HERDR_CLOSE_DELAY ?? mach.close_tab_after ?? 20);
-    const host = detectHost(cfg);
     const unit = `herdr-agent-${Math.floor(Date.now() / 1000)}-${process.pid}`; // herdr-board lists herdr-agent-* scopes
     const job = {
         agent: a, title: t, repo, dir, prefix: O, prompt: P, argv: cmd, env, unset: def.unset_env ?? [], stdin: Boolean(def.stdin),
@@ -179,7 +228,7 @@ export async function agent(argv) {
         host, unit, cap: parseSize(def.mem_max ?? mach.agent_mem_max ?? "off"),
         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,
+        keep: process.env.HERDR_KEEP_TAB === "1" || process.env.ORQ_KEEP_TAB === "1" || closeAfter <= 0, tui,
     };
     writeAtomic(`${O}.job.json`, JSON.stringify(job, null, 1));
     // Readable copy of the command (also what orq stats and herdr-board read).
@@ -187,9 +236,102 @@ export async function agent(argv) {
         `cd ${shq(dir)}\n${Object.entries(env).map(([k, val]) => `${k}=${shq(val)} `).join("")}${cmd.map(shq).join(" ")}${job.stdin ? ` < ${shq(P)}` : ""}\n`);
     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}`);
+    console.log(`[orq agent] ${t} → ${where}${tui ? " (TUI)" : ""}`);
     return 0;
 }
+/** 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)
+import { writeFileSync } from "fs"; import { spawn } from "child_process";
+export default {
+  id: "orq-turn",
+  setup: async (ctx) => {
+    const sub = new Set(), text = new Map(); // child sessions (subagents); answer text per session
+    (async () => {
+      for await (const e of ctx.event.subscribe()) {
+        const d = e.data ?? {}, id = d.sessionID;
+        if (e.type === "session.created" && d.parentID) sub.add(id);
+        if (!id || sub.has(id)) continue;
+        if (e.type === "session.execution.started") text.set(id, { msg: "", parts: [] });
+        else if (e.type === "session.text.ended") {
+          const t = text.get(id) ?? { msg: "", parts: [] };
+          if (t.msg !== d.assistantMessageID) { t.msg = d.assistantMessageID; t.parts = []; } // only the last message
+          t.parts[d.ordinal ?? t.parts.length] = d.text ?? ""; text.set(id, t);
+        } else if (e.type.startsWith("session.execution.") && e.type !== "session.execution.started") {
+          const f = ${JSON.stringify(`${O}.turn.md`)};
+          writeFileSync(f, (text.get(id)?.parts ?? []).filter((x) => x !== undefined).join("\\n"));
+          spawn(${JSON.stringify(hook[0])}, [...${JSON.stringify(hook.slice(1))}, id, f], { detached: true, stdio: "ignore" }).unref();
+        }
+      }
+    })().catch(() => {});
+    return {};
+  },
+};
+`;
+}
+/** End of a turn on the agent's screen: answer, session and .done from the agent's own hook payload. Never fails the agent. */
+function turn(file, kind, rest) {
+    try {
+        const j = JSON.parse(readFileSync(file, "utf8")), O = j.prefix;
+        let answer = "", sid;
+        if (kind === "codex") {
+            const e = JSON.parse(rest[rest.length - 1] ?? "{}");
+            if (e.type !== "agent-turn-complete")
+                return 0;
+            answer = String(e["last-assistant-message"] ?? "");
+            sid = e["thread-id"];
+        }
+        else if (kind === "claude") {
+            const e = JSON.parse(readFileSync(0, "utf8"));
+            if (e.stop_hook_active)
+                return 0;
+            sid = e.session_id;
+            answer = String(e.last_assistant_message ?? "") || lastClaudeText(String(e.transcript_path ?? ""));
+        }
+        else if (kind === "opencode") {
+            sid = rest[0];
+            try {
+                answer = readFileSync(rest[1], "utf8");
+                rmSync(rest[1], { force: true });
+            }
+            catch { /* none */ }
+        }
+        else {
+            sid = rest[0];
+            answer = readFileSync(0, "utf8");
+        }
+        writeFileSync(`${O}.out.md`, answer);
+        if (sid)
+            writeFileSync(`${O}.id`, `${sid}\n`);
+        const st = /\S/.test(answer) ? "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);
+    }
+    catch (e) {
+        console.error(`orq agent --turn: ${e.message}`);
+    }
+    return 0;
+}
+/** The last text Claude wrote, from its transcript (older Stop hooks have no last_assistant_message). */
+function lastClaudeText(transcript) {
+    let text = "";
+    try {
+        for (const l of readFileSync(transcript, "utf8").split(/\r?\n/)) {
+            try {
+                const e = JSON.parse(l);
+                if (e.type !== "assistant")
+                    continue;
+                const t = (e.message?.content ?? []).filter((c) => c.type === "text").map((c) => c.text).join("\n");
+                if (t)
+                    text = t;
+            }
+            catch { /* not JSON */ }
+        }
+    }
+    catch { /* no transcript */ }
+    return text;
+}
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /** Splits a stream into lines for `each`. */
 function lines(s, each) {
@@ -218,7 +360,6 @@ async function runJob(file) {
     catch { /* best effort */ } };
     state();
     const fmt = FORMATS[j.format] ?? FORMATS.text;
-    const log = createWriteStream(`${O}.log`);
     let rc = 0, stdout = "", logText = "";
     const pre = () => {
         if (j.throwaway) {
@@ -254,6 +395,51 @@ async function runJob(file) {
         if (j.throwaway)
             dropWorktree(j.repo, j.dir);
     };
+    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) => {
+            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`)) {
+                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);
+            }
+            rmSync(`${O}.pid`, { force: true });
+            return ok ? "ok" : "fail";
+        };
+        if (!pre())
+            rc = 2;
+        else {
+            const env = { ...process.env, ...j.env };
+            for (const k of j.unset)
+                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;
+            process.on("SIGINT", () => { });
+            const gone = () => { if (child)
+                killTree(child, false); end(129); 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; } });
+        }
+        const st = end(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) {
+            await sleep(j.closeAfter * 1000);
+            closeOwnTab(j.host);
+        }
+        return 0;
+    }
+    const log = createWriteStream(`${O}.log`);
     if (!pre())
         rc = 2;
     else {

package/dist/process.js

@@ -58,27 +58,29 @@ function parseTable(text) {
     }
     return t;
 }
-/** Total memory of `root` and all its descendants. */
-export function treeMem(root, table = processTable()) {
+/** `root` and all its descendants. */
+export function treePids(root, table = processTable()) {
     const kids = new Map();
     for (const [pid, [ppid]] of table)
         kids.set(ppid, [...(kids.get(ppid) ?? []), pid]);
-    let total = 0;
     const seen = new Set(), todo = [root];
     while (todo.length) {
         const p = todo.pop();
         if (seen.has(p))
             continue;
         seen.add(p);
-        total += table.get(p)?.[1] ?? 0;
         todo.push(...(kids.get(p) ?? []));
     }
-    return total;
+    return [...seen];
+}
+/** Total memory of `root` and all its descendants. */
+export function treeMem(root, table = processTable()) {
+    return treePids(root, table).reduce((t, p) => t + (table.get(p)?.[1] ?? 0), 0);
 }
-export function killTree(pid) {
+export function killTree(pid, group = true) {
     if (process.platform === "win32")
         spawnSync("taskkill", ["/T", "/F", "/PID", String(pid)], { stdio: "ignore" });
-    else
+    else if (group)
         try {
             process.kill(-pid, "SIGKILL");
         }
@@ -88,6 +90,12 @@ export function killTree(pid) {
             }
             catch { /* gone */ }
         }
+    else
+        for (const p of treePids(pid))
+            try {
+                process.kill(p, "SIGKILL");
+            }
+            catch { /* gone */ } // no group of its own
 }
 /** cmd.exe quoting for one argument (only used when Windows needs a shell). */
 export const winQuote = (a) => /[\s"&|<>^%()]/.test(a) || a === "" ? `"${a.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1")}"` : a;
@@ -103,10 +111,10 @@ export function runCapped(cmd, args, o = {}) {
         return wait(c);
     }
     const win = process.platform === "win32";
-    // Own process group on Linux/macOS, so the whole tree can be killed at once.
+    // Own process group on Linux/macOS, so the whole tree can be killed at once (not for a screen: it needs the terminal).
     // Windows: a shell only for .cmd/.bat shims (npx, claude…); an .exe runs directly (paths with spaces stay intact).
     const shell = win && !/\.exe$/i.test(cmd), q = shell && o.quote;
-    const child = spawn(q ? winQuote(cmd) : cmd, q ? args.map(winQuote) : args, { stdio: o.stdio ?? "inherit", cwd: o.cwd, env: o.env, detached: !win, shell, windowsHide: true });
+    const child = spawn(q ? winQuote(cmd) : cmd, q ? args.map(winQuote) : args, { stdio: o.stdio ?? "inherit", cwd: o.cwd, env: o.env, detached: !win && !o.tty, shell, windowsHide: true });
     o.onSpawn?.(child);
     if (mode === "off" || !child.pid)
         return wait(child);
@@ -117,7 +125,7 @@ export function runCapped(cmd, args, o = {}) {
         child.kill(sig);
     } };
     const onInt = fwd("SIGINT"), onTerm = fwd("SIGTERM");
-    if (!win) {
+    if (!win && !o.tty) {
         process.on("SIGINT", onInt);
         process.on("SIGTERM", onTerm);
     }
@@ -131,7 +139,7 @@ export function runCapped(cmd, args, o = {}) {
         if (used > o.cap && !killed) {
             killed = true;
             console.error(m(`orq: memory ${gb(used)} over the cap (${gb(o.cap)}): killing the process tree`, `orq: memória ${gb(used)} acima do limite (${gb(o.cap)}): encerrando a árvore de processos`));
-            killTree(child.pid);
+            killTree(child.pid, !o.tty);
         }
     }, o.intervalMs ?? 1000);
     return wait(child).then((code) => {

package/dist/terminal.js

@@ -3,6 +3,7 @@
 //   tmux   a background window in the current tmux session
 //   plain  a detached background process; its screen output goes to <state dir>/agents/<run>.log
 // auto = herdr inside a herdr pane (HERDR_PANE_ID), else tmux inside tmux (TMUX), else plain.
+// The agent's own screen (-T) needs herdr or tmux; follow-ups are typed into it while it is open.
 import { spawn, spawnSync } from "node:child_process";
 import { closeSync, mkdirSync, openSync } from "node:fs";
 import { join } from "node:path";
@@ -69,6 +70,31 @@ export function launch(host, l) {
     closeSync(fd);
     return `pid:${c.pid}`;
 }
+/** Is the screen `launch` returned still open? (herdr pane or tmux pane; a background pid has no screen) */
+export function screenOpen(where) {
+    if (where.startsWith("tmux:"))
+        return spawnSync("tmux", ["display-message", "-p", "-t", where.slice(5), "#{pane_id}"], { stdio: "ignore" }).status === 0;
+    if (!where || where.startsWith("pid:"))
+        return false;
+    return spawnSync("herdr", ["pane", "get", where], { stdio: "ignore" }).status === 0;
+}
+/** Type `text` into an open screen and submit it (a follow-up to an agent's own TUI). */
+export function typeInto(where, text) {
+    if (where.startsWith("tmux:")) {
+        // A bracketed paste keeps a multi-line prompt as one message; then Enter sends it.
+        const t = where.slice(5), run = (a, input) => {
+            const r = spawnSync("tmux", a, { input, encoding: "utf8" });
+            if (r.status !== 0)
+                throw new Error(`tmux ${a[0]}: ${(r.stderr || "").trim()}`);
+        };
+        run(["load-buffer", "-b", "orq-prompt", "-"], text);
+        run(["paste-buffer", "-p", "-d", "-b", "orq-prompt", "-t", t]);
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 300); // let the TUI take the paste before Enter
+        run(["send-keys", "-t", t, "Enter"]);
+        return;
+    }
+    herdr(["agent", "prompt", where, text]);
+}
 /** After a run: close our own herdr tab (the result stays in the files). tmux windows close when the runner exits. */
 export function closeOwnTab(host) {
     const p = process.env.HERDR_PANE_ID;

package/dist/testrun.js

@@ -2,7 +2,7 @@
 // memory cap (src/process.ts) and read its JSON report into "<file relative to the repo> :: <full test name>" lines.
 // The runner's own bin (node_modules/<runner>/package.json "bin") runs with this node, so Windows needs no shell;
 // without it, npx as before. Also the background job both share (launch on a TerminalHost, queue, .pid/.done, notify).
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { createWriteStream, existsSync, lstatSync, readFileSync, realpathSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -196,8 +196,12 @@ export async function inJob(j, label, slots, body, done) {
     }
     return st === "ok" ? 0 : 1;
 }
-/** The conductor is a herdr pane: type the line into it (herdr-notify waits for it to leave a dialog). */
-export function notify(pane, line) {
-    const local = join(dirname(CLI), "..", "setup", "herdr-notify");
-    spawnSync(existsSync(local) ? local : "herdr-notify", [pane, line], { stdio: "inherit" });
+/** The conductor is a herdr pane: type the line into it (herdr-notify waits for it to leave a dialog). In the
+ * background when the caller must not wait for that (an agent's end-of-turn hook holds its screen meanwhile). */
+export function notify(pane, line, background = false) {
+    const local = join(dirname(CLI), "..", "setup", "herdr-notify"), cmd = existsSync(local) ? local : "herdr-notify";
+    if (background)
+        spawn(cmd, [pane, line], { detached: true, stdio: "ignore" }).unref();
+    else
+        spawnSync(cmd, [pane, line], { stdio: "inherit" });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irythill/orq",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Orchestrate coding agents (Claude Code, Codex, OpenCode, Antigravity, Copilot) from one conductor.",
   "license": "MIT",
   "type": "module",

package/skills/issue/SKILL.md

@@ -15,7 +15,7 @@ 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`). No `-T`.
+  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
   task** (Claude Code: Bash with `run_in_background`); its exit wakes you and its output is the line
@@ -64,10 +64,10 @@ The output goes straight into `herdr-agent` (`herdr-agent $(orq pick ...) -g ...
 `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`
-for children (no memory cap, no answer file). **Screen mode (`-T`, or `HERDR_AGENT_TUI=1`):** 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 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
+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
+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).
 
 ## 4. Dispatch the implementer