agent.libx.js 0.94.5 → 0.94.6

package/README.md

@@ -111,7 +111,7 @@ agentx --resume <id> "…"    # resume a specific session
 - **Any provider** — set `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` / `GOOGLE_API_KEY` / `GROQ_API_KEY`; choose with `-m provider/model`.
 - **@-file mentions & headless JSON** — reference files inline in a prompt with `@path` (e.g. `explain @src/Agent.ts`); script with `-p --output-format json` to get one machine-readable result object on stdout (activity stays on stderr).
 - **Tab-completion** — `Tab` completes `/<command>` names and `@<path>` file/dir references (descends subdirs, dotfiles hidden unless typed) straight from the working tree.
-- **Duplex mode** — `agentx --duplex` runs the full standard REPL (slash commands, sessions, postures, rewind, MCP) with the three-tier engine driving turns: a fast voice model (`--voice-model`, default `groq/openai/gpt-oss-120b`) answers every line instantly and delegates real work to background workers built with the same wiring as a normal run (fs mode, permissions, MCP); worker activity shows as dim chrome and results are re-voiced when ready. Switch any tier live with `/model` (opens a reflex/act/think picker), or the `/voice-model` · `/think-model` shortcuts. `/tasks` lists background tasks and cancels a running one from a picker (Esc mid-turn cancels the foreground turn; Esc again at the idle prompt cancels running workers).
+- **Duplex mode** — `agentx --duplex` runs the full standard REPL (slash commands, sessions, postures, rewind, MCP) with the three-tier engine driving turns: a fast voice model (`--voice-model`, default `groq/openai/gpt-oss-120b`) answers every line instantly and delegates real work to background workers built with the same wiring as a normal run (fs mode, permissions, MCP); worker activity shows as dim chrome and results are re-voiced when ready. Switch any tier live with `/model` (opens a reflex/act/think picker), or the `/voice-model` · `/think-model` shortcuts. `/tasks` lists background tasks, inspects a task's live output tail, and cancels a running one from a picker (Esc mid-turn cancels the foreground turn; Esc again at the idle prompt cancels running workers).
 - **MCP servers** — declare `mcpServers: { name: { command, args } | { url } }` in config and they're auto-mounted at startup (in parallel, with an optional `mountTimeoutMs` deadline so one slow/dead server never blocks the rest): the client does the JSON-RPC handshake (stdio or HTTP) + `tools/list`, and the discovered tools appear as `mcp__<name>__<tool>` in `/tools` (inspect with `/mcp`). A bad server is logged and skipped, never blocking the agent. For large tool sets, **deferred mode** (`makeMcpToolSearch` / `mountMcpDeferred`) exposes just two bounded tools (`ToolSearch` + `McpCall`) instead of N defs — dodging the provider tool-cap and improving selection accuracy. **`mountMcpCatalog`** goes further: a cached, hash-keyed catalog + lazy connect means a turn that uses no MCP tool opens **zero** connections, and one that uses a tool connects exactly that server — latency scales with tools-used, not servers-configured. A down server is **negative-cached** (`failureCooldownMs`) so it never re-floors a later turn at the deadline. For zero turn-path latency even on a cold process, call **`warmMcpCatalog`** at boot + on a timer (off-turn discovery) and mount with **`{ discover: 'cache-only' }`** — the turn then never synchronously connects: it serves the warmed catalog and discovers any miss in the background.
 
 ## 🧬 It improves itself

package/dist/cli.js

@@ -4257,22 +4257,30 @@ ${recent}` : brief) + verify;
     const controller = new AbortController();
     const base = tierOpts?.hooks ?? o.actOptions?.hooks;
     const report = o.progressUpdates ? this.progressReporter(id) : void 0;
-    const hooks = report ? {
+    const tail = [];
+    const pushTail = (line) => {
+      tail.push(line.slice(0, 200));
+      if (tail.length > 120) tail.splice(0, tail.length - 120);
+    };
+    const hooks = {
       ...base,
       preToolUse: async (call, meta) => {
         const d = await base?.preToolUse?.(call, meta);
-        report.pre(call);
+        pushTail(`\u2699 ${describeCall(call)}`);
+        report?.pre(call);
         return d;
       },
       postToolUse: async (call, result, meta) => {
         await base?.postToolUse?.(call, result, meta);
-        report.post(call);
+        const last = result?.trim().split("\n").filter(Boolean).pop();
+        if (last) pushTail(`  \u21B3 ${last}`);
+        report?.post(call);
       },
       onToolOutput: (call, chunk, meta) => {
         base?.onToolOutput?.(call, chunk, meta);
-        report.output(chunk);
+        report?.output(chunk);
       }
-    } : base;
+    };
     const relayAsk = async (q2) => {
       const opts = q2.options?.length ? ` Options: ${q2.options.map((x) => x.label).join(", ")}.` : "";
       const a = await this.parkQuestion(id, `${q2.question}${opts}`);
@@ -4294,7 +4302,7 @@ ${recent}` : brief) + verify;
       // shared with the checker so a cancel tears down both
     };
     const promise = new Agent(agentOpts).run(briefText).then((res) => this.maybeVerify(id, briefText, res, tier, agentOpts)).then((res) => this.onWorkerSettled(id, res)).catch((err2) => this.onWorkerFailed(id, err2));
-    this.tasks.set(id, { id, label, status: "running", controller, promise });
+    this.tasks.set(id, { id, label, status: "running", controller, promise, tail });
   }
   /** Fresh-context check of a successful Act task: a NEW agent (same model/fs/tools, but NO shared
    *  conversation context) re-reads the file state against the brief and fixes any gap. The fix lands
@@ -4413,6 +4421,7 @@ Another agent just implemented the above. Independently check the CURRENT state
       return this.failTask(rec, msg);
     }
     rec.status = "done";
+    rec.result = res.text;
     log7.verbose(`task ${id} done (${res.steps} steps)`);
     this.notify("task_done", `task ${id} (${rec.label}) completed`, {
       id,
@@ -4430,6 +4439,7 @@ Another agent just implemented the above. Independently check the CURRENT state
   failTask(rec, msg) {
     this.dropAsk(rec.id);
     rec.status = "error";
+    rec.result = msg;
     log7.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
     this.queueRevoice(`[task ${rec.id} failed] ${msg}`);
@@ -10077,7 +10087,7 @@ ${extra}` : body);
 `));
       }
     }, tasks: {
-      desc: "background tasks \u2014 /tasks [cancel <id>], or alone for a picker (\u21B5 cancels the selected running task)",
+      desc: "background tasks \u2014 /tasks [cancel <id>], or alone for a picker (\u21B5 inspects output; running tasks can be cancelled)",
       run: async (a) => {
         const all = [...dx.tasks.values()];
         if (!all.length) {
@@ -10094,15 +10104,29 @@ ${extra}` : body);
           return;
         }
         const mark = (s) => s === "running" ? cyan("\u25D4 running") : s === "done" ? green("\u2713 done") : s === "cancelled" ? yellow("\u2298 cancelled") : red(`\u2717 ${s}`);
-        if (!process.stderr.isTTY || !process.stdin.isTTY) {
-          for (const t of all) err(`  ${t.id}  ${mark(t.status)}  ${dim(t.label.slice(0, 60))}
+        const inspect = (t2) => {
+          err(`  ${t2.id}  ${mark(t2.status)}  ${dim(t2.label)}
 `);
+          for (const l of t2.tail.slice(-20)) err(dim(`    ${l}
+`));
+          if (t2.result) err(dim(`    \u29BF ${t2.result.split("\n")[0].slice(0, 160)}
+`));
+          if (!t2.tail.length && !t2.result) err(dim("    (no activity yet)\n"));
+        };
+        if (!process.stderr.isTTY || !process.stdin.isTTY) {
+          for (const t2 of all) inspect(t2);
           return;
         }
-        const items = all.map((t) => ({ label: `${t.id}  ${t.label.slice(0, 60)}`, value: t.id, desc: mark(t.status) + (t.status === "running" ? " \xB7 \u21B5 to cancel" : "") }));
-        const id = await selectMenu(process.stderr, { title: "Background tasks \xB7 \u21B5 cancel running \xB7 esc close", items });
-        if (id) err(dim(`  ${dx.cancelTask(String(id))}
+        const items = all.map((t2) => ({ label: `${t2.id}  ${t2.label.slice(0, 60)}`, value: t2.id, desc: mark(t2.status) + " \xB7 \u21B5 inspect" }));
+        const id = await selectMenu(process.stderr, { title: "Background tasks \xB7 \u21B5 inspect \xB7 esc close", items });
+        if (!id) return;
+        const t = dx.tasks.get(String(id));
+        inspect(t);
+        if (t.status === "running") {
+          const v = await selectMenu(process.stderr, { title: `Cancel ${t.id}?`, items: [{ label: "Keep running", value: "keep" }, { label: "Cancel the task", value: "cancel" }], current: "keep" });
+          if (v === "cancel") err(dim(`  ${dx.cancelTask(t.id)}
 `));
+        }
       }
     } } : {},
     reasoning: {