dotmem 0.0.8 → 0.0.9

package/cli.cjs

@@ -2998,6 +2998,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) => {
@@ -3075,6 +3076,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) => {
@@ -3087,9 +3089,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;
@@ -3130,6 +3133,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);
@@ -5803,6 +5812,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";
@@ -5843,19 +5955,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");
@@ -5867,25 +5980,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;
@@ -5913,7 +6009,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));
@@ -5928,7 +6024,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();
       }
@@ -5943,7 +6039,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 });
@@ -5960,15 +6056,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,
@@ -5990,10 +6099,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) {
@@ -6083,7 +6198,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);
@@ -6107,7 +6222,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 {
@@ -6119,7 +6234,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 });
@@ -6989,7 +7104,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();
@@ -7024,7 +7139,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];
@@ -7049,7 +7164,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,
@@ -7069,7 +7184,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);
@@ -7180,7 +7295,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) {
@@ -10240,10 +10355,12 @@ var init_acquire = __esm({
     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");
@@ -10279,23 +10396,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();
@@ -12965,6 +13086,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) {