@sema-agent/core 3.0.0 → 4.0.0

package/dist/core/stub-env.d.ts

@@ -1,4 +1,4 @@
-import { type ExecutionEnv, ExecutionError, FileError, type FileInfo, type Result } from "../internal/harness.js";
+import { type ExecResult, type ExecutionEnv, ExecutionError, FileError, type FileInfo, type Result } from "../internal/harness.js";
 export declare class StubExecutionEnv implements ExecutionEnv {
     cwd: string;
     constructor(cwd?: string);
@@ -18,10 +18,6 @@ export declare class StubExecutionEnv implements ExecutionEnv {
     remove(path: string): Promise<Result<void, FileError>>;
     createTempDir(): Promise<Result<string, FileError>>;
     createTempFile(): Promise<Result<string, FileError>>;
-    exec(): Promise<Result<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }, ExecutionError>>;
+    exec(): Promise<Result<ExecResult, ExecutionError>>;
     cleanup(): Promise<void>;
 }

package/dist/core/surrogate-safe-slice.d.ts

@@ -0,0 +1,4 @@
+export declare const isHighSurrogate: (c: number) => boolean;
+export declare const isLowSurrogate: (c: number) => boolean;
+export declare function sliceHeadSafe(s: string, keep: number): string;
+export declare function sliceTailSafe(s: string, keep: number): string;

package/dist/core/surrogate-safe-slice.js

@@ -0,0 +1,18 @@
+export const isHighSurrogate = (c) => c >= 0xd800 && c <= 0xdbff;
+export const isLowSurrogate = (c) => c >= 0xdc00 && c <= 0xdfff;
+export function sliceHeadSafe(s, keep) {
+    if (keep <= 0)
+        return "";
+    if (s.length <= keep)
+        return s;
+    const head = s.slice(0, keep);
+    return keep > 0 && isHighSurrogate(head.charCodeAt(keep - 1)) ? head.slice(0, -1) : head;
+}
+export function sliceTailSafe(s, keep) {
+    if (keep <= 0)
+        return "";
+    if (s.length <= keep)
+        return s;
+    const tail = s.slice(-keep);
+    return keep > 0 && isLowSurrogate(tail.charCodeAt(0)) ? tail.slice(1) : tail;
+}

package/dist/core/task-registry-monitor.js

@@ -1,5 +1,5 @@
 import { delimitUntrusted } from "./untrusted-text.js";
-import { assertOwnership, defaultMonitorTimers, MONITOR_MAX_TIMEOUT_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_BATCH_WINDOW_MS, MONITOR_MAX_BATCHES_PER_MINUTE, MONITOR_STORM_BURST, MONITOR_STORM_KILL_AFTER_MS, MONITOR_LINE_BUF_CAP, MONITOR_SPILL_CAP_CHARS, TASK_OUTPUT_MAX_CHARS, mintCompletionId, clipMonitorEvent, clipMonitorLine, terminalTaskSummary, accountDroppedBytes, rollSpoolText, statusFromBackground, droppedGapNote, firstDropNote, alreadyTerminalStopNote, clipTaskOutput, sleepPollStep, } from "./task-registry-shared.js";
+import { assertOwnership, defaultMonitorTimers, MONITOR_MAX_TIMEOUT_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_BATCH_WINDOW_MS, MONITOR_MAX_BATCHES_PER_MINUTE, MONITOR_STORM_BURST, MONITOR_STORM_KILL_AFTER_MS, MONITOR_LINE_BUF_CAP, MONITOR_SPILL_CAP_CHARS, TASK_OUTPUT_MAX_CHARS, mintCompletionId, clipMonitorEvent, clipMonitorLine, terminalTaskSummary, accountDroppedBytes, renderSpoolBody, rollSpoolText, statusFromBackground, droppedGapNote, firstDropNote, alreadyTerminalStopNote, clipTaskOutput, sleepPollStep, } from "./task-registry-shared.js";
 import { buildToolResultRef, OFFLOAD_TOOL_NAME } from "./tool-result-store.js";
 export function registerMonitorLane(core, input) {
     assertOwnership(input, "registerMonitor");
@@ -318,18 +318,13 @@ export async function pollMonitorLane(handle, filter, deadline, signal) {
     const shape = (text) => clipTaskOutput(rx ? text.split(/\r?\n/).filter((l) => rx.test(l)).join("\n") : text, handle.outputFile);
     const running = handle.status === "running";
     const retrieval = running && deadline !== undefined && Date.now() >= deadline ? "timeout" : "success";
-    const timedOutClause = spool.timedOut === true ? ` (timed out after ${spool.timeoutSec !== undefined ? `${spool.timeoutSec}s` : "its background time budget"})` : "";
-    const displayStatus = (spool.exitCode !== undefined ? `exited(code ${spool.exitCode})` : running ? "running" : handle.status) + timedOutClause;
-    const rolledNote = spool.rolledChars > 0 ? `[!] ${spool.rolledChars} earlier char(s) dropped from the spool (memory bound)${monitorSpillNote(handle)}\n` : "";
-    const droppedNote = (spool.droppedBytes ?? 0) > 0
-        ? `[!] ${spool.droppedBytes} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n`
-        : spool.dropUnknown === true
-            ? "[!] an unknown amount of earlier output was permanently dropped before this window (buffer evicted)\n"
-            : "";
-    const drainNote = spool.drainFailed === true ? "[!] the final output drain at stop failed — the tail of the output may be missing\n" : "";
-    const stdoutHeading = droppedNote !== "" || drainNote !== "" ? "stdout (re-readable spool — INCOMPLETE, see note above)" : "stdout (full, re-readable)";
-    const body = `status: ${displayStatus}\n${rolledNote}${droppedNote}${drainNote}--- ${stdoutHeading} ---\n${shape(spool.stdout) || "(none)"}\n` +
-        `--- stderr ---\n${shape(spool.stderr) || "(none)"}`;
+    const body = renderSpoolBody(spool, {
+        running,
+        handleStatus: handle.status,
+        shape,
+        rolledExtraClause: monitorSpillNote(handle),
+        drainNote: spool.drainFailed === true ? "[!] the final output drain at stop failed — the tail of the output may be missing\n" : "",
+    });
     return {
         content: delimitUntrusted(`TaskOutput ${handle.id}`, body),
         details: {

package/dist/core/task-registry-shared.d.ts

@@ -252,6 +252,28 @@ export declare function accountDroppedBytes(spool: {
     truncated?: boolean;
     bytesDroppedBeforeCursor?: number;
 }): void;
+export declare function spoolDropNote(acct: {
+    droppedBytes?: number;
+    dropUnknown?: true;
+}): string;
+export interface RenderableSpool {
+    stdout: string;
+    stderr: string;
+    rolledChars: number;
+    exitCode?: number;
+    timedOut?: boolean;
+    timeoutSec?: number;
+    droppedBytes?: number;
+    dropUnknown?: true;
+}
+export interface SpoolBodyOptions {
+    running: boolean;
+    handleStatus: SemaTaskStatus;
+    shape: (text: string) => string;
+    rolledExtraClause: string;
+    drainNote: string;
+}
+export declare function renderSpoolBody(spool: RenderableSpool, opts: SpoolBodyOptions): string;
 export declare function droppedGapNote(spool: {
     droppedBytes?: number;
     dropUnknown?: true;

package/dist/core/task-registry-shared.js

@@ -102,6 +102,22 @@ export function accountDroppedBytes(spool, poll) {
     else if (poll.truncated === true)
         spool.dropUnknown = true;
 }
+export function spoolDropNote(acct) {
+    if ((acct.droppedBytes ?? 0) > 0)
+        return `[!] ${acct.droppedBytes} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n`;
+    if (acct.dropUnknown === true)
+        return "[!] an unknown amount of earlier output was permanently dropped before this window (buffer evicted)\n";
+    return "";
+}
+export function renderSpoolBody(spool, opts) {
+    const timedOutClause = spool.timedOut === true ? ` (timed out after ${spool.timeoutSec !== undefined ? `${spool.timeoutSec}s` : "its background time budget"})` : "";
+    const displayStatus = (spool.exitCode !== undefined ? `exited(code ${spool.exitCode})` : opts.running ? "running" : opts.handleStatus) + timedOutClause;
+    const rolledNote = spool.rolledChars > 0 ? `[!] ${spool.rolledChars} earlier char(s) dropped from the spool (memory bound)${opts.rolledExtraClause}\n` : "";
+    const droppedNote = spoolDropNote(spool);
+    const stdoutHeading = droppedNote !== "" || opts.drainNote !== "" ? "stdout (re-readable spool — INCOMPLETE, see note above)" : "stdout (full, re-readable)";
+    return (`status: ${displayStatus}\n${rolledNote}${droppedNote}${opts.drainNote}--- ${stdoutHeading} ---\n${opts.shape(spool.stdout) || "(none)"}\n` +
+        `--- stderr ---\n${opts.shape(spool.stderr) || "(none)"}`);
+}
 export function droppedGapNote(spool) {
     if ((spool.droppedBytes ?? 0) > 0)
         return ` [!] ${spool.droppedBytes} earlier byte(s) of output were permanently dropped before this window (execution-environment tail buffer evicted) — the event stream and this spool are INCOMPLETE.`;

package/dist/core/task-registry.d.ts

@@ -69,6 +69,7 @@ export declare class TaskRegistry {
     private sessionReapHooks;
     private bgQuiescenceWatchers;
     private legacyToTaskId;
+    private readonly notifier;
     private readonly core;
     durableAgentArmed(id: string): boolean;
     durableAgentRowProbe(id: string): (() => Promise<boolean>) | undefined;

package/dist/core/task-registry.js

@@ -4,9 +4,10 @@ import { hasBackgroundShell } from "./background-shell.js";
 import { shutdownDebug } from "./shutdown-debug.js";
 import { canAccessAgentRecord, } from "./background-agent-store.js";
 import { delimitUntrusted } from "./untrusted-text.js";
+import { createSafeNotifier } from "./safe-notify.js";
 import { registerMonitorLane, pollMonitorLane, stopMonitorLane } from "./task-registry-monitor.js";
 import { registerWorkflowLane, pollWorkflowLane, stopWorkflowLane } from "./task-registry-workflow.js";
-import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, droppedGapNote, alreadyTerminalStopNote, terminalTaskSummary, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
+import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, renderSpoolBody, spoolDropNote, droppedGapNote, alreadyTerminalStopNote, terminalTaskSummary, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
 export { normalizeAgentName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR } from "./task-registry-shared.js";
 import { TASK_OUTPUT_TOOL_NAME, TASK_STOP_TOOL_NAME, TASK_OUTPUT_ALIASES, TASK_STOP_ALIASES, TASK_OUTPUT_CONTRACT, TASK_STOP_CONTRACT, TASK_OUTPUT_MISSING_ID_MESSAGE, TASK_STOP_MISSING_ID_MESSAGE, TASK_STOP_PARAMS, resolveTaskIdArg, REGISTRY_TASK_TOOL_CAPS, composeTaskOutputDescription, composeTaskOutputParams, composeTaskStopDescription, } from "./task-tool-shape.js";
 import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
@@ -47,6 +48,31 @@ function bashTerminalResult(spool) {
     const err = spool.stderr.slice(-2_000);
     return err.length > 0 ? `${out}${out.length > 0 ? "\n" : ""}--- stderr (tail) ---\n${err}` : out;
 }
+async function drainBashTailBestEffort(handle) {
+    if (handle.outputFile === undefined)
+        return;
+    try {
+        const drained = await handle.env.pollBackground(handle.shellId);
+        if (drained.ok && handle.spool !== undefined)
+            accountDroppedBytes(handle.spool, drained.value);
+        if (drained.ok && (drained.value.stdout.length > 0 || drained.value.stderr.length > 0)) {
+            if (handle.spool !== undefined) {
+                const spool = handle.spool;
+                const cap = 2 * TASK_OUTPUT_MAX_CHARS;
+                spool.stdout = rollSpoolText(spool, spool.stdout + drained.value.stdout, cap);
+                spool.stderr = rollSpoolText(spool, spool.stderr + drained.value.stderr, cap);
+                const ap = await handle.env.appendFile(handle.outputFile, drained.value.stdout + drained.value.stderr);
+                if (!ap.ok)
+                    spool.mirrorFailed = true;
+            }
+            else {
+                await handle.env.appendFile(handle.outputFile, drained.value.stdout + drained.value.stderr);
+            }
+        }
+    }
+    catch {
+    }
+}
 function bashMirrorGapNote(handle) {
     return handle.outputFile !== undefined && handle.spool?.mirrorFailed === true
         ? " [!] The output file is INCOMPLETE (one or more writes to it failed) — trust the result text / TaskOutput over the file."
@@ -77,6 +103,7 @@ export class TaskRegistry {
     sessionReapHooks = new Set();
     bgQuiescenceWatchers = new Map();
     legacyToTaskId = new Map();
+    notifier = createSafeNotifier();
     core = (() => {
         const self = this;
         return {
@@ -407,22 +434,7 @@ export class TaskRegistry {
                 handle.stoppedBy = handle.stopSource ?? source;
                 handle.updatedAt = Date.now();
                 mintCompletionId(handle);
-                if (handle.outputFile !== undefined) {
-                    try {
-                        const drained = await handle.env.pollBackground(handle.shellId);
-                        if (drained.ok && (drained.value.stdout.length > 0 || drained.value.stderr.length > 0)) {
-                            const spool = (handle.spool ??= { stdout: "", stderr: "", rolledChars: 0 });
-                            const cap = 2 * TASK_OUTPUT_MAX_CHARS;
-                            spool.stdout = rollSpoolText(spool, spool.stdout + drained.value.stdout, cap);
-                            spool.stderr = rollSpoolText(spool, spool.stderr + drained.value.stderr, cap);
-                            const ap = await handle.env.appendFile(handle.outputFile, drained.value.stdout + drained.value.stderr);
-                            if (!ap.ok)
-                                spool.mirrorFailed = true;
-                        }
-                    }
-                    catch {
-                    }
-                }
+                await drainBashTailBestEffort(handle);
                 const resultText = handle.spool !== undefined ? bashTerminalResult(handle.spool) : "";
                 this.notifyTerminalOnce(handle, () => handle.onTerminal?.({
                     task_id: handle.id,
@@ -521,21 +533,13 @@ export class TaskRegistry {
             this.settleBackgroundAgent(handle.id, { status: "killed", error: "session released", cycle: handle.reviveCycle ?? 0 });
             if (reapTerminalNote !== undefined && handle.terminalNotified !== true) {
                 handle.terminalNotified = true;
-                try {
-                    reapTerminalNote();
-                }
-                catch {
-                }
+                this.notifier.notify(() => reapTerminalNote(), "taskRegistry.reapTerminalNote");
             }
             reaped++;
         }
         this.pokeBgQuiescence(sessionId);
         for (const hook of this.sessionReapHooks) {
-            try {
-                hook(sessionId, scope);
-            }
-            catch {
-            }
+            this.notifier.notify(() => hook(sessionId, scope), "taskRegistry.onSessionReap");
         }
         return reaped;
     }
@@ -585,11 +589,7 @@ export class TaskRegistry {
                     this.bgQuiescenceWatchers.delete(oldest);
                     queueMicrotask(() => {
                         for (const victim of victims) {
-                            try {
-                                victim("evicted");
-                            }
-                            catch {
-                            }
+                            this.notifier.notify(() => victim("evicted"), "taskRegistry.bgQuiescence.evicted");
                         }
                     });
                 }
@@ -617,22 +617,14 @@ export class TaskRegistry {
             return;
         this.bgQuiescenceWatchers.delete(owner);
         for (const cb of set) {
-            try {
-                cb("quiescent");
-            }
-            catch {
-            }
+            this.notifier.notify(() => cb("quiescent"), "taskRegistry.bgQuiescence.quiescent");
         }
     }
     notifyTerminalOnce(handle, send) {
         if (handle.terminalNotified === true)
             return;
         handle.terminalNotified = true;
-        try {
-            send();
-        }
-        catch {
-        }
+        this.notifier.notify(() => send(), "taskRegistry.notifyTerminalOnce");
         this.pokeBgQuiescence(handle.owner);
     }
     startBashWatcher(id, onTerminal) {
@@ -1049,17 +1041,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
             const shape = (text) => clipTaskOutput(rx ? text.split(/\r?\n/).filter((l) => rx.test(l)).join("\n") : text, handle.outputFile);
             const running = handle.status === "running";
             const retrieval = running && deadline !== undefined && Date.now() >= deadline ? "timeout" : "success";
-            const timedOutClause = spool.timedOut === true ? ` (timed out after ${spool.timeoutSec !== undefined ? `${spool.timeoutSec}s` : "its background time budget"})` : "";
-            const displayStatus = (spool.exitCode !== undefined ? `exited(code ${spool.exitCode})` : running ? "running" : handle.status) + timedOutClause;
-            const rolledNote = spool.rolledChars > 0 ? `[!] ${spool.rolledChars} earlier char(s) dropped from the spool (memory bound)\n` : "";
-            const droppedNote = (spool.droppedBytes ?? 0) > 0
-                ? `[!] ${spool.droppedBytes} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n`
-                : spool.dropUnknown === true
-                    ? "[!] an unknown amount of earlier output was permanently dropped before this window (buffer evicted)\n"
-                    : "";
-            const stdoutHeading = droppedNote !== "" ? "stdout (re-readable spool — INCOMPLETE, see note above)" : "stdout (full, re-readable)";
-            const body = `status: ${displayStatus}\n${rolledNote}${droppedNote}--- ${stdoutHeading} ---\n${shape(spool.stdout) || "(none)"}\n` +
-                `--- stderr ---\n${shape(spool.stderr) || "(none)"}`;
+            const body = renderSpoolBody(spool, { running, handleStatus: handle.status, shape, rolledExtraClause: "", drainNote: "" });
             return {
                 content: delimitUntrusted(`TaskOutput ${handle.id}`, body),
                 details: {
@@ -1089,7 +1071,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
         };
         let stdout = "";
         let stderr = "";
-        let dropped = 0;
+        const dropAcct = {};
         for (;;) {
             const r = await handle.env.pollBackground(handle.shellId);
             if (!r.ok) {
@@ -1107,7 +1089,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
             }
             stdout = roll(stdout + r.value.stdout);
             stderr = roll(stderr + r.value.stderr);
-            dropped += r.value.bytesDroppedBeforeCursor ?? 0;
+            accountDroppedBytes(dropAcct, r.value);
             handle.status = statusFromBackground(r.value.status, r.value.exitCode);
             if (handle.status === "killed" && handle.stoppedBy === undefined)
                 handle.stoppedBy = handle.stopSource ?? (r.value.timedOut === true ? "timeout" : "system");
@@ -1120,7 +1102,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
                 const shape = (text) => clipTaskOutput(rx ? text.split(/\r?\n/).filter((l) => rx.test(l)).join("\n") : text, handle.outputFile);
                 const timedOutClause = r.value.timedOut === true ? ` (timed out after ${r.value.timeoutSec !== undefined ? `${r.value.timeoutSec}s` : "its background time budget"})` : "";
                 const displayStatus = (r.value.status === "exited" ? `exited(code ${r.value.exitCode})` : r.value.status) + timedOutClause;
-                const droppedNote = (dropped > 0 ? `[!] ${dropped} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n` : "") +
+                const droppedNote = spoolDropNote(dropAcct) +
                     (rolledChars > 0 ? `[!] ${rolledChars} accumulated char(s) dropped from the middle during the blocked wait (memory bound)\n` : "");
                 const body = `status: ${displayStatus}\n${droppedNote}--- new stdout ---\n${shape(stdout) || "(none)"}\n` +
                     `--- new stderr ---\n${shape(stderr) || "(none)"}`;
@@ -1136,7 +1118,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
                         details: {
                             status: r.value.status,
                             exitCode: r.value.exitCode,
-                            bytesDroppedBeforeCursor: dropped,
+                            bytesDroppedBeforeCursor: dropAcct.droppedBytes ?? 0,
                             ...(r.value.timedOut === true ? { timedOut: true, ...(r.value.timeoutSec !== undefined ? { timeoutSec: r.value.timeoutSec } : {}) } : {}),
                         },
                     },
@@ -1205,6 +1187,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
         handle.status = "killed";
         handle.updatedAt = Date.now();
         mintCompletionId(handle);
+        await drainBashTailBestEffort(handle);
         this.notifyTerminalOnce(handle, () => explicitStopBashTerminalNote(handle, false));
         return {
             content: `Terminated ${handle.id}.`,

package/dist/core/tool-errors.js

@@ -1,14 +1,15 @@
 import { Value } from "typebox/value";
 const MAX_ERROR_CHARS = 10_000;
 const HALF = MAX_ERROR_CHARS / 2;
+import { isHighSurrogate, isLowSurrogate, sliceHeadSafe, sliceTailSafe } from "./surrogate-safe-slice.js";
 export function truncateError(s) {
     if (s.length <= MAX_ERROR_CHARS)
         return 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 head = sliceHeadSafe(s, HALF);
+    const tail = sliceTailSafe(s, HALF);
+    const removed = s.length - head.length - tail.length;
+    return `${head}\n\n... [${removed} characters truncated] ...\n\n${tail}`;
 }
-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;

package/dist/core/tool-name-aliases.js

@@ -52,7 +52,8 @@ export const TOMBSTONED_TOOLS = {
 const MCP_PREFIX = "mcp__";
 const MCP_NAME_SEP = "__";
 export function canonicalToolName(name) {
-    const renamed = OLD_TO_NEW[name] ?? name;
+    const mapped = Object.hasOwn(OLD_TO_NEW, name) ? OLD_TO_NEW[name] : undefined;
+    const renamed = typeof mapped === "string" ? mapped : name;
     if (renamed.includes(MCP_NAME_SEP) && !renamed.startsWith(MCP_PREFIX))
         return MCP_PREFIX + renamed;
     return renamed;

package/dist/core/tool-policy.js

@@ -8,7 +8,7 @@ export function decisionText(d) {
 }
 const ALLOW = { action: "allow" };
 function withTimeout(p, ms, onTimeout) {
-    if (!ms || ms <= 0) {
+    if (ms === undefined) {
         return p;
     }
     return new Promise((resolve, reject) => {
@@ -25,7 +25,6 @@ function withTimeout(p, ms, onTimeout) {
                 return;
             settle(resolve, onTimeout());
         }, ms);
-        timer.unref?.();
         p.then((v) => settle(resolve, v), (e) => settle(reject, e));
     });
 }
@@ -51,6 +50,9 @@ export function createAllowDenyPolicy(opts) {
     };
 }
 export function createApprovalPolicy(opts) {
+    if (opts.approvalTimeoutMs !== undefined && !Number.isFinite(opts.approvalTimeoutMs)) {
+        throw new Error(`createApprovalPolicy: approvalTimeoutMs must be a finite number of ms (got ${opts.approvalTimeoutMs}) — omit it to wait indefinitely`);
+    }
     const need = new Set(opts.requireApproval.map(canonicalToolName));
     const deny = new Set((opts.deny ?? []).map(canonicalToolName));
     const auto = new Set((opts.autoAllow ?? []).map(canonicalToolName));
@@ -403,6 +405,8 @@ export function createUnverifiableDeletePolicy(opts) {
 function pathSegments(p) {
     return p.split(/[\\/]/).filter(Boolean);
 }
+const CASE_INSENSITIVE_FS = process.platform === "darwin" || process.platform === "win32";
+const foldPathCase = (s) => (CASE_INSENSITIVE_FS ? s.toLowerCase() : s);
 function lexicalPath(p, home) {
     const norm = p.normalize("NFC");
     const expanded = norm === "~" ? home : /^~[\\/]/.test(norm) ? join(home, norm.slice(2)) : norm;
@@ -432,17 +436,18 @@ export function createTranscriptIntegrityPolicy(opts) {
     });
     const readAllow = new Set(opts?.readAllow ?? BASH_READONLY_DEFAULT_ALLOW);
     const shellTools = canonicalToolNameSet(opts?.tools);
-    const dirSegs = dirs.map(pathSegments);
+    const dirSegs = dirs.map((d) => pathSegments(d).map(foldPathCase));
     const inProtectedDir = (p) => {
         const abs = lexicalPath(p, home);
-        const segs = pathSegments(abs);
+        const segs = pathSegments(abs).map(foldPathCase);
         if (isAbsolute(abs)) {
             return dirSegs.some((d) => d.length <= segs.length && d.every((s, i) => s === segs[i]));
         }
         return dirSegs.some((d) => relativeContinuesDirTail(segs, d));
     };
     const referencesProtectedDir = (cmd) => {
-        if (textualForms.some((f) => cmd.includes(f)))
+        const hay = foldPathCase(cmd);
+        if (textualForms.some((f) => hay.includes(foldPathCase(f))))
             return true;
         for (const raw of cmd.split(/[\s;&|<>()]+/)) {
             if (raw === "")

package/dist/core/tool-result-store.d.ts

@@ -45,6 +45,7 @@ export declare class ScopedToolResultStore implements ToolResultStore {
 }
 export declare function isVolatileOffloadStore(store: ToolResultStore): boolean;
 export declare const OFFLOAD_TOOL_NAME = "ReadToolResult";
+export declare function createOffloadPersist(store: ToolResultStore, sessionId: string): (toolCallId: string, fullText: string) => string;
 export declare function offloadPagebackHint(ref: string, form: "preview" | "cleared", reachableTools?: ReadonlySet<string>): string;
 export declare const PERSISTED_OUTPUT_PREFIX = "<persisted-output ref=";
 export declare const DEFAULT_TOOL_RESULT_THRESHOLD_CHARS = 20000;

package/dist/core/tool-result-store.js

@@ -29,6 +29,10 @@ export class InMemoryToolResultStore {
     totalChars = 0;
     constructor(opts) {
         this.opts = opts;
+        const cap = opts?.maxTotalChars;
+        if (cap !== undefined && Number.isNaN(cap)) {
+            throw new Error("InMemoryToolResultStore: maxTotalChars must be a number (got NaN) — omit it for an unbounded store");
+        }
     }
     put(ref, content) {
         assertSafeToolResultRef(ref);
@@ -37,7 +41,7 @@ export class InMemoryToolResultStore {
         this.map.set(ref, content);
         this.totalChars += content.length;
         const cap = this.opts?.maxTotalChars;
-        if (cap !== undefined && cap > 0) {
+        if (cap !== undefined && Number.isFinite(cap)) {
             for (const [oldRef, oldContent] of this.map) {
                 if (this.totalChars <= cap || oldRef === ref)
                     break;
@@ -93,6 +97,16 @@ export function isVolatileOffloadStore(store) {
     return store instanceof InMemoryToolResultStore;
 }
 export const OFFLOAD_TOOL_NAME = "ReadToolResult";
+export function createOffloadPersist(store, sessionId) {
+    return (toolCallId, fullText) => {
+        const ref = buildToolResultRef(sessionId, toolCallId);
+        void Promise.resolve(store.put(ref, fullText)).catch((err) => {
+            const cause = err instanceof Error ? err.message : String(err);
+            void Promise.resolve(store.put(ref, `[offload LOST at write time: ${cause} — the inline preview is all that survived]`)).catch(() => undefined);
+        });
+        return ref;
+    };
+}
 export function offloadPagebackHint(ref, form, reachableTools) {
     const activate = reachableTools !== undefined && !reachableTools.has(OFFLOAD_TOOL_NAME)
         ? `${OFFLOAD_TOOL_NAME} is not active yet — call ${TOOL_SEARCH_NAME} with {"query":"select:${OFFLOAD_TOOL_NAME}"} to activate it, then `
@@ -144,6 +158,8 @@ export function buildPreview(full, ref, sizes, reachableTools) {
         `</persisted-output>`);
 }
 export function withToolResultOffload(tool, store, thresholdChars, sessionId, reachableTools) {
+    if (!(Number.isFinite(thresholdChars) && thresholdChars > 0))
+        return tool;
     const wrappedExecute = async (toolCallId, params, signal, onUpdate) => {
         const res = await tool.execute(toolCallId, params, signal, onUpdate);
         if (totalTextChars(res.content) <= thresholdChars)

package/dist/core/trace.d.ts

@@ -1,5 +1,6 @@
 import type { TaskStatus, ToolEffect } from "./types.js";
 import type { ThinkingLevel } from "../internal/harness-types.js";
+import type { ToolManifestRow } from "../prompt-assembly/tool-catalog.js";
 export interface TraceMechanismsSummary {
     finalizeInjected?: true;
     nudgesSent?: number;
@@ -42,15 +43,7 @@ export type TraceEvent = {
         hash: string;
         contentHash?: string;
     }>;
-    tools?: Array<{
-        wireName: string;
-        aliases: string[];
-        contractId: string;
-        implementationRevision: string;
-        cardId: string;
-        shapeDigest: string;
-        wireSchemaDigest: string;
-    }>;
+    tools?: ToolManifestRow[];
     totalChars: number;
     snapshot?: {
         cacheIdentity: string;

package/dist/core/types.d.ts

@@ -57,6 +57,19 @@ export type ToolReturn = string | {
     terminate?: boolean;
     isError?: boolean;
 };
+export interface NestedUsage {
+    tokens: number;
+    turns: number;
+    tasks: number;
+    costMicroUsd?: number;
+}
+export interface NestedUsageAccum {
+    tokens: number;
+    turns: number;
+    tasks: number;
+    costMicroUsd: number;
+    anyUnpriced: boolean;
+}
 export interface ToolExecuteContext {
     toolCallId: string;
     signal?: AbortSignal;
@@ -81,12 +94,7 @@ export interface ToolExecuteContext {
         release: () => Promise<void>;
     } | null>;
     parentCwd?: string;
-    reportUsage?: (usage: {
-        tokens: number;
-        turns: number;
-        tasks: number;
-        costMicroUsd?: number;
-    }) => void;
+    reportUsage?: (usage: NestedUsage) => void;
     model?: Model;
     thinkingLevel?: ThinkingLevel;
     principal?: string;
@@ -412,12 +420,7 @@ export interface TaskResult {
         outputTokens?: number;
         cacheWriteTokensLong?: number;
         costMicroUsd?: number;
-        nested?: {
-            tokens: number;
-            turns: number;
-            tasks: number;
-            costMicroUsd?: number;
-        };
+        nested?: NestedUsage;
         memory?: {
             tokens: number;
             costMicroUsd: number;

package/dist/core/untrusted-egress.js

@@ -1,5 +1,6 @@
 import { delimitUntrusted } from "./untrusted-text.js";
 import { scrubSecrets } from "./arg-summary.js";
+import { sliceHeadSafe } from "./surrogate-safe-slice.js";
 const URI_SCHEME = String.raw `[A-Za-z][A-Za-z0-9+.\-_]{0,63}`;
 const CREDENTIALS_IN_AUTHORITY = new RegExp(String.raw `(${URI_SCHEME}:\/\/)((?:[^/\s"'@]*@)+)`, "gi");
 const URL_OF_ANY_PROTOCOL = new RegExp(String.raw `${URI_SCHEME}:\/\/[^\s"'\`]+`, "gi");
@@ -52,16 +53,17 @@ function boundedString(value, max, redact) {
     if (s.length <= max)
         return s;
     const totalMarkers = countRedactionMarkers(s);
-    const plainSuffix = (keepN) => `…[+${s.length - keepN} chars]`;
-    const enrichedSuffix = (keepN) => {
-        const lost = totalMarkers - countRedactionMarkers(s.slice(0, keepN));
-        return lost > 0 ? `…[+${s.length - keepN} chars, ${lost} redaction marker(s) among them]` : plainSuffix(keepN);
+    const plainSuffix = (kept) => `…[+${s.length - kept.length} chars]`;
+    const enrichedSuffix = (kept) => {
+        const lost = totalMarkers - countRedactionMarkers(kept);
+        return lost > 0 ? `…[+${s.length - kept.length} chars, ${lost} redaction marker(s) among them]` : plainSuffix(kept);
     };
     const converge = (suffixFor) => {
         let keep = max;
         let out = "";
         for (let i = 0; i < 4; i++) {
-            out = `${s.slice(0, keep)}${suffixFor(keep)}`;
+            const kept = sliceHeadSafe(s, keep);
+            out = `${kept}${suffixFor(kept)}`;
             if (out.length <= max)
                 return out;
             if (keep === 0)

package/dist/core/workflow-journal-store.d.ts

@@ -3,23 +3,20 @@ export interface WorkflowJournalEntry {
     callKey: string;
     result: TaskResult;
 }
+export interface ResumeClaimArgs {
+    sourceRunId: string;
+    newRunId: string;
+    scope: string;
+}
 export interface WorkflowJournalStore {
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
     append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
     locator?(runId: string, scope: string): string | undefined;
-    resumeClaim?(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<{
+    resumeClaim?(input: ResumeClaimArgs): Promise<{
         granted: boolean;
         holder?: string;
     }>;
-    releaseResumeClaim?(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<void>;
+    releaseResumeClaim?(input: ResumeClaimArgs): Promise<void>;
 }
 export declare const MAX_JOURNAL_RESULT_BYTES: number;
 export declare function oversizeJournalResult(serialized: string): boolean;
@@ -31,19 +28,11 @@ export declare class InMemoryWorkflowJournalStore implements WorkflowJournalStor
     private readonly runs;
     private readonly resumeClaims;
     private claimsForScope;
-    resumeClaim(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<{
+    resumeClaim(input: ResumeClaimArgs): Promise<{
         granted: boolean;
         holder?: string;
     }>;
-    releaseResumeClaim(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<void>;
+    releaseResumeClaim(input: ResumeClaimArgs): Promise<void>;
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
     append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
 }