@sema-agent/core 3.0.0 → 4.0.0

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/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

@@ -124,14 +124,16 @@ export function createMonitorTool(env, opts) {
                 ? `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
-                ? retainedByEnv
-                    ? ". This environment declares retained background processes, so at the run teardown the watch is marked retained and " +
+                ? 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."
-                : retainedByEnv
+                : retained
                     ? ". This mount carries no session identity, so the watch is NOT session-resident despite persistent: true; and because this " +
-                        "environment declares retained background processes it survives the session's release rather than being settled with the run — " +
+                        "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 — " +
@@ -158,7 +160,7 @@ export function createMonitorTool(env, opts) {
                     ...(envWallWins && envWallMs !== undefined ? { effectiveTimeoutMs: envWallMs } : {}),
                     ...(isPersistent
                         ?
-                            { timeoutIgnored: timeout_ms !== undefined, sessionScoped, ...(retainedByEnv ? { retainedByEnv: true } : {}) }
+                            { 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,11 +1,6 @@
-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;

package/dist/tools/worktree.js

@@ -174,7 +174,9 @@ export function createWorktreeTools(env, opts) {
                     if (target === registered[0]) {
                         return errorResult(`Error (EnterWorktree): ${target} is the main working tree, not a linked worktree — nothing to enter.`);
                     }
-                    if (target !== repoRoot && !target.startsWith(repoRoot.endsWith("/") ? repoRoot : `${repoRoot}/`)) {
+                    const rootCanon = await env.canonicalPath(repoRoot);
+                    const fence = rootCanon.ok ? rootCanon.value : repoRoot;
+                    if (target !== fence && !target.startsWith(fence.endsWith("/") ? fence : `${fence}/`)) {
                         return errorResult(`Error (EnterWorktree): the worktree ${target} lives outside the task root ${repoRoot}; ` +
                             "file containment stays anchored at the task root, so it cannot be entered from this session.");
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",
@@ -41,6 +41,7 @@
     "dist",
     "README.md",
     "NOTICE.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "engines": {
@@ -60,7 +61,10 @@
     "gate:blackbox": "node scripts/run-blackbox-gate.mjs",
     "gate:ledger": "node scripts/verify-hardening-ledger.mjs",
     "gate:compensation": "node scripts/verify-compensation-registry.mjs",
-    "gate:message-branching": "node scripts/verify-no-message-branching.mjs"
+    "gate:message-branching": "node scripts/verify-no-message-branching.mjs",
+    "gate:failloud": "node scripts/verify-failloud.mjs",
+    "gate:domain-lexicon": "node scripts/verify-domain-lexicon.mjs",
+    "gate:single-mint": "node scripts/verify-single-mint.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",