@sema-agent/core 5.0.1 → 5.1.0

package/dist/stores/cc/mailbox-store.d.ts

@@ -4,5 +4,9 @@ export interface CcFileMailboxStoreOptions {
     teamDir: string;
     agentNameOf?: (handle: string) => string | undefined;
     now?: () => number;
+    onCorruptRead?: (info: {
+        path: string;
+        reason: string;
+    }) => void;
 }
 export declare function createCcFileMailboxStore(opts: CcFileMailboxStoreOptions): MailboxStore;

package/dist/stores/cc/mailbox-store.js

@@ -27,19 +27,33 @@ export function createCcFileMailboxStore(opts) {
         const name = opts.agentNameOf?.(handle) ?? handle;
         return join(inboxDir, `${sanitizeCcAgentName(name)}.json`);
     };
+    const discloseCorrupt = (path, reason) => {
+        try {
+            opts.onCorruptRead?.({ path, reason });
+        }
+        catch {
+        }
+    };
     const loadBox = (path) => {
         let raw;
         try {
             raw = readFileSync(path, "utf8");
         }
-        catch {
+        catch (err) {
+            if (err.code !== "ENOENT")
+                discloseCorrupt(path, `read failed (non-ENOENT): ${err.message}`);
             return [];
         }
         try {
             const parsed = JSON.parse(raw);
-            return Array.isArray(parsed) ? parsed : [];
+            if (!Array.isArray(parsed)) {
+                discloseCorrupt(path, "inbox document is not an array");
+                return [];
+            }
+            return parsed;
         }
         catch {
+            discloseCorrupt(path, "unparseable inbox JSON (torn write?)");
             return [];
         }
     };

package/dist/stores/file/session-policy-store.d.ts

@@ -1,7 +1,16 @@
 import { type PutRulesOptions, type SessionPermissionRules, type SessionPolicyStore, type SessionRulesRecord, type StoredSessionRules } from "../../core/session-policy-store.js";
 export declare class FileSessionPolicyStore implements SessionPolicyStore {
     private readonly dir;
-    constructor(root: string);
+    private readonly onCorruptRead;
+    constructor(root: string, opts?: {
+        onCorruptRead?: (info: {
+            sessionId: string;
+            principal?: string;
+            path: string;
+            reason: string;
+        }) => void;
+    });
+    private discloseCorrupt;
     private pathFor;
     private read;
     getRules(sessionId: string, principal?: string): Promise<StoredSessionRules | null>;

package/dist/stores/file/session-policy-store.js

@@ -4,9 +4,18 @@ import { loosenReasons, normalizeRules, stripRev, SessionPolicyError, } from "..
 import { atomicWriteFile, ensureDir, sanitizeScope } from "./fs-atomic.js";
 export class FileSessionPolicyStore {
     dir;
-    constructor(root) {
+    onCorruptRead;
+    constructor(root, opts) {
         this.dir = join(root, "session-policy");
         ensureDir(this.dir);
+        this.onCorruptRead = opts?.onCorruptRead;
+    }
+    discloseCorrupt(sessionId, principal, reason) {
+        try {
+            this.onCorruptRead?.({ sessionId, ...(principal !== undefined ? { principal } : {}), path: this.pathFor(sessionId, principal), reason });
+        }
+        catch {
+        }
     }
     pathFor(sessionId, principal) {
         const composite = JSON.stringify([sessionId, principal ?? null]);
@@ -24,20 +33,27 @@ export class FileSessionPolicyStore {
         }
         try {
             const parsed = JSON.parse(raw);
-            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                this.discloseCorrupt(sessionId, principal, "not a JSON object");
                 return null;
+            }
             const r = parsed;
-            if (r.rev !== undefined && (typeof r.rev !== "number" || !Number.isFinite(r.rev)))
+            if (r.rev !== undefined && (typeof r.rev !== "number" || !Number.isFinite(r.rev))) {
+                this.discloseCorrupt(sessionId, principal, "non-numeric rev");
                 return null;
+            }
             const strArr = (x) => x === undefined || (Array.isArray(x) && x.every((e) => typeof e === "string"));
-            if (!strArr(r.toolAllow) || !strArr(r.toolDeny) || !strArr(r.commandAllow) || !strArr(r.commandDeny) || !strArr(r.allowDirs))
+            if (!strArr(r.toolAllow) || !strArr(r.toolDeny) || !strArr(r.commandAllow) || !strArr(r.commandDeny) || !strArr(r.allowDirs)) {
+                this.discloseCorrupt(sessionId, principal, "malformed rule field");
                 return null;
+            }
             const { __sid: _sid, __principal: _principal, ...clean } = r;
             void _sid;
             void _principal;
             return clean;
         }
         catch {
+            this.discloseCorrupt(sessionId, principal, "unparseable JSON (torn/zero-byte write?)");
             return null;
         }
     }

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

@@ -37,7 +37,6 @@ export function createGrepTool(env, rootCanonical, additionalRoots) {
                 description: 'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults to 250 when unspecified. Pass 0 for unlimited (use sparingly — large result sets waste context).',
             })),
             offset: Type.Optional(Type.Number({ description: "Skip the first N output lines (pagination partner of head_limit)." })),
-            max_results: Type.Optional(Type.Number({ description: "Deprecated alias for head_limit." })),
         }),
         effect: "read",
         execute: async (args, ctx) => {
@@ -69,7 +68,7 @@ export function createGrepTool(env, rootCanonical, additionalRoots) {
             const grepRun = await runGrepDetailed(env, rootCanonical, {
                 ...a,
                 path: scoped,
-                head_limit: a.head_limit ?? a.max_results,
+                head_limit: a.head_limit,
                 context: a.context ?? a["-C"],
                 context_after: a.context_after ?? a["-A"],
                 context_before: a.context_before ?? a["-B"],

package/dist/tools/fs/fs-shared.d.ts

@@ -43,7 +43,6 @@ export declare function bashTimeoutCapsSec(caps: {
 export declare function bashMaxOutputChars(): number;
 export declare const FILE_PATH_PARAMS: {
     file_path: Type.TOptional<Type.TString>;
-    path: Type.TOptional<Type.TString>;
 };
 export declare function clipShellOutput(s: string): string;
 export declare function writeShellOverflowFile(env: ExecutionEnv, stdout: string, stderr: string): Promise<string | undefined>;

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

@@ -77,7 +77,6 @@ export function bashMaxOutputChars() {
 }
 export const FILE_PATH_PARAMS = {
     file_path: Type.Optional(Type.String({ description: "File path (within the configured root)." })),
-    path: Type.Optional(Type.String({ description: "Deprecated alias for `file_path` (back-compat; prefer file_path)." })),
 };
 export function clipShellOutput(s) {
     return clipWithFilePointer(s, bashMaxOutputChars());

package/dist/tools/todo.js

@@ -76,7 +76,7 @@ export function createTodoWriteTool() {
             todos: Type.Array(Type.Object({
                 content: Type.String({ description: "The task, in imperative form (e.g. \"Run the tests\")." }),
                 status: Type.Union([Type.Literal("pending"), Type.Literal("in_progress"), Type.Literal("completed")]),
-                activeForm: Type.Optional(Type.String({ description: "Present-continuous form shown while in progress (e.g. \"Running the tests\")." })),
+                activeForm: Type.String({ minLength: 1, description: "Present-continuous form shown while in progress (e.g. \"Running the tests\")." }),
             })),
         }),
         effect: "idempotent",

package/package.json

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