agent.libx.js 0.93.18 → 0.93.20

package/README.md

@@ -77,7 +77,7 @@ agentx --resume <id> "…"    # resume a specific session
 - **@-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 dual-model engine driving turns: a fast voice model (`--voice-model`, default haiku) 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.
-- **MCP servers** — declare `mcpServers: { name: { command, args } | { url } }` in config and they're auto-mounted at startup: 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.
+- **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.
 
 ## 🧬 It improves itself
 

package/cli/cli.ts

@@ -1035,6 +1035,9 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
   let dx: DuplexAgent | undefined;
   let voiceIO: VoiceIO | undefined; // real voice I/O (--voice + keys): mic→STT in, text_delta→TTS out
   let editorRef: LineEditor | undefined; // bound once the line editor exists — async chrome repaints the prompt via it
+  // During a turn the user's type-ahead lives on a "stash ›" line (no active editor to own it). Async
+  // chrome (streamed deltas, task events) lands on top of it — repaint the stash below, so it survives.
+  let repaintStash: () => void = () => {};
   let workerOptions: AgentOptions | undefined;
   // Worker UI verbosity: 'full' = ⚙ tool chrome per worker step; 'minimal' = task events only
   // (started/progress/⦿ done). Voice defaults minimal (chrome is noise next to speech); /workers toggles live.
@@ -1110,6 +1113,13 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
         if (e.kind === 'text_delta' && voiceIO) {
           voiceIO.speakDelta(e.message);
           editorRef?.suspend(); // no-op when already suspended
+        } else if (e.kind === 'text_delta' && stashBuf) {
+          // TEXT mode with type-ahead pending: lift the sacred stash line, let the markdown stream
+          // land, then repaint the stash below it (else the streamed ack overwrites what's being typed).
+          process.stdout.write('\r\x1b[K');
+          base.notify!(e);
+          repaintStash();
+          return;
         }
         if (e.kind === 'hold_filler' && voiceIO) {
           voiceIO.speakFiller(e.message);
@@ -1135,6 +1145,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           if (lines.length > shown.length) err(dim(`    … (+${lines.length - shown.length} more lines)\n`));
           duplexAccount(e.data); // worker tokens/cost are real spend — fold into /cost
           editorRef?.redrawNow();
+          repaintStash(); // type-ahead survives the async ⦿ landing
           return;
         }
         // Remaining task_* events (started/progress/cancelled/error) land ASYNC at a live prompt —
@@ -1145,6 +1156,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           // asks are decisions, not chatter — make them stand out (the voice also speaks them)
           err('\r\x1b[0J' + (e.kind === 'task_ask' ? yellow(`  ? ${e.message} — answer by voice or type yes/no\n`) : dim(`  · ${e.message}\n`)));
           editorRef?.redrawNow();
+          repaintStash(); // type-ahead survives the async task event landing
           return;
         }
         base.notify!(e); // makeHost always provides notify (the HostBridge type just marks it optional)
@@ -1921,6 +1933,8 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       const q = inputStash.length ? dim(` [${inputStash.length} queued]`) : '';
       err(`\r\x1b[K${dim('  stash › ')}${stashBuf}${q}`);
     };
+    repaintStash = renderStashBuf; // async chrome repaints the type-ahead line through this
+
     process.stdin.on('keypress', (_s, key) => {
       if (!activeTurn) return;
       if (key?.ctrl && key?.name === 'o') { toggleVerbose(); return; }
@@ -2064,9 +2078,12 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
   while (true) {
     // Double-Esc fired during the just-finished turn → open the jump-back picker now (turn has unwound).
     if (pendingRewind) { pendingRewind = false; const t = await rewindToMessage(); if (t !== undefined) prefill = t; }
-    aborting = false; stashBuf = ''; // re-arm cancel for the next turn
+    aborting = false;
+    const carry = stashBuf; stashBuf = ''; // type-ahead typed (not Enter'd) during the turn → carry it forward
     err('\n'); // blank line before the prompt (the editor renders on one line)
-    const initial = prefill; prefill = undefined; // consume the pending jump-back text (once)
+    // Consume the pending jump-back text (once); else fall back to un-submitted type-ahead so a line
+    // typed while the turn ran isn't lost — it lands editable in the fresh prompt (CC parity).
+    const initial = prefill ?? (carry || undefined); prefill = undefined;
     // Dim status footer under the prompt (context% · cost). Constant while typing one line (transcript is
     // fixed until submit), so compute once per iteration. Hidden on a fresh REPL (no usage yet) to stay clean.
     const ctxTok = estimateTranscriptTokens(face.transcript); // expensive: compute once per iteration (not per keystroke)

package/dist/cli.js

@@ -8600,6 +8600,8 @@ async function repl(args, ai, cfg, cwd) {
   let dx;
   let voiceIO;
   let editorRef;
+  let repaintStash = () => {
+  };
   let workerOptions;
   let workerChrome = "full";
   let duplexPersist = () => {
@@ -8655,6 +8657,11 @@ async function repl(args, ai, cfg, cwd) {
         if (e.kind === "text_delta" && voiceIO) {
           voiceIO.speakDelta(e.message);
           editorRef?.suspend();
+        } else if (e.kind === "text_delta" && stashBuf) {
+          process.stdout.write("\r\x1B[K");
+          base.notify(e);
+          repaintStash();
+          return;
         }
         if (e.kind === "hold_filler" && voiceIO) {
           voiceIO.speakFiller(e.message);
@@ -8679,6 +8686,7 @@ async function repl(args, ai, cfg, cwd) {
 `));
           duplexAccount(e.data);
           editorRef?.redrawNow();
+          repaintStash();
           return;
         }
         if (typeof e.kind === "string" && e.kind.startsWith("task_")) {
@@ -8687,6 +8695,7 @@ async function repl(args, ai, cfg, cwd) {
 `) : dim(`  \xB7 ${e.message}
 `)));
           editorRef?.redrawNow();
+          repaintStash();
           return;
         }
         base.notify(e);
@@ -9681,6 +9690,7 @@ ${extra}` : body);
       const q2 = inputStash.length ? dim(` [${inputStash.length} queued]`) : "";
       err(`\r\x1B[K${dim("  stash \u203A ")}${stashBuf}${q2}`);
     };
+    repaintStash = renderStashBuf;
     process.stdin.on("keypress", (_s, key) => {
       if (!activeTurn) return;
       if (key?.ctrl && key?.name === "o") {
@@ -9870,9 +9880,10 @@ ${extra}` : body);
       if (t !== void 0) prefill = t;
     }
     aborting = false;
+    const carry = stashBuf;
     stashBuf = "";
     err("\n");
-    const initial = prefill;
+    const initial = prefill ?? (carry || void 0);
     prefill = void 0;
     const ctxTok = estimateTranscriptTokens(face.transcript);
     const ctxCap = face.options.maxTokens || 2e5;