@remnic/plugin-openclaw 1.0.10 → 1.0.12

package/dist/chunk-OEI7GLV2.js

@@ -0,0 +1,17 @@
+import {
+  resolveHomeDir
+} from "./chunk-I6B2W2IY.js";
+
+// ../remnic-core/src/utils/path.ts
+import path from "path";
+function expandTildePath(p) {
+  if (p === "~") return resolveHomeDir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) {
+    return path.join(resolveHomeDir(), p.slice(2));
+  }
+  return p;
+}
+
+export {
+  expandTildePath
+};

package/dist/chunk-RKR6PTPA.js

@@ -0,0 +1,308 @@
+import {
+  generateSalt,
+  open,
+  seal
+} from "./chunk-YGGGUTG3.js";
+
+// ../remnic-core/src/secure-store/secure-fs.ts
+import { lstat, mkdir, readFile, readdir, rename, unlink, writeFile } from "fs/promises";
+import path from "path";
+var SecureStoreLockedError = class extends Error {
+  constructor(message = "secure-store is locked \u2014 run `remnic secure-store unlock` to decrypt") {
+    super(message);
+    this.name = "SecureStoreLockedError";
+  }
+};
+var SecureStoreDecryptError = class extends Error {
+  constructor(message = "secure-store decryption failed \u2014 wrong key or tampered ciphertext") {
+    super(message);
+    this.name = "SecureStoreDecryptError";
+  }
+};
+var MAGIC_BYTES = Buffer.from("REMNIC-ENC", "ascii");
+var FILE_FORMAT_VERSION = 1;
+var FILE_FORMAT_FLAGS = 0;
+var MAGIC_HEADER_SIZE = MAGIC_BYTES.length + 2;
+function isEncryptedFile(buf) {
+  if (buf.length < MAGIC_HEADER_SIZE) return false;
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+  return b.subarray(0, MAGIC_BYTES.length).equals(MAGIC_BYTES);
+}
+function encryptFileBody(plain, key, aad) {
+  const plainBuf = typeof plain === "string" ? Buffer.from(plain, "utf8") : plain;
+  const salt = generateSalt();
+  const envelope = seal(key, salt, plainBuf, aad ? { aad } : {});
+  const header = Buffer.alloc(MAGIC_HEADER_SIZE);
+  MAGIC_BYTES.copy(header, 0);
+  header.writeUInt8(FILE_FORMAT_VERSION, MAGIC_BYTES.length);
+  header.writeUInt8(FILE_FORMAT_FLAGS, MAGIC_BYTES.length + 1);
+  return Buffer.concat([header, envelope]);
+}
+function decryptFileBody(buf, key, aad) {
+  if (!isEncryptedFile(buf)) {
+    throw new Error("decryptFileBody: buffer does not start with REMNIC-ENC magic header");
+  }
+  const version = buf.readUInt8(MAGIC_BYTES.length);
+  if (version !== FILE_FORMAT_VERSION) {
+    throw new Error(
+      `decryptFileBody: unsupported file format version ${version} (this build supports ${FILE_FORMAT_VERSION})`
+    );
+  }
+  const flags = buf.readUInt8(MAGIC_BYTES.length + 1);
+  if (flags !== FILE_FORMAT_FLAGS) {
+    throw new Error(`decryptFileBody: unknown flags byte 0x${flags.toString(16).padStart(2, "0")}`);
+  }
+  const envelope = buf.subarray(MAGIC_HEADER_SIZE);
+  try {
+    return open(key, envelope, aad ? { aad } : {});
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new SecureStoreDecryptError(
+      `secure-store decryption failed: ${msg}`
+    );
+  }
+}
+function filePathAad(filePath, memoryDir) {
+  let rel = filePath;
+  if (memoryDir && path.isAbsolute(filePath)) {
+    rel = path.relative(memoryDir, filePath);
+  }
+  return Buffer.from(rel, "utf8");
+}
+async function readMaybeEncryptedFile(filePath, key, memoryDir) {
+  const buf = await readFile(filePath);
+  if (!isEncryptedFile(buf)) {
+    return buf.toString("utf8");
+  }
+  if (key === null) {
+    throw new SecureStoreLockedError(
+      `secure-store is locked \u2014 cannot read encrypted file at ${filePath}. Run \`remnic secure-store unlock\` to decrypt.`
+    );
+  }
+  const aad = filePathAad(filePath, memoryDir);
+  const plain = decryptFileBody(buf, key, aad);
+  return plain.toString("utf8");
+}
+async function writeMaybeEncryptedFile(filePath, content, key, options = {}, memoryDir) {
+  const { mode = 384, atomic = true } = options;
+  await mkdir(path.dirname(filePath), { recursive: true });
+  let data;
+  if (key !== null) {
+    const aad = filePathAad(filePath, memoryDir);
+    data = encryptFileBody(content, key, aad);
+  } else {
+    data = content;
+  }
+  if (atomic) {
+    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    try {
+      await writeFile(tempPath, data, { mode });
+      await rename(tempPath, filePath);
+    } catch (err) {
+      try {
+        await unlink(tempPath);
+      } catch {
+      }
+      throw err;
+    }
+  } else {
+    await writeFile(filePath, data, { mode });
+  }
+}
+async function migrateMemoryDirToEncrypted(dir, key, onBeforeEncrypt) {
+  const result = { encrypted: 0, skipped: 0, errors: [] };
+  const files = await collectEncryptableStorageFiles(dir);
+  for (const filePath of files) {
+    try {
+      const buf = await readFile(filePath);
+      if (isEncryptedFile(buf)) {
+        result.skipped++;
+        continue;
+      }
+      if (onBeforeEncrypt) {
+        try {
+          await onBeforeEncrypt(filePath);
+        } catch {
+        }
+      }
+      const content = buf.toString("utf8");
+      const aad = filePathAad(filePath, storageAadRootForFile(filePath, dir));
+      const encrypted = encryptFileBody(content, key, aad);
+      const tempPath = `${filePath}.enc-tmp-${process.pid}-${Date.now()}`;
+      try {
+        await writeFile(tempPath, encrypted, { mode: 384 });
+        await rename(tempPath, filePath);
+        result.encrypted++;
+      } catch (writeErr) {
+        try {
+          const { unlink: unlink2 } = await import("fs/promises");
+          await unlink2(tempPath);
+        } catch {
+        }
+        throw writeErr;
+      }
+    } catch (err) {
+      result.errors.push({
+        filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return result;
+}
+async function decryptMemoryDirToPlaintext(dir, key) {
+  const result = { decrypted: 0, skipped: 0, errors: [] };
+  const files = await collectStorageManagedFiles(dir, isDecryptableStoragePath);
+  for (const filePath of files) {
+    try {
+      const buf = await readFile(filePath);
+      if (!isEncryptedFile(buf)) {
+        result.skipped++;
+        continue;
+      }
+      const aad = filePathAad(filePath, storageAadRootForFile(filePath, dir));
+      const plaintext = decryptFileBody(buf, key, aad);
+      const tempPath = `${filePath}.dec-tmp-${process.pid}-${Date.now()}`;
+      try {
+        await writeFile(tempPath, plaintext, { mode: 384 });
+        await rename(tempPath, filePath);
+        result.decrypted++;
+      } catch (writeErr) {
+        try {
+          await unlink(tempPath);
+        } catch {
+        }
+        throw writeErr;
+      }
+    } catch (err) {
+      result.errors.push({
+        filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return result;
+}
+async function collectEncryptableStorageFiles(dir, rootDir = dir) {
+  return collectStorageManagedFiles(dir, isEncryptableStoragePath, rootDir);
+}
+async function collectStorageManagedFiles(dir, includeFile, rootDir = dir) {
+  const results = [];
+  let names;
+  try {
+    names = await readdir(dir, { encoding: "utf8" });
+  } catch {
+    return results;
+  }
+  for (const name of names) {
+    if (name.startsWith(".secure-store")) continue;
+    const full = path.join(dir, name);
+    let isDir = false;
+    let isFile = false;
+    try {
+      const s = await lstat(full);
+      if (s.isSymbolicLink()) continue;
+      isDir = s.isDirectory();
+      isFile = s.isFile();
+    } catch {
+      continue;
+    }
+    if (isDir) {
+      const sub = await collectStorageManagedFiles(full, includeFile, rootDir);
+      results.push(...sub);
+    } else if (isFile && includeFile(full, rootDir)) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function isEncryptableStoragePath(filePath, rootDir) {
+  const rel = path.relative(rootDir, filePath);
+  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return false;
+  const normalized = normalizeStorageRelativePath(rel);
+  if (normalized === "profile.md") return true;
+  if (isEncryptableStateSidecar(normalized)) return true;
+  if (isEncryptableSummarySidecar(normalized)) return true;
+  const firstSegment = normalized.split("/", 1)[0];
+  return ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS.has(firstSegment) && normalized.endsWith(".md");
+}
+function isDecryptableStoragePath(filePath, rootDir) {
+  if (isEncryptableStoragePath(filePath, rootDir)) return true;
+  const rel = path.relative(rootDir, filePath);
+  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return false;
+  const normalized = normalizeStorageRelativePath(rel);
+  const firstSegment = normalized.split("/", 1)[0];
+  return DECRYPTABLE_SIDECAR_ROOTS.has(firstSegment);
+}
+function normalizeStorageRelativePath(rel) {
+  const normalized = rel.split(path.sep).join("/");
+  const parts = normalized.split("/");
+  if (parts[0] === "namespaces" && parts.length >= 3) {
+    return parts.slice(2).join("/");
+  }
+  return normalized;
+}
+function storageAadRootForFile(filePath, rootDir) {
+  const rel = path.relative(rootDir, filePath);
+  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return rootDir;
+  const parts = rel.split(path.sep);
+  if (parts[0] === "namespaces" && parts.length >= 3 && parts[1]) {
+    return path.join(rootDir, "namespaces", parts[1]);
+  }
+  return rootDir;
+}
+var ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS = /* @__PURE__ */ new Set([
+  "facts",
+  "corrections",
+  "procedures",
+  "reasoning-traces",
+  "artifacts",
+  "archive",
+  "entities",
+  "identity"
+]);
+var ENCRYPTABLE_STATE_SIDECARS = /* @__PURE__ */ new Set([
+  "state/behavior-signals.jsonl",
+  "state/buffer-surprise-ledger.jsonl",
+  "state/buffer.json",
+  "state/compression-guideline-draft-state.json",
+  "state/compression-guideline-state.json",
+  "state/compression-guidelines.draft.md",
+  "state/compression-guidelines.md",
+  "state/entity-synthesis-queue.json",
+  "state/fact-hashes.txt",
+  "state/memory-actions.jsonl",
+  "state/memory-lifecycle-ledger.jsonl",
+  "state/meta.json",
+  "state/reextract-jobs.jsonl",
+  "state/topics.json"
+]);
+function isEncryptableStateSidecar(normalized) {
+  return ENCRYPTABLE_STATE_SIDECARS.has(normalized);
+}
+function isEncryptableSummarySidecar(normalized) {
+  return normalized.startsWith("summaries/") && normalized.endsWith(".json");
+}
+var DECRYPTABLE_SIDECAR_ROOTS = /* @__PURE__ */ new Set([
+  "state",
+  "indexes",
+  "index",
+  "provenance"
+]);
+
+export {
+  SecureStoreLockedError,
+  SecureStoreDecryptError,
+  MAGIC_BYTES,
+  FILE_FORMAT_VERSION,
+  FILE_FORMAT_FLAGS,
+  MAGIC_HEADER_SIZE,
+  isEncryptedFile,
+  encryptFileBody,
+  decryptFileBody,
+  filePathAad,
+  readMaybeEncryptedFile,
+  writeMaybeEncryptedFile,
+  migrateMemoryDirToEncrypted,
+  decryptMemoryDirToPlaintext
+};

package/dist/{chunk-7TENHBV2.js → chunk-RQCTMECT.js}

@@ -4,6 +4,9 @@ import {
 import {
   log
 } from "./chunk-UFU5GGGA.js";
+import {
+  readEnvVar
+} from "./chunk-I6B2W2IY.js";
 
 // ../remnic-core/src/openai-chat-compat.ts
 function normalizedModel(model) {
@@ -38,51 +41,9 @@ function buildChatCompletionTokenLimit(model, maxTokens, options) {
   return { max_tokens: safeMaxTokens };
 }
 
-// ../remnic-core/src/runtime/env.ts
-import os from "os";
-var REMNIC_ENGRAM_PREFIX_PAIRS = [
-  ["REMNIC_", "ENGRAM_"],
-  ["ENGRAM_", "REMNIC_"]
-];
-function getEnvMap() {
-  const runtimeProcess = globalThis.process;
-  return runtimeProcess?.["env"];
-}
-function legacyEnvCandidates(name) {
-  const candidates = [name];
-  for (const [primary, legacy] of REMNIC_ENGRAM_PREFIX_PAIRS) {
-    if (name.startsWith(primary)) {
-      candidates.push(`${legacy}${name.slice(primary.length)}`);
-    }
-  }
-  return candidates;
-}
-function readEnvVar(name) {
-  const env = getEnvMap();
-  for (const candidate of legacyEnvCandidates(name)) {
-    const value = env?.[candidate];
-    if (typeof value === "string") return value;
-  }
-  return void 0;
-}
-function resolveHomeDir() {
-  return readEnvVar("HOME") || os.homedir();
-}
-function cloneEnv() {
-  return { ...getEnvMap() ?? {} };
-}
-function mergeEnv(overrides) {
-  const merged = cloneEnv();
-  for (const [key, value] of Object.entries(overrides)) {
-    if (typeof value === "string") merged[key] = value;
-    else delete merged[key];
-  }
-  return merged;
-}
-
 // ../remnic-core/src/resolve-provider-secret.ts
 import path from "path";
-import os2 from "os";
+import os from "os";
 var _resolveApiKeyForProvider = null;
 var _getRuntimeAuthForModel = null;
 var _resolverLoaded = false;
@@ -126,6 +87,9 @@ async function getGatewayResolver() {
   return null;
 }
 async function findRuntimeModules() {
+  return findGatewayRuntimeModules("runtime-model-auth.runtime-");
+}
+async function findGatewayRuntimeModules(filePrefix) {
   const { accessSync, constants, readdirSync, realpathSync, statSync } = await import("fs");
   const { createRequire } = await import("module");
   const candidates = [];
@@ -169,7 +133,7 @@ async function findRuntimeModules() {
     try {
       const files = readdirSync(dir);
       for (const f of files) {
-        if (f.startsWith("runtime-model-auth.runtime-") && f.endsWith(".js")) {
+        if (f.startsWith(filePrefix) && f.endsWith(".js")) {
           candidates.push(path.join(dir, f));
         }
       }
@@ -200,7 +164,7 @@ function findExecutableOnPath(executableName, access, stat, executableMode) {
 }
 async function resolveProviderApiKey(providerId, apiKeyValue, gatewayConfig, agentDir) {
   const resolvedAgentDir = path.resolve(
-    agentDir ?? path.join(os2.homedir(), ".openclaw", "agents", "main", "agent")
+    agentDir ?? path.join(os.homedir(), ".openclaw", "agents", "main", "agent")
   );
   const cacheKey = `provider:${providerId}:agentDir:${resolvedAgentDir}`;
   if (resolvedCache.has(cacheKey)) {
@@ -730,10 +694,8 @@ function extractResponsesOutputText(data) {
 }
 
 export {
-  readEnvVar,
-  resolveHomeDir,
-  mergeEnv,
   shouldAssumeOpenAiChatCompletions,
   buildChatCompletionTokenLimit,
+  findGatewayRuntimeModules,
   FallbackLlmClient
 };

package/dist/chunk-SSFTU6LP.js

@@ -0,0 +1,182 @@
+import {
+  getKey,
+  readHeader,
+  secureStoreDir
+} from "./chunk-CXM7EBAO.js";
+import {
+  open,
+  seal
+} from "./chunk-YGGGUTG3.js";
+
+// ../remnic-core/src/transfer/capsule-crypto.ts
+import { open as openFileHandle, readFile, writeFile } from "fs/promises";
+import path from "path";
+var MAGIC = Buffer.from("REMNIC-ENC\0", "ascii");
+var FORMAT_VERSION = 2;
+var MIN_ENC_SIZE_V1 = MAGIC.length + 1 + 45;
+var MIN_ENC_SIZE = MAGIC.length + 1 + 2;
+async function isEncryptedCapsuleFile(filePath) {
+  if (!filePath.endsWith(".enc")) return false;
+  let fh = null;
+  try {
+    fh = await openFileHandle(filePath, "r");
+    const buf = Buffer.allocUnsafe(MAGIC.length);
+    const { bytesRead } = await fh.read(buf, 0, MAGIC.length, 0);
+    if (bytesRead < MAGIC.length) return false;
+    return buf.equals(MAGIC);
+  } catch {
+    return false;
+  } finally {
+    if (fh !== null) {
+      await fh.close().catch(() => void 0);
+    }
+  }
+}
+async function encryptCapsuleFile(opts) {
+  const encPath = opts.outPath ?? `${opts.sourceGzPath}.enc`;
+  const key = getKeyOrThrow(opts.memoryDir, "encrypt capsule");
+  const plaintext = await readFile(opts.sourceGzPath);
+  const basename = path.basename(encPath);
+  const aad = Buffer.from(basename, "utf-8");
+  const kdfSection = await loadKdfSection(opts.memoryDir);
+  const envelope = seal(key, kdfSection.salt, plaintext, { aad });
+  const versionBuf = Buffer.alloc(1);
+  versionBuf.writeUInt8(FORMAT_VERSION, 0);
+  const kdfJsonBuf = Buffer.from(kdfSection.json, "utf-8");
+  const kdfLenBuf = Buffer.alloc(2);
+  kdfLenBuf.writeUInt16LE(kdfJsonBuf.length, 0);
+  const output = Buffer.concat([MAGIC, versionBuf, kdfLenBuf, kdfJsonBuf, envelope]);
+  await writeFile(encPath, output);
+  return { encPath };
+}
+async function decryptCapsuleFile(opts) {
+  const gzPath = opts.outPath ?? opts.encPath.replace(/\.enc$/, "");
+  const buf = await readFile(opts.encPath);
+  if (buf.length < MIN_ENC_SIZE_V1) {
+    throw new Error(
+      `decryptCapsuleFile: file too short to be an encrypted capsule: ${opts.encPath}`
+    );
+  }
+  if (!buf.subarray(0, MAGIC.length).equals(MAGIC)) {
+    throw new Error(
+      `decryptCapsuleFile: file does not start with REMNIC-ENC magic: ${opts.encPath}`
+    );
+  }
+  const version = buf.readUInt8(MAGIC.length);
+  if (version !== 1 && version !== 2) {
+    throw new Error(
+      `decryptCapsuleFile: unsupported encrypted-capsule format version ${version} (this build supports versions 1 and 2): ${opts.encPath}`
+    );
+  }
+  const { key, envelopeOffset } = resolveKeyAndOffset(buf, version, opts.memoryDir, "decryptCapsuleFile", opts.encPath);
+  const envelope = buf.subarray(envelopeOffset);
+  const basename = path.basename(opts.encPath);
+  const aad = Buffer.from(basename, "utf-8");
+  let plaintext;
+  try {
+    plaintext = open(key, envelope, { aad });
+  } catch (cause) {
+    throw new Error(
+      `decryptCapsuleFile: authentication failed \u2014 wrong passphrase, tampered archive, or key mismatch. Ensure the secure-store is unlocked with the correct passphrase and the archive has not been modified: ${opts.encPath}`,
+      { cause }
+    );
+  }
+  await writeFile(gzPath, plaintext);
+  return { gzPath };
+}
+async function decryptCapsuleFileInMemory(encPath, memoryDir) {
+  const buf = await readFile(encPath);
+  if (buf.length < MIN_ENC_SIZE_V1) {
+    throw new Error(
+      `decryptCapsuleFileInMemory: file too short to be an encrypted capsule: ${encPath}`
+    );
+  }
+  if (!buf.subarray(0, MAGIC.length).equals(MAGIC)) {
+    throw new Error(
+      `decryptCapsuleFileInMemory: file does not start with REMNIC-ENC magic: ${encPath}`
+    );
+  }
+  const version = buf.readUInt8(MAGIC.length);
+  if (version !== 1 && version !== 2) {
+    throw new Error(
+      `decryptCapsuleFileInMemory: unsupported encrypted-capsule format version ${version} (this build supports versions 1 and 2): ${encPath}`
+    );
+  }
+  const { key, envelopeOffset } = resolveKeyAndOffset(buf, version, memoryDir, "decryptCapsuleFileInMemory", encPath);
+  const envelope = buf.subarray(envelopeOffset);
+  const basename = path.basename(encPath);
+  const aad = Buffer.from(basename, "utf-8");
+  try {
+    return open(key, envelope, { aad });
+  } catch (cause) {
+    throw new Error(
+      `decryptCapsuleFileInMemory: authentication failed \u2014 wrong passphrase, tampered archive, or key mismatch. Ensure the secure-store is unlocked with the correct passphrase and the archive has not been modified: ${encPath}`,
+      { cause }
+    );
+  }
+}
+async function loadKdfSection(memoryDir) {
+  try {
+    const header = await readHeader(memoryDir);
+    if (header !== null) {
+      const { decodeMetadataSalt } = await import("./metadata-JAGIWHEA.js");
+      const salt2 = decodeMetadataSalt(header.metadata);
+      const kdf = header.metadata.kdf;
+      const json2 = JSON.stringify({
+        algorithm: kdf.algorithm,
+        params: kdf.params,
+        salt: salt2.toString("hex")
+      });
+      return { json: json2, salt: salt2 };
+    }
+  } catch {
+  }
+  const { generateSalt } = await import("./cipher-VHAFCG7Z.js");
+  const salt = generateSalt();
+  const { DEFAULT_ARGON2ID_PARAMS } = await import("./kdf-H5B23ZM2.js");
+  const json = JSON.stringify({
+    algorithm: "argon2id",
+    params: DEFAULT_ARGON2ID_PARAMS,
+    salt: salt.toString("hex")
+  });
+  return { json, salt };
+}
+function getKeyOrThrow(memoryDir, action) {
+  const storeId = secureStoreDir(memoryDir);
+  const key = getKey(storeId);
+  if (key === null) {
+    throw new Error(
+      `Secure-store is locked or not initialized \u2014 cannot ${action}. Run \`remnic secure-store unlock\` first, or \`remnic secure-store init\` if the store has never been initialized.`
+    );
+  }
+  return key;
+}
+function resolveKeyAndOffset(buf, version, memoryDir, caller, encPath) {
+  if (version === 1) {
+    const key2 = getKeyOrThrow(memoryDir, "decrypt capsule");
+    return { key: key2, envelopeOffset: MAGIC.length + 1 };
+  }
+  const kdfLenOffset = MAGIC.length + 1;
+  if (buf.length < kdfLenOffset + 2) {
+    throw new Error(
+      `${caller}: file too short for format v2 KDF length field: ${encPath}`
+    );
+  }
+  const kdfLen = buf.readUInt16LE(kdfLenOffset);
+  const kdfJsonOffset = kdfLenOffset + 2;
+  if (buf.length < kdfJsonOffset + kdfLen) {
+    throw new Error(
+      `${caller}: file too short for format v2 KDF params section (expected ${kdfLen} bytes): ${encPath}`
+    );
+  }
+  const envelopeOffset = kdfJsonOffset + kdfLen;
+  const key = getKeyOrThrow(memoryDir, "decrypt capsule");
+  return { key, envelopeOffset };
+}
+
+export {
+  isEncryptedCapsuleFile,
+  encryptCapsuleFile,
+  decryptCapsuleFile,
+  decryptCapsuleFileInMemory
+};

package/dist/{chunk-BXTMZDRT.js → chunk-SVSQAG6M.js}

@@ -1,12 +1,14 @@
 import {
-  assertIsoRecordedAt,
-  assertString,
   countRecallTokenOverlap,
-  isRecord,
   normalizeRecallTokens,
-  recordStoreDay,
   topicOverlapScore
-} from "./chunk-YHH3SXKD.js";
+} from "./chunk-WPINX4MF.js";
+import {
+  assertIsoRecordedAt,
+  assertString,
+  isRecord,
+  recordStoreDay
+} from "./chunk-3G7FAF6S.js";
 import {
   listJsonFiles,
   readJsonFile

package/dist/{chunk-S2ISS4AH.js → chunk-TILAJIJR.js}

@@ -1,18 +1,18 @@
-import {
-  readEnvVar,
-  resolveHomeDir
-} from "./chunk-7TENHBV2.js";
-import {
-  StorageManager,
-  isConsolidationOperator
-} from "./chunk-JJSNPSCD.js";
 import {
   countRecallTokenOverlap,
   normalizeRecallTokens
-} from "./chunk-YHH3SXKD.js";
+} from "./chunk-WPINX4MF.js";
+import {
+  StorageManager,
+  isSemanticConsolidationLlmOperator
+} from "./chunk-7UZNLMW5.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";
+import {
+  readEnvVar,
+  resolveHomeDir
+} from "./chunk-I6B2W2IY.js";
 
 // ../remnic-core/src/connectors/codex-materialize-runner.ts
 import path2 from "path";
@@ -990,7 +990,7 @@ function parseOperatorAwareConsolidationResponse(response, cluster) {
   const obj = parsed;
   const rawOperator = typeof obj.operator === "string" ? obj.operator.trim().toLowerCase() : "";
   const rawOutput = typeof obj.output === "string" ? obj.output : "";
-  const operator = isConsolidationOperator(rawOperator) ? rawOperator : chooseConsolidationOperator(cluster);
+  const operator = isSemanticConsolidationLlmOperator(rawOperator) ? rawOperator : chooseConsolidationOperator(cluster);
   const output = rawOutput.trim().length > 0 ? rawOutput.trim() : response.trim();
   return { operator, output };
 }