agent.libx.js 0.93.17 → 0.93.19

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

@@ -3575,6 +3575,17 @@ var DuplexAgent = class {
   seq = 0;
   pendingEvents = [];
   flushQueued = false;
+  /** Per-voice-turn guards (reset by resetTurn at each turn's start). The reflex is a weak model:
+   *  left unguarded it polls TaskStatus after a dispatch and/or dispatches silently (dead air).
+   *  Like CC's Task tool, a dispatch is "said my piece, now wait for the push" — these enforce that. */
+  turnDispatched = false;
+  // an Act/Think fired this turn
+  turnBriefs = /* @__PURE__ */ new Set();
+  // briefs dispatched this turn (detect identical re-dispatch)
+  spokeThisTurn = false;
+  // any non-empty text_delta streamed this turn
+  nudging = false;
+  // re-ack pass in flight: block ALL tools, prevent recursion
   /** Parked worker questions awaiting a (voice-relayed) user answer, keyed by ask id. */
   pendingAsks = /* @__PURE__ */ new Map();
   /** Lazily resolved memory tools (async loadMemory runs in initMemory). */
@@ -3599,12 +3610,21 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       this.answerTaskTool(),
       this.holdTool()
     ];
+    const host = o.host;
+    const voiceHost = host && {
+      ask: host.ask ? (q2) => host.ask(q2) : void 0,
+      confirm: host.confirm ? (p, m) => host.confirm(p, m) : void 0,
+      notify: (ev) => {
+        if (ev?.kind === "text_delta" && typeof ev.message === "string" && ev.message.trim()) this.spokeThisTurn = true;
+        host.notify?.(ev);
+      }
+    };
     this.voice = new Agent({
       ai: o.ai,
       fs: new MemFilesystem2(),
       model: o.reflexModel,
       stream: true,
-      host: o.host,
+      host: voiceHost,
       // The reflex IS the conversational channel — it confirms ambiguity inline ("did you mean…?"),
       // never via the blocking AskUserQuestion tool (Agent auto-adds it whenever a host is set). Left in,
       // it stalls a voice turn until the kill-switch. Worker questions still reach the user via parkQuestion.
@@ -3614,7 +3634,9 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       maxSteps: 8,
       timeoutMs: 3e4,
       ...o.reflexOptions,
-      tools
+      tools,
+      // Composed AFTER the spread so the dispatch guard can't be dropped by reflexOptions.
+      hooks: composeHooks(this.dispatchGuard(), o.reflexOptions?.hooks)
     });
   }
   /** Resolve memory tools + inject index into voice system prompt (once). */
@@ -3625,11 +3647,54 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
     this.voice.options.tools.push(...mem.tools);
     if (mem.index) this.voice.options.systemPrompt += "\n\n" + mem.index;
   }
+  /** Clear the per-turn guards. Called at the head of every voice turn (user send + re-voice flush). */
+  resetTurn() {
+    this.turnDispatched = false;
+    this.turnBriefs.clear();
+    this.spokeThisTurn = false;
+  }
+  /** preToolUse guard on the reflex: once it has dispatched this turn, a dispatch is "said my piece,
+   *  now wait for the push" (CC's Task model). Block the temptations — TaskStatus polling and identical
+   *  re-dispatch — so the only remaining move is to voice a short ack and end. A genuinely NEW Act is
+   *  still allowed (parallel independent work). During a re-ack pass, block every tool. */
+  dispatchGuard() {
+    return {
+      preToolUse: (call) => {
+        if (this.nudging) return { block: true, reason: "Just say one short spoken acknowledgement \u2014 no tools this turn." };
+        if (!this.turnDispatched) return;
+        if (call.name === "TaskStatus")
+          return { block: true, reason: "You just dispatched a task this turn \u2014 do NOT poll. Give one short spoken acknowledgement and end your turn; the result arrives later as a [task \u2026] event." };
+        if ((call.name === "Act" || call.name === "Think") && this.turnBriefs.has(String(call.args?.brief ?? "")))
+          return { block: true, reason: "You already dispatched this exact task \u2014 acknowledge briefly and end your turn." };
+      }
+    };
+  }
+  /** True when the just-finished turn dispatched a task but voiced nothing — dead air to repair.
+   *  Requires a host: without one there's no stream to detect speech on (and no one to speak to). */
+  get silentDispatch() {
+    return !!this.options.host && this.turnDispatched && !this.spokeThisTurn;
+  }
+  /** A dispatch with no spoken text is dead air. Re-prompt the reflex ONCE so the LLM itself voices a
+   *  short ack (no template). If it STILL says nothing, fall back to a minimal line so silence never ships. */
+  async ackIfSilent() {
+    this.nudging = true;
+    try {
+      await this.voice.send("[reminder] You dispatched a task but said nothing to the user. Say ONE short spoken acknowledgement now \u2014 no tools.");
+    } catch (e) {
+      log6.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+    } finally {
+      this.nudging = false;
+    }
+    if (!this.spokeThisTurn) this.options.host?.notify?.({ kind: "text_delta", message: "Okay, on it." });
+  }
   /** One user turn: the voice agent streams the reply (and may Act/Think). Serialized with re-voice turns. */
   send(content) {
     return this.enqueue(async () => {
       await this.initMemory();
-      return this.voice.send(content);
+      this.resetTurn();
+      const res = await this.voice.send(content);
+      if (this.silentDispatch) await this.ackIfSilent();
+      return res;
     });
   }
   /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
@@ -3662,7 +3727,9 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       this.flushQueued = false;
       const events = this.pendingEvents.splice(0);
       if (!events.length) return;
+      this.resetTurn();
       await this.voice.send(events.join("\n"));
+      if (this.silentDispatch) await this.ackIfSilent();
       this.notify("revoice_done", "");
     });
   }
@@ -3895,6 +3962,8 @@ Another agent just implemented the above. Independently check the CURRENT state
         }
       },
       run: async ({ brief, label }) => {
+        this.turnDispatched = true;
+        this.turnBriefs.add(String(brief ?? ""));
         const id = await this.dispatch(String(brief ?? ""), "act", label ? String(label) : void 0);
         return `Acting on task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
       }
@@ -3913,6 +3982,8 @@ Another agent just implemented the above. Independently check the CURRENT state
         }
       },
       run: async ({ brief, label }) => {
+        this.turnDispatched = true;
+        this.turnBriefs.add(String(brief ?? ""));
         const id = await this.dispatch(String(brief ?? ""), "think", label ? String(label) : void 0);
         return `Thinking on task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
       }
@@ -4781,6 +4852,7 @@ import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor a
 // src/mcp.client.ts
 init_logging();
 import { spawn } from "child_process";
+import { createHash } from "crypto";
 var log10 = forComponent("mcp");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -4973,37 +5045,136 @@ var McpClient = class {
     await this.transport.close();
   }
 };
-async function mountMcpServer(name, cfg) {
-  const transport = cfg.url ? new HttpTransport({ url: cfg.url, headers: cfg.headers, bearerToken: cfg.bearerToken, timeoutMs: cfg.timeoutMs }) : new StdioTransport({ command: cfg.command, args: cfg.args, env: cfg.env, cwd: cfg.cwd, timeoutMs: cfg.timeoutMs });
-  const client = new McpClient(transport);
-  const init = await client.connect();
-  const specs = await client.listTools();
-  const tools = mcpToolsToAgentTools(specs, (tool, a) => client.callTool(tool, a), `mcp__${name}__`);
-  return { name, client, tools, specs, serverInfo: init?.serverInfo };
-}
-async function mountMcpServers(servers = {}) {
-  const out = [];
-  for (const [name, cfg] of Object.entries(servers)) {
-    if (!cfg || cfg.disabled) continue;
+function buildTransport(cfg) {
+  return cfg.url ? new HttpTransport({ url: cfg.url, headers: cfg.headers, bearerToken: cfg.bearerToken, timeoutMs: cfg.timeoutMs }) : new StdioTransport({ command: cfg.command, args: cfg.args, env: cfg.env, cwd: cfg.cwd, timeoutMs: cfg.timeoutMs });
+}
+function withTimeout(p, ms, label) {
+  if (!ms || ms <= 0) return p;
+  return new Promise((resolve4, reject) => {
+    const timer = setTimeout(() => reject(new Error(`MCP "${label}" mount exceeded ${ms}ms`)), ms);
+    timer.unref?.();
+    p.then((v) => {
+      clearTimeout(timer);
+      resolve4(v);
+    }, (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+  });
+}
+async function mountWithDeadline(name, cfg, mountTimeoutMs) {
+  const client = new McpClient(buildTransport(cfg));
+  try {
+    return await withTimeout((async () => {
+      const init = await client.connect();
+      const specs = await client.listTools();
+      const tools = mcpToolsToAgentTools(specs, (tool, a) => client.callTool(tool, a), `mcp__${name}__`);
+      return { name, client, tools, specs, serverInfo: init?.serverInfo };
+    })(), mountTimeoutMs, name);
+  } catch (e) {
+    await client.close().catch((err2) => log10.debug(`close after failed mount of "${name}": ${err2}`));
+    throw e;
+  }
+}
+function mountMcpServer(name, cfg) {
+  return mountWithDeadline(name, cfg);
+}
+function validEntries(servers) {
+  return Object.entries(servers).filter(([name, cfg]) => {
+    if (!cfg || cfg.disabled) return false;
     if (!cfg.command && !cfg.url) {
       log10.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
-      continue;
-    }
-    try {
-      const m = await mountMcpServer(name, cfg);
-      out.push(m);
-      log10.info(`MCP "${name}" mounted \u2014 ${m.tools.length} tool(s)${m.serverInfo?.name ? ` from ${m.serverInfo.name}` : ""}`);
-    } catch (e) {
-      if (e instanceof McpAuthError) log10.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
-      else log10.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
+      return false;
     }
-  }
+    return true;
+  });
+}
+function logMountFailure(name, e) {
+  if (e instanceof McpAuthError) log10.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
+  else log10.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
+}
+async function mountMcpServers(servers = {}, opts = {}) {
+  const entries = validEntries(servers);
+  const settled = await Promise.allSettled(entries.map(([name, cfg]) => mountWithDeadline(name, cfg, opts.mountTimeoutMs)));
+  const out = [];
+  settled.forEach((r, i) => {
+    const name = entries[i][0];
+    if (r.status === "fulfilled") {
+      out.push(r.value);
+      log10.info(`MCP "${name}" mounted \u2014 ${r.value.tools.length} tool(s)${r.value.serverInfo?.name ? ` from ${r.value.serverInfo.name}` : ""}`);
+    } else logMountFailure(name, r.reason);
+  });
   return out;
 }
+var MemMcpCatalog = class {
+  constructor(ttlMs = 5 * 6e4) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  m = /* @__PURE__ */ new Map();
+  get(key) {
+    const e = this.m.get(key);
+    if (!e) return null;
+    if (Date.now() > e.exp) {
+      this.m.delete(key);
+      return null;
+    }
+    return e.specs;
+  }
+  set(key, specs) {
+    this.m.set(key, { specs, exp: Date.now() + this.ttlMs });
+  }
+};
+var McpPool = class {
+  constructor(ttlMs = 5 * 6e4) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  warm = /* @__PURE__ */ new Map();
+  get(key) {
+    const e = this.warm.get(key);
+    if (!e) return null;
+    this.arm(key, e);
+    return e.client;
+  }
+  put(key, client) {
+    const prev = this.warm.get(key);
+    if (prev) {
+      clearTimeout(prev.timer);
+      if (prev.client !== client) void prev.client.close().catch((err2) => log10.debug(`warm-pool replace close failed: ${err2}`));
+    }
+    const e = { client, timer: void 0 };
+    this.warm.set(key, e);
+    this.arm(key, e);
+  }
+  arm(key, e) {
+    clearTimeout(e.timer);
+    e.timer = setTimeout(() => {
+      void this.evict(key);
+    }, this.ttlMs);
+    e.timer.unref?.();
+  }
+  async evict(key) {
+    const e = this.warm.get(key);
+    if (!e) return;
+    this.warm.delete(key);
+    await e.client.close().catch((err2) => log10.debug(`warm-pool evict close failed: ${err2}`));
+  }
+  async closeAll() {
+    for (const e of this.warm.values()) {
+      clearTimeout(e.timer);
+      await e.client.close().catch(() => {
+      });
+    }
+    this.warm.clear();
+  }
+};
+var defaultCatalog = new MemMcpCatalog();
+var defaultPool = new McpPool();
 
 // cli/mcpOAuth.ts
 import { createServer } from "http";
-import { randomBytes, createHash } from "crypto";
+import { randomBytes, createHash as createHash2 } from "crypto";
 import { readFileSync, writeFileSync as writeFileSync2, mkdirSync, existsSync } from "fs";
 import { dirname as dirname2 } from "path";
 var McpOAuthOptions = class {
@@ -5047,7 +5218,7 @@ var McpOAuth = class {
     const meta = await this.discover(serverUrl);
     const clientId = this.options.clientId ?? await this.registerClient(meta, serverUrl);
     const verifier = b64url(randomBytes(32));
-    const challenge = b64url(createHash("sha256").update(verifier).digest());
+    const challenge = b64url(createHash2("sha256").update(verifier).digest());
     const state = b64url(randomBytes(16));
     const { code, redirectUri } = await this.captureCode(meta.authorization_endpoint, clientId, challenge, state);
     const tok = await this.exchange(meta.token_endpoint, {
@@ -8429,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 = () => {
@@ -8484,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);
@@ -8508,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_")) {
@@ -8516,6 +8695,7 @@ async function repl(args, ai, cfg, cwd) {
 `) : dim(`  \xB7 ${e.message}
 `)));
           editorRef?.redrawNow();
+          repaintStash();
           return;
         }
         base.notify(e);
@@ -9510,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") {
@@ -9699,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;