@remnic/plugin-openclaw 1.0.35 → 1.0.37

package/dist/chunk-LZCGPRHS.js

@@ -0,0 +1,228 @@
+import {
+  clamp01,
+  computeLifecycleValueInputs,
+  daysSince
+} from "./chunk-BZ4EYURA.js";
+
+// ../remnic-core/src/tier-routing.ts
+function computeTierValueScore(memory, now, signals) {
+  const fm = memory.frontmatter;
+  const inputs = computeLifecycleValueInputs(memory, now, signals);
+  const correctionBoost = fm.category === "correction" ? 0.08 : 0;
+  const confirmedBoost = fm.verificationState === "user_confirmed" ? 0.05 : 0;
+  const score = inputs.confidence * 0.24 + inputs.access * 0.26 + inputs.recency * 0.2 + inputs.importance * 0.2 + inputs.feedback * 0.1 + correctionBoost + confirmedBoost - inputs.disputedPenalty * 0.5;
+  return clamp01(score);
+}
+function decideTierTransition(memory, currentTier, policy, now, signals) {
+  const valueScore = computeTierValueScore(memory, now, signals);
+  if (!policy.enabled) {
+    return {
+      currentTier,
+      nextTier: currentTier,
+      valueScore,
+      changed: false,
+      reason: "tier_migration_disabled"
+    };
+  }
+  if (currentTier === "hot") {
+    const ageDays = daysSince(memory.frontmatter.updated ?? memory.frontmatter.created, now.getTime());
+    if (ageDays >= policy.demotionMinAgeDays && valueScore <= policy.demotionValueThreshold) {
+      return {
+        currentTier,
+        nextTier: "cold",
+        valueScore,
+        changed: true,
+        reason: "value_below_demotion_threshold"
+      };
+    }
+    return {
+      currentTier,
+      nextTier: currentTier,
+      valueScore,
+      changed: false,
+      reason: ageDays < policy.demotionMinAgeDays ? "demotion_min_age_not_met" : "value_above_demotion_threshold"
+    };
+  }
+  if (valueScore >= policy.promotionValueThreshold) {
+    return {
+      currentTier,
+      nextTier: "hot",
+      valueScore,
+      changed: true,
+      reason: "value_above_promotion_threshold"
+    };
+  }
+  return {
+    currentTier,
+    nextTier: currentTier,
+    valueScore,
+    changed: false,
+    reason: "value_below_promotion_threshold"
+  };
+}
+
+// ../remnic-core/src/utility-learner.ts
+import path2 from "path";
+import * as fsReadModule0 from "fs/promises";
+const mkdir2 = fsReadModule0.mkdir;
+const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
+const rename = fsReadModule0.rename;
+const writeFile2 = fsReadModule0.writeFile;
+
+// ../remnic-core/src/utility-telemetry.ts
+import path from "path";
+import { mkdir, writeFile } from "fs/promises";
+function resolveUtilityTelemetryDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path.join(memoryDir, "state", "utility-telemetry");
+}
+
+// ../remnic-core/src/utility-learner.ts
+var UTILITY_LEARNING_SNAPSHOT_VERSION = 1;
+var UTILITY_LEARNING_STATE_FILE = "learning-state.json";
+function roundWeight(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function validateUtilityLearningSnapshot(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("utility learning snapshot must be an object");
+  }
+  const record = raw;
+  if (record.version !== UTILITY_LEARNING_SNAPSHOT_VERSION) {
+    throw new Error("utility learning snapshot version must be 1");
+  }
+  if (typeof record.updatedAt !== "string" || record.updatedAt.length === 0) {
+    throw new Error("utility learning snapshot updatedAt must be a string");
+  }
+  if (typeof record.windowDays !== "number" || !Number.isFinite(record.windowDays) || record.windowDays < 0) {
+    throw new Error("utility learning snapshot windowDays must be a non-negative number");
+  }
+  if (typeof record.minEventCount !== "number" || !Number.isFinite(record.minEventCount) || record.minEventCount < 1) {
+    throw new Error("utility learning snapshot minEventCount must be >= 1");
+  }
+  if (typeof record.maxWeightMagnitude !== "number" || !Number.isFinite(record.maxWeightMagnitude) || record.maxWeightMagnitude < 0) {
+    throw new Error("utility learning snapshot maxWeightMagnitude must be >= 0");
+  }
+  if (!Array.isArray(record.weights)) {
+    throw new Error("utility learning snapshot weights must be an array");
+  }
+  const weights = record.weights.map((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error("utility learning weight must be an object");
+    }
+    const weight = entry;
+    const target = weight.target;
+    const decision = weight.decision;
+    if (target !== "promotion" && target !== "ranking") {
+      throw new Error("utility learning weight target must be promotion|ranking");
+    }
+    if (!["promote", "demote", "hold", "boost", "suppress"].includes(String(decision))) {
+      throw new Error("utility learning weight decision is invalid");
+    }
+    if (typeof weight.eventCount !== "number" || !Number.isFinite(weight.eventCount) || weight.eventCount < 0) {
+      throw new Error("utility learning weight eventCount must be >= 0");
+    }
+    if (typeof weight.learnedWeight !== "number" || !Number.isFinite(weight.learnedWeight)) {
+      throw new Error("utility learning weight learnedWeight must be finite");
+    }
+    if (typeof weight.averageUtilityScore !== "number" || !Number.isFinite(weight.averageUtilityScore)) {
+      throw new Error("utility learning weight averageUtilityScore must be finite");
+    }
+    if (typeof weight.confidence !== "number" || !Number.isFinite(weight.confidence)) {
+      throw new Error("utility learning weight confidence must be finite");
+    }
+    if (typeof weight.updatedAt !== "string" || weight.updatedAt.length === 0) {
+      throw new Error("utility learning weight updatedAt must be a string");
+    }
+    const outcomeCounts = weight.outcomeCounts ?? {};
+    return {
+      target,
+      decision,
+      eventCount: weight.eventCount,
+      learnedWeight: roundWeight(weight.learnedWeight),
+      averageUtilityScore: roundWeight(weight.averageUtilityScore),
+      confidence: roundWeight(clamp01(weight.confidence)),
+      outcomeCounts,
+      updatedAt: weight.updatedAt
+    };
+  });
+  return {
+    version: 1,
+    updatedAt: record.updatedAt,
+    windowDays: record.windowDays,
+    minEventCount: record.minEventCount,
+    maxWeightMagnitude: record.maxWeightMagnitude,
+    weights
+  };
+}
+function resolveUtilityLearningStatePath(memoryDir, utilityTelemetryDir) {
+  return path2.join(resolveUtilityTelemetryDir(memoryDir, utilityTelemetryDir), UTILITY_LEARNING_STATE_FILE);
+}
+async function readUtilityLearningSnapshot(memoryDir, utilityTelemetryDir) {
+  const statePath = resolveUtilityLearningStatePath(memoryDir, utilityTelemetryDir);
+  try {
+    const raw = JSON.parse(await fileReader(statePath, "utf8"));
+    return validateUtilityLearningSnapshot(raw);
+  } catch {
+    return null;
+  }
+}
+
+// ../remnic-core/src/utility-runtime.ts
+var RANKING_MULTIPLIER_LIMIT = 0.12;
+var PROMOTION_THRESHOLD_DELTA_LIMIT = 0.07;
+var PROMOTION_THRESHOLD_WEIGHT_FACTOR = 0.2;
+function roundRuntimeValue(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function clampSigned(value, limit) {
+  if (!Number.isFinite(value) || limit <= 0) return 0;
+  return Math.max(-limit, Math.min(limit, value));
+}
+function learnedWeightFor(snapshot, target, decision) {
+  const entry = snapshot.weights.find((weight) => weight.target === target && weight.decision === decision);
+  return entry?.learnedWeight ?? 0;
+}
+async function loadUtilityRuntimeValues(options) {
+  if (!options.memoryUtilityLearningEnabled || !options.promotionByOutcomeEnabled) return null;
+  const snapshot = await readUtilityLearningSnapshot(options.memoryDir, options.utilityTelemetryDir);
+  if (!snapshot) return null;
+  return {
+    rankingBoostMultiplier: roundRuntimeValue(
+      1 + clampSigned(learnedWeightFor(snapshot, "ranking", "boost"), RANKING_MULTIPLIER_LIMIT)
+    ),
+    rankingSuppressMultiplier: roundRuntimeValue(
+      1 + clampSigned(learnedWeightFor(snapshot, "ranking", "suppress"), RANKING_MULTIPLIER_LIMIT)
+    ),
+    promoteThresholdDelta: roundRuntimeValue(
+      clampSigned(
+        learnedWeightFor(snapshot, "promotion", "promote") * -PROMOTION_THRESHOLD_WEIGHT_FACTOR,
+        PROMOTION_THRESHOLD_DELTA_LIMIT
+      )
+    ),
+    demoteThresholdDelta: roundRuntimeValue(
+      clampSigned(
+        learnedWeightFor(snapshot, "promotion", "demote") * PROMOTION_THRESHOLD_WEIGHT_FACTOR,
+        PROMOTION_THRESHOLD_DELTA_LIMIT
+      )
+    ),
+    snapshotUpdatedAt: snapshot.updatedAt
+  };
+}
+function applyUtilityPromotionRuntimePolicy(policy, runtime) {
+  if (!runtime) return policy;
+  return {
+    ...policy,
+    demotionValueThreshold: roundRuntimeValue(clamp01(policy.demotionValueThreshold + runtime.demoteThresholdDelta)),
+    promotionValueThreshold: roundRuntimeValue(clamp01(policy.promotionValueThreshold + runtime.promoteThresholdDelta))
+  };
+}
+
+export {
+  computeTierValueScore,
+  decideTierTransition,
+  loadUtilityRuntimeValues,
+  applyUtilityPromotionRuntimePolicy
+};

package/dist/{chunk-CXM7EBAO.js → chunk-MXFJXUHC.js}

@@ -15,7 +15,7 @@ import {
 } from "./chunk-YGGGUTG3.js";
 import {
   __export
-} from "./chunk-MLKGABMK.js";
+} from "./chunk-I2KLQ2HA.js";
 
 // ../remnic-core/src/secure-store/header.ts
 import * as fsReadModule0 from "fs/promises";

package/dist/{chunk-VRGUUHBV.js → chunk-NUWDSTP7.js}

@@ -1,6 +1,6 @@
 import {
   expandTildePath
-} from "./chunk-TDRJVMUP.js";
+} from "./chunk-EH4AXGRO.js";
 
 // ../remnic-core/src/connectors/live/state-store.ts
 import { promises as fs } from "fs";

package/dist/{chunk-4LYQ4ONL.js → chunk-QCCP4RU5.js}

@@ -1,6 +1,6 @@
 import {
   external_exports
-} from "./chunk-EXDYWXMB.js";
+} from "./chunk-4XDQ3KEC.js";
 
 // ../remnic-core/src/transfer/types.ts
 var ExportManifestV1Schema = external_exports.object({
@@ -34,6 +34,11 @@ var SemverLikeSchema = external_exports.string().min(1, "capsule.version must no
   /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/,
   "capsule.version must be a semver-like string (e.g. 1.0.0)"
 );
+function isSafePosixRelativePathPrefix(value) {
+  if (value.startsWith("/") || value.includes("\\")) return false;
+  const segments = value.split("/");
+  return segments.every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
 var CapsuleRetrievalPolicySchema = external_exports.object({
   /**
    * Per-tier weight overrides applied during recall when the capsule is the
@@ -66,8 +71,8 @@ var CapsuleParentSchema = external_exports.object({
    * capsule's records were placed. Typically `forks/<parent-capsule-id>`.
    * Must be a non-empty string with no leading slash.
    */
-  forkRoot: external_exports.string().min(1, "capsule.parent.forkRoot must not be empty").refine((v) => !v.startsWith("/"), {
-    message: "capsule.parent.forkRoot must be a relative path (no leading slash)"
+  forkRoot: external_exports.string().min(1, "capsule.parent.forkRoot must not be empty").refine(isSafePosixRelativePathPrefix, {
+    message: "capsule.parent.forkRoot must be a normalized posix-relative path with no traversal segments"
   })
 });
 var CapsuleBlockSchema = external_exports.object({

package/dist/{chunk-6OJAU466.js → chunk-QMUQV5NP.js}

@@ -141,7 +141,6 @@ function relPath(pagePath, memoryDir) {
 }
 
 export {
-  sidecarKey,
   createVersion,
   getVersion
 };

package/dist/{chunk-LLUROTZJ.js → chunk-QQXJODFL.js}

@@ -108,24 +108,24 @@ function parseCapsuleIncludeKinds(raw) {
   }
   return [...new Set(parts)];
 }
-function parseCapsulePeers(raw) {
+function parseCapsulePeers(raw, optionName = "--peers") {
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw !== "string") {
     throw new Error(
-      `--peers expects a comma-separated list of peer ids; got ${JSON.stringify(raw)}`
+      `${optionName} expects a comma-separated list of peer ids; got ${JSON.stringify(raw)}`
     );
   }
   if (raw.trim() === "") {
-    throw new Error(`--peers expects at least one non-empty peer id`);
+    throw new Error(`${optionName} expects at least one non-empty peer id`);
   }
   const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
   if (parts.length === 0) {
-    throw new Error(`--peers expects at least one non-empty peer id`);
+    throw new Error(`${optionName} expects at least one non-empty peer id`);
   }
   for (const p of parts) {
     if (p.includes("/") || p.includes("\\") || p === "." || p === "..") {
       throw new Error(
-        `--peers entries must be plain id tokens (no path separators): ${p}`
+        `${optionName} entries must be plain id tokens (no path separators): ${p}`
       );
     }
   }
@@ -134,15 +134,15 @@ function parseCapsulePeers(raw) {
 function parseCapsuleExportOptions(nameArg, opts) {
   if (typeof nameArg !== "string" || nameArg.trim() === "") {
     throw new Error(
-      `capsule export: <name> is required (e.g. "remnic capsule export my-capsule")`
+      `capsule export: --name is required (e.g. "remnic capsule export --name my-capsule")`
     );
   }
   const name = nameArg.trim();
-  const out = typeof opts.out === "string" && opts.out.trim() !== "" ? opts.out.trim() : void 0;
+  const outDir = typeof opts.outDir === "string" && opts.outDir.trim() !== "" ? opts.outDir.trim() : void 0;
   const since = parseCapsuleSince(opts.since);
   const includeKinds = parseCapsuleIncludeKinds(opts.includeKinds);
-  const peers = parseCapsulePeers(opts.peers);
-  return { name, out, since, includeKinds, peers };
+  const peerIds = parseCapsulePeers(opts.peerIds, "--peer-ids");
+  return { name, outDir, since, includeKinds, peerIds };
 }
 function parseCapsuleImportOptions(archiveArg, opts) {
   if (typeof archiveArg !== "string" || archiveArg.trim() === "") {

package/dist/{chunk-6F6EKSVP.js → chunk-QXXEF7VI.js}

@@ -10,7 +10,7 @@ import {
   unlock,
   verifyKey,
   writeHeader
-} from "./chunk-CXM7EBAO.js";
+} from "./chunk-MXFJXUHC.js";
 import {
   DEFAULT_ARGON2ID_PARAMS,
   DEFAULT_SCRYPT_PARAMS,