@remnic/plugin-openclaw 1.0.10 → 1.0.12

package/dist/{chunk-Z7GRLVK3.js → chunk-3GUF7RQI.js}

@@ -1,6 +1,84 @@
+// ../remnic-core/src/graph-edge-reinforcement.ts
+var CONFIDENCE_CEILING = 1;
+var DEFAULT_DECAY_WINDOW_MS = 90 * 24 * 60 * 60 * 1e3;
+var DEFAULT_DECAY_FLOOR = 0.1;
+var DEFAULT_DECAY_PER_WINDOW = 0.1;
+function readEdgeConfidence(edge) {
+  const raw = edge.confidence;
+  if (raw === void 0 || raw === null || !Number.isFinite(raw)) {
+    return CONFIDENCE_CEILING;
+  }
+  if (raw < 0) return 0;
+  if (raw > CONFIDENCE_CEILING) return CONFIDENCE_CEILING;
+  return raw;
+}
+function readLastReinforcedAt(edge) {
+  return edge.lastReinforcedAt ?? edge.ts;
+}
+function decayEdgeConfidence(edge, now, opts = {}) {
+  const windowMs = opts.windowMs ?? DEFAULT_DECAY_WINDOW_MS;
+  const perWindow = opts.perWindow ?? DEFAULT_DECAY_PER_WINDOW;
+  const floor = opts.floor ?? DEFAULT_DECAY_FLOOR;
+  if (!(windowMs > 0) || !Number.isFinite(perWindow) || perWindow < 0 || !Number.isFinite(floor)) {
+    return { ...edge, confidence: readEdgeConfidence(edge) };
+  }
+  const safeFloor = Math.min(CONFIDENCE_CEILING, Math.max(0, floor));
+  const nowMs = Date.parse(now);
+  const refMs = Date.parse(readLastReinforcedAt(edge));
+  if (!Number.isFinite(nowMs) || !Number.isFinite(refMs)) {
+    return { ...edge, confidence: readEdgeConfidence(edge) };
+  }
+  const age = nowMs - refMs;
+  const current = readEdgeConfidence(edge);
+  if (age <= windowMs) {
+    return { ...edge, confidence: current };
+  }
+  const windowsPast = Math.ceil((age - windowMs) / windowMs);
+  const decayed = current - perWindow * windowsPast;
+  const lowerBound = Math.min(safeFloor, current);
+  const next = Math.max(lowerBound, Math.min(current, decayed));
+  const newRefMs = refMs + windowsPast * windowMs;
+  const newRef = new Date(newRefMs).toISOString();
+  return { ...edge, confidence: next, lastReinforcedAt: newRef };
+}
+
 // ../remnic-core/src/graph.ts
 import { mkdir, appendFile, readFile } from "fs/promises";
 import * as path from "path";
+
+// ../remnic-core/src/graph-events.ts
+import { EventEmitter } from "events";
+var buses = /* @__PURE__ */ new Map();
+function getGraphEventBus(memoryDir) {
+  let bus = buses.get(memoryDir);
+  if (!bus) {
+    bus = new EventEmitter();
+    bus.setMaxListeners(200);
+    buses.set(memoryDir, bus);
+  }
+  return bus;
+}
+function emitGraphEvent(memoryDir, type, payload) {
+  const event = {
+    type,
+    memoryDir,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    payload
+  };
+  const bus = getGraphEventBus(memoryDir);
+  try {
+    bus.emit("graph-event", event);
+  } catch {
+  }
+}
+function subscribeGraphEvents(memoryDir, listener) {
+  const bus = getGraphEventBus(memoryDir);
+  bus.on("graph-event", listener);
+  return () => bus.off("graph-event", listener);
+}
+
+// ../remnic-core/src/graph.ts
+var DEFAULT_GRAPH_TRAVERSAL_CONFIDENCE_FLOOR = 0.2;
 var CAUSAL_PHRASES = [
   "as a result",
   "led to",
@@ -18,29 +96,71 @@ function graphFilePath(memoryDir, type) {
 async function ensureGraphsDir(memoryDir) {
   await mkdir(graphsDir(memoryDir), { recursive: true });
 }
+var graphWriteLocks = /* @__PURE__ */ new Map();
+function withGraphWriteLock(filePath, fn) {
+  const prev = graphWriteLocks.get(filePath) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  graphWriteLocks.set(
+    filePath,
+    next.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return next;
+}
 async function appendEdge(memoryDir, edge) {
   await ensureGraphsDir(memoryDir);
+  const filePath = graphFilePath(memoryDir, edge.type);
   const line = JSON.stringify(edge) + "\n";
-  await appendFile(graphFilePath(memoryDir, edge.type), line, "utf8");
+  await withGraphWriteLock(filePath, async () => {
+    await appendFile(filePath, line, "utf8");
+  });
+  emitGraphEvent(memoryDir, "edge-added", {
+    source: edge.from,
+    target: edge.to,
+    kind: edge.type,
+    weight: edge.weight,
+    label: edge.label,
+    confidence: typeof edge.confidence === "number" ? edge.confidence : 1
+  });
+}
+function isNodeError(err) {
+  return typeof err === "object" && err !== null && "code" in err;
+}
+function parseEdgesJsonl(raw) {
+  const edges = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      edges.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return edges;
 }
 async function readEdges(memoryDir, type) {
   const filePath = graphFilePath(memoryDir, type);
   try {
     const raw = await readFile(filePath, "utf8");
-    const edges = [];
-    for (const line of raw.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        edges.push(JSON.parse(trimmed));
-      } catch {
-      }
-    }
-    return edges;
+    return parseEdgesJsonl(raw);
   } catch {
     return [];
   }
 }
+async function readEdgesStrict(memoryDir, type) {
+  const filePath = graphFilePath(memoryDir, type);
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return parseEdgesJsonl(raw);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+}
 async function readAllEdges(memoryDir, config) {
   const parts = await Promise.all([
     config.entityGraphEnabled ? readEdges(memoryDir, "entity") : Promise.resolve([]),
@@ -238,21 +358,38 @@ var GraphIndex = class _GraphIndex {
    * Spreading activation BFS (SYNAPSE-inspired).
    *
    * Starting from `seeds`, traverse the combined graph for up to `maxSteps` hops.
-   * Each candidate gets an activation score = edge.weight × decay^hop.
-   * Returns top-N candidate paths sorted by descending activation score.
+   * Each candidate gets an activation score = edge.weight × edgeConfidence × decay^hop.
    *
-   * @param seeds   - initial memory paths to expand from (e.g. QMD top results)
+   * Issue #681 PR 3/3 — confidence-aware traversal:
+   *   - Each edge's `weight` is multiplied by its `confidence` (legacy edges
+   *     missing `confidence` are treated as 1.0, preserving prior behavior).
+   *   - Edges with `confidence < graphTraversalConfidenceFloor` are pruned and
+   *     contribute neither activation nor downstream neighbors.
+   *   - When `graphTraversalPageRankIterations > 0`, an additional PageRank-
+   *     style refinement pass redistributes activation along confidence-weighted
+   *     edges, sharpening the ranking among multi-hop candidates.
+   *   - Per-result provenance includes the highest-confidence edge that landed
+   *     on each candidate, so the X-ray surface can attribute pruning and
+   *     ranking decisions back to specific edges.
+   *
+   * @param seeds    - initial memory paths to expand from (e.g. QMD top results)
    * @param maxSteps - max BFS hops (from config: maxGraphTraversalSteps)
-   * @returns Array of {path, score} sorted descending, not including seed paths
+   * @returns Array of {path, score, edgeConfidence, ...} sorted descending, not including seed paths
    */
-  async spreadingActivation(seeds, maxSteps) {
+  async spreadingActivation(seeds, maxSteps, opts) {
     if (!this.cfg.multiGraphMemoryEnabled) return [];
     const steps = maxSteps ?? this.cfg.maxGraphTraversalSteps;
     const decay = this.cfg.graphActivationDecay;
+    const floor = opts?.includeLowConfidence === true ? 0 : clampConfidenceFloor(this.cfg.graphTraversalConfidenceFloor);
+    const iterations = clampPageRankIterations(
+      this.cfg.graphTraversalPageRankIterations
+    );
     try {
       const allEdges = await this.loadEdgesCached();
       const adj = /* @__PURE__ */ new Map();
       for (const edge of allEdges) {
+        const conf = readEdgeConfidence(edge);
+        if (conf < floor) continue;
         if (!adj.has(edge.from)) adj.set(edge.from, []);
         adj.get(edge.from).push(edge);
         if (edge.type !== "causal") {
@@ -271,7 +408,9 @@ var GraphIndex = class _GraphIndex {
         const edges = adj.get(node) ?? [];
         for (const edge of edges) {
           const neighbor = edge.to === node ? edge.from : edge.to;
-          const score = edge.weight * Math.pow(decay, hop + 1);
+          const conf = readEdgeConfidence(edge);
+          if (conf < floor) continue;
+          const score = edge.weight * conf * Math.pow(decay, hop + 1);
           if (!seedSet.has(neighbor)) {
             const existing = scores.get(neighbor) ?? 0;
             scores.set(neighbor, existing + score);
@@ -281,7 +420,8 @@ var GraphIndex = class _GraphIndex {
                 seed: sourceSeed,
                 hopDepth: hop + 1,
                 decayedWeight: score,
-                graphType: edge.type
+                graphType: edge.type,
+                edgeConfidence: conf
               });
             }
           }
@@ -291,6 +431,13 @@ var GraphIndex = class _GraphIndex {
           }
         }
       }
+      if (iterations > 0 && scores.size > 1) {
+        applyPageRankRefinement(scores, adj, {
+          iterations,
+          floor,
+          damping: 0.85
+        });
+      }
       if (this.cfg.graphLateralInhibitionEnabled && scores.size > 1) {
         const inhibited = applyLateralInhibition(scores, {
           beta: this.cfg.graphLateralInhibitionBeta,
@@ -306,7 +453,8 @@ var GraphIndex = class _GraphIndex {
         seed: provenance.get(p)?.seed ?? "",
         hopDepth: provenance.get(p)?.hopDepth ?? 0,
         decayedWeight: provenance.get(p)?.decayedWeight ?? 0,
-        graphType: provenance.get(p)?.graphType ?? "entity"
+        graphType: provenance.get(p)?.graphType ?? "entity",
+        edgeConfidence: provenance.get(p)?.edgeConfidence ?? 1
       })).sort((a, b) => b.score - a.score);
     } catch (err) {
       const { log } = await import("./logger-TNOKCH7X.js");
@@ -315,6 +463,63 @@ var GraphIndex = class _GraphIndex {
     }
   }
 };
+function clampConfidenceFloor(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    return DEFAULT_GRAPH_TRAVERSAL_CONFIDENCE_FLOOR;
+  }
+  if (raw < 0) return 0;
+  if (raw > 1) return 1;
+  return raw;
+}
+function clampPageRankIterations(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return 0;
+  if (raw <= 0) return 0;
+  return Math.floor(raw);
+}
+function applyPageRankRefinement(scores, adj, opts) {
+  const { iterations, floor, damping } = opts;
+  if (iterations <= 0 || scores.size === 0) return;
+  const safeDamping = Math.min(1, Math.max(0, damping));
+  const eligible = (edge, fromNode) => {
+    if (readEdgeConfidence(edge) < floor) return false;
+    const neighbor = edge.to === fromNode ? edge.from : edge.to;
+    return scores.has(neighbor);
+  };
+  const outboundTotal = /* @__PURE__ */ new Map();
+  for (const [node, edges] of adj.entries()) {
+    if (!scores.has(node)) continue;
+    let sum = 0;
+    for (const edge of edges) {
+      if (!eligible(edge, node)) continue;
+      sum += readEdgeConfidence(edge) * edge.weight;
+    }
+    if (sum > 0) outboundTotal.set(node, sum);
+  }
+  for (let i = 0; i < iterations; i += 1) {
+    const next = /* @__PURE__ */ new Map();
+    for (const [node, score] of scores) {
+      next.set(node, (1 - safeDamping) * score);
+    }
+    for (const [node, score] of scores) {
+      const outEdges = adj.get(node);
+      const total = outboundTotal.get(node);
+      if (!outEdges || outEdges.length === 0 || !total || total <= 0) {
+        next.set(node, (next.get(node) ?? 0) + safeDamping * score);
+        continue;
+      }
+      for (const edge of outEdges) {
+        if (!eligible(edge, node)) continue;
+        const conf = readEdgeConfidence(edge);
+        const neighbor = edge.to === node ? edge.from : edge.to;
+        const flow = safeDamping * score * (conf * edge.weight / total);
+        next.set(neighbor, (next.get(neighbor) ?? 0) + flow);
+      }
+    }
+    for (const [node, score] of next) {
+      scores.set(node, score);
+    }
+  }
+}
 function applyLateralInhibition(scores, opts) {
   const { beta, topM } = opts;
   if (beta === 0 || topM === 0) return new Map(scores);
@@ -334,7 +539,18 @@ function applyLateralInhibition(scores, opts) {
 }
 
 export {
+  DEFAULT_DECAY_WINDOW_MS,
+  DEFAULT_DECAY_FLOOR,
+  DEFAULT_DECAY_PER_WINDOW,
+  readEdgeConfidence,
+  decayEdgeConfidence,
+  subscribeGraphEvents,
+  graphsDir,
+  graphFilePath,
+  withGraphWriteLock,
   appendEdge,
+  readEdgesStrict,
+  readAllEdges,
   analyzeGraphHealth,
   GraphIndex
 };

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
+};