@sema-agent/core 2.13.0 → 4.0.0

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));
@@ -1008,7 +1011,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/data-plane.js

@@ -2,6 +2,7 @@ import { uuidv7 } from "../../internal/harness.js";
 import { firstSentence } from "../memory.js";
 import { computeEntryRev, parseEntryFile, serializeEntryFile } from "./frontmatter.js";
 import { scanMemoryFileName, scanMemoryWrite } from "./scan.js";
+import { MEMORY_INDEX_FILENAME } from "./file-backend.js";
 import { scopeDirName } from "./layout.js";
 export const REMOTE_HARVEST_PER_FILE_BYTES = 100 * 1024;
 export const REMOTE_MASS_DELETION_FUSE_RATIO = 0.5;
@@ -97,6 +98,9 @@ export function harvestFilesToPatches(baseline, files, opts = {}) {
             out.rejections.push({ path: f.relPath, code: "outside_root", reason: "file path escapes the memory root (containment gate, fail-closed)" });
             continue;
         }
+        const baseName = f.relPath.split("/").pop() ?? f.relPath;
+        if (baseName === MEMORY_INDEX_FILENAME || !baseName.endsWith(".md") || baseName.startsWith("."))
+            continue;
         if (inReadonlyDir(f.relPath)) {
             if (base === undefined) {
                 out.rejections.push({ path: f.relPath, code: "readonly_layer", reason: "a file inside a read-only inherited layer's directory is not writable from this session" });

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

@@ -56,10 +56,10 @@ export declare class MemoryEngine {
     };
     harvest(handle: MemorySessionHandle): Promise<HarvestReport>;
     private harvestCore;
-    rebaseline(handle: MemorySessionHandle): Promise<void>;
+    rebaseline(handle: MemorySessionHandle, keepBaseline?: ReadonlySet<string>): Promise<void>;
     private rebuildIndex;
     private committedContentFor;
-    private quarantineFile;
+    private gateDerivedIndex;
     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
 
@@ -147,6 +147,18 @@ export class MemoryEngine {
                 handle.baseIds.set(path, entry.id);
             }
         }
+        const indexGate = this.gateDerivedIndex(handle);
+        if (indexGate !== undefined) {
+            try {
+                enqueueMemoryAnnouncement(this.controlDir, {
+                    kind: "gate",
+                    at: this.now(),
+                    items: [`memory index rejected and rebuilt: ${inlineUntrusted(indexGate.reason)}`],
+                });
+            }
+            catch {
+            }
+        }
         const indexText = this.rebuildIndex(handle, headers, { write: writeScope !== null });
         handle.indexBaselineLines = countIndexLines(indexText);
         handle.indexText = indexText;
@@ -278,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 = [];
@@ -364,6 +378,7 @@ export class MemoryEngine {
                 basePathById.set(id, p);
         const patches = [];
         const pendingProjections = [];
+        const idsAddedThisHarvest = new Set();
         let processed = 0;
         for (let i = 0; i < kept.length; i++) {
             const f = kept[i];
@@ -401,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) {
@@ -465,7 +480,28 @@ export class MemoryEngine {
                 patches.push({ op: "update", id: parsed.id, entry: { ...entry, id: parsed.id, rev: computeEntryRev({ id: parsed.id, frontmatter: fm, body: parsed.body }) }, ...(revByBasePath.get(renamedFrom) !== undefined ? { baseRev: revByBasePath.get(renamedFrom) } : {}) });
                 continue;
             }
-            pendingProjections.push({ path: f.canonical, entry, needed: minted || needsCompletion(parsed, fm) });
+            let reboundId;
+            if (parsed.id !== undefined && (renamedFrom !== undefined || idsAddedThisHarvest.has(parsed.id))) {
+                reboundId = parsed.id;
+                const idless = serializeEntryFile({ id: "", frontmatter: fm, body: parsed.body }).replace(/^id:[ \t]*$\r?\n/m, "");
+                try {
+                    writeFileSync(f.canonical, idless, "utf8");
+                }
+                catch (err) {
+                    report.rejections.push({
+                        path: rel,
+                        code: "filename",
+                        reason: `memory write blocked: this file carries the entry id of another memory file (a copy is not a rename) and its frontmatter could not be rewritten (${err instanceof Error ? err.message : String(err)}) — remove the "id:" line so it can be committed as a new entry`,
+                    });
+                    continue;
+                }
+                id = uuidv7();
+                entry.id = id;
+                entry.rev = computeEntryRev(entry);
+                report.warnings.push(`${rel}: frontmatter id ${reboundId} already has a projection (${renamedFrom !== undefined ? relative(handle.memoryDir, renamedFrom) : "another new file in this harvest"}) — a copy is not a rename, so this file was committed as a NEW entry with a fresh id; the existing entry was left untouched`);
+            }
+            pendingProjections.push({ path: f.canonical, entry, needed: minted || reboundId !== undefined || needsCompletion(parsed, fm) });
+            idsAddedThisHarvest.add(entry.id);
             patches.push({ op: "add", id: entry.id, entry });
         }
         let patchReport;
@@ -503,12 +539,15 @@ export class MemoryEngine {
         const drained = this.backend.drainInboundFindings?.();
         if (drained !== undefined && drained.length > 0)
             report.inboundFindings = drained;
+        const indexRejection = this.gateDerivedIndex(handle);
+        if (indexRejection !== undefined)
+            report.rejections.push(indexRejection);
         const headers = await this.backend.listHeaders([...new Set([...handle.scopes, writeScope])]);
         handle.indexText = this.rebuildIndex(handle, headers, { write: true }, report.warnings);
-        await this.rebaseline(handle);
+        await this.rebaseline(handle, new Set(report.degraded?.pending ?? []));
         return report;
     }
-    async rebaseline(handle) {
+    async rebaseline(handle, keepBaseline = new Set()) {
         const writeScope = handle.writeScope;
         if (writeScope === null)
             return;
@@ -535,12 +574,17 @@ export class MemoryEngine {
             if (id === undefined)
                 continue;
             const stub = stubs.get(path);
-            const rev = revOfText(text, id);
+            const relPath = relative(handle.memoryDir, path);
+            const deferred = keepBaseline.has(relPath);
+            const priorRev = deferred ? handle.baseRevs.get(path) : undefined;
+            const priorId = deferred ? handle.baseIds.get(path) : undefined;
+            const rev = priorRev ?? revOfText(text, priorId ?? id);
+            const baselineId = priorId ?? id;
             next.push({
                 path,
-                relPath: relative(handle.memoryDir, path),
+                relPath,
                 scope: writeScope,
-                id,
+                id: baselineId,
                 slug: f.slug,
                 rev,
                 stub: stub !== undefined && stub.rev === rev,
@@ -548,7 +592,7 @@ export class MemoryEngine {
             });
             fileToScope.set(path, writeScope);
             baseRevs.set(path, rev);
-            baseIds.set(path, id);
+            baseIds.set(path, baselineId);
         }
         handle.materialized = next;
         handle.fileToScope = fileToScope;
@@ -650,34 +694,38 @@ export class MemoryEngine {
             return viaBackend;
         return readSafe(join(this.controlDir, "shadow", `${id}.md`));
     }
-    quarantineFile(path, content) {
-        const dest = join(this.controlDir, "quarantine", `${this.now()}-${basename(path)}`);
-        let captured;
-        let detail;
+    gateDerivedIndex(handle) {
+        if (handle.writeScope === null)
+            return undefined;
+        const indexPath = join(handle.writableRoot, MEMORY_INDEX_FILENAME);
+        const text = readSafe(indexPath);
+        if (text === undefined || text === "")
+            return undefined;
+        const finding = scanMemoryWrite(text).find((f) => f.code === "secret");
+        if (finding === undefined)
+            return undefined;
+        let detail = "";
         try {
-            mkdirSync(dirname(dest), { recursive: true });
-            writeFileSync(dest, content, "utf8");
-            captured = dest;
+            const dest = join(this.controlDir, QUARANTINE_DIR, `${this.now()}-${MEMORY_INDEX_FILENAME}`);
+            ensureDirExists(dirname(dest));
+            writeFileSync(dest, text, "utf8");
         }
         catch (err) {
-            detail = `quarantine copy failed: ${err instanceof Error ? err.message : String(err)}`;
+            detail = `; quarantine capture failed: ${err instanceof Error ? err.message : String(err)}`;
         }
-        let removed = false;
+        let cleared = false;
         try {
-            rmSync(path, { force: true });
-            removed = true;
+            writeFileSync(indexPath, "", "utf8");
+            cleared = 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)}`;
-            }
+        catch (err) {
+            detail = `${detail}; the derived index could NOT be cleared: ${err instanceof Error ? err.message : String(err)}`;
         }
-        return { ...(captured !== undefined ? { dest: captured } : {}), removed, ...(detail !== undefined ? { detail } : {}) };
+        return {
+            path: MEMORY_INDEX_FILENAME,
+            code: finding.code,
+            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}`,
+        };
     }
     readonlyDirNamesUnderRoot(handle) {
         const names = new Set();
@@ -722,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) {
@@ -739,6 +789,7 @@ export class MemoryEngine {
                     st = statSync(p);
                 }
                 catch {
+                    sweepSkipped.push(p);
                     continue;
                 }
                 if (st.isDirectory())
@@ -750,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,10 +26,10 @@ export declare class FileMemoryEngineBackend implements MemoryBackend {
     drainInboundFindings(): HarvestRejection[];
     readCommittedShadow(id: string): string | undefined;
     private shadowPath;
-    private quarantineFile;
     private loadLedger;
     private saveLedger;
     private recoverJournal;
+    private txnInFlight;
     private sweepStagedFiles;
     private excludedSubdirNames;
     private scopeDir;

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

@@ -1,11 +1,11 @@
-import { lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, openSync, writeSync, fsyncSync, closeSync } from "node:fs";
+import { lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, openSync, fsyncSync, closeSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { basename, dirname, join, relative } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { jaccardDistance, termSet } from "../memory-vector.js";
 import { MAX_MEMORY_BYTES } from "../memory.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { computeEntryRev, entryFromFile, isValidEntryId, parseEntryFile, serializeEntryFile } from "./frontmatter.js";
-import { ControlPlaneCorruptError, CURSORS_FILE, atomicWriteFileSync, claimRootScope, deriveControlPlaneDir, ensureDirExists, enqueueMemoryAnnouncement, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirName, } from "./layout.js";
+import { ControlPlaneCorruptError, CURSORS_FILE, QUARANTINE_DIR, atomicWriteFileSync, quarantineAndTombstone, claimRootScope, deriveControlPlaneDir, ensureDirExists, enqueueMemoryAnnouncement, registerScope, registeredScopes, resolveMemoryEngineRoot, scopeDirName, writeAllSync, } from "./layout.js";
 import { scanMemoryFileName, scanMemoryWrite } from "./scan.js";
 export const MEMORY_INDEX_FILENAME = "MEMORY.md";
 export const DEFAULT_MAX_ENTRY_DEPTH = 3;
@@ -18,6 +18,8 @@ export function scanEntryFiles(dir, opts = {}) {
             names = readdirSync(d);
         }
         catch {
+            if (d !== dir)
+                opts.onSkip?.(d, "unreadable");
             return;
         }
         for (const name of names.sort()) {
@@ -32,6 +34,7 @@ export function scanEntryFiles(dir, opts = {}) {
                 st = lstatSync(p);
             }
             catch {
+                opts.onSkip?.(p, "unreadable");
                 continue;
             }
             if (st.isSymbolicLink()) {
@@ -65,7 +68,6 @@ const TXN_LOCK_STALE_MS = 30_000;
 const TXN_LOCK_WAIT_MS = 15_000;
 const TXN_LOCK_STEAL_GRACE_MS = 250;
 const SHADOW_DIR = "shadow";
-const QUARANTINE_DIR = "quarantine";
 export class FileMemoryEngineBackend {
     directoryRoot;
     controlPlaneRoot;
@@ -79,10 +81,10 @@ export class FileMemoryEngineBackend {
         this.controlPlaneRoot = opts.controlDir ?? deriveControlPlaneDir(resolveMemoryEngineRoot(), dir);
         ensureDirExists(dir);
         ensureDirExists(this.controlPlaneRoot);
-        this.recoverJournal();
+        this.recoverJournal({ unlocked: true });
     }
     checkControlPlane() {
-        this.recoverJournal();
+        this.recoverJournal({ unlocked: true });
         this.ledger = undefined;
         this.loadLedger();
         registeredScopes(this.controlPlaneRoot);
@@ -98,35 +100,6 @@ export class FileMemoryEngineBackend {
     shadowPath(id) {
         return join(this.controlPlaneRoot, SHADOW_DIR, `${id}.md`);
     }
-    quarantineFile(path, content) {
-        const dest = join(this.controlPlaneRoot, QUARANTINE_DIR, `${Date.now()}-${basename(path)}`);
-        let captured;
-        let detail;
-        try {
-            ensureDirExists(dirname(dest));
-            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 } : {}) };
-    }
     loadLedger() {
         if (this.ledger)
             return this.ledger;
@@ -164,8 +137,10 @@ export class FileMemoryEngineBackend {
             return;
         atomicWriteFileSync(join(this.controlPlaneRoot, LEDGER_FILE), `${JSON.stringify(this.ledger, null, 2)}\n`);
     }
-    recoverJournal() {
+    recoverJournal(opts = {}) {
         const jp = join(this.controlPlaneRoot, JOURNAL_FILE);
+        if (opts.unlocked && this.txnInFlight())
+            return;
         const raw = readSafe(jp);
         if (raw !== undefined) {
             let journal;
@@ -205,6 +180,14 @@ export class FileMemoryEngineBackend {
         }
         this.sweepStagedFiles();
     }
+    txnInFlight() {
+        try {
+            return this.now() - statSync(this.txnLockDir()).mtimeMs < TXN_LOCK_STALE_MS;
+        }
+        catch {
+            return false;
+        }
+    }
     sweepStagedFiles() {
         const walk = (d, depth) => {
             let names;
@@ -268,12 +251,14 @@ export class FileMemoryEngineBackend {
         const ledger = sync ? this.loadLedger() : undefined;
         let ledgerChanged = false;
         const adoptedExternal = [];
+        const skippedUnreadable = [];
         for (const f of files) {
             let text;
             try {
                 text = readFileSync(f.path, "utf8");
             }
             catch {
+                skippedUnreadable.push(relative(this.directoryRoot, f.path));
                 continue;
             }
             const parsed = parseEntryFile(text);
@@ -302,7 +287,7 @@ export class FileMemoryEngineBackend {
                     }
                     if (finding) {
                         this.inboundFindings.push(finding);
-                        const q = this.quarantineFile(f.path, text);
+                        const q = quarantineAndTombstone(f.path, text, join(this.controlPlaneRoot, QUARANTINE_DIR), this.now);
                         const shadowText = committed !== undefined ? this.readCommittedShadow(entry.id) : undefined;
                         let restoredShadow = false;
                         if (shadowText !== undefined) {
@@ -368,6 +353,20 @@ export class FileMemoryEngineBackend {
             catch {
             }
         }
+        if (skippedUnreadable.length > 0) {
+            try {
+                enqueueMemoryAnnouncement(this.controlPlaneRoot, {
+                    kind: "external",
+                    at: this.now(),
+                    items: skippedUnreadable
+                        .slice(0, 12)
+                        .map((rel) => `committed memory entry could not be read and is MISSING from this session's memory: ${JSON.stringify(inlineUntrusted(rel))} — check the file (permissions/fs)`)
+                        .concat(skippedUnreadable.length > 12 ? [`…and ${skippedUnreadable.length - 12} more unreadable entr(ies)`] : []),
+                });
+            }
+            catch {
+            }
+        }
         if (!sync && this.batchScan !== undefined)
             this.batchScan.set(scope, entries);
         return entries;
@@ -448,7 +447,7 @@ export class FileMemoryEngineBackend {
                 try {
                     const fd = openSync(ownerPath, "w", 0o600);
                     try {
-                        writeSync(fd, token);
+                        writeAllSync(fd, token);
                         fsyncSync(fd);
                     }
                     finally {
@@ -574,7 +573,7 @@ export class FileMemoryEngineBackend {
             mkdirSync(dirname(op.target), { recursive: true });
             const fd = openSync(staged, "w", 0o600);
             try {
-                writeSync(fd, op.content);
+                writeAllSync(fd, op.content);
                 fsyncSync(fd);
             }
             finally {

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

@@ -23,6 +23,13 @@ export declare function scopeDirFor(memoryDir: string, controlDir: string, scope
 export declare function canonicalize(p: string): string;
 export declare function isContainedIn(root: string, child: string): boolean;
 export declare function ensureDirExists(dir: string): void;
+export declare const QUARANTINE_DIR = "quarantine";
+export interface QuarantineOutcome {
+    dest?: string;
+    removed: boolean;
+    detail?: string;
+}
+export declare function quarantineAndTombstone(path: string, content: string, quarantineDir: string, now: () => number): QuarantineOutcome;
 export declare const ANNOUNCEMENTS_FILE = "announcements.json";
 export declare const MEMORY_ANNOUNCEMENTS_MAX = 20;
 export declare const SCAN_FUSE_FILE = "scan-fuse.json";
@@ -39,5 +46,6 @@ export declare function readIndexRevs(controlDir: string): Record<string, string
 export declare function writeIndexRevs(controlDir: string, revs: Record<string, string>): void;
 export declare function scanFuseCount(controlDir: string, key: string): number;
 export declare function clearScanFuse(controlDir: string, keys: Iterable<string>): void;
+export declare function writeAllSync(fd: number, data: string): void;
 export declare function atomicWriteFileSync(path: string, data: string): void;
 export {};

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

@@ -1,7 +1,7 @@
-import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 const SCOPES_FILE = "scopes.json";
 export const CURSORS_FILE = "cursors.json";
 export class ControlPlaneCorruptError extends Error {
@@ -190,6 +190,52 @@ export function ensureDirExists(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true, mode: 0o700 });
 }
+export const QUARANTINE_DIR = "quarantine";
+const DELETED_TOMBSTONE = "---\ndeleted: true\n---\n";
+let quarantineSeq = 0;
+export function quarantineAndTombstone(path, content, quarantineDir, now) {
+    let captured;
+    let detail;
+    try {
+        ensureDirExists(quarantineDir);
+        const base = `${now()}-${basename(path)}`;
+        for (let attempt = 0; captured === undefined && attempt < 10; attempt++) {
+            const candidate = join(quarantineDir, attempt === 0 ? base : `${base}.${attempt}`);
+            try {
+                writeFileSync(candidate, content, { encoding: "utf8", flag: "wx" });
+                captured = candidate;
+            }
+            catch (err) {
+                if (!(err instanceof Error && "code" in err && err.code === "EEXIST"))
+                    throw err;
+            }
+        }
+        if (captured === undefined) {
+            const last = join(quarantineDir, `${base}.${process.pid}.${quarantineSeq++}`);
+            writeFileSync(last, content, { encoding: "utf8", flag: "wx" });
+            captured = last;
+        }
+    }
+    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, DELETED_TOMBSTONE, "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 } : {}) };
+}
 export const ANNOUNCEMENTS_FILE = "announcements.json";
 export const MEMORY_ANNOUNCEMENTS_MAX = 20;
 export const SCAN_FUSE_FILE = "scan-fuse.json";
@@ -216,11 +262,22 @@ function acquireSidecarLock(lockDir, opts = {}) {
         try {
             mkdirSync(lockDir);
             const token = `${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+            let fd;
             try {
-                writeSync(openSync(join(lockDir, "owner"), "w"), token);
+                fd = openSync(join(lockDir, "owner"), "w");
+                writeAllSync(fd, token);
             }
             catch {
             }
+            finally {
+                if (fd !== undefined) {
+                    try {
+                        closeSync(fd);
+                    }
+                    catch {
+                    }
+                }
+            }
             return token;
         }
         catch {
@@ -433,12 +490,22 @@ export function clearScanFuse(controlDir, keys) {
         return changed ? counts : undefined;
     });
 }
+export function writeAllSync(fd, data) {
+    const buf = Buffer.from(data, "utf8");
+    let written = 0;
+    while (written < buf.length) {
+        const n = writeSync(fd, buf, written, buf.length - written);
+        if (n <= 0)
+            throw new Error(`writeAllSync: write made no progress (${written}/${buf.length} bytes) — refusing to leave a truncated file`);
+        written += n;
+    }
+}
 export function atomicWriteFileSync(path, data) {
     ensureDirExists(dirname(path));
     const tmp = join(dirname(path), `.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`);
     const fd = openSync(tmp, "w", 0o600);
     try {
-        writeSync(fd, data);
+        writeAllSync(fd, data);
         fsyncSync(fd);
     }
     finally {