@livx.cc/agentx 0.99.15 → 0.99.16

package/dist/{Agent-CsVuR2O0.d.ts → Agent-CvLBalJE.d.ts}

@@ -370,6 +370,19 @@ declare class Agent {
      *  `options.tools` — otherwise a constructor-passed tool resurrects on the next prepare()
      *  rebuild (and re-adding it via addTools() would then DUPLICATE it in the wire schema). */
     removeTools(names: Set<string> | string[]): number;
+    /** Messages the host queued to steer the RUNNING turn (Claude-Code-style mid-turn input). The loop
+     *  drains them at each step boundary — after tool results are appended, before the next model call —
+     *  so they ride along with the latest tool results. A no-op between turns (nothing drains it). */
+    private pendingInjections;
+    /** Queue a user message into the in-flight turn. It lands as a `user` message at the next step
+     *  boundary; if the model was about to stop, the injection re-opens the loop so it's never lost.
+     *  Pushing onto `transcript` directly from outside would race the loop — this drains inside it. */
+    inject(content: MessageContent): void;
+    /** Drop any queued-but-unconsumed injections. The REPL calls this after a LOCAL command (/cmd, !bash)
+     *  — which runs no send() to drain them — so a mid-command steer can't leak into the next real turn. */
+    clearInjections(): void;
+    /** Fold any host-injected messages into the transcript as user turns. Returns true if any landed. */
+    private drainInjections;
     constructor(options?: Partial<AgentOptions>);
     /** Build the tool context from the resolved fs + options. Idempotent-safe: called once (ctor or ensureFs). */
     private buildCtx;

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { H as Hooks, h as RunResult, R as ReasoningEffort, A as Agent } from './Agent-CsVuR2O0.js';
+import { H as Hooks, h as RunResult, R as ReasoningEffort, A as Agent } from './Agent-CvLBalJE.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, H as HostBridge, c as ContentPart, e as MessageContent } from './tools-DKf3hN4M.js';
 

package/dist/cli.js

@@ -3406,6 +3406,27 @@ var Agent = class _Agent {
     if (this.options.tools) this.options.tools = this.options.tools.filter((t) => !s.has(t.name));
     return before - this.activeTools.length;
   }
+  /** Messages the host queued to steer the RUNNING turn (Claude-Code-style mid-turn input). The loop
+   *  drains them at each step boundary — after tool results are appended, before the next model call —
+   *  so they ride along with the latest tool results. A no-op between turns (nothing drains it). */
+  pendingInjections = [];
+  /** Queue a user message into the in-flight turn. It lands as a `user` message at the next step
+   *  boundary; if the model was about to stop, the injection re-opens the loop so it's never lost.
+   *  Pushing onto `transcript` directly from outside would race the loop — this drains inside it. */
+  inject(content) {
+    this.pendingInjections.push(content);
+  }
+  /** Drop any queued-but-unconsumed injections. The REPL calls this after a LOCAL command (/cmd, !bash)
+   *  — which runs no send() to drain them — so a mid-command steer can't leak into the next real turn. */
+  clearInjections() {
+    this.pendingInjections.length = 0;
+  }
+  /** Fold any host-injected messages into the transcript as user turns. Returns true if any landed. */
+  drainInjections() {
+    if (!this.pendingInjections.length) return false;
+    for (const content of this.pendingInjections.splice(0)) this.transcript.push({ role: "user", content });
+    return true;
+  }
   constructor(options) {
     this.options = { ...new AgentOptions(), ...options };
     if (this.options.fs) this.buildCtx();
@@ -3671,6 +3692,7 @@ var Agent = class _Agent {
         });
       }
       if (toolCalls.length === 0) {
+        if (this.drainInjections()) continue;
         log4.verbose(`completed in ${steps} step(s)`);
         await this.ctx.jobs?.drain();
         await this.activeHooks?.onStop?.(res.content ?? "");
@@ -3695,6 +3717,7 @@ var Agent = class _Agent {
         }
         this.transcript.push({ role: "tool", tool_call_id: tc.id, name: tc.function.name, content });
       }
+      this.drainInjections();
     }
   }
   /**
@@ -11740,6 +11763,13 @@ function installUpdate() {
   const r = spawnSync6("bun", ["add", "-g", "@livx.cc/agentx"], { stdio: "inherit" });
   return (r.status ?? 1) === 0;
 }
+var typeaheadOnLine = false;
+var clearTypeaheadLine = () => {
+  if (typeaheadOnLine) {
+    err("\r\x1B[2K");
+    typeaheadOnLine = false;
+  }
+};
 var spinner = /* @__PURE__ */ (() => {
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   let timer;
@@ -11768,8 +11798,10 @@ var spinner = /* @__PURE__ */ (() => {
         clearInterval(timer);
         timer = void 0;
         err("\r\x1B[2K");
+        typeaheadOnLine = false;
       }
     }
+    // the tail (type-ahead) went with it
   };
 })();
 var setTermTitle = (t) => {
@@ -11947,7 +11979,7 @@ REPL slash commands: /help /version /tools /permissions /status /cost /context /
 REPL completion: type / (commands+skills) or @ (files) for a LIVE menu \u2014 \u2191/\u2193 select, \u23CE/Tab accept, Esc dismiss.
 REPL multi-line: Option/Alt+Enter inserts a newline, or end a line with \\ to continue. Esc cancels a running turn / clears the input line; double-Esc jumps back to edit a previous message.
 REPL shortcuts: Shift+Tab cycles permission posture (ask \u2192 accept-edits \u2192 plan) \xB7 Alt+T toggles reasoning \xB7 Alt+P switches model \xB7 Ctrl+O toggles verbose tool output \xB7 Ctrl+X Ctrl+E edits the buffer in $EDITOR \xB7 \u2192 or Tab accepts the dim history ghost-suggestion \xB7 Alt+S/Ctrl+S stash/unstash.
-REPL stash: type while a turn is running \u2192 Enter queues it (auto-submits when the turn finishes). Alt+S (or Ctrl+S) with text stashes it; on an empty prompt pops the next entry for editing.
+REPL steer/stash: type while a turn is running \u2192 Enter STEERS it (the text reaches the model at its next step, alongside the next tool result). Alt+S (or Ctrl+S) with text stashes it for AFTER the turn instead; on an empty prompt pops the next stashed entry for editing.
 REPL editing (emacs/readline): Ctrl-A/E line start/end \xB7 Ctrl-B/F char \xB7 Alt-B/F or Alt/Ctrl-\u2190/\u2192 word \xB7 Ctrl-W kill word \xB7 Ctrl-U/K kill to start/end \xB7 Ctrl-Y yank \xB7 Ctrl-_ undo \xB7 Alt-D kill word fwd \xB7 Ctrl-L clear screen. Set editorMode:'vim' (or /config) for modal vim editing.
 REPL paste: large/multi-line pastes collapse to a [Pasted text +N lines] preview (expands on send); a pasted image/file path attaches as [Image]/[File]; Ctrl-V or /paste grabs a clipboard image (macOS).`;
 function newestModel() {
@@ -12035,9 +12067,11 @@ function makeHost(format = "text", opts) {
     notify(e) {
       if (e.kind === "turn_start") {
         activitySeen.clear();
+        typeaheadOnLine = false;
         return;
       }
       spinner.stop();
+      clearTypeaheadLine();
       if (e.kind === "text_delta") {
         flushLookupGroup();
         if (streamJson) process.stdout.write(JSON.stringify({ type: "text", text: e.message }) + "\n");
@@ -12184,7 +12218,10 @@ function displayHooks(fs, opts) {
       if (call.name === "TodoWrite" && Array.isArray(call.args?.todos)) latestTodos = call.args.todos;
       if (!on()) return;
       if (bg) err("\r\x1B[0J");
-      else spinner.stop();
+      else {
+        spinner.stop();
+        clearTypeaheadLine();
+      }
       flush();
       if (!bg && !verboseOutput && LOOKUP.has(call.name)) {
         pendingHeader = header(call);
@@ -12205,7 +12242,10 @@ function displayHooks(fs, opts) {
     async postToolUse(call, result) {
       if (!on()) return;
       if (bg) err("\r\x1B[0J");
-      else spinner.stop();
+      else {
+        spinner.stop();
+        clearTypeaheadLine();
+      }
       try {
         if (pendingHeader) {
           const t = String(result).replace(/\s+$/, "");
@@ -14662,6 +14702,7 @@ ${task}`;
     const renderStashBuf = () => {
       if (spinner.active) return;
       err(`\r\x1B[K${sEd.buf ? "  " + stashView() : ""}`);
+      typeaheadOnLine = !!sEd.buf;
     };
     repaintStash = renderStashBuf;
     keyInput.on("keypress", (_s, key) => {
@@ -14694,11 +14735,18 @@ ${task}`;
       if (action === "submit") {
         const text = sEd.expand().trim();
         sEd.reset();
+        typeaheadOnLine = false;
         if (text) {
-          inputStash.push(text);
           const view = text.replace(/\n+/g, " \u23CE ");
-          err(`\r\x1B[K${green("  \u2713 stashed")} ${dim(`#${inputStash.length}: ${view.slice(0, 50)}${view.length > 50 ? "\u2026" : ""}`)}
+          if ((activeTurn || dispatchPending) && !duplex) {
+            agent.inject(text);
+            err(`\r\x1B[K${bold(cyan("  \u21B3 steering \u203A"))} ${cyan(`${view.slice(0, 60)}${view.length > 60 ? "\u2026" : ""}`)}
+`);
+          } else {
+            inputStash.push(text);
+            err(`\r\x1B[K${green("  \u2713 stashed")} ${dim(`#${inputStash.length}: ${view.slice(0, 50)}${view.length > 50 ? "\u2026" : ""}`)}
 `);
+          }
         }
         return;
       }
@@ -15079,6 +15127,7 @@ ${out}
     }
     let quit = await dispatchLine(line) === "quit";
     const wasLocal = /^[!#/]/.test(line);
+    if (wasLocal) agent.clearInjections();
     while (!quit && !wasLocal && inputStash.length) {
       const next = inputStash.shift();
       const nview = next.replace(/\n+/g, " \u23CE ");