@remnic/plugin-openclaw 1.0.7 → 1.0.8

package/dist/{causal-consolidation-S6M7UTZG.js → causal-consolidation-33R5JTPX.js}

@@ -1,8 +1,13 @@
 import {
   buildExtensionsBlockForConsolidation,
   runPostConsolidationMaterialize
-} from "./chunk-QHMR3D7U.js";
-import "./chunk-KPMXWORS.js";
+} from "./chunk-BQLPVRIU.js";
+import {
+  FallbackLlmClient
+} from "./chunk-NXLHSCLU.js";
+import "./chunk-3A5ELHTT.js";
+import "./chunk-JJSNPSCD.js";
+import "./chunk-6OJAU466.js";
 import {
   readChainIndex,
   resolveChainsDir
@@ -10,10 +15,6 @@ import {
 import {
   isRecord
 } from "./chunk-YHH3SXKD.js";
-import {
-  FallbackLlmClient
-} from "./chunk-NXLHSCLU.js";
-import "./chunk-3A5ELHTT.js";
 import {
   listJsonFiles,
   readJsonFile

package/dist/chunk-5ZW5XJQ6.js

@@ -0,0 +1,125 @@
+import {
+  log
+} from "./chunk-UFU5GGGA.js";
+
+// ../remnic-core/src/extraction-judge-telemetry.ts
+import path from "path";
+import { appendFile, mkdir, readFile } from "fs/promises";
+var EXTRACTION_JUDGE_VERDICT_CATEGORY = "EXTRACTION_JUDGE_VERDICT";
+function judgeTelemetryPath(memoryDir) {
+  return path.join(
+    memoryDir,
+    "state",
+    "observation-ledger",
+    "extraction-judge-verdicts.jsonl"
+  );
+}
+async function recordJudgeVerdict(event, options) {
+  if (!options.enabled) return;
+  const filePath = judgeTelemetryPath(options.memoryDir);
+  try {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await appendFile(filePath, `${JSON.stringify(event)}
+`, "utf-8");
+  } catch (err) {
+    log.debug(
+      `extraction-judge-telemetry: append failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function readJudgeVerdictStats(memoryDir, opts = {}) {
+  const filePath = judgeTelemetryPath(memoryDir);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return {
+        total: 0,
+        accept: 0,
+        reject: 0,
+        defer: 0,
+        deferCapTriggered: 0,
+        meanElapsedMs: 0,
+        deferRate: 0,
+        malformed: 0
+      };
+    }
+    throw err;
+  }
+  let total = 0;
+  let accept = 0;
+  let reject = 0;
+  let defer = 0;
+  let deferCapTriggered = 0;
+  let elapsedSum = 0;
+  let malformed = 0;
+  let firstTs;
+  let lastTs;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      malformed += 1;
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      malformed += 1;
+      continue;
+    }
+    const p = parsed;
+    if (p.category !== EXTRACTION_JUDGE_VERDICT_CATEGORY) {
+      malformed += 1;
+      continue;
+    }
+    const ts = typeof p.ts === "string" ? p.ts : null;
+    if (ts === null) {
+      malformed += 1;
+      continue;
+    }
+    const tsMs = Date.parse(ts);
+    if (!Number.isFinite(tsMs)) {
+      malformed += 1;
+      continue;
+    }
+    if (typeof opts.sinceMs === "number" && tsMs < opts.sinceMs) continue;
+    if (typeof opts.untilMs === "number" && tsMs >= opts.untilMs) continue;
+    const kind = p.verdictKind;
+    if (kind === "accept") accept += 1;
+    else if (kind === "reject") reject += 1;
+    else if (kind === "defer") defer += 1;
+    else {
+      malformed += 1;
+      continue;
+    }
+    if (p.deferCapTriggered === true) deferCapTriggered += 1;
+    if (typeof p.elapsedMs === "number" && Number.isFinite(p.elapsedMs)) {
+      elapsedSum += p.elapsedMs;
+    }
+    total += 1;
+    if (firstTs === void 0 || ts < firstTs) firstTs = ts;
+    if (lastTs === void 0 || ts > lastTs) lastTs = ts;
+  }
+  return {
+    total,
+    accept,
+    reject,
+    defer,
+    deferCapTriggered,
+    meanElapsedMs: total > 0 ? elapsedSum / total : 0,
+    deferRate: total > 0 ? defer / total : 0,
+    firstTs,
+    lastTs,
+    malformed
+  };
+}
+
+export {
+  EXTRACTION_JUDGE_VERDICT_CATEGORY,
+  judgeTelemetryPath,
+  recordJudgeVerdict,
+  readJudgeVerdictStats
+};

package/dist/chunk-6OJAU466.js

@@ -0,0 +1,148 @@
+// ../remnic-core/src/page-versioning.ts
+import { createHash } from "crypto";
+import path from "path";
+import {
+  access,
+  mkdir,
+  readFile,
+  writeFile,
+  unlink
+} from "fs/promises";
+var NOOP_LOGGER = {
+  debug: () => {
+  },
+  warn: () => {
+  }
+};
+var writeLocks = /* @__PURE__ */ new Map();
+function withPageLock(pageKey, fn) {
+  const prev = writeLocks.get(pageKey) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  writeLocks.set(pageKey, next.then(() => {
+  }, () => {
+  }));
+  return next;
+}
+function contentHash(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function sidecarKey(pagePath) {
+  const withoutExt = pagePath.replace(/\.md$/i, "");
+  return withoutExt.replace(/[\\/]/g, "__");
+}
+function sidecarDir(memoryDir, sidecar, pagePath) {
+  return path.join(memoryDir, sidecar, sidecarKey(pagePath));
+}
+function manifestPath(memoryDir, sidecar, pagePath) {
+  return path.join(sidecarDir(memoryDir, sidecar, pagePath), "manifest.json");
+}
+async function fileExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readManifest(memoryDir, sidecar, pagePath) {
+  const mp = manifestPath(memoryDir, sidecar, pagePath);
+  try {
+    const raw = await readFile(mp, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) {
+      return { pagePath, versions: [], currentVersion: "0" };
+    }
+    const obj = parsed;
+    const versions = Array.isArray(obj.versions) ? obj.versions : [];
+    const currentVersion = typeof obj.currentVersion === "string" ? obj.currentVersion : "0";
+    return { pagePath: typeof obj.pagePath === "string" ? obj.pagePath : pagePath, versions, currentVersion };
+  } catch {
+    return { pagePath, versions: [], currentVersion: "0" };
+  }
+}
+async function writeManifest(memoryDir, sidecar, pagePath, history) {
+  const dir = sidecarDir(memoryDir, sidecar, pagePath);
+  await mkdir(dir, { recursive: true });
+  const mp = manifestPath(memoryDir, sidecar, pagePath);
+  await writeFile(mp, JSON.stringify(history, null, 2) + "\n", "utf-8");
+}
+async function createVersion(pagePath, content, trigger, config, log = NOOP_LOGGER, note, memoryDir) {
+  const { sidecarDir: sidecar, maxVersionsPerPage } = config;
+  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);
+  const mPath = manifestPath(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));
+  return withPageLock(mPath, async () => {
+    const history = await readManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));
+    const nextId = String(history.versions.length > 0 ? Math.max(...history.versions.map((v) => Number(v.versionId))) + 1 : 1);
+    const hash = contentHash(content);
+    const version = {
+      versionId: nextId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      contentHash: hash,
+      sizeBytes: Buffer.byteLength(content, "utf-8"),
+      trigger,
+      ...note !== void 0 ? { note } : {}
+    };
+    const dir = sidecarDir(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));
+    await mkdir(dir, { recursive: true });
+    const ext = path.extname(pagePath) || ".md";
+    const snapshotPath = path.join(dir, `${nextId}${ext}`);
+    await writeFile(snapshotPath, content, "utf-8");
+    history.versions.push(version);
+    history.currentVersion = nextId;
+    if (maxVersionsPerPage > 0 && history.versions.length > maxVersionsPerPage) {
+      const toRemove = history.versions.splice(0, history.versions.length - maxVersionsPerPage);
+      for (const old of toRemove) {
+        const oldPath = path.join(dir, `${old.versionId}${ext}`);
+        try {
+          await unlink(oldPath);
+        } catch {
+          log.debug(`page-versioning: could not remove old snapshot ${oldPath}`);
+        }
+      }
+    }
+    await writeManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir), history);
+    log.debug(`page-versioning: created version ${nextId} for ${pagePath} (trigger=${trigger})`);
+    return version;
+  });
+}
+async function getVersion(pagePath, versionId, config, memoryDir) {
+  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);
+  const rel = relPath(pagePath, resolvedMemoryDir);
+  const ext = path.extname(pagePath) || ".md";
+  const dir = sidecarDir(resolvedMemoryDir, config.sidecarDir, rel);
+  const snapshotPath = path.join(dir, `${versionId}${ext}`);
+  if (!await fileExists(snapshotPath)) {
+    throw new Error(`Version ${versionId} not found for ${pagePath}`);
+  }
+  return readFile(snapshotPath, "utf-8");
+}
+function resolveMemoryDir(pagePath) {
+  const knownSubdirs = /* @__PURE__ */ new Set([
+    "facts",
+    "corrections",
+    "entities",
+    "state",
+    "artifacts",
+    "questions",
+    "profiles"
+  ]);
+  let dir = path.dirname(pagePath);
+  for (let depth = 0; depth < 5; depth++) {
+    const base = path.basename(dir);
+    if (knownSubdirs.has(base) || /^\d{4}-\d{2}-\d{2}$/.test(base)) {
+      dir = path.dirname(dir);
+    } else {
+      break;
+    }
+  }
+  return dir;
+}
+function relPath(pagePath, memoryDir) {
+  return path.relative(memoryDir, pagePath);
+}
+
+export {
+  sidecarKey,
+  createVersion,
+  getVersion
+};

package/dist/{chunk-QHMR3D7U.js → chunk-BQLPVRIU.js}

@@ -1,6 +1,7 @@
 import {
-  StorageManager
-} from "./chunk-KPMXWORS.js";
+  StorageManager,
+  isConsolidationOperator
+} from "./chunk-JJSNPSCD.js";
 import {
   countRecallTokenOverlap,
   normalizeRecallTokens
@@ -936,6 +937,109 @@ Write ONLY the consolidated memory content (no metadata, no explanation, no prea
 function parseConsolidationResponse(response) {
   return response.trim();
 }
+function chooseConsolidationOperator(cluster) {
+  if (cluster.memories.length <= 1) return "update";
+  return "merge";
+}
+function buildOperatorAwareConsolidationPrompt(cluster) {
+  const memoryTexts = cluster.memories.map(
+    (m, i) => `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):
+${m.content}`
+  ).join("\n\n");
+  return `You are a memory consolidation system.  The following ${cluster.memories.length} memories in the "${cluster.category}" category contain overlapping information.
+
+Pick exactly ONE consolidation operator for this cluster and return a JSON object.
+
+Operator vocabulary:
+  - "merge"  \u2014 multiple distinct source memories overlap and should be collapsed into one canonical memory (most common).
+  - "update" \u2014 one source memory carries a stale value that a newer source supersedes within the same logical fact.
+  - "split"  \u2014 a single logical source really encodes multiple distinct facts that should be separated (rare; if you pick split, still emit ONE canonical body \u2014 the write path will chunk it later).
+
+Output JSON ONLY, no prose before or after.  The "operator" key MUST be set to exactly one of the three strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder like "merge|update|split".  Example shape:
+  {
+    "operator": "merge",
+    "output": "<the canonical memory text>"
+  }
+
+The "output" value must:
+1. Preserve ALL unique information from every source memory
+2. Remove redundancy and repetition
+3. Use clear, concise language
+4. Match the "${cluster.category}" category and tone
+5. NOT add information that isn't in the sources
+
+${memoryTexts}
+
+Return ONLY the JSON object:`;
+}
+function parseOperatorAwareConsolidationResponse(response, cluster) {
+  const fallback = {
+    operator: chooseConsolidationOperator(cluster),
+    output: response.trim()
+  };
+  const trimmed = response.trim();
+  if (trimmed.length === 0) return fallback;
+  const fenced = /^```(?:json)?\s*([\s\S]*?)```\s*$/u.exec(trimmed);
+  const payload = fenced ? fenced[1].trim() : trimmed;
+  const parsed = findLastJsonObjectWithOperator(payload);
+  if (parsed === void 0) return fallback;
+  if (typeof parsed !== "object" || parsed === null) return fallback;
+  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 output = rawOutput.trim().length > 0 ? rawOutput.trim() : response.trim();
+  return { operator, output };
+}
+function findLastJsonObjectWithOperator(text) {
+  let searchFrom = 0;
+  let last = void 0;
+  while (searchFrom < text.length) {
+    const start = text.indexOf("{", searchFrom);
+    if (start < 0) return last;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    let closed = false;
+    let endIdx = -1;
+    for (let i = start; i < text.length; i++) {
+      const ch = text[i];
+      if (inString) {
+        if (escape) {
+          escape = false;
+        } else if (ch === "\\") {
+          escape = true;
+        } else if (ch === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+      } else if (ch === "{") {
+        depth += 1;
+      } else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          closed = true;
+          endIdx = i;
+          break;
+        }
+      }
+    }
+    if (!closed) return last;
+    const slice = text.slice(start, endIdx + 1);
+    try {
+      const parsed = JSON.parse(slice);
+      if (typeof parsed === "object" && parsed !== null && "operator" in parsed) {
+        last = parsed;
+      }
+    } catch {
+    }
+    searchFrom = endIdx + 1;
+  }
+  return last;
+}
 async function buildExtensionsBlockForConsolidation(config) {
   if (!config.memoryExtensionsEnabled) return "";
   const root = resolveExtensionsRoot(config);
@@ -955,6 +1059,9 @@ export {
   findSimilarClusters,
   buildConsolidationPrompt,
   parseConsolidationResponse,
+  chooseConsolidationOperator,
+  buildOperatorAwareConsolidationPrompt,
+  parseOperatorAwareConsolidationResponse,
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };