@sema-agent/core 7.4.0 → 7.5.1

package/dist/stores/file/permission-rule-store.js

@@ -1,10 +1,32 @@
-import { closeSync, constants as FS, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, constants as FS, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { createHash, randomBytes } from "node:crypto";
 import { PERMISSION_RULE_WRITER, applySyncJoin, applyTombstones, assertDeleteDeltaCarriesNoAdd, assertRedemptionNotQuarantined, assertWriteDeltaScopeDurable, foldDelta, } from "../../core/permission-rule-store.js";
 import { canonicalize } from "../../core/canonical-json.js";
 import { BootLock } from "./fs-atomic.js";
 import { assertAdoptionBootGate } from "./adoption/marker.js";
+function isRuleFile(v) {
+    const p = v;
+    return typeof p === "object" && p !== null && p.schemaVersion === 3 && Array.isArray(p.rules) && Array.isArray(p.tombstones) && typeof p.rev === "number" && (p.quarantined === undefined || Array.isArray(p.quarantined));
+}
+function isLegacyRuleFile(v) {
+    const p = v;
+    return typeof p === "object" && p !== null && (p.schemaVersion === 1 || p.schemaVersion === 2) && Array.isArray(p.rules) && Array.isArray(p.tombstones) && typeof p.rev === "number";
+}
+function isOrgStateFile(v) {
+    const p = v;
+    return typeof p === "object" && p !== null && p.schemaVersion === 1 && typeof p.state === "object" && p.state !== null;
+}
+function schemaVersionWord(v) {
+    return typeof v === "object" && v !== null ? v.schemaVersion : undefined;
+}
+function jsonForm(v) {
+    return JSON.parse(JSON.stringify(v));
+}
+export const ORG_STATE_FILE = "org.json";
+export const SCHEMA3_MARKER_FILE = ".rule-schema-3";
+export class OrgRevisionRefusal extends Error {
+}
 const LOCAL_OWNER_FILE = "local-owner.json";
 const ADOPTION_FILE = "PERMISSION-RULES-ADOPTION.json";
 export function readRuleAdoptionFile(dir) {
@@ -92,7 +114,7 @@ function assertSafeDir(dir) {
             `refusing to use it — anyone who can write here can grant themselves permissions`);
     }
 }
-class FilePermissionRuleStore {
+class FileDurableRulePartition {
     dir;
     file;
     acquireWriteLock;
@@ -134,12 +156,11 @@ class FilePermissionRuleStore {
             this.disclose(why);
             return { unreadable: why };
         }
-        if ((parsed?.schemaVersion !== 1 && parsed?.schemaVersion !== 2) ||
-            !Array.isArray(parsed.rules) ||
-            !Array.isArray(parsed.tombstones) ||
-            typeof parsed.rev !== "number" ||
-            (parsed.quarantined !== undefined && !Array.isArray(parsed.quarantined))) {
-            const why = `${this.file} does not carry a readable rule-file shape; refusing the whole file and loading zero rules`;
+        if (!isRuleFile(parsed)) {
+            const sv = schemaVersionWord(parsed);
+            const why = sv === 1 || sv === 2
+                ? `${this.file} is a schema ${String(sv)} bucket that was not migrated to schema 3 (written by an older engine after this directory was migrated?); refusing the whole file and loading zero rules`
+                : `${this.file} does not carry a readable rule-file shape; refusing the whole file and loading zero rules`;
             this.disclose(why);
             return { unreadable: why };
         }
@@ -175,6 +196,8 @@ class FilePermissionRuleStore {
     }
     async list() {
         const r = this.read();
+        if ("unreadable" in r)
+            throw new Error(r.unreadable);
         if (!("file" in r))
             return { ...EMPTY_READ };
         const screened = this.screenDurableRows(r.file);
@@ -189,34 +212,13 @@ class FilePermissionRuleStore {
         const r = this.read();
         return "file" in r ? this.screenDurableRows(r.file).quarantined : [];
     }
-    async readOrgState() {
-        const r = this.read();
-        return "file" in r ? r.file.org : undefined;
-    }
-    async installOrgState(state) {
-        this.acquireWriteLock();
-        await this.serialize(() => {
-            const cur = this.current();
-            if (cur.org !== undefined && state.revisionHighWater < cur.org.revisionHighWater) {
-                throw new Error(`refusing to lower the org revision high-water mark (${cur.org.revisionHighWater} → ${state.revisionHighWater}) — an interleaved install must re-read and re-compare`);
-            }
-            if (cur.org !== undefined &&
-                state.snapshot.revision === cur.org.snapshot.revision &&
-                canonicalize(state.snapshot.rules) !== canonicalize(cur.org.snapshot.rules)) {
-                throw new Error(`refusing to replace org revision ${state.snapshot.revision} with DIFFERENT policy content under the same revision — content changes must bump the revision`);
-            }
-            if (!this.writeAndVerify({ ...cur, schemaVersion: 2, org: state })) {
-                throw new Error("the permission-rule store did not survive its own write; the org snapshot was not installed");
-            }
-        });
-    }
     current() {
         const r = this.read();
         if ("unreadable" in r) {
             throw new Error(`refusing to write the permission-rule store while it cannot be read: ${r.unreadable}`);
         }
         if ("absent" in r) {
-            return { schemaVersion: 1, actor: `file-${randomBytes(6).toString("hex")}`, counter: 0, rev: 0, rules: [], tombstones: [] };
+            return { schemaVersion: 3, actor: `file-${randomBytes(6).toString("hex")}`, counter: 0, rev: 0, rules: [], tombstones: [] };
         }
         return {
             schemaVersion: r.file.schemaVersion,
@@ -226,7 +228,6 @@ class FilePermissionRuleStore {
             rules: r.file.rules,
             tombstones: r.file.tombstones,
             ...(r.file.sync !== undefined ? { sync: r.file.sync } : {}),
-            ...(r.file.org !== undefined ? { org: r.file.org } : {}),
             ...(r.file.quarantined !== undefined ? { quarantined: r.file.quarantined } : {}),
         };
     }
@@ -284,7 +285,6 @@ class FilePermissionRuleStore {
                 }, delta, Date.now());
                 const landed = {
                     ...cur,
-                    schemaVersion: 2,
                     rev: cur.rev + 1,
                     rules: next.rules,
                     tombstones: next.tombstones,
@@ -309,15 +309,105 @@ class FilePermissionRuleStore {
         }),
     };
 }
-export class FilePermissionRuleStoreProvider {
+export class FileDurableRulePartitionProvider {
     dir;
     onError;
     lock;
+    orgPersistence;
     constructor(dir, onError, opts) {
         this.dir = dir;
         this.onError = onError;
         if (opts?.dataRoot !== undefined)
-            assertAdoptionBootGate(opts.dataRoot, "FilePermissionRuleStoreProvider");
+            assertAdoptionBootGate(opts.dataRoot, "FileDurableRulePartitionProvider");
+        this.migrateLegacyBuckets();
+    }
+    migrateLegacyBuckets() {
+        if (!existsSync(this.dir))
+            return;
+        if (existsSync(join(this.dir, SCHEMA3_MARKER_FILE)))
+            return;
+        try {
+            assertSafeDir(this.dir);
+        }
+        catch (err) {
+            this.onError?.(`legacy scan skipped: ${err.message}`);
+            return;
+        }
+        const held = this.lock !== undefined;
+        try {
+            this.acquireWriteLock();
+        }
+        catch (err) {
+            this.onError?.(`rule-file schema migration deferred (the directory will be scanned again by the next construction that can take its writer lock): ${err.message}`);
+            return;
+        }
+        let complete = true;
+        try {
+            let names;
+            try {
+                names = readdirSync(this.dir);
+            }
+            catch (err) {
+                this.onError?.(`rule-file schema migration deferred (the directory could not be listed): ${err.message}`);
+                return;
+            }
+            const candidates = names.filter((name) => name === LOCAL_OWNER_FILE || /^[0-9a-f]{64}\.json$/.test(name)).sort();
+            const legacy = [];
+            for (const name of candidates) {
+                const read = readLegacyBucket(join(this.dir, name));
+                if (read !== undefined)
+                    legacy.push({ name, file: read });
+            }
+            if (legacy.length === 0) {
+                this.writeSchema3Marker();
+                return;
+            }
+            const orgHome = this.fileOrgPersistence();
+            for (const { name, file } of legacy) {
+                const { org, schemaVersion: _legacyVersion, checksum: _legacyChecksum, ...rest } = file;
+                if (org !== undefined) {
+                    try {
+                        orgHome.installOrgStateSync(org);
+                    }
+                    catch (err) {
+                        if (err instanceof OrgRevisionRefusal) {
+                            this.onError?.(`the org block of ${name} was not folded into ${ORG_STATE_FILE}: ${err.message}`);
+                        }
+                        else {
+                            complete = false;
+                            this.onError?.(`legacy bucket ${name} left untouched: its org block could not be installed into ${ORG_STATE_FILE} (${err.message}); the migration will retry on the next construction`);
+                            continue;
+                        }
+                    }
+                }
+                const next = { ...rest, schemaVersion: 3 };
+                atomicPublish(this.dir, join(this.dir, name), JSON.stringify({ ...next, checksum: checksumOf(next) }, null, 2));
+                this.onError?.(`migrated ${name} to rule-file schema 3${org !== undefined ? ` (its org block moved to ${ORG_STATE_FILE})` : ""}`);
+            }
+            if (complete)
+                this.writeSchema3Marker();
+        }
+        finally {
+            if (!held) {
+                this.lock?.release();
+                this.lock = undefined;
+            }
+        }
+    }
+    writeSchema3Marker() {
+        try {
+            atomicPublish(this.dir, join(this.dir, SCHEMA3_MARKER_FILE), JSON.stringify({ schemaVersion: 3 }));
+        }
+        catch (err) {
+            this.onError?.(`could not write ${SCHEMA3_MARKER_FILE}: ${err.message}; the legacy scan will run again next construction`);
+        }
+    }
+    orgStatePersistence() {
+        return this.fileOrgPersistence();
+    }
+    fileOrgPersistence() {
+        this.orgPersistence ??= new FileOrgRuleStatePersistence(this.dir, this.acquireWriteLock, this.onError);
+        return this.orgPersistence;
     }
     acquireWriteLock = () => {
         if (this.lock !== undefined)
@@ -338,11 +428,11 @@ export class FilePermissionRuleStoreProvider {
                 return this.readOnlySourceView(principalRuleFileName(principal), principalRuleFileName(rec.toPrincipal), "adopted" in adoption || adoption.marker.phase >= 4);
             }
         }
-        return new FilePermissionRuleStore(this.dir, join(this.dir, principalRuleFileName(principal)), this.acquireWriteLock, this.onError);
+        return new FileDurableRulePartition(this.dir, join(this.dir, principalRuleFileName(principal)), this.acquireWriteLock, this.onError);
     }
     readOnlySourceView(sourceName, targetName, flipped) {
         const pick = flipped ? targetName : existsSync(join(this.dir, sourceName)) ? sourceName : targetName;
-        return readOnlyRuleStoreView(new FilePermissionRuleStore(this.dir, join(this.dir, pick), this.acquireWriteLock, this.onError));
+        return readOnlyRuleStoreView(new FileDurableRulePartition(this.dir, join(this.dir, pick), this.acquireWriteLock, this.onError));
     }
     forLocalOwner() {
         const adoption = readRuleAdoptionFile(this.dir);
@@ -352,13 +442,101 @@ export class FilePermissionRuleStoreProvider {
                 return this.readOnlySourceView(LOCAL_OWNER_FILE, principalRuleFileName(rec.toPrincipal), "adopted" in adoption || adoption.marker.phase >= 4);
             }
         }
-        return new FilePermissionRuleStore(this.dir, join(this.dir, LOCAL_OWNER_FILE), this.acquireWriteLock, this.onError);
+        return new FileDurableRulePartition(this.dir, join(this.dir, LOCAL_OWNER_FILE), this.acquireWriteLock, this.onError);
     }
     dispose() {
         this.lock?.release();
         this.lock = undefined;
     }
 }
+function readLegacyBucket(file) {
+    let raw;
+    try {
+        const st = lstatSync(file);
+        if (st.isSymbolicLink() || !st.isFile())
+            return undefined;
+        raw = readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isLegacyRuleFile(parsed))
+        return undefined;
+    const { checksum, ...body } = parsed;
+    return checksum === checksumOf(body) ? parsed : undefined;
+}
+class FileOrgRuleStatePersistence {
+    dir;
+    acquireWriteLock;
+    onError;
+    file;
+    writeChain = Promise.resolve();
+    constructor(dir, acquireWriteLock, onError) {
+        this.dir = dir;
+        this.acquireWriteLock = acquireWriteLock;
+        this.onError = onError;
+        this.file = join(dir, ORG_STATE_FILE);
+    }
+    readSync() {
+        let raw;
+        try {
+            assertSafeDir(this.dir);
+            const st = lstatSync(this.file);
+            if (st.isSymbolicLink() || !st.isFile())
+                throw new Error(`${this.file} is a symlink or not a regular file; refusing to load the org state from it`);
+            raw = readFileSync(this.file, "utf8");
+        }
+        catch (err) {
+            if (err?.code === "ENOENT")
+                return undefined;
+            throw err;
+        }
+        const parsed = JSON.parse(raw);
+        if (!isOrgStateFile(parsed))
+            throw new Error(`${this.file} does not carry a readable org-state shape; refusing it whole`);
+        const { checksum, ...body } = parsed;
+        if (checksum !== checksumOf(body))
+            throw new Error(`${this.file} failed its integrity check; refusing it whole`);
+        return parsed.state;
+    }
+    async readOrgState() {
+        return this.readSync();
+    }
+    installOrgStateSync(state) {
+        this.acquireWriteLock();
+        assertSafeDir(this.dir);
+        state = jsonForm(state);
+        const cur = this.readSync();
+        if (cur !== undefined && state.revisionHighWater < cur.revisionHighWater) {
+            throw new OrgRevisionRefusal(`refusing to lower the org revision high-water mark (${cur.revisionHighWater} → ${state.revisionHighWater}) — an interleaved install must re-read and re-compare`);
+        }
+        if (cur !== undefined && state.snapshot.revision === cur.snapshot.revision && canonicalize(state.snapshot.rules) !== canonicalize(cur.snapshot.rules)) {
+            throw new OrgRevisionRefusal(`refusing to replace org revision ${state.snapshot.revision} with DIFFERENT policy content under the same revision — content changes must bump the revision`);
+        }
+        if (cur !== undefined && state.snapshot.revision === cur.snapshot.revision && state.snapshot.fetchedAtMs <= cur.snapshot.fetchedAtMs)
+            return;
+        const body = { schemaVersion: 1, state };
+        atomicPublish(this.dir, this.file, JSON.stringify({ ...body, checksum: checksumOf(body) }, null, 2));
+        const after = this.readSync();
+        if (after === undefined || canonicalize(after) !== canonicalize(state)) {
+            const why = "the org state file did not survive its own write; the org snapshot was not installed";
+            this.onError?.(why);
+            throw new Error(why);
+        }
+    }
+    async installOrgState(state) {
+        const run = this.writeChain.then(() => this.installOrgStateSync(state), () => this.installOrgStateSync(state));
+        this.writeChain = run.then(() => undefined, () => undefined);
+        await run;
+    }
+}
 function readOnlyRuleStoreView(store) {
     return {
         list: () => store.list(),

package/dist/stores/file/task-list-store.d.ts

@@ -4,7 +4,7 @@ export declare function createFileTaskListStore(root: string, opts?: {
      * The DATA ROOT whose adoption marker gates construction (design/183 I6). Most of the file family
      * takes the data root and derives `join(root, "<family>")` itself; this factory is one of the TWO
      * faces that instead take a caller-chosen directory (the other being
-     * `FilePermissionRuleStoreProvider`, which takes a rule bucket) — here, the document's own
+     * `FileDurableRulePartitionProvider`, which takes a rule bucket) — here, the document's own
      * directory. So when a deployment hands in a SUBDIRECTORY the I6 check would look for the marker
      * inside that subdirectory, find nothing, and pass unconditionally: a gate that is always open
      * (backlog #136⑦). Supply the data root here and the gate reads the anchor the root-taking faces

package/dist/tools/fs/read-face.d.ts

@@ -19,7 +19,7 @@ export interface ReadFaceInputs {
     /** The verifier read-only mount (`handsReadOnly` / toolkit `readOnly`): its containment is a
      *  LOAD-BEARING wall (bash_readonly is genuinely confined by it) — never openable. */
     readOnlyMount: boolean;
-    /** Org governance declared (RunnerDeps.permissionRuleOrg in place): default roots; the task layer
+    /** Org governance declared (`RunnerDeps.permissionRuleStore.partitions.org === true`): default roots; the task layer
      *  may not open (D-2 — tighten-only under governance; the deps layer, being the deployment's own
      *  declaration, still may). */
     orgGoverned: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.4.0",
+  "version": "7.5.1",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",
@@ -58,6 +58,7 @@
     "prepare": "npm run build",
     "prepublishOnly": "npm run build && npm run test",
     "gate:blackbox": "node scripts/run-blackbox-gate.mjs",
+    "gate:repro": "node scripts/run-repro-gate.mjs",
     "gate:ledger": "node scripts/verify-hardening-ledger.mjs",
     "gate:compensation": "node scripts/verify-compensation-registry.mjs",
     "gate:message-branching": "node scripts/verify-no-message-branching.mjs",
@@ -71,7 +72,12 @@
     "gate:debts:rc": "node scripts/verify-debts.mjs --rc-gate",
     "gate:error-surface": "node scripts/verify-error-surface.mjs",
     "gate:criteria": "node scripts/criteria-lint.mjs",
-    "gate:reminder-literal": "node scripts/verify-reminder-literal.mjs"
+    "gate:reminder-literal": "node scripts/verify-reminder-literal.mjs",
+    "gate:wire": "node scripts/wire-changes.mjs",
+    "gate:layering": "node scripts/verify-layering.mjs",
+    "gate:phase-api": "node scripts/verify-phase-api.mjs",
+    "gate:agent-returns": "node scripts/verify-agent-returns.mjs",
+    "gate:all": "node scripts/gate-all.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",