@remnic/plugin-openclaw 1.0.10 → 1.0.11

package/dist/chunk-4G2XCSD2.js

@@ -0,0 +1,186 @@
+// ../remnic-core/src/lifecycle.ts
+var DEFAULT_POLICY = {
+  promoteHeatThreshold: 0.55,
+  staleDecayThreshold: 0.65,
+  archiveDecayThreshold: 0.85,
+  protectedCategories: ["decision", "principle", "commitment", "preference", "procedure"]
+};
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function clampLifecycleThreshold(value) {
+  return clamp01(value);
+}
+function parseIsoMs(value) {
+  if (!value) return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+function daysSince(value, nowMs) {
+  const ts = parseIsoMs(value);
+  if (ts === null) return 365;
+  return Math.max(0, (nowMs - ts) / 864e5);
+}
+function confidenceTierWeight(frontmatter) {
+  switch (frontmatter.confidenceTier) {
+    case "explicit":
+      return 1;
+    case "implied":
+      return 0.8;
+    case "inferred":
+      return 0.6;
+    case "speculative":
+      return 0.35;
+    default:
+      return clamp01(frontmatter.confidence ?? 0.5);
+  }
+}
+function accessWeight(accessCount) {
+  const raw = accessCount ?? 0;
+  if (raw <= 0) return 0;
+  return clamp01(Math.log1p(raw) / Math.log1p(20));
+}
+function recencyWeight(frontmatter, nowMs) {
+  const lastTouch = frontmatter.lastAccessed ?? frontmatter.updated ?? frontmatter.created;
+  const ageDays = daysSince(lastTouch, nowMs);
+  return clamp01(1 - ageDays / 90);
+}
+function feedbackWeight(signals) {
+  const raw = (signals?.feedbackScore ?? 0) + (signals?.actionPriorScore ?? 0);
+  return clamp01((raw + 1) / 2);
+}
+function boundedFeedbackScore(signals) {
+  const raw = (signals?.feedbackScore ?? 0) + (signals?.actionPriorScore ?? 0);
+  if (!Number.isFinite(raw)) return 0;
+  if (raw < -1) return -1;
+  if (raw > 1) return 1;
+  return raw;
+}
+function isProtectedMemory(frontmatter, policy) {
+  return frontmatter.policyClass === "protected" || policy.protectedCategories.includes(frontmatter.category);
+}
+function resolveLifecycleState(frontmatter) {
+  if (frontmatter.status === "archived") return "archived";
+  return frontmatter.lifecycleState ?? "candidate";
+}
+function computeHeat(memory, now, signals) {
+  const frontmatter = memory.frontmatter;
+  if (frontmatter.status === "archived") return 0;
+  const inputs = computeLifecycleValueInputs(memory, now, signals);
+  const causalBoost = clamp01(signals?.causalImpactScore ?? 0) * 0.05;
+  const score = inputs.confidence * 0.25 + inputs.access * 0.3 + inputs.recency * 0.2 + inputs.importance * 0.15 + inputs.feedback * 0.1 + causalBoost - inputs.disputedPenalty;
+  return clamp01(score);
+}
+function computeLifecycleValueInputs(memory, now, signals) {
+  const frontmatter = memory.frontmatter;
+  const nowMs = now.getTime();
+  return {
+    confidence: confidenceTierWeight(frontmatter),
+    access: accessWeight(frontmatter.accessCount),
+    recency: recencyWeight(frontmatter, nowMs),
+    importance: clamp01(frontmatter.importance?.score ?? 0.5),
+    feedback: feedbackWeight(signals),
+    disputedPenalty: frontmatter.verificationState === "disputed" ? 0.2 : 0
+  };
+}
+function computeDecay(memory, now, signals) {
+  const frontmatter = memory.frontmatter;
+  if (frontmatter.status === "archived") return 1;
+  const nowMs = now.getTime();
+  const ageDays = daysSince(frontmatter.updated ?? frontmatter.created, nowMs);
+  const staleAccessDays = daysSince(frontmatter.lastAccessed, nowMs);
+  const ageRisk = clamp01(ageDays / 180);
+  const staleAccessRisk = clamp01(staleAccessDays / 120);
+  const confidenceRisk = 1 - confidenceTierWeight(frontmatter);
+  const feedbackRisk = clamp01((boundedFeedbackScore(signals) * -1 + 1) / 2);
+  const heat = computeHeat(memory, now, signals);
+  const score = ageRisk * 0.3 + staleAccessRisk * 0.25 + confidenceRisk * 0.2 + feedbackRisk * 0.1 + (1 - heat) * 0.15;
+  return clamp01(score);
+}
+function toTerminalDisputedState(currentState) {
+  if (currentState === "archived") return "archived";
+  return "stale";
+}
+function isActiveEligible(verificationState) {
+  return verificationState === "user_confirmed" || verificationState === "system_inferred";
+}
+function decideLifecycleTransition(memory, policy, now, signals) {
+  const mergedPolicy = { ...DEFAULT_POLICY, ...policy };
+  const frontmatter = memory.frontmatter;
+  const currentState = resolveLifecycleState(frontmatter);
+  const heatScore = computeHeat(memory, now, signals);
+  const decayScore = computeDecay(memory, now, signals);
+  const protectedMemory = isProtectedMemory(frontmatter, mergedPolicy);
+  if (currentState === "archived") {
+    return {
+      currentState,
+      nextState: "archived",
+      heatScore,
+      decayScore,
+      changed: false,
+      reason: "archived_is_terminal"
+    };
+  }
+  if (frontmatter.verificationState === "disputed") {
+    const nextState = toTerminalDisputedState(currentState);
+    return {
+      currentState,
+      nextState,
+      heatScore,
+      decayScore,
+      changed: nextState !== currentState,
+      reason: "disputed_memories_do_not_promote_to_active"
+    };
+  }
+  if (decayScore >= mergedPolicy.archiveDecayThreshold && !protectedMemory) {
+    return {
+      currentState,
+      nextState: "archived",
+      heatScore,
+      decayScore,
+      changed: true,
+      reason: "decay_exceeded_archive_threshold"
+    };
+  }
+  if (decayScore >= mergedPolicy.staleDecayThreshold) {
+    return {
+      currentState,
+      nextState: "stale",
+      heatScore,
+      decayScore,
+      changed: currentState !== "stale",
+      reason: "decay_exceeded_stale_threshold"
+    };
+  }
+  if (heatScore >= mergedPolicy.promoteHeatThreshold) {
+    const nextState = isActiveEligible(frontmatter.verificationState) ? "active" : "validated";
+    return {
+      currentState,
+      nextState,
+      heatScore,
+      decayScore,
+      changed: currentState !== nextState,
+      reason: "heat_exceeded_promote_threshold"
+    };
+  }
+  return {
+    currentState,
+    nextState: currentState,
+    heatScore,
+    decayScore,
+    changed: false,
+    reason: "no_transition"
+  };
+}
+
+export {
+  clamp01,
+  clampLifecycleThreshold,
+  daysSince,
+  resolveLifecycleState,
+  computeLifecycleValueInputs,
+  decideLifecycleTransition
+};

package/dist/chunk-6IWEAUN6.js

@@ -0,0 +1,148 @@
+// ../remnic-core/src/secure-store/kdf.ts
+import { scryptSync, timingSafeEqual } from "crypto";
+import { createRequire } from "module";
+var requireArgon2 = createRequire(import.meta.url);
+var argon2Runtime;
+function loadArgon2Runtime() {
+  try {
+    argon2Runtime ??= requireArgon2("@node-rs/argon2");
+    return argon2Runtime;
+  } catch (cause) {
+    throw new Error(
+      "Argon2id KDF requires @node-rs/argon2 to be installed and loadable on this platform. Use scrypt compatibility mode for stores that must run without the Argon2 native binding.",
+      { cause }
+    );
+  }
+}
+var DEFAULT_SCRYPT_PARAMS = Object.freeze({
+  // 2^17. Hex-coding the literal would obscure the doubling chain.
+  N: 1 << 17,
+  r: 8,
+  p: 1,
+  keyLength: 32,
+  // 256 MiB ceiling — comfortably above the 128 MiB scrypt needs at N=2^17.
+  maxmem: 256 * 1024 * 1024
+});
+var DEFAULT_ARGON2ID_PARAMS = Object.freeze({
+  memoryKiB: 64 * 1024,
+  iterations: 3,
+  parallelism: 4,
+  keyLength: 32
+});
+var KDF_SALT_LENGTH = 16;
+var KDF_KEY_LENGTH = 32;
+function validateScryptParams(params) {
+  const { N, r, p, keyLength, maxmem } = params;
+  if (!Number.isInteger(N) || N < 2) {
+    throw new Error(`scrypt N must be an integer \u2265 2, got ${N}`);
+  }
+  if (N > 2 ** 30) {
+    throw new Error(`scrypt N is unreasonably large (max 2^30), got ${N}`);
+  }
+  if (!Number.isInteger(Math.log2(N))) {
+    throw new Error(`scrypt N must be a power of 2, got ${N}`);
+  }
+  if (!Number.isInteger(r) || r < 1) {
+    throw new Error(`scrypt r must be a positive integer, got ${r}`);
+  }
+  if (!Number.isInteger(p) || p < 1) {
+    throw new Error(`scrypt p must be a positive integer, got ${p}`);
+  }
+  if (!Number.isInteger(keyLength) || keyLength < 16) {
+    throw new Error(
+      `scrypt keyLength must be \u2265 16 (need 32 for AES-256), got ${keyLength}`
+    );
+  }
+  if (!Number.isInteger(maxmem) || maxmem < 1024) {
+    throw new Error(`scrypt maxmem must be a sane positive integer, got ${maxmem}`);
+  }
+}
+function validateArgon2idParams(params) {
+  const { memoryKiB, iterations, parallelism, keyLength } = params;
+  if (!Number.isInteger(memoryKiB) || memoryKiB < 8) {
+    throw new Error(`argon2id memoryKiB must be an integer \u2265 8, got ${memoryKiB}`);
+  }
+  if (!Number.isInteger(iterations) || iterations < 1) {
+    throw new Error(`argon2id iterations must be a positive integer, got ${iterations}`);
+  }
+  if (!Number.isInteger(parallelism) || parallelism < 1 || parallelism > 255) {
+    throw new Error(`argon2id parallelism must be an integer in [1, 255], got ${parallelism}`);
+  }
+  if (!Number.isInteger(keyLength) || keyLength !== KDF_KEY_LENGTH) {
+    throw new Error(
+      `argon2id keyLength must be ${KDF_KEY_LENGTH} (AES-256 requires a 32-byte key), got ${keyLength}`
+    );
+  }
+}
+function deriveKeyScrypt(passphrase, salt, params = DEFAULT_SCRYPT_PARAMS) {
+  if (typeof passphrase !== "string") {
+    throw new Error("passphrase must be a string");
+  }
+  if (passphrase.length === 0) {
+    throw new Error("passphrase must not be empty");
+  }
+  if (!(salt instanceof Uint8Array) || salt.length < 8) {
+    throw new Error(
+      `salt must be a Uint8Array of at least 8 bytes, got ${salt?.length ?? "non-buffer"}`
+    );
+  }
+  validateScryptParams(params);
+  return scryptSync(passphrase, Buffer.from(salt), params.keyLength, {
+    N: params.N,
+    r: params.r,
+    p: params.p,
+    maxmem: params.maxmem
+  });
+}
+function deriveKeyArgon2id(passphrase, salt, params = DEFAULT_ARGON2ID_PARAMS) {
+  if (typeof passphrase !== "string") {
+    throw new Error("passphrase must be a string");
+  }
+  if (passphrase.length === 0) {
+    throw new Error("passphrase must not be empty");
+  }
+  if (!(salt instanceof Uint8Array) || salt.length < 8) {
+    throw new Error(
+      `salt must be a Uint8Array of at least 8 bytes, got ${salt?.length ?? "non-buffer"}`
+    );
+  }
+  validateArgon2idParams(params);
+  const { Algorithm, Version, hashRawSync } = loadArgon2Runtime();
+  return hashRawSync(passphrase, {
+    algorithm: Algorithm.Argon2id,
+    version: Version.V0x13,
+    memoryCost: params.memoryKiB,
+    timeCost: params.iterations,
+    parallelism: params.parallelism,
+    outputLen: params.keyLength,
+    salt
+  });
+}
+function deriveKey(algorithm, passphrase, salt, params) {
+  if (algorithm === "scrypt") {
+    return deriveKeyScrypt(passphrase, salt, params);
+  }
+  if (algorithm === "argon2id") {
+    return deriveKeyArgon2id(passphrase, salt, params);
+  }
+  throw new Error(`unknown KDF algorithm: ${algorithm}`);
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+
+export {
+  DEFAULT_SCRYPT_PARAMS,
+  DEFAULT_ARGON2ID_PARAMS,
+  KDF_SALT_LENGTH,
+  KDF_KEY_LENGTH,
+  validateScryptParams,
+  validateArgon2idParams,
+  deriveKeyScrypt,
+  deriveKeyArgon2id,
+  deriveKey,
+  constantTimeEqual
+};

package/dist/{chunk-LN5UZQVG.js → chunk-6UFI73TJ.js}

@@ -1,14 +1,16 @@
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-WPINX4MF.js";
 import {
   assertIsoRecordedAt,
   assertSafePathSegment,
   assertString,
-  countRecallTokenOverlap,
   isRecord,
-  normalizeRecallTokens,
   optionalString,
   optionalStringArray,
   validateStringRecord
-} from "./chunk-YHH3SXKD.js";
+} from "./chunk-3G7FAF6S.js";
 import {
   listJsonFiles,
   readJsonFile