@remnic/plugin-openclaw 1.0.7 → 1.0.9

package/dist/{calibration-BAC7KNKR.js → calibration-674TDQNV.js}

@@ -1,6 +1,6 @@
 import {
   FallbackLlmClient
-} from "./chunk-NXLHSCLU.js";
+} from "./chunk-7TENHBV2.js";
 import "./chunk-3A5ELHTT.js";
 import {
   listJsonFiles

package/dist/{causal-consolidation-S6M7UTZG.js → causal-consolidation-5BEXLQV5.js}

@@ -1,8 +1,13 @@
 import {
   buildExtensionsBlockForConsolidation,
   runPostConsolidationMaterialize
-} from "./chunk-QHMR3D7U.js";
-import "./chunk-KPMXWORS.js";
+} from "./chunk-S2ISS4AH.js";
+import {
+  FallbackLlmClient
+} from "./chunk-7TENHBV2.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-NXLHSCLU.js → chunk-7TENHBV2.js}

@@ -126,9 +126,8 @@ async function getGatewayResolver() {
   return null;
 }
 async function findRuntimeModules() {
-  const { readdirSync } = await import("fs");
+  const { accessSync, constants, readdirSync, realpathSync, statSync } = await import("fs");
   const { createRequire } = await import("module");
-  const { execFileSync } = await import("child_process");
   const candidates = [];
   const distDirs = [];
   const pushDistDirs = (entryPath) => {
@@ -150,7 +149,6 @@ async function findRuntimeModules() {
   } catch {
   }
   try {
-    const { realpathSync } = await import("fs");
     const mainScript = process.argv[1];
     if (mainScript) {
       const realScript = realpathSync(mainScript);
@@ -161,12 +159,8 @@ async function findRuntimeModules() {
   } catch {
   }
   try {
-    const openclawBin = execFileSync("which", ["openclaw"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
+    const openclawBin = findExecutableOnPath("openclaw", accessSync, statSync, constants.X_OK);
     if (openclawBin) {
-      const { realpathSync } = await import("fs");
       pushDistDirs(realpathSync(openclawBin));
     }
   } catch {
@@ -184,6 +178,26 @@ async function findRuntimeModules() {
   }
   return candidates;
 }
+function findExecutableOnPath(executableName, access, stat, executableMode) {
+  const pathEnv = readEnvVar("PATH");
+  if (!pathEnv) return void 0;
+  const pathExts = process.platform === "win32" ? (readEnvVar("PATHEXT") ?? ".EXE;.CMD;.BAT;.COM").split(";").filter((ext) => ext.length > 0) : [""];
+  const hasExtension = path.extname(executableName).length > 0;
+  for (const dir of pathEnv.split(path.delimiter)) {
+    if (!dir) continue;
+    const candidateNames = process.platform === "win32" && !hasExtension ? pathExts.map((ext) => `${executableName}${ext}`) : [executableName];
+    for (const candidateName of candidateNames) {
+      const candidate = path.join(dir, candidateName);
+      try {
+        access(candidate, executableMode);
+        if (!stat(candidate).isFile()) continue;
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
 async function resolveProviderApiKey(providerId, apiKeyValue, gatewayConfig, agentDir) {
   const resolvedAgentDir = path.resolve(
     agentDir ?? path.join(os2.homedir(), ".openclaw", "agents", "main", "agent")

package/dist/{chunk-SVGN3ACY.js → chunk-HCFFXBLV.js}

@@ -3,7 +3,7 @@ import {
   parseContinuityImprovementLoops,
   parseContinuityIncident,
   sanitizeMemoryContent
-} from "./chunk-KPMXWORS.js";
+} from "./chunk-JJSNPSCD.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";
@@ -4881,7 +4881,7 @@ var CompoundingEngine = class {
     let promotionCandidates = this.config.compoundingSemanticEnabled ? this.derivePromotionCandidates(outcomeSummary, mistakes.registry, rubrics) : [];
     if (this.config.cmcConsolidationEnabled) {
       try {
-        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-S6M7UTZG.js");
+        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-5BEXLQV5.js");
         const causalCandidates = await deriveCausalPromotionCandidates({
           memoryDir: this.config.memoryDir,
           causalTrajectoryStoreDir: this.config.causalTrajectoryStoreDir,
@@ -4913,7 +4913,7 @@ var CompoundingEngine = class {
     }
     if (this.config.calibrationEnabled) {
       try {
-        const { runCalibrationConsolidation } = await import("./calibration-BAC7KNKR.js");
+        const { runCalibrationConsolidation } = await import("./calibration-674TDQNV.js");
         const calRules = await runCalibrationConsolidation({
           memoryDir: this.config.memoryDir,
           gatewayConfig: this.config.gatewayConfig,