@lazyingart/agintiflow 0.20.119 → 0.20.121

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.119",
+  "version": "0.20.121",
   "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

@@ -568,6 +568,18 @@ try {
   assert(failedOutsidePathAdvice?.failureKind === "workspace-path", "outside host path failure advice was not generated");
   assert(failedOutsidePathAdvice.suggestedCommand.includes("--sandbox-mode host"), "outside path advice did not suggest host mode");
   assert(!failedOutsidePathAdvice.suggestedCommand.includes("aginti run --sandbox host"), "outside path advice used legacy sandbox syntax");
+  const missingReadonlyHostPathAdvice = buildFailedCommandAdvice({
+    args: { command: "ls /home/lachlan/ProjectsLFS/ProteinStructure" },
+    commandPolicy: evaluateCommandPolicy("ls /home/lachlan/ProjectsLFS/ProteinStructure", dockerWorkspacePolicy),
+    commandResult: {
+      ok: false,
+      stdout: "",
+      stderr: "ls: cannot access '/home/lachlan/ProjectsLFS/ProteinStructure': No such file or directory",
+    },
+    config: dockerWorkspacePolicy,
+    state: { sessionId: "coding-readonly-missing-host-path-smoke" },
+  });
+  assert(missingReadonlyHostPathAdvice === null, "missing read-only host path should not trigger danger-mode permission advice");
   assert(
     shouldRunParallelScouts(
       {

package/src/agent-runner.js

@@ -1661,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":
@@ -1749,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);

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/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;
 
@@ -1173,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 = "") {
@@ -1307,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") {
@@ -1679,19 +1768,13 @@ class LiveRunInput {
   handleKey(str = "", key = {}) {
     if (key.ctrl && key.name === "c") {
       this.setStatus("stopping · ctrl-c");
-      this.controller.abort(createAbortError("Interrupted by 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.setStatus("stopping · escape");
-      this.controller.abort(createAbortError("Interrupted by escape."));
+      if (action === "abort") requestActiveRunStop({ source: "escape", exitSession: false });
       return;
     }
     if (key.meta && key.name === "up") {
@@ -2003,7 +2086,7 @@ function attachRunInterrupts(controller) {
     if (controller.signal.aborted) return;
     const reason = isEscape ? "escape" : "ctrl-c";
     printSystemLine(`status=stopping reason=${reason}`);
-    controller.abort(createAbortError(`Interrupted by ${reason}.`));
+    requestActiveRunStop({ source: reason, exitSession: isCtrlC });
   };
   input.on("keypress", handler);
   return () => {
@@ -3599,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) {
@@ -3685,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;
@@ -3697,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,
@@ -3712,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
@@ -3738,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;
         }
@@ -3767,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;
         }
@@ -3774,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/permission-advice.js

@@ -249,7 +249,7 @@ export function looksLikeDockerWorkspacePathFailure(result = {}, config = {}) {
 }
 
 export function buildFailedCommandAdvice({ args = {}, commandPolicy = {}, commandResult = {}, config = {}, state = {} } = {}) {
-  if (looksLikeDockerWorkspacePathFailure(commandResult, config)) {
+  if (looksLikeDockerWorkspacePathFailure(commandResult, config) && commandPolicy.category !== "read-only") {
     return {
       ...adviceForCategory("workspace-path", {
         toolName: "run_command",

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,