open-agents-ai 0.187.428 → 0.187.429

package/dist/index.js

@@ -540936,441 +540936,405 @@ import * as path5 from "node:path";
 import * as fs4 from "node:fs";
 function getMemoryStats(workingDir) {
   const stats = {
-    zettelkasten: { totalLinks: 0, avgLinksPerEpisode: 0, topNeighbors: [] },
-    knowledgeGraph: { totalNodes: 0, totalEdges: 0, nodeTypes: {}, edgeTypes: {} },
-    episodes: { total: 0, avgImportance: 0, oldestTs: null, newestTs: null, modalities: {} }
+    zettelkasten: { totalLinks: 0, avgLinksPerEpisode: 0, topLinked: [] },
+    knowledgeGraph: { totalNodes: 0, totalEdges: 0, activeEdges: 0, nodeTypes: {}, edgeTypes: {} },
+    episodes: { total: 0, byModality: {}, avgImportance: 0, recentCount: 0 }
   };
-  const memoryDbPath = path5.join(workingDir, ".oa", "episodes.db");
-  if (fs4.existsSync(memoryDbPath)) {
+  const episodesDbPath = path5.join(workingDir, ".oa", "episodes.db");
+  if (fs4.existsSync(episodesDbPath)) {
     try {
-      const Database2 = __require("better-sqlite3");
-      const db = new Database2(memoryDbPath, { readonly: true });
-      const episodeCount = db.prepare("SELECT COUNT(*) as count FROM episodes").get();
-      stats.episodes.total = episodeCount?.count || 0;
-      if (stats.episodes.total > 0) {
-        const avgImp = db.prepare("SELECT AVG(importance) as avg FROM episodes").get();
-        stats.episodes.avgImportance = avgImp?.avg || 0;
-        const oldest = db.prepare("SELECT MIN(timestamp) as min FROM episodes").get();
-        stats.episodes.oldestTs = oldest?.min || null;
-        const newest = db.prepare("SELECT MAX(timestamp) as max FROM episodes").get();
-        stats.episodes.newestTs = newest?.max || null;
-        const modalities = db.prepare("SELECT modality, COUNT(*) as count FROM episodes GROUP BY modality").all();
-        for (const m2 of modalities) {
-          stats.episodes.modalities[m2.modality || "text"] = m2.count;
-        }
-      }
-      db.close();
+      const episodeStore = new EpisodeStore(episodesDbPath);
+      const allEpisodes = episodeStore.search({ limit: 1e4 });
+      stats.episodes.total = allEpisodes.length;
+      if (allEpisodes.length > 0) {
+        const modalityCounts = {};
+        let totalImportance = 0;
+        const oneDayAgo = Date.now() - 864e5;
+        let recentCount = 0;
+        for (const ep of allEpisodes) {
+          const modality = ep.modality || "unknown";
+          modalityCounts[modality] = (modalityCounts[modality] || 0) + 1;
+          totalImportance += ep.importance || 0;
+          if (ep.timestamp > oneDayAgo) recentCount++;
+        }
+        stats.episodes.byModality = modalityCounts;
+        stats.episodes.avgImportance = totalImportance / allEpisodes.length;
+        stats.episodes.recentCount = recentCount;
+      }
+      episodeStore.close();
     } catch (e2) {
     }
   }
   const kgDbPath = path5.join(workingDir, ".oa", "knowledge.db");
   if (fs4.existsSync(kgDbPath)) {
     try {
-      const Database2 = __require("better-sqlite3");
-      const db = new Database2(kgDbPath, { readonly: true });
-      const nodeCount = db.prepare("SELECT COUNT(*) as count FROM nodes").get();
-      stats.knowledgeGraph.totalNodes = nodeCount?.count || 0;
-      const nodeTypes = db.prepare("SELECT node_type, COUNT(*) as count FROM nodes GROUP BY node_type").all();
-      for (const n2 of nodeTypes) {
-        stats.knowledgeGraph.nodeTypes[n2.node_type || "unknown"] = n2.count;
-      }
-      const edgeCount = db.prepare("SELECT COUNT(*) as count FROM edges").get();
-      stats.knowledgeGraph.totalEdges = edgeCount?.count || 0;
-      const edgeTypes = db.prepare("SELECT edge_type, COUNT(*) as count FROM edges GROUP BY edge_type").all();
-      for (const e2 of edgeTypes) {
-        stats.knowledgeGraph.edgeTypes[e2.edge_type || "unknown"] = e2.count;
+      const kg = new TemporalGraph(kgDbPath);
+      stats.knowledgeGraph.totalNodes = kg.nodeCount();
+      stats.knowledgeGraph.totalEdges = kg.edgeCount();
+      stats.knowledgeGraph.activeEdges = kg.activeEdgeCount();
+      const nodeTypes = ["entity", "event", "concept", "error", "file", "person", "tool", "location"];
+      for (const nt of nodeTypes) {
+        const nodes = kg.nodesByType(nt, 1e3);
+        if (nodes.length > 0) {
+          stats.knowledgeGraph.nodeTypes[nt] = nodes.length;
+        }
+      }
+      kg.close();
+    } catch (e2) {
+    }
+  }
+  const zettelDbPath = path5.join(workingDir, ".oa", "episodes.db");
+  if (fs4.existsSync(zettelDbPath)) {
+    try {
+      const episodeStore = new EpisodeStore(zettelDbPath);
+      const episodes = episodeStore.search({ limit: 100 });
+      let totalLinks = 0;
+      const linkCounts = [];
+      const episodesWithEmbeddings = episodes.filter((e2) => e2.embedding != null);
+      for (const ep of episodesWithEmbeddings.slice(0, 50)) {
+        try {
+          const neighbors2 = findNeighbors(ep, episodesWithEmbeddings, 5, 0.3);
+          if (neighbors2.length > 0) {
+            totalLinks += neighbors2.length;
+            linkCounts.push({ id: ep.id, linkCount: neighbors2.length });
+          }
+        } catch {
+        }
       }
-      db.close();
+      stats.zettelkasten.totalLinks = totalLinks;
+      stats.zettelkasten.avgLinksPerEpisode = episodesWithEmbeddings.length > 0 ? totalLinks / Math.min(episodesWithEmbeddings.length, 50) : 0;
+      stats.zettelkasten.topLinked = linkCounts.sort((a2, b) => b.linkCount - a2.linkCount).slice(0, 5);
+      episodeStore.close();
     } catch (e2) {
     }
   }
   return stats;
 }
 function formatTimestamp(ts) {
-  if (!ts) return "N/A";
-  const date = new Date(ts);
-  return date.toLocaleDateString() + " " + date.toLocaleTimeString();
+  if (!ts) return "unknown";
+  const d2 = new Date(ts);
+  return d2.toLocaleString();
 }
 async function showMemoryMenu(options2) {
-  const { rl, workingDir, availableRows } = options2;
+  const { rl, workingDir, availableRows = 20 } = options2;
+  const stats = getMemoryStats(workingDir);
   const items = [
     {
       key: "zettelkasten",
-      label: import_chalk.default.cyan("◈") + " Zettelkasten",
-      detail: "Associative note links and neighbor evolution"
+      label: import_chalk.default.cyan("Zettelkasten") + import_chalk.default.gray(` (${stats.zettelkasten.totalLinks} links)`),
+      detail: "Associative note links between episodes"
     },
     {
-      key: "knowledge_graph",
-      label: import_chalk.default.magenta("◉") + " Knowledge Graph",
-      detail: "Temporal nodes, edges, and concept relationships"
+      key: "knowledge",
+      label: import_chalk.default.magenta("Knowledge Graph") + import_chalk.default.gray(` (${stats.knowledgeGraph.totalNodes} nodes, ${stats.knowledgeGraph.activeEdges} edges)`),
+      detail: "Temporal graph of entities, events, and concepts"
     },
     {
       key: "episodes",
-      label: import_chalk.default.green("●") + " Episodes",
-      detail: "Stored experiences with importance and decay"
-    }
+      label: import_chalk.default.yellow("Episodes") + import_chalk.default.gray(` (${stats.episodes.total} total)`),
+      detail: "Stored experiences and observations"
+    },
+    { key: "separator", label: import_chalk.default.gray("─".repeat(30)) },
+    { key: "back", label: import_chalk.default.red("← Back") }
   ];
+  renderInfo2("Memory Browser — Select a system to explore");
+  console.log();
   const result = await tuiSelect({
     items,
-    activeKey: "zettelkasten",
-    title: "Memory Systems",
     rl,
-    availableRows,
-    onEnter: (item, { resolve: resolve41 }) => {
-      if (item.key === "zettelkasten") {
-        showZettelkastenMenu(options2).then(() => {
-          resolve41({ confirmed: true, key: "zettelkasten", index: 0 });
-        });
-        return true;
-      }
-      if (item.key === "knowledge_graph") {
-        showKnowledgeGraphMenu(options2).then(() => {
-          resolve41({ confirmed: true, key: "knowledge_graph", index: 1 });
-        });
-        return true;
-      }
-      if (item.key === "episodes") {
-        showEpisodesMenu(options2).then(() => {
-          resolve41({ confirmed: true, key: "episodes", index: 2 });
-        });
-        return true;
-      }
-      return false;
-    }
+    skipKeys: ["separator"],
+    availableRows
   });
-  if (result.confirmed && ["zettelkasten", "knowledge_graph", "episodes"].includes(result.key || "")) {
-    await showMemoryMenu(options2);
+  if (!result.confirmed || result.key === "back") {
+    return;
+  }
+  switch (result.key) {
+    case "zettelkasten":
+      await showZettelkastenMenu(options2);
+      break;
+    case "knowledge":
+      await showKnowledgeGraphMenu(options2);
+      break;
+    case "episodes":
+      await showEpisodesMenu(options2);
+      break;
   }
 }
 async function showZettelkastenMenu(options2) {
-  const { rl, workingDir, availableRows } = options2;
-  const stats = getMemoryStats(workingDir);
-  const items = [
-    {
-      key: "__back__",
-      label: import_chalk.default.gray("←") + " Back",
-      detail: "Return to memory menu"
-    },
-    {
-      key: "__stats__",
-      label: import_chalk.default.yellow("📊") + " Statistics",
-      detail: `Links: ${stats.zettelkasten.totalLinks} | Avg: ${stats.zettelkasten.avgLinksPerEpisode.toFixed(2)} per episode`
-    }
-  ];
-  for (const neighbor of stats.zettelkasten.topNeighbors.slice(0, 10)) {
-    items.push({
-      key: `neighbor_${neighbor.id}`,
-      label: import_chalk.default.cyan("◈") + ` ${neighbor.id.slice(0, 16)}...`,
-      detail: `${neighbor.linkCount} links`
-    });
+  const { rl, workingDir, availableRows = 20 } = options2;
+  const dbPath = path5.join(workingDir, ".oa", "episodes.db");
+  if (!fs4.existsSync(dbPath)) {
+    renderError2("No episode database found at .oa/episodes.db");
+    return;
   }
-  const result = await tuiSelect({
-    items,
-    activeKey: "__back__",
-    title: "Zettelkasten — Associative Links",
-    rl,
-    availableRows,
-    onEnter: (item, { resolve: resolve41 }) => {
-      if (item.key === "__back__") {
-        resolve41({ confirmed: false, key: "", index: -1 });
-        return true;
-      }
-      if (item.key === "__stats__") {
-        renderInfo2("Zettelkasten Statistics:");
-        console.log(`  Total Links: ${stats.zettelkasten.totalLinks}`);
-        console.log(`  Avg Links/Episode: ${stats.zettelkasten.avgLinksPerEpisode.toFixed(2)}`);
-        console.log(`  Top Neighbors: ${stats.zettelkasten.topNeighbors.length}`);
-        resolve41({ confirmed: true, key: "__stats__", index: 1 });
-        return true;
-      }
-      if (item.key?.startsWith("neighbor_")) {
-        const neighborId = item.key.replace("neighbor_", "");
-        showNeighborDetail(options2, neighborId).then(() => {
-          resolve41({ confirmed: true, key: item.key, index: -1 });
+  renderInfo2("Zettelkasten — Linked Episodes");
+  console.log();
+  try {
+    const episodeStore = new EpisodeStore(dbPath);
+    const episodes = episodeStore.search({ limit: 100 });
+    const episodesWithEmbeddings = episodes.filter((e2) => e2.embedding != null);
+    const items = [];
+    for (const ep of episodesWithEmbeddings.slice(0, 50)) {
+      try {
+        const neighbors2 = findNeighbors(ep, episodesWithEmbeddings, 5, 0.3);
+        const linkCount = neighbors2.length;
+        const preview = (ep.gist || ep.content || "").slice(0, 50);
+        items.push({
+          key: ep.id,
+          label: import_chalk.default.cyan(ep.id.slice(0, 8)) + import_chalk.default.gray(` (${linkCount} links)`) + " " + import_chalk.default.white(preview + "..."),
+          detail: `Modality: ${ep.modality}, Importance: ${ep.importance}`
         });
-        return true;
+      } catch {
       }
-      return false;
     }
-  });
-  if (result.confirmed && result.key !== "__back__") {
-    await showZettelkastenMenu(options2);
+    items.push({ key: "separator", label: import_chalk.default.gray("─".repeat(30)) });
+    items.push({ key: "back", label: import_chalk.default.red("← Back") });
+    const result = await tuiSelect({
+      items,
+      rl,
+      skipKeys: ["separator"],
+      availableRows
+    });
+    episodeStore.close();
+    if (result.confirmed && result.key !== "back") {
+      await showNeighborDetail(options2, result.key, episodesWithEmbeddings);
+    }
+  } catch (e2) {
+    renderError2(`Failed to load Zettelkasten: ${e2}`);
   }
 }
-async function showNeighborDetail(options2, neighborId) {
-  const { rl, availableRows } = options2;
-  const items = [
-    {
-      key: "__back__",
-      label: import_chalk.default.gray("←") + " Back",
-      detail: "Return to Zettelkasten menu"
-    },
-    {
-      key: "__info__",
-      label: import_chalk.default.cyan("◈") + ` ${neighborId}`,
-      detail: "Episode ID"
-    }
-  ];
-  await tuiSelect({
-    items,
-    activeKey: "__back__",
-    title: `Neighbor: ${neighborId.slice(0, 24)}...`,
-    rl,
-    availableRows,
-    onEnter: (item, { resolve: resolve41 }) => {
-      if (item.key === "__back__") {
-        resolve41({ confirmed: false, key: "", index: -1 });
-        return true;
-      }
-      return false;
+async function showNeighborDetail(options2, episodeId, allEpisodes) {
+  const { rl, workingDir, availableRows = 20 } = options2;
+  const dbPath = path5.join(workingDir, ".oa", "episodes.db");
+  renderInfo2(`Neighbors of ${episodeId.slice(0, 8)}`);
+  console.log();
+  try {
+    const episodeStore = new EpisodeStore(dbPath);
+    const episode = episodeStore.get(episodeId);
+    if (!episode || !episode.embedding) {
+      renderWarning2("Episode not found or has no embedding");
+      episodeStore.close();
+      return;
     }
-  });
-}
-async function showKnowledgeGraphMenu(options2) {
-  const { rl, workingDir, availableRows } = options2;
-  const stats = getMemoryStats(workingDir);
-  const items = [
-    {
-      key: "__back__",
-      label: import_chalk.default.gray("←") + " Back",
-      detail: "Return to memory menu"
-    },
-    {
-      key: "__stats__",
-      label: import_chalk.default.yellow("📊") + " Statistics",
-      detail: `Nodes: ${stats.knowledgeGraph.totalNodes} | Edges: ${stats.knowledgeGraph.totalEdges}`
+    const neighbors2 = findNeighbors(episode, allEpisodes, 10, 0.3);
+    if (neighbors2.length === 0) {
+      renderWarning2("No linked episodes found");
+      episodeStore.close();
+      return;
     }
-  ];
-  for (const [nodeType, count] of Object.entries(stats.knowledgeGraph.nodeTypes)) {
-    items.push({
-      key: `node_type_${nodeType}`,
-      label: import_chalk.default.magenta("◉") + ` ${nodeType}`,
-      detail: `${count} nodes`
-    });
-  }
-  for (const [edgeType, count] of Object.entries(stats.knowledgeGraph.edgeTypes)) {
-    items.push({
-      key: `edge_type_${edgeType}`,
-      label: import_chalk.default.blue("→") + ` ${edgeType}`,
-      detail: `${count} edges`
+    const items = neighbors2.map(({ episode: n2, similarity }) => ({
+      key: n2.id,
+      label: import_chalk.default.cyan(n2.id.slice(0, 8)) + " " + import_chalk.default.gray(`(sim: ${similarity.toFixed(2)})`),
+      detail: n2.gist || n2.content?.slice(0, 60) || "No preview"
+    }));
+    items.push({ key: "separator", label: import_chalk.default.gray("─".repeat(30)) });
+    items.push({ key: "back", label: import_chalk.default.red("← Back") });
+    const result = await tuiSelect({
+      items,
+      rl,
+      skipKeys: ["separator"],
+      availableRows
     });
-  }
-  const result = await tuiSelect({
-    items,
-    activeKey: "__back__",
-    title: "Knowledge Graph — Temporal Nodes & Edges",
-    rl,
-    availableRows,
-    onEnter: (item, { resolve: resolve41 }) => {
-      if (item.key === "__back__") {
-        resolve41({ confirmed: false, key: "", index: -1 });
-        return true;
-      }
-      if (item.key === "__stats__") {
-        renderInfo2("Knowledge Graph Statistics:");
-        console.log(`  Total Nodes: ${stats.knowledgeGraph.totalNodes}`);
-        console.log(`  Total Edges: ${stats.knowledgeGraph.totalEdges}`);
-        console.log(`  Node Types: ${Object.keys(stats.knowledgeGraph.nodeTypes).join(", ") || "none"}`);
-        console.log(`  Edge Types: ${Object.keys(stats.knowledgeGraph.edgeTypes).join(", ") || "none"}`);
-        resolve41({ confirmed: true, key: "__stats__", index: 1 });
-        return true;
-      }
-      resolve41({ confirmed: true, key: item.key, index: -1 });
-      return true;
+    episodeStore.close();
+    if (result.confirmed && result.key !== "back") {
+      await showEpisodeDetail(options2, result.key);
     }
-  });
-  if (result.confirmed && result.key !== "__back__") {
-    await showKnowledgeGraphMenu(options2);
+  } catch (e2) {
+    renderError2(`Failed to load neighbors: ${e2}`);
   }
 }
-async function showEpisodesMenu(options2) {
-  const { rl, workingDir, availableRows } = options2;
-  const stats = getMemoryStats(workingDir);
-  const items = [
-    {
-      key: "__back__",
-      label: import_chalk.default.gray("←") + " Back",
-      detail: "Return to memory menu"
-    },
-    {
-      key: "__stats__",
-      label: import_chalk.default.yellow("📊") + " Statistics",
-      detail: `Total: ${stats.episodes.total} | Avg Importance: ${stats.episodes.avgImportance.toFixed(2)}`
-    }
-  ];
-  for (const [modality, count] of Object.entries(stats.episodes.modalities)) {
-    items.push({
-      key: `modality_${modality}`,
-      label: import_chalk.default.green("●") + ` ${modality}`,
-      detail: `${count} episodes`
-    });
+async function showKnowledgeGraphMenu(options2) {
+  const { rl, workingDir, availableRows = 20 } = options2;
+  const dbPath = path5.join(workingDir, ".oa", "knowledge.db");
+  if (!fs4.existsSync(dbPath)) {
+    renderError2("No knowledge graph database found at .oa/knowledge.db");
+    return;
   }
-  if (stats.episodes.oldestTs && stats.episodes.newestTs) {
-    items.push({
-      key: "__time_range__",
-      label: import_chalk.default.blue("⏱") + " Time Range",
-      detail: `${formatTimestamp(stats.episodes.oldestTs)} → ${formatTimestamp(stats.episodes.newestTs)}`
+  renderInfo2("Knowledge Graph — Nodes and Edges");
+  console.log();
+  try {
+    const kg = new TemporalGraph(dbPath);
+    const nodeTypes = ["entity", "event", "concept", "error", "file", "person", "tool", "location"];
+    const items = [];
+    for (const nt of nodeTypes) {
+      const nodes = kg.nodesByType(nt, 100);
+      if (nodes.length > 0) {
+        items.push({
+          key: `type:${nt}`,
+          label: import_chalk.default.magenta(nt) + import_chalk.default.gray(` (${nodes.length} nodes)`),
+          detail: `Browse ${nt} nodes`
+        });
+      }
+    }
+    items.push({ key: "separator", label: import_chalk.default.gray("─".repeat(30)) });
+    items.push({ key: "back", label: import_chalk.default.red("← Back") });
+    const result = await tuiSelect({
+      items,
+      rl,
+      skipKeys: ["separator"],
+      availableRows
     });
+    kg.close();
+    if (result.confirmed && result.key !== "back" && result.key?.startsWith("type:")) {
+      await showNodesByType(options2, result.key.replace("type:", ""));
+    }
+  } catch (e2) {
+    renderError2(`Failed to load Knowledge Graph: ${e2}`);
   }
-  const episodes = loadRecentEpisodes(workingDir, 20);
-  for (const ep of episodes) {
-    const preview = ep.text?.slice(0, 40) || ep.gist?.slice(0, 40) || "no content";
-    items.push({
-      key: `episode_${ep.id}`,
-      label: import_chalk.default.green("●") + ` ${ep.id.slice(0, 12)}...`,
-      detail: `imp=${ep.importance?.toFixed(1) || "?"} | ${preview}...`
+}
+async function showNodesByType(options2, nodeType) {
+  const { rl, workingDir, availableRows = 20 } = options2;
+  const dbPath = path5.join(workingDir, ".oa", "knowledge.db");
+  renderInfo2(`Nodes of type: ${nodeType}`);
+  console.log();
+  try {
+    const kg = new TemporalGraph(dbPath);
+    const nodes = kg.nodesByType(nodeType, 50);
+    const items = nodes.map((n2) => ({
+      key: n2.id,
+      label: import_chalk.default.magenta(n2.text.slice(0, 40)) + import_chalk.default.gray(` (${n2.mentionCount} mentions)`),
+      detail: `First seen: ${formatTimestamp(n2.firstSeen)}`
+    }));
+    items.push({ key: "separator", label: import_chalk.default.gray("─".repeat(30)) });
+    items.push({ key: "back", label: import_chalk.default.red("← Back") });
+    const result = await tuiSelect({
+      items,
+      rl,
+      skipKeys: ["separator"],
+      availableRows
     });
-  }
-  const result = await tuiSelect({
-    items,
-    activeKey: "__back__",
-    title: "Episodes — Stored Experiences",
-    rl,
-    availableRows,
-    onEnter: (item, { resolve: resolve41 }) => {
-      if (item.key === "__back__") {
-        resolve41({ confirmed: false, key: "", index: -1 });
-        return true;
-      }
-      if (item.key === "__stats__") {
-        renderInfo2("Episode Statistics:");
-        console.log(`  Total Episodes: ${stats.episodes.total}`);
-        console.log(`  Avg Importance: ${stats.episodes.avgImportance.toFixed(2)}`);
-        console.log(`  Oldest: ${formatTimestamp(stats.episodes.oldestTs)}`);
-        console.log(`  Newest: ${formatTimestamp(stats.episodes.newestTs)}`);
-        console.log(`  Modalities: ${Object.entries(stats.episodes.modalities).map(([k, v]) => `${k}(${v})`).join(", ") || "none"}`);
-        resolve41({ confirmed: true, key: "__stats__", index: 1 });
-        return true;
-      }
-      if (item.key?.startsWith("episode_")) {
-        const episodeId = item.key.replace("episode_", "");
-        showEpisodeDetail(options2, episodeId).then(() => {
-          resolve41({ confirmed: true, key: item.key, index: -1 });
-        });
-        return true;
-      }
-      resolve41({ confirmed: true, key: item.key, index: -1 });
-      return true;
+    kg.close();
+    if (result.confirmed && result.key !== "back") {
+      await showNodeDetail(options2, result.key);
     }
-  });
-  if (result.confirmed && result.key !== "__back__") {
-    await showEpisodesMenu(options2);
+  } catch (e2) {
+    renderError2(`Failed to load nodes: ${e2}`);
   }
 }
-function loadRecentEpisodes(workingDir, limit) {
-  const memoryDbPath = path5.join(workingDir, ".oa", "memory.db");
-  if (!fs4.existsSync(memoryDbPath)) return [];
+async function showNodeDetail(options2, nodeId) {
+  const { rl, workingDir } = options2;
+  const dbPath = path5.join(workingDir, ".oa", "knowledge.db");
+  renderInfo2(`Node: ${nodeId}`);
+  console.log();
   try {
-    const Database2 = __require("better-sqlite3");
-    const db = new Database2(memoryDbPath, { readonly: true });
-    const episodes = db.prepare(`
-      SELECT id, text, gist, importance
-      FROM episodes
-      ORDER BY timestamp DESC
-      LIMIT ?
-    `).all(limit);
-    db.close();
-    return episodes;
+    const kg = new TemporalGraph(dbPath);
+    const node = kg.getNode(nodeId);
+    if (!node) {
+      renderWarning2("Node not found");
+      kg.close();
+      return;
+    }
+    console.log(import_chalk.default.bold("Text:"), node.text);
+    console.log(import_chalk.default.bold("Type:"), node.nodeType);
+    console.log(import_chalk.default.bold("Mentions:"), node.mentionCount);
+    console.log(import_chalk.default.bold("First seen:"), formatTimestamp(node.firstSeen));
+    console.log(import_chalk.default.bold("Last seen:"), formatTimestamp(node.lastSeen));
+    console.log();
+    const edges = kg.currentEdges(nodeId);
+    if (edges.length > 0) {
+      console.log(import_chalk.default.bold("Edges:"));
+      for (const e2 of edges.slice(0, 10)) {
+        const otherId = e2.srcId === nodeId ? e2.dstId : e2.srcId;
+        const otherNode = kg.getNode(otherId);
+        console.log(`  ${import_chalk.default.cyan(e2.relation)} → ${otherNode?.text || otherId.slice(0, 8)}`);
+      }
+    }
+    kg.close();
   } catch (e2) {
-    return [];
+    renderError2(`Failed to load node: ${e2}`);
   }
+  console.log();
+  renderInfo2("Press Enter to go back...");
+  await new Promise((resolve41) => {
+    rl.question("", () => resolve41());
+  });
 }
-async function showEpisodeDetail(options2, episodeId) {
-  const { rl, workingDir, availableRows } = options2;
-  const episode = loadEpisodeById(workingDir, episodeId);
-  if (!episode) {
-    renderWarning2(`Episode ${episodeId} not found.`);
+async function showEpisodesMenu(options2) {
+  const { rl, workingDir, availableRows = 20 } = options2;
+  const dbPath = path5.join(workingDir, ".oa", "episodes.db");
+  if (!fs4.existsSync(dbPath)) {
+    renderError2("No episode database found at .oa/episodes.db");
     return;
   }
-  const items = [
-    {
-      key: "__back__",
-      label: import_chalk.default.gray("←") + " Back",
-      detail: "Return to Episodes menu"
-    },
-    {
-      key: "__id__",
-      label: import_chalk.default.green("●") + " ID",
-      detail: episode.id
-    },
-    {
-      key: "__importance__",
-      label: import_chalk.default.yellow("★") + " Importance",
-      detail: String(episode.importance || 0)
-    },
-    {
-      key: "__modality__",
-      label: import_chalk.default.cyan("◈") + " Modality",
-      detail: episode.modality || "text"
-    },
-    {
-      key: "__timestamp__",
-      label: import_chalk.default.blue("⏱") + " Timestamp",
-      detail: formatTimestamp(episode.timestamp || null)
-    }
-  ];
-  if (episode.gist) {
-    items.push({
-      key: "__gist__",
-      label: import_chalk.default.magenta("📝") + " Gist",
-      detail: episode.gist.slice(0, 60) + (episode.gist.length > 60 ? "..." : "")
+  renderInfo2("Episodes — Recent Experiences");
+  console.log();
+  try {
+    const episodeStore = new EpisodeStore(dbPath);
+    const episodes = episodeStore.search({ limit: 50 });
+    const items = episodes.map((ep) => {
+      const preview = (ep.gist || ep.content || "").slice(0, 50);
+      const timeAgo = formatTimeAgo(ep.timestamp);
+      return {
+        key: ep.id,
+        label: import_chalk.default.yellow(ep.id.slice(0, 8)) + import_chalk.default.gray(` [${ep.modality}]`) + " " + import_chalk.default.white(preview + "..."),
+        detail: `Importance: ${ep.importance}, ${timeAgo}`
+      };
     });
-  }
-  if (episode.text) {
-    const textPreview = episode.text.slice(0, 100).replace(/\n/g, " ");
-    items.push({
-      key: "__text__",
-      label: import_chalk.default.white("📄") + " Text",
-      detail: textPreview + (episode.text.length > 100 ? "..." : "")
+    items.push({ key: "separator", label: import_chalk.default.gray("─".repeat(30)) });
+    items.push({ key: "back", label: import_chalk.default.red("← Back") });
+    const result = await tuiSelect({
+      items,
+      rl,
+      skipKeys: ["separator"],
+      availableRows
     });
-  }
-  await tuiSelect({
-    items,
-    activeKey: "__back__",
-    title: `Episode: ${episodeId.slice(0, 20)}...`,
-    rl,
-    availableRows,
-    onEnter: (item, { resolve: resolve41 }) => {
-      if (item.key === "__back__") {
-        resolve41({ confirmed: false, key: "", index: -1 });
-        return true;
-      }
-      if (item.key === "__text__" && episode.text) {
-        console.log("\n" + import_chalk.default.dim("─".repeat(40)));
-        console.log(import_chalk.default.white("Full Text:"));
-        console.log(episode.text);
-        console.log(import_chalk.default.dim("─".repeat(40)) + "\n");
-        resolve41({ confirmed: true, key: "__text__", index: -1 });
-        return true;
-      }
-      if (item.key === "__gist__" && episode.gist) {
-        console.log("\n" + import_chalk.default.dim("─".repeat(40)));
-        console.log(import_chalk.default.magenta("Full Gist:"));
-        console.log(episode.gist);
-        console.log(import_chalk.default.dim("─".repeat(40)) + "\n");
-        resolve41({ confirmed: true, key: "__gist__", index: -1 });
-        return true;
-      }
-      return false;
+    episodeStore.close();
+    if (result.confirmed && result.key !== "back") {
+      await showEpisodeDetail(options2, result.key);
     }
-  });
+  } catch (e2) {
+    renderError2(`Failed to load episodes: ${e2}`);
+  }
+}
+function formatTimeAgo(timestamp) {
+  const seconds = Math.floor((Date.now() - timestamp) / 1e3);
+  if (seconds < 60) return "just now";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
 }
-function loadEpisodeById(workingDir, id) {
-  const memoryDbPath = path5.join(workingDir, ".oa", "memory.db");
-  if (!fs4.existsSync(memoryDbPath)) return null;
+async function showEpisodeDetail(options2, episodeId) {
+  const { rl, workingDir } = options2;
+  const dbPath = path5.join(workingDir, ".oa", "episodes.db");
+  renderInfo2(`Episode: ${episodeId.slice(0, 8)}`);
+  console.log();
   try {
-    const Database2 = __require("better-sqlite3");
-    const db = new Database2(memoryDbPath, { readonly: true });
-    const episode = db.prepare(`
-      SELECT id, text, gist, importance, modality, timestamp
-      FROM episodes
-      WHERE id = ?
-    `).get(id);
-    db.close();
-    return episode || null;
+    const episodeStore = new EpisodeStore(dbPath);
+    const episode = episodeStore.get(episodeId);
+    if (!episode) {
+      renderWarning2("Episode not found");
+      episodeStore.close();
+      return;
+    }
+    console.log(import_chalk.default.bold("ID:"), episode.id);
+    console.log(import_chalk.default.bold("Timestamp:"), formatTimestamp(episode.timestamp));
+    console.log(import_chalk.default.bold("Modality:"), episode.modality);
+    console.log(import_chalk.default.bold("Importance:"), episode.importance);
+    console.log(import_chalk.default.bold("Decay Class:"), episode.decayClass);
+    console.log(import_chalk.default.bold("Strength:"), episode.strength);
+    if (episode.toolName) {
+      console.log(import_chalk.default.bold("Tool:"), episode.toolName);
+    }
+    if (episode.gist) {
+      console.log();
+      console.log(import_chalk.default.bold("Gist:"));
+      console.log(import_chalk.default.gray(episode.gist));
+    }
+    if (episode.content) {
+      console.log();
+      console.log(import_chalk.default.bold("Content:"));
+      const content = episode.content.length > 500 ? episode.content.slice(0, 500) + "..." : episode.content;
+      console.log(import_chalk.default.white(content));
+    }
+    episodeStore.close();
   } catch (e2) {
-    return null;
+    renderError2(`Failed to load episode: ${e2}`);
   }
+  console.log();
+  renderInfo2("Press Enter to go back...");
+  await new Promise((resolve41) => {
+    rl.question("", () => resolve41());
+  });
 }
 var import_chalk;
 var init_memory_menu = __esm({
@@ -541379,6 +541343,7 @@ var init_memory_menu = __esm({
     import_chalk = __toESM(require_source(), 1);
     init_tui_select();
     init_render2();
+    init_dist7();
   }
 });
 
@@ -581352,7 +581317,7 @@ import { readFileSync as readFileSync70, writeFileSync as writeFileSync48, appen
 import { existsSync as existsSync88 } from "node:fs";
 import { execSync as execSync56 } from "node:child_process";
 import { homedir as homedir40 } from "node:os";
-function formatTimeAgo(date) {
+function formatTimeAgo2(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
   if (seconds < 60) return "just now";
   const minutes = Math.floor(seconds / 60);
@@ -586511,7 +586476,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     if (savedCtx && savedCtx.entries.length > 0) {
       const lastEntry = savedCtx.entries[savedCtx.entries.length - 1];
       const lastTime = lastEntry.savedAt ? new Date(lastEntry.savedAt) : null;
-      const timeAgo = lastTime ? formatTimeAgo(lastTime) : "unknown";
+      const timeAgo = lastTime ? formatTimeAgo2(lastTime) : "unknown";
       const lastTask = lastEntry.task?.slice(0, 80) || "unknown";
       setTimeout(async () => {
         writeContent(() => {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.428",
+  "version": "0.187.429",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.428",
+      "version": "0.187.429",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {
@@ -392,9 +392,9 @@
       "license": "Apache-2.0"
     },
     "node_modules/@chainsafe/as-sha256": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@chainsafe/as-sha256/-/as-sha256-1.2.0.tgz",
-      "integrity": "sha512-H2BNHQ5C3RS+H0ZvOdovK6GjFAyq5T6LClad8ivwj9Oaiy28uvdsGVS7gNJKuZmg0FGHAI+n7F0Qju6U0QkKDA==",
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@chainsafe/as-sha256/-/as-sha256-1.2.4.tgz",
+      "integrity": "sha512-3GXDysZOKD6cTYbm48lEdXdUbS7cafjXQZfgHOspTByhoGR/JM3KBXyF3vE6bf63ImjNPyoEZwnQcpYPQ6k3bQ==",
       "license": "Apache-2.0"
     },
     "node_modules/@chainsafe/is-ip": {
@@ -481,13 +481,13 @@
       }
     },
     "node_modules/@helia/bitswap": {
-      "version": "3.2.2",
-      "resolved": "https://registry.npmjs.org/@helia/bitswap/-/bitswap-3.2.2.tgz",
-      "integrity": "sha512-f+FiGaSaQt070wT8To1e1cRcFIaRMOctrJAEKksOpLB3Y0qMjdqAKALM4jSNxh8mf7jFa5HyXGKIShQWVCxMcg==",
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/@helia/bitswap/-/bitswap-3.2.3.tgz",
+      "integrity": "sha512-uquUTgYaU5Z08SVFn+Psg1xhkeAqCdLWav0zAaNJE1bQX7UeLItW82+Nh5I40RaH9gMFFqL3IQR0mIzi+bj5Gg==",
       "license": "Apache-2.0 OR MIT",
       "dependencies": {
         "@helia/interface": "^6.2.1",
-        "@helia/utils": "^2.5.1",
+        "@helia/utils": "^2.5.2",
         "@libp2p/interface": "^3.2.0",
         "@libp2p/logger": "^6.2.4",
         "@libp2p/peer-collections": "^7.0.15",
@@ -523,14 +523,14 @@
       }
     },
     "node_modules/@helia/block-brokers": {
-      "version": "5.2.3",
-      "resolved": "https://registry.npmjs.org/@helia/block-brokers/-/block-brokers-5.2.3.tgz",
-      "integrity": "sha512-a6X2a0wYYRfbKhTE98/C6pvwQOtz0gQypQCMMHw3QoVGr15rJ6PxjwX5dMZxKD52GoWkQ9/eR01eGVfkXGtYqw==",
+      "version": "5.2.4",
+      "resolved": "https://registry.npmjs.org/@helia/block-brokers/-/block-brokers-5.2.4.tgz",
+      "integrity": "sha512-UsxtWVy2W95FVM561BZXEnb41RL6pr+cLF+AIxVIaugEvg4edUKh+3sbZXoINtzbqS664Ss2dhisHR1ZnYI57Q==",
       "license": "Apache-2.0 OR MIT",
       "dependencies": {
-        "@helia/bitswap": "^3.2.2",
+        "@helia/bitswap": "^3.2.3",
         "@helia/interface": "^6.2.1",
-        "@helia/utils": "^2.5.1",
+        "@helia/utils": "^2.5.2",
         "@libp2p/interface": "^3.2.0",
         "@libp2p/peer-id": "^6.0.6",
         "@libp2p/utils": "^7.0.15",
@@ -673,9 +673,9 @@
       }
     },
     "node_modules/@helia/utils": {
-      "version": "2.5.1",
-      "resolved": "https://registry.npmjs.org/@helia/utils/-/utils-2.5.1.tgz",
-      "integrity": "sha512-8HI3Ji6tz/C8XVhy/lHy6x/iSKLk7BtjAHQaSU/jrJOthB1hmmXFbo7jrSG9ql6Na7aygj9is4ajIaE/wxfAWg==",
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/@helia/utils/-/utils-2.5.2.tgz",
+      "integrity": "sha512-6/+RInRpJsJoo13ECQsSkBtK2xUGl/KWaJpBuK9tqg+ng3s5cec2qO9RVhZt4bdkPPqJc/PX+G9zwVhKqp5UwQ==",
       "license": "Apache-2.0 OR MIT",
       "dependencies": {
         "@helia/interface": "^6.2.1",
@@ -1520,9 +1520,9 @@
       }
     },
     "node_modules/@libp2p/webrtc": {
-      "version": "6.0.18",
-      "resolved": "https://registry.npmjs.org/@libp2p/webrtc/-/webrtc-6.0.18.tgz",
-      "integrity": "sha512-EX4lu+96K03V2WfiyAm+/I8VRXwUfIPS6n+NqyypIfqJmTWwTIZL/SsKO54m+R+ccUbSnaoa0eOVTDhFcMgnkw==",
+      "version": "6.0.19",
+      "resolved": "https://registry.npmjs.org/@libp2p/webrtc/-/webrtc-6.0.19.tgz",
+      "integrity": "sha512-BY0WAMfWcmmhlxB3hWafjjfiRtFO0IrfS9ffT8u4nfDG/FT+vrR/CLJtmEEsypuR6cuuPJCWgrKpKQXgjVm7AQ==",
       "license": "Apache-2.0 OR MIT",
       "dependencies": {
         "@chainsafe/is-ip": "^2.1.0",
@@ -1537,7 +1537,6 @@
         "@multiformats/multiaddr-matcher": "^3.0.1",
         "@peculiar/webcrypto": "^1.5.0",
         "@peculiar/x509": "^2.0.0",
-        "detect-browser": "^5.3.0",
         "get-port": "^7.1.0",
         "interface-datastore": "^9.0.1",
         "it-length-prefixed": "^10.0.1",
@@ -3894,12 +3893,6 @@
         "npm": "1.2.8000 || >= 1.4.16"
       }
     },
-    "node_modules/detect-browser": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/detect-browser/-/detect-browser-5.3.0.tgz",
-      "integrity": "sha512-53rsFbGdwMwlF7qvCt0ypLM5V5/Mbl0szB7GPN8y9NCcbknYOeVVXdrXEq+90IwAfrrzt6Hd+u2E2ntakICU8w==",
-      "license": "MIT"
-    },
     "node_modules/detect-libc": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
@@ -3951,9 +3944,9 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.340",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.340.tgz",
-      "integrity": "sha512-908qahOGocRMinT2nM3ajCEM99H4iPdv84eagPP3FfZy/1ZGeOy2CZYzjhms81ckOPCXPlW7LkY4XpxD8r1DrA==",
+      "version": "1.5.341",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.341.tgz",
+      "integrity": "sha512-1sZTssferjgDgaqRTc0ieP+ozzpOy7LQTPTtEW3yQFn4+ORdIAZWV5BthXPyHF7YqLvFJCUPhNhdAJQYlYUgiw==",
       "license": "ISC",
       "peer": true
     },

package/package.json

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