@sema-agent/core 7.48.0 → 7.49.1

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

@@ -8,7 +8,7 @@ import { ambiguousOriginRepresentation, committedDistilledOf, committedOriginOf,
 import { convertV1SidecarKeys } from "./delegation-settlement.js";
 import { layerObservationLookup, observedDivergenceNotice } from "./layer-observations.js";
 import { DEFAULT_MAX_ENTRY_DEPTH, MEMORY_INDEX_FILENAME, scanEntryFiles } from "./entry-scan.js";
-import { ControlPlaneCorruptError, CURSORS_FILE, QUARANTINE_DIR, CHALLENGES_FILE, IMPORT_RECEIPTS_DIR, LINEAGE_FILE, SESSION_POLLUTION_DIR, appendChallengeEvents, atomicWriteFileSync, quarantineAndTombstone, captureAndClearLineageForEntries, adoptRootScopeLayout, adoptCanonicalKeyedControlDir, deriveControlPlaneDir, ensureDirExists, enqueueMemoryAnnouncement, importLatchTxnId, importLineageCommitted, importSessionPollution, isContainedIn, permissionRemedyOf, withPermissionRemedy, lineageContributionsOfSession, listSessionPollution, readChallengeEvents, readLineageRecord, registerScope, registeredScopes, releaseImportLatch, layoutNeedsAdoption, resolveMemoryEngineRoot, scopeDirFor, scopeDirName, scopeRegistryShape, stageImportLatch, landingPathOf, landsOutsideStore, storeActRefusal, storeRootMovedRefusal, writeAllSync, } from "./layout.js";
+import { ControlPlaneCorruptError, CURSORS_FILE, QUARANTINE_DIR, CHALLENGES_FILE, IMPORT_RECEIPTS_DIR, LINEAGE_FILE, SESSION_POLLUTION_DIR, appendChallengeEvents, atomicWriteFileSync, quarantineAndTombstone, captureAndClearLineageForEntries, adoptRootScopeLayout, anchorStoreRoot, effectiveControlRootOf, ensureDirExists, LEDGER_FILE, enqueueMemoryAnnouncement, importLatchTxnId, importLineageCommitted, importSessionPollution, isContainedIn, permissionRemedyOf, withPermissionRemedy, lineageContributionsOfSession, listSessionPollution, readChallengeEvents, readLineageRecord, registerScope, registeredScopes, releaseImportLatch, layoutNeedsAdoption, scopeDirFor, scopeDirName, scopeRegistryShape, stageImportLatch, landsOutsideStore, storeActRefusal, storeRootMovedRefusal, writeAllSync, STORE_JOURNAL_FILE, STORE_TXN_LOCK_DIR, TXN_LOCK_STALE_MS, acquireStoreTxnLock, assertStoreTxnLockOwnership, tryStoreTxnLock, } from "./layout.js";
 import { screenInboundEntries } from "./data-plane.js";
 import { scanMemoryFileName, scanMemoryWrite } from "./scan.js";
 import { thrownText } from "../thrown-value.js";
@@ -100,15 +100,10 @@ class AuditSnapshotContendedError extends Error {
 }
 class AuditObservationUnstableError extends Error {
 }
-const LEDGER_FILE = "revs.json";
 const LEDGER_SCHEMA_VERSION = 2;
 const LEDGER_V1_BACKUP_FILE = "revs.v1.json.bak";
 const TRANSFERS_FILE = "transfers.jsonl";
 const CHAIN_DEGRADED_FILE = "transfers.chain-degraded.json";
-const JOURNAL_FILE = "journal.json";
-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 STORE_IDENTITY_FILE = "store-identity.json";
 function rowsRev(rows, id) {
@@ -522,7 +517,6 @@ function probeProjection(absPath, id) {
 export class FileMemoryEngineBackend {
     directoryRoot;
     controlPlaneRoot;
-    physicalRoot;
     now;
     onIncident;
     ledger;
@@ -542,11 +536,9 @@ export class FileMemoryEngineBackend {
         this.now = opts.now ?? Date.now;
         this.onIncident = opts.onIncident;
         this.directoryRoot = dir;
-        if (opts.controlDir === undefined)
-            adoptCanonicalKeyedControlDir(resolveMemoryEngineRoot(), dir, opts.onIncident);
-        this.controlPlaneRoot = opts.controlDir ?? deriveControlPlaneDir(resolveMemoryEngineRoot(), dir);
+        this.controlPlaneRoot = effectiveControlRootOf(dir, { controlDir: opts.controlDir, onIncident: opts.onIncident });
+        this.assertRootAnchored();
         ensureDirExists(dir);
-        this.physicalRoot = landingPathOf(dir);
         ensureDirExists(this.controlPlaneRoot);
         this.recoverJournal({ unlocked: true });
         try {
@@ -579,7 +571,7 @@ export class FileMemoryEngineBackend {
         });
     }
     ensureLayout(ownerCandidate) {
-        this.assertRootIntact();
+        this.assertRootAnchored();
         if (!layoutNeedsAdoption(this.directoryRoot, this.controlPlaneRoot))
             return;
         const lock = this.tryAcquireTxnLockSync();
@@ -594,7 +586,7 @@ export class FileMemoryEngineBackend {
         }
     }
     async adoptRootScopeLayout(opts = {}) {
-        this.assertRootIntact();
+        this.assertRootAnchored();
         if (!layoutNeedsAdoption(this.directoryRoot, this.controlPlaneRoot))
             return;
         const lock = await this.acquireTxnLock();
@@ -777,117 +769,7 @@ export class FileMemoryEngineBackend {
         }
     }
     tryAcquireTxnLockSync() {
-        const lockDir = this.txnLockDir();
-        const ownerPath = join(lockDir, "owner");
-        const tryMkdir = () => {
-            try {
-                mkdirSync(this.controlPlaneRoot, { recursive: true });
-            }
-            catch (err) {
-                throw new ControlPlaneCorruptError(`memory control-plane root could not be created (${err.code ?? "io error"}) at ${this.controlPlaneRoot} — a lock-acquisition fault is not contention; deferring recovery/migration on it would be silent (fail-closed)`, { cause: err });
-            }
-            try {
-                mkdirSync(lockDir);
-                return true;
-            }
-            catch (err) {
-                if (err.code === "EEXIST")
-                    return false;
-                throw new ControlPlaneCorruptError(`memory txn lock could not be created (${err.code ?? "io error"}) at ${lockDir} — a lock-acquisition fault is not contention; deferring recovery/migration on it would be silent (fail-closed)`, { cause: err });
-            }
-        };
-        let acquired = tryMkdir();
-        if (!acquired) {
-            let mtimeMs;
-            try {
-                mtimeMs = statSync(lockDir).mtimeMs;
-            }
-            catch (err) {
-                if (err.code !== "ENOENT") {
-                    throw new ControlPlaneCorruptError(`memory txn lock state could not be probed (${err.code ?? "io error"}) at ${lockDir} — a probe failure is not contention (fail-closed)`, { cause: err });
-                }
-                let occupant;
-                try {
-                    occupant = lstatSync(lockDir);
-                }
-                catch (lerr) {
-                    if (lerr.code !== "ENOENT") {
-                        throw new ControlPlaneCorruptError(`memory txn lock re-probe failed (${lerr.code ?? "io error"}) at ${lockDir} — a probe failure is not contention (fail-closed)`, { cause: lerr });
-                    }
-                }
-                if (occupant !== undefined && !occupant.isDirectory()) {
-                    throw new ControlPlaneCorruptError(`memory txn lock path is occupied by an invalid node (a dangling symlink?) at ${lockDir} — not contention and not a release race; remove the occupant (fail-closed)`, { cause: err });
-                }
-                mtimeMs = undefined;
-            }
-            if (mtimeMs !== undefined && this.now() - mtimeMs > TXN_LOCK_STALE_MS) {
-                let tokenPresent = false;
-                try {
-                    statSync(ownerPath);
-                    tokenPresent = true;
-                }
-                catch (err) {
-                    if (err.code !== "ENOENT") {
-                        throw new ControlPlaneCorruptError(`memory txn lock owner token could not be probed (${err.code ?? "io error"}) at ${ownerPath} — a probe failure is not a mid-acquisition (fail-closed)`, { cause: err });
-                    }
-                }
-                if (tokenPresent) {
-                    const tomb = join(this.controlPlaneRoot, `txn.lock.stale-${randomUUID()}`);
-                    let stolen = false;
-                    try {
-                        renameSync(lockDir, tomb);
-                        stolen = true;
-                    }
-                    catch (err) {
-                        if (err.code !== "ENOENT") {
-                            throw new ControlPlaneCorruptError(`memory txn lock stale-steal rename failed (${err.code ?? "io error"}) at ${lockDir} — a rename fault is not a lost race (fail-closed)`, { cause: err });
-                        }
-                    }
-                    if (stolen) {
-                        rmSync(tomb, { recursive: true, force: true });
-                        acquired = tryMkdir();
-                    }
-                }
-            }
-            if (!acquired)
-                return undefined;
-        }
-        const token = randomUUID();
-        try {
-            const fd = openSync(ownerPath, "w", 0o600);
-            try {
-                writeAllSync(fd, token);
-                fsyncSync(fd);
-            }
-            finally {
-                closeSync(fd);
-            }
-        }
-        catch (err) {
-            try {
-                rmSync(lockDir, { recursive: true, force: true });
-            }
-            catch {
-            }
-            throw new Error(`memory txn lock owner token could not be written at ${ownerPath}: ${thrownText(err)}`);
-        }
-        return {
-            token,
-            release: () => {
-                try {
-                    if (readFileSync(ownerPath, "utf8") !== token)
-                        return;
-                }
-                catch {
-                    return;
-                }
-                try {
-                    rmSync(lockDir, { recursive: true, force: true });
-                }
-                catch {
-                }
-            },
-        };
+        return tryStoreTxnLock(this.controlPlaneRoot, { now: this.now });
     }
     tryOpportunisticMigrate() {
         const lock = this.tryAcquireTxnLockSync();
@@ -946,12 +828,12 @@ export class FileMemoryEngineBackend {
         this.assertTxnLockOwnership(lockToken);
         this.precheckTransfersAppendable();
         const journal = { txn: `${Date.now()}-migrate`, ops: [], ledger2: ledgerEnvelope(next, this.envelopeExtras), transfers: events };
-        atomicWriteFileSync(join(this.controlPlaneRoot, JOURNAL_FILE), JSON.stringify(journal));
+        atomicWriteFileSync(join(this.controlPlaneRoot, STORE_JOURNAL_FILE), JSON.stringify(journal));
         this.ledger = next;
         this.persistedSchemaVersion = "v2";
         this.saveLedger();
         this.appendTransfers(events);
-        rmSync(join(this.controlPlaneRoot, JOURNAL_FILE), { force: true });
+        rmSync(join(this.controlPlaneRoot, STORE_JOURNAL_FILE), { force: true });
         this.enqueueExternalItems([
             fullMigration
                 ? `memory ledger upgraded to v2 (${bound.length} row(s) bound, ${unbound.length} unbound${unbound.length > 0 ? `: ${unbound.slice(0, 8).join(", ")}${unbound.length > 8 ? ", …" : ""}` : ""})`
@@ -1027,7 +909,7 @@ export class FileMemoryEngineBackend {
                 if (!isTail)
                     throw new ControlPlaneCorruptError(`transfer evidence log line ${i + 1} is unparseable (not a torn tail — fail-closed): ${path}`);
                 let journalHasPendingEvidence = false;
-                const jraw = readControlFileOrAbsent(join(this.controlPlaneRoot, JOURNAL_FILE), "transaction journal");
+                const jraw = readControlFileOrAbsent(join(this.controlPlaneRoot, STORE_JOURNAL_FILE), "transaction journal");
                 if (jraw !== undefined) {
                     try {
                         const jparsed = JSON.parse(jraw);
@@ -1215,7 +1097,7 @@ export class FileMemoryEngineBackend {
         }
     }
     recoverJournal(fence) {
-        this.assertRootIntact();
+        this.assertRootAnchored();
         if (fence.token === undefined) {
             if (this.txnInFlight())
                 return;
@@ -1231,7 +1113,7 @@ export class FileMemoryEngineBackend {
             return;
         }
         const fenceToken = fence.token;
-        const jp = join(this.controlPlaneRoot, JOURNAL_FILE);
+        const jp = join(this.controlPlaneRoot, STORE_JOURNAL_FILE);
         const raw = readControlFileOrAbsent(jp, "transaction journal");
         if (raw !== undefined) {
             const journal = parseJournal(raw, jp);
@@ -1465,21 +1347,23 @@ export class FileMemoryEngineBackend {
             throw new ControlPlaneCorruptError(`txn lock state could not be probed (${code ?? "io error"}) at ${this.txnLockDir()} — a probe failure is not "no writer" (fail-closed)`);
         }
     }
-    refuseEscapingTargets(ops, at) {
+    refuseEscapingTargets(ops, at, anchoredRoot) {
+        let root;
         for (const op of ops) {
             if (op.kind !== "write" && op.kind !== "delete")
                 continue;
+            root ??= this.assertRootAnchored(anchoredRoot);
             for (const path of op.staged === undefined ? [op.target] : [op.target, op.staged]) {
-                if (landsOutsideStore(this.physicalRoot, path))
+                if (landsOutsideStore(root, path))
                     throw storeActRefusal(`${path === op.target ? "a" : "the staged file of a"} ${op.kind} at ${at}`, path);
             }
         }
     }
-    assertRootIntact() {
-        const now = landingPathOf(this.directoryRoot);
-        if (now === this.physicalRoot)
-            return;
-        throw storeRootMovedRefusal("backend", this.directoryRoot);
+    assertRootAnchored(expected) {
+        const root = anchorStoreRoot(this.directoryRoot, this.controlPlaneRoot, { onIncident: this.onIncident, now: this.now });
+        if (expected !== undefined && expected !== root)
+            throw storeRootMovedRefusal(this.directoryRoot, { controlDir: this.controlPlaneRoot, recorded: root, now: expected });
+        return root;
     }
     sweepStagedFiles() {
         const walk = (d, depth) => {
@@ -1689,10 +1573,10 @@ export class FileMemoryEngineBackend {
                     ledger2: ledgerEnvelope(rows, this.envelopeExtras),
                     transfers: moveEvents,
                 };
-                atomicWriteFileSync(join(this.controlPlaneRoot, JOURNAL_FILE), JSON.stringify(journal));
+                atomicWriteFileSync(join(this.controlPlaneRoot, STORE_JOURNAL_FILE), JSON.stringify(journal));
                 this.saveLedger();
                 this.appendTransfers(moveEvents);
-                rmSync(join(this.controlPlaneRoot, JOURNAL_FILE), { force: true });
+                rmSync(join(this.controlPlaneRoot, STORE_JOURNAL_FILE), { force: true });
             }
             else {
                 this.saveLedger();
@@ -2226,10 +2110,10 @@ export class FileMemoryEngineBackend {
         scored.sort((a, b) => band(a) - band(b) || a.score - b.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
         return scored.slice(0, limit);
     }
-    async applyPatches(patches) {
+    async applyPatches(patches, opts) {
         const lock = await this.acquireTxnLock();
         try {
-            return await this.applyPatchesLocked(patches, lock.token);
+            return await this.applyPatchesLocked(patches, lock.token, opts?.anchoredRoot);
         }
         catch (err) {
             throw withPermissionRemedy(err, this.directoryRoot);
@@ -2239,117 +2123,18 @@ export class FileMemoryEngineBackend {
         }
     }
     txnLockDir() {
-        return join(this.controlPlaneRoot, "txn.lock");
-    }
-    async acquireTxnLock(timings = {}) {
-        const staleMs = timings.staleMs ?? TXN_LOCK_STALE_MS;
-        const waitMs = timings.waitMs ?? TXN_LOCK_WAIT_MS;
-        const stealGraceMs = timings.stealGraceMs ?? TXN_LOCK_STEAL_GRACE_MS;
-        const lockDir = this.txnLockDir();
-        const ownerPath = join(lockDir, "owner");
-        mkdirSync(this.controlPlaneRoot, { recursive: true });
-        const start = Date.now();
-        let deadline = start + waitMs;
-        for (;;) {
-            let acquired = false;
-            try {
-                mkdirSync(lockDir);
-                acquired = true;
-            }
-            catch (err) {
-                if (err.code !== "EEXIST")
-                    throw err;
-            }
-            if (acquired) {
-                const token = randomUUID();
-                try {
-                    const fd = openSync(ownerPath, "w", 0o600);
-                    try {
-                        writeAllSync(fd, token);
-                        fsyncSync(fd);
-                    }
-                    finally {
-                        closeSync(fd);
-                    }
-                }
-                catch (err) {
-                    try {
-                        rmSync(lockDir, { recursive: true, force: true });
-                    }
-                    catch {
-                    }
-                    throw new Error(`memory txn lock owner token could not be written at ${ownerPath}: ${thrownText(err)}`);
-                }
-                return {
-                    token,
-                    release: () => {
-                        try {
-                            if (readFileSync(ownerPath, "utf8") !== token)
-                                return;
-                        }
-                        catch {
-                            return;
-                        }
-                        try {
-                            rmSync(lockDir, { recursive: true, force: true });
-                        }
-                        catch {
-                        }
-                    },
-                };
-            }
-            let mtimeMs;
-            try {
-                mtimeMs = statSync(lockDir).mtimeMs;
-            }
-            catch {
-                mtimeMs = undefined;
-            }
-            if (mtimeMs !== undefined) {
-                const staleAt = mtimeMs + staleMs;
-                deadline = Math.max(deadline, staleAt + stealGraceMs);
-                if (Date.now() > staleAt) {
-                    let tokenPresent = false;
-                    try {
-                        statSync(ownerPath);
-                        tokenPresent = true;
-                    }
-                    catch {
-                    }
-                    if (tokenPresent) {
-                        const tomb = join(this.controlPlaneRoot, `txn.lock.stale-${randomUUID()}`);
-                        let stolen = false;
-                        try {
-                            renameSync(lockDir, tomb);
-                            stolen = true;
-                        }
-                        catch {
-                        }
-                        if (stolen)
-                            rmSync(tomb, { recursive: true, force: true });
-                    }
-                }
-            }
-            if (Date.now() > deadline) {
-                throw new Error(`memory txn lock timeout (${waitMs}ms, extended to the lock's stale line) at ${lockDir} — another writer is wedged?`);
-            }
-            await new Promise((r) => setTimeout(r, 20 + Math.floor(Math.random() * 40)));
-        }
+        return join(this.controlPlaneRoot, STORE_TXN_LOCK_DIR);
+    }
+    acquireTxnLock(timings = {}) {
+        return acquireStoreTxnLock(this.controlPlaneRoot, { now: Date.now, timings });
     }
     assertTxnLockOwnership(token) {
-        let held;
-        try {
-            held = readFileSync(join(this.txnLockDir(), "owner"), "utf8");
-        }
-        catch {
-            held = undefined;
-        }
-        if (held !== token) {
-            throw new ControlPlaneCorruptError("txn lock ownership lost before commit (holder stalled past the stale deadline and was stolen from?) — transaction aborted, nothing was committed", { facet: "lock-ownership" });
-        }
+        assertStoreTxnLockOwnership(this.controlPlaneRoot, token);
     }
-    async applyPatchesLocked(patches, lockToken) {
+    async applyPatchesLocked(patches, lockToken, anchoredRoot) {
         this.assertTxnLockOwnership(lockToken);
+        if (anchoredRoot !== undefined)
+            this.assertRootAnchored(anchoredRoot);
         this.ledger = undefined;
         this.recoverJournal({ token: lockToken });
         this.adoptLayoutLocked(lockToken, patches.find((p) => p.op === "add" && p.entry !== undefined)?.entry?.scope);
@@ -2393,7 +2178,7 @@ export class FileMemoryEngineBackend {
         const stagedFiles = [];
         const refuseUnstaging = (batch, at) => {
             try {
-                this.refuseEscapingTargets(batch, at);
+                this.refuseEscapingTargets(batch, at, anchoredRoot);
             }
             catch (err) {
                 for (const f of stagedFiles) {
@@ -2439,7 +2224,7 @@ export class FileMemoryEngineBackend {
             this.precheckTransfersAppendable();
         const journal = { txn, ops, ledger2: ledgerEnvelope(rows, this.envelopeExtras), ...(coherentTransfers.length > 0 ? { transfers: coherentTransfers } : {}) };
         refuseUnstaging(ops, "applyPatches (commit point)");
-        atomicWriteFileSync(join(this.controlPlaneRoot, JOURNAL_FILE), JSON.stringify(journal));
+        atomicWriteFileSync(join(this.controlPlaneRoot, STORE_JOURNAL_FILE), JSON.stringify(journal));
         for (const op of ops) {
             this.refuseEscapingTargets([op], "applyPatches (after the commit point; the journal is kept)");
             if (op.kind === "write" && op.staged) {
@@ -2462,7 +2247,7 @@ export class FileMemoryEngineBackend {
         return report;
     }
     closeJournalIfOurs(txn) {
-        const jp = join(this.controlPlaneRoot, JOURNAL_FILE);
+        const jp = join(this.controlPlaneRoot, STORE_JOURNAL_FILE);
         let raw;
         try {
             raw = readFileSync(jp, "utf8");
@@ -2867,7 +2652,7 @@ export class FileMemoryEngineBackend {
                 this.precheckTransfersAppendable();
                 const journal = { txn, ops, ledger2: ledgerEnvelope(rows, this.envelopeExtras), transfers };
                 this.refuseEscapingTargets(ops, "eraseWithEvidence (commit point)");
-                atomicWriteFileSync(join(this.controlPlaneRoot, JOURNAL_FILE), JSON.stringify(journal));
+                atomicWriteFileSync(join(this.controlPlaneRoot, STORE_JOURNAL_FILE), JSON.stringify(journal));
                 for (const op of ops) {
                     this.refuseEscapingTargets([op], "eraseWithEvidence (after the commit point; the journal is kept)");
                     if (op.kind === "delete") {
@@ -2946,7 +2731,7 @@ export class FileMemoryEngineBackend {
     static AUDIT_FENCE_ATTEMPTS = 6;
     static AUDIT_FENCE_RETRY_MS = 25;
     auditJournalPending() {
-        return readControlFileOrAbsent(join(this.controlPlaneRoot, JOURNAL_FILE), "transaction journal") !== undefined;
+        return readControlFileOrAbsent(join(this.controlPlaneRoot, STORE_JOURNAL_FILE), "transaction journal") !== undefined;
     }
     auditReadLedger() {
         const path = join(this.controlPlaneRoot, LEDGER_FILE);

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

@@ -17,7 +17,7 @@ export type { OriginClearanceRow, OriginClearanceEvent, OriginClearanceShadow }
 export { MEMORY_ORIGIN_CAUSES, writableRootOf } from "./types.js";
 export type { MemoryBackend, MemoryEntry, MemoryEntryFrontmatter, MemoryEntryOrigin, MemoryOriginCause, MemoryScopeEnumeration, MemoryEntryDistilled, MemoryEntryDistilledInput, MemoryEntryHeader, ScoredMemoryEntry, NotePatch, PatchReport, MaterializedFile, MemorySessionHandle, HarvestReport, HarvestRejection, HarvestRejectionCode, MemoryAnnouncement, ScanFinding, } from "./types.js";
 export { memoryBackendContract, assertMemoryBackendSearchEquivalence, type MemoryBackendContractHooks, } from "./memory-backend-contract.js";
-export { SCOPE_SEGMENT_MAX_ENCODED, PROJECT_MARKER_PATH, encodeScopeSegment, decodeScopeSegment, parseScopeKey, formatUserScope, formatOrgScope, formatProjScope, formatUserProjScope, isPersonalScope, assertScopeContractPlacement, formatProjectMarker, parseProjectMarker, resolveProjectId, PROJECT_ID_REGEX, type ParsedScopeKey, } from "./scope-contract.js";
+export { SCOPE_SEGMENT_MAX_ENCODED, PROJECT_MARKER_PATH, encodeScopeSegment, decodeScopeSegment, parseScopeKey, formatUserScope, formatOrgScope, formatProjScope, formatUserProjScope, isPersonalScope, isOrgScopeKey, assertScopeContractPlacement, formatProjectMarker, parseProjectMarker, resolveProjectId, PROJECT_ID_REGEX, type ParsedScopeKey, } from "./scope-contract.js";
 export { migrateScope, type MigrateScopeReport } from "./migrate.js";
 export { materializeEntriesToFiles, harvestFilesToPatches, projectionsToWriteBack, screenInboundEntries, REMOTE_HARVEST_PER_FILE_BYTES, REMOTE_MASS_DELETION_FUSE_RATIO, type RemoteMemoryFile, type RemoteMemoryBaseline, type RemoteMaterialization, type RemoteHarvestResult, type InboundEntryFinding, } from "./data-plane.js";
 export { reconcileMemoryEntries, nextSyncBaseline, mergeRecallHits, type MemorySyncCursor, type MemorySyncConflict, type MemorySyncPlan, type RecallSource, } from "./sync.js";

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

@@ -15,7 +15,7 @@ export { DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, LLM_DISTILLER_CONTRACT, LLM_D
 export { CONSOLIDATION_DRIVER_PLANS_DIR, CONSOLIDATION_DRIVER_RUNS_FILE, archiveDistillerPlan, readConsolidationDriverRun, runMemoryConsolidationDriver, } from "./consolidation-driver.js";
 export { MEMORY_ORIGIN_CAUSES, writableRootOf } from "./types.js";
 export { memoryBackendContract, assertMemoryBackendSearchEquivalence, } from "./memory-backend-contract.js";
-export { SCOPE_SEGMENT_MAX_ENCODED, PROJECT_MARKER_PATH, encodeScopeSegment, decodeScopeSegment, parseScopeKey, formatUserScope, formatOrgScope, formatProjScope, formatUserProjScope, isPersonalScope, assertScopeContractPlacement, formatProjectMarker, parseProjectMarker, resolveProjectId, PROJECT_ID_REGEX, } from "./scope-contract.js";
+export { SCOPE_SEGMENT_MAX_ENCODED, PROJECT_MARKER_PATH, encodeScopeSegment, decodeScopeSegment, parseScopeKey, formatUserScope, formatOrgScope, formatProjScope, formatUserProjScope, isPersonalScope, isOrgScopeKey, assertScopeContractPlacement, formatProjectMarker, parseProjectMarker, resolveProjectId, PROJECT_ID_REGEX, } from "./scope-contract.js";
 export { migrateScope } from "./migrate.js";
 export { materializeEntriesToFiles, harvestFilesToPatches, projectionsToWriteBack, screenInboundEntries, REMOTE_HARVEST_PER_FILE_BYTES, REMOTE_MASS_DELETION_FUSE_RATIO, } from "./data-plane.js";
 export { reconcileMemoryEntries, nextSyncBaseline, mergeRecallHits, } from "./sync.js";