open-agents-ai 0.187.439 → 0.187.440

package/dist/index.js

@@ -512278,6 +512278,317 @@ var init_toolPatternStore = __esm({
   }
 });
 
+// packages/memory/dist/zettelkasten.js
+function cosineSimilarity2(a2, b) {
+  if (a2.length !== b.length || a2.length === 0)
+    return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i2 = 0; i2 < a2.length; i2++) {
+    dot += a2[i2] * b[i2];
+    normA += a2[i2] * a2[i2];
+    normB += b[i2] * b[i2];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom > 0 ? dot / denom : 0;
+}
+function findNeighbors(episode, candidates, topK, minSimilarity) {
+  if (!episode.embedding)
+    return [];
+  const scored = [];
+  for (const candidate of candidates) {
+    if (candidate.id === episode.id)
+      continue;
+    if (!candidate.embedding)
+      continue;
+    let sim;
+    if (episode.embedding.length === candidate.embedding.length) {
+      sim = cosineSimilarity2(episode.embedding, candidate.embedding);
+    } else if (episode.clipEmbedding && candidate.clipEmbedding && episode.clipEmbedding.length === candidate.clipEmbedding.length) {
+      sim = cosineSimilarity2(episode.clipEmbedding, candidate.clipEmbedding);
+    } else {
+      continue;
+    }
+    if (sim >= minSimilarity) {
+      scored.push({ episode: candidate, similarity: sim });
+    }
+  }
+  scored.sort((a2, b) => b.similarity - a2.similarity);
+  return scored.slice(0, topK);
+}
+function linkEpisode(episode, episodeStore, graph, config) {
+  const cfg = { ...DEFAULT_CONFIG3, ...config };
+  const result = { episodeId: episode.id, linkedTo: [], linksCreated: 0 };
+  if (!episode.embedding)
+    return result;
+  const candidates = episodeStore.recent(500).filter((e2) => e2.embedding != null);
+  const neighbors2 = findNeighbors(episode, candidates, cfg.topK, cfg.minSimilarity);
+  for (const { episode: neighbor, similarity } of neighbors2) {
+    if (result.linksCreated >= cfg.maxLinksPerEpisode)
+      break;
+    const srcNodeId = graph.upsertNode({
+      text: episode.content.slice(0, 100),
+      nodeType: "event"
+    });
+    const dstNodeId = graph.upsertNode({
+      text: neighbor.content.slice(0, 100),
+      nodeType: "event"
+    });
+    graph.addEdge({
+      srcId: srcNodeId,
+      dstId: dstNodeId,
+      relation: "related_to",
+      fact: `Associated: ${episode.content.slice(0, 50)} ↔ ${neighbor.content.slice(0, 50)}`,
+      edgeType: "synonym",
+      confidence: similarity,
+      sourceEpisodeId: episode.id
+    });
+    result.linkedTo.push({ neighborId: neighbor.id, similarity, linked: true });
+    result.linksCreated++;
+    if (similarity >= cfg.evolutionThreshold && neighbor.gist !== episode.content.slice(0, 200)) {
+      const evolvedGist = neighbor.gist ? `${neighbor.gist} | Also related: ${episode.content.slice(0, 100)}` : `Related context: ${episode.content.slice(0, 150)}`;
+      episodeStore.setGist(neighbor.id, evolvedGist.slice(0, 500));
+    }
+  }
+  return result;
+}
+function batchLink(episodeStore, graph, config) {
+  const episodes = episodeStore.recent(200).filter((e2) => e2.embedding != null);
+  let totalLinks = 0;
+  let processed = 0;
+  for (const ep of episodes) {
+    const result = linkEpisode(ep, episodeStore, graph, config);
+    totalLinks += result.linksCreated;
+    if (result.linksCreated > 0)
+      processed++;
+  }
+  return { processed, linksCreated: totalLinks };
+}
+var DEFAULT_CONFIG3;
+var init_zettelkasten = __esm({
+  "packages/memory/dist/zettelkasten.js"() {
+    "use strict";
+    DEFAULT_CONFIG3 = {
+      topK: 3,
+      minSimilarity: 0.3,
+      evolutionThreshold: 0.6,
+      maxLinksPerEpisode: 10
+    };
+  }
+});
+
+// packages/memory/dist/pprRetrieval.js
+function extractQueryEntities(query) {
+  const entities = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add2 = (text) => {
+    const normalized = text.trim().toLowerCase();
+    if (normalized.length < 2 || seen.has(normalized))
+      return;
+    seen.add(normalized);
+    entities.push(text.trim());
+  };
+  const filePattern = /(?:[\w./-]+\/[\w./-]+|[\w-]+\.\w{1,5})\b/g;
+  for (const match of query.matchAll(filePattern)) {
+    if (match[0].includes(".") || match[0].includes("/"))
+      add2(match[0]);
+  }
+  const errorPattern = /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b|\b\w+(?:Error|Exception|Failed|Failure)\b/g;
+  for (const match of query.matchAll(errorPattern))
+    add2(match[0]);
+  const camelPattern = /\b[a-z][a-z0-9]*(?:[A-Z][a-zA-Z0-9]+)+\b/g;
+  for (const match of query.matchAll(camelPattern))
+    add2(match[0]);
+  const toolPattern = /\b(?:file_read|file_write|file_edit|shell|grep_search|find_files|memory_\w+|web_\w+|camera_\w+|audio_\w+|wifi_\w+|bluetooth_\w+|sdr_\w+|flipper_\w+|meshtastic|gps_\w+|visual_\w+)\b/g;
+  for (const match of query.matchAll(toolPattern))
+    add2(match[0]);
+  const quotedPattern = /["']([^"']{2,50})["']/g;
+  for (const match of query.matchAll(quotedPattern))
+    add2(match[1]);
+  const STOP_WORDS2 = /* @__PURE__ */ new Set([
+    "the",
+    "and",
+    "for",
+    "was",
+    "are",
+    "not",
+    "but",
+    "had",
+    "has",
+    "have",
+    "this",
+    "that",
+    "with",
+    "from",
+    "what",
+    "when",
+    "where",
+    "how",
+    "why",
+    "which",
+    "who",
+    "did",
+    "does",
+    "can",
+    "could",
+    "would",
+    "should",
+    "will",
+    "been",
+    "being",
+    "were",
+    "about",
+    "than",
+    "then",
+    "also",
+    "just",
+    "more",
+    "some",
+    "only",
+    "into",
+    "over"
+  ]);
+  const words = query.split(/\s+/).filter((w) => w.length >= 4 && !STOP_WORDS2.has(w.toLowerCase()));
+  for (const word2 of words) {
+    if (/^[A-Z]/.test(word2) || /[._-]/.test(word2) || /\d/.test(word2)) {
+      add2(word2.replace(/[.,;:!?]+$/, ""));
+    }
+  }
+  return entities;
+}
+function personalizedPageRank(graph, seedNodeIds, config) {
+  const cfg = { ...DEFAULT_CONFIG4, ...config };
+  const scores = /* @__PURE__ */ new Map();
+  if (seedNodeIds.length === 0)
+    return scores;
+  const nodeCount = graph.nodeCount();
+  if (nodeCount === 0)
+    return scores;
+  const teleportProb = 1 / seedNodeIds.length;
+  const seedSet = new Set(seedNodeIds);
+  const allNodes = /* @__PURE__ */ new Set();
+  for (const seedId of seedNodeIds) {
+    allNodes.add(seedId);
+    const neighbors2 = graph.neighbors(seedId);
+    for (const { node } of neighbors2) {
+      allNodes.add(node.id);
+      const hop2 = graph.neighbors(node.id);
+      for (const { node: n2 } of hop2)
+        allNodes.add(n2.id);
+    }
+  }
+  for (const nodeId of allNodes) {
+    scores.set(nodeId, seedSet.has(nodeId) ? teleportProb : 0);
+  }
+  for (let iter = 0; iter < cfg.maxIterations; iter++) {
+    const newScores = /* @__PURE__ */ new Map();
+    let maxDelta = 0;
+    for (const nodeId of allNodes) {
+      const teleport = seedSet.has(nodeId) ? (1 - cfg.damping) * teleportProb : 0;
+      let walkSum = 0;
+      const inEdges = graph.currentEdges(nodeId);
+      for (const edge of inEdges) {
+        const neighborId = edge.srcId === nodeId ? edge.dstId : edge.srcId;
+        const neighborScore = scores.get(neighborId) ?? 0;
+        const neighborOutDegree = graph.currentEdges(neighborId).length || 1;
+        walkSum += neighborScore / neighborOutDegree;
+      }
+      const newScore = teleport + cfg.damping * walkSum;
+      newScores.set(nodeId, newScore);
+      const delta = Math.abs(newScore - (scores.get(nodeId) ?? 0));
+      if (delta > maxDelta)
+        maxDelta = delta;
+    }
+    for (const [id, score] of newScores)
+      scores.set(id, score);
+    if (maxDelta < cfg.convergenceThreshold) {
+      return scores;
+    }
+  }
+  return scores;
+}
+function retrieveByPPR(query, graph, episodeStore, config) {
+  const cfg = { ...DEFAULT_CONFIG4, ...config };
+  const queryEntities = extractQueryEntities(query);
+  if (queryEntities.length === 0) {
+    return { episodes: [], queryEntities: [], seedNodes: [], iterations: 0 };
+  }
+  const seedNodes = [];
+  for (const entity of queryEntities) {
+    const seedsBefore = seedNodes.length;
+    const node = graph.findNode(entity);
+    if (node) {
+      seedNodes.push(node.id);
+    }
+    const symbolNodes = graph.findSymbolNodesByName(entity, 10);
+    for (const s2 of symbolNodes)
+      seedNodes.push(s2.id);
+    if (seedNodes.length > seedsBefore)
+      continue;
+    for (const nodeType of ["file", "error", "tool", "entity", "event", "concept", "person"]) {
+      const candidates = graph.nodesByType(nodeType, 50);
+      for (const candidate of candidates) {
+        if (candidate.text.toLowerCase().includes(entity.toLowerCase()) || entity.toLowerCase().includes(candidate.text.toLowerCase())) {
+          seedNodes.push(candidate.id);
+          break;
+        }
+      }
+      if (seedNodes.length > seedsBefore)
+        break;
+    }
+  }
+  if (seedNodes.length === 0) {
+    return { episodes: [], queryEntities, seedNodes: [], iterations: 0 };
+  }
+  const pprScores = personalizedPageRank(graph, seedNodes, cfg);
+  const episodeScores = /* @__PURE__ */ new Map();
+  for (const [nodeId, score] of pprScores) {
+    if (score < 1e-3)
+      continue;
+    const node = graph.getNode(nodeId);
+    if (!node)
+      continue;
+    const edges = graph.currentEdges(nodeId);
+    for (const edge of edges) {
+      if (edge.sourceEpisodeId) {
+        const existing = episodeScores.get(edge.sourceEpisodeId);
+        if (existing) {
+          existing.score += score;
+          existing.matchedNodes.push(node.text);
+        } else {
+          episodeScores.set(edge.sourceEpisodeId, { score, matchedNodes: [node.text] });
+        }
+      }
+    }
+  }
+  const ranked = [...episodeScores.entries()].sort((a2, b) => b[1].score - a2[1].score).slice(0, cfg.topK);
+  const episodes = [];
+  for (const [epId, { score, matchedNodes }] of ranked) {
+    const episode = episodeStore.get(epId);
+    if (episode) {
+      episodes.push({ episode, pprScore: score, matchedNodes: [...new Set(matchedNodes)] });
+    }
+  }
+  return {
+    episodes,
+    queryEntities,
+    seedNodes,
+    iterations: cfg.maxIterations
+  };
+}
+var DEFAULT_CONFIG4;
+var init_pprRetrieval = __esm({
+  "packages/memory/dist/pprRetrieval.js"() {
+    "use strict";
+    init_zettelkasten();
+    DEFAULT_CONFIG4 = {
+      damping: 0.5,
+      maxIterations: 50,
+      convergenceThreshold: 1e-6,
+      topK: 10
+    };
+  }
+});
+
 // packages/memory/dist/episodeStore.js
 import { join as join66 } from "node:path";
 import { mkdirSync as mkdirSync26, existsSync as existsSync49 } from "node:fs";
@@ -512349,6 +512660,8 @@ var init_episodeStore = __esm({
   "packages/memory/dist/episodeStore.js"() {
     "use strict";
     init_db();
+    init_zettelkasten();
+    init_pprRetrieval();
     DECAY_TAU = {
       session: 36e5,
       // 1 hour
@@ -512360,11 +512673,19 @@ var init_episodeStore = __esm({
     };
     EpisodeStore = class {
       db;
-      constructor(dbPath) {
+      /** WO-AM-05: Optional TemporalGraph for Zettelkasten auto-linking */
+      graph = null;
+      /** WO-AM-05: Zettelkasten config for neighbor linking */
+      zettelConfig = { topK: 5, minSimilarity: 0.7, evolutionThreshold: 0.6, maxLinksPerEpisode: 10 };
+      constructor(dbPath, graph, zettelConfig) {
         const dir = dbPath === ":memory:" ? null : join66(dbPath, "..");
         if (dir && !existsSync49(dir))
           mkdirSync26(dir, { recursive: true });
         this.db = initDb(dbPath);
+        this.graph = graph ?? null;
+        if (zettelConfig) {
+          this.zettelConfig = { ...this.zettelConfig, ...zettelConfig };
+        }
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS episodes (
         id TEXT PRIMARY KEY,
@@ -512414,6 +512735,15 @@ var init_episodeStore = __esm({
       INSERT INTO episodes (id, timestamp, session_id, task_id, turn_number, modality, tool_name, content, content_hash, metadata, importance, decay_class, strength)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1.0)
     `).run(id, now, ep.sessionId ?? null, ep.taskId ?? null, ep.turnNumber ?? null, modality, ep.toolName ?? null, ep.content, contentHash, ep.metadata ? JSON.stringify(ep.metadata) : null, importance, decayClass);
+        if (this.graph) {
+          try {
+            const episode = this.get(id);
+            if (episode) {
+              linkEpisode(episode, this, this.graph, this.zettelConfig);
+            }
+          } catch {
+          }
+        }
         return id;
       }
       /** Retrieve episodes matching a query, scored by recency + importance + (lexical + embedding). */
@@ -512527,6 +512857,34 @@ var init_episodeStore = __esm({
         }
         return topK.map((s2) => s2.episode);
       }
+      /** WO-AM-05: PPR-enhanced search for multi-hop retrieval (HippoRAG).
+       *  Falls back to standard search if graph is unavailable or no entities found.
+       */
+      searchWithPPR(query, opts = {}) {
+        const standardResults = this.search(query, opts);
+        if (!this.graph || !query.query) {
+          return standardResults;
+        }
+        try {
+          const pprResult = retrieveByPPR(query.query, this.graph, this, {
+            damping: 0.5,
+            maxIterations: 50,
+            convergenceThreshold: 1e-6,
+            topK: query.limit ?? 20
+          });
+          const merged = [...standardResults];
+          const seenIds = new Set(merged.map((e2) => e2.id));
+          for (const { episode } of pprResult.episodes) {
+            if (!seenIds.has(episode.id)) {
+              merged.push(episode);
+              seenIds.add(episode.id);
+            }
+          }
+          return merged.slice(0, query.limit ?? 20);
+        } catch {
+          return standardResults;
+        }
+      }
       /** Get a single episode by ID. */
       get(id) {
         const row = this.db.prepare("SELECT * FROM episodes WHERE id = ?").get(id);
@@ -512782,147 +513140,49 @@ var init_temporalGraph = __esm({
           edge: this.rowToEdge(r2)
         }));
       }
-      // ─── Statistics ──────────────────────────────────────────────────────────
-      nodeCount() {
-        return this.db.prepare("SELECT COUNT(*) as n FROM kg_nodes").get().n;
-      }
-      edgeCount() {
-        return this.db.prepare("SELECT COUNT(*) as n FROM kg_edges").get().n;
-      }
-      activeEdgeCount() {
-        return this.db.prepare("SELECT COUNT(*) as n FROM kg_edges WHERE valid_until IS NULL").get().n;
-      }
-      close() {
-        try {
-          this.db.close();
-        } catch {
-        }
-      }
-      // ─── Internal ────────────────────────────────────────────────────────────
-      rowToNode(row) {
-        return {
-          id: row.id,
-          text: row.text,
-          nodeType: row.node_type,
-          embedding: row.embedding ? new Float32Array(new Uint8Array(row.embedding).buffer) : null,
-          firstSeen: row.first_seen,
-          lastSeen: row.last_seen,
-          mentionCount: row.mention_count
-        };
-      }
-      rowToEdge(row) {
-        return {
-          id: row.id,
-          srcId: row.src_id,
-          dstId: row.dst_id,
-          relation: row.relation,
-          fact: row.fact,
-          edgeType: row.edge_type,
-          validFrom: row.valid_from,
-          validUntil: row.valid_until,
-          confidence: row.confidence,
-          sourceEpisodeId: row.source_episode_id,
-          modality: row.modality
-        };
-      }
-    };
-  }
-});
-
-// packages/memory/dist/zettelkasten.js
-function cosineSimilarity2(a2, b) {
-  if (a2.length !== b.length || a2.length === 0)
-    return 0;
-  let dot = 0, normA = 0, normB = 0;
-  for (let i2 = 0; i2 < a2.length; i2++) {
-    dot += a2[i2] * b[i2];
-    normA += a2[i2] * a2[i2];
-    normB += b[i2] * b[i2];
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom > 0 ? dot / denom : 0;
-}
-function findNeighbors(episode, candidates, topK, minSimilarity) {
-  if (!episode.embedding)
-    return [];
-  const scored = [];
-  for (const candidate of candidates) {
-    if (candidate.id === episode.id)
-      continue;
-    if (!candidate.embedding)
-      continue;
-    let sim;
-    if (episode.embedding.length === candidate.embedding.length) {
-      sim = cosineSimilarity2(episode.embedding, candidate.embedding);
-    } else if (episode.clipEmbedding && candidate.clipEmbedding && episode.clipEmbedding.length === candidate.clipEmbedding.length) {
-      sim = cosineSimilarity2(episode.clipEmbedding, candidate.clipEmbedding);
-    } else {
-      continue;
-    }
-    if (sim >= minSimilarity) {
-      scored.push({ episode: candidate, similarity: sim });
-    }
-  }
-  scored.sort((a2, b) => b.similarity - a2.similarity);
-  return scored.slice(0, topK);
-}
-function linkEpisode(episode, episodeStore, graph, config) {
-  const cfg = { ...DEFAULT_CONFIG3, ...config };
-  const result = { episodeId: episode.id, linkedTo: [], linksCreated: 0 };
-  if (!episode.embedding)
-    return result;
-  const candidates = episodeStore.recent(500).filter((e2) => e2.embedding != null);
-  const neighbors2 = findNeighbors(episode, candidates, cfg.topK, cfg.minSimilarity);
-  for (const { episode: neighbor, similarity } of neighbors2) {
-    if (result.linksCreated >= cfg.maxLinksPerEpisode)
-      break;
-    const srcNodeId = graph.upsertNode({
-      text: episode.content.slice(0, 100),
-      nodeType: "event"
-    });
-    const dstNodeId = graph.upsertNode({
-      text: neighbor.content.slice(0, 100),
-      nodeType: "event"
-    });
-    graph.addEdge({
-      srcId: srcNodeId,
-      dstId: dstNodeId,
-      relation: "related_to",
-      fact: `Associated: ${episode.content.slice(0, 50)} ↔ ${neighbor.content.slice(0, 50)}`,
-      edgeType: "synonym",
-      confidence: similarity,
-      sourceEpisodeId: episode.id
-    });
-    result.linkedTo.push({ neighborId: neighbor.id, similarity, linked: true });
-    result.linksCreated++;
-    if (similarity >= cfg.evolutionThreshold && neighbor.gist !== episode.content.slice(0, 200)) {
-      const evolvedGist = neighbor.gist ? `${neighbor.gist} | Also related: ${episode.content.slice(0, 100)}` : `Related context: ${episode.content.slice(0, 150)}`;
-      episodeStore.setGist(neighbor.id, evolvedGist.slice(0, 500));
-    }
-  }
-  return result;
-}
-function batchLink(episodeStore, graph, config) {
-  const episodes = episodeStore.recent(200).filter((e2) => e2.embedding != null);
-  let totalLinks = 0;
-  let processed = 0;
-  for (const ep of episodes) {
-    const result = linkEpisode(ep, episodeStore, graph, config);
-    totalLinks += result.linksCreated;
-    if (result.linksCreated > 0)
-      processed++;
-  }
-  return { processed, linksCreated: totalLinks };
-}
-var DEFAULT_CONFIG3;
-var init_zettelkasten = __esm({
-  "packages/memory/dist/zettelkasten.js"() {
-    "use strict";
-    DEFAULT_CONFIG3 = {
-      topK: 3,
-      minSimilarity: 0.3,
-      evolutionThreshold: 0.6,
-      maxLinksPerEpisode: 10
+      // ─── Statistics ──────────────────────────────────────────────────────────
+      nodeCount() {
+        return this.db.prepare("SELECT COUNT(*) as n FROM kg_nodes").get().n;
+      }
+      edgeCount() {
+        return this.db.prepare("SELECT COUNT(*) as n FROM kg_edges").get().n;
+      }
+      activeEdgeCount() {
+        return this.db.prepare("SELECT COUNT(*) as n FROM kg_edges WHERE valid_until IS NULL").get().n;
+      }
+      close() {
+        try {
+          this.db.close();
+        } catch {
+        }
+      }
+      // ─── Internal ────────────────────────────────────────────────────────────
+      rowToNode(row) {
+        return {
+          id: row.id,
+          text: row.text,
+          nodeType: row.node_type,
+          embedding: row.embedding ? new Float32Array(new Uint8Array(row.embedding).buffer) : null,
+          firstSeen: row.first_seen,
+          lastSeen: row.last_seen,
+          mentionCount: row.mention_count
+        };
+      }
+      rowToEdge(row) {
+        return {
+          id: row.id,
+          srcId: row.src_id,
+          dstId: row.dst_id,
+          relation: row.relation,
+          fact: row.fact,
+          edgeType: row.edge_type,
+          validFrom: row.valid_from,
+          validUntil: row.valid_until,
+          confidence: row.confidence,
+          sourceEpisodeId: row.source_episode_id,
+          modality: row.modality
+        };
+      }
     };
   }
 });
@@ -513027,219 +513287,6 @@ var init_gistCompressor = __esm({
   }
 });
 
-// packages/memory/dist/pprRetrieval.js
-function extractQueryEntities(query) {
-  const entities = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add2 = (text) => {
-    const normalized = text.trim().toLowerCase();
-    if (normalized.length < 2 || seen.has(normalized))
-      return;
-    seen.add(normalized);
-    entities.push(text.trim());
-  };
-  const filePattern = /(?:[\w./-]+\/[\w./-]+|[\w-]+\.\w{1,5})\b/g;
-  for (const match of query.matchAll(filePattern)) {
-    if (match[0].includes(".") || match[0].includes("/"))
-      add2(match[0]);
-  }
-  const errorPattern = /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b|\b\w+(?:Error|Exception|Failed|Failure)\b/g;
-  for (const match of query.matchAll(errorPattern))
-    add2(match[0]);
-  const camelPattern = /\b[a-z][a-z0-9]*(?:[A-Z][a-zA-Z0-9]+)+\b/g;
-  for (const match of query.matchAll(camelPattern))
-    add2(match[0]);
-  const toolPattern = /\b(?:file_read|file_write|file_edit|shell|grep_search|find_files|memory_\w+|web_\w+|camera_\w+|audio_\w+|wifi_\w+|bluetooth_\w+|sdr_\w+|flipper_\w+|meshtastic|gps_\w+|visual_\w+)\b/g;
-  for (const match of query.matchAll(toolPattern))
-    add2(match[0]);
-  const quotedPattern = /["']([^"']{2,50})["']/g;
-  for (const match of query.matchAll(quotedPattern))
-    add2(match[1]);
-  const STOP_WORDS2 = /* @__PURE__ */ new Set([
-    "the",
-    "and",
-    "for",
-    "was",
-    "are",
-    "not",
-    "but",
-    "had",
-    "has",
-    "have",
-    "this",
-    "that",
-    "with",
-    "from",
-    "what",
-    "when",
-    "where",
-    "how",
-    "why",
-    "which",
-    "who",
-    "did",
-    "does",
-    "can",
-    "could",
-    "would",
-    "should",
-    "will",
-    "been",
-    "being",
-    "were",
-    "about",
-    "than",
-    "then",
-    "also",
-    "just",
-    "more",
-    "some",
-    "only",
-    "into",
-    "over"
-  ]);
-  const words = query.split(/\s+/).filter((w) => w.length >= 4 && !STOP_WORDS2.has(w.toLowerCase()));
-  for (const word2 of words) {
-    if (/^[A-Z]/.test(word2) || /[._-]/.test(word2) || /\d/.test(word2)) {
-      add2(word2.replace(/[.,;:!?]+$/, ""));
-    }
-  }
-  return entities;
-}
-function personalizedPageRank(graph, seedNodeIds, config) {
-  const cfg = { ...DEFAULT_CONFIG4, ...config };
-  const scores = /* @__PURE__ */ new Map();
-  if (seedNodeIds.length === 0)
-    return scores;
-  const nodeCount = graph.nodeCount();
-  if (nodeCount === 0)
-    return scores;
-  const teleportProb = 1 / seedNodeIds.length;
-  const seedSet = new Set(seedNodeIds);
-  const allNodes = /* @__PURE__ */ new Set();
-  for (const seedId of seedNodeIds) {
-    allNodes.add(seedId);
-    const neighbors2 = graph.neighbors(seedId);
-    for (const { node } of neighbors2) {
-      allNodes.add(node.id);
-      const hop2 = graph.neighbors(node.id);
-      for (const { node: n2 } of hop2)
-        allNodes.add(n2.id);
-    }
-  }
-  for (const nodeId of allNodes) {
-    scores.set(nodeId, seedSet.has(nodeId) ? teleportProb : 0);
-  }
-  for (let iter = 0; iter < cfg.maxIterations; iter++) {
-    const newScores = /* @__PURE__ */ new Map();
-    let maxDelta = 0;
-    for (const nodeId of allNodes) {
-      const teleport = seedSet.has(nodeId) ? (1 - cfg.damping) * teleportProb : 0;
-      let walkSum = 0;
-      const inEdges = graph.currentEdges(nodeId);
-      for (const edge of inEdges) {
-        const neighborId = edge.srcId === nodeId ? edge.dstId : edge.srcId;
-        const neighborScore = scores.get(neighborId) ?? 0;
-        const neighborOutDegree = graph.currentEdges(neighborId).length || 1;
-        walkSum += neighborScore / neighborOutDegree;
-      }
-      const newScore = teleport + cfg.damping * walkSum;
-      newScores.set(nodeId, newScore);
-      const delta = Math.abs(newScore - (scores.get(nodeId) ?? 0));
-      if (delta > maxDelta)
-        maxDelta = delta;
-    }
-    for (const [id, score] of newScores)
-      scores.set(id, score);
-    if (maxDelta < cfg.convergenceThreshold) {
-      return scores;
-    }
-  }
-  return scores;
-}
-function retrieveByPPR(query, graph, episodeStore, config) {
-  const cfg = { ...DEFAULT_CONFIG4, ...config };
-  const queryEntities = extractQueryEntities(query);
-  if (queryEntities.length === 0) {
-    return { episodes: [], queryEntities: [], seedNodes: [], iterations: 0 };
-  }
-  const seedNodes = [];
-  for (const entity of queryEntities) {
-    const seedsBefore = seedNodes.length;
-    const node = graph.findNode(entity);
-    if (node) {
-      seedNodes.push(node.id);
-    }
-    const symbolNodes = graph.findSymbolNodesByName(entity, 10);
-    for (const s2 of symbolNodes)
-      seedNodes.push(s2.id);
-    if (seedNodes.length > seedsBefore)
-      continue;
-    for (const nodeType of ["file", "error", "tool", "entity", "event", "concept", "person"]) {
-      const candidates = graph.nodesByType(nodeType, 50);
-      for (const candidate of candidates) {
-        if (candidate.text.toLowerCase().includes(entity.toLowerCase()) || entity.toLowerCase().includes(candidate.text.toLowerCase())) {
-          seedNodes.push(candidate.id);
-          break;
-        }
-      }
-      if (seedNodes.length > seedsBefore)
-        break;
-    }
-  }
-  if (seedNodes.length === 0) {
-    return { episodes: [], queryEntities, seedNodes: [], iterations: 0 };
-  }
-  const pprScores = personalizedPageRank(graph, seedNodes, cfg);
-  const episodeScores = /* @__PURE__ */ new Map();
-  for (const [nodeId, score] of pprScores) {
-    if (score < 1e-3)
-      continue;
-    const node = graph.getNode(nodeId);
-    if (!node)
-      continue;
-    const edges = graph.currentEdges(nodeId);
-    for (const edge of edges) {
-      if (edge.sourceEpisodeId) {
-        const existing = episodeScores.get(edge.sourceEpisodeId);
-        if (existing) {
-          existing.score += score;
-          existing.matchedNodes.push(node.text);
-        } else {
-          episodeScores.set(edge.sourceEpisodeId, { score, matchedNodes: [node.text] });
-        }
-      }
-    }
-  }
-  const ranked = [...episodeScores.entries()].sort((a2, b) => b[1].score - a2[1].score).slice(0, cfg.topK);
-  const episodes = [];
-  for (const [epId, { score, matchedNodes }] of ranked) {
-    const episode = episodeStore.get(epId);
-    if (episode) {
-      episodes.push({ episode, pprScore: score, matchedNodes: [...new Set(matchedNodes)] });
-    }
-  }
-  return {
-    episodes,
-    queryEntities,
-    seedNodes,
-    iterations: cfg.maxIterations
-  };
-}
-var DEFAULT_CONFIG4;
-var init_pprRetrieval = __esm({
-  "packages/memory/dist/pprRetrieval.js"() {
-    "use strict";
-    init_zettelkasten();
-    DEFAULT_CONFIG4 = {
-      damping: 0.5,
-      maxIterations: 50,
-      convergenceThreshold: 1e-6,
-      topK: 10
-    };
-  }
-});
-
 // packages/memory/dist/embeddings.js
 async function generateEmbedding(text, config) {
   const cfg = { ...DEFAULT_CONFIG5, ...config };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.439",
+  "version": "0.187.440",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.439",
+      "version": "0.187.440",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {
@@ -4207,9 +4207,9 @@
       }
     },
     "node_modules/express-rate-limit": {
-      "version": "8.3.2",
-      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.3.2.tgz",
-      "integrity": "sha512-77VmFeJkO0/rvimEDuUC5H30oqUC4EyOhyGccfqoLebB0oiEYfM7nwPrsDsBL1gsTpwfzX8SFy2MT3TDyRq+bg==",
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.4.0.tgz",
+      "integrity": "sha512-gDK8yiqKxrGta+3WtON59arrrw6GLmadA1qoFgYXzdcch8fmKDID2XqO8itsi3f1wufXYPT51387dN6cvVBS3Q==",
       "license": "MIT",
       "dependencies": {
         "ip-address": "10.1.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.439",
+  "version": "0.187.440",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",