@sema-agent/core 2.1.0 → 2.3.0

package/dist/tools/fs/safety.js

@@ -41,7 +41,10 @@ const BLOCKED_DEVICE_PATHS = new Set([
 function isProcStdioFd(key) {
     return key.startsWith("/proc/") && (key.endsWith("/fd/0") || key.endsWith("/fd/1") || key.endsWith("/fd/2"));
 }
-const PROC_SENSITIVE_RE = /^\/proc\/[^/]+\/(environ|cmdline|auxv|maps|mem|stat)$/;
+const PROC_SENSITIVE_SUFFIXES = ["/environ", "/cmdline", "/auxv", "/maps", "/mem", "/stat"];
+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) {
     return /^[A-Za-z]:[\\/]/.test(p) || p.startsWith("\\\\") || (!p.startsWith("/") && p.includes("\\"));
@@ -54,7 +57,7 @@ function isWinReservedDeviceKey(key) {
     return WIN_RESERVED_RE.test(base);
 }
 export function isBlockedDevicePath(key) {
-    return BLOCKED_DEVICE_PATHS.has(key) || isProcStdioFd(key) || PROC_SENSITIVE_RE.test(key) || isWinReservedDeviceKey(key);
+    return BLOCKED_DEVICE_PATHS.has(key) || isProcStdioFd(key) || isProcSensitiveFile(key) || isWinReservedDeviceKey(key);
 }
 export function normalizeAbsPathLexically(p) {
     if (!p.startsWith("/"))
@@ -73,12 +76,16 @@ export function normalizeAbsPathLexically(p) {
 }
 const BINARY_EXTENSIONS = new Set([
     ".exe", ".dll", ".so", ".dylib", ".o", ".a", ".obj", ".lib", ".bin", ".class", ".pyc", ".pyo", ".wasm",
-    ".zip", ".tar", ".gz", ".tgz", ".bz2", ".xz", ".7z", ".rar", ".jar", ".war", ".ear", ".lz4", ".zst",
+    ".app", ".msi", ".deb", ".rpm", ".node", ".rlib",
+    ".zip", ".tar", ".gz", ".tgz", ".bz2", ".xz", ".7z", ".rar", ".jar", ".war", ".ear", ".lz4", ".zst", ".z",
     ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff", ".tif", ".ico", ".heic", ".avif",
-    ".mp3", ".wav", ".flac", ".ogg", ".m4a", ".aac", ".mp4", ".mov", ".avi", ".mkv", ".webm", ".wmv", ".flv",
+    ".mp3", ".wav", ".flac", ".ogg", ".m4a", ".aac", ".wma", ".aiff", ".opus",
+    ".mp4", ".mov", ".avi", ".mkv", ".webm", ".wmv", ".flv", ".m4v", ".mpeg", ".mpg",
     ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".odt", ".ods", ".odp",
     ".woff", ".woff2", ".ttf", ".otf", ".eot",
-    ".db", ".sqlite", ".sqlite3", ".mdb", ".dat", ".pdb", ".ipa", ".apk", ".dmg", ".iso", ".img",
+    ".psd", ".ai", ".eps", ".sketch", ".fig", ".xd", ".blend", ".3ds", ".max", ".swf", ".fla",
+    ".db", ".sqlite", ".sqlite3", ".mdb", ".idx", ".dat", ".data", ".lockb",
+    ".pdb", ".ipa", ".apk", ".dmg", ".iso", ".img",
 ]);
 export function hasBinaryExtension(path) {
     const dot = path.lastIndexOf(".");
@@ -256,7 +263,7 @@ export function checkNoChange(oldString, newString) {
 }
 export function checkStale(entry, currentHash) {
     if (entry.hash !== currentHash) {
-        return { code: "stale", message: "File has been modified since it was read; read it again before editing." };
+        return { code: "stale", message: "File has been modified since read, either by the user or by a linter. Read it again before attempting to write it." };
     }
     return undefined;
 }
@@ -292,6 +299,95 @@ export function resolveQuoteMatch(content, oldString) {
         return undefined;
     return content.substring(idx, idx + oldString.length);
 }
+const UNICODE_ESCAPE_RE = /\\u[0-9a-fA-F]{4}/;
+const NON_ASCII_RE = /[\u0080-\uffff]/;
+function decodeUnicodeEscapes(s) {
+    return s.replace(/(\\\\)|\\u([0-9a-fA-F]{4})/g, (m, dbl, hex) => (dbl !== undefined ? m : String.fromCharCode(parseInt(hex, 16))));
+}
+function escapedSpellingPattern(s) {
+    let out = "";
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if (code >= 128) {
+            out += "\\\\u";
+            for (const d of code.toString(16).padStart(4, "0"))
+                out += d >= "a" ? `[${d}${d.toUpperCase()}]` : d;
+        }
+        else
+            out += s[i].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    return out;
+}
+export function resolveEscapeMatch(content, oldString) {
+    if (oldString === "")
+        return undefined;
+    if (UNICODE_ESCAPE_RE.test(oldString)) {
+        const decoded = decodeUnicodeEscapes(oldString);
+        if (decoded !== oldString && content.includes(decoded))
+            return decoded;
+    }
+    if (NON_ASCII_RE.test(oldString)) {
+        let hit = null;
+        try {
+            hit = content.match(new RegExp(escapedSpellingPattern(oldString)));
+        }
+        catch {
+            hit = null;
+        }
+        if (hit)
+            return hit[0];
+    }
+    return undefined;
+}
+export function adaptNewStringEscapes(oldString, matchedOld, newString) {
+    if (oldString === matchedOld)
+        return newString;
+    if (NON_ASCII_RE.test(oldString)) {
+        let full;
+        try {
+            full = new RegExp(`^${escapedSpellingPattern(oldString)}$`);
+        }
+        catch {
+            full = undefined;
+        }
+        if (full?.test(matchedOld)) {
+            const hexOf = new Map();
+            let upper = 0;
+            let lower = 0;
+            for (let i = 0, at = 0; i < oldString.length; i++) {
+                const code = oldString.charCodeAt(i);
+                if (code >= 128) {
+                    const hex = matchedOld.slice(at + 2, at + 6);
+                    hexOf.set(code, hex);
+                    for (const d of hex) {
+                        if (d >= "a" && d <= "f")
+                            lower++;
+                        else if (d >= "A" && d <= "F")
+                            upper++;
+                    }
+                    at += 6;
+                }
+                else
+                    at += 1;
+            }
+            return newString.replace(/[\u0080-\uffff]/g, (ch) => {
+                const code = ch.charCodeAt(0);
+                const known = hexOf.get(code);
+                if (known !== undefined)
+                    return `\\u${known}`;
+                const hex = code.toString(16).padStart(4, "0");
+                return `\\u${upper > lower ? hex.toUpperCase() : hex}`;
+            });
+        }
+    }
+    if (UNICODE_ESCAPE_RE.test(oldString) && decodeUnicodeEscapes(oldString) === matchedOld)
+        return decodeUnicodeEscapes(newString);
+    return newString;
+}
+export function escapeMatchWasAttempted(oldString) {
+    return UNICODE_ESCAPE_RE.test(oldString) || NON_ASCII_RE.test(oldString);
+}
+export const ESCAPE_MATCH_MISS_NOTE = "\n(note: Edit also tried swapping \\uXXXX escapes and their characters; neither form matched, so the mismatch is likely elsewhere in old_string. Re-read the file and copy the exact surrounding text.)";
 function isQuoteOpenerPosition(chars, i) {
     if (i === 0)
         return true;

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

@@ -21,6 +21,7 @@ export declare function splitAbsoluteGlobPattern(pattern: string): {
     relativePattern: string;
 } | undefined;
 export declare function shellQuote(s: string): string;
+export declare function invalidGlobTokens(glob: string): string[];
 export declare function gitignoreMatcher(content: string): (rel: string, isDir: boolean) => boolean;
 export declare function buildIgnore(env: ExecutionEnv, root: string, signal?: AbortSignal): Promise<(rel: string, isDir: boolean) => boolean>;
 export interface WalkResult {

package/dist/tools/fs/search.js

@@ -76,7 +76,7 @@ export function splitAbsoluteGlobPattern(pattern) {
 export function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-function globTokenToRegExp(token, anchored, glob = false) {
+function globTokenToRegExp(token, anchored, glob = false, report) {
     const charToRe = (ch) => ch === "*" ? "[^/]*" : ch === "?" ? "[^/]" : ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
     let re = "";
     for (let i = 0; i < token.length; i++) {
@@ -100,8 +100,11 @@ function globTokenToRegExp(token, anchored, glob = false) {
                 re += `(?:${alts.join("|")})`;
                 i = close;
             }
-            else
+            else {
                 re += "\\{";
+                if (report)
+                    report.degraded = true;
+            }
         }
         else if (glob && c === "[") {
             let j = i + 1;
@@ -129,14 +132,27 @@ function globTokenToRegExp(token, anchored, glob = false) {
                 re += cls;
                 i = close;
             }
-            else
+            else {
                 re += "\\[";
+                if (report)
+                    report.degraded = true;
+            }
         }
         else
             re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
     }
     return new RegExp(`${anchored ? "^" : "(^|/)"}${re}$`);
 }
+export function invalidGlobTokens(glob) {
+    const bad = [];
+    for (const token of splitGlobParam(glob)) {
+        const report = { degraded: false };
+        globTokenToRegExp(normalizeGlobToken(token), globIsAnchored(token), true, report);
+        if (report.degraded)
+            bad.push(token);
+    }
+    return bad;
+}
 function normalizeGlobToken(token) {
     let t = token;
     while (t.startsWith("./"))
@@ -1095,6 +1111,10 @@ export async function runGlobDetailed(env, root, pattern, opts = {}, signal) {
             const error = `Error (Glob): path ${JSON.stringify(opts.path)} does not exist — check the path, or omit \`path\` to search the whole root.`;
             return { text: error, error, filenames: [], numFiles: 0, truncated: false, durationMs: Date.now() - t0, totalMatches: 0, countIsComplete: false };
         }
+        if (probe.ok && probe.value.kind === "file") {
+            const error = `Error (Glob): path ${JSON.stringify(opts.path)} is not a directory — \`path\` scopes the search to a directory; pass its parent directory (and name the file in \`pattern\`), or omit \`path\` to search the whole root.`;
+            return { text: error, error, filenames: [], numFiles: 0, truncated: false, durationMs: Date.now() - t0, totalMatches: 0, countIsComplete: false };
+        }
     }
     const pat = normalizeGlobToken(pattern);
     const anchored = globIsAnchored(pattern);

package/dist/tools/monitor.d.ts

@@ -1,6 +1,7 @@
 import type { AgentTool, ExecutionEnv } from "../internal/harness-types.js";
 import { type MonitorTimers, type TaskRegistry } from "../core/task-registry.js";
 import type { TaskNotificationPayload } from "../core/task-notification.js";
+import type { ToolResultStore } from "../core/tool-result-store.js";
 export interface MonitorToolOptions {
     registry: TaskRegistry;
     owner?: string;
@@ -15,5 +16,6 @@ export interface MonitorToolOptions {
     timers?: MonitorTimers;
     batchWindowMs?: number;
     maxBatchesPerMinute?: number;
+    toolResultStore?: ToolResultStore;
 }
 export declare function createMonitorTool(env: ExecutionEnv, opts: MonitorToolOptions): AgentTool;

package/dist/tools/monitor.js

@@ -10,7 +10,7 @@ const MONITOR_DESCRIPTION = "Run a shell command in the background and watch its
     `exceeds its timeout is killed and reported (default ${MONITOR_DEFAULT_TIMEOUT_MS}ms, max ${MONITOR_MAX_TIMEOUT_MS}ms).\n` +
     "- stderr does NOT trigger notifications, but it is captured — read it any time with TaskOutput(task_id), " +
     "which also serves the full re-readable stdout spool.\n" +
-    "- A monitor that produces too many events is stopped automatically (the stop notification says why).\n" +
+    "- A monitor that produces too many events is rate-limited: excess batches are suppressed (a notification tells you how many), and a watch that stays over the limit is stopped automatically.\n" +
     "- Set persistent: true for a session-resident watch with no watch timeout of its own; it still ends when " +
     "the execution environment's background time budget expires, when you stop it with TaskStop(task_id), or " +
     "when the session is released.\n" +
@@ -82,6 +82,8 @@ export function createMonitorTool(env, opts) {
                     ...(opts.timers !== undefined ? { timers: opts.timers } : {}),
                     ...(opts.batchWindowMs !== undefined ? { batchWindowMs: opts.batchWindowMs } : {}),
                     ...(opts.maxBatchesPerMinute !== undefined ? { maxBatchesPerMinute: opts.maxBatchesPerMinute } : {}),
+                    ...(opts.sessionId !== undefined ? { sessionId: opts.sessionId } : {}),
+                    ...(opts.toolResultStore !== undefined ? { toolResultStore: opts.toolResultStore } : {}),
                 });
             }
             catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",
@@ -56,7 +56,8 @@
     "smoke": "tsx src/examples/smoke.ts",
     "eval": "tsx eval/run.ts",
     "prepare": "npm run build",
-    "prepublishOnly": "npm run build && npm run test"
+    "prepublishOnly": "npm run build && npm run test",
+    "gate:blackbox": "node scripts/run-blackbox-gate.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",