agent.libx.js 0.92.1 → 0.92.3

package/cli/cli.ts

@@ -373,6 +373,10 @@ function displayHooks(fs?: IFilesystem): Hooks {
       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));
     },
+    onToolOutput(_call, chunk) {
+      if (!verboseOutput) return; // Ctrl+O verbose: live-tail streaming tool output (default chrome stays calm)
+      for (const ln of String(chunk).split('\n')) if (ln.trim()) err(dim(`    ⋮ ${ln.length > 200 ? ln.slice(0, 200) + '…' : ln}\n`));
+    },
     async postToolUse(call, result) {
       spinner.stop();
       try {
@@ -1039,7 +1043,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       workerModel: agent.options.model,
       workerOptions,
       host,
-      ...(args.voice ? { voiceStyle: 'conversational' as const } : {}),
+      ...(args.voice ? { voiceStyle: 'conversational' as const, progressUpdates: true } : {}), // voice: narrate throttled worker progress (dead air is worse than a short aside)
       // Per-TASK checkpoint frames (the natural undo unit in duplex = one delegation): opened BEFORE
       // the worker spawns (post-spawn would race its first edits). `checkpoints` is bound below.
       onTaskStart: async (_id, label) => { await checkpoints.begin(label); },

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);
@@ -3383,6 +3415,11 @@ function digestRun(messages, maxChars) {
 import { MemFilesystem as MemFilesystem2 } from "@livx.cc/wcli/core";
 init_logging();
 var log6 = forComponent("DuplexAgent");
+function describeCall(call) {
+  const v = call.args && Object.values(call.args).find((x) => typeof x === "string" && x.trim());
+  const hint = v ? ` (${String(v).replace(/\s+/g, " ").trim().slice(0, 48)})` : "";
+  return `${call.name}${hint}`;
+}
 var DuplexAgentOptions = class {
   /** Any ai.libx.js AIClient — shared by the voice and worker agents (routed by model). */
   ai;
@@ -3403,11 +3440,16 @@ var DuplexAgentOptions = class {
   /** Awaited BEFORE a delegated worker spawns — open a per-task checkpoint frame, audit, etc.
    *  (post-spawn would race the worker's first edits). */
   onTaskStart;
+  /** Re-voice throttled worker progress asides ('[task t1 progress] …') so long tasks aren't dead
+   *  air. Off by default — each update costs a voice turn (LLM call + speech). */
+  progressUpdates = false;
+  /** Min ms between progress re-voices per task. */
+  progressIntervalMs = 25e3;
   /** Host overrides for QuickLook lookups (keyed by `what`). The engine's defaults go through the
    *  (possibly jailed) fs — e.g. `.git/**` is deny-listed, so the CLI supplies 'branch' itself. */
   quickLook;
 };
-var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou work in a pair: you talk, and a background worker with FULL access to the user\'s environment (files, shell, web) does the hands-on work. You can find out or do ANYTHING by calling `Delegate` with a clear, self-contained brief \u2014 so NEVER tell the user you can\'t see, access, or do something. Delegate and find out. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), delegate IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nAfter calling Delegate, tell the user you are on it in one short sentence, then end your turn. Do not wait for the result.\nResults arrive later as events like "[task t1 completed] \u2026" or "[task t1 failed] \u2026". When one arrives, summarize it for the ear in one or two short sentences. Never read raw file paths, diffs, or code aloud verbatim.\nDo not fire a second Delegate for work already in flight \u2014 check `TaskStatus` first. Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not delegate, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file \u2014 use `QuickLook` (instant, no task). Anything requiring searching, reasoning, running commands, or editing still goes through `Delegate`.\nNEVER claim to have stored, saved, or remembered something durably \u2014 you cannot. Anything the user wants persisted (their name, preferences, notes) must be Delegated so a worker writes it to memory.\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled or surprising, briefly confirm what they meant ("did you mean\u2026?") instead of answering the literal words.';
+var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou work in a pair: you talk, and a background worker with FULL access to the user\'s environment (files, shell, web) does the hands-on work. You can find out or do ANYTHING by calling `Delegate` with a clear, self-contained brief \u2014 so NEVER tell the user you can\'t see, access, or do something. Delegate and find out. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), delegate IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nAfter calling Delegate, tell the user you are on it in one short sentence, then end your turn. Do not wait for the result.\nResults arrive later as events like "[task t1 completed] \u2026" or "[task t1 failed] \u2026". When one arrives, summarize it for the ear in one or two short sentences. "[task t1 progress] \u2026" events are interim status, NOT results \u2014 give at most a half-sentence aside ("still on it \u2014 running tests now") and end your turn. Never present progress as a finished result.\nNever read raw file paths, diffs, or code aloud verbatim.\nDo not fire a second Delegate for work already in flight \u2014 check `TaskStatus` first. Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not delegate, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file \u2014 use `QuickLook` (instant, no task). Anything requiring searching, reasoning, running commands, or editing still goes through `Delegate`.\nNEVER claim to have stored, saved, or remembered something durably \u2014 you cannot. Anything the user wants persisted (their name, preferences, notes) must be Delegated so a worker writes it to memory.\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled or surprising, briefly confirm what they meant ("did you mean\u2026?") instead of answering the literal words.';
 var VOICE_STYLE_CONVERSATIONAL = `Speak like a person in a live conversation, not an assistant reading a script. React first, then deliver: a quick impulsive beat ("oh nice", "hmm, hold on", "ah, got it") before the substance. Use contractions always. Vary sentence length \u2014 some very short. Light fillers and backchannels are fine ("mm-hm", "right", "let's see") but at most one per reply \u2014 never stack them. When you delegate, say it like a human would ("hang on, let me actually dig into that \u2014 gimme a minute") instead of announcing a task. When a result comes back, react to it like you just found out ("okay so \u2014 turns out\u2026"). Match the user's energy: a quick question gets a quick answer \u2014 a few words is a perfectly good turn. Prefer a short answer plus an offer ("want the details?") over covering everything. Never narrate your own mechanics (no "I will now delegate", no task ids out loud).`;
 var DuplexAgent = class {
   options;
@@ -3492,18 +3534,78 @@ ${recent}` : brief;
   spawnWorker(id, label, briefText) {
     const o = this.options;
     const controller = new AbortController();
+    const base = o.workerOptions?.hooks;
+    const report = o.progressUpdates ? this.progressReporter(id) : void 0;
+    const hooks = report ? {
+      ...base,
+      preToolUse: async (call, meta) => {
+        const d = await base?.preToolUse?.(call, meta);
+        report.pre(call);
+        return d;
+      },
+      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({
       ai: o.ai,
       fs: o.fs,
       model: o.workerModel,
       ...o.workerOptions,
       // may override ai/fs/model/tools/… —
+      ...hooks ? { hooks } : {},
       signal: controller.signal
       // …but never the per-task cancellation signal
     });
     const promise = worker.run(briefText).then((res) => this.onWorkerSettled(id, res)).catch((err2) => this.onWorkerFailed(id, err2));
     this.tasks.set(id, { id, label, status: "running", controller, promise });
   }
+  /** Throttled per-task progress: worker tool calls → at most one progress re-voice per interval.
+   *  Two sources, one throttle: completed steps (post) and a heartbeat for a SINGLE long tool call
+   *  (pre records the in-flight call; a self-cleaning timer narrates "still inside Bash — 70s").
+   *  Completion supersedes: nothing is emitted once the task has settled. */
+  progressReporter(id) {
+    let lastAt = Date.now();
+    let steps = 0;
+    let inflight = null;
+    const due = () => {
+      const rec = this.tasks.get(id);
+      return rec && rec.status === "running" && Date.now() - lastAt >= this.options.progressIntervalMs ? rec : void 0;
+    };
+    const emit = (rec, line, call) => {
+      lastAt = Date.now();
+      this.notify("task_progress", `task ${id} (${rec.label}): ${line}`, { id, steps, call: call.name });
+      this.queueRevoice(`[task ${id} progress] ${line}`);
+    };
+    const timer = setInterval(() => {
+      const rec = this.tasks.get(id);
+      if (!rec || rec.status !== "running") return clearInterval(timer);
+      if (!inflight || !due()) return;
+      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(), tail: "" };
+      },
+      output: (chunk) => {
+        if (inflight) inflight.tail = (inflight.tail + chunk).slice(-500);
+      },
+      // digest only — NEVER re-voices directly
+      post: (call) => {
+        steps++;
+        inflight = null;
+        const rec = due();
+        if (rec) emit(rec, `still running \u2014 ${steps} steps so far, now: ${describeCall(call)}`, call);
+      }
+    };
+  }
   onWorkerSettled(id, res) {
     const rec = this.tasks.get(id);
     if (res.finishReason === "aborted" || rec.status === "cancelled") {
@@ -7045,6 +7147,11 @@ function displayHooks(fs) {
   \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));
     },
+    onToolOutput(_call, chunk) {
+      if (!verboseOutput) return;
+      for (const ln of String(chunk).split("\n")) if (ln.trim()) err(dim(`    \u22EE ${ln.length > 200 ? ln.slice(0, 200) + "\u2026" : ln}
+`));
+    },
     async postToolUse(call, result) {
       spinner.stop();
       try {
@@ -7654,7 +7761,8 @@ async function repl(args, ai, cfg, cwd) {
       workerModel: agent.options.model,
       workerOptions,
       host,
-      ...args.voice ? { voiceStyle: "conversational" } : {},
+      ...args.voice ? { voiceStyle: "conversational", progressUpdates: true } : {},
+      // voice: narrate throttled worker progress (dead air is worse than a short aside)
       // Per-TASK checkpoint frames (the natural undo unit in duplex = one delegation): opened BEFORE
       // the worker spawns (post-spawn would race its first edits). `checkpoints` is bound below.
       onTaskStart: async (_id, label) => {