@sema-agent/core 2.13.0 → 4.0.0

package/dist/tools/fs/notebook.d.ts

@@ -1,3 +1,4 @@
+import type { ImageContent } from "../../internal/llm.js";
 export declare function isNotebookPath(p: string): boolean;
 export declare const NOTEBOOK_CELL_OUTPUT_POINTER_CHARS = 10000;
 export declare const NOTEBOOK_OUTPUT_TEXT_CLIP = 10000;
@@ -31,11 +32,7 @@ export interface NotebookRender {
     blocks: Array<{
         type: "text";
         text: string;
-    } | {
-        type: "image";
-        data: string;
-        mimeType: string;
-    }>;
+    } | ImageContent>;
     textChars: number;
     imageChars: number;
 }

package/dist/tools/fs/safety.d.ts

@@ -22,8 +22,11 @@ export interface FsViolation {
     roots?: readonly string[];
     message: string;
 }
+export declare function isAbsolutePathForm(p: string): boolean;
+export declare function isWinFormPath(p: string): boolean;
 export declare function isBlockedDevicePath(key: string): boolean;
 export declare function normalizeAbsPathLexically(p: string): string;
+export declare function foldRedundantPathSegments(p: string): string;
 export declare function hasBinaryExtension(path: string): boolean;
 export declare function imageMimeForRead(path: string): string | undefined;
 export declare function imageMagicMatches(bytes: Uint8Array, mimeType: string): boolean;

package/dist/tools/fs/safety.js

@@ -18,20 +18,20 @@ export function sha256(content) {
     return createHash("sha256").update(content, "utf8").digest("hex");
 }
 const SEP = "/";
-function isAbsolutePathForm(p) {
-    return p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p);
+export function isAbsolutePathForm(p) {
+    return p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p) || p.startsWith("\\\\");
 }
 function normalizeForCompare(p) {
-    let n = p.replace(/\\/g, "/");
+    let n = isWinFormPath(p) ? p.replace(/\\/g, "/") : p;
     if (/^[A-Za-z]:(\/|$)/.test(n))
         n = n[0].toLowerCase() + n.slice(1);
     return n;
 }
 function nativeSepOf(p) {
-    return p.includes("\\") ? "\\" : "/";
+    return isWinFormPath(p) && p.includes("\\") ? "\\" : "/";
 }
 function lastSepIndex(p) {
-    return Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+    return isWinFormPath(p) ? Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\")) : p.lastIndexOf("/");
 }
 const BLOCKED_DEVICE_PATHS = new Set([
     "/dev/zero", "/dev/random", "/dev/urandom", "/dev/full",
@@ -46,7 +46,7 @@ function isProcSensitiveFile(key) {
     return key.startsWith("/proc/") && PROC_SENSITIVE_SUFFIXES.some((suf) => key.endsWith(suf));
 }
 const WIN_RESERVED_RE = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\.[^\\/]*)?$/i;
-function isWinFormPath(p) {
+export function isWinFormPath(p) {
     return /^[A-Za-z]:[\\/]/.test(p) || p.startsWith("\\\\") || (!p.startsWith("/") && p.includes("\\"));
 }
 function isWinReservedDeviceKey(key) {
@@ -60,19 +60,48 @@ export function isBlockedDevicePath(key) {
     return BLOCKED_DEVICE_PATHS.has(key) || isProcStdioFd(key) || isProcSensitiveFile(key) || isWinReservedDeviceKey(key);
 }
 export function normalizeAbsPathLexically(p) {
-    if (!p.startsWith("/"))
-        return p;
-    const out = [];
-    for (const seg of p.split("/")) {
+    return foldSegmentsLexically(p, true);
+}
+export function foldRedundantPathSegments(p) {
+    return foldSegmentsLexically(p, false);
+}
+function foldSegmentsLexically(p, foldParents) {
+    const isUnc = p.startsWith("\\\\");
+    const drive = /^[A-Za-z]:/.exec(p)?.[0] ?? "";
+    const winForm = isUnc || drive !== "" || (!p.startsWith("/") && p.includes("\\"));
+    const sep = winForm && p.includes("\\") ? "\\" : "/";
+    const splitter = winForm ? /[\\/]+/ : /\/+/;
+    let prefix = drive;
+    let rest = p.slice(drive.length + (isUnc ? 2 : 0));
+    let abs = rest.startsWith("/") || (winForm && rest.startsWith("\\"));
+    if (isUnc) {
+        const segs = rest.split(splitter).filter((seg) => seg !== "");
+        const host = segs.shift() ?? "";
+        const share = segs.shift();
+        prefix = sep + sep + host + (share === undefined ? "" : sep + share);
+        rest = segs.join(sep);
+        abs = true;
+    }
+    const outSegs = [];
+    for (const seg of rest.split(splitter)) {
         if (seg === "" || seg === ".")
             continue;
         if (seg === "..") {
-            out.pop();
+            if (!foldParents) {
+                outSegs.push(seg);
+                continue;
+            }
+            if (outSegs.length > 0 && outSegs[outSegs.length - 1] !== "..")
+                outSegs.pop();
+            else if (!abs)
+                outSegs.push("..");
             continue;
         }
-        out.push(seg);
+        outSegs.push(seg);
     }
-    return `/${out.join("/")}`;
+    if (outSegs.length === 0)
+        return abs ? prefix + sep : prefix === "" ? "." : prefix;
+    return prefix + (abs ? sep : "") + outSegs.join(sep);
 }
 const BINARY_EXTENSIONS = new Set([
     ".exe", ".dll", ".so", ".dylib", ".o", ".a", ".obj", ".lib", ".bin", ".class", ".pyc", ".pyo", ".wasm",
@@ -229,7 +258,7 @@ function parentDir(abs) {
 }
 async function canonicalizeNewPath(env, abs, signal) {
     const sep = nativeSepOf(abs);
-    const parts = abs.split(/[\\/]/);
+    const parts = isWinFormPath(abs) ? abs.split(/[\\/]/) : abs.split("/");
     const tail = [];
     while (parts.length > 1) {
         const candidate = parts.join(sep) || sep;

package/dist/tools/fs/search.js

@@ -1,5 +1,5 @@
 import { delimitUntrusted } from "../../core/untrusted-text.js";
-import { hasBinaryExtension } from "./safety.js";
+import { hasBinaryExtension, isAbsolutePathForm } from "./safety.js";
 const WALK_MAX_FILES = 5000;
 const WALK_MAX_DEPTH = 32;
 const GREP_DEFAULT_CAP = 250;
@@ -51,7 +51,7 @@ export function splitGlobParam(glob) {
     return out;
 }
 export function splitAbsoluteGlobPattern(pattern) {
-    if (!(pattern.startsWith("/") || /^[A-Za-z]:[\\/]/.test(pattern)))
+    if (!isAbsolutePathForm(pattern))
         return undefined;
     const m = /[*?[{]/.exec(pattern);
     if (!m) {
@@ -758,7 +758,7 @@ export async function jsGrep(env, root, p, signal, guards) {
     }
     const ignore = await buildIgnore(env, root, signal);
     const rootPrefix = root.replace(/[\\/]+$/, "") + (root.includes("\\") ? "\\" : "/");
-    const start = p.path ? (p.path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p.path) ? p.path : `${rootPrefix}${p.path}`) : root;
+    const start = p.path ? (isAbsolutePathForm(p.path) ? p.path : `${rootPrefix}${p.path}`) : root;
     let walked;
     if (p.path) {
         const info = await env.fileInfo(start, signal);
@@ -992,7 +992,7 @@ async function sortRgFilesByMtime(env, root, stdout, signal) {
     const rootPrefix = root.replace(/[\\/]+$/, "") + (root.includes("\\") ? "\\" : "/");
     const toAbs = (p) => {
         const stripped = p.startsWith("./") ? p.slice(2) : p;
-        return stripped.startsWith("/") || /^[A-Za-z]:[\\/]/.test(stripped) ? stripped : `${rootPrefix}${stripped}`;
+        return isAbsolutePathForm(stripped) ? stripped : `${rootPrefix}${stripped}`;
     };
     const infos = await Promise.all(paths.map((p) => env.fileInfo(toAbs(p), signal)));
     const withMtime = paths.map((p, i) => {
@@ -1104,7 +1104,7 @@ export async function runGlobDetailed(env, root, pattern, opts = {}, signal) {
     const t0 = Date.now();
     const baseIgnore = await buildIgnore(env, root, signal);
     const rootPrefix = root.replace(/[\\/]+$/, "") + (root.includes("\\") ? "\\" : "/");
-    const start = opts.path ? (opts.path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(opts.path) ? opts.path : `${rootPrefix}${opts.path}`) : root;
+    const start = opts.path ? (isAbsolutePathForm(opts.path) ? opts.path : `${rootPrefix}${opts.path}`) : root;
     if (opts.path !== undefined) {
         const probe = await env.fileInfo(start, signal);
         if (!probe.ok && probe.error.code === "not_found") {

package/dist/tools/loop-tick.js

@@ -49,7 +49,7 @@ Read and analyze freely — understanding the state of things has no blast radiu
 `;
 const DYNAMIC_APPENDIX = `
 
-If a Monitor is armed (check TaskList), keep \`delaySeconds\` at 1200–1800s — the Monitor is the wake signal and this is only the fallback heartbeat. If you were woken by a \`<task-notification>\`, handle the event before deciding whether to re-arm. To stop the loop, call ${SCHEDULE_WAKEUP_TOOL_NAME} with \`stop: true\` and TaskStop the monitor (use TaskList to find its task ID if no longer in context).`;
+If a Monitor is armed (its task_id was reported in the receipt when you started it), keep \`delaySeconds\` at 1200–1800s — the Monitor is the wake signal and this is only the fallback heartbeat. If you were woken by a \`<task-notification>\`, handle the event before deciding whether to re-arm. To stop the loop, call ${SCHEDULE_WAKEUP_TOOL_NAME} with \`stop: true\` and TaskStop the monitor (its task id is in that start receipt, and in the \`<task-id>\` of every notification the watch sends).`;
 function pushNotificationAppendix(persistentVariant) {
     const r = persistentVariant
         ? "newly blocked on a decision you won't make alone, you're ending the loop"

package/dist/tools/monitor.d.ts

@@ -17,5 +17,6 @@ export interface MonitorToolOptions {
     batchWindowMs?: number;
     maxBatchesPerMinute?: number;
     toolResultStore?: ToolResultStore;
+    retainBackgroundProcesses?: boolean;
 }
 export declare function createMonitorTool(env: ExecutionEnv, opts: MonitorToolOptions): AgentTool;

package/dist/tools/monitor.js

@@ -29,6 +29,16 @@ const MONITOR_DESCRIPTION = "Run a shell command in the background and watch its
     '- Wrong: `until grep -q "BUILD SUCCEEDED" build.log; do sleep 5; done` — if the build fails, this never exits and you wait until the watch times out.\n' +
     '- Right: `until grep -qE "BUILD (SUCCEEDED|FAILED)" build.log; do sleep 5; done` — every terminal state exits.\n' +
     "Before arming, ask: *if this process crashed right now, would my filter emit anything?* If not, widen it.";
+function envBackgroundWallSec(caps, requestedSec) {
+    const positive = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : undefined);
+    const cap = positive(caps.maxBgTimeoutSec);
+    const base = requestedSec ?? positive(caps.defaultBgTimeoutSec);
+    if (base === undefined)
+        return cap;
+    if (cap === undefined)
+        return base;
+    return Math.min(base, cap);
+}
 export function createMonitorTool(env, opts) {
     return defineTool({
         name: "Monitor",
@@ -56,9 +66,10 @@ export function createMonitorTool(env, opts) {
             }
             const isPersistent = persistent === true;
             const timeoutMs = Math.min(MONITOR_MAX_TIMEOUT_MS, Math.max(1, Math.floor(timeout_ms ?? MONITOR_DEFAULT_TIMEOUT_MS)));
+            const spawnTimeoutSec = isPersistent ? undefined : Math.ceil(timeoutMs / 1000) + 5;
             const spawn = await env.spawnBackground(command, {
                 ...(opts.cwdRef !== undefined ? { cwd: opts.cwdRef.current } : {}),
-                ...(isPersistent ? {} : { timeout: Math.ceil(timeoutMs / 1000) + 5 }),
+                ...(spawnTimeoutSec !== undefined ? { timeout: spawnTimeoutSec } : {}),
             });
             if (!spawn.ok)
                 return errorResult(`Error (Monitor): ${spawn.error.message}`);
@@ -87,18 +98,52 @@ export function createMonitorTool(env, opts) {
                 });
             }
             catch (e) {
-                await env.killBackground(spawn.value.shellId).catch(() => undefined);
-                return errorResult(`Error (Monitor): the watch process was started but could not be registered (${e instanceof Error ? e.message : String(e)}); it has been terminated.`);
+                const why = e instanceof Error ? e.message : String(e);
+                let killDetail;
+                try {
+                    const kill = await env.killBackground(spawn.value.shellId);
+                    if (!kill.ok)
+                        killDetail = `${kill.error.code}: ${kill.error.message}`;
+                }
+                catch (killErr) {
+                    killDetail = killErr instanceof Error ? killErr.message : String(killErr);
+                }
+                return errorResult(killDetail === undefined
+                    ? `Error (Monitor): the watch process was started but could not be registered (${why}); it has been terminated.`
+                    : `Error (Monitor): the watch process was started but could not be registered (${why}), and it could NOT be terminated either (${killDetail}). ` +
+                        `It may still be running as background shell ${spawn.value.shellId}; no task id was minted, so TaskOutput/TaskStop cannot reach it — ` +
+                        "stop it out of band (the environment's own background time budget and its teardown sweep are the remaining backstops).");
             }
-            const bgTimeout = env.backgroundCapabilities.defaultBgTimeoutSec;
+            const bgTimeout = envBackgroundWallSec(env.backgroundCapabilities, spawnTimeoutSec);
             const wasClamped = timeout_ms !== undefined && timeout_ms !== timeoutMs;
             const clampNote = !isPersistent && wasClamped ? ` (clamped to ${timeoutMs}ms from your requested ${timeout_ms}ms)` : "";
             const timeoutIgnoredNote = isPersistent && timeout_ms !== undefined ? ` (the timeout_ms you passed is ignored because persistent is true)` : "";
+            const envWallMs = bgTimeout !== undefined ? bgTimeout * 1000 : undefined;
+            const envWallWins = !isPersistent && envWallMs !== undefined && envWallMs < timeoutMs;
+            const persistentBudget = bgTimeout !== undefined
+                ? `the execution environment kills background processes after ${bgTimeout}s`
+                : `the execution environment's background time budget still applies`;
+            const retainedByEnv = env.backgroundCapabilities.retainBackgroundProcesses === true;
+            const retainedBySpec = opts.retainBackgroundProcesses === true;
+            const retained = retainedByEnv || retainedBySpec;
+            const persistentAnchor = sessionScoped
+                ? retained
+                    ? ". This run retains background processes (environment capability or task spec), so at the run teardown the watch is marked retained and " +
+                        "survives the session's release: only your TaskStop, the command's own exit, or that budget end it."
+                    : "; it runs until then, until you stop it, or until the session ends."
+                : retained
+                    ? ". This mount carries no session identity, so the watch is NOT session-resident despite persistent: true; and because this " +
+                        "run retains background processes (environment capability or task spec) it survives the session's release rather than being settled with the run — " +
+                        "nothing but your TaskStop, the command's own exit, or that budget will end it, and no later turn can reach it " +
+                        "(stop it explicitly with TaskStop before you finish)."
+                    : ". This mount carries no session identity, so the watch is NOT session-resident despite persistent: true — " +
+                        "it belongs to this task alone and the run teardown settles it, so do not count on it outliving this turn " +
+                        "(stop it explicitly with TaskStop when you are done).";
             const lifetime = isPersistent
-                ? typeof bgTimeout === "number"
-                    ? `It is persistent: no watch timeout of its own${timeoutIgnoredNote}, but the execution environment kills background processes after ${bgTimeout}s; it runs until then, until you stop it, or until the session ends.`
-                    : `It is persistent: no watch timeout of its own${timeoutIgnoredNote}, but the execution environment's background time budget still applies; it runs until then, until you stop it, or until the session ends.`
-                : `It will be killed after ${timeoutMs}ms${clampNote} if still running.`;
+                ? `It is persistent: no watch timeout of its own${timeoutIgnoredNote}, but ${persistentBudget}${persistentAnchor}`
+                : envWallWins
+                    ? `It will be killed after ${envWallMs}ms if still running — the execution environment's background time budget (${bgTimeout}s) is shorter than the ${timeoutMs}ms watch timeout${clampNote}, and the shorter of the two wins.`
+                    : `It will be killed after ${timeoutMs}ms${clampNote} if still running.`;
             const content = onNotify !== undefined
                 ? `Monitoring in background; task_id=${taskId}. Each stdout line becomes a notification event (lines within ` +
                     `~200ms are batched); you'll get a final notification with the exit code when it ends — do not poll. ` +
@@ -111,8 +156,11 @@ export function createMonitorTool(env, opts) {
                     type: "monitor-start",
                     taskId,
                     persistent: isPersistent,
+                    ...(bgTimeout !== undefined ? { envBudgetSec: bgTimeout } : {}),
+                    ...(envWallWins && envWallMs !== undefined ? { effectiveTimeoutMs: envWallMs } : {}),
                     ...(isPersistent
-                        ? { timeoutIgnored: timeout_ms !== undefined }
+                        ?
+                            { timeoutIgnored: timeout_ms !== undefined, sessionScoped, ...(retainedByEnv ? { retainedByEnv: true } : {}), ...(retainedBySpec ? { retainedBySpec: true } : {}) }
                         : { timeoutMs, ...(timeout_ms !== undefined ? { requestedTimeoutMs: timeout_ms } : {}), wasClamped }),
                 },
             };

package/dist/tools/worktree.d.ts

@@ -1,13 +1,10 @@
-import type { AgentTool, ExecutionEnv } from "../internal/harness-types.js";
+import type { ActiveWorktreeSession, AgentTool, ExecutionEnv } from "../internal/harness-types.js";
 import type { CwdRef } from "./fs/index.js";
-export interface ActiveWorktreeSession {
-    worktreeDir: string;
-    originalCwd: string;
-    baseSha: string;
-    entered?: boolean;
-}
+export type { ActiveWorktreeSession };
 export interface WorktreeSessionRef {
     current?: ActiveWorktreeSession;
+    exiting?: boolean;
+    entering?: boolean;
 }
 export interface WorktreeToolsOptions {
     repoRoot: string;