nolo-cli 0.212.0-alpha.1 → 0.222.0-alpha.2

package/{chunk-JNKSDZFS.js → chunk-KEN3N2TN.js}

@@ -4,9 +4,6 @@ import {
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
-import {
-  resolveNoloStateDir
-} from "./chunk-6UBGXX2W.js";
 import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
@@ -16,6 +13,9 @@ import {
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
+import {
+  resolveNoloStateDir
+} from "./chunk-6UBGXX2W.js";
 
 // packages/agent-runtime/processTask.ts
 var PROCESS_TASK_TERMINAL_STATUSES = [
@@ -168,6 +168,7 @@ var ProcessRegistry = class {
   byTaskId = /* @__PURE__ */ new Map();
   eventLog;
   terminalListeners = /* @__PURE__ */ new Set();
+  backgroundListeners = /* @__PURE__ */ new Set();
   constructor(eventLogOptions) {
     this.eventLog = new ProcessTaskEventLog(eventLogOptions);
   }
@@ -190,6 +191,21 @@ var ProcessRegistry = class {
       this.terminalListeners.delete(listener);
     };
   }
+  /** Payload-free invalidation for the listBackground() view; no replay. */
+  onBackgroundChange(listener) {
+    this.backgroundListeners.add(listener);
+    return () => {
+      this.backgroundListeners.delete(listener);
+    };
+  }
+  emitBackgroundChange() {
+    for (const listener of [...this.backgroundListeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
   /** Emit a terminal notice synchronously; listener errors must not break registry callers. */
   emitTerminal(notice) {
     for (const listener of [...this.terminalListeners]) {
@@ -220,6 +236,7 @@ var ProcessRegistry = class {
     this.processes.set(proc.pid, record);
     this.byTaskId.set(record.taskId, proc.pid);
     this.eventLog.append({ taskId: record.taskId, pid: proc.pid, type: "started" });
+    if (!record.transient) this.emitBackgroundChange();
     return { ...record };
   }
   list() {
@@ -271,9 +288,11 @@ var ProcessRegistry = class {
     const item = this.processes.get(pid);
     if (!item) return void 0;
     if (!item.promoted) {
+      const wasTransient = item.transient;
       item.promoted = true;
       item.transient = false;
       this.eventLog.append({ taskId: item.taskId, pid, type: "promoted" });
+      if (wasTransient) this.emitBackgroundChange();
     }
     return { ...item };
   }
@@ -304,6 +323,8 @@ var ProcessRegistry = class {
         }
       }
       item.status = "stopped";
+      item.endedAt = Date.now();
+      if (!item.transient) this.emitBackgroundChange();
       this.eventLog.append({ taskId: item.taskId, pid, type: "killed" });
       this.emitTerminal({
         taskId: item.taskId,
@@ -334,6 +355,8 @@ var ProcessRegistry = class {
           }
         }
         item.status = "stopped";
+        item.endedAt = Date.now();
+        if (!item.transient) this.emitBackgroundChange();
         this.eventLog.append({ taskId: item.taskId, pid: item.pid, type: "killed" });
         this.emitTerminal({
           taskId: item.taskId,
@@ -352,6 +375,8 @@ var ProcessRegistry = class {
       item.exitCode = exitCode;
       if (resultCapsule) item.resultCapsule = resultCapsule;
       item.status = exitCode === 0 ? "exited" : "failed";
+      item.endedAt = Date.now();
+      if (!item.transient) this.emitBackgroundChange();
       this.eventLog.append({
         taskId: item.taskId,
         pid,
@@ -390,6 +415,7 @@ var ProcessRegistry = class {
     if (!item) return false;
     this.processes.delete(pid);
     this.byTaskId.delete(item.taskId);
+    if (!item.transient) this.emitBackgroundChange();
     return true;
   }
   clear() {
@@ -397,6 +423,7 @@ var ProcessRegistry = class {
     this.byTaskId.clear();
     this.eventLog.clear();
     this.terminalListeners.clear();
+    this.backgroundListeners.clear();
   }
 };
 var registry = null;
@@ -408,8 +435,9 @@ function getProcessRegistry() {
 }
 
 // packages/agent-runtime/workspaceShell.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { createWriteStream, mkdirSync as mkdirSync2, rmSync } from "node:fs";
-import { dirname, join as join3, resolve } from "node:path";
+import { dirname, join as join3, resolve as resolve2 } from "node:path";
 import { spawn as spawnChildProcess } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { tmpdir } from "node:os";
@@ -567,9 +595,9 @@ function spawnToWebStreams(options) {
     env: options.env,
     stdio: ["ignore", "pipe", "pipe"]
   });
-  const exited = new Promise((resolve2) => {
-    child.on("exit", (code) => resolve2(code ?? 1));
-    child.on("error", () => resolve2(127));
+  const exited = new Promise((resolve3) => {
+    child.on("exit", (code) => resolve3(code ?? 1));
+    child.on("error", () => resolve3(127));
   });
   const toWeb = (stream) => {
     if (!stream) return null;
@@ -664,6 +692,11 @@ function findWindowsPowerShellAlias(options = {}) {
   return null;
 }
 
+// packages/agent-runtime/processTaskResult.ts
+import { openSync, readSync, closeSync } from "node:fs";
+import { isAbsolute as isAbsolute2, resolve } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
 // packages/agent-runtime/toolSpillStore.ts
 import { createHash, randomUUID } from "node:crypto";
 import { constants, copyFileSync, createReadStream, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, renameSync, statSync as statSync3, unlinkSync, utimesSync, writeFileSync } from "node:fs";
@@ -695,11 +728,11 @@ function countLines(text) {
 var SPILL_PUBLICATION_GRACE_MS = 6e4;
 async function hashFileStreaming(path) {
   const hash = createHash("sha256");
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const stream = createReadStream(path);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
-    stream.on("end", () => resolve2());
+    stream.on("end", () => resolve3());
   });
   return hash.digest("hex");
 }
@@ -925,6 +958,41 @@ function formatToolOverflowMarker(args) {
 `;
 }
 
+// packages/agent-runtime/toolOutputSpillProjection.ts
+var TOOL_OUTPUT_SPILL_BYTES = 30 * 1024;
+var TOOL_OUTPUT_SPILL_LINES = 800;
+var HEAD_LINES = 30;
+var TAIL_LINES = 50;
+var PREVIEW_CHARS = 12 * 1024;
+var MARKER = /\[Omitted \d+ lines \([\d.]+ KB\)\. Full output saved to [^\n]+\]/;
+function isSpilledToolOutput(text) {
+  return MARKER.test(text) && text.length <= PREVIEW_CHARS * 2 + 2048;
+}
+function formatSpilledToolOutput(args) {
+  const headLines = args.head.split("\n").slice(0, HEAD_LINES);
+  const tailLines = args.tail.split("\n").slice(-TAIL_LINES);
+  const head = headLines.join("\n").slice(0, PREVIEW_CHARS);
+  const tail = tailLines.join("\n").slice(-PREVIEW_CHARS);
+  const omitted = Math.max(0, args.totalLines - headLines.length - tailLines.length);
+  return `${head}
+
+[Omitted ${omitted} lines (${(args.byteLength / 1024).toFixed(1)} KB). Full output saved to ${args.displayPath}]
+
+${tail}`;
+}
+function spillLargeToolOutput(content, toolName, workspaceRoot) {
+  if (isSpilledToolOutput(content)) return content;
+  const byteLength = Buffer.byteLength(content);
+  const totalLines = countLines(content);
+  if (byteLength <= TOOL_OUTPUT_SPILL_BYTES && totalLines <= TOOL_OUTPUT_SPILL_LINES) return content;
+  try {
+    const spill = spillToolOutput({ content, toolName, workspaceRoot });
+    return formatSpilledToolOutput({ head: content, tail: content, totalLines, byteLength, displayPath: spill.displayPath });
+  } catch {
+    return content;
+  }
+}
+
 // packages/agent-runtime/processTaskResult.ts
 var PROCESS_RESULT_CAPSULE_TAIL_CHARS = 4e3;
 var PROCESS_RESULT_CAPSULE_SPILL_THRESHOLD_CHARS = 2e4;
@@ -932,6 +1000,27 @@ function tailText(value, maxChars) {
   if (value.length <= maxChars) return { text: value, truncated: false };
   return { text: value.slice(-maxChars), truncated: true };
 }
+function reuseStreamSpill(text, workspaceRoot) {
+  const displayPath = /Full output saved to ([^\n]+?)\]/.exec(text)?.[1];
+  if (!displayPath) return void 0;
+  const path = isAbsolute2(displayPath) ? displayPath : workspaceRoot ? resolve(workspaceRoot, displayPath) : void 0;
+  if (!path) return void 0;
+  const fd = openSync(path, "r");
+  try {
+    const buffer = Buffer.alloc(64 * 1024);
+    const decoder = new StringDecoder("utf8");
+    let totalChars = 0, newlines = 0;
+    const count = (chunk) => {
+      totalChars += chunk.length;
+      for (let i = chunk.indexOf("\n"); i >= 0; i = chunk.indexOf("\n", i + 1)) newlines++;
+    };
+    for (let bytes; (bytes = readSync(fd, buffer, 0, buffer.length, null)) > 0; ) count(decoder.write(buffer.subarray(0, bytes)));
+    count(decoder.end());
+    return { displayPath, totalChars, totalLines: totalChars ? newlines + 1 : 0 };
+  } finally {
+    closeSync(fd);
+  }
+}
 function formatCapsuleStream(name, value) {
   return value.trim() ? `${name}:
 ${value.replace(/\n+$/, "")}` : "";
@@ -953,10 +1042,33 @@ function buildProcessTaskResultCapsule(args) {
   const stderrTail = tailText(stderrTailSource, tailChars);
   const inlineSize = stdout.length + stderr.length;
   const inlineTruncated = stdoutTail.truncated || stderrTail.truncated;
-  const truncated = inlineTruncated || ringEvicted || Boolean(captureError);
+  const truncated = inlineTruncated || ringEvicted || Boolean(captureError) || isSpilledToolOutput(stdout) || isSpilledToolOutput(stderr);
   const shouldSpill = truncated || inlineSize > spillThresholdChars;
   let spill;
-  if (shouldSpill) {
+  let streamSpills;
+  if (isSpilledToolOutput(stdout) || isSpilledToolOutput(stderr)) {
+    streamSpills = {};
+    for (const [name, text] of [["stdout", stdout], ["stderr", stderr]]) {
+      if (!text) continue;
+      try {
+        if (isSpilledToolOutput(text)) {
+          streamSpills[name] = reuseStreamSpill(text, args.workspaceRoot);
+        } else {
+          const result = spillToolOutput({ content: text, toolName: "execShell", workspaceRoot: args.workspaceRoot });
+          streamSpills[name] = { displayPath: result.displayPath, totalChars: result.totalChars, totalLines: result.totalLines };
+        }
+      } catch {
+      }
+    }
+    const primary = streamSpills.stdout ?? streamSpills.stderr;
+    if (primary) {
+      spill = {
+        displayPath: primary.displayPath,
+        totalChars: (streamSpills.stdout?.totalChars ?? 0) + (streamSpills.stderr?.totalChars ?? 0),
+        totalLines: (streamSpills.stdout?.totalLines ?? 0) + (streamSpills.stderr?.totalLines ?? 0)
+      };
+    }
+  } else if (shouldSpill) {
     try {
       const result = spillToolOutput({
         content: [
@@ -984,11 +1096,16 @@ function buildProcessTaskResultCapsule(args) {
     ...durationMs !== void 0 ? { durationMs } : {},
     ...captureError ? { captureError } : {},
     truncated,
-    ...spill ? { spill } : {}
+    ...spill ? { spill } : {},
+    ...streamSpills ? { streamSpills } : {}
   };
 }
 
 // packages/agent-runtime/workspaceShell.ts
+var shellChildEnvironment = new AsyncLocalStorage();
+function withShellChildEnvironment(env, run) {
+  return shellChildEnvironment.run(env, run);
+}
 var EXEC_SHELL_TIMEOUT_ENV = "NOLO_EXEC_SHELL_TIMEOUT_MS";
 var EXEC_SHELL_DETACH_ENV = "NOLO_EXEC_SHELL_DETACH_MS";
 var DEFAULT_EXEC_SHELL_DETACH_MS = 12e4;
@@ -1283,19 +1400,33 @@ function resolveDetachMs(override) {
   return parsed === void 0 ? DEFAULT_EXEC_SHELL_DETACH_MS : parsed;
 }
 function truncateToolOutput(value, limit = 2e4, options) {
+  if (isSpilledToolOutput(value)) return value;
   if (value.length <= limit) return value;
   let spillNote = "";
+  let spillPathOnly = "";
   try {
     const spill = spillToolOutput({
       content: value,
       toolName: options?.toolName ?? "execShell",
       workspaceRoot: options?.workspaceRoot
     });
-    spillNote = `; spillFile=${spill.displayPath}; totalLines=${spill.totalLines}`;
+    spillNote = `; spillFile=${spill.displayPath}; totalLines=${spill.totalLines}; hint=read a range, not the whole spill (readFile lines=A-B or sed -n 'A,Bp'); a full read re-injects ${spill.totalChars} chars`;
+    spillPathOnly = `; spillFile=${spill.displayPath}`;
   } catch {
   }
   const approxMarkerLen = 40 + spillNote.length;
-  if (limit <= approxMarkerLen) return value.slice(0, limit);
+  if (limit <= approxMarkerLen) {
+    const notice = `[... truncated ${value.length} chars]`;
+    const withFullNote = `[... truncated ${value.length} chars${spillNote} ...]`;
+    if (withFullNote.length <= limit) return withFullNote;
+    const withPath = `[... truncated ${value.length} chars${spillPathOnly} ...]`;
+    if (withPath.length <= limit) return withPath;
+    if (notice.length <= limit) {
+      const pathOmitted = " [... path omitted]";
+      return notice.length + pathOmitted.length <= limit ? notice + pathOmitted : notice;
+    }
+    return limit <= 0 ? "" : "\u2026";
+  }
   const remaining = limit - approxMarkerLen;
   const headSize = Math.floor(remaining * 0.3);
   const tailSize = remaining - headSize;
@@ -1315,7 +1446,7 @@ function removeSpillFile(path) {
   } catch {
   }
 }
-function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BYTES) {
+function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BYTES, capture) {
   if (!stream) return Promise.resolve("");
   const options = typeof maxBytesOrOptions === "number" ? { maxBytes: maxBytesOrOptions } : maxBytesOrOptions ?? {};
   const maxBytes = typeof options.maxBytes === "number" && Number.isFinite(options.maxBytes) && options.maxBytes >= 0 ? options.maxBytes : DEFAULT_MAX_STREAM_BUFFER_BYTES;
@@ -1325,7 +1456,17 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
   return new Promise((resolveStream, rejectStream) => {
     const chunks = [];
     let totalBytes = 0;
+    let observedBytes = 0;
+    let observedLines = 1;
+    let tail = Buffer.alloc(0);
     let settled = false;
+    let captureResolved = false;
+    const resolveCapture = (text) => {
+      if (captureResolved) return;
+      captureResolved = true;
+      capture?.stopSignal.removeEventListener("abort", stopCapture);
+      resolveStream(text);
+    };
     let truncated = false;
     let spillState = spillPath ? "idle" : "disabled";
     let spillError = null;
@@ -1334,6 +1475,7 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
     let spillSink = null;
     let sourcePausedForSpill = false;
     let sinkFinished = false;
+    let spillSettlement;
     const formatLimit = maxBytes >= 1024 * 1024 ? `${Math.round(maxBytes / (1024 * 1024))}MB` : `${Math.round(maxBytes / 1024)}KB`;
     const resumeSourceIfPaused = () => {
       if (!sourcePausedForSpill) return;
@@ -1344,7 +1486,7 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
       }
     };
     const markSpillFailed = (error) => {
-      if (spillState === "failed") return;
+      if (spillSettlement || spillState === "failed") return;
       spillState = "failed";
       if (!spillError) {
         spillError = toErrorMessage(error);
@@ -1411,26 +1553,30 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
       for (const head of headChunks) writeToSink(head);
       writeToSink(crossingChunk);
     };
-    const settleSpillRetention = async () => {
-      if (!spillPath || spillRetention === "keep") {
-        if (spillPath && spillRetention === "keep" && spillState === "ok") {
-          spillRetainedPath = spillPath;
-        }
-        return;
-      }
-      if (spillRetention === "promote" && spillState === "ok" && sourceEnded) {
-        const promoted = await promoteToolSpillFile(spillPath, {
-          workspaceRoot: options.spillWorkspaceRoot
-        });
-        if (promoted.ok) {
-          spillRetainedPath = promoted.displayPath;
+    const settleSpillRetention = () => {
+      if (spillSettlement) return spillSettlement;
+      spillSettlement = Promise.resolve().then(async () => {
+        if (!spillPath || spillRetention === "keep") {
+          if (spillPath && spillRetention === "keep" && spillState === "ok") {
+            spillRetainedPath = spillPath;
+          }
           return;
         }
-        if (promoted.preservedPath) {
-          return;
+        if (spillRetention === "promote" && spillState === "ok" && sourceEnded) {
+          const promoted = await (capture?.promoteSpill ?? promoteToolSpillFile)(spillPath, {
+            workspaceRoot: options.spillWorkspaceRoot
+          });
+          if (promoted.ok) {
+            spillRetainedPath = promoted.displayPath;
+            return;
+          }
+          if (promoted.preservedPath) {
+            return;
+          }
         }
-      }
-      removeSpillFile(spillPath);
+        removeSpillFile(spillPath);
+      });
+      return spillSettlement;
     };
     const finalize = (wasTruncated) => {
       if (settled) return;
@@ -1438,8 +1584,20 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
       const truncatedNow = wasTruncated || truncated;
       const baseText = Buffer.concat(chunks).toString("utf8");
       const done = async () => {
+        if (captureResolved) return;
         await settleSpillRetention();
+        if (captureResolved) return;
         let text = baseText;
+        if (truncatedNow && spillRetainedPath && sourceEnded && options.maxLines !== void 0) {
+          resolveCapture(formatSpilledToolOutput({
+            head: baseText,
+            tail: tail.toString("utf8"),
+            totalLines: observedLines,
+            byteLength: observedBytes,
+            displayPath: spillRetainedPath
+          }));
+          return;
+        }
         if (truncatedNow) {
           const notes = [`output exceeded ${formatLimit} buffer limit`];
           if (spillRetainedPath && sourceEnded) {
@@ -1453,7 +1611,8 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
 
 [stream pipe truncated: ${notes.join("; ")}]`;
         }
-        resolveStream(text);
+        chunks.length = 0;
+        resolveCapture(text);
       };
       const sink = spillSink;
       if (!sink || spillState !== "open") {
@@ -1486,14 +1645,36 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
         settleSink(true, error);
       }
     };
+    const stopCapture = () => {
+      if (captureResolved) return;
+      settled = true;
+      const reason = "capture incomplete: post-exit drain grace exceeded";
+      const snapshot = Buffer.concat(chunks).toString("utf8");
+      chunks.length = 0;
+      capture?.onIncomplete(reason);
+      if (!spillSettlement) {
+        markSpillFailed(new Error(reason));
+        void settleSpillRetention();
+      }
+      resolveCapture(`${snapshot}
+
+[${reason}]`);
+    };
+    capture?.stopSignal.addEventListener("abort", stopCapture, { once: true });
+    if (capture?.stopSignal.aborted) stopCapture();
     stream.on("data", (chunk) => {
       if (settled) return;
       const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      observedBytes += buf.length;
+      for (const byte of buf) if (byte === 10) observedLines++;
+      if (options.maxLines !== void 0) {
+        tail = Buffer.concat([tail, buf.subarray(Math.max(0, buf.length - maxBytes))]).subarray(-maxBytes);
+      }
       if (truncated) {
         writeToSink(buf);
         return;
       }
-      if (totalBytes + buf.length >= maxBytes) {
+      if (totalBytes + buf.length >= maxBytes || observedLines > (options.maxLines ?? Infinity)) {
         const remaining = Math.max(0, maxBytes - totalBytes);
         const headChunks = chunks.slice();
         if (remaining > 0) {
@@ -1524,6 +1705,9 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
       }
       resumeSourceIfPaused();
       void settleSpillRetention();
+      captureResolved = true;
+      capture?.stopSignal.removeEventListener("abort", stopCapture);
+      chunks.length = 0;
       rejectStream(error);
     });
     stream.on("end", () => {
@@ -1533,14 +1717,6 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
     stream.on("close", () => finalize(false));
   });
 }
-function waitForNodeProcessExit(proc) {
-  return new Promise((resolveExit, rejectExit) => {
-    proc.on("error", rejectExit);
-    proc.on("close", (code) => {
-      resolveExit(code ?? 0);
-    });
-  });
-}
 function deriveLabel(command) {
   const trimmed = command.trim();
   if (!trimmed) return "process";
@@ -1588,8 +1764,10 @@ async function runWorkspaceCommand(args) {
     ...args.commandPrefix ?? [],
     ...args.command
   ];
+  const spawnedAt = Date.now();
   const proc = spawnChildProcess(command[0] ?? "", command.slice(1), {
-    cwd: resolve(args.workspaceRoot),
+    cwd: resolve2(args.workspaceRoot),
+    env: { ...process.env, ...shellChildEnvironment.getStore() },
     stdio: [
       args.stdin === void 0 ? "ignore" : "pipe",
       "pipe",
@@ -1621,7 +1799,10 @@ async function runWorkspaceCommand(args) {
       owner: args.owner ?? null
     });
   }
-  const exitPromise = waitForNodeProcessExit(proc);
+  const processExitPromise = new Promise((resolveExit, rejectExit) => {
+    proc.once("exit", (code) => resolveExit(code ?? 0));
+    proc.once("error", rejectExit);
+  });
   const cleanupChildOnHostSignal = (signal) => {
     if (typeof proc.pid === "number") {
       try {
@@ -1641,21 +1822,54 @@ async function runWorkspaceCommand(args) {
     process.removeListener("SIGTERM", cleanupChildOnHostSignal);
     process.removeListener("SIGINT", cleanupChildOnHostSignal);
   };
-  exitPromise.then(detachSignalCleanup, detachSignalCleanup);
+  const captureCutoff = new AbortController();
+  let stdoutIncomplete;
+  let stderrIncomplete;
   const stdoutCapture = stdoutPromiseResult(
     readNodeStream(proc.stdout, {
+      maxBytes: TOOL_OUTPUT_SPILL_BYTES,
+      maxLines: TOOL_OUTPUT_SPILL_LINES,
       spillPath: join3(tmpdir(), `nolo-stream-${randomUUID2()}.log`),
       spillRetention: "promote",
       spillWorkspaceRoot: args.workspaceRoot
+    }, {
+      stopSignal: captureCutoff.signal,
+      onIncomplete: (reason) => {
+        stdoutIncomplete = reason;
+      }
     })
-  );
+  ).then((result) => ({ ...result, error: result.error || stdoutIncomplete }));
   const stderrCapture = stdoutPromiseResult(
     readNodeStream(proc.stderr, {
+      maxBytes: TOOL_OUTPUT_SPILL_BYTES,
+      maxLines: TOOL_OUTPUT_SPILL_LINES,
       spillPath: join3(tmpdir(), `nolo-stream-${randomUUID2()}-stderr.log`),
       spillRetention: "promote",
       spillWorkspaceRoot: args.workspaceRoot
+    }, {
+      stopSignal: captureCutoff.signal,
+      onIncomplete: (reason) => {
+        stderrIncomplete = reason;
+      }
     })
-  );
+  ).then((result) => ({ ...result, error: result.error || stderrIncomplete }));
+  const exitPromise = processExitPromise.then(async (code) => {
+    const drainTimer = setTimeout(() => captureCutoff.abort(), 2e3);
+    try {
+      await Promise.all([stdoutCapture, stderrCapture]);
+      return code;
+    } finally {
+      clearTimeout(drainTimer);
+    }
+  });
+  let processExited = false;
+  let terminationReason;
+  let timeout;
+  let forceKillTimer;
+  const cleanupTerminationTimers = () => {
+    if (timeout) clearTimeout(timeout);
+    if (forceKillTimer) clearTimeout(forceKillTimer);
+  };
   const killChild = (signal) => {
     if (detached && typeof proc.pid === "number") {
       try {
@@ -1669,7 +1883,22 @@ async function runWorkspaceCommand(args) {
     } catch {
     }
   };
-  let timeout;
+  const onProcessExit = () => {
+    processExited = true;
+    cleanupTerminationTimers();
+    detachSignalCleanup();
+  };
+  proc.once("exit", onProcessExit);
+  proc.once("error", onProcessExit);
+  const terminate = (reason) => {
+    if (processExited || terminationReason) return;
+    terminationReason = reason;
+    if (timeout) clearTimeout(timeout);
+    killChild("SIGTERM");
+    forceKillTimer = setTimeout(() => {
+      if (!processExited) killChild("SIGKILL");
+    }, 500);
+  };
   let detachTimer;
   const timeoutResult = Symbol("timeout");
   const abortResult = Symbol("abort");
@@ -1680,7 +1909,10 @@ async function runWorkspaceCommand(args) {
       resolveAbort(abortResult);
       return;
     }
-    abortListener = () => resolveAbort(abortResult);
+    abortListener = () => {
+      terminate("abort");
+      resolveAbort(abortResult);
+    };
     args.abortSignal.addEventListener("abort", abortListener, { once: true });
   }) : null;
   const effectiveDetachMs = resolveDetachMs(args.detachMs);
@@ -1690,7 +1922,12 @@ async function runWorkspaceCommand(args) {
   const exitOrTimeoutPromise = timeoutMs ? Promise.race([
     exitPromise,
     new Promise((resolveTimeout) => {
-      timeout = setTimeout(() => resolveTimeout(timeoutResult), timeoutMs);
+      timeout = setTimeout(() => {
+        if (processExited) return;
+        const aborted2 = args.abortSignal?.aborted === true;
+        terminate(aborted2 ? "abort" : "timeout");
+        resolveTimeout(aborted2 ? abortResult : timeoutResult);
+      }, Math.max(0, timeoutMs - (Date.now() - spawnedAt)));
     })
   ]) : exitPromise;
   const raceCandidates = [
@@ -1704,7 +1941,7 @@ async function runWorkspaceCommand(args) {
   try {
     raceWinner = await Promise.race(raceCandidates);
   } catch (error) {
-    if (timeout) clearTimeout(timeout);
+    cleanupTerminationTimers();
     if (detachTimer) clearTimeout(detachTimer);
     if (abortListener && args.abortSignal) {
       args.abortSignal.removeEventListener("abort", abortListener);
@@ -1717,24 +1954,20 @@ async function runWorkspaceCommand(args) {
     }
     throw error;
   }
-  if (timeout) clearTimeout(timeout);
   if (detachTimer) clearTimeout(detachTimer);
   if (abortListener && args.abortSignal) {
     args.abortSignal.removeEventListener("abort", abortListener);
   }
-  const timedOut = raceWinner === timeoutResult;
-  const aborted = raceWinner === abortResult;
+  const aborted = raceWinner === abortResult || raceWinner === timeoutResult && args.abortSignal?.aborted === true;
+  const timedOut = raceWinner === timeoutResult && !aborted;
   const detachedProcess = raceWinner === detachResult;
   if (timedOut || aborted) {
-    killChild("SIGTERM");
-    const forceKillTimer = setTimeout(() => {
-      killChild("SIGKILL");
-    }, 500);
+    terminate(aborted ? "abort" : "timeout");
     try {
       await exitPromise;
     } catch {
     } finally {
-      clearTimeout(forceKillTimer);
+      cleanupTerminationTimers();
     }
   }
   if (detachedProcess) {
@@ -1752,9 +1985,9 @@ async function runWorkspaceCommand(args) {
       owner: args.owner ?? null
     });
     const taskId = envelope.taskId;
-    proc.on("close", (code) => {
+    void exitPromise.then(() => {
       detachSignalCleanup();
-      const exitCode2 = code ?? 1;
+      const exitCode2 = terminationReason === "abort" ? 130 : terminationReason === "timeout" ? 124 : proc.exitCode ?? 1;
       void (async () => {
         const [stdoutResult, stderrResult] = await Promise.all([
           stdoutCapture,
@@ -1763,10 +1996,15 @@ async function runWorkspaceCommand(args) {
         const stdout2 = stdoutResult.value;
         const stderr2 = stderrResult.value;
         let capsule;
+        const terminalStderr = terminationReason === "abort" ? `${stderr2.trim() ? `${stderr2.trim()}
+` : ""}command aborted by signal
+` : terminationReason === "timeout" ? `${stderr2.trim() ? `${stderr2.trim()}
+` : ""}command timed out after ${timeoutMs}ms
+` : stderr2;
         try {
           capsule = buildProcessTaskResultCapsule({
             stdout: stdout2,
-            stderr: stderr2,
+            stderr: terminalStderr,
             exitCode: exitCode2,
             // Duration is measured from the registry envelope's startedAt
             // (spawn moment), not from the detach moment.
@@ -1778,6 +2016,7 @@ async function runWorkspaceCommand(args) {
         }
         registry2.markExited(pid, exitCode2, capsule);
       })();
+    }, () => {
     });
     const immediate = effectiveDetachMs === 0;
     const reason = immediate ? `command looks long-running; moved to background immediately (pid=${pid}, label=${label})` : `command detached to background after ${effectiveDetachMs}ms (pid=${pid}, label=${label})`;
@@ -1806,8 +2045,10 @@ Use listProcesses to inspect or stop it.`,
     stderrCapture
   ]);
   const stdout = stdoutCaptureResult.value;
-  const rawStderr = stderrCaptureResult.value;
   const streamCaptureError = [stdoutCaptureResult.error, stderrCaptureResult.error].filter(Boolean).join("; ");
+  const rawStderr = streamCaptureError ? `${stderrCaptureResult.value}
+[${streamCaptureError}]
+` : stderrCaptureResult.value;
   const exitCode = aborted ? 130 : timedOut ? 124 : Number(raceWinner);
   if (typeof proc.pid === "number") {
     registry2.completeTransient(proc.pid, exitCode);
@@ -1841,8 +2082,6 @@ ${stderr.trim()}` : "",
 }
 
 export {
-  spillToolOutput,
-  formatToolOverflowMarker,
   resolveExecutableOnPath,
   createGlob,
   spawnToWebStreams,
@@ -1850,7 +2089,12 @@ export {
   reportedTaskStatus,
   toProcessTaskView,
   getProcessRegistry,
+  spillToolOutput,
+  formatToolOverflowMarker,
+  isSpilledToolOutput,
+  spillLargeToolOutput,
   buildProcessTaskResultCapsule,
+  withShellChildEnvironment,
   extractActivity,
   findPowerShellExecutable,
   buildWorkspaceShellPlan,