@sema-agent/core 3.0.0 → 5.0.0

package/dist/core/checkpoint-store.d.ts

@@ -3,7 +3,8 @@ import type { RepairBundle } from "../agents/repair-loop.js";
 import type { WorkspaceHandle } from "./remote-env.js";
 import type { ConsolidationNote } from "./runner/memory-consolidation.js";
 import type { SessionPermissionRules } from "./session-policy-store.js";
-import type { TaskResult } from "./types.js";
+import type { NestedUsageAccum, TaskResult } from "./types.js";
+import type { ActiveWorktreeSession } from "../internal/harness-types.js";
 export type CheckpointToken = string & {
     readonly __brand: "CheckpointToken";
 };
@@ -112,12 +113,7 @@ export interface CheckpointState {
         value?: unknown;
         set?: boolean;
     };
-    nestedStats: {
-        tokens: number;
-        turns: number;
-        tasks: number;
-        costMicroUsd: number;
-    };
+    nestedStats: NestedUsageAccum;
     consolidationNotes?: ConsolidationNote[];
     readFileState?: Array<[string, ReadEntry]>;
     repairBundle?: RepairBundle;
@@ -131,12 +127,7 @@ export interface CheckpointState {
         description?: string;
     }>;
     handsCwd?: string;
-    activeWorktree?: {
-        worktreeDir: string;
-        originalCwd: string;
-        baseSha: string;
-        entered?: boolean;
-    };
+    activeWorktree?: ActiveWorktreeSession;
     inheritedGate?: {
         ancestorRules?: ReadonlyArray<{
             sessionId: string;
@@ -273,6 +264,8 @@ export declare function validatePendingSteer(steer: {
     text: string;
     trusted: boolean;
 };
+export declare function checkpointRowMatches(cp: Checkpoint | undefined, scope: string, status: Checkpoint["status"]): cp is Checkpoint;
+export declare function checkpointOccMatches(cp: Checkpoint, expect?: ResolveExpectation): boolean;
 export type CheckpointFaultMode = "resolve-after-commit" | "resolve-before-commit";
 export declare class InMemoryCheckpointStore implements CheckpointStore {
     private cps;

package/dist/core/checkpoint-store.js

@@ -237,6 +237,12 @@ export function validatePendingSteer(steer) {
     }
     return { text: steer.text, trusted: steer.trusted };
 }
+export function checkpointRowMatches(cp, scope, status) {
+    return cp !== undefined && cp.scope === scope && cp.status === status;
+}
+export function checkpointOccMatches(cp, expect) {
+    return expect === undefined || (cp.rev ?? 0) === expect.rev;
+}
 export class InMemoryCheckpointStore {
     cps = new Map();
     fault = null;
@@ -256,10 +262,10 @@ export class InMemoryCheckpointStore {
             throw new Error("injected fault: resolve before commit");
         }
         const cp = this.cps.get(token);
-        if (!cp || cp.scope !== scope || cp.status !== "pending") {
+        if (!checkpointRowMatches(cp, scope, "pending")) {
             return false;
         }
-        if (expect !== undefined && (cp.rev ?? 0) !== expect.rev) {
+        if (!checkpointOccMatches(cp, expect)) {
             return false;
         }
         cp.status = "resolved";
@@ -276,7 +282,7 @@ export class InMemoryCheckpointStore {
     }
     async reopen(token, scope, reason) {
         const cp = this.cps.get(token);
-        if (!cp || cp.scope !== scope || cp.status !== "resolved") {
+        if (!checkpointRowMatches(cp, scope, "resolved")) {
             return false;
         }
         cp.status = "pending";
@@ -287,7 +293,7 @@ export class InMemoryCheckpointStore {
     async setPendingSteer(token, scope, steer) {
         const clean = validatePendingSteer(steer);
         const cp = this.cps.get(token);
-        if (!cp || cp.scope !== scope || cp.status !== "pending") {
+        if (!checkpointRowMatches(cp, scope, "pending")) {
             return false;
         }
         cp.state.pendingSteer = clean;
@@ -295,7 +301,7 @@ export class InMemoryCheckpointStore {
     }
     async expire(token, scope) {
         const cp = this.cps.get(token);
-        if (!cp || cp.scope !== scope || cp.status !== "pending") {
+        if (!checkpointRowMatches(cp, scope, "pending")) {
             return false;
         }
         cp.status = "expired";

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

@@ -1,3 +1,5 @@
+declare function relUnder(root: string, child: string): string | null;
+declare function joinUnder(root: string, rel: string): string;
 import type { ExecutionEnv } from "../internal/harness-types.js";
 export interface FileSnapshotError {
     code: "too_large" | "enumerate_failed" | "read_failed" | "restore_failed" | "not_found" | "aborted";
@@ -51,3 +53,9 @@ export declare class InMemoryFileSnapshotStore implements FileSnapshotStore {
     importManifest(scope: string, key: string, manifest: Map<string, string>, srcGetBlob: (hash: string) => Promise<Uint8Array | undefined>): Promise<FileSnapshotResult>;
     reap(scope: string, keepKeys: string[]): Promise<number>;
 }
+export declare const __testables: {
+    joinUnder: typeof joinUnder;
+    relUnder: typeof relUnder;
+    stripTrailSep: (p: string) => string;
+};
+export {};

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

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
+import { isAbsolutePathForm, isWinFormPath } from "../tools/fs/safety.js";
 const normSlash = (p) => p.replace(/\\/g, "/");
-const stripTrailSep = (p) => p.replace(/[\\/]+$/, "");
+const stripTrailSep = (p) => (isWinFormPath(p) ? p.replace(/[\\/]+$/, "") : p.replace(/\/+$/, ""));
 const foldDrive = (p) => (/^[A-Za-z]:(\/|$)/.test(p) ? p[0].toLowerCase() + p.slice(1) : p);
-const isWinFormPath = (p) => /^[A-Za-z]:[\\/]/.test(p) || p.startsWith("\\\\") || (!p.startsWith("/") && p.includes("\\"));
 function relUnder(root, child) {
     const fold = isWinFormPath(root) ? normSlash : (p) => p;
     const r = foldDrive(fold(stripTrailSep(root)));
@@ -18,7 +18,7 @@ function joinUnder(root, rel) {
     return stripTrailSep(root) + (win ? "\\" : "/") + (win ? rel.replace(/\//g, "\\") : rel);
 }
 function isUnsafeRelPath(relN) {
-    return relN.startsWith("/") || /^[A-Za-z]:/.test(relN) || relN.split("/").includes("..");
+    return isAbsolutePathForm(relN) || /^[A-Za-z]:/.test(relN) || relN.split("/").includes("..");
 }
 export const DEFAULT_SNAPSHOT_BOUNDS = {
     maxFiles: 10000,
@@ -256,3 +256,4 @@ export class InMemoryFileSnapshotStore {
         return removed;
     }
 }
+export const __testables = { joinUnder, relUnder, stripTrailSep };

package/dist/core/fs-write-gate-policy.js

@@ -1,15 +1,14 @@
 import { canonicalizeTarget, writeTargetPath } from "../tools/fs/safety.js";
-import { canonicalToolName } from "./tool-name-aliases.js";
 import { PATH_WRITE_TOOLS, isWithin } from "./runner/session-rule-policy.js";
 const ask = (message) => ({ action: "ask", message, decisionReason: "rule" });
 export function createFsWriteGatePolicy(opts) {
     const { env, rootPath, defaultWrite } = opts;
-    const gated = new Set([...PATH_WRITE_TOOLS, "NotebookEdit"].map(canonicalToolName));
+    const gated = new Set([...PATH_WRITE_TOOLS, "NotebookEdit"]);
     const acceptDirs = opts.acceptDirs && opts.acceptDirs.length > 0 ? opts.acceptDirs : undefined;
     const exemptDirs = opts.exemptDirs && opts.exemptDirs.length > 0 ? opts.exemptDirs : undefined;
     return {
         async check(req, signal) {
-            const canonical = canonicalToolName(req.toolName);
+            const canonical = req.toolName;
             if (!gated.has(canonical))
                 return { action: "allow" };
             const path = writeTargetPath(canonical, req.args);

package/dist/core/hooks.d.ts

@@ -7,7 +7,9 @@ export interface Hooks {
     userPromptSubmit?(prompt: string): UserPromptSubmitResult | undefined | Promise<UserPromptSubmitResult | undefined>;
     stop?(ctx: StopHookContext): StopHookResult | undefined | Promise<StopHookResult | undefined>;
     postToolUseFailure?(toolName: string, input: unknown, failure: HookToolFailure, ctx: HookToolContext): PostToolUseFailureResult | undefined | Promise<PostToolUseFailureResult | undefined>;
-    postToolBatch?(batch: PostToolBatchCall[]): PostToolBatchResult | undefined | Promise<PostToolBatchResult | undefined>;
+    postToolBatch?(batch: PostToolBatchCall[], meta?: {
+        injectedThisTurn: "final_verification" | "finalize";
+    }): PostToolBatchResult | undefined | Promise<PostToolBatchResult | undefined>;
     preCompact?(ctx: PreCompactContext): PreCompactResult | undefined | Promise<PreCompactResult | undefined>;
     postCompact?(ctx: PostCompactContext): void | Promise<void>;
     stopFailure?(ctx: StopFailureContext): void | Promise<void>;
@@ -102,6 +104,7 @@ export interface ToolGateResult {
     preToolContext: string[];
 }
 export interface ToolGateInput {
+    onNotifyError?: (failure: import("./safe-notify.js").SafeNotifyFailure) => void;
     event: {
         toolCallId: string;
         toolName: string;

package/dist/core/hooks.js

@@ -1,6 +1,7 @@
 import { decisionText } from "./tool-policy.js";
 import { inlineUntrusted } from "./untrusted-text.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "./ask-question.js";
+import { createSafeNotifier } from "./safe-notify.js";
 export function cloneObserverInput(input) {
     try {
         return structuredClone(input);
@@ -23,12 +24,8 @@ function preToolUseCrashReason(subject, err) {
         `This is a failure of the deployment's hook, NOT of the tool itself — an identical retry reaches the ` +
         `same hook and fails the same way. Hook error: ${cause || "(no message)"}`);
 }
-function traceHookCrash(input, err) {
-    try {
-        input.onHookError?.(err);
-    }
-    catch {
-    }
+function traceHookCrash(input, err, notifier) {
+    notifier.notify(() => input.onHookError?.(err), "toolGate.onHookError");
 }
 function withProbeTimeout(p, ms, signal) {
     if (ms === undefined && signal === undefined)
@@ -62,6 +59,7 @@ export async function runToolGate(input) {
     let currentInput = event.input;
     const preToolContext = [];
     let hookAsk;
+    const notifier = createSafeNotifier(input.onNotifyError !== undefined ? { onError: input.onNotifyError } : undefined);
     if (preToolUse) {
         let r;
         try {
@@ -69,13 +67,9 @@ export async function runToolGate(input) {
         }
         catch (err) {
             const reason = preToolUseCrashReason(`this call to "${toolName}"`, err);
-            traceHookCrash(input, err);
+            traceHookCrash(input, err, notifier);
             if (input.permissionDenied) {
-                try {
-                    await input.permissionDenied({ toolName, input: cloneObserverInput(currentInput), toolCallId, reason, source: "hook" });
-                }
-                catch {
-                }
+                await notifier.notifyAsync(() => input.permissionDenied?.({ toolName, input: cloneObserverInput(currentInput), toolCallId, reason, source: "hook" }), "toolGate.permissionDenied");
             }
             return { block: true, reason: formatHookFeedback(reason), preToolContext };
         }
@@ -216,7 +210,7 @@ export async function runToolGate(input) {
                             hr = await preToolUse(toolName, editArgs, { toolCallId, toolName });
                         }
                         catch (err) {
-                            traceHookCrash(input, err);
+                            traceHookCrash(input, err, notifier);
                             editDenied = { action: "deny", reason: preToolUseCrashReason(`the approved edit for "${toolName}"`, err) };
                             denySource = "hook";
                             break;
@@ -288,11 +282,7 @@ export async function runToolGate(input) {
             currentInput = decision.updatedInput;
         }
         if (input.permissionDenied) {
-            try {
-                await input.permissionDenied({ toolName, input: cloneObserverInput(currentInput), toolCallId, reason: denyReason, source: denySource });
-            }
-            catch {
-            }
+            await notifier.notifyAsync(() => input.permissionDenied?.({ toolName, input: cloneObserverInput(currentInput), toolCallId, reason: denyReason, source: denySource }), "toolGate.permissionDenied");
         }
         return {
             block: true,

package/dist/core/lsp.js

@@ -1,4 +1,5 @@
 import { uriToPath } from "./lsp-protocol.js";
+import { foldRedundantPathSegments, isAbsolutePathForm } from "../tools/fs/safety.js";
 import { Type } from "typebox";
 import { defineTool, errorResult } from "./tools.js";
 export const LSP_OPERATIONS = [
@@ -67,10 +68,10 @@ export function settleOnAbort(job, signal, onAbort) {
     });
 }
 export function resolveLspPath(filePath, cwd) {
-    const isAbsForm = filePath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(filePath) || filePath.startsWith("\\\\");
+    const isAbsForm = isAbsolutePathForm(filePath);
     if (isAbsForm || !cwd)
-        return filePath;
-    return cwd.replace(/[\\/]+$/, "") + (cwd.includes("\\") ? "\\" : "/") + filePath;
+        return foldRedundantPathSegments(filePath);
+    return foldRedundantPathSegments(cwd.replace(/[\\/]+$/, "") + (cwd.includes("\\") ? "\\" : "/") + filePath);
 }
 export const MAX_LSP_FILE_BYTES = 10 * 1000 * 1000;
 function fmt(result, ctx) {

package/dist/core/mailbox-store.d.ts

@@ -8,12 +8,13 @@ export interface MailboxLease {
     messages: MailboxMessage[];
     maxSeq: number;
 }
+export interface MailboxAppendMessage {
+    from?: string;
+    content: string;
+    sentAt: number;
+}
 export interface MailboxStore {
-    append(scope: string, handle: string, msg: {
-        from?: string;
-        content: string;
-        sentAt: number;
-    }): Promise<number>;
+    append(scope: string, handle: string, msg: MailboxAppendMessage): Promise<number>;
     claimLease(scope: string, handle: string, owner: string, ttlMs: number, now?: number): Promise<MailboxLease | null>;
     ack(scope: string, handle: string, owner: string, upToSeq: number): Promise<void>;
     releaseLease(scope: string, handle: string, owner: string): Promise<void>;
@@ -28,11 +29,7 @@ export declare class InMemoryMailboxStore implements MailboxStore {
     private boxes;
     private key;
     private box;
-    append(scope: string, handle: string, msg: {
-        from?: string;
-        content: string;
-        sentAt: number;
-    }): Promise<number>;
+    append(scope: string, handle: string, msg: MailboxAppendMessage): Promise<number>;
     claimLease(scope: string, handle: string, owner: string, ttlMs: number, now?: number): Promise<MailboxLease | null>;
     ack(scope: string, handle: string, owner: string, upToSeq: number): Promise<void>;
     releaseLease(scope: string, handle: string, owner: string): Promise<void>;

package/dist/core/mcp.d.ts

@@ -8,6 +8,11 @@ export interface McpToolAxis {
     egress?: true;
     effect?: ToolEffect;
 }
+export interface McpDroppedTool {
+    server: string;
+    tool: string;
+    reason: string;
+}
 export interface MaterializedMcp {
     tools: AgentTool[];
     toolAxes: McpToolAxis[];
@@ -23,11 +28,7 @@ export interface MaterializedMcp {
         pendingRemovals: string[];
     };
     warnings: Error[];
-    droppedTools: Array<{
-        server: string;
-        tool: string;
-        reason: string;
-    }>;
+    droppedTools: McpDroppedTool[];
     statuses: McpServerStatus[];
     refresh: (server?: string) => Promise<McpRefreshResult[]>;
     dispose: () => Promise<void>;
@@ -41,11 +42,7 @@ export interface McpRefreshResult {
     removed: string[];
     tools?: AgentTool[];
     axes?: McpToolAxis[];
-    dropped?: Array<{
-        server: string;
-        tool: string;
-        reason: string;
-    }>;
+    dropped?: McpDroppedTool[];
     error?: string;
 }
 export interface McpServerStatus {

package/dist/core/mcp.js

@@ -7,6 +7,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { CallToolResultSchema, ElicitRequestSchema, ErrorCode, ListResourcesResultSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
 import { MCP_IMAGE_MAX_BASE64, sharpImageResizer } from "./image-downsample.js";
+import { sliceHeadSafe, sliceTailSafe } from "./surrogate-safe-slice.js";
 import { truncateError } from "./tool-errors.js";
 import { delimitUntrusted, inlineUntrusted, sanitizeUntrustedText } from "./untrusted-text.js";
 import { validateJsonSchemaShape } from "./runner/strict-output-schema.js";
@@ -75,8 +76,10 @@ export function truncateMcpErrorText(s) {
     let head = MCP_ERROR_HEAD_CHARS;
     let out = "";
     for (let i = 0; i < 4; i++) {
-        const removed = s.length - head - MCP_ERROR_TAIL_CHARS;
-        out = `${s.slice(0, head)}\n\n... [${removed} characters truncated] ...\n\n${s.slice(s.length - MCP_ERROR_TAIL_CHARS)}`;
+        const headText = sliceHeadSafe(s, head);
+        const tailText = sliceTailSafe(s, MCP_ERROR_TAIL_CHARS);
+        const removed = s.length - headText.length - tailText.length;
+        out = `${headText}\n\n... [${removed} characters truncated] ...\n\n${tailText}`;
         if (out.length <= max)
             break;
         head = Math.max(0, head - (out.length - max));
@@ -753,9 +756,6 @@ function applyCallerAxisOverride(name, hint, override) {
 const LIST_MCP_RESOURCES = "ListMcpResourcesTool";
 const READ_MCP_RESOURCE = "ReadMcpResourceTool";
 const READ_MCP_RESOURCE_DIR = "ReadMcpResourceDirTool";
-const LEGACY_LIST_MCP_RESOURCES = "ListMcpResources";
-const LEGACY_READ_MCP_RESOURCE = "ReadMcpResource";
-const LEGACY_READ_MCP_RESOURCE_DIR = "ReadMcpResourceDir";
 const MCP_SKILLS_EXTENSION = "io.modelcontextprotocol/skills";
 const MAX_DIR_READ_PAGES = 20;
 const DIR_READ_NOT_A_DIRECTORY_RE = /not a directory|isn'?t a directory|not a folder/i;
@@ -840,7 +840,6 @@ function buildResourceTools(resourceServers) {
     if (listable.length > 0) {
         tools.push({
             name: LIST_MCP_RESOURCES,
-            aliases: [LEGACY_LIST_MCP_RESOURCES],
             description: "List the resources available from connected MCP servers (uri / name / description). Pass `server` to limit " +
                 "to one server, or omit it to list across all. Resource metadata is external/untrusted data.",
             label: LIST_MCP_RESOURCES,
@@ -900,7 +899,6 @@ function buildResourceTools(resourceServers) {
     if (readable.length > 0) {
         tools.push({
             name: READ_MCP_RESOURCE,
-            aliases: [LEGACY_READ_MCP_RESOURCE],
             description: "Read a specific MCP resource by `server` + `uri` (from ListMcpResourcesTool). Its content is external/untrusted data.",
             label: READ_MCP_RESOURCE,
             executionMode: "parallel",
@@ -950,7 +948,6 @@ function buildResourceTools(resourceServers) {
     if (listable.length > 0) {
         tools.push({
             name: READ_MCP_RESOURCE_DIR,
-            aliases: [LEGACY_READ_MCP_RESOURCE_DIR],
             description: "List the MCP resources UNDER a directory `uri` on `server` — its child resources (those whose uri is " +
                 "nested below it; subdirectories carry mimeType \"inode/directory\"). Use it to browse a hierarchical " +
                 "resource namespace after ListMcpResourcesTool. Resource metadata is external/untrusted data.",
@@ -1008,7 +1005,8 @@ function buildResourceTools(resourceServers) {
                     const res = await rs.client
                         .listResources(undefined, { signal: watchdog.combinedSignal, timeout: timeoutMs })
                         .catch((err) => rethrowHonestMcpError(err, { server, what, timeoutMs, writeEffect: false, signal, attributeServer: true, idle: { signal: watchdog.idleSignal, idleMs } }));
-                    const children = res.resources.filter((r) => typeof r.uri === "string" && r.uri !== uri && r.uri.startsWith(uri));
+                    const dirPrefix = uri.endsWith("/") ? uri : `${uri}/`;
+                    const children = res.resources.filter((r) => typeof r.uri === "string" && r.uri !== uri && r.uri.startsWith(dirPrefix));
                     return renderDirChildren(server, uri, children);
                 }
                 finally {

package/dist/core/memory-engine/engine.d.ts

@@ -60,7 +60,6 @@ export declare class MemoryEngine {
     private rebuildIndex;
     private committedContentFor;
     private gateDerivedIndex;
-    private quarantineFile;
     private readonlyDirNamesUnderRoot;
     private writeIfChanged;
     private writeBackProjection;

package/dist/core/memory-engine/engine.js

@@ -1,12 +1,12 @@
 import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative, sep } from "node:path";
+import { dirname, join, relative, sep } from "node:path";
 import { uuidv7 } from "../../internal/harness.js";
 import { MAX_MEMORY_BYTES, composeMemoryBlock, firstSentence } from "../memory.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { formatMemoryAge } from "../memory-recall.js";
 import { computeEntryRev, parseEntryFile, serializeEntryFile } from "./frontmatter.js";
 import { DEFAULT_MAX_ENTRY_DEPTH, MEMORY_INDEX_FILENAME, scanEntryFiles } from "./file-backend.js";
-import { SCAN_FUSE_THRESHOLD, readIndexRevs, writeIndexRevs, bumpScanFuse, canonicalize, claimRootScope, clearScanFuse, deriveControlPlaneDir, drainMemoryAnnouncements, enqueueMemoryAnnouncement, ensureDirExists, isContainedIn, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirFor, } from "./layout.js";
+import { QUARANTINE_DIR, SCAN_FUSE_THRESHOLD, quarantineAndTombstone, readIndexRevs, writeIndexRevs, bumpScanFuse, canonicalize, claimRootScope, clearScanFuse, deriveControlPlaneDir, drainMemoryAnnouncements, enqueueMemoryAnnouncement, ensureDirExists, isContainedIn, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirFor, } from "./layout.js";
 import { scanMemoryFileName, scanMemoryWrite, scanRemediation } from "./scan.js";
 export const MEMORY_INSTRUCTION_TEMPLATE = `# Memory
 
@@ -290,6 +290,8 @@ export class MemoryEngine {
                     report.rejections.push({ path: rel, code: "symlink", reason: "symlinks are not harvested into memory (containment gate)" });
                 else if (kind === "depth")
                     report.rejections.push({ path: rel, code: "nested_too_deep", reason: `memory files nested deeper than ${this.maxDepth} levels are not harvested` });
+                else if (kind === "unreadable")
+                    report.rejections.push({ path: rel, code: "unreadable", reason: "the path could not be read (lstat/readdir failed) — its content was NOT harvested this pass" });
             },
         });
         const records = [];
@@ -414,7 +416,7 @@ export class MemoryEngine {
             scanFindings.push(...scanMemoryWrite(f.text));
             const finding = scanFindings[0];
             if (finding !== undefined) {
-                const q = this.quarantineFile(f.canonical, f.text);
+                const q = quarantineAndTombstone(f.canonical, f.text, join(this.controlDir, QUARANTINE_DIR), this.now);
                 let contained = q.removed;
                 const priorId = idByBasePath.get(f.canonical);
                 if (priorId !== undefined) {
@@ -704,8 +706,8 @@ export class MemoryEngine {
             return undefined;
         let detail = "";
         try {
-            const dest = join(this.controlDir, "quarantine", `${this.now()}-${MEMORY_INDEX_FILENAME}`);
-            mkdirSync(dirname(dest), { recursive: true });
+            const dest = join(this.controlDir, QUARANTINE_DIR, `${this.now()}-${MEMORY_INDEX_FILENAME}`);
+            ensureDirExists(dirname(dest));
             writeFileSync(dest, text, "utf8");
         }
         catch (err) {
@@ -725,35 +727,6 @@ export class MemoryEngine {
             reason: `memory index blocked: ${finding.reason} (${cleared ? "index cleared and rebuilt from entry frontmatter; the offending prose was captured to quarantine" : "index still carries the offending content"})${detail}`,
         };
     }
-    quarantineFile(path, content) {
-        const dest = join(this.controlDir, "quarantine", `${this.now()}-${basename(path)}`);
-        let captured;
-        let detail;
-        try {
-            mkdirSync(dirname(dest), { recursive: true });
-            writeFileSync(dest, content, "utf8");
-            captured = dest;
-        }
-        catch (err) {
-            detail = `quarantine copy failed: ${err instanceof Error ? err.message : String(err)}`;
-        }
-        let removed = false;
-        try {
-            rmSync(path, { force: true });
-            removed = true;
-        }
-        catch (rmErr) {
-            try {
-                writeFileSync(path, "---\ndeleted: true\n---\n", "utf8");
-                removed = true;
-                detail = `${detail !== undefined ? `${detail}; ` : ""}delete failed (${rmErr instanceof Error ? rmErr.message : String(rmErr)}) — tombstoned in place`;
-            }
-            catch (clearErr) {
-                detail = `${detail !== undefined ? `${detail}; ` : ""}suspect file could not be deleted or cleared: ${clearErr instanceof Error ? clearErr.message : String(clearErr)}`;
-            }
-        }
-        return { ...(captured !== undefined ? { dest: captured } : {}), removed, ...(detail !== undefined ? { detail } : {}) };
-    }
     readonlyDirNamesUnderRoot(handle) {
         const names = new Set();
         for (const [scope, dirName] of Object.entries(registeredScopes(this.controlDir))) {
@@ -797,12 +770,14 @@ export class MemoryEngine {
     chmodScopeTree(dir, dirMode, fileMode, opts = {}) {
         if (!existsSync(dir))
             return;
+        const sweepSkipped = [];
         const walk = (d, isRoot) => {
             let names = [];
             try {
                 names = readdirSync(d);
             }
             catch {
+                sweepSkipped.push(d);
                 return;
             }
             for (const name of names) {
@@ -814,6 +789,7 @@ export class MemoryEngine {
                     st = statSync(p);
                 }
                 catch {
+                    sweepSkipped.push(p);
                     continue;
                 }
                 if (st.isDirectory())
@@ -825,6 +801,20 @@ export class MemoryEngine {
                 chmodSafe(d, dirMode);
         };
         walk(dir, true);
+        if (sweepSkipped.length > 0) {
+            try {
+                enqueueMemoryAnnouncement(this.controlDir, {
+                    kind: "gate",
+                    at: this.now(),
+                    items: sweepSkipped
+                        .slice(0, 12)
+                        .map((p) => `mode sweep could not read ${JSON.stringify(inlineUntrusted(relative(dir, p) || "."))} — files under it keep their previous mode`)
+                        .concat(sweepSkipped.length > 12 ? [`…and ${sweepSkipped.length - 12} more sweepSkipped path(s)`] : []),
+                });
+            }
+            catch {
+            }
+        }
     }
 }
 const MAX_ANNOUNCEMENT_ITEMS = 12;

package/dist/core/memory-engine/file-backend.d.ts

@@ -9,7 +9,7 @@ export interface ScannedEntryFile {
 export declare function scanEntryFiles(dir: string, opts?: {
     maxDepth?: number;
     exclude?: ReadonlySet<string>;
-    onSkip?: (path: string, kind: "symlink" | "depth" | "nonmd" | "dotfile") => void;
+    onSkip?: (path: string, kind: "symlink" | "depth" | "nonmd" | "dotfile" | "unreadable") => void;
 }): ScannedEntryFile[];
 export declare class FileMemoryEngineBackend implements MemoryBackend {
     readonly directoryRoot: string;
@@ -26,7 +26,6 @@ export declare class FileMemoryEngineBackend implements MemoryBackend {
     drainInboundFindings(): HarvestRejection[];
     readCommittedShadow(id: string): string | undefined;
     private shadowPath;
-    private quarantineFile;
     private loadLedger;
     private saveLedger;
     private recoverJournal;