@lazyingart/agintiflow 0.20.118 → 0.20.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.118",
+  "version": "0.20.120",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/scripts/smoke-cli-chat.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -110,6 +110,88 @@ function runCli(args, inputText) {
   });
 }
 
+function shellQuote(value = "") {
+  return `'${String(value).replace(/'/g, `'\"'\"'`)}'`;
+}
+
+function tmux(args, options = {}) {
+  return execFileSync("tmux", args, {
+    encoding: "utf8",
+    timeout: options.timeout || 12000,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function tmuxCapture(session) {
+  try {
+    return tmux(["capture-pane", "-t", session, "-p", "-S", "-200"], { timeout: 5000 });
+  } catch {
+    return "";
+  }
+}
+
+async function waitForTmuxText(session, pattern, timeoutMs = 12000) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const pane = tmuxCapture(session);
+    if (pattern.test(pane)) return pane;
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  return tmuxCapture(session);
+}
+
+async function runTmuxInterruptSmoke({ key, expected }) {
+  const session = `aginti-interrupt-${process.pid}-${key.toLowerCase().replace(/[^a-z0-9]+/g, "")}`;
+  const command = [
+    "env",
+    `AGINTIFLOW_HOME=${shellQuote(agintiflowHome)}`,
+    "AGINTIFLOW_RUNTIME_DIR=",
+    "AGINTI_LANGUAGE=en",
+    "AGINTI_INTERRUPT_FORCE_EXIT_MS=2500",
+    shellQuote(process.execPath),
+    shellQuote(binPath),
+    "chat",
+    "--provider",
+    "mock",
+    "--routing",
+    "manual",
+    "--profile",
+    "code",
+    "--allow-shell",
+    "-s",
+    "normal",
+  ].join(" ");
+  const shellCommand = `cd ${shellQuote(tempRoot)} && ${command}`;
+  try {
+    tmux(["kill-session", "-t", session], { timeout: 2000 });
+  } catch {
+    // Session does not exist.
+  }
+  try {
+    tmux(["new-session", "-d", "-s", session, "bash", "-lc", `${shellCommand}; printf '\\nEXIT:%s\\n' "$?"; sleep 3`]);
+    let pane = await waitForTmuxText(session, /user>/, 10000);
+    if (!/user>/.test(pane)) throw new Error(`interrupt smoke did not reach prompt before ${key}\n${pane}`);
+    tmux(["send-keys", "-t", session, "-l", "sleep interruption smoke"]);
+    tmux(["send-keys", "-t", session, "Enter"]);
+    pane = await waitForTmuxText(session, /run_command|model_wait|Docker:/, 12000);
+    if (!/run_command|model_wait|Docker:/.test(pane)) throw new Error(`interrupt smoke did not start a run before ${key}\n${pane}`);
+    tmux(["send-keys", "-t", session, key]);
+    pane = await waitForTmuxText(session, expected, 10000);
+    if (!expected.test(pane)) throw new Error(`interrupt smoke did not observe ${expected} after ${key}\n${pane}`);
+    if (key === "Escape" && !/EXIT:/.test(pane)) {
+      tmux(["send-keys", "-t", session, "-l", "/exit"]);
+      tmux(["send-keys", "-t", session, "Enter"]);
+      await waitForTmuxText(session, /EXIT:0/, 8000);
+    }
+  } finally {
+    try {
+      tmux(["kill-session", "-t", session], { timeout: 2000 });
+    } catch {
+      // Session may already have exited.
+    }
+  }
+}
+
 try {
   const translatedHelpKeys = [
     "helpHelp",
@@ -363,8 +445,8 @@ try {
   if (classifyEscapeAction({ active: false }) !== "noop") {
     throw new Error("idle Esc should not redraw or clear the prompt");
   }
-  if (classifyEscapeAction({ active: true, pendingAsap: [{ content: "apply now" }] }) !== "wait-for-asap") {
-    throw new Error("active Esc should wait when ASAP pipe messages are pending");
+  if (classifyEscapeAction({ active: true, pendingAsap: [{ content: "apply now" }] }) !== "abort") {
+    throw new Error("active Esc should always abort, even when ASAP pipe messages are pending");
   }
   if (classifyEscapeAction({ active: true, pendingAsap: [] }) !== "abort") {
     throw new Error("active Esc should abort when no ASAP pipe messages are pending");
@@ -664,6 +746,9 @@ try {
     throw new Error("resume history should render full saved messages instead of compact previews");
   }
 
+  await runTmuxInterruptSmoke({ key: "Escape", expected: /Active run stopped|Session saved/ });
+  await runTmuxInterruptSmoke({ key: "C-c", expected: /EXIT:130|Session stopped by ctrl-c|Interrupted\. Session saved/ });
+
   console.log(
     JSON.stringify(
       {
@@ -702,6 +787,8 @@ try {
           "interactive-chat",
           "mock-file-write",
           "run-status",
+          "tmux-escape-active-run-stop",
+          "tmux-ctrl-c-session-stop",
           "resume-latest",
           "resume-history-metadata",
           "resume-history-prompt-labels",

package/scripts/smoke-coding-tools.js

@@ -9,6 +9,7 @@ import {
   runAgent,
   sanitizeToolResult,
   shouldShortCircuitToolBatch,
+  shellDiagnosticHint,
   skippedAfterBlockedToolResult,
 } from "../src/agent-runner.js";
 import { formatBehaviorContractForPrompt } from "../src/behavior-contract.js";
@@ -410,6 +411,13 @@ try {
     quotedDangerSearchPolicy.category !== "destructive",
     "quoted destructive strings in grep pattern should not classify as a destructive command"
   );
+  const grepCountHint = shellDiagnosticHint("grep -c 'Fatal\\|Emergency' article.log && echo done", {
+    ok: false,
+    exitCode: 1,
+    stdout: "0\n",
+    stderr: "",
+  });
+  assert(grepCountHint.includes("grep -c exits 1"), "failed grep-count validation should explain clean zero-match exit behavior");
   const actualDangerAfterQuotePolicy = evaluateCommandPolicy('echo "rm -rf is text" && rm -rf reports', dockerWorkspacePolicy);
   assert(!actualDangerAfterQuotePolicy.allowed, "actual destructive command after quoted text should still be blocked");
   assert(actualDangerAfterQuotePolicy.category === "destructive", "actual destructive command after quoted text was not classified as destructive");

package/scripts/smoke-toolchain-docker.js

@@ -65,6 +65,25 @@ try {
   const outsideRead = await runToolchainCommand(`cat ${path.join(outsideData, "source-note.txt")}`, config);
   assert(outsideRead.stdout.includes("READ_ONLY_HOST_MOUNT_OK"), "Docker normal mode could not read the configured outside data root");
 
+  const abortController = new AbortController();
+  const abortCommand = `python3 -c 'import time; time.sleep(20)'`;
+  const abortPolicy = evaluateCommandPolicy(abortCommand, { ...config, packageInstallPolicy: "allow" });
+  assert(abortPolicy.allowed, "long-running Docker command should be allowed for interrupt smoke");
+  const abortStartedAt = Date.now();
+  const abortRun = runDockerSandboxCommand(abortCommand, { ...config, packageInstallPolicy: "allow" }, abortPolicy, {
+    signal: abortController.signal,
+  });
+  setTimeout(() => abortController.abort(new Error("smoke interrupt")), 500);
+  let interrupted = false;
+  try {
+    await abortRun;
+  } catch (error) {
+    interrupted = /abort|interrupt|cancel/i.test(String(error?.name || "")) || /abort|interrupt|cancel/i.test(String(error?.message || ""));
+  }
+  const abortElapsed = Date.now() - abortStartedAt;
+  assert(interrupted, "Docker command did not reject as interrupted after AbortController abort");
+  assert(abortElapsed < 8000, `Docker interrupt took too long: ${abortElapsed}ms`);
+
   await fs.writeFile(
     path.join(workspace, "plot_fx.py"),
     [

package/src/agent-runner.js

@@ -2,9 +2,8 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import net from "node:net";
 import path from "node:path";
-import { exec as execCallback, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { promisify } from "node:util";
 import { chromium } from "playwright";
 import { createClient, createPlan, requestNextStep } from "./model-client.js";
 import { SessionStore } from "./session-store.js";
@@ -54,7 +53,6 @@ import {
   serializeStepBudgetState,
 } from "./step-budget-controller.js";
 
-const exec = promisify(execCallback);
 const BROWSER_TOOLS = new Set(["open_url", "open_workspace_file", "preview_workspace", "click", "type", "scroll", "press", "back"]);
 const WORKSPACE_TOOLS = new Set(WORKSPACE_TOOL_NAMES);
 const STATIC_PREVIEW_SERVER_PATH = fileURLToPath(new URL("./static-preview-server.js", import.meta.url));
@@ -585,6 +583,7 @@ async function createInitialState(config, sessionId) {
             : "No shell command tool is available.",
           `Permission contract: permission mode is ${config.permissionMode || "normal"}. Safe mode asks before workspace writes/setup. Normal mode allows current-project writes, read-only inspection of visible host paths, and approved Docker setup, but outside-workspace writes and host-system changes require approval. Danger mode is trusted host/full-access mode. Do not bypass blockers by retrying variants. If a tool result includes permissionAdvice or suggestedCommand, stop, explain the blocker, copy the exact suggestedCommand when giving a rerun path, and ask the user to approve/rerun that mode or choose a safer workspace-relative path. Never invent legacy AgInTi syntax such as \`aginti run --sandbox host\`; use the exact flags from permissionAdvice.`,
           "If an operation fails but a directory, artifact, or file already exists, treat it as pre-existing unless you have evidence this run created or updated it. Verify expected outputs before claiming success.",
+          "For validation/evidence commands, remember that grep exits 1 on zero matches. If zero matches is the expected clean result, use `grep -c PATTERN file || true`, split evidence checks into independent commands, or use awk/python so a clean zero count does not stop an `&&` chain.",
           config.allowShellTool
         ? "Host tmux tools are available for long-running terminals: list sessions, capture panes, send safe keys/text, and start detached sessions. Prefer these tools for monitoring long installs/tests/dev servers without blocking; capture before sending input and never send secrets or sudo passwords. Do not start or install tmux inside Docker run_command containers because those containers are short-lived. In Docker sandbox mode, tmux start/send commands must stay workspace-write-bound; prefer run_command for read-only host absolute path inspection through read-only mounts, and ask for --sandbox-mode host for trusted whole-host write/system work."
         + " For one-shot tmux commands, redirect stdout/stderr and exit status to a durable workspace log or keep the pane alive for capture; if capture fails because the session ended, do not infer output or exit status."
@@ -1006,6 +1005,7 @@ async function applyContinuationPrompt(state, config, observers) {
       temporalContext,
       config.startUrl ? `Suggested start URL: ${config.startUrl}` : "",
       config.allowedDomains.length > 0 ? `Allowed domains: ${config.allowedDomains.join(", ")}` : "",
+      "Validation reminder: grep exits 1 on zero matches. For clean-zero checks, guard `grep -c` with `|| true` or split evidence commands so the validation can continue.",
       config.allowShellTool
         ? config.useDockerSandbox
           ? `Shell working directory mounted into Docker as /workspace from ${config.commandCwd}. Use relative paths or /workspace paths for outputs/writes; common host data roots are read-only at original absolute paths for inspection. Persistent Docker env: /aginti-env, caches: /aginti-cache. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
@@ -1076,6 +1076,112 @@ function safeExecutionEnv() {
   };
 }
 
+function trimOutput(value = "", limit = 8000) {
+  const text = redactSensitiveText(String(value || ""));
+  return text.trim().slice(0, limit);
+}
+
+function killChildTree(child, signal = "SIGTERM") {
+  if (!child || child.killed) return;
+  try {
+    if (process.platform === "win32") child.kill(signal);
+    else process.kill(-child.pid, signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+      // Best effort; process may already be gone.
+    }
+  }
+}
+
+function runHostShellCommand(command, config) {
+  return new Promise((resolve, reject) => {
+    const shell = hostShellOption();
+    const child = spawn(String(command || ""), {
+      cwd: config.commandCwd,
+      env: safeExecutionEnv(),
+      shell,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    const timeoutMs = Number(config.shellTimeoutMs || process.env.AGINTI_SHELL_TIMEOUT_MS || 30000);
+    const maxStdout = 220 * 1024;
+    const maxStderr = 120 * 1024;
+
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (config.abortSignal && onAbort) config.abortSignal.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const onAbort = () => {
+      killChildTree(child, "SIGTERM");
+      setTimeout(() => killChildTree(child, "SIGKILL"), 1200).unref?.();
+      const error = new Error("Run interrupted by user.");
+      error.name = "AbortError";
+      error.code = "ABORT_ERR";
+      settle(() => reject(error));
+    };
+    const timer =
+      Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? setTimeout(() => {
+            timedOut = true;
+            killChildTree(child, "SIGTERM");
+            setTimeout(() => killChildTree(child, "SIGKILL"), 1200).unref?.();
+          }, timeoutMs)
+        : null;
+    timer?.unref?.();
+
+    if (config.abortSignal?.aborted) return onAbort();
+    if (config.abortSignal) config.abortSignal.addEventListener("abort", onAbort, { once: true });
+
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < maxStdout) stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < maxStderr) stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      settle(() =>
+        resolve({
+          ok: false,
+          exitCode: 1,
+          stdout,
+          stderr: `${stderr}${stderr ? "\n" : ""}${error instanceof Error ? error.message : String(error)}`,
+        })
+      );
+    });
+    child.on("close", (code, signalName) => {
+      settle(() =>
+        resolve({
+          ok: !timedOut && Number(code || 0) === 0,
+          exitCode: timedOut ? 124 : Number.isInteger(code) ? code : signalName ? 130 : 1,
+          stdout,
+          stderr: `${stderr}${timedOut ? `\nCommand timed out after ${timeoutMs}ms.` : ""}`,
+        })
+      );
+    });
+  });
+}
+
+export function shellDiagnosticHint(command = "", result = {}) {
+  if (result?.ok !== false) return "";
+  const text = String(command || "");
+  if (/\bgrep\b[\s\S]*\s-c\b|\bgrep\s+-c\b/.test(text)) {
+    return "grep -c exits 1 when it finds zero matches even though it prints 0. For count-only validation, use `grep -c PATTERN file || true`, split evidence commands, or use awk/python when zero matches is the expected clean state.";
+  }
+  if (/\bgrep\b/.test(text) && /&&/.test(text)) {
+    return "grep exits 1 when it finds no matches, so an `&&` evidence chain can stop early. If no matches is acceptable, guard that grep with `|| true` or run independent validation commands.";
+  }
+  return "";
+}
+
 function hashForLog(value) {
   return crypto.createHash("sha256").update(String(value ?? "")).digest("hex");
 }
@@ -1261,29 +1367,26 @@ async function runShellCommand(command, config, policy = evaluateCommandPolicy(c
     throwIfAborted(config);
     const result = config.useDockerSandbox
       ? await runDockerSandboxCommand(command, config, policy, { signal: config.abortSignal })
-      : await exec(command, {
-          cwd: config.commandCwd,
-          timeout: 30000,
-          maxBuffer: 200 * 1024,
-          shell: hostShellOption(),
-          env: safeExecutionEnv(),
-          signal: config.abortSignal,
-        });
+      : await runHostShellCommand(command, config);
+    const diagnosticHint = shellDiagnosticHint(command, result);
 
     return {
-      ok: true,
-      exitCode: 0,
-      stdout: redactSensitiveText(result.stdout).trim().slice(0, 8000),
-      stderr: redactSensitiveText(result.stderr).trim().slice(0, 4000),
+      ok: result.ok !== false,
+      exitCode: Number.isInteger(result.exitCode) ? result.exitCode : 0,
+      stdout: trimOutput(result.stdout, 8000),
+      stderr: trimOutput(result.stderr, 4000),
+      ...(diagnosticHint ? { diagnosticHint } : {}),
     };
   } catch (error) {
     if (isAbortError(error, config)) throw error;
-    return {
+    const failedResult = {
       ok: false,
       exitCode: Number.isInteger(error?.code) ? error.code : 1,
-      stdout: redactSensitiveText(String(error?.stdout || "")).trim().slice(0, 8000),
-      stderr: redactSensitiveText(String(error?.stderr || error?.message || "")).trim().slice(0, 4000),
+      stdout: trimOutput(error?.stdout || "", 8000),
+      stderr: trimOutput(error?.stderr || error?.message || "", 4000),
     };
+    const diagnosticHint = shellDiagnosticHint(command, failedResult);
+    return diagnosticHint ? { ...failedResult, diagnosticHint } : failedResult;
   }
 }
 
@@ -1295,6 +1398,7 @@ async function captureSyntheticSnapshot(store, step, config) {
     pageText: [
       "No browser page is currently open.",
       config.startUrl ? `Suggested start URL: ${config.startUrl}` : "",
+      "Validation reminder: grep exits 1 on zero matches; guard expected clean-zero grep checks or split evidence commands.",
       config.allowShellTool
         ? config.useDockerSandbox
           ? `Shell tool available in Docker with mounted workspace /workspace from ${config.commandCwd}. Use relative paths or /workspace paths for outputs/writes; common host data roots are read-only at original absolute paths for inspection. Persistent Docker env: /aginti-env, caches: /aginti-cache. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
@@ -1557,9 +1661,9 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         break;
       case "wait":
         if (browserState.page) {
-          await browserState.page.waitForTimeout(Number.isFinite(args.ms) ? Number(args.ms) : 1000);
+          await abortable(browserState.page.waitForTimeout(Number.isFinite(args.ms) ? Number(args.ms) : 1000), config.abortSignal);
         } else {
-          await new Promise((resolve) => setTimeout(resolve, Number.isFinite(args.ms) ? Number(args.ms) : 1000));
+          await abortable(new Promise((resolve) => setTimeout(resolve, Number.isFinite(args.ms) ? Number(args.ms) : 1000)), config.abortSignal);
         }
         break;
       case "inspect_project":
@@ -1645,14 +1749,14 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         return result;
       }
       case "tmux_list_sessions": {
-        const result = await listTmuxSessions(args);
+        const result = await listTmuxSessions(args, config);
         const eventResult = sanitizeToolResult(result);
         await store.appendEvent(result.ok ? "tool.completed" : "tool.failed", eventResult);
         observers.event(result.ok ? "tool.completed" : "tool.failed", eventResult);
         return result;
       }
       case "tmux_capture_pane": {
-        const result = await captureTmuxPane(args);
+        const result = await captureTmuxPane(args, config);
         const eventResult = sanitizeToolResult(result);
         await store.appendEvent(result.ok ? "tool.completed" : "tool.failed", eventResult);
         observers.event(result.ok ? "tool.completed" : "tool.failed", eventResult);
@@ -2377,6 +2481,7 @@ export async function runAgent(config) {
             command: redactSensitiveText(toolResult.args?.command || ""),
             stdout: toolResult.stdout || "",
             stderr: toolResult.stderr || "",
+            diagnosticHint: toolResult.diagnosticHint || "",
             commandPolicy: toolResult.commandPolicy,
             blocked: Boolean(toolResult.blocked),
             error: toolResult.error || toolResult.reason || "",

package/src/auxiliary-tools.js

@@ -164,11 +164,43 @@ async function writeJson(filePath, payload) {
   await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
 }
 
-async function requestJson(url, payload, apiKey, { timeoutMs = 300000, retries = 2 } = {}) {
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = signal.reason instanceof Error ? signal.reason : new Error("Operation interrupted by user.");
+  error.name = error.name || "AbortError";
+  throw error;
+}
+
+function sleepAbortable(ms, signal) {
+  if (!signal) return new Promise((resolve) => setTimeout(resolve, ms));
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason instanceof Error ? signal.reason : new Error("Operation interrupted by user."));
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+async function requestJson(url, payload, apiKey, { timeoutMs = 300000, retries = 2, signal = null } = {}) {
   let lastError = null;
   for (let attempt = 0; attempt <= retries; attempt += 1) {
+    throwIfAborted(signal);
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const onAbort = () => controller.abort(signal.reason || new Error("Operation interrupted by user."));
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    if (signal?.aborted) onAbort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
     try {
       const response = await fetch(url, {
         method: "POST",
@@ -187,25 +219,29 @@ async function requestJson(url, payload, apiKey, { timeoutMs = 300000, retries =
       }
       return parseJsonResponse(text);
     } catch (error) {
+      if (signal?.aborted || error?.code === "ABORT_ERR" || (error?.name === "AbortError" && !timedOut)) throw error;
       lastError = error;
       const retryable = TRANSIENT_HTTP_CODES.has(Number(error?.status)) || /aborted|timeout|fetch failed/i.test(String(error?.message || ""));
       if (!retryable || attempt >= retries) throw error;
-      await new Promise((resolve) => setTimeout(resolve, 2000 + attempt * 2000));
+      await sleepAbortable(2000 + attempt * 2000, signal);
     } finally {
       clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
     }
   }
   throw lastError || new Error("Image API request failed.");
 }
 
-async function pollResult({ host, taskId, apiKey, outputDir, intervalMs = 5000, timeoutMs = 900000, requestTimeoutMs = 300000 }) {
+async function pollResult({ host, taskId, apiKey, outputDir, intervalMs = 5000, timeoutMs = 900000, requestTimeoutMs = 300000, signal = null }) {
   const started = Date.now();
   const pollUrl = `${host.replace(/\/+$/, "")}/v1/draw/result`;
   let attempt = 0;
   while (true) {
+    throwIfAborted(signal);
     const result = await requestJson(pollUrl, { id: taskId }, apiKey, {
       timeoutMs: requestTimeoutMs,
       retries: 4,
+      signal,
     });
     await writeJson(path.join(outputDir, "result_response.json"), result);
 
@@ -214,15 +250,16 @@ async function pollResult({ host, taskId, apiKey, outputDir, intervalMs = 5000,
     if (status === "succeeded" || status === "failed") return result;
     if (Date.now() - started > timeoutMs) throw new Error(`Image generation polling timed out for task ${taskId}.`);
     attempt += 1;
-    await new Promise((resolve) => setTimeout(resolve, Math.min(intervalMs + attempt * 250, 12000)));
+    await sleepAbortable(Math.min(intervalMs + attempt * 250, 12000), signal);
   }
 }
 
-async function downloadImage(url, destination) {
+async function downloadImage(url, destination, signal = null) {
   const response = await fetch(url, {
     headers: {
       "User-Agent": "AgInTiFlow/1.0",
     },
+    signal,
   });
   if (!response.ok) throw new Error(`Image download failed with HTTP ${response.status}.`);
   const buffer = Buffer.from(await response.arrayBuffer());
@@ -268,7 +305,7 @@ function veniceBaseUrl(value = "") {
     .replace(/\/+$/, "");
 }
 
-async function generateVeniceImages({ prompt, args, target, outputStem, manifest, manifestPath }) {
+async function generateVeniceImages({ prompt, args, target, outputStem, manifest, manifestPath, signal = null }) {
   const apiKey = veniceKey();
   if (!apiKey) {
     throw new Error("Missing VENICE_API_KEY. Run `aginti login venice` or `aginti keys set venice --stdin`.");
@@ -295,6 +332,7 @@ async function generateVeniceImages({ prompt, args, target, outputStem, manifest
   const resultPayload = await requestJson(`${base}/image/generate`, payload, apiKey, {
     timeoutMs: Number(args.requestTimeoutMs) || 300000,
     retries: 2,
+    signal,
   });
   await writeJson(path.join(target.absolutePath, "venice_result_response.json"), {
     id: resultPayload.id || "",
@@ -419,7 +457,7 @@ export async function generateImage(args = {}, config = {}) {
   }
 
   if (provider === "venice") {
-    return generateVeniceImages({ prompt, args, target, outputStem, manifest, manifestPath });
+    return generateVeniceImages({ prompt, args, target, outputStem, manifest, manifestPath, signal: config.abortSignal });
   }
 
   const apiKey = grsaiKey();
@@ -431,6 +469,7 @@ export async function generateImage(args = {}, config = {}) {
   const submitPayload = await requestJson(submitUrl, payload, apiKey, {
     timeoutMs: Number(args.requestTimeoutMs) || 300000,
     retries: 2,
+    signal: config.abortSignal,
   });
   await writeJson(path.join(target.absolutePath, "submit_response.json"), submitPayload);
   const taskId = submitPayload?.data?.id || submitPayload?.id;
@@ -449,6 +488,7 @@ export async function generateImage(args = {}, config = {}) {
     intervalMs: Number(args.pollIntervalMs) || 5000,
     timeoutMs: Number(args.pollTimeoutMs) || 900000,
     requestTimeoutMs: Number(args.requestTimeoutMs) || 300000,
+    signal: config.abortSignal,
   });
 
   const status = resultPayload.status || resultPayload?.data?.status;
@@ -468,7 +508,7 @@ export async function generateImage(args = {}, config = {}) {
     const suffix = path.extname(parsed.pathname) || ".png";
     const filename = urls.length === 1 ? `${outputStem}${suffix}` : `${outputStem}_${String(index + 1).padStart(2, "0")}${suffix}`;
     const absolutePath = path.join(target.absolutePath, filename);
-    const info = await downloadImage(urls[index], absolutePath);
+    const info = await downloadImage(urls[index], absolutePath, config.abortSignal);
     const relativePath = path.posix.join(target.relativePath, filename);
     imagePaths.push(relativePath);
     downloads.push({ path: relativePath, ...info });

package/src/docker-sandbox.js

@@ -1,3 +1,4 @@
+import crypto from "node:crypto";
 import fsSync, { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -63,6 +64,23 @@ async function execDocker(args, options = {}) {
     signal: options.signal,
   };
   recordSandboxLog("docker.command", { args });
+  const containerName = options.containerName || "";
+  let abortHandler = null;
+  if (options.signal && containerName) {
+    abortHandler = () => {
+      void execFile("docker", ["kill", containerName], {
+        timeout: 8000,
+        maxBuffer: 32 * 1024,
+      }).catch((error) => {
+        recordSandboxLog("docker.kill.failed", {
+          containerName,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      });
+    };
+    if (options.signal.aborted) abortHandler();
+    else options.signal.addEventListener("abort", abortHandler, { once: true });
+  }
 
   try {
     const result = await execFile("docker", args, execOptions);
@@ -81,6 +99,8 @@ async function execDocker(args, options = {}) {
       stdout: redactSensitiveText(result.stdout),
       stderr: redactSensitiveText(result.stderr),
     };
+  } finally {
+    if (options.signal && abortHandler) options.signal.removeEventListener("abort", abortHandler);
   }
 }
 
@@ -282,7 +302,11 @@ function dockerCommand(command, policy) {
   return [...envLines, dockerUserCommand(command, policy)].join("\n");
 }
 
-function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command, config), persistentDirs = persistentDockerDirs(config)) {
+function dockerContainerName() {
+  return `aginti-${process.pid}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`.slice(0, 63);
+}
+
+function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command, config), persistentDirs = persistentDockerDirs(config), options = {}) {
   const uid = typeof process.getuid === "function" ? String(process.getuid()) : "";
   const gid = typeof process.getgid === "function" ? String(process.getgid()) : "";
   const userArgs = uid && gid && !policy.requiresDockerRoot ? ["--user", `${uid}:${gid}`] : [];
@@ -299,6 +323,7 @@ function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command,
   return [
     "run",
     "--rm",
+    ...(options.containerName ? ["--name", options.containerName] : []),
     "--network",
     networkMode,
     "--cap-drop",
@@ -337,10 +362,12 @@ function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command,
 
 export async function runDockerSandboxCommand(command, config, policy = evaluateCommandPolicy(command, config), options = {}) {
   const persistentDirs = await ensurePersistentDockerDirs(config);
-  const result = await execDocker(dockerRunArgs(command, config, policy, persistentDirs), {
+  const containerName = dockerContainerName();
+  const result = await execDocker(dockerRunArgs(command, config, policy, persistentDirs, { containerName }), {
     timeout: dockerExecTimeoutMs(policy),
     maxBuffer: 300 * 1024,
     signal: options.signal,
+    containerName,
   });
 
   const payload = {

package/src/interactive-cli.js

@@ -210,6 +210,10 @@ export class ComposerHistory {
 
 const promptHistory = new ComposerHistory();
 let activeRunInput = null;
+let activeRunController = null;
+let activeRunExitAfterStop = false;
+let activeRunAbortSource = "";
+let activeRunForceExitTimer = null;
 let cliLanguage = resolveLanguage();
 
 function setCliLanguage(language = "") {
@@ -230,6 +234,24 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function interruptForceExitMs() {
+  const value = Number(process.env.AGINTI_INTERRUPT_FORCE_EXIT_MS || 8000);
+  return Number.isFinite(value) && value > 0 ? value : 8000;
+}
+
+function restoreTerminalForExit() {
+  try {
+    if (typeof input.setRawMode === "function" && input.isRaw) input.setRawMode(false);
+  } catch {
+    // Terminal may already be closed.
+  }
+  try {
+    output.write(ansi.cursorShow);
+  } catch {
+    // Ignore closed stdout.
+  }
+}
+
 const ROLE_LABEL_WIDTH = "aginti".length;
 const PROMPT_LABEL_WIDTH = "aginti>".length;
 
@@ -720,6 +742,9 @@ function printCommandOutputLog(data = {}) {
     if (advice.suggestedCommand) outputLine(`${color(" | ", ansi.red)} rerun: ${compactLine(advice.suggestedCommand, 120)}`);
     if (advice.trustedHostCommand) outputLine(`${color(" | ", ansi.red)} host: ${compactLine(advice.trustedHostCommand, 120)}`);
   }
+  if (data.diagnosticHint) {
+    outputLine(`${label("hint", ansi.yellow)} ${compactLine(data.diagnosticHint, 112)}`);
+  }
 }
 
 function printHeading(text) {
@@ -1170,16 +1195,83 @@ function removeAt(buffer, cursor) {
   };
 }
 
-function createAbortError(message = "Aborted with Ctrl+C") {
+function createAbortError(message = "Aborted with Ctrl+C", options = {}) {
   const error = new Error(message);
   error.code = "ABORT_ERR";
   error.name = "AbortError";
+  error.source = options.source || "";
+  error.exitSession = Boolean(options.exitSession);
   return error;
 }
 
 export function classifyEscapeAction({ active = false, pendingAsap = [] } = {}) {
   if (!active) return "noop";
-  return Array.isArray(pendingAsap) && pendingAsap.length > 0 ? "wait-for-asap" : "abort";
+  return "abort";
+}
+
+function scheduleRunForceExit(reason = "interrupt", forceExitMs = interruptForceExitMs()) {
+  if (activeRunForceExitTimer || !Number.isFinite(forceExitMs) || forceExitMs <= 0) return;
+  activeRunForceExitTimer = setTimeout(() => {
+    restoreTerminalForExit();
+    printSystemLine(`status=force_exit reason=${reason}`);
+    process.exit(130);
+  }, forceExitMs);
+  activeRunForceExitTimer.unref?.();
+}
+
+function clearRunForceExit() {
+  if (!activeRunForceExitTimer) return;
+  clearTimeout(activeRunForceExitTimer);
+  activeRunForceExitTimer = null;
+}
+
+function requestActiveRunStop({ source = "escape", exitSession = false, forceExitMs = interruptForceExitMs() } = {}) {
+  if (!activeRunController) return false;
+  activeRunExitAfterStop = activeRunExitAfterStop || Boolean(exitSession);
+  activeRunAbortSource = activeRunAbortSource || source;
+  const reason = source === "ctrl-c" ? "ctrl-c" : source === "sigterm" ? "sigterm" : "escape";
+  const message =
+    exitSession || source === "ctrl-c"
+      ? "Interrupted by ctrl-c; stopping the session."
+      : `Interrupted by ${reason}; stopping the active run.`;
+  if (!activeRunController.signal.aborted) {
+    printStatusEvent({ status: "stopping" }, "interrupt", `${reason}; hard stop in ${Math.ceil(forceExitMs / 1000)}s`);
+    activeRunController.abort(createAbortError(message, { source, exitSession }));
+  } else if (exitSession) {
+    scheduleRunForceExit("second-interrupt", 100);
+    return true;
+  }
+  scheduleRunForceExit(reason, forceExitMs);
+  return true;
+}
+
+function clearActiveRunControl(controller) {
+  if (activeRunController !== controller) return;
+  activeRunController = null;
+  activeRunAbortSource = "";
+  activeRunExitAfterStop = false;
+  clearRunForceExit();
+}
+
+function installProcessInterruptHandlers() {
+  const onSigint = () => {
+    if (requestActiveRunStop({ source: "ctrl-c", exitSession: true, forceExitMs: interruptForceExitMs() })) return;
+    restoreTerminalForExit();
+    printSystemLine("status=exit reason=ctrl-c");
+    process.exit(130);
+  };
+  const onSigterm = () => {
+    if (requestActiveRunStop({ source: "sigterm", exitSession: true, forceExitMs: 1000 })) return;
+    restoreTerminalForExit();
+    printSystemLine("status=exit reason=sigterm");
+    process.exit(143);
+  };
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
+  return () => {
+    process.off("SIGINT", onSigint);
+    process.off("SIGTERM", onSigterm);
+  };
 }
 
 export function activeRunSlashCommandAction(value = "") {
@@ -1304,7 +1396,7 @@ function readTtyPrompt(options = {}) {
       if (key.ctrl && key.name === "c") {
         clearPromptPanel();
         cleanup();
-        reject(createAbortError());
+        reject(createAbortError("Interrupted by ctrl-c.", { source: "ctrl-c", exitSession: true }));
         return;
       }
       if ((key.ctrl && key.name === "j") || key.sequence === "\n") {
@@ -1675,18 +1767,14 @@ class LiveRunInput {
 
   handleKey(str = "", key = {}) {
     if (key.ctrl && key.name === "c") {
-      this.controller.abort(new Error("Interrupted by ctrl-c."));
+      this.setStatus("stopping · ctrl-c");
+      requestActiveRunStop({ source: "ctrl-c", exitSession: true });
       return;
     }
     if (key.name === "escape") {
       const action = classifyEscapeAction({ active: true, pendingAsap: this.pendingAsap });
-      if (action === "wait-for-asap") {
-        const count = this.pendingAsap.length;
-        this.setStatus(`running · waiting to apply ${count} asap pipe message${count === 1 ? "" : "s"}`);
-        this.redraw();
-        return;
-      }
-      this.controller.abort(new Error("Interrupted by escape."));
+      this.setStatus("stopping · escape");
+      if (action === "abort") requestActiveRunStop({ source: "escape", exitSession: false });
       return;
     }
     if (key.meta && key.name === "up") {
@@ -1784,7 +1872,9 @@ function printStatus(state) {
   printSystemLine(`project=${process.cwd()}`);
   printSystemLine(`cwd=${state.commandCwd || process.cwd()}`);
   printSystemLine(`session=${state.sessionId || "new"}`);
-  printSystemLine(`status=${state.status || "idle"}${state.activeGoal ? ` workingOn=${state.activeGoal}` : ""}`);
+  const progress =
+    state.currentStep && state.currentMaxSteps ? ` progress=${state.currentStep}/${state.currentMaxSteps}` : state.currentStep ? ` progress=${state.currentStep}` : "";
+  printSystemLine(`status=${state.status || "idle"}${progress}${state.activeGoal ? ` workingOn=${state.activeGoal}` : ""}`);
   printSystemLine(`language=${state.language || cliLanguage} (${languageLabel(state.language || cliLanguage)})`);
   if (state.lastEvent) printSystemLine(`last=${state.lastEvent}`);
   printSystemLine(`provider=${state.provider || "auto"} routing=${state.routingMode} model=${state.model || "auto"}`);
@@ -1954,9 +2044,26 @@ async function printResumeHistory(state, { limit = 0 } = {}) {
   for (const entry of shown) printHistoryEntry(entry);
 }
 
-function printStatusEvent(state, label, details = "") {
+function toolStatusDetails(data = {}) {
+  const tool = data.toolName || "unknown";
+  const args = data.args || {};
+  if (tool === "run_command" && args.command) return `${tool}: ${compactLine(args.command, 58)}`;
+  if ((tool === "write_file" || tool === "apply_patch" || tool === "read_file" || tool === "open_workspace_file") && args.path) {
+    return `${tool}: ${compactLine(args.path, 58)}`;
+  }
+  if ((tool === "open_url" || tool === "web_research" || tool === "web_search") && (args.url || args.query || args.q)) {
+    return `${tool}: ${compactLine(args.url || args.query || args.q, 58)}`;
+  }
+  return tool;
+}
+
+function printStatusEvent(state, label, details = "", meta = {}) {
   const safeDetails = compactLine(details, 72);
-  state.lastEvent = safeDetails ? `${label}: ${safeDetails}` : label;
+  if (meta.step) state.currentStep = meta.step;
+  if (meta.maxSteps) state.currentMaxSteps = meta.maxSteps;
+  const progress =
+    state.currentStep && state.currentMaxSteps ? `step ${state.currentStep}/${state.currentMaxSteps} · ` : state.currentStep ? `step ${state.currentStep} · ` : "";
+  state.lastEvent = `${progress}${safeDetails ? `${label}: ${safeDetails}` : label}`;
   const statusText = `${state.status || "running"} · ${state.lastEvent}`;
   if (activeRunInput) {
     activeRunInput.setStatus(statusText);
@@ -1979,7 +2086,7 @@ function attachRunInterrupts(controller) {
     if (controller.signal.aborted) return;
     const reason = isEscape ? "escape" : "ctrl-c";
     printSystemLine(`status=stopping reason=${reason}`);
-    controller.abort(new Error(`Interrupted by ${reason}.`));
+    requestActiveRunStop({ source: reason, exitSession: isCtrlC });
   };
   input.on("keypress", handler);
   return () => {
@@ -3575,6 +3682,10 @@ async function runPrompt(prompt, state, packageDir, { approvalDepth = 0 } = {})
     projectSessionsDir: config.projectSessionsDir,
   });
   const liveInput = new LiveRunInput({ state, store, controller });
+  activeRunController = controller;
+  activeRunExitAfterStop = false;
+  activeRunAbortSource = "";
+  clearRunForceExit();
   const liveStarted = liveInput.start();
   const detachInterrupts = liveStarted ? () => {} : attachRunInterrupts(controller);
   if (liveStarted) {
@@ -3613,12 +3724,18 @@ async function runPrompt(prompt, state, packageDir, { approvalDepth = 0 } = {})
       onEvent: (type, data = {}) => {
         if (type === "plan.created") {
           printStatusEvent(state, "planned");
+        } else if (type === "budget.initialized") {
+          state.currentMaxSteps = data.currentMaxSteps || data.initialMaxSteps || state.maxSteps;
+          printStatusEvent(state, "budget", `${state.currentMaxSteps} steps`);
         } else if (type === "model.requested") {
-          printStatusEvent(state, "model_wait", `${data.provider || "model"}/${data.model || ""}`);
+          printStatusEvent(state, "model_wait", `${data.provider || "model"}/${data.model || ""}`, {
+            step: data.step,
+            maxSteps: state.currentMaxSteps,
+          });
         } else if (type === "tool.started") {
-          printStatusEvent(state, "tool", data.toolName || "unknown");
-        } else if (type === "tool.completed") {
-          printStatusEvent(state, "tool_done", data.toolName || "unknown");
+          printStatusEvent(state, "tool", toolStatusDetails(data));
+        } else if (type === "tool.completed" || type === "tool.failed") {
+          printStatusEvent(state, type === "tool.failed" || data.ok === false ? "tool_failed" : "tool_done", toolStatusDetails(data));
         } else if (type === "file.changed") {
           printWorkspaceChange(data);
         } else if (type === "tool.blocked") {
@@ -3643,7 +3760,10 @@ async function runPrompt(prompt, state, packageDir, { approvalDepth = 0 } = {})
         } else if (type === "session.stopped") {
           printStatusEvent(state, "stopped", data.reason || "");
         } else if (type === "model.responded") {
-          printStatusEvent(state, "model_responded", data.content ? data.content.slice(0, 80).replace(/\s+/g, " ") : "");
+          printStatusEvent(state, "model_responded", data.content ? data.content.slice(0, 80).replace(/\s+/g, " ") : "", {
+            step: data.step,
+            maxSteps: state.currentMaxSteps,
+          });
         }
       },
     });
@@ -3652,11 +3772,15 @@ async function runPrompt(prompt, state, packageDir, { approvalDepth = 0 } = {})
   } finally {
     detachInterrupts();
     queuedAfterFinish = await liveInput.stop();
+    clearRunForceExit();
   }
   if (runError) {
     state.status = isAbortError(runError) ? "stopped" : "failed";
     state.activeGoal = "";
     printSystemLine(`status=${state.status} session=${state.sessionId}`);
+    const exitSession = Boolean(runError.exitSession || activeRunExitAfterStop);
+    clearActiveRunControl(controller);
+    if (isAbortError(runError) && !exitSession) return queuedAfterFinish;
     throw runError;
   }
   state.sessionId = result.sessionId || state.sessionId;
@@ -3664,9 +3788,16 @@ async function runPrompt(prompt, state, packageDir, { approvalDepth = 0 } = {})
   state.activeGoal = "";
   printSystemLine(`status=${state.status} session=${state.sessionId}`);
   if (result.stopped && result.reason === "user_interrupt") {
-    await printResumeHint(state);
+    const exitSession = activeRunExitAfterStop;
+    const abortSource = activeRunAbortSource || "ctrl-c";
+    clearActiveRunControl(controller);
+    if (exitSession) {
+      throw createAbortError("Session stopped by ctrl-c.", { source: abortSource, exitSession: true });
+    }
+    printAgentMessage("Active run stopped. Session saved; enter a new prompt or use /status.");
     return [];
   }
+  clearActiveRunControl(controller);
   if (!result.stopped && latestPermissionAdvice) {
     const approvalQueued = await maybeContinueAfterPermissionApproval(latestPermissionAdvice, state, packageDir, {
       approvalDepth,
@@ -3679,6 +3810,7 @@ async function runPrompt(prompt, state, packageDir, { approvalDepth = 0 } = {})
 
 export async function startInteractiveCli(args = {}, { packageDir, packageVersion } = {}) {
   const state = createState(args);
+  const detachProcessInterrupts = installProcessInterruptHandlers();
   setCliLanguage(state.language);
   const rl =
     input.isTTY && output.isTTY
@@ -3705,6 +3837,7 @@ export async function startInteractiveCli(args = {}, { packageDir, packageVersio
       } catch (error) {
         if (error?.code === "ERR_USE_AFTER_CLOSE") break;
         if (isAbortError(error)) {
+          if (error.exitSession) process.exitCode = 130;
           await printResumeHint(state);
           break;
         }
@@ -3734,6 +3867,7 @@ export async function startInteractiveCli(args = {}, { packageDir, packageVersio
         }
       } catch (error) {
         if (isAbortError(error)) {
+          if (error.exitSession) process.exitCode = 130;
           await printResumeHint(state);
           break;
         }
@@ -3741,6 +3875,8 @@ export async function startInteractiveCli(args = {}, { packageDir, packageVersio
       }
     }
   } finally {
+    detachProcessInterrupts();
     rl?.close();
+    restoreTerminalForExit();
   }
 }

package/src/model-client.js

@@ -405,6 +405,7 @@ export function normalizeTextToolCallResponse(response) {
 
 function mockCommandForGoal(goal = "") {
   const text = String(goal).toLowerCase();
+  if (/\bsleep\b|\binterrupt\b|\bstall\b|\blong[- ]running\b/.test(text)) return "python3 -c 'import time; time.sleep(20)'";
   if (/\blist\b|folder contents|directory contents|files?/.test(text)) return "ls -la";
   return "pwd";
 }

package/src/tmux-tools.js

@@ -50,6 +50,7 @@ async function runTmux(args, options = {}) {
       timeout: options.timeout ?? 12000,
       maxBuffer: options.maxBuffer ?? 220 * 1024,
       env: safeEnv(),
+      signal: options.signal,
     });
     return {
       ok: true,
@@ -57,6 +58,7 @@ async function runTmux(args, options = {}) {
       stderr: redactSensitiveText(result.stderr || ""),
     };
   } catch (error) {
+    if (error?.name === "AbortError" || error?.code === "ABORT_ERR") throw error;
     const message = redactSensitiveText(error instanceof Error ? error.message : String(error));
     return {
       ok: false,
@@ -161,10 +163,11 @@ function isShellPaneCommand(command = "") {
   return /^(?:ba|z|fi|da|k)?sh$|^fish$/.test(String(command || "").trim());
 }
 
-async function getPaneCurrentCommand(target) {
+async function getPaneCurrentCommand(target, config = {}) {
   const result = await runTmux(["display-message", "-p", "-t", target, "#{pane_current_command}"], {
     timeout: 4000,
     maxBuffer: 16 * 1024,
+    signal: config.abortSignal,
   });
   if (!result.ok) return "";
   return String(result.stdout || "").trim();
@@ -215,12 +218,12 @@ function parsePanes(stdout = "") {
     });
 }
 
-export async function listTmuxSessions(args = {}) {
+export async function listTmuxSessions(args = {}, config = {}) {
   const sessionsResult = await runTmux([
     "list-sessions",
     "-F",
     "#{session_name}|#{session_windows}|#{session_attached}|#{session_created}|#{session_activity}",
-  ]);
+  ], { signal: config.abortSignal });
   if (!sessionsResult.ok && /no server running|failed to connect/i.test(`${sessionsResult.stderr} ${sessionsResult.error}`)) {
     return { ok: true, toolName: "tmux_list_sessions", sessions: [], panes: [], summary: "No tmux server is running." };
   }
@@ -233,7 +236,7 @@ export async function listTmuxSessions(args = {}) {
       "-a",
       "-F",
       "#{session_name}:#{window_index}.#{pane_index}|#{pane_current_path}|#{pane_current_command}|#{pane_active}|#{pane_title}",
-    ]);
+    ], { signal: config.abortSignal });
     if (panesResult.ok) panes = parsePanes(panesResult.stdout);
   }
   const sessions = parseSessions(sessionsResult.stdout);
@@ -246,13 +249,14 @@ export async function listTmuxSessions(args = {}) {
   };
 }
 
-export async function captureTmuxPane(args = {}) {
+export async function captureTmuxPane(args = {}, config = {}) {
   const target = validateTarget(args.target);
   if (!target.ok) return { ok: false, toolName: "tmux_capture_pane", blocked: true, reason: target.reason };
   const lines = clampInteger(args.lines, 80, 1, MAX_CAPTURE_LINES);
   const result = await runTmux(["capture-pane", "-t", target.target, "-p", "-S", `-${lines}`], {
     timeout: 8000,
     maxBuffer: 260 * 1024,
+    signal: config.abortSignal,
   });
   if (!result.ok) return { ok: false, toolName: "tmux_capture_pane", target: target.target, error: result.stderr || result.error };
   const content = redactSensitiveText(result.stdout || "").replace(/\s+$/g, "");
@@ -299,7 +303,7 @@ export async function sendTmuxKeys(args = {}, config = {}) {
   const keyArgsForPolicy = [...keys];
   if (enter) keyArgsForPolicy.push("Enter");
   if (text && keyArgsForPolicy.includes("Enter") && shouldApplyDockerShellPolicy(config)) {
-    const paneCommand = await getPaneCurrentCommand(target.target);
+      const paneCommand = await getPaneCurrentCommand(target.target, config);
     if (isShellPaneCommand(paneCommand)) {
       const dockerPolicy = checkDockerShellPolicyForTmuxText(text, config, "tmux text");
       if (!dockerPolicy.ok) {
@@ -323,14 +327,14 @@ export async function sendTmuxKeys(args = {}, config = {}) {
 
   const steps = [];
   if (text) {
-    const sent = await runTmux(["send-keys", "-t", target.target, "-l", text], { timeout: 8000 });
+    const sent = await runTmux(["send-keys", "-t", target.target, "-l", text], { timeout: 8000, signal: config.abortSignal });
     if (!sent.ok) return { ok: false, toolName: "tmux_send_keys", target: target.target, error: sent.stderr || sent.error };
     steps.push("literal-text");
   }
   const keyArgs = [...keys];
   if (enter) keyArgs.push("Enter");
   if (keyArgs.length > 0) {
-    const sent = await runTmux(["send-keys", "-t", target.target, ...keyArgs], { timeout: 8000 });
+    const sent = await runTmux(["send-keys", "-t", target.target, ...keyArgs], { timeout: 8000, signal: config.abortSignal });
     if (!sent.ok) return { ok: false, toolName: "tmux_send_keys", target: target.target, error: sent.stderr || sent.error };
     steps.push(...keyArgs);
   }
@@ -395,7 +399,7 @@ export async function startTmuxSession(args = {}, config = {}) {
 
   const tmuxArgs = ["new-session", "-d", "-s", name.name, "-c", cwd.cwd];
   if (command) tmuxArgs.push(command);
-  const result = await runTmux(tmuxArgs, { timeout: 10000 });
+  const result = await runTmux(tmuxArgs, { timeout: 10000, signal: config.abortSignal });
   if (!result.ok) return { ok: false, toolName: "tmux_start_session", session: name.name, error: result.stderr || result.error };
   return {
     ok: true,

package/src/tool-wrappers.js

@@ -1,10 +1,7 @@
-import { execFile as execFileCallback, execFileSync } from "node:child_process";
-import { promisify } from "node:util";
+import { execFileSync, spawn } from "node:child_process";
 import { getModelPresets } from "./model-routing.js";
 import { redactSensitiveText } from "./redaction.js";
 
-const execFile = promisify(execFileCallback);
-
 export const WRAPPER_NAMES = ["codex", "claude", "gemini", "copilot", "qwen"];
 export const DEFAULT_WRAPPER_NAME = "codex";
 
@@ -31,6 +28,93 @@ function cleanOutput(value, limit) {
   return redactSensitiveText(value).trim().slice(0, limit);
 }
 
+function killChildTree(child, signal = "SIGTERM") {
+  if (!child || child.killed) return;
+  try {
+    if (process.platform === "win32") child.kill(signal);
+    else process.kill(-child.pid, signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+      // Process may already have exited.
+    }
+  }
+}
+
+function runWrapperProcess(spec, config) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(spec.command, spec.args, {
+      cwd: config.commandCwd,
+      env: process.env,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const timeoutMs = Number(config.wrapperTimeoutMs) || 120000;
+    const maxStdout = 512 * 1024;
+    const maxStderr = 128 * 1024;
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (config.abortSignal && onAbort) config.abortSignal.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const makeError = (message, code = 1) => {
+      const error = new Error(message);
+      error.code = code;
+      error.stdout = stdout;
+      error.stderr = stderr;
+      return error;
+    };
+    const onAbort = () => {
+      killChildTree(child, "SIGTERM");
+      setTimeout(() => killChildTree(child, "SIGKILL"), 1200).unref?.();
+      const error = makeError("Wrapper interrupted by user.", "ABORT_ERR");
+      error.name = "AbortError";
+      settle(() => reject(error));
+    };
+    const timer =
+      Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? setTimeout(() => {
+            timedOut = true;
+            killChildTree(child, "SIGTERM");
+            setTimeout(() => killChildTree(child, "SIGKILL"), 1200).unref?.();
+          }, timeoutMs)
+        : null;
+    timer?.unref?.();
+
+    if (config.abortSignal?.aborted) return onAbort();
+    if (config.abortSignal) config.abortSignal.addEventListener("abort", onAbort, { once: true });
+
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < maxStdout) stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < maxStderr) stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      settle(() => reject(makeError(error instanceof Error ? error.message : String(error), 1)));
+    });
+    child.on("close", (code, signal) => {
+      if (timedOut) {
+        settle(() => reject(makeError(`Wrapper timed out after ${timeoutMs}ms.`, 124)));
+        return;
+      }
+      if (Number(code || 0) === 0) {
+        settle(() => resolve({ stdout, stderr }));
+        return;
+      }
+      settle(() => reject(makeError(`Wrapper exited with ${signal || code}.`, Number.isInteger(code) ? code : 1)));
+    });
+  });
+}
+
 function buildPrompt(prompt) {
   return `${BASE_ADVISORY_PROMPT}\n\nTask:\n${prompt}`;
 }
@@ -157,13 +241,7 @@ export async function runAgentWrapper({ wrapper, prompt }, config) {
     return { ok: false, wrapper, error: `Wrapper command is not available: ${wrapper}` };
   }
 
-  const runOnce = async (spec) =>
-    execFile(spec.command, spec.args, {
-      cwd: config.commandCwd,
-      timeout: Number(config.wrapperTimeoutMs) || 120000,
-      maxBuffer: 512 * 1024,
-      env: process.env,
-    });
+  const runOnce = async (spec) => runWrapperProcess(spec, config);
 
   try {
     const result = await runOnce(commandSpec);
@@ -174,6 +252,7 @@ export async function runAgentWrapper({ wrapper, prompt }, config) {
       stderr: cleanOutput(result.stderr, 4000),
     };
   } catch (error) {
+    if (error?.name === "AbortError" || error?.code === "ABORT_ERR") throw error;
     if (wrapper === "codex") {
       const fallbackSpec = wrapperCommand(wrapper, prompt, config, { fallback: true });
       try {
@@ -186,6 +265,7 @@ export async function runAgentWrapper({ wrapper, prompt }, config) {
           stderr: cleanOutput(fallback.stderr, 4000),
         };
       } catch (fallbackError) {
+        if (fallbackError?.name === "AbortError" || fallbackError?.code === "ABORT_ERR") throw fallbackError;
         return {
           ok: false,
           wrapper,