@sema-agent/core 5.0.1 → 5.2.0

package/dist/orchestration/run-workflow-tool.js

@@ -338,16 +338,20 @@ export async function createRunWorkflowTool(d) {
                     catch (err) {
                         return structuredError(`failed to resolve workflow name: ${redactSecrets(err instanceof Error ? err.message : String(err)).slice(0, 300)}`);
                     }
+                    const resolvedShape = resolved;
+                    if (resolvedShape !== undefined && (resolvedShape === null || typeof resolvedShape !== "object")) {
+                        return structuredError("the wired workflow script store's resolveName returned the retired bare-string form — the resolution shape is now { script, defaultArgs? } (one shape); upgrade the store implementation");
+                    }
                 }
                 if (resolved === undefined && builtinsEnabled) {
                     resolved = resolveBuiltinWorkflow(rawName);
                 }
                 if (resolved === undefined)
                     return structuredError(`unknown workflow name: ${JSON.stringify(rawName)}`);
-                script = typeof resolved === "string" ? resolved : resolved.script;
-                if (typeof resolved !== "string" && "defaultArgs" in resolved)
+                script = resolved.script;
+                if ("defaultArgs" in resolved)
                     registeredDefaultArgs = resolved.defaultArgs;
-                if (typeof resolved !== "string" && typeof resolved.stringArgKey === "string" && resolved.stringArgKey.length > 0) {
+                if (typeof resolved.stringArgKey === "string" && resolved.stringArgKey.length > 0) {
                     registeredStringArgKey = resolved.stringArgKey;
                 }
             }

package/dist/orchestration/workflow-script-store.d.ts

@@ -12,7 +12,7 @@ export interface WorkflowScriptStore {
     readonly scopePartitioned: true;
     persist(runId: string, script: string, scope: string): Promise<string> | string;
     load(scriptPath: string, scope: string): Promise<string> | string;
-    resolveName?(name: string): Promise<string | NamedWorkflowResolution | undefined> | string | NamedWorkflowResolution | undefined;
+    resolveName?(name: string): Promise<NamedWorkflowResolution | undefined> | NamedWorkflowResolution | undefined;
     list?(): NamedWorkflowListing[] | Promise<NamedWorkflowListing[]>;
 }
 export declare function mergeWorkflowArgs(callArgs: unknown, defaultArgs: unknown): unknown;

package/dist/orchestration/workflow-script-store.js

@@ -95,7 +95,7 @@ export function createFileWorkflowScriptStore(dir) {
             const script = readFileSync(path, "utf-8");
             const argsPath = join(root, `${stem}.args.json`);
             if (!existsSync(argsPath))
-                return script;
+                return { script };
             let defaultArgs;
             try {
                 defaultArgs = JSON.parse(readFileSync(argsPath, "utf-8"));

package/dist/prompt-assembly/assemble.js

@@ -101,8 +101,6 @@ export function assemblePrompt(inputs) {
         userSystemPrompt: inputs.userSystemPrompt,
         userAppendSystemPrompt: inputs.userAppendSystemPrompt,
         tools: inputs.tools,
-        memoryEnabled: false,
-        consolidationEnabled: false,
         ...facts,
     };
     let pack = SEMA_DEFAULT_PACK;

package/dist/prompt-assembly/tool-catalog.d.ts

@@ -1,6 +1,7 @@
 import type { TSchema } from "typebox";
 import type { AgentTool } from "../internal/harness-types.js";
-export type ToolOrigin = "core" | "caller" | "mcp" | "synthetic";
+import type { ProtocolId } from "../core/protocol-table.js";
+export type ToolOrigin = "core" | "caller" | "synthetic" | ProtocolId;
 export interface ToolContractDescriptor {
     contractId: string;
     implementationRevision: string;

package/dist/prompts/default.d.ts

@@ -64,8 +64,6 @@ export interface StablePromptContext {
     userSystemPrompt?: string;
     userAppendSystemPrompt?: string;
     tools: AgentTool[];
-    memoryEnabled: boolean;
-    consolidationEnabled?: boolean;
     policyEnabled?: boolean;
     hooksEnabled?: boolean;
     isolationEnabled?: boolean;

package/dist/prompts/default.js

@@ -365,10 +365,6 @@ export function constitutionBlocks(ctx) {
         blocks.push({ id: "mode.worktree", text: WORKTREE_NOTICE });
     if (ctx.goalEnabled)
         blocks.push({ id: "mode.goal", text: GOAL_COMPLETION_GUIDANCE });
-    if (ctx.memoryEnabled)
-        blocks.push({ id: "memory.safety", text: MEMORY_SAFETY });
-    if (ctx.memoryEnabled && !ctx.consolidationEnabled)
-        blocks.push({ id: "memory.hygiene", text: MEMORY_HYGIENE });
     return blocks;
 }
 export function composeConstitution(roleBase, ctx) {
@@ -393,7 +389,7 @@ export function analyzePromptCacheFriendliness(provider, opts = {}) {
     const build = (memoryBlock) => {
         if (!provider.stableSystem)
             throw new Error("PromptProvider does not implement stableSystem");
-        return composeSystemPrompt(provider.stableSystem({ userSystemPrompt: opts.userSystemPrompt, tools, memoryEnabled: true }), memoryBlock);
+        return composeSystemPrompt(provider.stableSystem({ userSystemPrompt: opts.userSystemPrompt, tools }), memoryBlock);
     };
     const a = build(PROBE_MEMORY_A);
     const b = build(PROBE_MEMORY_B);

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,21 +27,73 @@ export function createCcFileMailboxStore(opts) {
         const name = opts.agentNameOf?.(handle) ?? handle;
         return join(inboxDir, `${sanitizeCcAgentName(name)}.json`);
     };
-    const loadBox = (path) => {
+    const discloseCorrupt = (path, reason) => {
+        try {
+            opts.onCorruptRead?.({ path, reason });
+        }
+        catch {
+        }
+    };
+    const deferredNotes = () => {
+        const pending = [];
+        return {
+            note: (path, reason) => {
+                pending.push({ path, reason });
+            },
+            flush: () => {
+                const batch = pending.splice(0, pending.length);
+                for (const n of batch)
+                    discloseCorrupt(n.path, n.reason);
+            },
+        };
+    };
+    const entryDefect = (e) => {
+        if (e === null)
+            return "null entry";
+        if (Array.isArray(e))
+            return "array entry";
+        if (typeof e !== "object")
+            return `${typeof e} entry`;
+        return undefined;
+    };
+    const loadBox = (path, note) => {
         let raw;
         try {
             raw = readFileSync(path, "utf8");
         }
-        catch {
+        catch (err) {
+            if (err.code !== "ENOENT")
+                note(path, `read failed (non-ENOENT): ${err.message}`);
             return [];
         }
+        let parsed;
         try {
-            const parsed = JSON.parse(raw);
-            return Array.isArray(parsed) ? parsed : [];
+            parsed = JSON.parse(raw);
         }
         catch {
+            note(path, "unparseable inbox JSON (torn write?)");
+            return [];
+        }
+        if (!Array.isArray(parsed)) {
+            note(path, "inbox document is not an array");
             return [];
         }
+        const kept = [];
+        let dropped = 0;
+        let firstReason;
+        for (const e of parsed) {
+            const defect = entryDefect(e);
+            if (defect === undefined) {
+                kept.push(e);
+                continue;
+            }
+            dropped += 1;
+            if (firstReason === undefined)
+                firstReason = defect;
+        }
+        if (dropped > 0)
+            note(path, `${dropped} malformed inbox entries skipped (first: ${firstReason})`);
+        return kept;
     };
     const saveBox = (path, box) => {
         atomicWriteFile(inboxDir, path, JSON.stringify(box, null, 2));
@@ -51,8 +103,9 @@ export function createCcFileMailboxStore(opts) {
             requireDefaultScope(scope);
             mkdirSync(inboxDir, { recursive: true });
             const path = inboxPath(handle);
+            const notes = deferredNotes();
             return withCcLock(path, () => {
-                const box = loadBox(path);
+                const box = loadBox(path, notes.note);
                 box.push({
                     type: "message",
                     ...(msg.from !== undefined ? { from: msg.from } : {}),
@@ -64,6 +117,8 @@ export function createCcFileMailboxStore(opts) {
                 });
                 saveBox(path, box);
                 return box.length;
+            }).finally(() => {
+                notes.flush();
             });
         },
         claimLease: (scope, handle, owner, ttlMs, now) => {
@@ -73,7 +128,7 @@ export function createCcFileMailboxStore(opts) {
             const held = leases.get(key);
             if (held !== undefined && held.expiresAt > t && held.owner !== owner)
                 return Promise.resolve(null);
-            const box = loadBox(key);
+            const box = loadBox(key, discloseCorrupt);
             const maxSeq = box.length;
             const pending = box
                 .map((e, i) => ({ e, seq: i + 1 }))
@@ -97,8 +152,9 @@ export function createCcFileMailboxStore(opts) {
                 return Promise.resolve();
             if (!existsSync(path))
                 return Promise.resolve();
+            const notes = deferredNotes();
             return withCcLock(path, () => {
-                const box = loadBox(path);
+                const box = loadBox(path, notes.note);
                 let changed = false;
                 for (let i = 0; i < Math.min(upToSeq, box.length); i++) {
                     if (box[i].read !== true) {
@@ -110,6 +166,8 @@ export function createCcFileMailboxStore(opts) {
                     saveBox(path, box);
                 if (held.maxSeq <= upToSeq)
                     leases.delete(path);
+            }).finally(() => {
+                notes.flush();
             });
         },
         releaseLease: (scope, handle, owner) => {
@@ -122,7 +180,7 @@ export function createCcFileMailboxStore(opts) {
         },
         peekCount: (scope, handle) => {
             requireDefaultScope(scope);
-            return Promise.resolve(loadBox(inboxPath(handle)).filter((e) => e.read !== true).length);
+            return Promise.resolve(loadBox(inboxPath(handle), discloseCorrupt).filter((e) => e.read !== true).length);
         },
         drop: (scope, handle) => {
             requireDefaultScope(scope);
@@ -146,7 +204,7 @@ export function createCcFileMailboxStore(opts) {
                 if (!f.endsWith(".json"))
                     continue;
                 const path = join(inboxDir, f);
-                const box = loadBox(path);
+                const box = loadBox(path, discloseCorrupt);
                 const newest = box.reduce((acc, e) => {
                     const t = typeof e.timestamp === "string" ? Date.parse(e.timestamp) : Number.NaN;
                     return Number.isFinite(t) ? Math.max(acc, t) : Number.POSITIVE_INFINITY;

package/dist/stores/file/file-snapshot-store.d.ts

@@ -1,5 +1,11 @@
 import type { ExecutionEnv } from "../../internal/harness-types.js";
 import { type FileSnapshotBounds, type FileSnapshotResult, type FileSnapshotStore } from "../../core/file-snapshot-store.js";
+export interface FileFileSnapshotStoreOptions {
+    onCorruptRead?: (info: {
+        path: string;
+        reason: string;
+    }) => void;
+}
 export declare class FileFileSnapshotStore implements FileSnapshotStore {
     private readonly base;
     private readonly blobsDir;
@@ -7,7 +13,9 @@ export declare class FileFileSnapshotStore implements FileSnapshotStore {
     private get inFlight();
     private readonly inFlightKey;
     private readonly bounds;
-    constructor(root: string, bounds?: Partial<FileSnapshotBounds>);
+    private readonly onCorruptRead;
+    constructor(root: string, bounds?: Partial<FileSnapshotBounds>, opts?: FileFileSnapshotStoreOptions);
+    private disclose;
     private scopeDir;
     private manifestPath;
     private tryManifestPath;

package/dist/stores/file/file-snapshot-store.js

@@ -18,7 +18,8 @@ export class FileFileSnapshotStore {
     }
     inFlightKey;
     bounds;
-    constructor(root, bounds) {
+    onCorruptRead;
+    constructor(root, bounds, opts) {
         this.base = join(root, "file-snapshots");
         this.blobsDir = join(this.base, "blobs");
         this.manifestsDir = join(this.base, "manifests");
@@ -30,6 +31,14 @@ export class FileFileSnapshotStore {
             maxBytes: bounds?.maxBytes ?? DEFAULT_SNAPSHOT_BOUNDS.maxBytes,
             ignoreDirs: new Set(bounds?.ignoreDirs ?? DEFAULT_SNAPSHOT_BOUNDS.ignoreDirs),
         };
+        this.onCorruptRead = opts?.onCorruptRead;
+    }
+    disclose(path, reason) {
+        try {
+            this.onCorruptRead?.({ path, reason });
+        }
+        catch {
+        }
     }
     scopeDir(scope) {
         return join(this.manifestsDir, sanitizeScope(scope));
@@ -60,9 +69,13 @@ export class FileFileSnapshotStore {
         }
         try {
             const parsed = JSON.parse(raw);
-            return Array.isArray(parsed) ? new Map(parsed) : null;
+            if (Array.isArray(parsed))
+                return new Map(parsed);
+            this.disclose(path, "manifest is not a pair array — read as no snapshot");
+            return null;
         }
         catch {
+            this.disclose(path, "unparseable manifest JSON (torn/zero-byte write?) — read as no snapshot");
             return null;
         }
     }
@@ -132,6 +145,7 @@ export class FileFileSnapshotStore {
         catch (err) {
             if (err.code === "ENOENT")
                 return [];
+            this.disclose(dir, `manifest scope directory unreadable (${err.code ?? "unknown"}) — listed as no keys`);
             return [];
         }
         return entries
@@ -242,8 +256,10 @@ export class FileFileSnapshotStore {
         catch (err) {
             if (err.code === "ENOENT")
                 entries = [];
-            else
+            else {
                 entries = [];
+                this.disclose(dir, `manifest scope directory unreadable (${err.code ?? "unknown"}) — the manifest-deletion pass was skipped`);
+            }
         }
         for (const file of entries) {
             if (!file.endsWith(".json"))
@@ -266,8 +282,10 @@ export class FileFileSnapshotStore {
         catch (err) {
             if (err.code === "ENOENT")
                 scopeDirs = [];
-            else
+            else {
+                this.disclose(this.manifestsDir, `manifest root unreadable (${err.code ?? "unknown"}) — blob GC aborted, every blob kept`);
                 return removed;
+            }
         }
         for (const scopeName of scopeDirs) {
             const sdir = join(this.manifestsDir, scopeName);
@@ -279,6 +297,7 @@ export class FileFileSnapshotStore {
                 if (err.code === "ENOENT")
                     continue;
                 complete = false;
+                this.disclose(sdir, `manifest scope directory unreadable (${err.code ?? "unknown"}) — blob GC aborted, every blob kept`);
                 break;
             }
             for (const file of files) {
@@ -287,6 +306,7 @@ export class FileFileSnapshotStore {
                 const m = this.readManifest(join(sdir, file));
                 if (!m) {
                     complete = false;
+                    this.disclose(join(sdir, file), "manifest unreadable during the live-set scan — blob GC aborted, every blob kept");
                     break;
                 }
                 for (const h of m.values())
@@ -301,7 +321,10 @@ export class FileFileSnapshotStore {
         try {
             blobs = readdirSync(this.blobsDir);
         }
-        catch {
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                this.disclose(this.blobsDir, `blob directory unreadable (${err.code ?? "unknown"}) — blob GC skipped, every blob kept`);
+            }
             return removed;
         }
         for (const blob of blobs) {

package/dist/stores/file/fs-atomic.d.ts

@@ -4,7 +4,10 @@ export declare function resolveDataRoot(explicit?: string): string;
 export declare function writeThenLink(target: string, content: string | Uint8Array): void;
 export declare function ensureDir(dir: string): void;
 export declare function atomicWriteFile(tmpDir: string, target: string, bytes: string): void;
-export declare function readJsonlRecords<T>(path: string): T[];
+export declare function readJsonlRecords<T>(path: string, onCorrupt?: (info: {
+    path: string;
+    reason: string;
+}) => void): T[];
 export declare function canonicalStoreKey(p: string): string;
 export declare class AppendLog {
     private fd;

package/dist/stores/file/fs-atomic.js

@@ -101,7 +101,7 @@ function basenameOf(p) {
 function dirnameOf(p) {
     return dirname(p);
 }
-export function readJsonlRecords(path) {
+export function readJsonlRecords(path, onCorrupt) {
     let raw;
     try {
         raw = readFileSync(path, "utf8");
@@ -126,6 +126,7 @@ export function readJsonlRecords(path) {
             out.push(JSON.parse(line));
         }
         catch {
+            onCorrupt?.({ path, reason: `unparseable jsonl record at line ${i + 1} (skipped; the rest of the replay is intact)` });
         }
     }
     return out;

package/dist/stores/file/index.d.ts

@@ -9,10 +9,10 @@ import type { FileSnapshotStore } from "../../core/file-snapshot-store.js";
 import type { WorkflowJournalStore } from "../../core/workflow-journal-store.js";
 export { FileCheckpointStore, type FileCheckpointStoreOptions } from "./checkpoint-store.js";
 export { FileMemoryStore } from "./memory-store.js";
-export { FileSessionRepo } from "./session-store.js";
+export { FileSessionRepo, type FileSessionRepoOptions } from "./session-store.js";
 export { FileToolResultStore } from "./tool-result-store.js";
-export { FileSessionPolicyStore } from "./session-policy-store.js";
-export { FileFileSnapshotStore } from "./file-snapshot-store.js";
+export { FileSessionPolicyStore, type FileSessionPolicyStoreOptions, type SessionPolicyCorruptReadInfo } from "./session-policy-store.js";
+export { FileFileSnapshotStore, type FileFileSnapshotStoreOptions } from "./file-snapshot-store.js";
 export { FileWorkflowJournalStore, MAX_JOURNAL_RESULT_BYTES, oversizeJournalResult } from "./workflow-journal-store.js";
 export { resolveDataRoot, sanitizeScope, sanitizePathComponent, createFileConsolidationLock } from "./fs-atomic.js";
 export { atomicWriteFile, writeThenLink, ensureDir, readJsonlRecords, AppendLog } from "./fs-atomic.js";
@@ -23,6 +23,13 @@ export interface FileStorageBackendOptions {
     checkpoint?: FileCheckpointStoreOptions;
     snapshotBounds?: Partial<import("../../core/file-snapshot-store.js").FileSnapshotBounds>;
     embedder?: import("../../core/memory.js").Embedder;
+    onCorruptRead?: (info: FileStorageCorruptReadInfo) => void;
+}
+export interface FileStorageCorruptReadInfo {
+    path: string;
+    reason: string;
+    sessionId?: string;
+    principal?: string;
 }
 export declare class FileStorageBackend {
     readonly root: string;

package/dist/stores/file/index.js

@@ -39,7 +39,8 @@ export class FileStorageBackend {
         this.lock = new BootLock(join(this.root, "LOCK"));
         this.lock.acquire();
         try {
-            const repo = new FileSessionRepo(this.root);
+            const corruptRead = opts.onCorruptRead !== undefined ? { onCorruptRead: opts.onCorruptRead } : undefined;
+            const repo = new FileSessionRepo(this.root, corruptRead);
             this.fileSessions = repo;
             this.ttl = new TtlSessionStore({ repo, evict: opts.evict ?? "forget" });
             this.sessionStore = this.ttl;
@@ -48,8 +49,8 @@ export class FileStorageBackend {
             this.fileMemory = new FileMemoryStore(this.root, opts.embedder ? { embedder: opts.embedder } : {});
             this.memoryStore = guardedMemoryStore(this.fileMemory, opts.utilityGate);
             this.toolResultStore = new FileToolResultStore(this.root);
-            this.sessionPolicyStore = new FileSessionPolicyStore(this.root);
-            this.fileSnapshotStore = new FileFileSnapshotStore(this.root, opts.snapshotBounds);
+            this.sessionPolicyStore = new FileSessionPolicyStore(this.root, corruptRead);
+            this.fileSnapshotStore = new FileFileSnapshotStore(this.root, opts.snapshotBounds, corruptRead);
             this.fileWorkflowJournal = new FileWorkflowJournalStore(this.root);
             this.workflowJournalStore = this.fileWorkflowJournal;
             this.consolidationLock = createFileConsolidationLock(join(this.root, "consolidation-locks"));

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

@@ -2,6 +2,10 @@ import { type MailboxAppendMessage, type MailboxLease, type MailboxStore } from
 export interface FileMailboxStoreOptions {
     fsync?: boolean;
     compactEvery?: number;
+    onCorruptRead?: (info: {
+        path: string;
+        reason: string;
+    }) => void;
 }
 export declare class FileMailboxStore implements MailboxStore {
     private readonly dir;
@@ -9,6 +13,7 @@ export declare class FileMailboxStore implements MailboxStore {
     private readonly fsyncEnabled;
     private readonly compactEvery;
     private readonly touched;
+    private readonly discloseCorrupt;
     constructor(root: string, opts?: FileMailboxStoreOptions);
     private boxPath;
     private lockKey;

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

@@ -39,9 +39,21 @@ export class FileMailboxStore {
     fsyncEnabled;
     compactEvery;
     touched = new Map();
+    discloseCorrupt;
     constructor(root, opts = {}) {
         this.fsyncEnabled = opts.fsync !== false;
         this.compactEvery = opts.compactEvery ?? 500;
+        const sink = opts.onCorruptRead;
+        this.discloseCorrupt =
+            sink === undefined
+                ? undefined
+                : (info) => {
+                    try {
+                        sink(info);
+                    }
+                    catch {
+                    }
+                };
         const lexicalDir = resolve(join(root, "mailboxes"));
         const lexicalTmp = resolve(join(root, "tmp"));
         ensureDir(lexicalDir);
@@ -67,7 +79,7 @@ export class FileMailboxStore {
             return b;
         }
         ensureDir(join(this.dir, sanitizeScope(scope)));
-        const events = readJsonlRecords(path);
+        const events = readJsonlRecords(path, this.discloseCorrupt);
         const state = { messages: [], nextSeq: 1, log: new AppendLog(path), events: events.length, refs: 1, path };
         for (const ev of events)
             applyEvent(state, ev);
@@ -145,7 +157,7 @@ export class FileMailboxStore {
             return 0;
         return withPathLock(this.lockKey(scope, handle), () => {
             const b = { messages: [], nextSeq: 1 };
-            for (const ev of readJsonlRecords(path))
+            for (const ev of readJsonlRecords(path, this.discloseCorrupt))
                 applyEvent(b, ev);
             return b.messages.length;
         });
@@ -200,7 +212,7 @@ export class FileMailboxStore {
                 if (sharedBoxes.has(key))
                     return false;
                 const b = { messages: [], nextSeq: 1 };
-                for (const ev of readJsonlRecords(path))
+                for (const ev of readJsonlRecords(path, this.discloseCorrupt))
                     applyEvent(b, ev);
                 const newest = newestSentAt(b.messages);
                 if (newest === undefined || newest >= now - maxAgeMs)

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

@@ -1,7 +1,19 @@
 import { type PutRulesOptions, type SessionPermissionRules, type SessionPolicyStore, type SessionRulesRecord, type StoredSessionRules } from "../../core/session-policy-store.js";
+export interface SessionPolicyCorruptReadInfo {
+    sessionId: string;
+    principal?: string;
+    path: string;
+    reason: string;
+}
+export interface FileSessionPolicyStoreOptions {
+    onCorruptRead?: (info: SessionPolicyCorruptReadInfo) => void;
+}
 export declare class FileSessionPolicyStore implements SessionPolicyStore {
     private readonly dir;
-    constructor(root: string);
+    private readonly onCorruptRead;
+    constructor(root: string, opts?: FileSessionPolicyStoreOptions);
+    private disclose;
+    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,21 @@ 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;
+    }
+    disclose(info) {
+        try {
+            this.onCorruptRead?.(info);
+        }
+        catch {
+        }
+    }
+    discloseCorrupt(sessionId, principal, reason) {
+        this.disclose({ sessionId, ...(principal !== undefined ? { principal } : {}), path: this.pathFor(sessionId, principal), reason });
     }
     pathFor(sessionId, principal) {
         const composite = JSON.stringify([sessionId, principal ?? null]);
@@ -24,20 +36,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;
         }
     }
@@ -74,15 +93,29 @@ export class FileSessionPolicyStore {
         for (const file of files) {
             if (!file.endsWith(".json"))
                 continue;
+            const full = join(this.dir, file);
+            let raw;
+            try {
+                raw = readFileSync(full, "utf8");
+            }
+            catch (err) {
+                if (err.code !== "ENOENT") {
+                    this.disclose({ sessionId, path: full, reason: `read failed (non-ENOENT): ${err.message}` });
+                }
+                continue;
+            }
             let parsed;
             try {
-                parsed = JSON.parse(readFileSync(join(this.dir, file), "utf8"));
+                parsed = JSON.parse(raw);
             }
             catch {
+                this.disclose({ sessionId, path: full, reason: "unparseable JSON (torn/zero-byte write?)" });
                 continue;
             }
-            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                this.disclose({ sessionId, path: full, reason: "not a JSON object" });
                 continue;
+            }
             const r = parsed;
             if (r.__sid !== sessionId)
                 continue;

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

@@ -1,9 +1,17 @@
 import type { Session, SessionForkOptions, SessionMetadata, SessionRepo, SessionTreeEntry } from "../../internal/harness.js";
+export interface FileSessionRepoOptions {
+    onCorruptRead?: (info: {
+        path: string;
+        reason: string;
+    }) => void;
+}
 export declare class FileSessionRepo implements SessionRepo {
     private readonly dir;
     private readonly tmpDir;
+    private readonly onCorruptRead;
     private readonly joined;
-    constructor(root: string);
+    constructor(root: string, opts?: FileSessionRepoOptions);
+    private disclose;
     private pathFor;
     private read;
     private storage;