@sema-agent/core 2.0.1 → 2.1.0

package/dist/stores/file/workflow-journal-store.js

@@ -1,14 +1,18 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { callKeyOrdinal } from "../../core/workflow-journal-store.js";
 import { AppendLog } from "./fs-atomic.js";
 import { canonicalStoreKey, sanitizePathComponent } from "./fs-atomic.js";
 import { oversizeJournalResult } from "../../core/workflow-journal-store.js";
 export { MAX_JOURNAL_RESULT_BYTES, oversizeJournalResult } from "../../core/workflow-journal-store.js";
+export const RESUME_CLAIM_TTL_MS = 60 * 60 * 1000;
 const sharedJournalDirs = new Map();
+const MAX_OPEN_JOURNAL_LOGS = 64;
 export class FileWorkflowJournalStore {
     fsyncEnabled;
     dir;
+    claimsDir;
     shared;
     sharedKey;
     closed = false;
@@ -22,6 +26,7 @@ export class FileWorkflowJournalStore {
         this.fsyncEnabled = fsyncEnabled;
         this.dir = join(root, "workflow-journal");
         mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+        this.claimsDir = join(this.dir, "claims");
         this.sharedKey = canonicalStoreKey(this.dir);
         const existing = sharedJournalDirs.get(this.sharedKey);
         if (existing !== undefined) {
@@ -87,7 +92,22 @@ export class FileWorkflowJournalStore {
         let log = this.logs.get(runId);
         if (log === undefined) {
             log = new AppendLog(this.pathFor(runId));
-            this.logs.set(runId, log);
+        }
+        else {
+            this.logs.delete(runId);
+        }
+        this.logs.set(runId, log);
+        while (this.logs.size > MAX_OPEN_JOURNAL_LOGS) {
+            const coldest = this.logs.keys().next().value;
+            if (coldest === undefined || coldest === runId)
+                break;
+            const stale = this.logs.get(coldest);
+            this.logs.delete(coldest);
+            try {
+                stale?.close();
+            }
+            catch {
+            }
         }
         const line = { scope, ordinal: callKeyOrdinal(entry.callKey), callKey: entry.callKey, result: entry.result };
         log.append(line, this.fsyncEnabled);
@@ -98,6 +118,86 @@ export class FileWorkflowJournalStore {
             return [];
         return [...rec.byOrdinal.entries()].sort((a, b) => a[0] - b[0]).map(([, e]) => e);
     }
+    claimPathFor(sourceRunId, scope) {
+        const scopeTag = createHash("sha256").update(scope).digest("hex").slice(0, 16);
+        return join(this.claimsDir, `${sanitizePathComponent(sourceRunId)}.${scopeTag}.json`);
+    }
+    readClaim(path) {
+        if (!existsSync(path))
+            return undefined;
+        try {
+            const rec = JSON.parse(readFileSync(path, "utf8"));
+            if (typeof rec.holder !== "string" || typeof rec.expiresAt !== "number" || !Number.isFinite(rec.expiresAt)) {
+                return undefined;
+            }
+            return rec;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async resumeClaim(input) {
+        const { sourceRunId, newRunId, scope } = input;
+        let path;
+        try {
+            path = this.claimPathFor(sourceRunId, scope);
+        }
+        catch {
+            return { granted: true };
+        }
+        mkdirSync(this.claimsDir, { recursive: true, mode: 0o700 });
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const record = { sourceRunId, holder: newRunId, expiresAt: Date.now() + RESUME_CLAIM_TTL_MS };
+            try {
+                const fd = openSync(path, "wx", 0o600);
+                try {
+                    writeSync(fd, JSON.stringify(record));
+                }
+                finally {
+                    closeSync(fd);
+                }
+                return { granted: true };
+            }
+            catch (err) {
+                if (err.code !== "EEXIST")
+                    throw err;
+            }
+            const existing = this.readClaim(path);
+            if (existing !== undefined && existing.holder === newRunId) {
+                return { granted: true };
+            }
+            if (existing === undefined || existing.expiresAt <= Date.now()) {
+                try {
+                    unlinkSync(path);
+                }
+                catch {
+                }
+                continue;
+            }
+            return { granted: false, holder: existing.holder };
+        }
+        const winner = this.readClaim(path);
+        if (winner === undefined || winner.holder === newRunId)
+            return { granted: true };
+        return { granted: false, holder: winner.holder };
+    }
+    async releaseResumeClaim(input) {
+        let path;
+        try {
+            path = this.claimPathFor(input.sourceRunId, input.scope);
+        }
+        catch {
+            return;
+        }
+        const existing = this.readClaim(path);
+        if (existing === undefined || existing.holder !== input.newRunId)
+            return;
+        try {
+            unlinkSync(path);
+        }
+        catch {
+        }
+    }
     async deleteByRun(runId) {
         const log = this.logs.get(runId);
         if (log !== undefined) {

package/dist/tools/fs/bash-readonly-classifier.js

@@ -159,7 +159,7 @@ export function classifyCompoundReadonly(command, allow) {
         const deviceArgs = toks.slice(1).filter((t) => !t.startsWith("-")).map(normalizeAbsPathLexically).filter(isBlockedDevicePath);
         const rescuedByHead = headBoundIsSmall(name, toks) && deviceArgs.every((d) => GENERATOR_DEVICES.has(d));
         if (!rescuedByHead && deviceArgs.length > 0) {
-            return "an unbounded device source (/dev/zero, /dev/stdin, /proc/<pid>/fd/0, …) would block the pipeline until the tool timeout — not auto-allowed";
+            return "reads a device/special file that is either unbounded (/dev/zero, /dev/stdin, /proc/<pid>/fd/0, … — blocks the pipeline until the tool timeout) or process-private (/proc/<pid>/environ, /proc/<pid>/mem, …) — not auto-allowed";
         }
     }
     return undefined;

package/dist/tools/fs/fs-read.js

@@ -250,10 +250,10 @@ export function createReadFileTool(env, state, rootCanonical, cwdRef, additional
             }
             const truncated = start > 1 || end < total || pageMarker !== undefined;
             const prev = state.get(r.key);
-            if (total > 0 && prev?.seededFromContext && start === 1 && effLimit === undefined && prev.hash === hash) {
+            if (total > 0 && prev?.seededFromContext && !prev.isPartialView && start === 1 && effLimit === undefined && prev.hash === hash) {
                 return seededFileUnchangedReminder(r.key);
             }
-            if (total > 0 && prev && prev.hash === hash && prev.view && prev.view.start === start && prev.view.end === end) {
+            if (total > 0 && prev && !prev.isPartialView && prev.hash === hash && prev.view && prev.view.start === start && prev.view.end === end) {
                 return `[${path}: unchanged since you last read it (lines ${start}-${end} of ${total}); content omitted to save context]`;
             }
             state.set(r.key, {

package/dist/tools/fs/safety.js

@@ -38,17 +38,23 @@ const BLOCKED_DEVICE_PATHS = new Set([
     "/dev/stdin", "/dev/stdout", "/dev/stderr", "/dev/tty", "/dev/console",
     "/dev/fd/0", "/dev/fd/1", "/dev/fd/2",
 ]);
-const PROC_FD_RE = /^\/proc\/[^/]+\/fd\/[0-2]$/;
+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 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("\\"));
+}
 function isWinReservedDeviceKey(key) {
-    if (!(/^[A-Za-z]:[\\/]/.test(key) || key.startsWith("\\\\") || (!key.startsWith("/") && key.includes("\\"))))
+    if (!isWinFormPath(key))
         return false;
     const t = key.replace(/[\\/]+$/, "");
     const base = t.slice(Math.max(t.lastIndexOf("/"), t.lastIndexOf("\\")) + 1);
     return WIN_RESERVED_RE.test(base);
 }
 export function isBlockedDevicePath(key) {
-    return BLOCKED_DEVICE_PATHS.has(key) || PROC_FD_RE.test(key) || isWinReservedDeviceKey(key);
+    return BLOCKED_DEVICE_PATHS.has(key) || isProcStdioFd(key) || PROC_SENSITIVE_RE.test(key) || isWinReservedDeviceKey(key);
 }
 export function normalizeAbsPathLexically(p) {
     if (!p.startsWith("/"))
@@ -168,10 +174,11 @@ export async function resolveKey(env, rootCanonical, path, signal, baseCwd, addi
     return { ok: true, key };
 }
 export async function canonicalizeTarget(env, path, signal, baseCwd) {
-    if (isUncPath(path)) {
-        return { ok: false, message: `path "${path}" is a UNC/network path; refused (potential credential leak).` };
+    if (isUncPath(path) && isWinFormPath(path)) {
+        return { ok: true, key: path };
     }
-    const target = baseCwd && !isAbsolutePathForm(path) ? `${baseCwd.replace(/[\\/]+$/, "")}/${path}` : path;
+    const spelled = path.startsWith("//") ? path.replace(/^\/+/, "/") : path;
+    const target = baseCwd && !isAbsolutePathForm(spelled) ? `${baseCwd.replace(/[\\/]+$/, "")}/${spelled}` : spelled;
     const absR = await env.absolutePath(target, signal);
     if (!absR.ok)
         return { ok: false, message: `cannot resolve path "${path}": ${absR.error.message}` };

package/dist/tools/task-list.d.ts

@@ -20,5 +20,6 @@ export interface TaskListStore {
 }
 export declare function normalizeTaskShape<T>(item: T): T;
 export declare function assertJsonMetadata(value: unknown, path?: string): void;
+export declare function compareTaskIds(a: string, b: string): number;
 export declare function createMemoryTaskListStore(): TaskListStore;
 export declare function createTaskListTools(store?: TaskListStore): ToolSpec[];

package/dist/tools/task-list.js

@@ -55,6 +55,17 @@ export function assertJsonMetadata(value, path = "metadata") {
     }
     throw new Error(`Task ${path} must be JSON-serializable (found ${t === "object" ? "non-plain object" : t}).`);
 }
+export function compareTaskIds(a, b) {
+    const num = (id) => (/^\d+$/.test(id) ? Number.parseInt(id, 10) : Number.NaN);
+    const [na, nb] = [num(a), num(b)];
+    if (Number.isFinite(na) && Number.isFinite(nb))
+        return na - nb || a.localeCompare(b);
+    if (Number.isFinite(na))
+        return -1;
+    if (Number.isFinite(nb))
+        return 1;
+    return a.localeCompare(b);
+}
 export function createMemoryTaskListStore() {
     const tasks = new Map();
     let nextId = 1;
@@ -69,7 +80,7 @@ export function createMemoryTaskListStore() {
             tasks.set(id, snapTask(item));
         },
         delete: (id) => tasks.delete(id),
-        list: () => [...tasks.values()].map(snapTask),
+        list: () => [...tasks.values()].sort((a, b) => compareTaskIds(a.id, b.id)).map(snapTask),
         allocateId: () => String(nextId++),
     };
 }
@@ -133,7 +144,7 @@ export function createTaskListTools(store) {
             activeForm: Type.Optional(Type.String({ description: 'Present continuous form shown when in_progress (e.g., "Running tests")' })),
             metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Arbitrary metadata to attach to the task" })),
         }),
-        effect: "idempotent",
+        effect: "write",
         execute: (args) => serialized(tasks, async (tx) => {
             const a = args;
             if (a.metadata)

package/dist/tools/web.js

@@ -577,6 +577,13 @@ export function createWebFetchSummarizer(brain, model) {
 const DEFAULT_SEARCH_TIMEOUT_MS = 30_000;
 const SEARCH_ERROR_EXCERPT_CHARS = 2048;
 const SEARCH_QUERY_MAX_CHARS = 2_000;
+const DETAILS_QUERY_ECHO_MAX_CHARS = 500;
+function clipQueryEcho(query) {
+    const cps = [...query];
+    return cps.length > DETAILS_QUERY_ECHO_MAX_CHARS
+        ? cps.slice(0, DETAILS_QUERY_ECHO_MAX_CHARS).join("") + `…[${cps.length} chars total]`
+        : query;
+}
 function classifySearchFailure(message) {
     const m = message.toLowerCase();
     const status = /(?:\bhttp\b|\bstatus\b|\bcode\b|\berror\b)\D{0,12}?(\d{3})\b/.exec(m)?.[1];
@@ -619,6 +626,18 @@ function hostMatchesDomain(host, domain) {
         return false;
     return h === d || h.endsWith("." + d);
 }
+const URL_SCHEME_PREFIX = /^([a-z][a-z0-9+.-]*):/i;
+function normalizeResultUrl(raw) {
+    const s = raw.trim();
+    if (!s)
+        return { url: raw, schemeAssumed: false };
+    if (s.startsWith("//"))
+        return { url: "https:" + s, schemeAssumed: true };
+    const scheme = URL_SCHEME_PREFIX.exec(s)?.[1];
+    if (scheme !== undefined && !scheme.includes("."))
+        return { url: s, schemeAssumed: false };
+    return { url: "https://" + s, schemeAssumed: true };
+}
 function webSearchResultAllowed(url, allowed, blocked) {
     let host;
     try {
@@ -662,7 +681,7 @@ export function createWebSearchTool(config) {
             const startedAt = Date.now();
             const failCard = (extra = {}) => ({
                 type: "web-search",
-                query,
+                query: clipQueryEcho(query),
                 results: [],
                 durationSeconds: (Date.now() - startedAt) / 1000,
                 searchCount: 0,
@@ -723,13 +742,18 @@ export function createWebSearchTool(config) {
                 clearTimeout(timer);
                 ctx.signal?.removeEventListener("abort", onOuterAbort);
             }
-            const usable = results.filter((r) => webSearchResultAllowed(r.url));
-            const droppedUnusable = results.length - usable.length;
+            const normalized = results.map((r) => {
+                const n = normalizeResultUrl(r.url);
+                return { ...r, url: n.url, schemeAssumed: n.schemeAssumed };
+            });
+            const usable = normalized.filter((r) => webSearchResultAllowed(r.url));
+            const droppedUnusable = normalized.length - usable.length;
             const domainFiltered = usable.filter((r) => webSearchResultAllowed(r.url, allowed_domains, blocked_domains));
             const droppedByDomain = usable.length - domainFiltered.length;
-            results = domainFiltered.slice(0, max);
+            const kept = domainFiltered.slice(0, max);
+            const schemeAssumed = kept.filter((r) => r.schemeAssumed).length;
             let clipped = false;
-            const shown = results.map((r) => {
+            const shown = kept.map((r) => {
                 const title = clipCodePoints(r.title, SEARCH_TITLE_MAX_CHARS);
                 const url = clipCodePoints(r.url, MAX_URL_LENGTH);
                 const snippet = clipCodePoints(r.snippet, SEARCH_SNIPPET_MAX_CHARS);
@@ -750,7 +774,13 @@ export function createWebSearchTool(config) {
             const clipNote = clipped
                 ? "\n\n[WebSearch: one or more result fields exceeded the display limits and were truncated — treat the text above as an excerpt, not the backend's full result.]"
                 : "";
-            const modelText = `${fenced}${dropNote}${domainNote}${clipNote}\n\nREMINDER: You MUST include the sources above in your response to the user using markdown hyperlinks.`;
+            const schemeNote = schemeAssumed > 0
+                ? `\n\n[WebSearch: ${schemeAssumed} result(s) came back with no URL scheme (a bare domain or a protocol-relative URL) and are shown normalized to https:// — that scheme is this tool's assumption, not the backend's claim.]`
+                : "";
+            const tailReminder = shown.length > 0
+                ? "REMINDER: You MUST include the sources above in your response to the user using markdown hyperlinks."
+                : "REMINDER: this search returned ZERO usable sources — there is nothing above to cite. Do not fabricate sources, URLs or citations; tell the user the search returned no usable results (the notes above say why, when there is a why) and answer from what you already know, or try a different query.";
+            const modelText = `${fenced}${dropNote}${domainNote}${schemeNote}${clipNote}\n\n${tailReminder}`;
             return {
                 content: modelText,
                 details: {

package/package.json

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