agent.libx.js 0.94.4 → 0.94.6

package/README.md

@@ -104,14 +104,14 @@ agentx --resume <id> "…"    # resume a specific session
 ```
 
 - **Filesystem + Shell** — by default the CLI has **full real-filesystem access like Claude Code** (root `/` is the machine root, the launch dir is the working dir, absolute host paths and above-cwd reach both work) with a **real `/bin/sh`** (`Shell` tool) so the agent can run git, bun, node, curl, and any installed binary. Secrets (`.env`, `.ssh`, keys, `.git`) stay hidden by the jail; env secrets are scrubbed from the child shell. `--sandbox` instead operates over an in-memory copy of the working dir with a VFS-only `bash` — the real disk is never touched. `--boddb <dir>` runs over a **persistent database workspace** (a bod-db store at `<dir>` — `meta.db` tree + `files/` bytes) that survives across runs while the real disk stays untouched; DB-native by default, or add `--seed` to hydrate it from cwd on the first run. `--no-shell` forces the VFS bash in disk mode. (`/sandbox` shows the active mode.)
-- **Sessions** — every conversation persists to `./.agent/sessions/<id>.json`; `--continue`/`--resume` (and `/sessions`, `/resume`) pick it back up, *with memory across turns* — a REPL turn sees the previous one. A global symlink index at `~/.agent/sessions/` enables cross-project lookup: `--resume 090715-335` resolves from any directory, and `/sessions all` lists every project's sessions in one picker.
+- **Sessions** — every conversation persists to `./.agent/sessions/<id>.json`; `--continue`/`--resume` (and `/sessions`, `/resume`) pick it back up, *with memory across turns* — a REPL turn sees the previous one. A global symlink index at `~/.agent/sessions/` enables cross-project lookup: `--resume 090715-myproject` resolves from any directory, and `/sessions all` lists every project's sessions in one picker.
 - **Diffs** — every `Edit`/`Write`/`MultiEdit` renders a colorized `+/-` diff (TTY-gated; plain when piped).
 - **Slash commands** — `/help /tools /model /compact /clear /sessions /resume /commands /init`; user-defined `./.agent/commands/<name>.md` are invokable directly as `/<name>` (the same registry the model's `SlashCommand` tool uses).
 - **Project instructions** — `./AGENTS.md` (or `CLAUDE.md`) auto-loads into every run; `/init` scaffolds one.
 - **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}`);
@@ -6581,7 +6591,17 @@ var SessionStore = class {
     const d = new Date(now5);
     const p = (n, w = 2) => String(n).padStart(w, "0");
     const slug2 = (cwd ?? process.cwd()).split("/").pop()?.replace(/[^A-Za-z0-9_-]/g, "") || "session";
-    return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${slug2}`;
+    let id = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${slug2}`;
+    if (existsSync5(this.dir) && existsSync5(join6(this.dir, `${id}.json`))) {
+      for (let i = 2; i <= 99; i++) {
+        const c = `${id}-${i}`;
+        if (!existsSync5(join6(this.dir, `${c}.json`))) {
+          id = c;
+          break;
+        }
+      }
+    }
+    return id;
   }
   /** A session id must be one safe path segment — blocks `../`-style traversal via --resume/load/save. */
   safeId(id) {
@@ -7771,7 +7791,7 @@ function applyKey(s, key, str) {
       }
       if (s.vim === "normal" && s.buf.length) return "none";
       if (s.buf.length) return "cancel";
-      if (wasEsc) return "rewind";
+      if (wasEsc || key?.sequence === "\x1B\x1B") return "rewind";
       s.prevEsc = true;
       return "none";
     // first Esc on empty → arm double-Esc
@@ -10067,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) {
@@ -10084,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: {