open-agents-ai 0.187.161 → 0.187.163

package/dist/index.js

@@ -3680,7 +3680,7 @@ var init_memory_search = __esm({
     "use strict";
     MemorySearchTool = class {
       name = "memory_search";
-      description = "Search across all memory entries by relevance. Unlike memory_read (exact topic+key), this finds relevant memories using text matching. Use when you don't know the exact topic or key, or want to find all memories related to a concept.";
+      description = "Search across all memory entries by relevance. Unlike memory_read (exact topic+key), this finds relevant memories using text matching or associative graph traversal. Use when you don't know the exact topic or key, or want to find all memories related to a concept. Mode 'graph' uses knowledge graph traversal for multi-hop associative queries (e.g. 'what caused the auth error?').";
       parameters = {
         type: "object",
         properties: {
@@ -3691,6 +3691,11 @@ var init_memory_search = __esm({
           max_results: {
             type: "number",
             description: "Maximum number of results to return (default: 10)"
+          },
+          mode: {
+            type: "string",
+            enum: ["text", "graph", "episodes"],
+            description: "Search mode: 'text' (default \u2014 TF-IDF), 'graph' (PPR traversal), 'episodes' (recent episodes). Default: text."
           }
         },
         required: ["query"]
@@ -3702,7 +3707,87 @@ var init_memory_search = __esm({
       async execute(args) {
         const query = args["query"];
         const maxResults = args["max_results"] ?? 10;
+        const mode = args["mode"] ?? "text";
         const start2 = performance.now();
+        if (mode === "graph" || mode === "episodes") {
+          try {
+            const { join: pathJoin } = await import("node:path");
+            const { existsSync: pathExists } = await import("node:fs");
+            const { createRequire: createRequire7 } = await import("node:module");
+            const oaDir = pathJoin(this.workingDir, ".oa");
+            const epDbPath = pathJoin(oaDir, "episodes.db");
+            const kgDbPath = pathJoin(oaDir, "knowledge.db");
+            if (!pathExists(epDbPath)) {
+              return { success: true, output: `No episode store found. Run tasks to build the knowledge graph.`, durationMs: performance.now() - start2 };
+            }
+            const req2 = createRequire7(import.meta.url);
+            const Database2 = req2("better-sqlite3");
+            if (mode === "episodes") {
+              const db = new Database2(epDbPath, { readonly: true });
+              const queryLower = query.toLowerCase();
+              const rows = db.prepare(`
+            SELECT * FROM episodes
+            WHERE content LIKE ? OR tool_name LIKE ?
+            ORDER BY importance DESC, timestamp DESC
+            LIMIT ?
+          `).all(`%${queryLower}%`, `%${queryLower}%`, maxResults);
+              db.close();
+              if (rows.length === 0) {
+                return { success: true, output: `No episodes found for "${query}".`, durationMs: performance.now() - start2 };
+              }
+              const lines = rows.map((r2) => `[${r2.tool_name ?? r2.modality}] (importance: ${r2.importance}, decay: ${r2.decay_class})
+  ${r2.content.slice(0, 200)}`);
+              return {
+                success: true,
+                output: `Episode search for "${query}" (${rows.length} results):
+
+${lines.join("\n\n")}`,
+                durationMs: performance.now() - start2
+              };
+            }
+            if (mode === "graph" && pathExists(kgDbPath)) {
+              const db = new Database2(kgDbPath, { readonly: true });
+              const queryLower = query.toLowerCase();
+              const nodes = db.prepare(`
+            SELECT * FROM kg_nodes WHERE text LIKE ? ORDER BY mention_count DESC LIMIT 20
+          `).all(`%${queryLower}%`);
+              const episodeIds = /* @__PURE__ */ new Set();
+              const nodeInfo = [];
+              for (const node of nodes.slice(0, 5)) {
+                const edges = db.prepare(`
+              SELECT * FROM kg_edges WHERE (src_id = ? OR dst_id = ?) AND valid_until IS NULL
+            `).all(node.id, node.id);
+                nodeInfo.push(`${node.text} (${node.node_type}, ${node.mention_count} mentions, ${edges.length} edges)`);
+                for (const edge of edges) {
+                  if (edge.source_episode_id)
+                    episodeIds.add(edge.source_episode_id);
+                }
+              }
+              db.close();
+              const epLines = [];
+              if (episodeIds.size > 0 && pathExists(epDbPath)) {
+                const epDb = new Database2(epDbPath, { readonly: true });
+                for (const epId of [...episodeIds].slice(0, maxResults)) {
+                  const ep = epDb.prepare("SELECT * FROM episodes WHERE id = ?").get(epId);
+                  if (ep)
+                    epLines.push(`[${ep.tool_name ?? ep.modality}] ${ep.content.slice(0, 150)}`);
+                }
+                epDb.close();
+              }
+              const output = [
+                `Knowledge graph search for "${query}":`,
+                `
+Nodes found: ${nodes.length}`,
+                nodeInfo.length > 0 ? nodeInfo.map((n2) => `  - ${n2}`).join("\n") : "  (no matching nodes)",
+                epLines.length > 0 ? `
+Linked episodes (${epLines.length}):
+${epLines.map((l2) => `  ${l2}`).join("\n")}` : ""
+              ].filter(Boolean).join("\n");
+              return { success: true, output, durationMs: performance.now() - start2 };
+            }
+          } catch {
+          }
+        }
         try {
           const allEntries = await this.loadAllMemories();
           if (allEntries.length === 0) {
@@ -265041,9 +265126,405 @@ var init_temporalGraph = __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;
+    const sim = cosineSimilarity2(episode.embedding, candidate.embedding);
+    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_CONFIG4, ...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)} \u2194 ${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_CONFIG4;
+var init_zettelkasten = __esm({
+  "packages/memory/dist/zettelkasten.js"() {
+    "use strict";
+    DEFAULT_CONFIG4 = {
+      topK: 3,
+      minSimilarity: 0.3,
+      evolutionThreshold: 0.6,
+      maxLinksPerEpisode: 10
+    };
+  }
+});
+
+// packages/memory/dist/gistCompressor.js
+function compressToGist(episodes, taskDescription) {
+  if (episodes.length === 0) {
+    return {
+      gist: "Empty task \u2014 no actions taken.",
+      sourceEpisodeIds: [],
+      episodeType: "mixed",
+      turnCount: 0,
+      toolsUsed: [],
+      filesModified: [],
+      errorsEncountered: [],
+      timestamp: Date.now()
+    };
+  }
+  const toolsUsed = [...new Set(episodes.map((e2) => e2.toolName).filter(Boolean))];
+  const filesModified = extractFilePaths(episodes, ["file_write", "file_edit", "file_patch", "batch_edit"]);
+  const filesRead = extractFilePaths(episodes, ["file_read"]);
+  const errorsEncountered = episodes.filter((e2) => e2.content.toLowerCase().includes("error") || e2.content.toLowerCase().includes("failed")).map((e2) => e2.content.slice(0, 80)).slice(0, 3);
+  const episodeType = classifyTrajectory(episodes, errorsEncountered);
+  const parts = [];
+  const taskSnippet = taskDescription.slice(0, 100).replace(/\n/g, " ");
+  parts.push(`Task: "${taskSnippet}"`);
+  if (filesModified.length > 0) {
+    parts.push(`Modified ${filesModified.length} file(s): ${filesModified.slice(0, 3).join(", ")}`);
+  }
+  if (errorsEncountered.length > 0 && episodeType === "error_recovery") {
+    parts.push(`Encountered ${errorsEncountered.length} error(s), recovered successfully`);
+  } else if (errorsEncountered.length > 0) {
+    parts.push(`${errorsEncountered.length} error(s) encountered`);
+  }
+  parts.push(`Used ${toolsUsed.length} tools across ${episodes.length} steps`);
+  const lastEp = episodes[episodes.length - 1];
+  if (lastEp.toolName === "task_complete") {
+    parts.push("Completed successfully");
+  } else if (lastEp.content.toLowerCase().includes("error")) {
+    parts.push("Ended with errors");
+  }
+  const gist = parts.join(". ") + ".";
+  return {
+    gist,
+    sourceEpisodeIds: episodes.map((e2) => e2.id),
+    episodeType,
+    turnCount: Math.max(...episodes.map((e2) => e2.turnNumber ?? 0)),
+    toolsUsed,
+    filesModified,
+    errorsEncountered,
+    timestamp: episodes[episodes.length - 1]?.timestamp ?? Date.now()
+  };
+}
+function compressAndStore(episodeStore, sessionId, taskDescription, minTurns = 10) {
+  const episodes = episodeStore.recent(500, sessionId);
+  const maxTurn = Math.max(0, ...episodes.map((e2) => e2.turnNumber ?? 0));
+  if (maxTurn < minTurns)
+    return null;
+  const gistRecord = compressToGist(episodes.reverse(), taskDescription);
+  episodeStore.insert({
+    sessionId,
+    modality: "gist",
+    content: gistRecord.gist,
+    importance: 8,
+    decayClass: "procedural",
+    sourceEpisodeId: gistRecord.sourceEpisodeIds[0]
+  });
+  return gistRecord;
+}
+function extractFilePaths(episodes, toolNames) {
+  const paths = [];
+  for (const ep of episodes) {
+    if (!ep.toolName || !toolNames.includes(ep.toolName))
+      continue;
+    if (ep.metadata) {
+      const fp = ep.metadata.args_fingerprint;
+      if (fp) {
+        const pathMatch = fp.match(/path=([^,]+)/);
+        if (pathMatch)
+          paths.push(pathMatch[1]);
+      }
+    }
+  }
+  return [...new Set(paths)];
+}
+function classifyTrajectory(episodes, errors) {
+  const hasErrors = errors.length > 0;
+  const lastSuccess = episodes.some((e2) => e2.toolName === "task_complete");
+  const hasFileEdits = episodes.some((e2) => ["file_write", "file_edit"].includes(e2.toolName ?? ""));
+  const hasSearch = episodes.some((e2) => ["grep_search", "find_files", "web_search"].includes(e2.toolName ?? ""));
+  if (hasErrors && lastSuccess)
+    return "error_recovery";
+  if (hasSearch && !hasFileEdits)
+    return "discovery";
+  if (!hasErrors && hasFileEdits)
+    return "tool_sequence";
+  return "mixed";
+}
+var init_gistCompressor = __esm({
+  "packages/memory/dist/gistCompressor.js"() {
+    "use strict";
+  }
+});
+
+// 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 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_CONFIG5, ...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_CONFIG5, ...config };
+  const queryEntities = extractQueryEntities(query);
+  if (queryEntities.length === 0) {
+    return { episodes: [], queryEntities: [], seedNodes: [], iterations: 0 };
+  }
+  const seedNodes = [];
+  for (const entity of queryEntities) {
+    const node = graph.findNode(entity);
+    if (node) {
+      seedNodes.push(node.id);
+      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 > queryEntities.indexOf(entity))
+        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_CONFIG5;
+var init_pprRetrieval = __esm({
+  "packages/memory/dist/pprRetrieval.js"() {
+    "use strict";
+    init_zettelkasten();
+    DEFAULT_CONFIG5 = {
+      damping: 0.5,
+      maxIterations: 50,
+      convergenceThreshold: 1e-6,
+      topK: 10
+    };
+  }
+});
+
 // packages/memory/dist/embeddings.js
 async function generateEmbedding(text, config) {
-  const cfg = { ...DEFAULT_CONFIG4, ...config };
+  const cfg = { ...DEFAULT_CONFIG6, ...config };
   try {
     const url = `${cfg.baseUrl}/api/embed`;
     const resp = await fetch(url, {
@@ -265078,7 +265559,7 @@ async function generateEmbedding(text, config) {
   }
 }
 async function checkEmbeddingAvailable(config) {
-  const cfg = { ...DEFAULT_CONFIG4, ...config };
+  const cfg = { ...DEFAULT_CONFIG6, ...config };
   try {
     const resp = await fetch(`${cfg.baseUrl}/api/tags`, {
       signal: AbortSignal.timeout(5e3)
@@ -265105,11 +265586,11 @@ async function pullEmbeddingModel(baseUrl, model, timeoutMs) {
     return false;
   }
 }
-var DEFAULT_CONFIG4;
+var DEFAULT_CONFIG6;
 var init_embeddings = __esm({
   "packages/memory/dist/embeddings.js"() {
     "use strict";
-    DEFAULT_CONFIG4 = {
+    DEFAULT_CONFIG6 = {
       baseUrl: "http://localhost:11434",
       model: "nomic-embed-text",
       timeoutMs: 3e4
@@ -265139,6 +265620,9 @@ var init_dist7 = __esm({
     init_toolPatternStore();
     init_episodeStore();
     init_temporalGraph();
+    init_zettelkasten();
+    init_gistCompressor();
+    init_pprRetrieval();
     init_embeddings();
     init_proceduralMemoryStore();
   }
@@ -265898,6 +266382,15 @@ var init_agenticRunner = __esm({
             const embResult = await generateEmbedding(content, { baseUrl });
             if (embResult?.vector) {
               this._episodeStore.setEmbedding(id, embResult.vector);
+              if (this._temporalGraph) {
+                const episode = this._episodeStore.get(id);
+                if (episode?.embedding) {
+                  try {
+                    linkEpisode(episode, this._episodeStore, this._temporalGraph);
+                  } catch {
+                  }
+                }
+              }
             }
           } catch {
           }
@@ -266798,6 +267291,21 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
             if (compacted.length < prevLen)
               recentToolResults.clear();
           }
+          if (turn > 0 && turn % 3 === 0 && this._temporalGraph && this._episodeStore) {
+            try {
+              const taskGoal = this._taskState.goal || task.slice(0, 200);
+              const pprResult = retrieveByPPR(taskGoal, this._temporalGraph, this._episodeStore, { topK: 3 });
+              if (pprResult.episodes.length > 0) {
+                const memoryLines = pprResult.episodes.map(({ episode, pprScore, matchedNodes }) => `- [${episode.toolName ?? episode.modality}] ${episode.content.slice(0, 120)} (via: ${matchedNodes.slice(0, 2).join(", ")})`);
+                compacted.push({
+                  role: "system",
+                  content: `[Associative Memory \u2014 related prior experience]
+${memoryLines.join("\n")}`
+                });
+              }
+            } catch {
+            }
+          }
           if (this.options.environmentProvider) {
             try {
               const envStr = this.options.environmentProvider();
@@ -268138,6 +268646,19 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
               await this.processPendingEmbeddings();
             }
             this.stopEmbeddingPipeline();
+            const gist = compressAndStore(this._episodeStore, this._sessionId, task, 10);
+            if (gist) {
+              this.emit({ type: "status", content: `Gist compressed: "${gist.gist.slice(0, 100)}..."`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+            }
+            if (this._temporalGraph) {
+              try {
+                const linkResult = batchLink(this._episodeStore, this._temporalGraph);
+                if (linkResult.linksCreated > 0) {
+                  this.emit({ type: "status", content: `Zettelkasten: ${linkResult.linksCreated} associative links created`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                }
+              } catch {
+              }
+            }
             if (this._temporalGraph) {
               const nodes = this._temporalGraph.nodeCount();
               const edges = this._temporalGraph.activeEdgeCount();
@@ -303382,7 +303903,7 @@ function createEditHistoryLogger(repoRoot, sessionId) {
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       tool: toolName,
-      files: extractFilePaths(toolName, toolArgs),
+      files: extractFilePaths2(toolName, toolArgs),
       summary: buildSummary(toolName, toolArgs),
       success,
       session: sessionId,
@@ -303395,7 +303916,7 @@ function createEditHistoryLogger(repoRoot, sessionId) {
   }
   return { logToolCall, logPath: logPath2 };
 }
-function extractFilePaths(tool, args) {
+function extractFilePaths2(tool, args) {
   if (tool === "batch_edit") {
     const edits = args["edits"];
     if (Array.isArray(edits)) {

package/package.json

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