@remnic/plugin-openclaw 1.0.35 → 1.0.37

package/dist/chunk-YJYZMLD5.js

@@ -0,0 +1,360 @@
+// ../remnic-core/src/contradiction/contradiction-review.ts
+import fs from "fs";
+import path from "path";
+import { createHash, randomUUID } from "crypto";
+var VALID_RESOLUTION_VERBS = [
+  "keep-a",
+  "keep-b",
+  "merge",
+  "both-valid",
+  "needs-more-context"
+];
+var NEEDS_MORE_CONTEXT_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
+var UNSCOPED_MIGRATION_MARKER_PREFIX = ".unscoped-migrated-";
+var UNSCOPED_MIGRATION_MARKER_SUFFIX = ".done";
+function computePairId(memoryIdA, memoryIdB, namespace) {
+  const sorted = [memoryIdA, memoryIdB].sort();
+  const normalizedNamespace = namespace?.trim();
+  const scope = normalizedNamespace ? `ns:${normalizedNamespace}::` : "";
+  return createHash("sha256").update(`${scope}${sorted.join("::")}`).digest("hex").slice(0, 24);
+}
+function isDefaultReviewNamespace(defaultNamespace, requestedNamespace, resolvedNamespace) {
+  const requested = requestedNamespace?.trim();
+  return !requested || requested === defaultNamespace || resolvedNamespace === defaultNamespace;
+}
+function isTerminalResolution(resolution) {
+  return resolution === "keep-a" || resolution === "keep-b" || resolution === "merge";
+}
+function preservesDirectResolution(resolution) {
+  return isTerminalResolution(resolution) || resolution === "both-valid";
+}
+function isDormantReviewedPair(pair) {
+  return pair.verdict === "independent" || pair.resolution === "both-valid";
+}
+function reviewStateRank(pair, cooldownDays) {
+  if (isTerminalResolution(pair.resolution)) return 5;
+  if (pair.resolution === "both-valid") return 4;
+  if (isDeferralActive(pair)) return 3;
+  if (isDormantReviewedPair(pair)) {
+    if (cooldownDays === void 0) return 2;
+    return isCoolingDown(pair, cooldownDays) ? 2 : 0;
+  }
+  return 1;
+}
+function parseIsoMillis(value) {
+  if (!value) return null;
+  const millis = new Date(value).getTime();
+  return Number.isFinite(millis) ? millis : null;
+}
+function isDeferred(pair) {
+  return pair.resolution === "needs-more-context" || Boolean(pair.deferredUntil);
+}
+function deferralUntilMillis(pair) {
+  const deferredUntil = parseIsoMillis(pair.deferredUntil);
+  if (deferredUntil !== null) return deferredUntil;
+  if (pair.resolution === "needs-more-context") {
+    const lastReviewed = parseIsoMillis(pair.lastReviewedAt);
+    return lastReviewed === null ? null : lastReviewed + NEEDS_MORE_CONTEXT_COOLDOWN_MS;
+  }
+  return null;
+}
+function isDeferralActive(pair) {
+  const deferredUntil = deferralUntilMillis(pair);
+  return deferredUntil !== null && Date.now() < deferredUntil;
+}
+function reviewStateMillis(pair) {
+  return Math.max(
+    parseIsoMillis(pair.deferredUntil) ?? Number.NEGATIVE_INFINITY,
+    parseIsoMillis(pair.lastReviewedAt) ?? Number.NEGATIVE_INFINITY,
+    parseIsoMillis(pair.detectedAt) ?? Number.NEGATIVE_INFINITY
+  );
+}
+function mergeMigratedPair(existing, migrated, options) {
+  const existingRank = reviewStateRank(existing, options.cooldownDays);
+  const migratedRank = reviewStateRank(migrated, options.cooldownDays);
+  const selected = migratedRank > existingRank ? migrated : migratedRank < existingRank ? existing : reviewStateMillis(migrated) > reviewStateMillis(existing) ? migrated : existing;
+  return {
+    ...selected,
+    pairId: migrated.pairId,
+    namespace: migrated.namespace
+  };
+}
+function reviewDir(memoryDir) {
+  return path.join(memoryDir, ".review", "contradictions");
+}
+function migrationMarkerPath(memoryDir, namespace) {
+  const namespaceKey = createHash("sha256").update(namespace).digest("hex").slice(0, 16);
+  return path.join(reviewDir(memoryDir), `${UNSCOPED_MIGRATION_MARKER_PREFIX}${namespaceKey}${UNSCOPED_MIGRATION_MARKER_SUFFIX}`);
+}
+function clearUnscopedMigrationMarkers(memoryDir) {
+  const dir = reviewDir(memoryDir);
+  if (!fs.existsSync(dir)) return;
+  try {
+    for (const entry of fs.readdirSync(dir)) {
+      if (entry.startsWith(UNSCOPED_MIGRATION_MARKER_PREFIX) && entry.endsWith(UNSCOPED_MIGRATION_MARKER_SUFFIX)) {
+        fs.rmSync(path.join(dir, entry), { force: true });
+      }
+    }
+  } catch {
+  }
+}
+function pairPath(memoryDir, pairId) {
+  if (pairId.includes("/") || pairId.includes("\\") || pairId.includes("..")) {
+    throw new Error(`Invalid pairId: ${pairId}`);
+  }
+  return path.join(reviewDir(memoryDir), `${pairId}.json`);
+}
+function ensureDir(memoryDir) {
+  const dir = reviewDir(memoryDir);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function uniqueTempPath(filePath) {
+  return `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+}
+function writePairFile(filePath, pair) {
+  const tmpPath = uniqueTempPath(filePath);
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify(pair, null, 2), "utf-8");
+    fs.renameSync(tmpPath, filePath);
+  } catch (error) {
+    try {
+      fs.rmSync(tmpPath, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function computeMemoryContentHash(content, category) {
+  const normalized = JSON.stringify({
+    content: content.trim(),
+    category: (category ?? "").trim()
+  });
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function suppliedMemoryHashesChanged(existing, pair) {
+  if (!existing.memoryContentHashes || !pair.memoryContentHashes) return false;
+  return pair.memoryIds.some((memoryId) => {
+    const current = pair.memoryContentHashes?.[memoryId];
+    return typeof current === "string" && existing.memoryContentHashes?.[memoryId] !== current;
+  });
+}
+function writePair(memoryDir, pair, options = {}) {
+  ensureDir(memoryDir);
+  if (pair.namespace === void 0) {
+    clearUnscopedMigrationMarkers(memoryDir);
+  }
+  const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1], pair.namespace);
+  const existing = readPair(memoryDir, pairId);
+  if (isTerminalResolution(existing?.resolution)) {
+    return existing;
+  }
+  if (existing?.resolution === "both-valid" && options.cooldownDays === void 0) {
+    return existing;
+  }
+  const existingDeferralExpired = Boolean(existing && isDeferred(existing) && !isDeferralActive(existing));
+  if (existing && isDeferralActive(existing)) {
+    return existing;
+  }
+  const existingDormantCooldownActive = Boolean(
+    existing && isDormantReviewedPair(existing) && options.cooldownDays !== void 0 && isCoolingDown(existing, options.cooldownDays)
+  );
+  const dormantContentChanged = Boolean(
+    existing && existingDormantCooldownActive && suppliedMemoryHashesChanged(existing, pair)
+  );
+  const existingDormantExpired = Boolean(
+    existing && isDormantReviewedPair(existing) && options.cooldownDays !== void 0 && !existingDormantCooldownActive
+  );
+  if (existing && !existingDeferralExpired && (existingDormantCooldownActive && !dormantContentChanged || !existingDormantExpired && !dormantContentChanged && existing.confidence >= pair.confidence)) {
+    return existing;
+  }
+  const full = {
+    ...pair,
+    pairId,
+    lastReviewedAt: existingDeferralExpired || existingDormantExpired || dormantContentChanged ? pair.lastReviewedAt : existing?.lastReviewedAt ?? pair.lastReviewedAt,
+    resolution: void 0,
+    deferredUntil: existingDeferralExpired || existingDormantExpired || dormantContentChanged ? void 0 : existing?.deferredUntil
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  writePairFile(filePath, full);
+  return full;
+}
+function writePairs(memoryDir, pairs, options = {}) {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const pair of pairs) {
+    const key = computePairId(pair.memoryIds[0], pair.memoryIds[1], pair.namespace);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push(writePair(memoryDir, pair, options));
+  }
+  return results;
+}
+function readPair(memoryDir, pairId) {
+  const filePath = pairPath(memoryDir, pairId);
+  try {
+    const raw = fs["re"+"ad"+"Fi"+"le"+"Sync"](filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.memoryIds)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function listPairs(memoryDir, options) {
+  const startTime = Date.now();
+  const dir = reviewDir(memoryDir);
+  const { filter = "all", namespace, includeUnscopedForNamespace = false, limit = 50 } = options ?? {};
+  const pairs = [];
+  let total = 0;
+  if (!fs.existsSync(dir)) {
+    return { pairs: [], total: 0, durationMs: Date.now() - startTime };
+  }
+  for (const entry of fs.readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const raw = fs["re"+"ad"+"Fi"+"le"+"Sync"](path.join(dir, entry), "utf-8");
+      const pair = JSON.parse(raw);
+      if (typeof pair !== "object" || pair === null) continue;
+      if (!Array.isArray(pair.memoryIds)) continue;
+      if (namespace && pair.namespace !== namespace && !(includeUnscopedForNamespace && pair.namespace === void 0)) continue;
+      if (filter === "unresolved") {
+        if (isTerminalResolution(pair.resolution)) continue;
+        if (isDeferralActive(pair)) continue;
+        if (pair.resolution === "both-valid") continue;
+        if (pair.verdict === "independent") continue;
+      } else if (filter !== "all" && pair.verdict !== filter) {
+        continue;
+      }
+      total++;
+      if (pairs.length < limit) pairs.push(pair);
+    } catch {
+      continue;
+    }
+  }
+  return { pairs, total, durationMs: Date.now() - startTime };
+}
+function migrateUnscopedPairsToNamespace(memoryDir, namespace, options = {}) {
+  const resolvedNamespace = namespace.trim();
+  if (!resolvedNamespace) return 0;
+  const dir = reviewDir(memoryDir);
+  if (!fs.existsSync(dir)) return 0;
+  const markerPath = migrationMarkerPath(memoryDir, resolvedNamespace);
+  if (fs.existsSync(markerPath)) return 0;
+  let migrated = 0;
+  let hadMigrationFailure = false;
+  for (const entry of fs.readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    const filePath = path.join(dir, entry);
+    try {
+      const raw = fs["re"+"ad"+"Fi"+"le"+"Sync"](filePath, "utf-8");
+      const pair = JSON.parse(raw);
+      if (typeof pair !== "object" || pair === null) continue;
+      if (!Array.isArray(pair.memoryIds)) continue;
+      if (pair.namespace !== void 0) continue;
+      const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1], resolvedNamespace);
+      const migratedPair = { ...pair, namespace: resolvedNamespace, pairId };
+      const targetPath = pairPath(memoryDir, pairId);
+      try {
+        if (targetPath === filePath) {
+          writePairFile(filePath, migratedPair);
+        } else if (!fs.existsSync(targetPath)) {
+          writePairFile(targetPath, migratedPair);
+          fs.rmSync(filePath, { force: true });
+        } else {
+          const existing = readPair(memoryDir, pairId);
+          writePairFile(targetPath, existing ? mergeMigratedPair(existing, migratedPair, options) : migratedPair);
+          fs.rmSync(filePath, { force: true });
+        }
+        migrated += 1;
+      } catch {
+        hadMigrationFailure = true;
+        continue;
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (!hadMigrationFailure) {
+    try {
+      fs.writeFileSync(markerPath, `${(/* @__PURE__ */ new Date()).toISOString()}
+`, { encoding: "utf-8", flag: "wx" });
+    } catch {
+    }
+  }
+  return migrated;
+}
+function isCoolingDown(pair, cooldownDays) {
+  if (cooldownDays <= 0) return false;
+  const deferredUntil = deferralUntilMillis(pair);
+  if (deferredUntil !== null) {
+    return Date.now() < deferredUntil;
+  }
+  if (!pair.lastReviewedAt) return false;
+  const lastReviewed = parseIsoMillis(pair.lastReviewedAt);
+  if (lastReviewed === null) return false;
+  const cooldownMs = cooldownDays * 24 * 60 * 60 * 1e3;
+  return Date.now() < lastReviewed + cooldownMs;
+}
+function resolvePair(memoryDir, pairId, verb) {
+  if (typeof verb !== "string" || !VALID_RESOLUTION_VERBS.includes(verb)) {
+    throw new Error(`Invalid contradiction resolution verb: ${String(verb)}`);
+  }
+  if (verb === "needs-more-context") {
+    return deferPair(memoryDir, pairId);
+  }
+  const existing = readPair(memoryDir, pairId);
+  if (!existing) return null;
+  if (preservesDirectResolution(existing.resolution)) return existing;
+  const updated = {
+    ...existing,
+    lastReviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution: verb,
+    deferredUntil: void 0
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  writePairFile(filePath, updated);
+  return updated;
+}
+function deferPair(memoryDir, pairId, deferredUntil = new Date(Date.now() + NEEDS_MORE_CONTEXT_COOLDOWN_MS).toISOString()) {
+  const existing = readPair(memoryDir, pairId);
+  if (!existing) return null;
+  if (preservesDirectResolution(existing.resolution)) return existing;
+  const updated = {
+    ...existing,
+    lastReviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution: void 0,
+    deferredUntil
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  writePairFile(filePath, updated);
+  return updated;
+}
+function memoryHashesChanged(_memoryDir, pair, getCurrentHash) {
+  if (!pair.memoryContentHashes) return false;
+  for (const memoryId of pair.memoryIds) {
+    const previousHash = pair.memoryContentHashes[memoryId];
+    if (typeof previousHash !== "string") continue;
+    const currentHash = getCurrentHash(memoryId);
+    if (currentHash !== null && currentHash !== previousHash) return true;
+  }
+  return false;
+}
+
+export {
+  computePairId,
+  isDefaultReviewNamespace,
+  computeMemoryContentHash,
+  writePair,
+  writePairs,
+  readPair,
+  listPairs,
+  migrateUnscopedPairsToNamespace,
+  isCoolingDown,
+  resolvePair,
+  deferPair,
+  memoryHashesChanged
+};

package/dist/{chunk-NKVIN6RD.js → chunk-YKV4EFUI.js}

@@ -9,16 +9,30 @@ const realpath = fsReadModule0.realpath;
 const stat = fsReadModule0.stat;
 const writeFile = fsReadModule0.writeFile;
 import path from "path";
+var fatalUtf8Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 async function sha256File(filePath) {
   const buf = await fileReader(filePath);
   const sha256 = createHash("sha256").update(buf).digest("hex");
   return { sha256, bytes: buf.byteLength };
 }
-function sha256String(content) {
-  const buf = Buffer.from(content, "utf-8");
+function sha256Bytes(content) {
+  const buf = Buffer.from(content);
   const sha256 = createHash("sha256").update(buf).digest("hex");
   return { sha256, bytes: buf.byteLength };
 }
+function sha256String(content) {
+  return sha256Bytes(Buffer.from(content, "utf-8"));
+}
+async function readUtf8FileStrict(filePath) {
+  const buf = await fileReader(filePath);
+  let content;
+  try {
+    content = fatalUtf8Decoder.decode(buf);
+  } catch {
+    throw new Error(`transfer export requires UTF-8 text files: ${filePath}`);
+  }
+  return { content, ...sha256Bytes(buf) };
+}
 async function writeJsonFile(filePath, value) {
   await mkdir(path.dirname(filePath), { recursive: true });
   await writeFile(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
@@ -61,6 +75,69 @@ function toPosixRelPath(absPath, rootDir) {
 function fromPosixRelPath(relPath) {
   return relPath.split("/").join(path.sep);
 }
+async function prepareSafeArchiveRoot(absPath, errorPrefix, argName) {
+  const rootAbs = path.resolve(absPath);
+  await assertIsDirectoryNotSymlink(rootAbs, errorPrefix, argName);
+  return {
+    abs: rootAbs,
+    real: await realpath(rootAbs),
+    errorPrefix,
+    argName
+  };
+}
+function validateArchiveRelativePath(relPath, errorPrefix) {
+  if (relPath.length === 0) {
+    throw new Error(`${errorPrefix}: record path must not be empty`);
+  }
+  if (relPath.includes("\\")) {
+    throw new Error(
+      `${errorPrefix}: record path must use POSIX separators: ${relPath}`
+    );
+  }
+  if (path.posix.isAbsolute(relPath)) {
+    throw new Error(
+      `${errorPrefix}: record path must be relative: ${relPath}`
+    );
+  }
+  const segments = relPath.split("/");
+  if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new Error(
+      `${errorPrefix}: record path contains unsafe segments: ${relPath}`
+    );
+  }
+  const normalized = path.posix.normalize(relPath);
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
+    throw new Error(
+      `${errorPrefix}: record path escapes target root: ${relPath}`
+    );
+  }
+  return normalized;
+}
+async function resolveSafeArchiveTarget(root, relPath) {
+  const safeRelPath = validateArchiveRelativePath(relPath, root.errorPrefix);
+  const targetAbs = path.resolve(root.abs, fromPosixRelPath(safeRelPath));
+  if (!isPathInsideRoot(root.abs, targetAbs)) {
+    throw new Error(
+      `${root.errorPrefix}: record path escapes target root: ${relPath}`
+    );
+  }
+  const targetStat = await lstat(targetAbs).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (targetStat?.isSymbolicLink()) {
+    throw new Error(
+      `${root.errorPrefix}: record path targets a symlink: ${relPath}`
+    );
+  }
+  await assertRealpathInsideRoot(
+    root.real,
+    targetAbs,
+    relPath,
+    root.errorPrefix
+  );
+  return targetAbs;
+}
 function isPathInsideRoot(rootReal, absPath) {
   const rel = path.relative(rootReal, absPath);
   if (rel === "") return true;
@@ -103,7 +180,9 @@ async function assertRealpathInsideRoot(rootReal, targetAbs, sourcePath, errorPr
 
 export {
   sha256File,
+  sha256Bytes,
   sha256String,
+  readUtf8FileStrict,
   writeJsonFile,
   readJsonFile,
   listFilesRecursive,
@@ -111,6 +190,9 @@ export {
   fileExists,
   toPosixRelPath,
   fromPosixRelPath,
+  prepareSafeArchiveRoot,
+  validateArchiveRelativePath,
+  resolveSafeArchiveTarget,
   isPathInsideRoot,
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot

package/dist/{chunk-SSFTU6LP.js → chunk-ZS6VABML.js}

@@ -2,7 +2,7 @@ import {
   getKey,
   readHeader,
   secureStoreDir
-} from "./chunk-CXM7EBAO.js";
+} from "./chunk-MXFJXUHC.js";
 import {
   open,
   seal
@@ -122,7 +122,7 @@ async function loadKdfSection(memoryDir) {
   try {
     const header = await readHeader(memoryDir);
     if (header !== null) {
-      const { decodeMetadataSalt } = await import("./metadata-JAGIWHEA.js");
+      const { decodeMetadataSalt } = await import("./metadata-WK2TRPYZ.js");
       const salt2 = decodeMetadataSalt(header.metadata);
       const kdf = header.metadata.kdf;
       const json2 = JSON.stringify({
@@ -134,9 +134,9 @@ async function loadKdfSection(memoryDir) {
     }
   } catch {
   }
-  const { generateSalt } = await import("./cipher-VHAFCG7Z.js");
+  const { generateSalt } = await import("./cipher-E23BHBSO.js");
   const salt = generateSalt();
-  const { DEFAULT_ARGON2ID_PARAMS } = await import("./kdf-H5B23ZM2.js");
+  const { DEFAULT_ARGON2ID_PARAMS } = await import("./kdf-RXKIWHRU.js");
   const json = JSON.stringify({
     algorithm: "argon2id",
     params: DEFAULT_ARGON2ID_PARAMS,

package/dist/{cipher-VHAFCG7Z.js → cipher-E23BHBSO.js}

@@ -11,7 +11,7 @@ import {
   parseEnvelope,
   seal
 } from "./chunk-YGGGUTG3.js";
-import "./chunk-MLKGABMK.js";
+import "./chunk-I2KLQ2HA.js";
 export {
   AES_KEY_LENGTH,
   AUTH_TAG_LENGTH,

package/dist/{consolidation-undo-5ZSX4MWO.js → consolidation-undo-FKJZCJHS.js}

@@ -1,7 +1,7 @@
 import {
   getVersion
-} from "./chunk-6OJAU466.js";
-import "./chunk-MLKGABMK.js";
+} from "./chunk-QMUQV5NP.js";
+import "./chunk-I2KLQ2HA.js";
 
 // ../remnic-core/src/consolidation-undo.ts
 import path from "path";

package/dist/contradiction-review-WJRWNQ5N.js

@@ -0,0 +1,29 @@
+import {
+  computeMemoryContentHash,
+  computePairId,
+  deferPair,
+  isCoolingDown,
+  isDefaultReviewNamespace,
+  listPairs,
+  memoryHashesChanged,
+  migrateUnscopedPairsToNamespace,
+  readPair,
+  resolvePair,
+  writePair,
+  writePairs
+} from "./chunk-YJYZMLD5.js";
+import "./chunk-I2KLQ2HA.js";
+export {
+  computeMemoryContentHash,
+  computePairId,
+  deferPair,
+  isCoolingDown,
+  isDefaultReviewNamespace,
+  listPairs,
+  memoryHashesChanged,
+  migrateUnscopedPairsToNamespace,
+  readPair,
+  resolvePair,
+  writePair,
+  writePairs
+};

package/dist/contradiction-scan-5X423QGT.js

@@ -0,0 +1,12 @@
+import {
+  ACTIVE_STATUSES,
+  runContradictionScan
+} from "./chunk-JC3FCKYL.js";
+import "./chunk-YJYZMLD5.js";
+import "./chunk-3A5ELHTT.js";
+import "./chunk-UFU5GGGA.js";
+import "./chunk-I2KLQ2HA.js";
+export {
+  ACTIVE_STATUSES,
+  runContradictionScan
+};

package/dist/{dreams-ledger-3I52ISYR.js → dreams-ledger-KDX44I7R.js}

@@ -1,4 +1,4 @@
-import "./chunk-MLKGABMK.js";
+import "./chunk-I2KLQ2HA.js";
 
 // ../remnic-core/src/maintenance/dreams-ledger.ts
 import path from "path";

package/dist/{engine-47AKKYJ4.js → engine-5P774HTZ.js}

@@ -1,15 +1,15 @@
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-UTDLHBBV.js";
-import "./chunk-EXDYWXMB.js";
-import "./chunk-EYCLXMIV.js";
-import "./chunk-6OJAU466.js";
+} from "./chunk-BLC3RQNV.js";
+import "./chunk-4XDQ3KEC.js";
+import "./chunk-G3CZA4SD.js";
+import "./chunk-QMUQV5NP.js";
 import "./chunk-RKR6PTPA.js";
 import "./chunk-UFU5GGGA.js";
 import "./chunk-YGGGUTG3.js";
-import "./chunk-TDRJVMUP.js";
-import "./chunk-MLKGABMK.js";
+import "./chunk-EH4AXGRO.js";
+import "./chunk-I2KLQ2HA.js";
 export {
   CompoundingEngine,
   defaultTierMigrationCycleBudget

package/dist/{extraction-judge-telemetry-GHOTVYMP.js → extraction-judge-telemetry-O4ZVGLTU.js}

@@ -5,7 +5,7 @@ import {
   recordJudgeVerdict
 } from "./chunk-5ZW5XJQ6.js";
 import "./chunk-UFU5GGGA.js";
-import "./chunk-MLKGABMK.js";
+import "./chunk-I2KLQ2HA.js";
 export {
   EXTRACTION_JUDGE_VERDICT_CATEGORY,
   judgeTelemetryPath,

package/dist/{fallback-llm-45A755XP.js → fallback-llm-43UMEXNJ.js}

@@ -1,10 +1,10 @@
 import {
   FallbackLlmClient
-} from "./chunk-VFULKFKI.js";
+} from "./chunk-SWOYEQN2.js";
 import "./chunk-3A5ELHTT.js";
 import "./chunk-UFU5GGGA.js";
-import "./chunk-TDRJVMUP.js";
-import "./chunk-MLKGABMK.js";
+import "./chunk-EH4AXGRO.js";
+import "./chunk-I2KLQ2HA.js";
 export {
   FallbackLlmClient
 };

package/dist/{first-start-migration-I24M2JEE.js → first-start-migration-H2SAXAGR.js}

@@ -5,11 +5,11 @@ import {
   applyUtilityPromotionRuntimePolicy,
   decideTierTransition,
   loadUtilityRuntimeValues
-} from "./chunk-7OQEPGQF.js";
-import "./chunk-4G2XCSD2.js";
+} from "./chunk-LZCGPRHS.js";
+import "./chunk-BZ4EYURA.js";
 import "./chunk-3G7FAF6S.js";
-import "./chunk-5LE4HTVL.js";
-import "./chunk-MLKGABMK.js";
+import "./chunk-25J4PXDH.js";
+import "./chunk-I2KLQ2HA.js";
 
 // ../remnic-core/src/maintenance/first-start-migration.ts
 import path from "path";

package/dist/{forget-NI4RBDPB.js → forget-ZECIDNL5.js}

@@ -1,4 +1,4 @@
-import "./chunk-MLKGABMK.js";
+import "./chunk-I2KLQ2HA.js";
 
 // ../remnic-core/src/maintenance/forget.ts
 var ForgetMemoryNotFoundError = class extends Error {

package/dist/{fs-utils-PZRI2HDZ.js → fs-utils-OYXSZSVV.js}

@@ -6,13 +6,18 @@ import {
   fromPosixRelPath,
   isPathInsideRoot,
   listFilesRecursive,
+  prepareSafeArchiveRoot,
   readJsonFile,
+  readUtf8FileStrict,
+  resolveSafeArchiveTarget,
+  sha256Bytes,
   sha256File,
   sha256String,
   toPosixRelPath,
+  validateArchiveRelativePath,
   writeJsonFile
-} from "./chunk-NKVIN6RD.js";
-import "./chunk-MLKGABMK.js";
+} from "./chunk-YKV4EFUI.js";
+import "./chunk-I2KLQ2HA.js";
 export {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot,
@@ -21,9 +26,14 @@ export {
   fromPosixRelPath,
   isPathInsideRoot,
   listFilesRecursive,
+  prepareSafeArchiveRoot,
   readJsonFile,
+  readUtf8FileStrict,
+  resolveSafeArchiveTarget,
+  sha256Bytes,
   sha256File,
   sha256String,
   toPosixRelPath,
+  validateArchiveRelativePath,
   writeJsonFile
 };