agent.libx.js 0.92.2 → 0.92.4

package/cli/cli.ts

@@ -358,23 +358,38 @@ function makeHost(format: 'text' | 'json' | 'stream-json' = 'text', opts?: { str
   };
 }
 
-/** Hooks that render tool activity to stderr: a preToolUse header, and for edits a colorized diff. */
-function displayHooks(fs?: IFilesystem): Hooks {
+/** Hooks that render tool activity to stderr: a preToolUse header, and for edits a colorized diff.
+ *  `opts.background` marks the agent as a BACKGROUND one (duplex workers): its chrome lands async on
+ *  top of a live prompt, so it must never drive the foreground spinner (the 'agentx › '/'⠹ thinking…'
+ *  flicker), clears the prompt line before printing, and repaints via the callback after. `opts.gate`
+ *  is evaluated per call — false renders nothing (minimal mode: task events only). */
+function displayHooks(fs?: IFilesystem, opts?: { gate?: () => boolean; background?: () => void }): Hooks {
   const EDIT = new Set(['Edit', 'MultiEdit', 'Write']);
   const before = new Map<string, string>();
   const MAX = 64 * 1024; // skip diffing very large files
+  const bg = opts?.background;
+  const on = () => !opts?.gate || opts.gate();
   const read = async (p: unknown): Promise<string> => {
     if (!fs || typeof p !== 'string') return '';
     try { return await fs.readFile(p); } catch { return ''; }
   };
   return {
     async preToolUse(call) {
-      spinner.stop(); // a tool is about to run → stop "thinking…"
+      if (!on()) return;
+      if (bg) err('\r\x1b[0J'); else spinner.stop(); // foreground: a tool is about to run → stop "thinking…"
       err(cyan(`\n  ⚙ ${call.name}`) + dim(' ' + summarizeCall(call.name, call.args)) + '\n');
       if (EDIT.has(call.name)) before.set(String(call.args?.path), await read(call.args?.path));
+      bg?.();
+    },
+    onToolOutput(_call, chunk) {
+      if (!verboseOutput || !on()) return; // Ctrl+O verbose: live-tail streaming tool output (default chrome stays calm)
+      if (bg) err('\r\x1b[0J');
+      for (const ln of String(chunk).split('\n')) if (ln.trim()) err(dim(`    ⋮ ${ln.length > 200 ? ln.slice(0, 200) + '…' : ln}\n`));
+      bg?.();
     },
     async postToolUse(call, result) {
-      spinner.stop();
+      if (!on()) return;
+      if (bg) err('\r\x1b[0J'); else spinner.stop();
       try {
         if (EDIT.has(call.name)) {
           const path = String(call.args?.path);
@@ -401,7 +416,8 @@ function displayHooks(fs?: IFilesystem): Hooks {
           err(dim('    ⎿ (no output)\n')); // empty result → confirm completion so it doesn't look hung
         }
       } finally {
-        spinner.start(); // tool done → the model is thinking about the next step
+        if (bg) bg(); // background: repaint the live prompt below the chrome — NEVER the spinner
+        else spinner.start(); // foreground: tool done → the model is thinking about the next step
       }
     },
   };
@@ -961,6 +977,9 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
   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
   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.
+  let workerChrome: 'full' | 'minimal' = 'full';
   let duplexPersist: () => void = () => {}; // bound once the session exists (re-voice fires async)
   let duplexAccount: (data: any) => void = () => {}; // worker cost → session meta (bound below)
   // Workers are non-interactive: a permission 'ask' can't pop a menu mid-conversation (it would fight
@@ -978,6 +997,11 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     if (workerOptions.permissions)
       workerOptions.permissions = new PermissionPolicy({ ...workerOptions.permissions.options, host: undefined, ask: duplexAsk });
     workerOptions.planMode = false; // a worker's plan could never be approved (no host) — it would stall to maxSteps
+    // Workers are BACKGROUND agents: rebuild their display hooks so chrome never drives the foreground
+    // spinner (the 'agentx › '/'⠹ thinking…' flicker) and repaints the live prompt after each print.
+    workerChrome = args.voice ? 'minimal' : (cfg.workerChrome ?? 'full');
+    const workerDisplay = displayHooks(agent.options.fs, { gate: () => workerChrome === 'full', background: () => editorRef?.redrawNow() });
+    workerOptions.hooks = cfg.hooks ? composeHooks(workerDisplay, hooksFromConfig(cfg.hooks)) : workerDisplay;
     // The single voice: markdown-rendered deltas on stdout = the SPOKEN channel. Everything else
     // (⚙ tool chrome, task events, worker results) is VISUAL chrome on stderr — when wired to a
     // real voice API, only text_delta becomes speech; the rest feeds the screen.
@@ -1395,7 +1419,13 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
         else err(dim('  ' + (duplex ? `voice ${dx!.options.voiceModel} · worker ${work.model}` : work.model) + '\n'));
       },
     },
-    ...(duplex ? { 'voice-model': {
+    ...(duplex ? { workers: {
+      desc: 'duplex worker chrome — /workers <full|minimal>: per-step ⚙ tool activity vs task events only',
+      run: async (a: string[]) => {
+        if (a[0] === 'full' || a[0] === 'minimal') { workerChrome = a[0]; err(green(`  ✓ worker chrome → ${a[0]}\n`)); return; }
+        err(dim(`  worker chrome: ${workerChrome} (use /workers full|minimal)\n`));
+      },
+    }, 'voice-model': {
       desc: 'switch the duplex voice (fast) model — /voice-model <id>, or alone for a picker',
       run: async (a: string[]) => {
         const apply = (id: string) => {

package/dist/{Agent-BzwprwHr.d.ts → Agent-QwBA0wu6.d.ts}

@@ -1,5 +1,5 @@
 import { IFilesystem } from '@livx.cc/wcli/core';
-import { M as Message, H as HostBridge, A as AgentTool, C as ChatLike, e as MessageContent } from './tools-CeK5AquG.js';
+import { M as Message, H as HostBridge, A as AgentTool, C as ChatLike, e as MessageContent } from './tools-GPWp7oXq.js';
 
 /**
  * Hooks — deterministic interception points around tool execution, run by the
@@ -31,6 +31,9 @@ interface Hooks {
     preToolUse?(call: ToolUse, meta?: ToolUseMeta): Promise<PreToolUseDecision | void> | PreToolUseDecision | void;
     /** Observe a tool's result after it ran (audit, metrics, side-channel). */
     postToolUse?(call: ToolUse, result: string, meta?: ToolUseMeta): void | Promise<void>;
+    /** Observe a tool's INCREMENTAL output while it runs (only tools that stream, e.g. the real
+     *  Shell). Fire-and-forget — sync, never awaited, never alters the result. */
+    onToolOutput?(call: ToolUse, chunk: string, meta?: ToolUseMeta): void;
     /** Fired once when the agent loop stops cleanly with the model's final text. */
     onStop?(finalText: string): void;
     /** Fired once at session start (a fresh `run()`, or the first `send()`). Return a string to inject
@@ -59,11 +62,17 @@ declare class RecordingHooks implements Hooks {
         result: string;
         meta?: ToolUseMeta;
     }>;
+    outputs: Array<{
+        call: ToolUse;
+        chunk: string;
+        meta?: ToolUseMeta;
+    }>;
     stops: string[];
     /** tool name -> reason; a matching preToolUse call is blocked with that reason. */
     constructor(blocks?: Record<string, string>);
     preToolUse(call: ToolUse, meta?: ToolUseMeta): PreToolUseDecision | void;
     postToolUse(call: ToolUse, result: string, meta?: ToolUseMeta): void;
+    onToolOutput(call: ToolUse, chunk: string, meta?: ToolUseMeta): void;
     onStop(finalText: string): void;
 }
 /** Recording lifecycle hooks for tests: capture session-start/prompt-submit/pre-compact + script transforms. */

package/dist/cli.d.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
-import { h as RunResult, R as ReasoningEffort } from './Agent-BzwprwHr.js';
+import { h as RunResult, R as ReasoningEffort } from './Agent-QwBA0wu6.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
-import { M as Message, c as ContentPart } from './tools-CeK5AquG.js';
+import { M as Message, c as ContentPart } from './tools-GPWp7oXq.js';
 
 /**
  * On-disk session store for the CLI: each conversation is one JSON file at

package/dist/cli.js

@@ -1386,6 +1386,18 @@ function makeRealShellTool(options) {
         timedOut = true;
         ctl.abort();
       }, timeoutMs);
+      let pend = "";
+      let flushTimer = null;
+      const flushEmit = (ctx2) => {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = null;
+        }
+        if (pend) {
+          ctx2.emit?.(redactSecrets(pend));
+          pend = "";
+        }
+      };
       try {
         return await new Promise((resolve4) => {
           let out = "";
@@ -1402,7 +1414,13 @@ function makeRealShellTool(options) {
             return finish(`[exit 1] failed to spawn shell: ${e?.message ?? e}`);
           }
           const collect = (chunk) => {
-            out += typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+            const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+            out += s;
+            if (ctx.emit && !settled) {
+              pend += s;
+              if (pend.length >= 1024) flushEmit(ctx);
+              else flushTimer ??= setTimeout(() => flushEmit(ctx), 250);
+            }
           };
           proc.stdout?.on("data", collect);
           proc.stderr?.on("data", collect);
@@ -1412,6 +1430,7 @@ function makeRealShellTool(options) {
             finish(`[exit 1] ${err2?.message ?? err2}${out ? "\n" + clean(out) : ""}`);
           });
           proc.on("close", (code) => {
+            flushEmit(ctx);
             if (ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean(out)));
             const body = clean(out);
             if (code && code !== 0) return finish(`[exit ${code}]${body ? "\n" + body : ""}`);
@@ -1420,6 +1439,7 @@ function makeRealShellTool(options) {
         });
       } finally {
         clearTimeout(timer);
+        if (flushTimer) clearTimeout(flushTimer);
         ctx.signal?.removeEventListener("abort", onAbort);
       }
     }
@@ -2409,6 +2429,9 @@ function composeHooks(...list) {
     async postToolUse(call, result, meta) {
       for (const h of hooks) await h.postToolUse?.(call, result, meta);
     },
+    onToolOutput(call, chunk, meta) {
+      for (const h of hooks) h.onToolOutput?.(call, chunk, meta);
+    },
     onStop(text) {
       for (const h of hooks) h.onStop?.(text);
     },
@@ -2919,6 +2942,13 @@ var Agent = class _Agent {
     let threw = false;
     try {
       log3.debug(`${tc.function.name}(${tc.function.arguments})`);
+      this.ctx.emit = hooks?.onToolOutput ? (chunk) => {
+        try {
+          hooks.onToolOutput(call, chunk, meta);
+        } catch (e) {
+          log3.debug(`onToolOutput hook error: ${e}`);
+        }
+      } : void 0;
       const raw = await tool.run(args, this.ctx);
       if (typeof raw === "string") {
         result = raw;
@@ -2931,6 +2961,8 @@ var Agent = class _Agent {
       log3.debug(`${tc.function.name} -> error: ${msg}`);
       result = `Error: ${msg}`;
       threw = true;
+    } finally {
+      this.ctx.emit = void 0;
     }
     if (!threw) result = await this.maybeAutoTest(tc.function.name, result);
     await hooks?.postToolUse?.(call, result, meta);
@@ -3514,6 +3546,10 @@ ${recent}` : brief;
       postToolUse: async (call, result, meta) => {
         await base?.postToolUse?.(call, result, meta);
         report.post(call);
+      },
+      onToolOutput: (call, chunk, meta) => {
+        base?.onToolOutput?.(call, chunk, meta);
+        report.output(chunk);
       }
     } : base;
     const worker = new Agent({
@@ -3550,13 +3586,18 @@ ${recent}` : brief;
       const rec = this.tasks.get(id);
       if (!rec || rec.status !== "running") return clearInterval(timer);
       if (!inflight || !due()) return;
-      emit(rec, `still inside ${describeCall(inflight.call)} \u2014 ${Math.round((Date.now() - inflight.at) / 1e3)}s on this step`, inflight.call);
+      const last = inflight.tail.trim().split("\n").filter(Boolean).pop()?.slice(-80);
+      emit(rec, `still inside ${describeCall(inflight.call)} \u2014 ${Math.round((Date.now() - inflight.at) / 1e3)}s on this step${last ? `, last output: ${last}` : ""}`, inflight.call);
     }, Math.max(this.options.progressIntervalMs, 250));
     timer.unref?.();
     return {
       pre: (call) => {
-        inflight = { call, at: Date.now() };
+        inflight = { call, at: Date.now(), tail: "" };
+      },
+      output: (chunk) => {
+        if (inflight) inflight.tail = (inflight.tail + chunk).slice(-500);
       },
+      // digest only — NEVER re-voices directly
       post: (call) => {
         steps++;
         inflight = null;
@@ -7087,10 +7128,12 @@ function makeHost(format = "text", opts) {
     }
   };
 }
-function displayHooks(fs) {
+function displayHooks(fs, opts) {
   const EDIT = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "Write"]);
   const before = /* @__PURE__ */ new Map();
   const MAX = 64 * 1024;
+  const bg = opts?.background;
+  const on = () => !opts?.gate || opts.gate();
   const read = async (p) => {
     if (!fs || typeof p !== "string") return "";
     try {
@@ -7101,13 +7144,25 @@ function displayHooks(fs) {
   };
   return {
     async preToolUse(call) {
-      spinner.stop();
+      if (!on()) return;
+      if (bg) err("\r\x1B[0J");
+      else spinner.stop();
       err(cyan(`
   \u2699 ${call.name}`) + dim(" " + summarizeCall(call.name, call.args)) + "\n");
       if (EDIT.has(call.name)) before.set(String(call.args?.path), await read(call.args?.path));
+      bg?.();
+    },
+    onToolOutput(_call, chunk) {
+      if (!verboseOutput || !on()) return;
+      if (bg) err("\r\x1B[0J");
+      for (const ln of String(chunk).split("\n")) if (ln.trim()) err(dim(`    \u22EE ${ln.length > 200 ? ln.slice(0, 200) + "\u2026" : ln}
+`));
+      bg?.();
     },
     async postToolUse(call, result) {
-      spinner.stop();
+      if (!on()) return;
+      if (bg) err("\r\x1B[0J");
+      else spinner.stop();
       try {
         if (EDIT.has(call.name)) {
           const path = String(call.args?.path);
@@ -7136,7 +7191,8 @@ function displayHooks(fs) {
           err(dim("    \u23BF (no output)\n"));
         }
       } finally {
-        spinner.start();
+        if (bg) bg();
+        else spinner.start();
       }
     }
   };
@@ -7648,6 +7704,7 @@ async function repl(args, ai, cfg, cwd) {
   let voiceIO;
   let editorRef;
   let workerOptions;
+  let workerChrome = "full";
   let duplexPersist = () => {
   };
   let duplexAccount = () => {
@@ -7663,6 +7720,9 @@ async function repl(args, ai, cfg, cwd) {
     if (workerOptions.permissions)
       workerOptions.permissions = new PermissionPolicy({ ...workerOptions.permissions.options, host: void 0, ask: duplexAsk });
     workerOptions.planMode = false;
+    workerChrome = args.voice ? "minimal" : cfg.workerChrome ?? "full";
+    const workerDisplay = displayHooks(agent.options.fs, { gate: () => workerChrome === "full", background: () => editorRef?.redrawNow() });
+    workerOptions.hooks = cfg.hooks ? composeHooks(workerDisplay, hooksFromConfig(cfg.hooks)) : workerDisplay;
     const base = makeHost("text", { stream: true });
     const host = {
       ...base,
@@ -8121,7 +8181,19 @@ ${extra}` : body);
         else err(dim("  " + (duplex ? `voice ${dx.options.voiceModel} \xB7 worker ${work.model}` : work.model) + "\n"));
       }
     },
-    ...duplex ? { "voice-model": {
+    ...duplex ? { workers: {
+      desc: "duplex worker chrome \u2014 /workers <full|minimal>: per-step \u2699 tool activity vs task events only",
+      run: async (a) => {
+        if (a[0] === "full" || a[0] === "minimal") {
+          workerChrome = a[0];
+          err(green(`  \u2713 worker chrome \u2192 ${a[0]}
+`));
+          return;
+        }
+        err(dim(`  worker chrome: ${workerChrome} (use /workers full|minimal)
+`));
+      }
+    }, "voice-model": {
       desc: "switch the duplex voice (fast) model \u2014 /voice-model <id>, or alone for a picker",
       run: async (a) => {
         const apply = (id) => {