open-agents-ai 0.103.82 → 0.103.85

package/dist/index.js

@@ -1343,10 +1343,22 @@ var init_shell = __esm({
       workingDir;
       defaultTimeout;
       _sudoPassword = null;
+      /** Active child processes — killed on abort for instant /stop */
+      _activeChildren = /* @__PURE__ */ new Set();
       constructor(workingDir, defaultTimeout = 3e4) {
         this.workingDir = workingDir;
         this.defaultTimeout = defaultTimeout;
       }
+      /** Kill all active child processes immediately (called by /stop) */
+      killAll() {
+        for (const child of this._activeChildren) {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }
+        this._activeChildren.clear();
+      }
       /** Set a cached sudo password for the session. The shell tool will
        *  automatically retry permission-denied commands with `sudo -S`. */
       setSudoPassword(password) {
@@ -1397,17 +1409,14 @@ ${stdinInput ?? ""}`);
             cwd: this.workingDir,
             env: {
               ...process.env,
-              // Non-interactive mode: libraries like prompts, inquirer,
-              // create-next-app, and many Node CLI tools check CI to skip
-              // interactive prompts and use defaults instead.
               CI: "true",
               NONINTERACTIVE: "1",
-              // Disable color in most tools to get clean output
               NO_COLOR: "1",
               FORCE_COLOR: "0"
             },
             stdio: ["pipe", "pipe", "pipe"]
           });
+          this._activeChildren.add(child);
           let stdout = "";
           let stderr = "";
           let killed = false;
@@ -1450,6 +1459,7 @@ ${stdinInput ?? ""}`);
           }
           child.stdin.end();
           child.on("exit", (code) => {
+            this._activeChildren.delete(child);
             exitFlushTimer = setTimeout(() => {
               const durationMs = performance.now() - start;
               if (killed) {
@@ -4703,6 +4713,24 @@ Process error: ${err.message}`;
         entry.finishedAt = Date.now();
         return true;
       }
+      /** Kill ALL running tasks immediately (for /stop and /quit authority) */
+      stopAll() {
+        let killed = 0;
+        for (const [, entry] of this.tasks) {
+          if (entry.status !== "running")
+            continue;
+          if (entry.child) {
+            try {
+              entry.child.kill("SIGKILL");
+            } catch {
+            }
+          }
+          entry.status = "stopped";
+          entry.finishedAt = Date.now();
+          killed++;
+        }
+        return killed;
+      }
       list() {
         return Array.from(this.tasks.values()).map(toInfo);
       }
@@ -12432,8 +12460,8 @@ async function handleCmd(cmd) {
           // succeeds in <1s. Racing them eliminates the wait.
           dlog('remote_infer: invoking ' + riCapName + ' on peer ' + riTargetPeer.slice(0, 20) + ' (libp2p' + (_natsConn ? ' + NATS parallel' : '') + ')');
           try {
-            var RI_TIMEOUT = 300000;
-            var riInvokeP = nexus.invokeCapability(riTargetPeer, riCapName, riData, { stream: false, maxDurationMs: 240000 });
+            var RI_TIMEOUT = 60000;  // 60s outer timeout \u2014 fail fast for interactive use
+            var riInvokeP = nexus.invokeCapability(riTargetPeer, riCapName, riData, { stream: false, maxDurationMs: 45000 });
             var riTimeoutP = new Promise(function(_, reject) { setTimeout(function() { reject(new Error('remote_infer timed out after ' + (RI_TIMEOUT / 1000) + 's')); }, RI_TIMEOUT); });
 
             // Build race candidates \u2014 libp2p + timeout always present
@@ -12444,7 +12472,7 @@ async function handleCmd(cmd) {
               var _riNatsRaceP = (async function() {
                 var _rSubject = 'nexus.invoke.' + riTargetPeer;
                 var _rPayload = JSON.stringify({ capability: riCapName, input: riData, from: nexus.peerId || '' });
-                var _rResp = await _natsConn.request(_rSubject, _natsCodec.encode(_rPayload), { timeout: 240000 });
+                var _rResp = await _natsConn.request(_rSubject, _natsCodec.encode(_rPayload), { timeout: 45000 });
                 var _rResult = JSON.parse(_natsCodec.decode(_rResp.data));
                 if (_rResult && _rResult.error) throw new Error('NATS: ' + _rResult.error);
                 dlog('remote_infer: NATS won the race');
@@ -12483,8 +12511,8 @@ async function handleCmd(cmd) {
               var rPid = riCandidates[ri];
               dlog('remote_infer: trying peer ' + rPid.slice(0, 20) + '...');
               try {
-                var PEER_INVOKE_TIMEOUT = 180000; // 3 min per peer \u2014 remote API inference can be slow
-                var specInvoke = nexus.invokeCapability(rPid, riCapName, riData, { stream: false, maxDurationMs: 150000 });
+                var PEER_INVOKE_TIMEOUT = 30000;  // 30s per peer in discovery \u2014 fail fast, try next
+                var specInvoke = nexus.invokeCapability(rPid, riCapName, riData, { stream: false, maxDurationMs: 25000 });
                 var specTimeout = new Promise(function(_, reject) {
                   setTimeout(function() { reject(new Error('peer invoke timeout')); }, PEER_INVOKE_TIMEOUT);
                 });
@@ -12513,7 +12541,7 @@ async function handleCmd(cmd) {
                   try {
                     var _dpSubject = 'nexus.invoke.' + _dpPid;
                     var _dpPayload = JSON.stringify({ capability: riCapName, input: riData, from: nexus.peerId || '' });
-                    var _dpResp = await _natsConn.request(_dpSubject, _natsCodec.encode(_dpPayload), { timeout: 180000 });
+                    var _dpResp = await _natsConn.request(_dpSubject, _natsCodec.encode(_dpPayload), { timeout: 30000 });
                     var _dpResult = JSON.parse(_natsCodec.decode(_dpResp.data));
                     if (_dpResult && !_dpResult.error) {
                       riResult = _dpResult;
@@ -18628,6 +18656,7 @@ var init_agenticRunner = __esm({
       handlers = [];
       pendingUserMessages = [];
       aborted = false;
+      _abortController = new AbortController();
       _paused = false;
       _pauseResolve = null;
       _sudoPassword = null;
@@ -18837,14 +18866,30 @@ ${this.options.dynamicContext}`,
       injectUserMessage(content) {
         this.pendingUserMessages.push(content);
       }
-      /** Abort the current task run */
+      /** Retract the last pending user message (Esc cancel).
+       *  Returns the retracted text, or null if queue is empty or already consumed. */
+      retractLastPendingMessage() {
+        if (this.pendingUserMessages.length === 0)
+          return null;
+        return this.pendingUserMessages.pop();
+      }
+      /** Abort the current task run — cancels in-flight requests and kills child processes */
       abort() {
         this.aborted = true;
+        this._abortController.abort();
+        const shellTool = this.tools.get("shell");
+        if (shellTool && typeof shellTool.killAll === "function") {
+          shellTool.killAll();
+        }
         if (this._pauseResolve) {
           this._pauseResolve();
           this._pauseResolve = null;
         }
       }
+      /** Get the current abort signal for passing to fetch/spawn */
+      get abortSignal() {
+        return this._abortController.signal;
+      }
       /**
        * Pause the current task gracefully. The run loop will suspend at the next
        * turn boundary (between tool calls / model requests) without destroying state.
@@ -18955,6 +19000,11 @@ Respond with your assessment, then take action.`;
       }
       /** Run a task through the agentic loop */
       async run(task, context) {
+        this.aborted = false;
+        this._abortController = new AbortController();
+        if (typeof this.backend.setAbortSignal === "function") {
+          this.backend.setAbortSignal(this._abortController.signal);
+        }
         const start = Date.now();
         const taskTimeoutMs = this.options.taskTimeoutMs;
         const selfEvalInterval = taskTimeoutMs;
@@ -19101,6 +19151,10 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
           try {
             response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
           } catch (reqErr) {
+            if (reqErr instanceof Error && reqErr.fatal) {
+              this.emit({ type: "error", content: `Backend error: ${reqErr.message}`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+              break;
+            }
             const recovered = await this.retryOnTransient(reqErr, chatRequest, turn);
             if (!recovered) {
               const errMsg = reqErr instanceof Error ? reqErr.message : String(reqErr);
@@ -19615,6 +19669,10 @@ Integrate this guidance into your current approach. Continue working on the task
             try {
               response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
             } catch (reqErr) {
+              if (this.aborted || reqErr instanceof Error && reqErr.name === "AbortError") {
+                this.emit({ type: "error", content: "Task aborted by user", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                break;
+              }
               const recovered = await this.retryOnTransient(reqErr, chatRequest, turn);
               if (!recovered) {
                 const errMsg2 = reqErr instanceof Error ? reqErr.message : String(reqErr);
@@ -20857,6 +20915,8 @@ ${transcript}`
       // -------------------------------------------------------------------------
       /** Detect whether an error is transient (worth retrying) */
       isTransientError(err) {
+        if (err instanceof Error && err.fatal)
+          return false;
         const msg = err instanceof Error ? err.message : String(err);
         if (/Backend HTTP (502|503|504)/i.test(msg))
           return true;
@@ -20866,6 +20926,10 @@ ${transcript}`
           return true;
         if (/model is loading|server busy|overloaded/i.test(msg))
           return true;
+        if (/multiaddrs failed|all multiaddrs failed|dial to peer failed|stream was reset|Cannot reach peer/i.test(msg))
+          return true;
+        if (/NATS.*timeout|relay.*timeout|invoke.*timeout/i.test(msg))
+          return true;
         return false;
       }
       /**
@@ -21004,12 +21068,18 @@ ${transcript}`
       model;
       apiKey;
       thinking;
+      /** Abort signal — set by the runner so /stop can cancel in-flight requests */
+      _abortSignal = null;
       constructor(baseUrl, model, apiKey, thinking) {
         this.baseUrl = normalizeBaseUrl(baseUrl);
         this.model = model;
         this.apiKey = apiKey ?? "";
         this.thinking = thinking ?? true;
       }
+      /** Set the abort signal from the runner (called at run start) */
+      setAbortSignal(signal) {
+        this._abortSignal = signal;
+      }
       /** Build auth headers — all providers use standard Bearer token auth. */
       authHeaders() {
         const headers = { "Content-Type": "application/json" };
@@ -21027,11 +21097,14 @@ ${transcript}`
           max_tokens: request.maxTokens,
           think: this.thinking
         };
-        const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+        const fetchOpts = {
           method: "POST",
           headers: this.authHeaders(),
           body: JSON.stringify(body)
-        });
+        };
+        if (this._abortSignal)
+          fetchOpts.signal = this._abortSignal;
+        const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, fetchOpts);
         if (!resp.ok) {
           const text = await resp.text().catch(() => "");
           const isHtml = text.trimStart().startsWith("<!") || text.trimStart().startsWith("<html");
@@ -21089,11 +21162,14 @@ ${transcript}`
           stream_options: { include_usage: true },
           think: this.thinking
         };
-        const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+        const streamFetchOpts = {
           method: "POST",
           headers: this.authHeaders(),
           body: JSON.stringify(body)
-        });
+        };
+        if (this._abortSignal)
+          streamFetchOpts.signal = this._abortSignal;
+        const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, streamFetchOpts);
         if (!resp.ok) {
           const text = await resp.text().catch(() => "");
           const isHtml = text.trimStart().startsWith("<!") || text.trimStart().startsWith("<html");
@@ -21181,6 +21257,15 @@ var init_nexusBackend = __esm({
         this.authKey = authKey || "";
         this.thinking = thinking ?? true;
       }
+      /** Reset the consecutive failure counter (called on endpoint switch / reconnect) */
+      resetFailures() {
+        this.consecutiveFailures = 0;
+      }
+      /** Update target peer (allows switching peers without recreating the backend) */
+      setTargetPeer(peerId) {
+        this.targetPeer = peerId;
+        this.consecutiveFailures = 0;
+      }
       async chatCompletion(request) {
         if (this.consecutiveFailures >= _NexusAgenticBackend.MAX_CONSECUTIVE_FAILURES) {
           const err = new Error(`Remote peer unreachable after ${this.consecutiveFailures} attempts. Use /endpoint to switch to a local model or reconnect.`);
@@ -21217,7 +21302,10 @@ var init_nexusBackend = __esm({
         }
         if (parsed.success === false) {
           this.consecutiveFailures++;
-          throw new Error(`Remote inference failed: ${parsed.output || rawResult}`);
+          const output = String(parsed.output || rawResult);
+          const isDialErr = /multiaddrs failed|Cannot reach peer|dial to peer|timeout|ECONNREFUSED/i.test(output);
+          const hint = isDialErr ? ` (${this.consecutiveFailures}/${_NexusAgenticBackend.MAX_CONSECUTIVE_FAILURES} failures \u2014 will stop after ${_NexusAgenticBackend.MAX_CONSECUTIVE_FAILURES})` : "";
+          throw new Error(`Remote inference failed: ${output}${hint}`);
         }
         this.consecutiveFailures = 0;
         const invokeResult = parsed.result;
@@ -38670,6 +38758,8 @@ var init_voice = __esm({
             await this.ensureLuxtts();
             this.luxttsActive = true;
             this.mlxActive = false;
+            this.ensureLuxttsDaemon().catch(() => {
+            });
           } else if (isMlx) {
             await this.ensureMlxAudio();
             this.mlxActive = true;
@@ -38722,6 +38812,8 @@ var init_voice = __esm({
               await this.ensureLuxtts();
               this.luxttsActive = true;
               this.mlxActive = false;
+              this.ensureLuxttsDaemon().catch(() => {
+              });
             } else if (isMlx) {
               await this.ensureMlxAudio();
               this.mlxActive = true;
@@ -39308,7 +39400,7 @@ var init_voice = __esm({
       isMlxCapable() {
         return platform3() === "darwin" && process.arch === "arm64";
       }
-      /** Resolve python3 binary path */
+      /** Resolve python3 binary path (cached after first call) */
       findPython3() {
         if (this.python3Path)
           return this.python3Path;
@@ -39324,6 +39416,52 @@ var init_voice = __esm({
         }
         return null;
       }
+      /** Async version of findPython3 — non-blocking */
+      async findPython3Async() {
+        if (this.python3Path)
+          return this.python3Path;
+        for (const bin of ["python3", "python"]) {
+          try {
+            const path = await this.asyncShell(`which ${bin}`, 5e3);
+            if (path) {
+              this.python3Path = path;
+              return path;
+            }
+          } catch {
+          }
+        }
+        return null;
+      }
+      /** Non-blocking shell execution — async alternative to execSync.
+       *  Returns stdout string on exit 0, rejects otherwise. */
+      asyncShell(command, timeoutMs = 3e4) {
+        return new Promise((resolve31, reject) => {
+          const proc = nodeSpawn("sh", ["-c", command], {
+            stdio: ["ignore", "pipe", "pipe"],
+            cwd: tmpdir6()
+          });
+          let stdout = "";
+          let stderr = "";
+          proc.stdout.on("data", (d) => {
+            stdout += d.toString();
+          });
+          proc.stderr.on("data", (d) => {
+            stderr += d.toString();
+          });
+          proc.on("error", reject);
+          const timer = setTimeout(() => {
+            proc.kill("SIGKILL");
+            reject(new Error(`Timeout after ${timeoutMs}ms`));
+          }, timeoutMs);
+          proc.on("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+              resolve31(stdout.trim());
+            else
+              reject(new Error(stderr.slice(0, 300) || `Exit code ${code}`));
+          });
+        });
+      }
       /** Check if mlx-audio is installed */
       checkMlxInstalled() {
         if (this.mlxInstalled !== null)
@@ -39496,9 +39634,10 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
        * Ensure LuxTTS venv is created with all dependencies.
        * On first run: creates venv, installs PyTorch + LuxTTS + deps (~5-15 min).
        * Subsequent runs: checks venv exists and import works.
+       * All shell commands use asyncShell — never blocks the event loop.
        */
       async ensureLuxtts() {
-        const py = this.findPython3();
+        const py = await this.findPython3Async();
         if (!py) {
           throw new Error("python3 not found. LuxTTS requires Python 3.10+. Try: apt install python3 / brew install python3");
         }
@@ -39506,23 +39645,25 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         const venvPy = luxttsVenvPy();
         if (existsSync34(venvPy)) {
           try {
-            execSync27(`${venvPy} -c "import sys; sys.path.insert(0, '${luxttsRepoDir()}'); from zipvoice.luxvoice import LuxTTS; print('ok')"`, { stdio: "pipe", timeout: 3e4 });
+            await this.asyncShell(`${venvPy} -c "import sys; sys.path.insert(0, '${luxttsRepoDir()}'); from zipvoice.luxvoice import LuxTTS; print('ok')"`, 3e4);
             let hasCudaSys = false;
             try {
-              execSync27("nvidia-smi", { stdio: "pipe", timeout: 5e3 });
+              await this.asyncShell("nvidia-smi", 5e3);
               hasCudaSys = true;
             } catch {
             }
             if (hasCudaSys) {
-              try {
-                const torchCheck = execSync27(`${venvPy} -c "import torch; print('cuda' if torch.cuda.is_available() else 'cpu')"`, { stdio: "pipe", timeout: 15e3 }).toString().trim();
+              this.asyncShell(`${venvPy} -c "import torch; print('cuda' if torch.cuda.is_available() else 'cpu')"`, 15e3).then(async (torchCheck) => {
                 if (torchCheck === "cpu") {
-                  renderWarning("GPU detected but PyTorch is CPU-only. Reinstalling with CUDA support...");
-                  execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet --force-reinstall torch torchaudio --index-url https://download.pytorch.org/whl/cu124`, { stdio: "pipe", timeout: 6e5 });
-                  renderInfo("PyTorch reinstalled with CUDA GPU support.");
+                  renderWarning("GPU detected but PyTorch is CPU-only. Reinstalling with CUDA support in background...");
+                  try {
+                    await this.asyncShell(`${JSON.stringify(venvPy)} -m pip install --quiet --force-reinstall torch torchaudio --index-url https://download.pytorch.org/whl/cu124`, 6e5);
+                    renderInfo("PyTorch reinstalled with CUDA GPU support.");
+                  } catch {
+                  }
                 }
-              } catch {
-              }
+              }).catch(() => {
+              });
             }
             this.writeLuxttsInferScript();
             this.autoDetectCloneRef();
@@ -39535,27 +39676,24 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         if (!existsSync34(venvDir)) {
           renderInfo("  Creating Python virtual environment...");
           try {
-            execSync27(`${py} -m venv ${JSON.stringify(venvDir)}`, {
-              stdio: "pipe",
-              timeout: 6e4
-            });
+            await this.asyncShell(`${py} -m venv ${JSON.stringify(venvDir)}`, 6e4);
           } catch (err) {
             throw new Error(`Failed to create venv: ${err instanceof Error ? err.message : String(err)}`);
           }
         }
         let hasCuda = false;
         try {
-          execSync27("nvidia-smi", { stdio: "pipe", timeout: 5e3 });
+          await this.asyncShell("nvidia-smi", 5e3);
           hasCuda = true;
         } catch {
         }
         if (hasCuda) {
           renderInfo("  Installing PyTorch (CUDA GPU)...");
           try {
-            execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio --index-url https://download.pytorch.org/whl/cu124`, { stdio: "pipe", timeout: 6e5 });
+            await this.asyncShell(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio --index-url https://download.pytorch.org/whl/cu124`, 6e5);
           } catch {
             try {
-              execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio`, { stdio: "pipe", timeout: 6e5 });
+              await this.asyncShell(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio`, 6e5);
             } catch (err2) {
               throw new Error(`Failed to install PyTorch (CUDA): ${err2 instanceof Error ? err2.message : String(err2)}`);
             }
@@ -39563,10 +39701,10 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         } else {
           renderInfo("  Installing PyTorch (CPU \u2014 no NVIDIA GPU detected)...");
           try {
-            execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio --index-url https://download.pytorch.org/whl/cpu`, { stdio: "pipe", timeout: 6e5 });
+            await this.asyncShell(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio --index-url https://download.pytorch.org/whl/cpu`, 6e5);
           } catch {
             try {
-              execSync27(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio`, { stdio: "pipe", timeout: 6e5 });
+              await this.asyncShell(`${JSON.stringify(venvPy)} -m pip install --quiet torch torchaudio`, 6e5);
             } catch (err2) {
               throw new Error(`Failed to install PyTorch: ${err2 instanceof Error ? err2.message : String(err2)}`);
             }
@@ -39577,9 +39715,9 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           renderInfo("  Cloning LuxTTS repository...");
           try {
             if (existsSync34(repoDir)) {
-              execSync27(`rm -rf ${JSON.stringify(repoDir)}`, { stdio: "pipe" });
+              await this.asyncShell(`rm -rf ${JSON.stringify(repoDir)}`, 3e4);
             }
-            execSync27(`git clone --depth 1 https://github.com/ysharma3501/LuxTTS.git ${JSON.stringify(repoDir)}`, { stdio: "pipe", timeout: 12e4 });
+            await this.asyncShell(`git clone --depth 1 https://github.com/ysharma3501/LuxTTS.git ${JSON.stringify(repoDir)}`, 12e4);
           } catch (err) {
             throw new Error(`Failed to clone LuxTTS: ${err instanceof Error ? err.message : String(err)}`);
           }
@@ -39587,19 +39725,15 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         renderInfo("  Installing LuxTTS dependencies...");
         const pipCmd = JSON.stringify(venvPy);
         const installCmds = [
-          // Core deps from requirements.txt
           `${pipCmd} -m pip install --quiet lhotse huggingface_hub safetensors pydub onnxruntime librosa "transformers<=4.57.6" inflect numpy vocos "setuptools<81"`,
-          // Tokenization deps (piper_phonemize from custom index, plus CJK support)
           `${pipCmd} -m pip install --quiet piper-phonemize --find-links https://k2-fsa.github.io/icefall/piper_phonemize.html`,
           `${pipCmd} -m pip install --quiet jieba pypinyin cn2an`,
-          // LinaCodec custom vocoder (required by Zipvoice)
           `${pipCmd} -m pip install --quiet "git+https://github.com/ysharma3501/LinaCodec.git"`,
-          // Zipvoice package from the cloned repo (installs as 'zipvoice')
           `${pipCmd} -m pip install --quiet -e ${JSON.stringify(repoDir)}`
         ];
         for (const cmd of installCmds) {
           try {
-            execSync27(cmd, { stdio: "pipe", timeout: 3e5 });
+            await this.asyncShell(cmd, 3e5);
           } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             if (msg.includes("piper") || msg.includes("LinaCodec")) {
@@ -39610,7 +39744,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
         }
         try {
-          execSync27(`${venvPy} -c "import sys; sys.path.insert(0, '${repoDir}'); from zipvoice.luxvoice import LuxTTS; print('ok')"`, { stdio: "pipe", timeout: 3e4 });
+          await this.asyncShell(`${venvPy} -c "import sys; sys.path.insert(0, '${repoDir}'); from zipvoice.luxvoice import LuxTTS; print('ok')"`, 3e4);
         } catch (err) {
           throw new Error(`LuxTTS installed but import failed: ${err instanceof Error ? err.message : String(err)}`);
         }
@@ -45505,8 +45639,11 @@ var init_status_bar = __esm({
       active = false;
       scrollRegionTop = 1;
       stdinHooked = false;
-      /** Track previous terminal rows to clear ghost separators on resize */
+      /** Track previous terminal dimensions to clear ghost separators on resize */
       _prevTermRows = 0;
+      _prevTermCols = 0;
+      /** Debounce timer for resize events — prevents separator stacking during drag */
+      _resizeTimer = null;
       /**
        * Depth-counted content write guard.  Incremented by beginContentWrite(),
        * decremented by endContentWrite().  Footer is only redrawn and cursor
@@ -45953,6 +46090,7 @@ var init_status_bar = __esm({
         this.scrollRegionTop = scrollRegionTop ?? 1;
         this.active = true;
         this._prevTermRows = process.stdout.rows ?? 24;
+        this._prevTermCols = process.stdout.columns ?? 80;
         this.applyScrollRegion();
         this.renderFooterAndPositionInput();
         this.hookStdin();
@@ -45990,24 +46128,42 @@ var init_status_bar = __esm({
       get reservedRows() {
         return this._currentFooterHeight;
       }
-      /** Handle terminal resize — reapply scroll region and redraw footer */
+      /** Handle terminal resize — debounced to prevent separator stacking during drag */
       handleResize() {
         if (!this.active)
           return;
+        if (this._resizeTimer)
+          clearTimeout(this._resizeTimer);
+        this._resizeTimer = setTimeout(() => {
+          this._resizeTimer = null;
+          this._handleResizeImmediate();
+        }, 50);
+      }
+      /** Actual resize handler — called after debounce settles */
+      _handleResizeImmediate() {
+        if (!this.active)
+          return;
+        const prevRows = this._prevTermRows;
+        const prevCols = this._prevTermCols;
         this.updateFooterHeight();
         const rows = process.stdout.rows ?? 24;
-        const prevRows = this._prevTermRows;
+        const cols = process.stdout.columns ?? 80;
         this._prevTermRows = rows;
+        this._prevTermCols = cols;
         const pos = this.rowPositions(rows);
         const w = getTermWidth();
         const sep = c2.dim("\u2500".repeat(w));
-        let clearGhosts = "";
-        if (prevRows > 0 && rows < prevRows) {
-          clearGhosts = "\x1B[1;" + rows + `r\x1B[${pos.bufferRow};1H\x1B[J`;
+        let clearBuf = "";
+        if (prevRows > 0 && (rows !== prevRows || cols !== prevCols)) {
+          const wrapFactor = cols > 0 ? Math.ceil(prevCols / cols) : 1;
+          const extraWrappedRows = Math.max(0, (wrapFactor - 1) * 3);
+          const safetyMargin = extraWrappedRows + 2;
+          const clearFrom = Math.max(1, pos.bufferRow - safetyMargin);
+          clearBuf = "\x1B[1;" + rows + `r\x1B[${clearFrom};1H\x1B[J`;
         }
         if (this.writeDepth > 0) {
           const inputWrap = this.wrapInput(w);
-          let buf = clearGhosts + `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r\x1B[?25l\x1B[?7l\x1B[${pos.bufferRow};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${pos.topSepRow};1H\x1B[2K${sep}`;
+          let buf = clearBuf + `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r\x1B[?25l\x1B[?7l\x1B[${pos.bufferRow};1H\x1B[2K${this.buildBufferContent(w)}\x1B[${pos.topSepRow};1H\x1B[2K${sep}`;
           for (let i = 0; i < inputWrap.lines.length; i++) {
             const row = pos.inputStartRow + i;
             const prefix = i === 0 ? this.promptText : " ".repeat(this.promptWidth);
@@ -46016,8 +46172,8 @@ var init_status_bar = __esm({
           buf += `\x1B[${pos.bottomSepRow};1H\x1B[2K${sep}\x1B[${pos.metricsRow};1H\x1B[2K${this.buildMetricsLine()}\x1B[?7h\x1B[${pos.scrollEnd};1H`;
           process.stdout.write(buf);
         } else {
-          if (clearGhosts)
-            process.stdout.write(clearGhosts);
+          if (clearBuf)
+            process.stdout.write(clearBuf);
           this.applyScrollRegion();
           this.renderFooterAndPositionInput();
         }
@@ -47869,8 +48025,9 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
   let currentTaskType;
   let sessionFilesTouched = [];
   let sessionToolCallCount = 0;
+  let lastSteeringInput = "";
+  let lastSteeringRetracted = false;
   let restoredSessionContext = null;
-  let pendingSessionRestore = false;
   let sessionSudoPassword = null;
   let sudoPromptPending = false;
   const idlePrompt = `${c2.bold(c2.white("\u276F "))}`;
@@ -49130,7 +49287,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       if (!activeTask)
         return false;
       activeTask.runner.abort();
-      writeContent(() => renderInfo("Task aborted."));
+      const bgKilled = taskManager.stopAll();
+      writeContent(() => renderInfo(`Task aborted.${bgKilled > 0 ? ` ${bgKilled} background task(s) killed.` : ""}`));
       return true;
     },
     pauseTask() {
@@ -49222,28 +49380,40 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       const lastTime = lastEntry.savedAt ? new Date(lastEntry.savedAt) : null;
       const timeAgo = lastTime ? formatTimeAgo(lastTime) : "unknown";
       const lastTask = lastEntry.task?.slice(0, 80) || "unknown";
-      setTimeout(() => {
+      setTimeout(async () => {
         writeContent(() => {
           renderInfo(`Previous session found (${savedCtx.entries.length} entries, last active ${timeAgo})`);
           renderInfo(`Last task: ${lastTask}${lastEntry.task && lastEntry.task.length > 80 ? "..." : ""}`);
-          renderInfo(`Restore previous context? (y/n) [auto-restores in 15s]`);
         });
-        showPrompt();
-        pendingSessionRestore = true;
-        setTimeout(() => {
-          if (pendingSessionRestore) {
-            pendingSessionRestore = false;
-            const prompt = buildContextRestorePrompt(repoRoot);
-            if (prompt) {
-              restoredSessionContext = prompt;
-              const info = loadSessionContext(repoRoot);
-              writeContent(() => renderInfo(`Context auto-restored from ${info?.entries.length ?? 0} session(s).`));
-            } else {
-              writeContent(() => renderInfo("No context to restore. Starting fresh."));
-            }
-            showPrompt();
-          }
+        let autoRestoreTimer = setTimeout(() => {
+          autoRestoreTimer = null;
         }, 15e3);
+        const result = await tuiSelect({
+          items: [
+            { key: "restore", label: "Restore previous context" },
+            { key: "fresh", label: "Start fresh" }
+          ],
+          activeKey: "restore",
+          title: "Restore previous session context?",
+          rl
+        });
+        if (autoRestoreTimer)
+          clearTimeout(autoRestoreTimer);
+        if (result.confirmed && result.key === "restore" || !result.confirmed && !autoRestoreTimer) {
+          const prompt = buildContextRestorePrompt(repoRoot);
+          if (prompt) {
+            restoredSessionContext = prompt;
+            const info = loadSessionContext(repoRoot);
+            writeContent(() => renderInfo(`Context restored from ${info?.entries.length ?? 0} session(s).`));
+          } else {
+            writeContent(() => renderInfo("No context to restore. Starting fresh."));
+          }
+        } else if (result.confirmed && result.key === "fresh") {
+          writeContent(() => renderInfo("Starting fresh."));
+        } else {
+          writeContent(() => renderInfo("Starting fresh."));
+        }
+        showPrompt();
       }, 150);
     }
   }
@@ -49366,22 +49536,6 @@ ${result.content.slice(0, 2e3)}${result.content.length > 2e3 ? "\n[truncated]" :
   rl.on("line", (line) => {
     persistHistoryLine(line);
     const input = line.trim();
-    if (pendingSessionRestore) {
-      pendingSessionRestore = false;
-      const answer = input.toLowerCase();
-      if (answer === "y" || answer === "yes") {
-        const prompt = buildContextRestorePrompt(repoRoot);
-        if (prompt) {
-          restoredSessionContext = prompt;
-          const info = loadSessionContext(repoRoot);
-          writeContent(() => renderInfo(`Context restored from ${info?.entries.length ?? 0} session(s). Will be injected into your next task.`));
-        }
-      } else {
-        writeContent(() => renderInfo("Starting fresh."));
-      }
-      showPrompt();
-      return;
-    }
     if (!input) {
       if (pasteBuffer.length > 0) {
         flushPasteBuffer();
@@ -49436,6 +49590,7 @@ ${result.content.slice(0, 2e3)}${result.content.length > 2e3 ? "\n[truncated]" :
         if (activeTask) {
           activeTask.runner.abort();
         }
+        taskManager.stopAll();
         if (blessEngine?.isActive)
           blessEngine.stop();
         if (telegramBridge?.isActive)
@@ -49505,6 +49660,10 @@ Execute this skill now. Follow the behavioral guidance above.`;
     const isImage = isImagePath(cleanPath) && existsSync40(resolve28(repoRoot, cleanPath));
     const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync40(resolve28(repoRoot, cleanPath));
     if (activeTask) {
+      if (activeTask.runner.isPaused) {
+        activeTask.runner.resume();
+        statusBar.setProcessing(true);
+      }
       if (isImage) {
         try {
           const imgPath = resolve28(repoRoot, cleanPath);
@@ -49532,8 +49691,16 @@ ${result.text}`;
           writeContent(() => renderUserInterrupt(`[Media: ${cleanPath}]`));
         }
       } else {
+        const isReplacement = lastSteeringRetracted;
+        lastSteeringInput = input;
+        lastSteeringRetracted = false;
         const lineCount = input.split("\n").length;
-        if (lineCount > 1) {
+        if (isReplacement) {
+          const displayText2 = lineCount > 1 ? `[pasted ${lineCount} lines]` : input;
+          writeContent(() => process.stdout.write(`
+  ${c2.green("\u21BB")} ${c2.bold("Context replaced:")} ${displayText2}
+`));
+        } else if (lineCount > 1) {
           writeContent(() => renderUserInterrupt(`[pasted ${lineCount} lines]`));
         } else {
           writeContent(() => renderUserInterrupt(input));
@@ -49904,6 +50071,7 @@ ${c2.dim("(paste cancelled)")}
     }
     if (activeTask) {
       activeTask.runner.abort();
+      taskManager.stopAll();
       writeContent(() => renderTaskAborted());
     } else {
       writeContent(() => process.stdout.write(`
@@ -49912,6 +50080,42 @@ ${c2.dim("(Use /quit to exit)")}
     }
     showPrompt();
   });
+  if (process.stdin.isTTY) {
+    readline2.emitKeypressEvents(process.stdin, rl);
+    process.stdin.on("keypress", (_str, key) => {
+      if (!key)
+        return;
+      if (key.name === "escape" && activeTask) {
+        if (!activeTask.runner.isPaused) {
+          activeTask.runner.pause();
+          statusBar.setProcessing(false);
+        }
+        const retracted = activeTask.runner.retractLastPendingMessage();
+        if (retracted) {
+          lastSteeringInput = retracted;
+          lastSteeringRetracted = true;
+          writeContent(() => process.stdout.write(`  ${c2.yellow("\u23F8")} ${c2.dim("\x1B[9m" + retracted.slice(0, 120) + "\x1B[29m")} ${c2.dim("\u2190 retracted, edit below and press Enter")}
+`));
+          rl.line = retracted;
+          rl.cursor = retracted.length;
+          if (statusBar.isActive)
+            statusBar.renderFooterPreserveCursor?.();
+        } else if (lastSteeringInput) {
+          lastSteeringRetracted = true;
+          writeContent(() => process.stdout.write(`  ${c2.yellow("\u23F8")} ${c2.dim("\x1B[9m" + lastSteeringInput.slice(0, 120) + "\x1B[29m")} ${c2.dim("\u2190 already sent, re-type below to override")}
+`));
+          rl.line = lastSteeringInput;
+          rl.cursor = lastSteeringInput.length;
+          if (statusBar.isActive)
+            statusBar.renderFooterPreserveCursor?.();
+        } else {
+          writeContent(() => process.stdout.write(`  ${c2.yellow("\u23F8")} ${c2.dim("Paused. /resume to continue, /stop to kill.")}
+`));
+        }
+        showPrompt();
+      }
+    });
+  }
 }
 async function runWithTUI(task, config, repoPath) {
   const repoRoot = resolve28(repoPath ?? cwd());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.82",
+  "version": "0.103.85",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",