@remnic/core 1.1.30 → 9.3.515

package/dist/{chunk-QKZGQIPJ.js → chunk-3Q4H3OBR.js}

@@ -2,13 +2,13 @@ import {
   exportWorkBoardMarkdown,
   exportWorkBoardSnapshot,
   importWorkBoardSnapshot
-} from "./chunk-ZKSK55RC.js";
+} from "./chunk-ETUPBUHB.js";
 import {
   WorkStorage
-} from "./chunk-WELDCG6C.js";
+} from "./chunk-L227SKTB.js";
 import {
   importCapsule
-} from "./chunk-ZYVPLJ4T.js";
+} from "./chunk-DHGSZ3UD.js";
 import {
   applyTagFilter,
   normalizeTags,
@@ -19,11 +19,12 @@ import {
 } from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
-} from "./chunk-FBYESMQ2.js";
+} from "./chunk-3C5RPJAX.js";
 import {
   clusterByKey,
+  projectTagProjectId,
   resolveGitContext
-} from "./chunk-FDU6HUUL.js";
+} from "./chunk-EDQVAMQI.js";
 import {
   getTrustZoneStoreStatus,
   isTrustZoneName,
@@ -32,16 +33,16 @@ import {
   scoreTrustZoneProvenance,
   seedTrustZoneDemoDataset,
   summarizeTrustZonePromotionReadiness
-} from "./chunk-QDZ2RLEC.js";
+} from "./chunk-472U7RDF.js";
 import {
   estimateRecallTokens
-} from "./chunk-MGKYQQYF.js";
+} from "./chunk-7Q3RCKAQ.js";
 import {
   recordObjectiveStateSnapshotsFromObservedMessages
-} from "./chunk-GL6I6MEQ.js";
+} from "./chunk-WSGF57U2.js";
 import {
   objectiveStateStoreOverrideForNamespace
-} from "./chunk-5UM2VJ6D.js";
+} from "./chunk-UEY3VB6W.js";
 import {
   buildProposedActions,
   buildQualityScore,
@@ -49,19 +50,19 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-76FLAAUC.js";
+} from "./chunk-2AN2L4NL.js";
 import {
   recordMemoryOutcome
 } from "./chunk-EIR5VLIH.js";
 import {
   buildGraphSnapshot
-} from "./chunk-PCUKNJAZ.js";
+} from "./chunk-JKV57BTN.js";
 import {
   wrapWorkLayerContext
-} from "./chunk-RRF5UOBJ.js";
+} from "./chunk-EI6V5UXY.js";
 import {
   formatProfileTraceAscii
-} from "./chunk-NBNN5GOB.js";
+} from "./chunk-QY7YA7OL.js";
 import {
   buildProcedurePersistBody,
   normalizeProcedureSteps
@@ -70,30 +71,30 @@ import {
   persistExplicitCapture,
   queueExplicitCaptureForReview,
   validateExplicitCaptureInput
-} from "./chunk-25MQ7IHJ.js";
+} from "./chunk-EUML3N6B.js";
 import {
   CrossNamespaceBudget
-} from "./chunk-GDFS42HT.js";
+} from "./chunk-CHCA44C3.js";
 import {
   FileCalendarSource,
   buildBriefing,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-SIC6U3GZ.js";
+} from "./chunk-YHV3KRKS.js";
 import {
   parseEntityFile
-} from "./chunk-VBJ7V5SK.js";
+} from "./chunk-UIPDNLXA.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
-} from "./chunk-Q7P4WJDP.js";
+} from "./chunk-M5T4Q2ZU.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
 } from "./chunk-SCU65EZI.js";
 import {
   getMemoryProjectionPath
-} from "./chunk-3KW65B36.js";
+} from "./chunk-KILOTVIF.js";
 import {
   inferMemoryStatus,
   toMemoryPathRel
@@ -104,14 +105,14 @@ import {
 import {
   filterTrajectoriesByLookbackDays,
   readCausalTrajectoryRecords
-} from "./chunk-MY6TPVXW.js";
+} from "./chunk-LMPHTYJC.js";
 import {
   canReadNamespace,
   canWriteNamespace,
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
-} from "./chunk-UWVJF25J.js";
+} from "./chunk-HWVTS5NO.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -121,36 +122,111 @@ import {
 import {
   AccessIdempotencyStore,
   hashAccessIdempotencyPayload
-} from "./chunk-XKECPATV.js";
+} from "./chunk-VFUEZZBS.js";
 import {
   exportCapsule
-} from "./chunk-QA2ZAPBU.js";
+} from "./chunk-IPLYGWQF.js";
 import {
+  OFFLINE_SYNC_SNAPSHOT_FORMAT,
   applyOfflineSyncChangeset,
   applyOfflineSyncFileContentChunk,
   buildOfflineSyncSnapshot,
   buildOfflineSyncSnapshotForPaths,
   buildOfflineSyncSnapshotFromBase,
+  iterateOfflineSyncSnapshotFileRecords,
   readOfflineSyncFileContentChunk
-} from "./chunk-MG7NA5H3.js";
+} from "./chunk-4Q73JBSM.js";
 import {
   evaluateActionConfidence
 } from "./chunk-AH2JUU6X.js";
 
 // src/access-service.ts
-import { stat } from "fs/promises";
+import { stat as stat2 } from "fs/promises";
 import * as nodeFs from "fs/promises";
 import { constants as fsConstants } from "fs";
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { ZodError } from "zod";
 
 // src/procedural/procedure-miner.ts
+import { createHash } from "crypto";
+import { mkdir, rm, stat } from "fs/promises";
+import path from "path";
 var PROCEDURE_CLUSTER_ATTR_MAX = 500;
+var PROCEDURE_CLUSTER_LOCK_STALE_MS = 12e4;
+var PROCEDURE_CLUSTER_LOCK_TIMEOUT_MS = 3e4;
+var inProcessClusterWriteLocks = /* @__PURE__ */ new Map();
 function clusterKey(record) {
   const goal = record.goal.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 120);
   const refs = [...record.entityRefs ?? []].map((r) => r.trim().toLowerCase()).sort();
   return `${goal}|${refs.join(",")}`;
 }
+function clusterKeyHash(cluster) {
+  return createHash("sha256").update(cluster).digest("hex");
+}
+function isErrnoCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function acquireClusterWriteLock(memoryDir, clusterHash) {
+  const lockRoot = path.join(path.resolve(memoryDir), "state", "procedure-miner-locks");
+  const lockDir = path.join(lockRoot, `${clusterHash}.lock`);
+  await mkdir(lockRoot, { recursive: true });
+  const startedAt = Date.now();
+  let attempts = 0;
+  while (true) {
+    try {
+      await mkdir(lockDir);
+      return async () => {
+        await rm(lockDir, { recursive: true, force: true });
+      };
+    } catch (err) {
+      if (!isErrnoCode(err, "EEXIST")) throw err;
+    }
+    try {
+      const info = await stat(lockDir);
+      if (Date.now() - info.mtimeMs > PROCEDURE_CLUSTER_LOCK_STALE_MS) {
+        await rm(lockDir, { recursive: true, force: true });
+        continue;
+      }
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) continue;
+      throw err;
+    }
+    if (Date.now() - startedAt > PROCEDURE_CLUSTER_LOCK_TIMEOUT_MS) {
+      throw new Error(`Timed out waiting for procedure cluster write lock ${clusterHash}`);
+    }
+    attempts += 1;
+    await sleep(Math.min(250, 25 * attempts));
+  }
+}
+async function withClusterWriteLock(memoryDir, clusterHash, fn) {
+  const inProcessKey = `${path.resolve(memoryDir)}:${clusterHash}`;
+  const previous = inProcessClusterWriteLocks.get(inProcessKey) ?? Promise.resolve();
+  let releaseInProcess;
+  const current = previous.catch(() => void 0).then(
+    () => new Promise((resolve2) => {
+      releaseInProcess = resolve2;
+    })
+  );
+  inProcessClusterWriteLocks.set(inProcessKey, current);
+  await previous.catch(() => void 0);
+  let releaseDisk = null;
+  try {
+    releaseDisk = await acquireClusterWriteLock(memoryDir, clusterHash);
+    return await fn();
+  } finally {
+    try {
+      if (releaseDisk) await releaseDisk();
+    } finally {
+      releaseInProcess();
+      if (inProcessClusterWriteLocks.get(inProcessKey) === current) {
+        inProcessClusterWriteLocks.delete(inProcessKey);
+      }
+    }
+  }
+}
 function successRate(group) {
   if (group.length === 0) return 0;
   const ok = group.filter((g) => g.outcomeKind === "success" || g.outcomeKind === "partial").length;
@@ -179,9 +255,15 @@ function pseudoStepsFromCluster(group) {
 }
 async function hasExistingClusterWrite(storage, cluster) {
   const clusterKey2 = cluster.slice(0, PROCEDURE_CLUSTER_ATTR_MAX);
+  const clusterHash = clusterKeyHash(cluster);
   const memories = await storage.readAllMemories();
   for (const m of memories) {
     if (m.frontmatter.category !== "procedure") continue;
+    const h = m.frontmatter.structuredAttributes?.procedure_cluster_hash;
+    if (typeof h === "string") {
+      if (h === clusterHash) return true;
+      continue;
+    }
     const c = m.frontmatter.structuredAttributes?.procedure_cluster;
     if (c === clusterKey2) return true;
   }
@@ -209,27 +291,32 @@ async function runProcedureMining(options) {
     const rate = successRate(group);
     if (rate < cfg.successFloor) continue;
     clustersProcessed += 1;
-    if (await hasExistingClusterWrite(options.storage, key)) {
-      log.debug(`procedure-miner: skip duplicate cluster key=${key.slice(0, 40)}\u2026`);
-      continue;
-    }
     const steps = normalizeProcedureSteps(pseudoStepsFromCluster(group));
     if (steps.length < 2) continue;
     const title = `When you work on goals like: ${group[0].goal.trim().slice(0, 140)}`;
     const body = buildProcedurePersistBody(title, steps);
+    const clusterHash = clusterKeyHash(key);
     const promote = cfg.autoPromoteEnabled === true && group.length >= cfg.autoPromoteOccurrences && rate >= cfg.successFloor;
-    await options.storage.writeMemory("procedure", body, {
-      source: "procedure-miner",
-      status: promote ? "active" : "pending_review",
-      tags: ["procedure-miner", "causal-trajectory"],
-      structuredAttributes: {
-        procedure_cluster: key.slice(0, PROCEDURE_CLUSTER_ATTR_MAX),
-        trajectory_ids: group.map((g) => g.trajectoryId).join(",").slice(0, 1900),
-        trajectory_count: String(group.length),
-        success_rate: rate.toFixed(4)
+    const wrote = await withClusterWriteLock(options.memoryDir, clusterHash, async () => {
+      if (await hasExistingClusterWrite(options.storage, key)) {
+        log.debug(`procedure-miner: skip duplicate cluster key=${key.slice(0, 40)}\u2026`);
+        return false;
       }
+      await options.storage.writeMemory("procedure", body, {
+        source: "procedure-miner",
+        status: promote ? "active" : "pending_review",
+        tags: ["procedure-miner", "causal-trajectory"],
+        structuredAttributes: {
+          procedure_cluster: key.slice(0, PROCEDURE_CLUSTER_ATTR_MAX),
+          procedure_cluster_hash: clusterHash,
+          trajectory_ids: group.map((g) => g.trajectoryId).join(",").slice(0, 1900),
+          trajectory_count: String(group.length),
+          success_rate: rate.toFixed(4)
+        }
+      });
+      return true;
     });
-    proceduresWritten += 1;
+    if (wrote) proceduresWritten += 1;
   }
   return { clustersProcessed, proceduresWritten };
 }
@@ -634,7 +721,7 @@ var EngramAccessService = class {
     const snapshotForSerialization = {
       sessionKey: options.sessionKey ?? "",
       recordedAt: new Date(options.snapshot.capturedAt).toISOString(),
-      queryHash: createHash("sha256").update(options.query).digest("hex"),
+      queryHash: createHash2("sha256").update(options.query).digest("hex"),
       queryLen: options.query.length,
       memoryIds,
       namespace,
@@ -888,7 +975,7 @@ var EngramAccessService = class {
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
     let projectionAvailable = false;
     try {
-      await stat(getMemoryProjectionPath(storage.dir));
+      await stat2(getMemoryProjectionPath(storage.dir));
       projectionAvailable = true;
     } catch {
       projectionAvailable = false;
@@ -1034,11 +1121,11 @@ var EngramAccessService = class {
     if (!this.orchestrator.config.codingMode?.projectScope) return;
     if (this.orchestrator.getCodingContextForSession(sessionKey)) return;
     if (typeof options.projectTag === "string" && options.projectTag.trim().length > 0) {
-      const tag = options.projectTag.trim();
+      const projectId = projectTagProjectId(options.projectTag);
       this.orchestrator.setCodingContextForSession(sessionKey, {
-        projectId: `tag:${tag}`,
+        projectId,
         branch: null,
-        rootPath: `tag:${tag}`,
+        rootPath: projectId,
         defaultBranch: null
       });
       return;
@@ -2621,10 +2708,12 @@ var EngramAccessService = class {
     }
     const limit = Math.max(1, Math.min(request.limit ?? 10, 100));
     const lcmSessionKey = request.sessionKey && namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
+    const lcmSessionPrefix = request.sessionPrefix && namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionPrefix}` : request.sessionPrefix;
     const rawResults = await this.orchestrator.lcmEngine.searchContextFull(
       request.query,
       limit,
-      lcmSessionKey
+      lcmSessionKey,
+      lcmSessionPrefix
     );
     const results = rawResults.map((r) => ({
       sessionId: r.session_id,
@@ -3162,9 +3251,7 @@ ${next}`);
     const { query, namespace, maxResults, collection, principal } = request;
     const resolvedNs = this.resolveReadableNamespace(namespace, principal);
     const namespaceFilter = resolvedNs !== this.orchestrator.config.defaultNamespace ? resolvedNs : void 0;
-    const results = collection === "global" ? (await this.orchestrator.qmd.searchGlobal(query, maxResults)).filter(
-      (r) => namespaceFilter ? r.path.includes(`/namespaces/${namespaceFilter}/`) || !r.path.includes("/namespaces/") && namespaceFilter === this.orchestrator.config.defaultNamespace : true
-    ) : await this.orchestrator.searchAcrossNamespaces({
+    const results = collection === "global" && !namespaceFilter ? await this.orchestrator.qmd.searchGlobal(query, maxResults) : await this.orchestrator.searchAcrossNamespaces({
       query,
       namespaces: namespaceFilter ? [namespaceFilter] : void 0,
       maxResults,
@@ -3400,7 +3487,7 @@ ${next}`);
       sourceSessionKey: request.sessionKey,
       inputSummary: inputSummaryParts.length > 0 ? inputSummaryParts.join(" | ").slice(0, 500) : void 0,
       dryRun: request.dryRun === true,
-      promptHash: typeof request.sourcePrompt === "string" && request.sourcePrompt.length > 0 ? createHash("sha256").update(request.sourcePrompt).digest("hex") : void 0
+      promptHash: typeof request.sourcePrompt === "string" && request.sourcePrompt.length > 0 ? createHash2("sha256").update(request.sourcePrompt).digest("hex") : void 0
     };
     const preview = this.orchestrator.previewMemoryActionEvent(event);
     if (request.dryRun === true) {
@@ -3413,7 +3500,7 @@ ${next}`);
     const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const storageDir = storage.dir;
-    const { writeFile, mkdir } = await import("fs/promises");
+    const { writeFile, mkdir: mkdir2 } = await import("fs/promises");
     const { join: join2, resolve: resolve2 } = await import("path");
     const safeKey = request.sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
     if (!safeKey) throw new EngramAccessInputError("sessionKey is required");
@@ -3422,7 +3509,7 @@ ${next}`);
     if (!resolved.startsWith(resolve2(storageDir))) {
       throw new EngramAccessInputError("Invalid sessionKey");
     }
-    await mkdir(checkpointDir, { recursive: true });
+    await mkdir2(checkpointDir, { recursive: true });
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const filePath = join2(checkpointDir, `checkpoint-${ts}.md`);
     await writeFile(filePath, request.context, "utf-8");
@@ -3508,7 +3595,7 @@ ${next}`);
    * deterministic alphabetical order (mirroring `listPeers` storage semantics).
    */
   async peerList() {
-    const { listPeers } = await import("./peers-HCVGHMAE.js");
+    const { listPeers } = await import("./peers/index.js");
     const peers = await listPeers(this.orchestrator.config.memoryDir);
     return { peers };
   }
@@ -3518,7 +3605,7 @@ ${next}`);
    * pattern used throughout the service.
    */
   async peerGet(peerId) {
-    const peers = await import("./peers-HCVGHMAE.js");
+    const peers = await import("./peers/index.js");
     const validateId = peers.assertValidPeerId;
     try {
       validateId(peerId);
@@ -3538,7 +3625,7 @@ ${next}`);
    * Returns `{ created: true }` on first write, `{ created: false }` on update.
    */
   async peerSet(input) {
-    const peers = await import("./peers-HCVGHMAE.js");
+    const peers = await import("./peers/index.js");
     const validateId = peers.assertValidPeerId;
     const { id } = input;
     try {
@@ -3586,7 +3673,7 @@ ${next}`);
    * log data are not destroyed.
    */
   async peerDelete(peerId) {
-    const peers = await import("./peers-HCVGHMAE.js");
+    const peers = await import("./peers/index.js");
     const validateId = peers.assertValidPeerId;
     try {
       validateId(peerId);
@@ -3610,7 +3697,7 @@ ${next}`);
    * not exist (idempotent no-op).
    */
   async peerForget(peerId, opts) {
-    const peers = await import("./peers-HCVGHMAE.js");
+    const peers = await import("./peers/index.js");
     const validateId = peers.assertValidPeerId;
     try {
       validateId(peerId);
@@ -3634,7 +3721,7 @@ ${next}`);
    * but in practice the reasoner only writes profiles for registered peers.
    */
   async peerProfileGet(peerId) {
-    const peers = await import("./peers-HCVGHMAE.js");
+    const peers = await import("./peers/index.js");
     const validateId = peers.assertValidPeerId;
     try {
       validateId(peerId);
@@ -3744,7 +3831,7 @@ ${next}`);
   async validateCapsuleImportArchivePath(archivePath) {
     let archiveStat;
     try {
-      archiveStat = await stat(archivePath);
+      archiveStat = await stat2(archivePath);
     } catch (err) {
       if (!this.isCapsuleImportPathInputFsError(err)) throw err;
       const message = err instanceof Error ? err.message : String(err);
@@ -3876,7 +3963,7 @@ ${next}`);
   async offlineSyncSnapshot(options = {}) {
     const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const storageHash = createHash("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    const storageHash = createHash2("sha256").update(storage.dir).digest("hex").slice(0, 16);
     const snapshotBuilder = options.includeContent === false && options.baseFiles && options.baseFiles.length > 0 ? buildOfflineSyncSnapshotFromBase : buildOfflineSyncSnapshot;
     const snapshot = await snapshotBuilder({
       root: storage.dir,
@@ -3894,10 +3981,30 @@ ${next}`);
       ...snapshot
     };
   }
+  async offlineSyncSnapshotStream(options = {}) {
+    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const storageHash = createHash2("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    return {
+      namespace: resolvedNamespace,
+      format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
+      schemaVersion: 1,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
+      includeTranscripts: options.includeTranscripts !== false,
+      files: iterateOfflineSyncSnapshotFileRecords({
+        root: storage.dir,
+        includeContent: options.includeContent === true,
+        includeTranscripts: options.includeTranscripts !== false,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+        readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath)
+      })
+    };
+  }
   async offlineSyncFiles(options) {
     const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const storageHash = createHash("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    const storageHash = createHash2("sha256").update(storage.dir).digest("hex").slice(0, 16);
     try {
       const snapshot = await buildOfflineSyncSnapshotForPaths({
         root: storage.dir,
@@ -4014,7 +4121,7 @@ ${next}`);
    * Return per-phase Dreams telemetry for the last N hours (default 24).
    */
   async dreamsStatus(options) {
-    const { getDreamsStatus, normalizeDreamsStatusWindowHours } = await import("./dreams-ledger-LR2NBAZE.js");
+    const { getDreamsStatus, normalizeDreamsStatusWindowHours } = await import("./dreams-ledger-3WSCI5V4.js");
     let windowHours;
     try {
       windowHours = normalizeDreamsStatusWindowHours(options?.windowHours);
@@ -4033,7 +4140,7 @@ ${next}`);
    * respectively, returning the same telemetry shape as a scheduled run.
    */
   async dreamsRun(options) {
-    const { runDreamsPhase } = await import("./dreams-ledger-LR2NBAZE.js");
+    const { runDreamsPhase } = await import("./dreams-ledger-3WSCI5V4.js");
     const validPhases = ["lightSleep", "rem", "deepSleep"];
     if (!validPhases.includes(options.phase)) {
       throw new EngramAccessInputError(
@@ -4104,4 +4211,4 @@ export {
   shapeMemorySummary,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-QKZGQIPJ.js.map
+//# sourceMappingURL=chunk-3Q4H3OBR.js.map