@sema-agent/core 1.433.0 → 1.435.0

package/dist/core/task-registry.js

@@ -7,6 +7,7 @@ import { summarizeWorkflowRun } from "./workflow-run-store.js";
 import { canAccessAgentRecord, BackgroundAgentStoreError, } from "./background-agent-store.js";
 import { delimitUntrusted } from "./untrusted-text.js";
 import { boundedRedactedSummary } from "./untrusted-egress.js";
+import { clipWithFilePointer } from "./tool-errors.js";
 const defaultMonitorTimers = {
     setInterval: (fn, ms) => {
         const h = setInterval(() => void fn(), ms);
@@ -52,8 +53,6 @@ const TASK_OUTPUT_DEFAULT_CHARS = 32_000;
 const TASK_OUTPUT_MAX_CHARS = 160_000;
 const TASK_OUTPUT_ALIASES = ["BashOutput", "AgentOutputTool", "BashOutputTool", "AgentOutput", "WorkflowStatus"];
 const TASK_STOP_ALIASES = ["KillShell", "KillBash"];
-const isHighSurrogate = (c) => c >= 0xd800 && c <= 0xdbff;
-const isLowSurrogate = (c) => c >= 0xdc00 && c <= 0xdfff;
 const TASK_OUTPUT_MIN_CHARS = 512;
 function taskMaxOutputChars() {
     const raw = process.env.TASK_MAX_OUTPUT_LENGTH;
@@ -67,24 +66,7 @@ function taskMaxOutputChars() {
     return Math.min(Math.max(n, TASK_OUTPUT_MIN_CHARS), TASK_OUTPUT_MAX_CHARS);
 }
 export function clipTaskOutput(s, fullOutputPath) {
-    const limit = taskMaxOutputChars();
-    if (s.length <= limit)
-        return s;
-    if (fullOutputPath !== undefined) {
-        const header = `[Truncated. Full output: ${fullOutputPath}]\n\n`;
-        const room = limit - header.length;
-        return room > 0 ? header + s.slice(-room) : header.trimEnd().slice(0, Math.min(limit, s.length));
-    }
-    const omittedCount = (kept) => s.length - kept;
-    const markerFor = (kept) => `\n…[${s.length} chars total, ${omittedCount(kept)} omitted from the middle]…\n`;
-    const budget = limit - markerFor(0).length;
-    if (budget < 2)
-        return s.slice(0, limit);
-    const half = Math.floor(budget / 2);
-    const headEnd = half > 0 && isHighSurrogate(s.charCodeAt(half - 1)) ? half - 1 : half;
-    const tailStart = half > 0 && isLowSurrogate(s.charCodeAt(s.length - half)) ? s.length - half + 1 : s.length - half;
-    const kept = headEnd + (s.length - tailStart);
-    return `${s.slice(0, headEnd)}${markerFor(kept)}${s.slice(tailStart)}`;
+    return clipWithFilePointer(s, taskMaxOutputChars(), fullOutputPath);
 }
 function firstString(...values) {
     for (const value of values) {

package/dist/core/tool-errors.d.ts

@@ -1,5 +1,6 @@
 import type { TSchema } from "typebox";
 export declare function truncateError(s: string): string;
+export declare function clipWithFilePointer(s: string, limit: number, fullOutputPath?: string): string;
 export declare function formatToolError(error: unknown): string;
 export type WorkerErrorClass = "budget" | "limit" | "output" | "suspend" | "review" | "unexpected" | "oracle" | "resume" | "config" | "conflict" | "brain" | "aborted" | "unknown";
 export declare function errorClassOf(errorCode: string | undefined): WorkerErrorClass;

package/dist/core/tool-errors.js

@@ -7,6 +7,27 @@ export function truncateError(s) {
     const removed = s.length - MAX_ERROR_CHARS;
     return `${s.slice(0, HALF)}\n\n... [${removed} characters truncated] ...\n\n${s.slice(s.length - HALF)}`;
 }
+const isHighSurrogate = (c) => c >= 0xd800 && c <= 0xdbff;
+const isLowSurrogate = (c) => c >= 0xdc00 && c <= 0xdfff;
+export function clipWithFilePointer(s, limit, fullOutputPath) {
+    if (s.length <= limit)
+        return s;
+    if (fullOutputPath !== undefined) {
+        const header = `[Truncated. Full output: ${fullOutputPath}]\n\n`;
+        const room = limit - header.length;
+        return room > 0 ? header + s.slice(-room) : header.trimEnd().slice(0, Math.min(limit, s.length));
+    }
+    const omittedCount = (kept) => s.length - kept;
+    const markerFor = (kept) => `\n…[${s.length} chars total, ${omittedCount(kept)} omitted from the middle]…\n`;
+    const budget = limit - markerFor(0).length;
+    if (budget < 2)
+        return s.slice(0, limit);
+    const half = Math.floor(budget / 2);
+    const headEnd = half > 0 && isHighSurrogate(s.charCodeAt(half - 1)) ? half - 1 : half;
+    const tailStart = half > 0 && isLowSurrogate(s.charCodeAt(s.length - half)) ? s.length - half + 1 : s.length - half;
+    const kept = headEnd + (s.length - tailStart);
+    return `${s.slice(0, headEnd)}${markerFor(kept)}${s.slice(tailStart)}`;
+}
 function isShellLike(e) {
     return typeof e === "object" && e !== null && ("exitCode" in e || "stderr" in e || "stdout" in e);
 }

package/dist/engine/execution-env/kill-tree.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 const DEFAULT_GRACE_MS = 3000;
@@ -25,8 +25,18 @@ export function killProcessTree(pid, opts) {
         return;
     }
     const graceMs = normalizeGraceMs(opts?.graceMs);
-    signalProcessTreeUnix(pid, "SIGTERM", useGroupKill);
+    const termDescendants = signalProcessTreeUnix(pid, "SIGTERM", useGroupKill);
     setTimeout(() => {
+        const rediscovered = enumerateDescendantsSync(pid);
+        const verifiedCarriedForward = new Map();
+        for (const [p, originalEtime] of termDescendants) {
+            const currentEtime = rediscovered.etimeOf.get(p);
+            if (currentEtime !== undefined && verifyStillSameProcess(originalEtime, currentEtime)) {
+                verifiedCarriedForward.set(p, currentEtime);
+            }
+        }
+        const knownDescendants = new Map([...verifiedCarriedForward, ...rediscovered.descendants]);
+        killEach(knownDescendants.keys(), "SIGKILL");
         if (escalationCancelled(opts?.stillRunning)) {
             if (useGroupKill && isProcessAlive(-pid)) {
                 try {
@@ -43,7 +53,19 @@ export function killProcessTree(pid, opts) {
         if (!stillAlive) {
             return;
         }
-        signalProcessTreeUnix(pid, "SIGKILL", useGroupKill);
+        if (useGroupKill) {
+            try {
+                process.kill(-pid, "SIGKILL");
+                return;
+            }
+            catch {
+            }
+        }
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+        }
     }, graceMs).unref();
 }
 function escalationCancelled(stillRunning) {
@@ -82,19 +104,107 @@ function isProcessAlive(pid) {
     }
 }
 function signalProcessTreeUnix(pid, signal, useGroupKill) {
+    const descendants = enumerateDescendantsSync(pid).descendants;
     if (useGroupKill) {
         try {
             process.kill(-pid, signal);
-            return;
         }
         catch {
+            try {
+                process.kill(pid, signal);
+            }
+            catch {
+            }
         }
+        killEach(descendants.keys(), signal);
+        return descendants;
     }
     try {
         process.kill(pid, signal);
     }
     catch {
     }
+    killEach(descendants.keys(), signal);
+    return descendants;
+}
+function killEach(pids, signal) {
+    for (const pid of pids) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+        }
+    }
+}
+const PS_ENUMERATION_TIMEOUT_MS = 500;
+const EMPTY_SNAPSHOT = { descendants: new Map(), etimeOf: new Map() };
+function enumerateDescendantsSync(rootPid) {
+    if (process.platform === "win32")
+        return EMPTY_SNAPSHOT;
+    let out;
+    try {
+        const result = spawnSync("ps", ["-A", "-o", "pid=", "-o", "ppid=", "-o", "etime="], {
+            timeout: PS_ENUMERATION_TIMEOUT_MS,
+            encoding: "utf8",
+            windowsHide: true,
+        });
+        if (result.error || typeof result.stdout !== "string")
+            return EMPTY_SNAPSHOT;
+        out = result.stdout;
+    }
+    catch {
+        return EMPTY_SNAPSHOT;
+    }
+    const childrenOf = new Map();
+    const etimeOf = new Map();
+    for (const line of out.split("\n")) {
+        const m = /^\s*(\d+)\s+(\d+)\s+(\S+)\s*$/.exec(line);
+        if (!m)
+            continue;
+        const p = Number(m[1]);
+        const pp = Number(m[2]);
+        etimeOf.set(p, m[3]);
+        const list = childrenOf.get(pp);
+        if (list)
+            list.push(p);
+        else
+            childrenOf.set(pp, [p]);
+    }
+    const seen = new Set();
+    const queue = [rootPid];
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        for (const kid of childrenOf.get(cur) ?? []) {
+            if (kid <= 1 || kid === rootPid || seen.has(kid))
+                continue;
+            seen.add(kid);
+            queue.push(kid);
+        }
+    }
+    const descendants = new Map();
+    for (const p of seen) {
+        const et = etimeOf.get(p);
+        if (et !== undefined)
+            descendants.set(p, et);
+    }
+    return { descendants, etimeOf };
+}
+function verifyStillSameProcess(originalEtime, currentEtime) {
+    const orig = parseEtimeSeconds(originalEtime);
+    const cur = parseEtimeSeconds(currentEtime);
+    if (orig === undefined || cur === undefined)
+        return false;
+    return cur >= orig;
+}
+function parseEtimeSeconds(etime) {
+    const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(etime.trim());
+    if (!m)
+        return undefined;
+    const days = m[1] !== undefined ? Number(m[1]) : 0;
+    const hours = m[2] !== undefined ? Number(m[2]) : 0;
+    const minutes = Number(m[3]);
+    const seconds = Number(m[4]);
+    return days * 86400 + hours * 3600 + minutes * 60 + seconds;
 }
 function runTaskkill(args) {
     try {

package/dist/tools/fs/index.js

@@ -4,9 +4,10 @@ import { defineTool } from "../../core/tools.js";
 import { createTaskOutputTool, createTaskStopTool, defaultTaskRegistry } from "../../core/task-registry.js";
 import { hasBackgroundShell } from "../../core/background-shell.js";
 import { delimitUntrusted } from "../../core/untrusted-text.js";
+import { clipWithFilePointer } from "../../core/tool-errors.js";
 import { sha256, resolveKey, violationText, requireRead, checkStale, checkEditMatch, checkNoChange, hasBinaryExtension, isBinaryContent, fileArgPath, imageMimeForRead, imageMagicMatches, similarNameSuggestion, resolveQuoteMatch, adaptNewStringQuotes, deletionOldString, countOccurrences, OVERSIZE_READ_ESCAPE_HINT, isBlockedDevicePath, normalizeAbsPathLexically, } from "./safety.js";
 import { decodeTextBytes, encodeTextForFile, normalizeEditText } from "./encoding.js";
-import { runGrepDetailed, runGlobDetailed, splitAbsoluteGlobPattern } from "./search.js";
+import { runGrepDetailed, runGlobDetailed, splitAbsoluteGlobPattern, shellQuote } from "./search.js";
 import { makeRepoMapTool } from "./repo-map.js";
 import { ghRateLimitHint } from "./gh-rate-limit.js";
 import { MCP_IMAGE_MAX_BASE64, IMAGE_TARGET_RAW_SIZE, sharpImageDownsampler } from "../../core/mcp.js";
@@ -61,12 +62,23 @@ const FILE_PATH_PARAMS = {
     path: Type.Optional(Type.String({ description: "Deprecated alias for `file_path` (back-compat; prefer file_path)." })),
 };
 function clipShellOutput(s) {
-    const max = bashMaxOutputChars();
-    if (s.length <= max)
-        return s;
-    const half = Math.floor(max / 2);
-    const omitted = s.length - 2 * half;
-    return `${s.slice(0, half)}\n…[${s.length} chars total, ${omitted} omitted from the middle]…\n${s.slice(s.length - half)}`;
+    return clipWithFilePointer(s, bashMaxOutputChars());
+}
+async function writeShellOverflowFile(env, stdout, stderr) {
+    const tf = await env.createTempFile({ prefix: "bash-output-", suffix: ".log" });
+    if (!tf.ok)
+        return undefined;
+    const body = stderr.length > 0 ? `${stdout}${stdout.length > 0 && !stdout.endsWith("\n") ? "\n" : ""}--- stderr ---\n${stderr}` : stdout;
+    const w = await env.writeFile(tf.value, body);
+    if (!w.ok)
+        return undefined;
+    const canon = await env.canonicalPath(tf.value);
+    return canon.ok ? canon.value : tf.value;
+}
+function shellRecoveryHint(path, readOnly) {
+    const quoted = shellQuote(path);
+    const example = readOnly ? `tail -c 50000 ${quoted}` : `sed -n 'START,ENDp' ${quoted}`;
+    return `\n(captured output preserved at ${path} — inspect with bash, e.g. \`${example}\`)`;
 }
 const FILE_STATE_TRAILER = " (file state is current in your context — no need to Read it back)";
 const CWD_SENTINEL = "__cc_cwd_9f2c1b__";
@@ -1446,7 +1458,7 @@ export function canAutoBackground(command) {
         return false;
     return true;
 }
-async function runShell(env, cwd, toolName, command, timeoutSec, signal, cwdRef, detach, execClamp, toolCallId) {
+async function runShell(env, cwd, toolName, command, timeoutSec, signal, cwdRef, detach, execClamp, toolCallId, readOnly) {
     let timeout = Math.min(BASH_MAX_TIMEOUT_SEC, Math.max(1, Math.floor(timeoutSec ?? BASH_DEFAULT_TIMEOUT_SEC)));
     const requestedSec = timeout;
     let clampedByDeadline = false;
@@ -1509,9 +1521,13 @@ async function runShell(env, cwd, toolName, command, timeoutSec, signal, cwdRef,
             return `Error (${toolName}): connection to the execution environment was lost — the command's outcome is unknown and it may still be running. Verify its effects before retrying; retry only if the command is idempotent. (${res.error.message})`;
         }
         if (res.error.code === "timeout" || res.error.code === "aborted" || res.error.code === "callback_error") {
-            const clip = clipShellOutput;
-            const pStdout = clip(res.error.partialStdout ?? "");
-            const pStderr = clip(res.error.partialStderr ?? "");
+            const rawStdout = res.error.partialStdout ?? "";
+            const rawStderr = res.error.partialStderr ?? "";
+            const cutOverflowFile = rawStdout.length > bashMaxOutputChars() || rawStderr.length > bashMaxOutputChars()
+                ? await writeShellOverflowFile(env, rawStdout, rawStderr)
+                : undefined;
+            const pStdout = clipShellOutput(rawStdout);
+            const pStderr = clipShellOutput(rawStderr);
             const headline = res.error.code === "timeout"
                 ? clampedByDeadline
                     ? deadlineExhausted
@@ -1526,13 +1542,15 @@ async function runShell(env, cwd, toolName, command, timeoutSec, signal, cwdRef,
             const body = captured.length > 0
                 ? `\n${delimitUntrusted("partial command output", captured)}`
                 : `\n(no output was produced before the cutoff)`;
+            const overflowNote = cutOverflowFile !== undefined ? shellRecoveryHint(cutOverflowFile, readOnly) : "";
             return {
-                content: `Error (${toolName}): ${headline}${body}`,
+                content: `Error (${toolName}): ${headline}${body}${overflowNote}`,
                 details: {
                     type: "bash",
                     stdout: pStdout,
                     stderr: pStderr,
                     exitCode: null,
+                    ...(cutOverflowFile !== undefined ? { output_file: cutOverflowFile } : {}),
                     ...(res.error.code === "timeout"
                         ? {
                             timedOut: true,
@@ -1567,26 +1585,38 @@ async function runShell(env, cwd, toolName, command, timeoutSec, signal, cwdRef,
                 cwdRef.current = captured;
         }
     }
-    const clip = clipShellOutput;
-    const clippedStdout = clip(stdout);
-    const clippedStderr = clip(stderr);
+    const clippedStdout = clipShellOutput(stdout);
+    const clippedStderr = clipShellOutput(stderr);
     const stdoutImage = dataUriImageFromStdout(stdout);
     if (stdoutImage) {
+        const imgOverflowFile = stderr.length > bashMaxOutputChars() ? await writeShellOverflowFile(env, "", stderr) : undefined;
+        const imgOverflowNote = imgOverflowFile !== undefined ? shellRecoveryHint(imgOverflowFile, readOnly) : "";
         return {
             content: [
                 { type: "image", data: stdoutImage.data, mimeType: stdoutImage.mime },
-                { type: "text", text: `exit code: ${exitCode}\n[Image data detected in stdout and shown above]${stderr.trim() !== "" ? `\n--- stderr ---\n${clippedStderr}` : ""}` },
+                { type: "text", text: `exit code: ${exitCode}\n[Image data detected in stdout and shown above]${stderr.trim() !== "" ? `\n--- stderr ---\n${clippedStderr}` : ""}${imgOverflowNote}` },
             ],
-            details: { type: "bash", stdout: "[image data]", stderr: clippedStderr, exitCode, isImage: true },
+            details: { type: "bash", stdout: "[image data]", stderr: clippedStderr, exitCode, isImage: true, ...(imgOverflowFile !== undefined ? { output_file: imgOverflowFile } : {}) },
         };
     }
+    const cleanOverflowFile = stdout.length > bashMaxOutputChars() || stderr.length > bashMaxOutputChars() ? await writeShellOverflowFile(env, stdout, stderr) : undefined;
+    const overflowNote = cleanOverflowFile !== undefined ? shellRecoveryHint(cleanOverflowFile, readOnly) : "";
     const exit1Note = exitCode === 1 ? bashExitOneInterpretation(command) : undefined;
     const parts = [`exit code: ${exitCode}${exit1Note ? ` (${exit1Note} — exit 1 from this command is not an error)` : ""}`, `--- stdout ---\n${clippedStdout || "(empty)"}`];
     if (stderr.trim() !== "")
         parts.push(`--- stderr ---\n${clippedStderr}`);
+    if (overflowNote)
+        parts.push(overflowNote.trim());
     return {
         content: parts.join("\n"),
-        details: { type: "bash", stdout: clippedStdout, stderr: clippedStderr, exitCode, ...(exit1Note ? { returnCodeInterpretation: exit1Note } : {}) },
+        details: {
+            type: "bash",
+            stdout: clippedStdout,
+            stderr: clippedStderr,
+            exitCode,
+            ...(exit1Note ? { returnCodeInterpretation: exit1Note } : {}),
+            ...(cleanOverflowFile !== undefined ? { output_file: cleanOverflowFile } : {}),
+        },
     };
 }
 function bashDescription(coAuthor, bgNotifies = false, bgRetained = false) {
@@ -1828,7 +1858,7 @@ export function makeBashTool(env, rootCanonical, coAuthor = false, cwdRef = { cu
                 : undefined;
             let res;
             try {
-                res = await runShell(env, rootCanonical, "Bash", command, msTimeoutToSec(timeout), ctx.signal, cwdRef, detachChain, taskOpts.execClamp, ctx.toolCallId);
+                res = await runShell(env, rootCanonical, "Bash", command, msTimeoutToSec(timeout), ctx.signal, cwdRef, detachChain, taskOpts.execClamp, ctx.toolCallId, false);
             }
             finally {
                 taskOpts.detachHub?.gc(ctx.toolCallId);
@@ -1863,7 +1893,7 @@ export function makeBashReadonlyTool(env, rootCanonical, allow, execClamp) {
             const reason = coarseReadonlyCheck(command, allow);
             if (reason)
                 return `Error (Bash): ${reason}`;
-            return runShell(env, rootCanonical, "Bash", command, msTimeoutToSec(timeout), ctx.signal, undefined, undefined, execClamp, ctx.toolCallId);
+            return runShell(env, rootCanonical, "Bash", command, msTimeoutToSec(timeout), ctx.signal, undefined, undefined, execClamp, ctx.toolCallId, true);
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "1.433.0",
+  "version": "1.435.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",