@sema-agent/core 3.0.0 → 4.0.0

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));
@@ -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/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;

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;
@@ -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;
@@ -278,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);
@@ -312,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) {
@@ -378,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;
@@ -458,7 +447,7 @@ export class FileMemoryEngineBackend {
                 try {
                     const fd = openSync(ownerPath, "w", 0o600);
                     try {
-                        writeSync(fd, token);
+                        writeAllSync(fd, token);
                         fsyncSync(fd);
                     }
                     finally {
@@ -584,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";
@@ -219,7 +265,7 @@ function acquireSidecarLock(lockDir, opts = {}) {
             let fd;
             try {
                 fd = openSync(join(lockDir, "owner"), "w");
-                writeSync(fd, token);
+                writeAllSync(fd, token);
             }
             catch {
             }
@@ -444,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 {

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

@@ -1,5 +1,11 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { canonicalize } from "./layout.js";
+function pathSegmentsDualFamily(p) {
+    return p.split(/[\\/]/).filter(Boolean);
+}
+const CASE_INSENSITIVE_FS = process.platform === "darwin" || process.platform === "win32";
+const foldPathCase = (s) => (CASE_INSENSITIVE_FS ? s.toLowerCase() : s);
 export const SCOPE_SEGMENT_MAX_ENCODED = 64;
 const SEGMENT_SAFE = /^[A-Za-z0-9._-]$/;
 export function encodeScopeSegment(raw) {
@@ -117,9 +123,9 @@ export function assertScopeContractPlacement(args) {
     const personal = args.parsedScopes.filter(isCentralAuthorityScope);
     if (personal.length === 0)
         return;
-    const root = resolve(args.repoRoot);
-    const dir = resolve(args.memoryDir);
-    if (dir === root || dir.startsWith(root + "/")) {
+    const rootSegs = pathSegmentsDualFamily(canonicalize(resolve(args.repoRoot))).map(foldPathCase);
+    const dirSegs = pathSegmentsDualFamily(canonicalize(resolve(args.memoryDir))).map(foldPathCase);
+    if (rootSegs.length <= dirSegs.length && rootSegs.every((s, i) => s === dirSegs[i])) {
         const e = new Error(`memory scope contract v2: central-authority scope(s) ${personal
             .map((p) => `"${p.kind}"`)
             .join(", ")} cannot materialize into an IN-REPO memory dir (${args.memoryDir}) — ` +

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

@@ -88,7 +88,7 @@ export interface MemorySessionHandle {
     indexBaselineLines: number;
     indexText: string;
 }
-export type HarvestRejectionCode = "outside_root" | "symlink" | "secret" | "injection" | "filename" | "too_large" | "file_cap" | "readonly_layer" | "stub_modified" | "nested_too_deep" | "quarantine_failed" | "invalid";
+export type HarvestRejectionCode = "outside_root" | "symlink" | "secret" | "injection" | "filename" | "too_large" | "file_cap" | "readonly_layer" | "stub_modified" | "nested_too_deep" | "quarantine_failed" | "unreadable" | "invalid";
 export interface HarvestRejection {
     path: string;
     code: HarvestRejectionCode;

package/dist/core/runner/active-skill-scope.d.ts

@@ -16,7 +16,6 @@ export declare class ActiveSkillScope {
     active(): readonly ActiveSkillFrame[];
     get size(): number;
 }
-export declare function isWithin(root: string, p: string): boolean;
 export declare function createActiveSkillScopePolicy(opts: {
     scope: ActiveSkillScope;
     env: ExecutionEnv;

package/dist/core/runner/active-skill-scope.js

@@ -1,4 +1,5 @@
 import { canonicalizeTarget, fileArgPath } from "../../tools/fs/safety.js";
+import { PATH_WRITE_TOOLS, isWithin } from "./session-rule-policy.js";
 import { canonicalToolName } from "../tool-name-aliases.js";
 import { parseSkillToolEntry, skillSpecifierRejection } from "../skill-tool-specifier.js";
 export class ActiveSkillScope {
@@ -16,21 +17,6 @@ export class ActiveSkillScope {
         return this.frames.length;
     }
 }
-const PATH_WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit"]);
-export function isWithin(root, p) {
-    const norm = (x) => {
-        let n = x.replace(/\\/g, "/");
-        if (/^[A-Za-z]:(\/|$)/.test(n))
-            n = n[0].toLowerCase() + n.slice(1);
-        return n;
-    };
-    const r = norm(root);
-    const c = norm(p);
-    if (c === r)
-        return true;
-    const base = r.endsWith("/") ? r : r + "/";
-    return c.startsWith(base);
-}
 export function createActiveSkillScopePolicy(opts) {
     const { scope, env, rootPath, toolEffects } = opts;
     return {

package/dist/core/runner/assemble-result.d.ts

@@ -1,5 +1,5 @@
 import type { AssistantMessage } from "../../internal/llm.js";
-import type { TaskResult, TaskSpec } from "../types.js";
+import type { NestedUsage, TaskResult, TaskSpec } from "../types.js";
 export interface Stats {
     turns: number;
     tokens: number;
@@ -12,12 +12,7 @@ export interface Stats {
     cacheHitRate?: number;
     totalInputTokens: number;
     costMicroUsd: number;
-    nested?: {
-        tokens: number;
-        turns: number;
-        tasks: number;
-        costMicroUsd?: number;
-    };
+    nested?: NestedUsage;
     memory?: {
         tokens: number;
         costMicroUsd: number;

package/dist/core/runner/assemble-result.js

@@ -1,5 +1,4 @@
-import { DEGENERATE_MESSAGE } from "../../brain/repetition.js";
-import { WALLTIME_CUTOFF_MESSAGE } from "../../brain/walltime.js";
+import { isDegenerateCutMessage, isWalltimeCutMessage } from "../../brain/terminal-cause.js";
 import { extractErrorCode, stripErrorCodePrefix } from "../../brain/errors.js";
 export function errorCodeOf(err) {
     let cur = err;
@@ -54,8 +53,8 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     let checkpointToken;
     let checkpointGate;
     let workspaceRestoreMode;
-    const isDegenerate = final?.stopReason === "error" && final.errorMessage === DEGENERATE_MESSAGE;
-    const isWalltimeCutoff = final?.stopReason === "error" && final.errorMessage === WALLTIME_CUTOFF_MESSAGE;
+    const isDegenerate = final?.stopReason === "error" && isDegenerateCutMessage(final);
+    const isWalltimeCutoff = final?.stopReason === "error" && isWalltimeCutMessage(final);
     if (flags.outputInvalid) {
         status = "failed";
         errorCode = "output.invalid";

package/dist/core/runner/compaction-call-options.d.ts

@@ -0,0 +1,7 @@
+import { type TracerHook } from "../trace.js";
+import type { MaybeCompactOptions } from "../auto-compaction.js";
+import type { TaskSpec } from "../types.js";
+import type { Prepared } from "./prepare-task.js";
+export declare function buildWorkingFileAttachments(spec: TaskSpec, prepared: Prepared): MaybeCompactOptions["workingFileAttachments"];
+export declare function centerAdoptionOption(prepared: Prepared): Partial<Pick<MaybeCompactOptions, "centerAdoption">>;
+export declare function emitInputTruncated(tracer: TracerHook | undefined, taskId: string): NonNullable<MaybeCompactOptions["onInputTruncated"]>;

package/dist/core/runner/compaction-call-options.js

@@ -0,0 +1,30 @@
+import { emitTrace } from "../trace.js";
+export function buildWorkingFileAttachments(spec, prepared) {
+    if (spec.compaction?.attachWorkingFiles === false || !prepared.readTaskFile)
+        return undefined;
+    return {
+        readFile: prepared.readTaskFile,
+        ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
+        ...(prepared.normalizeAttachmentPath ? { normalizePath: prepared.normalizeAttachmentPath } : {}),
+        ...(prepared.isDedupStubResult ? { isDedupStubResult: prepared.isDedupStubResult } : {}),
+        ...(prepared.instructionSources
+            ? { instructionSourcePaths: prepared.instructionSources.filter((s) => s.contentHash !== null).map((s) => s.path) }
+            : {}),
+        ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
+    };
+}
+export function centerAdoptionOption(prepared) {
+    const ca = prepared.centerCompactionCandidate?.();
+    return ca !== undefined ? { centerAdoption: ca } : {};
+}
+export function emitInputTruncated(tracer, taskId) {
+    return (info) => emitTrace(tracer, () => ({
+        kind: "compaction.input_truncated",
+        version: 1,
+        taskId,
+        label: info.label,
+        droppedChars: info.droppedChars,
+        keptChars: info.keptChars,
+        ts: Date.now(),
+    }));
+}