@geravant/sinain 1.10.0 → 1.10.1

package/sinain-core/src/learning/local-curation.ts

@@ -0,0 +1,373 @@
+/**
+ * LocalCurationService — local-first knowledge pipeline for sinain-core.
+ *
+ * Runs the same Python scripts as the OpenClaw server-side pipeline,
+ * but triggered locally: on session end (SIGINT/SIGTERM) and periodically.
+ *
+ * This ensures knowledge persists between bare-agent sessions even when
+ * no OpenClaw gateway is available.
+ *
+ * Memory directory: SINAIN_MEMORY_DIR (default: ~/.sinain/memory)
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync, appendFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { FeedItem } from "../types.js";
+import { log, warn, error } from "../log.js";
+
+const TAG = "local-curation";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/** Resolve the sinain-memory Python scripts directory. */
+function resolveScriptsDir(): string {
+  // Look for sinain-memory scripts in known locations
+  const candidates = [
+    resolve(__dirname, "..", "..", "..", "sinain-hud-plugin", "sinain-memory"),
+    resolve(__dirname, "..", "..", "sinain-memory"),
+    resolve(process.env.HOME || "", ".sinain", "sinain-memory"),
+  ];
+  for (const dir of candidates) {
+    if (existsSync(resolve(dir, "session_distiller.py"))) {
+      return dir;
+    }
+  }
+  return candidates[0]; // Fallback
+}
+
+/** Resolve the local memory directory. */
+function resolveMemoryDir(): string {
+  const raw = process.env.SINAIN_MEMORY_DIR
+    || process.env.OPENCLAW_WORKSPACE_DIR
+    || `${process.env.HOME}/.sinain/memory`;
+  const expanded = raw.startsWith("~") ? raw.replace("~", process.env.HOME || "") : raw;
+
+  // If pointing to workspace, use the memory subdirectory
+  if (expanded.endsWith("/workspace") || expanded.endsWith("/workspace/")) {
+    return resolve(expanded, "memory");
+  }
+  return expanded;
+}
+
+export class LocalCurationService {
+  private memoryDir: string;
+  private scriptsDir: string;
+  private sessionStartTs: number;
+  private curationTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor() {
+    this.memoryDir = resolveMemoryDir();
+    this.scriptsDir = resolveScriptsDir();
+    this.sessionStartTs = Date.now();
+
+    // Ensure memory directory exists
+    for (const subdir of ["", "playbook-logs", "playbook-archive", "eval-logs", "eval-reports"]) {
+      const dir = resolve(this.memoryDir, subdir);
+      mkdirSync(dir, { recursive: true });
+    }
+
+    log(TAG, `memory: ${this.memoryDir}`);
+    log(TAG, `scripts: ${this.scriptsDir}`);
+    log(TAG, `scripts available: ${existsSync(resolve(this.scriptsDir, "session_distiller.py"))}`);
+  }
+
+  /** Start periodic curation (30-minute timer). */
+  startPeriodicCuration(): void {
+    if (this.curationTimer) return;
+    const intervalMs = 30 * 60 * 1000; // 30 minutes
+    this.curationTimer = setInterval(() => {
+      this.runCurationPipeline();
+    }, intervalMs);
+    log(TAG, `periodic curation started (every 30 min)`);
+  }
+
+  /** Stop periodic curation. */
+  stop(): void {
+    if (this.curationTimer) {
+      clearInterval(this.curationTimer);
+      this.curationTimer = null;
+    }
+  }
+
+  /**
+   * Save feed items to disk for deferred distillation.
+   * Called during shutdown — instant (no LLM), survives tsx force-kill.
+   */
+  savePendingSession(feedItems: FeedItem[]): void {
+    if (feedItems.length < 3) {
+      log(TAG, `skipping save — only ${feedItems.length} feed items`);
+      return;
+    }
+
+    const pendingPath = resolve(this.memoryDir, "pending-session.json");
+    const data = {
+      ts: new Date().toISOString(),
+      sessionKey: "local-session",
+      durationMs: Date.now() - this.sessionStartTs,
+      items: feedItems.map(item => ({
+        text: item.text,
+        ts: item.ts,
+        source: item.source || "unknown",
+        channel: item.channel || "agent",
+      })),
+    };
+
+    writeFileSync(pendingPath, JSON.stringify(data), "utf-8");
+    log(TAG, `saved ${feedItems.length} feed items to pending-session.json`);
+  }
+
+  /**
+   * Distill a previously saved pending session (from a prior shutdown).
+   * Called on startup — runs LLM distillation when there's no time pressure.
+   */
+  distillPendingSession(): void {
+    const pendingPath = resolve(this.memoryDir, "pending-session.json");
+    if (!existsSync(pendingPath)) return;
+
+    let data: any;
+    try {
+      data = JSON.parse(readFileSync(pendingPath, "utf-8"));
+    } catch {
+      warn(TAG, "corrupt pending-session.json — removing");
+      unlinkSync(pendingPath);
+      return;
+    }
+
+    const items: FeedItem[] = data.items || [];
+    if (items.length < 3) {
+      log(TAG, `pending session too small (${items.length} items) — removing`);
+      unlinkSync(pendingPath);
+      return;
+    }
+
+    log(TAG, `distilling pending session: ${items.length} items from ${data.ts}`);
+
+    // Remove pending file first so a crash here doesn't loop
+    unlinkSync(pendingPath);
+
+    this.runDistillation(items, {
+      ts: data.ts,
+      sessionKey: data.sessionKey || "local-session",
+      durationMs: data.durationMs || 0,
+    });
+  }
+
+  /**
+   * Distill the current session on shutdown.
+   * First saves feed items to disk (instant), then attempts LLM distillation.
+   * If tsx kills the process before LLM finishes, the saved file will be
+   * picked up on next startup via distillPendingSession().
+   */
+  async distillSession(feedItems: FeedItem[]): Promise<void> {
+    if (feedItems.length < 3) {
+      log(TAG, `skipping distillation — only ${feedItems.length} feed items`);
+      return;
+    }
+
+    // Step 0: Save to disk FIRST — survives force-kill
+    this.savePendingSession(feedItems);
+
+    const sessionMeta = {
+      ts: new Date().toISOString(),
+      sessionKey: "local-session",
+      durationMs: Date.now() - this.sessionStartTs,
+    };
+
+    const transcript = feedItems.map(item => ({
+      text: item.text,
+      ts: item.ts,
+      source: item.source || "unknown",
+      channel: item.channel || "agent",
+    }));
+
+    // Step 1+2: Attempt LLM distillation (may be killed by tsx)
+    if (this.runDistillation(transcript, sessionMeta)) {
+      // Success — remove the pending file since we distilled in-place
+      const pendingPath = resolve(this.memoryDir, "pending-session.json");
+      try { unlinkSync(pendingPath); } catch { /* already gone */ }
+    }
+    // If killed here, pending-session.json remains for next startup
+  }
+
+  /**
+   * Run the actual distillation pipeline (session_distiller + knowledge_integrator).
+   * Returns true if distillation succeeded.
+   */
+  private runDistillation(transcript: any[], sessionMeta: { ts: string; sessionKey: string; durationMs: number }): boolean {
+    if (!existsSync(resolve(this.scriptsDir, "session_distiller.py"))) {
+      warn(TAG, "session_distiller.py not found — skipping distillation");
+      this.writeDailyNotesFallback(transcript as any);
+      return false;
+    }
+
+    log(TAG, `distilling session: ${transcript.length} items, ${Math.round(sessionMeta.durationMs / 60000)} min`);
+
+    try {
+      // Step 1: Distill session into a SessionDigest
+      const digestJson = execFileSync("python3", [
+        resolve(this.scriptsDir, "session_distiller.py"),
+        "--memory-dir", this.memoryDir,
+        "--transcript", JSON.stringify(transcript),
+        "--session-meta", JSON.stringify(sessionMeta),
+      ], {
+        timeout: 30_000,
+        encoding: "utf-8",
+        env: { ...process.env, PYTHONPATH: this.scriptsDir },
+      });
+
+      const digest = JSON.parse(digestJson);
+
+      if (digest.isEmpty || digest.error) {
+        log(TAG, `distillation skipped: ${digest.error || "empty session"}`);
+        this.writeDailyNotesFallback(transcript as any);
+        return false;
+      }
+
+      log(TAG, `distilled: "${(digest.whatHappened || "").slice(0, 80)}..."`);
+
+      // Write daily session notes
+      this.writeDailyNotes(digest, transcript as any);
+
+      // Step 2: Integrate into playbook + knowledge graph
+      try {
+        const integratorOutput = execFileSync("python3", [
+          resolve(this.scriptsDir, "knowledge_integrator.py"),
+          "--memory-dir", this.memoryDir,
+          "--digest", JSON.stringify(digest),
+        ], {
+          timeout: 30_000,
+          encoding: "utf-8",
+          env: { ...process.env, PYTHONPATH: this.scriptsDir },
+        });
+
+        const result = JSON.parse(integratorOutput);
+        log(TAG, `knowledge integrated: ${JSON.stringify(result.graphStats || result)}`);
+      } catch (err: any) {
+        warn(TAG, `knowledge integration failed: ${err.message?.slice(0, 200)}`);
+      }
+      return true;
+    } catch (err: any) {
+      warn(TAG, `distillation failed: ${err.message?.slice(0, 200)}`);
+      this.writeDailyNotesFallback(transcript as any);
+      return false;
+    }
+  }
+
+  /** Run the periodic curation pipeline (feedback → mining → curation). */
+  private runCurationPipeline(): void {
+    log(TAG, "running periodic curation...");
+
+    const scripts = [
+      "feedback_analyzer.py",
+      "memory_miner.py",
+      "playbook_curator.py",
+    ];
+
+    for (const script of scripts) {
+      const scriptPath = resolve(this.scriptsDir, script);
+      if (!existsSync(scriptPath)) {
+        warn(TAG, `${script} not found — skipping`);
+        continue;
+      }
+
+      try {
+        execFileSync("python3", [
+          scriptPath,
+          "--memory-dir", this.memoryDir,
+        ], {
+          timeout: 60_000,
+          encoding: "utf-8",
+          env: { ...process.env, PYTHONPATH: this.scriptsDir },
+        });
+        log(TAG, `  ✓ ${script}`);
+      } catch (err: any) {
+        warn(TAG, `  ✗ ${script}: ${err.message?.slice(0, 100)}`);
+      }
+    }
+
+    log(TAG, "periodic curation complete");
+  }
+
+  /** Write distilled session notes to daily file. */
+  private writeDailyNotes(digest: any, feedItems: FeedItem[]): void {
+    const date = new Date().toISOString().slice(0, 10);
+    const notesPath = resolve(this.memoryDir, `${date}.md`);
+
+    const sections = [
+      `## Session ${new Date().toISOString().slice(11, 16)} UTC`,
+      "",
+      `### Summary`,
+      digest.whatHappened || "(no summary)",
+      "",
+    ];
+
+    if (digest.patterns?.length > 0) {
+      sections.push("### Patterns Observed");
+      for (const p of digest.patterns) {
+        sections.push(`- ${typeof p === "string" ? p : p.pattern || JSON.stringify(p)}`);
+      }
+      sections.push("");
+    }
+
+    if (digest.entities?.length > 0) {
+      sections.push("### Entities");
+      sections.push(digest.entities.map((e: string) => `\`${e}\``).join(", "));
+      sections.push("");
+    }
+
+    if (digest.preferences?.length > 0) {
+      sections.push("### User Preferences");
+      for (const p of digest.preferences) {
+        sections.push(`- ${typeof p === "string" ? p : JSON.stringify(p)}`);
+      }
+      sections.push("");
+    }
+
+    // Append (don't overwrite — multiple sessions per day)
+    const content = sections.join("\n") + "\n---\n\n";
+    appendFileSync(notesPath, content, "utf-8");
+    log(TAG, `daily notes written: ${notesPath}`);
+  }
+
+  /** Fallback: write raw feed summary when distillation fails. */
+  private writeDailyNotesFallback(feedItems: FeedItem[]): void {
+    if (feedItems.length < 3) return;
+
+    const date = new Date().toISOString().slice(0, 10);
+    const notesPath = resolve(this.memoryDir, `${date}.md`);
+
+    const agentItems = feedItems.filter(i => i.source === "openclaw" || i.text.startsWith("[🤖]") || i.text.startsWith("[🔧"));
+    const audioItems = feedItems.filter(i => i.text.startsWith("[🔊]"));
+
+    const sections = [
+      `## Session ${new Date().toISOString().slice(11, 16)} UTC (raw — distillation unavailable)`,
+      "",
+      `${feedItems.length} feed items, ${audioItems.length} audio, ${agentItems.length} agent responses`,
+      "",
+    ];
+
+    // Include agent responses (most valuable)
+    if (agentItems.length > 0) {
+      sections.push("### Agent Responses");
+      for (const item of agentItems.slice(-10)) {
+        sections.push(`- ${item.text.slice(0, 200)}`);
+      }
+      sections.push("");
+    }
+
+    // Include audio highlights (first 5 non-trivial)
+    const meaningfulAudio = audioItems.filter(i => i.text.length > 20 && !i.text.includes("Thank you") && !i.text.includes("Okay"));
+    if (meaningfulAudio.length > 0) {
+      sections.push("### Audio Highlights");
+      for (const item of meaningfulAudio.slice(0, 10)) {
+        sections.push(`- ${item.text}`);
+      }
+      sections.push("");
+    }
+
+    const content = sections.join("\n") + "\n---\n\n";
+    appendFileSync(notesPath, content, "utf-8");
+    log(TAG, `daily notes (fallback) written: ${notesPath}`);
+  }
+}

package/sinain-core/src/server.ts

@@ -12,6 +12,142 @@ import { log, error } from "./log.js";
 const TAG = "server";
 const MAX_SENSE_BODY = 2 * 1024 * 1024;
 
+const KNOWLEDGE_UI_HTML = `<!DOCTYPE html>
+<html><head>
+<meta charset="utf-8"><title>Sinain Knowledge</title>
+<style>
+  body { font-family: -apple-system, sans-serif; background: #1a1a2e; color: #e0e0e0; margin: 0; padding: 20px; }
+  h1 { color: #00ff88; font-size: 18px; }
+  h2 { color: #00cc66; font-size: 14px; margin-top: 20px; }
+  .card { background: #16213e; border-radius: 8px; padding: 12px; margin: 8px 0; border-left: 3px solid #00ff88; }
+  .card .domain { color: #00ff88; font-size: 11px; text-transform: uppercase; }
+  .card .value { margin-top: 4px; }
+  .card .meta { color: #888; font-size: 11px; margin-top: 4px; }
+  .controls { display: flex; gap: 10px; margin: 16px 0; flex-wrap: wrap; }
+  button { background: #00ff88; color: #1a1a2e; border: none; padding: 8px 16px; border-radius: 4px; cursor: pointer; font-weight: bold; }
+  button:hover { background: #00cc66; }
+  button.secondary { background: #333; color: #ccc; }
+  input, select { background: #16213e; color: #e0e0e0; border: 1px solid #333; padding: 8px; border-radius: 4px; }
+  #status { color: #00ff88; font-size: 12px; margin: 8px 0; }
+  #facts { max-height: 70vh; overflow-y: auto; }
+  .import-area { margin: 16px 0; }
+  textarea { width: 100%; height: 100px; background: #16213e; color: #e0e0e0; border: 1px solid #333; border-radius: 4px; padding: 8px; font-family: monospace; font-size: 12px; }
+</style>
+</head><body>
+<h1>Sinain Knowledge Graph</h1>
+<div class="controls">
+  <input id="search" type="text" placeholder="Search entities..." oninput="filterFacts()">
+  <select id="domainFilter" onchange="filterFacts()"><option value="">All domains</option></select>
+  <button onclick="loadFacts()">Refresh</button>
+  <button onclick="exportKnowledge()" class="secondary">Export</button>
+  <button onclick="exportDomain()" class="secondary">Export Domain</button>
+</div>
+<div id="status">Loading...</div>
+<div id="facts"></div>
+
+<h2>Import Knowledge</h2>
+<div class="import-area">
+  <textarea id="importData" placeholder="Paste exported JSON here, or enter a URL to fetch from another sinain instance..."></textarea>
+  <div class="controls">
+    <button onclick="importKnowledge()">Import</button>
+    <button onclick="importFromUrl()" class="secondary">Import from URL</button>
+  </div>
+</div>
+
+<script>
+let allFacts = [];
+
+async function loadFacts() {
+  document.getElementById('status').textContent = 'Loading...';
+  try {
+    const res = await fetch('/knowledge/entities?max=200');
+    const data = await res.json();
+    allFacts = typeof data.entities === 'string' ? JSON.parse(data.entities) : data.entities;
+    const domains = [...new Set(allFacts.map(f => f.domain).filter(Boolean))].sort();
+    const sel = document.getElementById('domainFilter');
+    sel.innerHTML = '<option value="">All domains (' + allFacts.length + ')</option>' +
+      domains.map(d => '<option value="' + d + '">' + d + ' (' + allFacts.filter(f=>f.domain===d).length + ')</option>').join('');
+    document.getElementById('status').textContent = allFacts.length + ' entities loaded';
+    filterFacts();
+  } catch (e) { document.getElementById('status').textContent = 'Error: ' + e.message; }
+}
+
+function filterFacts() {
+  const q = document.getElementById('search').value.toLowerCase();
+  const domain = document.getElementById('domainFilter').value;
+  const filtered = allFacts.filter(f => {
+    if (domain && f.domain !== domain) return false;
+    if (q) {
+      const text = JSON.stringify(f).toLowerCase();
+      return text.includes(q);
+    }
+    return true;
+  });
+  document.getElementById('facts').innerHTML = filtered.map(f =>
+    '<div class="card">' +
+    '<span class="domain">' + (f.domain||'general') + '</span>' +
+    '<div class="value">' + esc(f.entity || f.entityId || '?') + ': ' + esc(f.value||'') + '</div>' +
+    '<div class="meta">confidence: ' + (f.confidence||'?') + ' | confirmed: ' + (f.reinforce_count||1) + 'x | id: ' + esc(f.entityId||'') + '</div>' +
+    '</div>'
+  ).join('');
+  document.getElementById('status').textContent = filtered.length + ' of ' + allFacts.length + ' entities';
+}
+
+function esc(s) { return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;'); }
+
+async function exportKnowledge() {
+  window.open('/knowledge/export?max=500', '_blank');
+}
+
+async function exportDomain() {
+  const domain = document.getElementById('domainFilter').value;
+  if (!domain) { alert('Select a domain first'); return; }
+  window.open('/knowledge/export?domain=' + encodeURIComponent(domain) + '&max=500', '_blank');
+}
+
+async function importKnowledge() {
+  const el = document.getElementById('status');
+  const data = document.getElementById('importData').value.trim();
+  if (!data) { el.textContent = 'Error: paste JSON data first'; return; }
+  el.textContent = 'Importing...';
+  try {
+    JSON.parse(data); // validate JSON first
+  } catch(e) { el.textContent = 'Error: invalid JSON — ' + e.message; return; }
+  try {
+    const res = await fetch('/knowledge/import', { method: 'POST', body: data });
+    const text = await res.text();
+    console.log('Import response:', text);
+    const result = JSON.parse(text);
+    el.textContent = result.ok
+      ? 'Imported ' + (result.imported||0) + ' facts, skipped ' + (result.skipped||0)
+      : 'Error: ' + (result.error||'unknown');
+    if (result.ok) { document.getElementById('importData').value = ''; loadFacts(); }
+  } catch (e) { el.textContent = 'Import failed: ' + e.message; console.error(e); }
+}
+
+async function importFromUrl() {
+  const el = document.getElementById('status');
+  const input = document.getElementById('importData').value.trim();
+  if (!input.startsWith('http')) { el.textContent = 'Error: enter a URL starting with http'; return; }
+  el.textContent = 'Fetching from ' + input + '...';
+  try {
+    const res = await fetch(input);
+    if (!res.ok) { el.textContent = 'Fetch failed: HTTP ' + res.status; return; }
+    const data = await res.text();
+    el.textContent = 'Fetched ' + data.length + ' bytes, importing...';
+    const importRes = await fetch('/knowledge/import', { method: 'POST', body: data });
+    const result = await importRes.json();
+    el.textContent = result.ok
+      ? 'Imported ' + (result.imported||0) + ' facts from URL, skipped ' + (result.skipped||0)
+      : 'Error: ' + (result.error||'unknown');
+    if (result.ok) { document.getElementById('importData').value = ''; loadFacts(); }
+  } catch (e) { el.textContent = 'Fetch error: ' + e.message + ' (CORS may block cross-origin URLs — use export file instead)'; console.error(e); }
+}
+
+loadFacts();
+</script>
+</body></html>`;
+
 /** Server epoch — lets clients detect restarts. */
 const serverEpoch = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
 
@@ -41,6 +177,9 @@ export interface ServerDeps {
   respondEscalation?: (id: string, response: string) => any;
   getKnowledgeDocPath?: () => string | null;
   queryKnowledgeFacts?: (entities: string[], maxFacts: number) => Promise<string>;
+  listKnowledgeEntities?: (max: number) => Promise<string>;
+  exportKnowledge?: (domain: string | null, max: number) => Promise<string>;
+  importKnowledge?: (data: string) => Promise<string>;
   onSpawnCommand?: (text: string) => void;
   getSpawnPending?: () => { id: string; task: string; label: string; ts: number } | null;
   respondSpawn?: (id: string, result: string) => { ok: boolean; error?: string };
@@ -272,6 +411,64 @@ export function createAppServer(deps: ServerDeps) {
         return;
       }
 
+      if (req.method === "GET" && url.pathname === "/knowledge/entities") {
+        // List all entities in the knowledge graph
+        const max = Math.min(parseInt(url.searchParams.get("max") || "50"), 200);
+        if (deps.listKnowledgeEntities) {
+          try {
+            const entities = await deps.listKnowledgeEntities(max);
+            res.end(JSON.stringify({ ok: true, entities }));
+          } catch (err) {
+            res.end(JSON.stringify({ ok: true, entities: [], error: String(err) }));
+          }
+        } else {
+          res.end(JSON.stringify({ ok: true, entities: [] }));
+        }
+        return;
+      }
+
+      if (req.method === "GET" && url.pathname === "/knowledge/export") {
+        // Export knowledge module (filterable by domain)
+        const domain = url.searchParams.get("domain") || null;
+        const max = Math.min(parseInt(url.searchParams.get("max") || "100"), 500);
+        if (deps.exportKnowledge) {
+          try {
+            const data = await deps.exportKnowledge(domain, max);
+            res.setHeader("Content-Type", "application/json");
+            res.setHeader("Content-Disposition", `attachment; filename="sinain-knowledge-${domain || "all"}.json"`);
+            res.end(data);
+          } catch (err) {
+            res.end(JSON.stringify({ ok: false, error: String(err) }));
+          }
+        } else {
+          res.end(JSON.stringify({ ok: false, error: "export not available" }));
+        }
+        return;
+      }
+
+      if (req.method === "POST" && url.pathname === "/knowledge/import") {
+        // Import knowledge module
+        const body = await readBody(req, 1_000_000); // 1MB max
+        if (deps.importKnowledge) {
+          try {
+            const result = await deps.importKnowledge(body);
+            res.end(result);
+          } catch (err) {
+            res.end(JSON.stringify({ ok: false, error: String(err) }));
+          }
+        } else {
+          res.end(JSON.stringify({ ok: false, error: "import not available" }));
+        }
+        return;
+      }
+
+      if (req.method === "GET" && url.pathname === "/knowledge/ui") {
+        // Simple web UI for browsing and transferring knowledge
+        res.setHeader("Content-Type", "text/html");
+        res.end(KNOWLEDGE_UI_HTML);
+        return;
+      }
+
       // ── /traces ──
       if (req.method === "GET" && url.pathname === "/traces") {
         const after = parseInt(url.searchParams.get("after") || "0");

package/sinain-mcp-server/index.ts

@@ -203,19 +203,30 @@ server.tool(
 );
 
 // 8. sinain_get_knowledge
+// Queries sinain-core's /knowledge API which merges both local and workspace DBs.
+// Falls back to reading the workspace knowledge doc directly if sinain-core is unreachable.
 server.tool(
   "sinain_get_knowledge",
-  "Get the portable knowledge document (playbook + long-term facts + recent sessions)",
+  "Get the portable knowledge document (playbook + long-term facts from both local and workspace databases)",
   {},
   async () => {
+    // Try sinain-core API first (merges both DBs)
+    try {
+      const data = await coreRequest("GET", "/knowledge");
+      if (data.ok && data.content) {
+        return textResult(stripPrivateTags(data.content));
+      }
+    } catch {
+      // sinain-core unreachable — fall through to local files
+    }
+
+    // Fallback: read workspace files directly
     try {
-      // Read pre-rendered knowledge doc (fast, no subprocess)
       const docPath = resolve(MEMORY_DIR, "sinain-knowledge.md");
       if (existsSync(docPath)) {
         const content = readFileSync(docPath, "utf-8");
         return textResult(stripPrivateTags(content));
       }
-      // Fallback: read playbook directly
       const playbookPath = resolve(MEMORY_DIR, "sinain-playbook.md");
       if (existsSync(playbookPath)) {
         return textResult(stripPrivateTags(readFileSync(playbookPath, "utf-8")));
@@ -228,14 +239,33 @@ server.tool(
 );
 
 // 8b. sinain_knowledge_query (graph query — entity-based lookup)
+// Queries sinain-core's /knowledge/facts API which merges both local and workspace DBs.
+// Falls back to local graph_query.py (workspace DB only) if sinain-core is unreachable.
 server.tool(
   "sinain_knowledge_query",
-  "Query the knowledge graph for facts about specific entities/domains",
+  "Query the knowledge graph for facts about specific entities/domains (searches both local and workspace databases)",
   {
     entities: z.array(z.string()).optional().default([]),
     max_facts: z.number().optional().default(5),
   },
   async ({ entities, max_facts }) => {
+    // Try sinain-core API first (merges both local + workspace DBs)
+    if (entities.length > 0) {
+      try {
+        const params = new URLSearchParams({
+          entities: entities.join(","),
+          max: String(max_facts),
+        });
+        const data = await coreRequest("GET", `/knowledge/facts?${params}`);
+        if (data.ok && data.facts) {
+          return textResult(stripPrivateTags(data.facts));
+        }
+      } catch {
+        // sinain-core unreachable — fall through to local script
+      }
+    }
+
+    // Fallback: query workspace DB directly via graph_query.py
     try {
       const dbPath = resolve(MEMORY_DIR, "knowledge-graph.db");
       const scriptPath = resolve(SCRIPTS_DIR, "graph_query.py");

package/sinain-memory/eval/retrieval_benchmark.jsonl

@@ -0,0 +1,12 @@
+{"query": "OCR pipeline stalls on macOS 14", "expected_entities": ["fact:ocr-backpressure", "fact:sck-capture"], "category": "error-resolution"}
+{"query": "camera conflicts with screen capture", "expected_entities": ["fact:camera-conflict", "fact:coremediaio"], "category": "error-resolution"}
+{"query": "audio gain not applied in pipeline", "expected_entities": ["fact:audio-gain"], "category": "bug-fix"}
+{"query": "Flutter ProviderNotFoundException in secondary window", "expected_entities": ["fact:flutter-provider", "fact:multi-window"], "category": "error-resolution"}
+{"query": "user prefers concise Telegram messages", "expected_entities": ["fact:telegram-preference"], "category": "user-preference"}
+{"query": "PyObjC performRequests_error_ returns bool not tuple", "expected_entities": ["fact:pyobjc-api"], "category": "bug-fix"}
+{"query": "ScreenCaptureKit zero-copy IOSurface", "expected_entities": ["fact:sck-capture", "fact:iosurface"], "category": "tool-knowledge"}
+{"query": "OpenClaw gateway workspace not initialized", "expected_entities": ["fact:workspace-init"], "category": "error-resolution"}
+{"query": "react-native metro bundler cache invalidation", "expected_entities": ["fact:react-native-metro"], "category": "tool-knowledge"}
+{"query": "sinain agent session key format", "expected_entities": ["fact:session-key"], "category": "tool-knowledge"}
+{"query": "what was the OCR backend last month", "expected_entities": ["fact:ocr-backend"], "category": "temporal"}
+{"query": "when did we switch from CGDisplayCreateImage to ScreenCaptureKit", "expected_entities": ["fact:sck-capture", "fact:cgdisplay-deprecation"], "category": "temporal"}