@ai-dossier/sched 0.70.0 → 0.70.1-next.730.1

package/dist/persist.js

@@ -2,16 +2,16 @@
 /**
  * Crash-safe persistence for the scheduler core.
  *
- * `state.json` is written atomically: contents land in `state.json.tmp` in the
+ * `state.json` is written atomically: contents land in an exclusive temporary file in the
  * SAME directory (rename is atomic only within a filesystem), get fsynced, and
  * are renamed over `state.json`. A process killed between writes therefore
  * leaves either the previous complete state or the new one — never a partial
- * file (AC2). A stray `.tmp` is ignored by `load()` and overwritten by the
- * next write.
+ * file (AC2). Stray temporary files are ignored; publication never opens an
+ * existing temporary pathname that could alias evidence or block on a FIFO.
  *
- * Cross-process mutations are serialized by a directory mutex (`.sched-lock`),
- * the same acquire/release protocol as `packages/worktree-pool/src/pool-actions.ts`
- * (acquireLock/releaseLock there) — the two copies must be kept in lockstep.
+ * Reads/recovery and mutations share `.sched-lock`. Linux additionally pins a
+ * permanent kernel guard, so stale-owner observation and reclamation cannot race
+ * a new owner. Other platforms fail closed on stale locks (manual reconciliation).
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -46,12 +46,17 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchedStore = exports.CorruptStateError = exports.LockTimeoutError = void 0;
 exports.releaseOwnStateLock = releaseOwnStateLock;
 exports.writeAtomic = writeAtomic;
 exports.isEngineLeaseRace = isEngineLeaseRace;
-const fs = __importStar(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
 const path = __importStar(require("node:path"));
 const dispatch_1 = require("./dispatch");
 const journal_1 = require("./journal");
@@ -67,10 +72,12 @@ const ENGINE_LEASE_HOLDER_FILE = 'holder.json';
 /** Thrown when the cross-process lock cannot be acquired in time. */
 class LockTimeoutError extends Error {
     lockPath;
-    constructor(lockPath, heldByPid) {
+    constructor(lockPath, heldByPid, permanent = false) {
         const holder = heldByPid !== null ? `; held by pid ${heldByPid}` : ' (no pid file found)';
-        super(`Timed out waiting for scheduler lock (${LOCK_TIMEOUT_MS}ms)${holder}. ` +
-            `If that process is not running, remove ${lockPath}`);
+        super(permanent
+            ? `Timed out waiting for scheduler kernel guard (${LOCK_TIMEOUT_MS}ms): ${lockPath}. Retry or inspect the state-lock holder; never unlink or replace this permanent guard file.`
+            : `Timed out waiting for scheduler lock (${LOCK_TIMEOUT_MS}ms)${holder}. ` +
+                `If that process is not running, remove ${lockPath}`);
         this.name = 'LockTimeoutError';
         this.lockPath = lockPath;
     }
@@ -81,7 +88,8 @@ class CorruptStateError extends Error {
     constructor(filePath, cause) {
         const reason = cause instanceof Error ? cause.message : String(cause);
         super(`Scheduler state file is corrupt: ${filePath} (${reason}). ` +
-            'Rename or remove it to reset the queue — GitHub remains the system of record.');
+            'Preserve the original file as evidence; repair only the named record/field, then retry. ' +
+            'For invalid JSON repair the JSON syntax; for unsupported schemas use a compatible engine; for I/O failures restore file access. Do not reset the queue.');
         this.name = 'CorruptStateError';
         this.filePath = filePath;
     }
@@ -99,10 +107,10 @@ exports.CorruptStateError = CorruptStateError;
 function releaseOwnStateLock(dir) {
     const lockPath = path.join(dir, LOCK_DIR);
     try {
-        const pid = Number.parseInt(fs.readFileSync(path.join(lockPath, 'pid'), 'utf-8').trim(), 10);
+        const pid = Number.parseInt(node_fs_1.default.readFileSync(path.join(lockPath, 'pid'), 'utf-8').trim(), 10);
         if (pid !== process.pid)
             return false;
-        fs.rmSync(lockPath, { recursive: true, force: true });
+        node_fs_1.default.rmSync(lockPath, { recursive: true, force: true });
         return true;
     }
     catch {
@@ -112,93 +120,276 @@ function releaseOwnStateLock(dir) {
 /** Write `contents` to `filePath` atomically (tmp + fsync + rename, same directory). */
 function writeAtomic(filePath, contents) {
     const dir = path.dirname(filePath);
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    const tmp = `${filePath}.tmp`;
-    const fd = fs.openSync(tmp, 'w', 0o600);
+    node_fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const tmp = path.join(dir, `.state-write-${(0, node_crypto_1.randomUUID)()}`);
+    const fd = node_fs_1.default.openSync(tmp, node_fs_1.default.constants.O_WRONLY | node_fs_1.default.constants.O_CREAT | node_fs_1.default.constants.O_EXCL | node_fs_1.default.constants.O_NOFOLLOW, 0o600);
     try {
-        fs.writeFileSync(fd, contents, 'utf8');
-        fs.fsyncSync(fd);
+        try {
+            node_fs_1.default.writeFileSync(fd, contents, 'utf8');
+            node_fs_1.default.fsyncSync(fd);
+        }
+        finally {
+            node_fs_1.default.closeSync(fd);
+        }
+        node_fs_1.default.renameSync(tmp, filePath);
     }
     finally {
-        fs.closeSync(fd);
+        node_fs_1.default.rmSync(tmp, { force: true });
     }
-    fs.renameSync(tmp, filePath);
     // Best-effort directory fsync so the rename itself is durable. Not available
     // on every platform/fs — a failure here never blocks the write.
     try {
-        const dfd = fs.openSync(dir, 'r');
+        fsyncDirectory(dir);
+    }
+    catch {
+        // ignore
+    }
+}
+const QUARANTINE_DIR = 'quarantine';
+const QUARANTINE_MARKER = 'terminal-quarantine:';
+/** Build an entirely validated inert candidate BEFORE touching any evidence/state files. */
+function isolateTerminalBatches(data, evidence) {
+    if (!data || typeof data !== 'object')
+        throw new Error('Scheduler state must be an object');
+    const obj = data;
+    if (!Array.isArray(obj.batches) || !Array.isArray(obj.entries) || !Array.isArray(obj.slots)) {
+        throw new Error('Scheduler state must have batches, entries and slots arrays');
+    }
+    const ids = new Set();
+    const records = [];
+    const batches = obj.batches.map((batch, index) => {
+        // Even a bad record must have one unambiguous identity. Never recover duplicates.
+        if (!batch || typeof batch.id !== 'string' || !batch.id || ids.has(batch.id)) {
+            throw new Error(`batches[${index}]: missing or duplicate batch id`);
+        }
+        ids.add(batch.id);
+        try {
+            (0, state_1.validateBatchRecord)(batch, obj.entries);
+            return batch;
+        }
+        catch (err) {
+            const reason = `batches[${index}] (id ${JSON.stringify(batch.id)}): ${err.message}`;
+            if (!types_1.TERMINAL_BATCH_STATUSES.has(batch.status))
+                throw new Error(reason);
+            const references = obj.entries.filter((entry) => entry?.batch === batch.id);
+            if (references.some((entry) => !types_1.TERMINAL_ISSUE_STATUSES.has(entry.status))) {
+                throw new Error(`${reason}; active/parked entry references this batch — repair only this record`);
+            }
+            const unit = (0, state_1.batchUnit)(batch.id);
+            if (obj.slots.some((slot) => slot?.status !== 'idle' &&
+                (slot?.unit === unit ||
+                    (typeof slot?.unit === 'string' && slot.unit.startsWith(`${unit}#`))))) {
+                throw new Error(`${reason}; held batch/member slot — repair only this record`);
+            }
+            records.push({ index, id: batch.id, reason });
+            return {
+                ...(0, state_1.createBatch)(batch.id, references.map((entry) => entry.issue), new Date(0)),
+                status: batch.status,
+                blocked_reason: `${QUARANTINE_MARKER}${evidence}; ${reason}; original cleanup obligations require record-local reconciliation`,
+            };
+        }
+    });
+    // Also checks schema, entries, slots, referential integrity and all global fields.
+    // A terminal exception must never hide independently corrupt active/global state.
+    return { state: (0, state_1.validateState)({ ...obj, batches }), records };
+}
+function fsyncDirectory(dir) {
+    const fd = node_fs_1.default.openSync(dir, 'r');
+    try {
+        node_fs_1.default.fsyncSync(fd);
+    }
+    finally {
+        node_fs_1.default.closeSync(fd);
+    }
+}
+/** Mandatory durable evidence; existing digest files are verified, never overwritten. */
+function preserveQuarantine(dir, digest, raw, records) {
+    const evidenceDir = path.join(dir, QUARANTINE_DIR);
+    node_fs_1.default.mkdirSync(evidenceDir, { recursive: true, mode: 0o700 });
+    if (!node_fs_1.default.lstatSync(evidenceDir).isDirectory() || node_fs_1.default.lstatSync(evidenceDir).isSymbolicLink()) {
+        throw new Error(`quarantine directory is not a store-owned directory: ${evidenceDir}`);
+    }
+    const manifest = Buffer.from(`${JSON.stringify({ digest, state_file: STATE_FILE, records }, null, 2)}\n`);
+    for (const [name, bytes] of [
+        [`${digest}.json`, raw],
+        [`${digest}.manifest.json`, manifest],
+    ]) {
+        const target = path.join(evidenceDir, name);
+        let present = true;
         try {
-            fs.fsyncSync(dfd);
+            node_fs_1.default.lstatSync(target);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+            present = false;
+        }
+        if (!present) {
+            const tmp = path.join(evidenceDir, `.pending-${(0, node_crypto_1.randomUUID)()}`);
+            const fd = node_fs_1.default.openSync(tmp, node_fs_1.default.constants.O_WRONLY |
+                node_fs_1.default.constants.O_CREAT |
+                node_fs_1.default.constants.O_EXCL |
+                node_fs_1.default.constants.O_NOFOLLOW, 0o600);
+            try {
+                try {
+                    node_fs_1.default.writeFileSync(fd, bytes);
+                    node_fs_1.default.fsyncSync(fd);
+                }
+                finally {
+                    node_fs_1.default.closeSync(fd);
+                }
+                node_fs_1.default.renameSync(tmp, target);
+            }
+            finally {
+                node_fs_1.default.rmSync(tmp, { force: true });
+            }
+        }
+        const fd = node_fs_1.default.openSync(target, node_fs_1.default.constants.O_RDONLY | node_fs_1.default.constants.O_NOFOLLOW | node_fs_1.default.constants.O_NONBLOCK);
+        try {
+            if (!node_fs_1.default.fstatSync(fd).isFile() || !node_fs_1.default.readFileSync(fd).equals(bytes)) {
+                throw new Error(`quarantine evidence verification failed: ${target}`);
+            }
+            node_fs_1.default.fsyncSync(fd);
         }
         finally {
-            fs.closeSync(dfd);
+            node_fs_1.default.closeSync(fd);
         }
     }
-    catch {
-        // ignore
+    fsyncDirectory(evidenceDir);
+    fsyncDirectory(dir); // makes the new quarantine directory durable too
+}
+// --- State mutex ---
+const stateGuards = new Map();
+/** Same inherited-open-description flock primitive as zero-trust/lock.ts.
+ * That private workspace cannot be a dependency of the published scheduler.
+ * The guard inode is permanent: never unlink/replace it, including after a crash.
+ */
+function acquireStateGuard(dir) {
+    if (process.platform !== 'linux')
+        return null;
+    const file = path.join(dir, `${LOCK_DIR}.guard`);
+    const fd = node_fs_1.default.openSync(file, node_fs_1.default.constants.O_RDWR | node_fs_1.default.constants.O_CREAT | node_fs_1.default.constants.O_NOFOLLOW | node_fs_1.default.constants.O_NONBLOCK, 0o600);
+    try {
+        const stat = node_fs_1.default.fstatSync(fd);
+        if (!stat.isFile() || stat.nlink !== 1 || stat.uid !== process.getuid?.()) {
+            throw new Error(`Scheduler lock guard must be a private regular file: ${file}`);
+        }
+        const result = (0, node_child_process_1.spawnSync)('/usr/bin/flock', ['-x', '-w', String(LOCK_TIMEOUT_MS / 1000), '3'], {
+            stdio: ['ignore', 'ignore', 'ignore', fd],
+            timeout: LOCK_TIMEOUT_MS + 1000,
+        });
+        if (result.error)
+            throw new Error(`Could not acquire scheduler kernel guard (${file}): ${result.error.message}`);
+        if (result.status !== 0)
+            throw new LockTimeoutError(file, null, true);
+        const named = node_fs_1.default.lstatSync(file);
+        if (named.dev !== stat.dev || named.ino !== stat.ino)
+            throw new Error(`Scheduler lock guard changed: ${file}`);
+        return fd;
+    }
+    catch (err) {
+        node_fs_1.default.closeSync(fd);
+        throw err;
     }
 }
-// --- Lock (directory mutex, worktree-pool protocol) ---
 function acquireLock(dir) {
+    dir = path.resolve(dir);
     const lockPath = path.join(dir, LOCK_DIR);
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    const start = Date.now();
-    let heldByPid = null;
-    while (true) {
-        try {
-            fs.mkdirSync(lockPath);
-            fs.writeFileSync(path.join(lockPath, 'pid'), String(process.pid), { mode: 0o600 });
-            return;
-        }
-        catch {
-            heldByPid = null;
+    node_fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const guard = acquireStateGuard(dir);
+    try {
+        const start = Date.now();
+        let heldByPid = null;
+        while (true) {
             try {
-                const pidFile = path.join(lockPath, 'pid');
-                if (fs.existsSync(pidFile)) {
-                    const lockPid = Number.parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-                    heldByPid = Number.isNaN(lockPid) ? null : lockPid;
-                    try {
-                        process.kill(lockPid, 0);
-                    }
-                    catch {
-                        // Recorded holder is dead. Take the stale lock over by RENAMING it
-                        // first: with two contenders both seeing the dead pid, only one
-                        // rename succeeds — the loser's rmSync cannot delete the winner's
-                        // freshly-acquired lock (the plain rmSync-race the pool protocol
-                        // inherits from its original mkdir-mutex).
-                        const stale = `${lockPath}.stale-${process.pid}-${Date.now()}`;
-                        try {
-                            fs.renameSync(lockPath, stale);
-                        }
-                        catch {
-                            // another contender already took it over — fall through to retry
-                        }
+                // Publish ownership atomically; a killed pending writer cannot leave a
+                // public PID-less mutex. Pending names are inert and never reclaimed.
+                const pending = path.join(dir, `${LOCK_DIR}.pending-${(0, node_crypto_1.randomUUID)()}`);
+                node_fs_1.default.mkdirSync(pending, { mode: 0o700 });
+                try {
+                    node_fs_1.default.writeFileSync(path.join(pending, 'pid'), String(process.pid), { mode: 0o600 });
+                    node_fs_1.default.renameSync(pending, lockPath);
+                }
+                catch (err) {
+                    node_fs_1.default.rmSync(pending, { recursive: true, force: true });
+                    throw err;
+                }
+                if (guard !== null)
+                    stateGuards.set(dir, guard);
+                return;
+            }
+            catch (err) {
+                // Permission/disk failures are not contention; retrying them hides the
+                // real I/O diagnosis and unnecessarily stalls read-only watchers (#1245).
+                if (!['EEXIST', 'ENOTEMPTY'].includes(err.code ?? ''))
+                    throw err;
+                heldByPid = null;
+                try {
+                    const pidFile = path.join(lockPath, 'pid');
+                    if (node_fs_1.default.existsSync(pidFile)) {
+                        const lockPid = Number.parseInt(node_fs_1.default.readFileSync(pidFile, 'utf-8').trim(), 10);
+                        heldByPid = Number.isNaN(lockPid) ? null : lockPid;
                         try {
-                            fs.rmSync(stale, { recursive: true, force: true });
+                            process.kill(lockPid, 0);
                         }
                         catch {
-                            // best effort cleanup
+                            // Without the kernel guard there is no atomic compare-and-remove
+                            // for a directory owner. Refuse rather than steal a replacement.
+                            if (guard === null)
+                                throw new LockTimeoutError(lockPath, heldByPid);
+                            // Recorded holder is dead. Take the stale lock over by RENAMING it
+                            // first: with two contenders both seeing the dead pid, only one
+                            // rename succeeds — the loser's rmSync cannot delete the winner's
+                            // freshly-acquired lock (the plain rmSync-race the pool protocol
+                            // inherits from its original mkdir-mutex).
+                            const stale = `${lockPath}.stale-${process.pid}-${Date.now()}`;
+                            try {
+                                node_fs_1.default.renameSync(lockPath, stale);
+                            }
+                            catch {
+                                // another contender already took it over — fall through to retry
+                            }
+                            try {
+                                node_fs_1.default.rmSync(stale, { recursive: true, force: true });
+                            }
+                            catch {
+                                // best effort cleanup
+                            }
+                            continue;
                         }
-                        continue;
                     }
                 }
+                catch {
+                    // retry
+                }
+                if (Date.now() - start > LOCK_TIMEOUT_MS) {
+                    throw new LockTimeoutError(lockPath, heldByPid);
+                }
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_RETRY_MS);
             }
-            catch {
-                // retry
-            }
-            if (Date.now() - start > LOCK_TIMEOUT_MS) {
-                throw new LockTimeoutError(lockPath, heldByPid);
-            }
-            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_RETRY_MS);
         }
     }
+    catch (err) {
+        if (guard !== null)
+            node_fs_1.default.closeSync(guard);
+        throw err;
+    }
 }
 function releaseLock(dir) {
-    fs.rmSync(path.join(dir, LOCK_DIR), { recursive: true, force: true });
+    dir = path.resolve(dir);
+    const guard = stateGuards.get(dir);
+    try {
+        node_fs_1.default.rmSync(path.join(dir, LOCK_DIR), { recursive: true, force: true });
+    }
+    finally {
+        stateGuards.delete(dir);
+        if (guard !== undefined)
+            node_fs_1.default.closeSync(guard);
+    }
 }
 function readEngineLeaseHolder(leasePath) {
     try {
-        const raw = JSON.parse(fs.readFileSync(path.join(leasePath, ENGINE_LEASE_HOLDER_FILE), 'utf8'));
+        const raw = JSON.parse(node_fs_1.default.readFileSync(path.join(leasePath, ENGINE_LEASE_HOLDER_FILE), 'utf8'));
         if (raw === null || typeof raw !== 'object')
             return null;
         const candidate = raw;
@@ -242,6 +433,7 @@ class SchedStore {
     dir;
     /** The lease this store instance acquired (heartbeat target). */
     heldLease = null;
+    warnedQuarantines = new Set();
     constructor(dir, userConfigPath = path.resolve(dir, '..', '..', CONFIG_FILE)) {
         this.userConfigPath = userConfigPath;
         this.dir = dir;
@@ -287,25 +479,25 @@ class SchedStore {
             if (readEngineLeaseHolder(leasePath)?.id !== held.id)
                 return;
             const next = { ...held, updated_at: now.toISOString() };
-            fs.writeFileSync(tmp, `${JSON.stringify(next)}\n`, { mode: 0o600 });
+            node_fs_1.default.writeFileSync(tmp, `${JSON.stringify(next)}\n`, { mode: 0o600 });
             // Compare-and-swap on the lease id, as late as the filesystem allows: a
             // reclaim between the first check and here must not be overwritten by a
             // stale heartbeat (rename has no CAS; this narrows the window to the
             // gap between this read and the rename).
             if (readEngineLeaseHolder(leasePath)?.id !== held.id) {
-                fs.rmSync(tmp, { force: true });
+                node_fs_1.default.rmSync(tmp, { force: true });
                 return;
             }
-            fs.renameSync(tmp, path.join(leasePath, ENGINE_LEASE_HOLDER_FILE));
+            node_fs_1.default.renameSync(tmp, path.join(leasePath, ENGINE_LEASE_HOLDER_FILE));
         }
         catch {
-            fs.rmSync(tmp, { force: true });
+            node_fs_1.default.rmSync(tmp, { force: true });
             // Heartbeat is advisory; the pid-liveness check remains the source of truth.
         }
     }
     /** Acquire the engine lifecycle lease, separate from short-lived state mutation locks. */
     acquireEngineLease() {
-        fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+        node_fs_1.default.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
         let reclaimed;
         const leasePath = path.join(this.dir, ENGINE_LEASE_DIR);
         const lease = {
@@ -319,17 +511,17 @@ class SchedStore {
             // A unique pending directory must be created and populated successfully.
             // Permission, quota, or read-only filesystem failures are operational errors,
             // not contention, and must reach the caller.
-            fs.mkdirSync(pending, { mode: 0o700 });
+            node_fs_1.default.mkdirSync(pending, { mode: 0o700 });
             try {
-                fs.writeFileSync(path.join(pending, ENGINE_LEASE_HOLDER_FILE), `${JSON.stringify(lease)}\n`, {
+                node_fs_1.default.writeFileSync(path.join(pending, ENGINE_LEASE_HOLDER_FILE), `${JSON.stringify(lease)}\n`, {
                     mode: 0o600,
                 });
-                fs.renameSync(pending, leasePath);
+                node_fs_1.default.renameSync(pending, leasePath);
                 this.heldLease = lease;
                 return { acquired: true, lease, ...(reclaimed ? { reclaimed } : {}) };
             }
             catch (err) {
-                fs.rmSync(pending, { recursive: true, force: true });
+                node_fs_1.default.rmSync(pending, { recursive: true, force: true });
                 if (!isEngineLeaseRace(err))
                     throw err;
                 const holder = readEngineLeaseHolder(leasePath);
@@ -340,7 +532,7 @@ class SchedStore {
                 // a newly acquired lease after both observed the old holder.
                 const stale = `${leasePath}.stale-${lease.id}`;
                 try {
-                    fs.renameSync(leasePath, stale);
+                    node_fs_1.default.renameSync(leasePath, stale);
                     if (holder !== null) {
                         reclaimed = {
                             pid: holder.pid,
@@ -348,7 +540,7 @@ class SchedStore {
                             updated_at: holder.updated_at ?? null,
                         };
                     }
-                    fs.rmSync(stale, { recursive: true, force: true });
+                    node_fs_1.default.rmSync(stale, { recursive: true, force: true });
                 }
                 catch (reclaimErr) {
                     if (!isEngineLeaseRace(reclaimErr))
@@ -362,27 +554,59 @@ class SchedStore {
     releaseEngineLease(lease) {
         const leasePath = path.join(this.dir, ENGINE_LEASE_DIR);
         if (readEngineLeaseHolder(leasePath)?.id === lease.id) {
-            fs.rmSync(leasePath, { recursive: true, force: true });
+            node_fs_1.default.rmSync(leasePath, { recursive: true, force: true });
         }
         if (this.heldLease?.id === lease.id)
             this.heldLease = null;
     }
+    /** Synchronous, non-reentrant locked read. Requires directory write access even
+     * for healthy state, may throw LockTimeoutError, and may publish quarantine
+     * evidence/state recovery. Inside withLock use its supplied state, not load(). */
     load() {
-        const statePath = this.statePath;
-        if (!fs.existsSync(statePath)) {
-            return (0, state_1.createEmptyState)();
+        acquireLock(this.dir);
+        try {
+            return this.loadLocked();
+        }
+        finally {
+            releaseLock(this.dir);
         }
+    }
+    warnQuarantined(state) {
+        for (const batch of state.batches) {
+            if (batch.blocked_reason?.startsWith(QUARANTINE_MARKER) &&
+                !this.warnedQuarantines.has(batch.blocked_reason)) {
+                console.error(`⚠ Scheduler ${this.statePath}: ${batch.blocked_reason}`);
+                this.warnedQuarantines.add(batch.blocked_reason);
+            }
+        }
+    }
+    loadLocked() {
+        const statePath = this.statePath;
         let raw;
         try {
-            raw = fs.readFileSync(statePath, 'utf-8');
+            const fd = node_fs_1.default.openSync(statePath, node_fs_1.default.constants.O_RDONLY | node_fs_1.default.constants.O_NOFOLLOW | node_fs_1.default.constants.O_NONBLOCK);
+            try {
+                if (!node_fs_1.default.fstatSync(fd).isFile())
+                    throw new Error('state must be a regular file, not a special filesystem object');
+                raw = node_fs_1.default.readFileSync(fd);
+            }
+            finally {
+                node_fs_1.default.closeSync(fd);
+            }
         }
         catch (err) {
+            if (err.code === 'ENOENT')
+                return (0, state_1.createEmptyState)();
             // An I/O failure (permissions, disk, read-only mount) is NOT corruption —
             // the destructive "rename to reset" advice must not attach to it.
             throw new CorruptStateError(statePath, new Error(`could not READ the file (${err.message}) — this is an I/O failure, not corruption; renaming will not fix it`));
         }
+        let parsed;
         try {
-            return (0, state_1.validateState)(JSON.parse(raw));
+            parsed = JSON.parse(raw.toString('utf8'));
+            const state = (0, state_1.validateState)(parsed);
+            this.warnQuarantined(state);
+            return state;
         }
         catch (err) {
             // A newer-than-installed schema is not corruption (#537) — rethrow as
@@ -390,7 +614,24 @@ class SchedStore {
             // upgrade-the-engine message instead of "rename or remove it".
             if (err instanceof types_1.EngineTooOldError)
                 throw err;
-            throw new CorruptStateError(statePath, err);
+            if (parsed === undefined)
+                throw new CorruptStateError(statePath, err);
+            const digest = (0, node_crypto_1.createHash)('sha256').update(raw).digest('hex');
+            const evidence = path.join(this.dir, QUARANTINE_DIR, `${digest}.json`);
+            try {
+                const isolated = isolateTerminalBatches(parsed, evidence);
+                if (isolated.records.length === 0)
+                    throw err;
+                preserveQuarantine(this.dir, digest, raw, isolated.records);
+                this.save(isolated.state);
+                this.warnQuarantined(isolated.state);
+                return isolated.state;
+            }
+            catch (recoveryError) {
+                if (recoveryError instanceof types_1.EngineTooOldError)
+                    throw recoveryError;
+                throw new CorruptStateError(statePath, new Error(`${err.message}; terminal quarantine refused (${recoveryError.message}); evidence location ${evidence}`));
+            }
         }
     }
     save(state) {
@@ -403,7 +644,7 @@ class SchedStore {
     withLock(fn) {
         acquireLock(this.dir);
         try {
-            const current = this.load();
+            const current = this.loadLocked();
             const { state, result } = fn(current);
             this.save(state);
             return result;
@@ -415,7 +656,7 @@ class SchedStore {
     loadConfig() {
         const userProfiles = this.loadUserProfiles();
         let config;
-        if (!fs.existsSync(this.configPath)) {
+        if (!node_fs_1.default.existsSync(this.configPath)) {
             config = { max_slots: types_1.DEFAULT_MAX_SLOTS };
             return mergeDispatchProfiles(config, userProfiles);
         }
@@ -441,7 +682,7 @@ class SchedStore {
     /** Parse + strictly validate the project config file (throws on ANY problem). */
     parseConfigFile() {
         let config;
-        const parsed = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(this.configPath, 'utf-8'));
         const version = String(parsed.schema_version);
         if (version !== types_1.CONFIG_SCHEMA_VERSION && !types_1.LEGACY_CONFIG_SCHEMA_VERSIONS.includes(version)) {
             throw new Error(`unsupported schema version ${version}`);
@@ -507,7 +748,7 @@ class SchedStore {
         // are ignored) so it can never block a valid project-config reload; the
         // caller is told, naming the file.
         const userProfiles = this.loadUserProfiles(onUserConfigError);
-        if (!fs.existsSync(this.configPath)) {
+        if (!node_fs_1.default.existsSync(this.configPath)) {
             return mergeDispatchProfiles({ max_slots: types_1.DEFAULT_MAX_SLOTS }, userProfiles);
         }
         return mergeDispatchProfiles(this.parseConfigFile(), userProfiles);
@@ -519,7 +760,7 @@ class SchedStore {
     configFingerprint() {
         const stamp = (file) => {
             try {
-                const st = fs.statSync(file);
+                const st = node_fs_1.default.statSync(file);
                 return `${st.mtimeMs}:${st.size}`;
             }
             catch {
@@ -573,10 +814,10 @@ class SchedStore {
         writeAtomic(this.configPath, `${JSON.stringify(file, null, 2)}\n`);
     }
     loadUserProfiles(onError) {
-        if (!fs.existsSync(this.userConfigPath))
+        if (!node_fs_1.default.existsSync(this.userConfigPath))
             return {};
         try {
-            const raw = JSON.parse(fs.readFileSync(this.userConfigPath, 'utf-8'));
+            const raw = JSON.parse(node_fs_1.default.readFileSync(this.userConfigPath, 'utf-8'));
             const userConfig = requirePlainObject('user config', raw);
             if (userConfig.dispatch_profiles === undefined)
                 return {};