dotmem 0.0.8 → 0.1.0

package/cli.js

@@ -30,6 +30,18 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// suppress-idb-warning.ts
+var orig;
+var init_suppress_idb_warning = __esm({
+  "suppress-idb-warning.ts"() {
+    orig = console.warn.bind(console);
+    console.warn = (...args) => {
+      if (typeof args[0] === "string" && args[0].includes("IndexedDB is not available")) return;
+      orig(...args);
+    };
+  }
+});
+
 // core/env.ts
 var DEV;
 var init_env = __esm({
@@ -64,6 +76,7 @@ function configure(opts) {
 var g, STORE_PREFIX, INDEX_KEY, journal, journal_default;
 var init_journal = __esm({
   "core/memory/journal.ts"() {
+    init_suppress_idb_warning();
     init_env();
     g = globalThis;
     __name(namespace, "namespace");
@@ -2989,6 +3002,7 @@ var init_policy_store = __esm({
       if (entry.target !== void 0) built.target = entry.target;
       if (entry.reason !== void 0) built.reason = entry.reason;
       if (entry.detail !== void 0) built.detail = entry.detail;
+      if (entry.mandatory !== void 0) built.mandatory = entry.mandatory;
       return built;
     }, "validatePolicyAuditEntry");
     validatePolicyDocument = /* @__PURE__ */ __name((value) => {
@@ -3066,6 +3080,7 @@ var init_policy_store = __esm({
       if (entry.target !== void 0) built.target = entry.target;
       if (entry.reason !== void 0) built.reason = entry.reason;
       if (entry.detail !== void 0) built.detail = entry.detail;
+      if (entry.mandatory !== void 0) built.mandatory = entry.mandatory;
       return built;
     }, "buildAuditEntry");
     boundedAudit = /* @__PURE__ */ __name((entries2, overrides) => {
@@ -3078,9 +3093,10 @@ var init_policy_store = __esm({
       for (let index = entries2.length - 1; index >= 0; index--) {
         const entry = entries2[index];
         const activeLinked = entry.target !== void 0 && activeOverrideIds.has(entry.target) && (entry.action === "override" || entry.action === "revoke");
-        if (activeLinked || budget > 0) {
+        const mandatory = entry.mandatory === true;
+        if (activeLinked || mandatory || budget > 0) {
           kept.unshift(entry);
-          if (!activeLinked) budget--;
+          if (!activeLinked && !mandatory) budget--;
         }
       }
       return kept;
@@ -3121,6 +3137,12 @@ var init_policy_store = __esm({
         try {
           await fs5.writeFile(temporary, `${JSON.stringify(document, null, 2)}
 `, "utf8");
+          const handle = await fs5.open(temporary, "r+");
+          try {
+            await handle.sync();
+          } finally {
+            await handle.close();
+          }
           await fs5.rename(temporary, filePath);
         } catch (error) {
           await fs5.rm(temporary, { force: true }).catch(() => void 0);
@@ -5254,7 +5276,7 @@ function encodeMemFile(stateValue, preserved) {
 function decodeMemDocument(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid .mem file format");
   const file = value;
-  if (file.format !== MEM_FORMAT) throw new Error("Invalid .mem file format");
+  if (file.format !== MEM_FORMAT && file.format !== MEM_FORMAT_LEGACY) throw new Error("Invalid .mem file format");
   if (file.version === MEM_FORMAT_VERSION_V1) {
     if (!file.knowledge) throw new Error("Invalid .mem file format");
     return { state: validateSourceState(file.knowledge) };
@@ -5336,11 +5358,12 @@ function decodeMemDocument(value) {
     preserved: { map: structuredClone(map), data: structuredClone(stateRecord) }
   };
 }
-var MEM_FORMAT, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
+var MEM_FORMAT, MEM_FORMAT_LEGACY, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
 var init_mem_codec = __esm({
   "core/knowledge/mem-codec.ts"() {
     init_state();
     MEM_FORMAT = "dotmem.knowledge";
+    MEM_FORMAT_LEGACY = "memorio.knowledge";
     MEM_FORMAT_VERSION = 2;
     MEM_FORMAT_VERSION_V1 = 1;
     expectedFields = {
@@ -5489,12 +5512,13 @@ async function inspectMem(input) {
     return { status: artifactError.code, representation: "unknown", message: artifactError.message, parts: [] };
   }
 }
-var MEM_PACKAGE_FORMAT, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, signaturePayload, base64UrlDecode, keyIdentity, signaturePath, encodePackage, isZip, decodePackage, verifySignature;
+var MEM_PACKAGE_FORMAT, MEM_PACKAGE_FORMAT_LEGACY, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, signaturePayload, base64UrlDecode, keyIdentity, signaturePath, encodePackage, isZip, decodePackage, verifySignature;
 var init_mem_package = __esm({
   "core/knowledge/mem-package.ts"() {
     init_browser();
     init_mem_codec();
     MEM_PACKAGE_FORMAT = "dotmem.package";
+    MEM_PACKAGE_FORMAT_LEGACY = "memorio.package";
     MEM_PACKAGE_VERSION = 1;
     MEM_PACKAGE_LIMITS = Object.freeze({
       maximumPackageBytes: 10 * 1024 * 1024,
@@ -5679,10 +5703,10 @@ ${contentId}
         if (!parts[path3]) throw new MemArtifactError("invalid", `Missing MEM package part: ${path3}`);
       }
       const manifest = parseJson(parts[MANIFEST_PATH], MANIFEST_PATH);
-      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format || manifest.version !== MEM_PACKAGE_VERSION) {
+      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format !== MEM_PACKAGE_FORMAT_LEGACY || manifest.version !== MEM_PACKAGE_VERSION) {
         throw new MemArtifactError("unsupported", "Unsupported MEM package format or version");
       }
-      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
+      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format !== MEM_FORMAT_LEGACY || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
         throw new MemArtifactError("invalid", "Invalid MEM package manifest");
       }
       const integrity = parseJson(parts[INTEGRITY_PATH], INTEGRITY_PATH);
@@ -5794,6 +5818,109 @@ ${contentId}
   }
 });
 
+// core/storage-coordinator/index.ts
+var nodeFs4, withStorageLock, readStorageGeneration, writeStorageGeneration;
+var init_storage_coordinator = __esm({
+  "core/storage-coordinator/index.ts"() {
+    nodeFs4 = /* @__PURE__ */ __name(async () => import('fs/promises'), "nodeFs");
+    withStorageLock = /* @__PURE__ */ __name(async (directoryPath, operationOrOptions, operation, _options = {}) => {
+      const opts = typeof operationOrOptions === "function" ? operation ?? {} : operationOrOptions ?? {};
+      const op = typeof operationOrOptions === "function" ? operationOrOptions : operation;
+      const timeoutMs = opts.timeoutMs ?? 3e4;
+      const staleMs = opts.staleMs ?? 6e4;
+      const lockName = opts.lockName ?? ".storage.lock";
+      const lockPath = `${directoryPath}/${lockName}`;
+      const fs5 = await nodeFs4();
+      const started = Date.now();
+      await fs5.mkdir(directoryPath, { recursive: true });
+      while (true) {
+        try {
+          await fs5.mkdir(lockPath);
+          const token2 = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+          await fs5.writeFile(`${lockPath}/owner.json`, JSON.stringify({ token: token2, pid: process.pid, createdAt: Date.now() }), { flag: "wx" });
+          break;
+        } catch (error) {
+          const code = error.code;
+          if (code !== "EEXIST" && code !== "ENOENT" && code !== "EPERM" && code !== "ENOTEMPTY") throw error;
+          let stale = false;
+          let processDead = false;
+          try {
+            const raw = await fs5.readFile(`${lockPath}/owner.json`, "utf8");
+            const parsed = JSON.parse(raw);
+            const ageStale = typeof parsed.createdAt === "number" && Date.now() - parsed.createdAt > staleMs;
+            if (typeof parsed.pid === "number") {
+              try {
+                process.kill(parsed.pid, 0);
+              } catch {
+                processDead = true;
+              }
+            } else {
+              processDead = true;
+            }
+            if (ageStale || processDead) stale = true;
+          } catch {
+            stale = true;
+          }
+          if (stale) {
+            if (processDead) {
+              try {
+                await fs5.rm(lockPath, { recursive: true, force: true });
+                continue;
+              } catch {
+              }
+            }
+            try {
+              await fs5.rmdir(lockPath);
+              continue;
+            } catch {
+            }
+          }
+          if (Date.now() - started > timeoutMs) {
+            throw new Error(`Storage lock timeout for ${directoryPath}`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+      }
+      let token = "";
+      try {
+        const raw = await fs5.readFile(`${lockPath}/owner.json`, "utf8");
+        token = JSON.parse(raw).token ?? "";
+      } catch {
+        token = "";
+      }
+      try {
+        return await op();
+      } finally {
+        try {
+          const raw = await fs5.readFile(`${lockPath}/owner.json`, "utf8");
+          const parsed = JSON.parse(raw);
+          if (parsed.token === token && token) {
+            await fs5.rm(lockPath, { recursive: true, force: true });
+          }
+        } catch {
+        }
+      }
+    }, "withStorageLock");
+    readStorageGeneration = /* @__PURE__ */ __name(async (directoryPath) => {
+      const fs5 = await nodeFs4();
+      try {
+        const raw = await fs5.readFile(`${directoryPath}/.storage.generation`, "utf8");
+        const value = Number(raw.trim());
+        return Number.isFinite(value) && value >= 0 ? value : 0;
+      } catch {
+        return 0;
+      }
+    }, "readStorageGeneration");
+    writeStorageGeneration = /* @__PURE__ */ __name(async (directoryPath, value) => {
+      const fs5 = await nodeFs4();
+      await fs5.mkdir(directoryPath, { recursive: true });
+      const temp = `${directoryPath}/.storage.generation.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+      await fs5.writeFile(temp, String(value));
+      await fs5.rename(temp, `${directoryPath}/.storage.generation`);
+    }, "writeStorageGeneration");
+  }
+});
+
 // core/knowledge/mem-repository.ts
 function resolveDuplicate(existing, existingSource, current, currentSource) {
   const existingRetracts = existing.revision?.kind === "retracts";
@@ -5834,19 +5961,20 @@ async function parseMemFile(value, sourceId) {
     throw new Error(`${message} in ${sourceId}`);
   }
 }
-var DOTMEM_DIRECTORY, DEFAULT_MEM_FILE, directoryLocks, nodeFs4, separator2, normalizePath, isAbsolutePath, resolvePath, joinPath2, parentPath, uniqueSuffix, withDirectoryLock, isMissingDirectory, sourcePriority, memFilePath, MemDirectoryKnowledgeRepository;
+var DOTMEM_DIRECTORY, DEFAULT_MEM_FILE, nodeFs5, repositoryLoadCaches, separator2, normalizePath, isAbsolutePath, resolvePath, joinPath2, parentPath, uniqueSuffix, isMissingDirectory, sourcePriority, memFilePath, MemDirectoryKnowledgeRepository;
 var init_mem_repository = __esm({
   "core/knowledge/mem-repository.ts"() {
     init_mem_codec();
     init_mem_package();
     init_state();
     init_acquisition_limits();
+    init_storage_coordinator();
     DOTMEM_DIRECTORY = ".dotmem";
     DEFAULT_MEM_FILE = "project.mem";
-    directoryLocks = /* @__PURE__ */ new Map();
-    nodeFs4 = /* @__PURE__ */ __name(async () => {
+    nodeFs5 = /* @__PURE__ */ __name(async () => {
       return import('fs/promises');
     }, "nodeFs");
+    repositoryLoadCaches = /* @__PURE__ */ new Map();
     separator2 = /* @__PURE__ */ __name(() => process.platform === "win32" ? "\\" : "/", "separator");
     normalizePath = /* @__PURE__ */ __name((value) => value.replace(/[\\/]+/g, separator2()), "normalizePath");
     isAbsolutePath = /* @__PURE__ */ __name((value) => /^(?:[A-Za-z]:[\\/]|[\\/])/.test(value), "isAbsolutePath");
@@ -5858,25 +5986,8 @@ var init_mem_repository = __esm({
       return index <= 0 ? "." : normalized.slice(0, index);
     }, "parentPath");
     uniqueSuffix = /* @__PURE__ */ __name(() => globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`, "uniqueSuffix");
-    withDirectoryLock = /* @__PURE__ */ __name(async (directoryPath, operation) => {
-      const previous = directoryLocks.get(directoryPath) ?? Promise.resolve();
-      let release = /* @__PURE__ */ __name(() => void 0, "release");
-      const gate = new Promise((resolveGate) => {
-        release = resolveGate;
-      });
-      const queued = previous.then(() => gate);
-      directoryLocks.set(directoryPath, queued);
-      await previous;
-      try {
-        return await operation();
-      } finally {
-        release();
-        if (directoryLocks.get(directoryPath) === queued) directoryLocks.delete(directoryPath);
-      }
-    }, "withDirectoryLock");
     isMissingDirectory = /* @__PURE__ */ __name((error) => error.code === "ENOENT", "isMissingDirectory");
     sourcePriority = /* @__PURE__ */ __name((sourceId, scope) => {
-      if (sourceId.endsWith(".mem") && sourceId !== "project.mem" && sourceId !== "user.mem" && sourceId !== "agent.mem") return 0;
       if (scope === "project" || sourceId === "project.mem") return 4;
       if (scope === "user" || sourceId === "user.mem") return 3;
       if (sourceId === "agent.mem" || sourceId === "agent") return 2;
@@ -5904,7 +6015,7 @@ var init_mem_repository = __esm({
         this.loadWritableOnly = loadWritableOnly;
       }
       async discover() {
-        const { readdir } = await nodeFs4();
+        const { readdir } = await nodeFs5();
         try {
           const entries2 = await readdir(this.directoryPath, { withFileTypes: true });
           return entries2.filter((entry) => entry.isFile() && entry.name.endsWith(".mem") && entry.name !== "@brain.mem").map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
@@ -5919,7 +6030,7 @@ var init_mem_repository = __esm({
        * receive a clear failure instead of discovering corruption on first use.
        */
       async initialize() {
-        const { mkdir } = await nodeFs4();
+        const { mkdir } = await nodeFs5();
         await mkdir(this.directoryPath, { recursive: true });
         await this.load();
       }
@@ -5934,7 +6045,7 @@ var init_mem_repository = __esm({
        * that does not delete is not a delete.
        */
       async clearWritable() {
-        const { rm, readdir } = await nodeFs4();
+        const { rm, readdir } = await nodeFs5();
         const filePath = memFilePath(this.directoryPath, this.writableSourceId);
         await rm(filePath, { force: true });
         await rm(`${filePath}.bak`, { force: true });
@@ -5951,15 +6062,28 @@ var init_mem_repository = __esm({
         }
       }
       async load() {
-        const loaded = this.loadWritableOnly ? await this.loadSources([this.writableSourceId]) : await this.loadSources();
-        return this.combine(loaded);
+        const cacheKey = `${this.directoryPath}:${this.writableSourceId}:${this.loadWritableOnly}`;
+        for (let attempt = 0; attempt < 5; attempt += 1) {
+          const generationBefore = await readStorageGeneration(this.directoryPath);
+          const cached = repositoryLoadCaches.get(cacheKey);
+          if (cached && cached.signature === String(generationBefore)) {
+            return structuredClone(cached.state);
+          }
+          const loaded = this.loadWritableOnly ? await this.loadSources([this.writableSourceId]) : await this.loadSources();
+          const state2 = this.combine(loaded);
+          const generationAfter = await readStorageGeneration(this.directoryPath);
+          if (generationBefore !== generationAfter && attempt < 4) continue;
+          repositoryLoadCaches.set(cacheKey, { signature: String(generationAfter), state: structuredClone(state2) });
+          return state2;
+        }
+        throw new Error("Unable to load stable repository state");
       }
-      async save(state2, expectedVersion) {
+      async save(state2, expectedVersion, locked = false) {
         const validated = validateKnowledgeState(state2);
         if (!Number.isInteger(expectedVersion) || expectedVersion < 0 || validated.version !== expectedVersion + 1) {
           throw new Error("Invalid expected persisted version");
         }
-        await withDirectoryLock(this.directoryPath, async () => {
+        const doWrite = /* @__PURE__ */ __name(async () => {
           const loaded = await this.loadSources();
           const writable = loaded.find((source) => source.id === this.writableSourceId) ?? {
             id: this.writableSourceId,
@@ -5981,10 +6105,16 @@ var init_mem_repository = __esm({
             claims: [...writable.state.claims, ...newClaims]
           };
           await this.writeSource(writable.filePath, nextWritable, writable.preserved, writable.package);
-        });
+          await writeStorageGeneration(this.directoryPath, await readStorageGeneration(this.directoryPath) + 1);
+        }, "doWrite");
+        if (locked) {
+          await doWrite();
+        } else {
+          await withStorageLock(this.directoryPath, doWrite);
+        }
       }
       async loadSources(sourceIds) {
-        const { readFile: readFile8 } = await nodeFs4();
+        const { readFile: readFile8 } = await nodeFs5();
         const ids = sourceIds ?? await this.discover();
         const sources = [];
         for (const sourceId of ids) {
@@ -6074,7 +6204,7 @@ var init_mem_repository = __esm({
        * valid package, so the backup is always a version this library can read.
        */
       async keepLastValidVersion(filePath) {
-        const { readFile: readFile8, copyFile, rename, rm } = await nodeFs4();
+        const { readFile: readFile8, copyFile, rename, rm } = await nodeFs5();
         let current;
         try {
           current = await readFile8(filePath);
@@ -6098,7 +6228,7 @@ var init_mem_repository = __esm({
       }
       /** Best-effort directory sync: the rename is durable once the directory is. */
       async syncDirectory(directoryPath) {
-        const { open } = await nodeFs4();
+        const { open } = await nodeFs5();
         try {
           const handle = await open(directoryPath, "r");
           try {
@@ -6110,7 +6240,7 @@ var init_mem_repository = __esm({
         }
       }
       async writeSource(filePath, state2, preserved, preservedPackage) {
-        const { mkdir, rename, rm, open, readFile: readFile8 } = await nodeFs4();
+        const { mkdir, rename, rm, open, readFile: readFile8 } = await nodeFs5();
         if (!Number.isInteger(state2.version) || state2.version < 0) throw new Error("Invalid writable .mem knowledge version");
         for (const claim of state2.claims) validateClaim(claim);
         await mkdir(parentPath(filePath), { recursive: true });
@@ -6980,7 +7110,7 @@ var init_project_identity = __esm({
 });
 
 // core/knowledge/staging.ts
-var DOTMEM_STAGE_FORMAT, DOTMEM_STAGE_VERSION, StageFileError, generateRequestId, nodeCwd, resolveStagingDirectory, stagePathFor, nodeFs5, normalizeClaimIds, revisionFromOptions, writeStageFile, readStageFile, validateStageFile, commitStageFile, cleanupStageFile;
+var DOTMEM_STAGE_FORMAT, DOTMEM_STAGE_VERSION, StageFileError, generateRequestId, nodeCwd, resolveStagingDirectory, stagePathFor, nodeFs6, normalizeClaimIds, revisionFromOptions, writeStageFile, readStageFile, validateStageFile, commitStageFile, cleanupStageFile;
 var init_staging = __esm({
   "core/knowledge/staging.ts"() {
     init_claim_record();
@@ -7015,7 +7145,7 @@ var init_staging = __esm({
       return `${base}/dotmem`;
     }, "resolveStagingDirectory");
     stagePathFor = /* @__PURE__ */ __name((requestId) => `${resolveStagingDirectory()}/${requestId}.stage`, "stagePathFor");
-    nodeFs5 = /* @__PURE__ */ __name(async () => import('fs/promises'), "nodeFs");
+    nodeFs6 = /* @__PURE__ */ __name(async () => import('fs/promises'), "nodeFs");
     normalizeClaimIds = /* @__PURE__ */ __name((value) => {
       if (!value) return [];
       return Array.isArray(value) ? value : [value];
@@ -7040,7 +7170,7 @@ var init_staging = __esm({
       };
       const requestId = generateRequestId();
       const stagePath = stagePathFor(requestId);
-      const fs5 = await nodeFs5();
+      const fs5 = await nodeFs6();
       await fs5.mkdir(resolveStagingDirectory(), { recursive: true });
       const stageFile = {
         format: DOTMEM_STAGE_FORMAT,
@@ -7060,7 +7190,7 @@ var init_staging = __esm({
     }, "writeStageFile");
     readStageFile = /* @__PURE__ */ __name(async (requestId) => {
       const stagePath = stagePathFor(requestId);
-      const fs5 = await nodeFs5();
+      const fs5 = await nodeFs6();
       try {
         const content = await fs5.readFile(stagePath, "utf8");
         return JSON.parse(content);
@@ -7171,7 +7301,7 @@ var init_staging = __esm({
     }, "commitStageFile");
     cleanupStageFile = /* @__PURE__ */ __name(async (requestId) => {
       const stagePath = stagePathFor(requestId);
-      const fs5 = await nodeFs5();
+      const fs5 = await nodeFs6();
       try {
         await fs5.unlink(stagePath);
       } catch (error) {
@@ -8949,6 +9079,7 @@ function _inferConfidence(claim) {
 var LOGIC_MEM_FILE, nodeCwd2, cachedRuntime, LogicEngine, logic, logic_default;
 var init_logic = __esm({
   "core/logic/index.ts"() {
+    init_suppress_idb_warning();
     init_knowledge();
     init_mem_repository();
     init_acquisition_boundary();
@@ -9342,6 +9473,7 @@ async function resetKnowledgeRuntimeCaches() {
 var EmptyLogicRepository, KNOWLEDGE_STATE_KEY, knowledgeSaveQueue, StoreKnowledgeRepository, RuntimeSlot, projectSlot, userSlot, installDotMemReadme;
 var init_knowledge_runtime = __esm({
   "core/memory/knowledge-runtime.ts"() {
+    init_suppress_idb_warning();
     init_knowledge();
     init_project_identity();
     init_user_paths();
@@ -9874,6 +10006,7 @@ async function getEntry(key) {
 var MEMORY_INDEX_KEY, SUPERSEDED_PREFIX, entries;
 var init_entries = __esm({
   "core/memory/entries.ts"() {
+    init_suppress_idb_warning();
     init_env();
     init_journal();
     MEMORY_INDEX_KEY = "__dotmem_memory_index__";
@@ -10226,15 +10359,18 @@ async function findClaimAcrossAllSources(claimId, scope, sourceProject) {
 var acquire;
 var init_acquire = __esm({
   "core/memory/acquire.ts"() {
+    init_suppress_idb_warning();
     init_env();
     init_project_identity();
     init_project_anchor();
     init_acquisition_boundary();
     init_claim_record();
+    init_state();
     init_router();
     init_store_queue();
     init_staging();
     init_user_paths();
+    init_storage_coordinator();
     init_mem_repository();
     init_knowledge_runtime();
     __name(normalizeClaimIds3, "normalizeClaimIds");
@@ -10270,23 +10406,27 @@ var init_acquire = __esm({
           );
         }
         const revision = revisionFromAcquire2(opts);
+        const repository = target.repository;
         await withStoreQueue(acquisitionStoreKey(kind, scope, sourceProject), async () => {
-          const state2 = await target.runtime.select([]);
-          await target.runtime.update({
-            basedOnVersion: state2.context.knowledgeVersion,
-            claims: [buildClaimRecord({
-              id: opts.id,
-              knowledge: boundary.knowledge,
-              applicability: opts.applicability,
-              evidence: opts.evidence,
-              epistemicType: opts.epistemicType,
-              provenance: opts.provenance,
-              acquiredAt: opts.acquiredAt,
-              revision,
-              scope,
-              sourceProject,
-              kind
-            })]
+          await withStorageLock(repository.directoryPath, async () => {
+            const state2 = await repository.load();
+            const next = updateKnowledge(state2, {
+              basedOnVersion: state2.version,
+              claims: [buildClaimRecord({
+                id: opts.id,
+                knowledge: boundary.knowledge,
+                applicability: opts.applicability,
+                evidence: opts.evidence,
+                epistemicType: opts.epistemicType,
+                provenance: opts.provenance,
+                acquiredAt: opts.acquiredAt,
+                revision,
+                scope,
+                sourceProject,
+                kind
+              })]
+            });
+            await repository.save(next, state2.version, true);
           });
         });
         const verification = await target.repository.load();
@@ -11818,6 +11958,7 @@ async function bootstrapProject() {
 var pendingDetectionEvents, detectionFlushScheduled, flushDetectionEvents, memory;
 var init_memory = __esm({
   "core/memory/index.ts"() {
+    init_suppress_idb_warning();
     init_journal();
     init_brain();
     init_knowledge_runtime();
@@ -12724,6 +12865,7 @@ var init_policy3 = __esm({
 });
 
 // core/cli/index.ts
+init_suppress_idb_warning();
 init_memory();
 
 // core/continuity/freshness.ts
@@ -12956,6 +13098,10 @@ var saveContinuityDocument = /* @__PURE__ */ __name(async (path3, document) => {
   }
 }, "saveContinuityDocument");
 
+// core/continuity-ledger/index.ts
+init_memory();
+init_memory();
+
 // core/continuity/index.ts
 var continuity = {
   async context(options) {
@@ -14100,7 +14246,7 @@ Run \`npx dotmem <command> --help\` for command-specific options.
 Memory:
   context "<situation>" [--explain] [--json] [--full] [--claims-only] [--limit <N>] [--format brief]
                               project acquired experience for a situation
-  init                         initialize dotmem for the current project (.mem/)
+  init                         initialize dotmem for the current project (.dotmem/)
   acquire                      acquire durable experience from a JSON claim on stdin
   learn "<text>" [--scope <user|project>] [--situation "<text>"] [--id "<id>"]
                               acquire a claim from plain text (shorthand for acquire)