metame-cli 1.6.0 → 1.6.1

package/scripts/daemon-wiki.js

@@ -17,7 +17,7 @@
 
 const os = require('os');
 const path = require('path');
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 
 const {
   listWikiPages,
@@ -80,6 +80,11 @@ function createWikiCommandHandler(deps) {
       await _handleHelp(bot, chatId);
       return true;
     }
+    if (trimmed === '/wiki import' || trimmed.startsWith('/wiki import ')) {
+      const args = trimmed.slice(12).trim();
+      await _handleImport(bot, chatId, args);
+      return true;
+    }
     // Unknown /wiki subcommand — show help
     if (trimmed.startsWith('/wiki ')) {
       await _handleHelp(bot, chatId);
@@ -123,7 +128,14 @@ function createWikiCommandHandler(deps) {
     }
 
     const db = getDb();
-    const { wikiPages, facts } = searchWikiAndFacts(db, query, { trackSearch: true });
+    let wikiPages, facts;
+    try {
+      const { hybridSearchWiki } = require('./core/hybrid-search');
+      ({ wikiPages, facts } = await hybridSearchWiki(db, query, { trackSearch: true }));
+    } catch (err) {
+      log('WARN', `[wiki-research] hybrid search fallback to FTS: ${err.message}`);
+      ({ wikiPages, facts } = searchWikiAndFacts(db, query, { trackSearch: true }));
+    }
 
     if (wikiPages.length === 0 && facts.length === 0) {
       await bot.sendMessage(chatId,
@@ -206,6 +218,13 @@ function createWikiCommandHandler(deps) {
       const lines = ['✅ Wiki 重建完成'];
       if (result.built.length > 0) {
         lines.push(`• 重建: ${result.built.join(', ')}`);
+        try {
+          const { execFile } = require('child_process');
+          const embScript = path.join(os.homedir(), '.metame', 'daemon-embedding.js');
+          execFile('node', [embScript], { timeout: 120000, stdio: 'ignore' }, (err) => {
+            if (err) log('WARN', `[wiki-sync] embedding trigger failed: ${err.message}`);
+          });
+        } catch { }
       }
       if (result.failed.length > 0) {
         lines.push(`• 失败: ${result.failed.map(f => f.slug).join(', ')}`);
@@ -214,6 +233,68 @@ function createWikiCommandHandler(deps) {
         lines.push(`• 文件导出失败 (DB 已更新): ${result.exportFailed.join(', ')}`);
       }
       await bot.sendMessage(chatId, lines.join('\n'));
+
+      // Phased doc + cluster rebuild (wiki-import feature extension)
+      const { listStaleDocSources } = require('./core/wiki-db');
+      const { buildDocWikiPage } = require('./wiki-reflect-build');
+      const { extractText } = require('./wiki-extract');
+      const allDocSlugsForSync = db.prepare("SELECT slug FROM doc_sources WHERE status='active'").all().map(r => r.slug);
+      const staleDocSources = listStaleDocSources(db);
+      const builtDocSlugs = [];
+      for (const docSrc of staleDocSources) {
+        try {
+          const { text } = await extractText(docSrc.file_path);
+          const docResult = await buildDocWikiPage(db, docSrc, text, { allowedSlugs: allDocSlugsForSync, providers });
+          if (docResult) {
+            db.prepare("UPDATE doc_sources SET content_stale=0, built_at=? WHERE id=?")
+              .run(new Date().toISOString(), docSrc.id);
+            builtDocSlugs.push(docSrc.slug);
+          }
+        } catch (docErr) {
+          db.prepare("UPDATE doc_sources SET error_message=? WHERE id=?").run(docErr.message, docSrc.id);
+          log('WARN', `[wiki-sync] doc rebuild failed ${docSrc.slug}: ${docErr.message}`);
+        }
+      }
+      // Cascade stale cluster pages
+      if (builtDocSlugs.length > 0) {
+        const ph = builtDocSlugs.map(() => '?').join(',');
+        const affected = db.prepare(`SELECT DISTINCT page_slug FROM wiki_page_doc_sources
+          WHERE role='cluster_member' AND doc_source_id IN
+          (SELECT id FROM doc_sources WHERE slug IN (${ph}))`).all(...builtDocSlugs).map(r => r.page_slug);
+        if (affected.length) {
+          db.prepare(`UPDATE wiki_pages SET staleness=1 WHERE slug IN (${affected.map(() => '?').join(',')})`).run(...affected);
+        }
+      }
+      // Rebuild stale cluster pages after embedding drain
+      const { waitForEmbeddingDrain } = require('./wiki-import');
+      const phase1ChunkIds = builtDocSlugs.flatMap(slug =>
+        db.prepare("SELECT id FROM content_chunks WHERE page_slug=?").all(slug).map(c => c.id)
+      );
+      const drainedOk = await waitForEmbeddingDrain(db, phase1ChunkIds, (msg) => log('INFO', msg));
+      if (drainedOk) {
+        const { buildTopicClusterPage } = require('./wiki-reflect-build');
+        const { getClusterMemberIds } = require('./core/wiki-db');
+        const staleClusterPages = db.prepare("SELECT * FROM wiki_pages WHERE source_type='topic_cluster' AND staleness=1").all();
+        for (const cp of staleClusterPages) {
+          const memberIds = getClusterMemberIds(db, cp.slug);
+          const getDocSrcById = db.prepare("SELECT * FROM doc_sources WHERE id=?");
+          const docRows = memberIds.map(id => getDocSrcById.get(id)).filter(Boolean);
+          try {
+            await buildTopicClusterPage(db, docRows, { allowedSlugs: allDocSlugsForSync, providers, existingClusters: [] });
+          } catch (clErr) {
+            log('WARN', `[wiki-sync] cluster rebuild failed ${cp.slug}: ${clErr.message}`);
+          }
+        }
+      }
+      if (staleDocSources.length > 0) {
+        const docMsg = [];
+        if (builtDocSlugs.length > 0) docMsg.push(`• 文档页面重建: ${builtDocSlugs.join(', ')}`);
+        const docFailed = staleDocSources.length - builtDocSlugs.length;
+        if (docFailed > 0) docMsg.push(`• 文档重建失败: ${docFailed} 个（见日志）`);
+        if (docMsg.length > 0) {
+          await bot.sendMessage(chatId, `📄 文档页面同步\n\n${docMsg.join('\n')}`);
+        }
+      }
     } catch (err) {
       log('ERROR', `[wiki-sync] ${err.message}`);
       if (err.message.includes('another instance')) {
@@ -263,10 +344,10 @@ function createWikiCommandHandler(deps) {
       // Try Obsidian URI first (opens vault by path if already configured)
       const vaultName = path.basename(outputDir);
       try {
-        execSync(`open "obsidian://open?vault=${encodeURIComponent(vaultName)}"`, { timeout: 5000 });
+        execFileSync('open', [`obsidian://open?vault=${encodeURIComponent(vaultName)}`], { timeout: 5000 });
       } catch {
         // Fallback: open folder in Finder — user can then drag into Obsidian
-        execSync(`open "${outputDir}"`, { timeout: 5000 });
+        execFileSync('open', [outputDir], { timeout: 5000 });
       }
       await bot.sendMessage(chatId,
         `📂 已打开 Obsidian vault: \`${outputDir}\`\n\n` +
@@ -279,6 +360,46 @@ function createWikiCommandHandler(deps) {
     }
   }
 
+  async function _handleImport(bot, chatId, args) {
+    const noCluster = args.includes('--no-cluster');
+    const inputPath = args.replace('--no-cluster', '').trim();
+
+    if (!inputPath) {
+      await bot.sendMessage(chatId, '用法: `/wiki import <路径或文件>` [--no-cluster]\n\n示例:\n`/wiki import ~/Documents/notes`\n`/wiki import ~/report.pdf`');
+      return;
+    }
+
+    const resolvedPath = inputPath.replace(/^~/, require('node:os').homedir());
+
+    let stat;
+    try { stat = require('node:fs').statSync(resolvedPath); }
+    catch { await bot.sendMessage(chatId, `❌ 路径不存在: ${resolvedPath}`); return; }
+
+    const isDir = stat.isDirectory();
+    await bot.sendMessage(chatId, `⏳ 开始导入 ${isDir ? '目录' : '文件'}: \`${resolvedPath}\`\n${noCluster ? '（跳过聚类）' : '（含自动聚类）'}`);
+
+    const { runWikiImport } = require('./wiki-import');
+    const db = getDb();
+    const logFn = (msg) => { log('INFO', msg); };
+
+    try {
+      const stats = await runWikiImport(db, resolvedPath, {
+        providers, noCluster, log: logFn,
+      });
+      await bot.sendMessage(chatId,
+        `✅ 导入完成\n\n` +
+        `- 新建/更新页面: ${stats.imported}\n` +
+        `- 跳过 (未变更): ${stats.skipped}\n` +
+        `- 失败: ${stats.failed}\n` +
+        `- 聚类页面: ${stats.clusters}\n\n` +
+        `使用 \`/wiki\` 查看全部页面`
+      );
+    } catch (err) {
+      log('ERROR', `[wiki-import] ${err.message}`);
+      await bot.sendMessage(chatId, `❌ 导入失败: ${err.message}`);
+    }
+  }
+
   async function _handleHelp(bot, chatId) {
     await bot.sendMessage(chatId, [
       '📚 **Wiki 命令**',
@@ -287,6 +408,7 @@ function createWikiCommandHandler(deps) {
       '`/wiki research <关键词>` — 搜索知识',
       '`/wiki page <slug>` — 查看页面全文',
       '`/wiki sync` — 重建陈旧页面',
+      '`/wiki import <路径>` — 导入本地文档 (md/txt/PDF)',
       '`/wiki pin <标签> [标题]` — 手工注册主题',
       '`/wiki open` — 在 Obsidian 中打开 vault',
     ].join('\n'));

package/scripts/daemon.js

@@ -2387,7 +2387,7 @@ async function main() {
   }
 
   // Config validation: warn on unknown/suspect fields
-  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'weixin', 'heartbeat', 'budget', 'projects', 'imessage', 'siri_bridge'];
+  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'weixin', 'heartbeat', 'budget', 'projects', 'imessage', 'siri_bridge', 'hooks'];
   const KNOWN_DAEMON = [
     'model',          // legacy (still valid as fallback)
     'models',         // per-engine model map: { claude, codex }
@@ -2402,6 +2402,8 @@ async function main() {
     'mac_control_mode',
     'enable_nl_mac_control',
     'enable_nl_mac_fallback',
+    'wiki_output_dir',       // wiki export path (used by daemon-command-router)
+    'skill_evolution_notify', // whether to notify on skill evolution (used by daemon-task-scheduler)
   ];
   for (const key of Object.keys(config)) {
     if (!KNOWN_SECTIONS.includes(key)) log('WARN', `Config: unknown section "${key}" (typo?)`);
@@ -2510,7 +2512,7 @@ async function main() {
   };
 
   // Start heartbeat scheduler
-  let heartbeatTimer = startHeartbeat(config, notifyFn, notifyPersonalFn);
+  let heartbeatTimer = startHeartbeat(config, notifyFn, notifyPersonalFn, adminNotifyFn);
 
   let shuttingDown = false;
   function spawnReplacementDaemon(reason) {

package/scripts/feishu-adapter.js

@@ -393,11 +393,14 @@ function createBot(config) {
       let stopped = false;
       let currentWs = null;
       let healthTimer = null;
+      let sleepWakeTimer = null;
       let reconnectTimer = null;
       let reconnectDelay = 5000; // start 5s, doubles up to 60s
       const MAX_RECONNECT_DELAY = 60000;
       const HEALTH_CHECK_INTERVAL = 90000; // check every 90s
       const SILENT_THRESHOLD = 300000; // 5 min no SDK activity → suspect dead
+      const SLEEP_DETECT_INTERVAL = 5000; // tick every 5s to detect clock jump
+      const SLEEP_JUMP_THRESHOLD = 30000; // clock jump >30s = system was sleeping
 
       // Track last SDK activity (any event received = alive)
       let _lastActivityAt = Date.now();
@@ -538,15 +541,37 @@ function createBot(config) {
         }, HEALTH_CHECK_INTERVAL);
       }
 
+      // Sleep/wake detector: if the JS clock jumps >30s, system was sleeping → force reconnect
+      function startSleepWakeDetector() {
+        let _lastTickAt = Date.now();
+        sleepWakeTimer = setInterval(() => {
+          if (stopped) return;
+          const now = Date.now();
+          const elapsed = now - _lastTickAt;
+          _lastTickAt = now;
+          if (elapsed > SLEEP_JUMP_THRESHOLD) {
+            _log('INFO', `System wake detected (${Math.round(elapsed / 1000)}s gap) — forcing reconnect`);
+            reconnectDelay = 5000;
+            clearTimeout(reconnectTimer);
+            try { currentWs?.stop?.(); } catch { /* ignore */ }
+            currentWs = null;
+            touchActivity(); // reset silence counter so health check doesn't double-fire
+            connect();
+          }
+        }, SLEEP_DETECT_INTERVAL);
+      }
+
       // Initial connect
       connect();
       startHealthCheck();
+      startSleepWakeDetector();
 
       return Promise.resolve({
         stop() {
           stopped = true;
           clearTimeout(reconnectTimer);
           clearInterval(healthTimer);
+          clearInterval(sleepWakeTimer);
           currentWs = null;
         },
         reconnect() {

package/scripts/memory-backfill-chunks.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+'use strict';
+
+/**
+ * memory-backfill-chunks.js — One-time backfill for existing wiki pages
+ *
+ * For each wiki page that has content but no content_chunks rows:
+ * 1. Splits content into chunks via recursive chunker
+ * 2. Inserts chunk rows
+ * 3. Enqueues each chunk for embedding generation
+ *
+ * Idempotent: pages with existing chunks are skipped.
+ *
+ * Usage: node scripts/memory-backfill-chunks.js
+ */
+
+const path = require('path');
+const os = require('os');
+
+const DB_PATH = path.join(os.homedir(), '.metame', 'memory.db');
+
+function main() {
+  const { DatabaseSync } = require('node:sqlite');
+  const db = new DatabaseSync(DB_PATH);
+  db.exec('PRAGMA journal_mode = WAL');
+  db.exec('PRAGMA busy_timeout = 3000');
+
+  // Ensure schema is up to date
+  try {
+    const { applyWikiSchema } = require('./memory-wiki-schema');
+    applyWikiSchema(db);
+  } catch (err) {
+    process.stderr.write(`Schema init failed: ${err.message}\n`);
+    db.close();
+    process.exit(1);
+  }
+
+  const { chunkText } = require('./core/chunker');
+
+  // Find pages without chunks
+  const pages = db.prepare(`
+    SELECT wp.slug, wp.content
+    FROM wiki_pages wp
+    WHERE wp.content IS NOT NULL
+      AND wp.content != ''
+      AND NOT EXISTS (
+        SELECT 1 FROM content_chunks cc WHERE cc.page_slug = wp.slug
+      )
+  `).all();
+
+  if (pages.length === 0) {
+    console.log('All wiki pages already have chunks. Nothing to backfill.');
+    db.close();
+    return;
+  }
+
+  console.log(`Backfilling ${pages.length} wiki pages...`);
+
+  const insertChunk = db.prepare(
+    'INSERT INTO content_chunks (id, page_slug, chunk_text, chunk_idx) VALUES (?, ?, ?, ?)',
+  );
+  const enqueue = db.prepare(
+    "INSERT INTO embedding_queue (item_type, item_id) VALUES ('chunk', ?)",
+  );
+
+  let totalChunks = 0;
+
+  db.prepare('BEGIN').run();
+  try {
+    for (const page of pages) {
+      const chunks = chunkText(page.content, { targetWords: 300 });
+      for (let i = 0; i < chunks.length; i++) {
+        const chunkId = `ck_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        insertChunk.run(chunkId, page.slug, chunks[i], i);
+        enqueue.run(chunkId);
+        totalChunks++;
+      }
+    }
+    db.prepare('COMMIT').run();
+  } catch (err) {
+    try { db.prepare('ROLLBACK').run(); } catch { }
+    process.stderr.write(`Backfill failed: ${err.message}\n`);
+    db.close();
+    process.exit(1);
+  }
+
+  console.log(`Done. Created ${totalChunks} chunks for ${pages.length} pages. Run daemon-embedding.js to generate embeddings.`);
+  db.close();
+}
+
+main();

package/scripts/memory-search.js

@@ -3,14 +3,15 @@
  * memory-search.js — Cross-session memory recall CLI
  *
  * Usage:
- *   node memory-search.js "<query>"                # hybrid search (QMD + FTS5)
+ *   node memory-search.js "<query>"                # hybrid search (FTS5 + vector + RRF)
  *   node memory-search.js "<q1>" "<q2>" "<q3>"     # multi-keyword parallel search
  *   node memory-search.js --facts "<query>"         # search facts only
  *   node memory-search.js --sessions "<query>"      # search sessions only
+ *   node memory-search.js --fts-only "<query>"      # force pure FTS5 (no vector)
  *   node memory-search.js --recent                  # show recent sessions
  *
  * Multi-keyword: results are deduplicated by fact ID, best rank wins.
- * Async: uses QMD hybrid search (BM25 + vector) when available, falls back to FTS5.
+ * Hybrid: uses FTS5 + vector embeddings + RRF fusion when available, falls back to FTS5.
  */
 
 'use strict';
@@ -31,8 +32,20 @@ if (!memoryPath) {
 const memory = require(memoryPath);
 
 const args = process.argv.slice(2);
-const mode = args[0] && args[0].startsWith('--') ? args[0] : null;
-const queries = mode ? args.slice(1) : args;
+// Parse flags: allow multiple -- flags before queries
+const flags = new Set();
+let firstQueryIdx = 0;
+for (let i = 0; i < args.length; i++) {
+  if (args[i].startsWith('--')) { flags.add(args[i]); firstQueryIdx = i + 1; }
+  else break;
+}
+const mode = flags.has('--facts') ? '--facts'
+  : flags.has('--sessions') ? '--sessions'
+  : flags.has('--recent') ? '--recent'
+  : flags.has('--fts-only') ? '--fts-only'
+  : null;
+const ftsOnly = flags.has('--fts-only');
+const queries = args.slice(firstQueryIdx);
 
 async function main() {
   try {
@@ -79,20 +92,35 @@ async function main() {
       limit: 3,
     });
 
-    // Wiki pages (if available)
+    // Wiki pages — hybrid search (FTS5 + vector + RRF) when available
     let wikiResults = [];
-    if (typeof memory.searchWikiAndFacts === 'function') {
-      try {
-        const allWiki = [];
-        for (const q of queries) {
-          const { wikiPages } = memory.searchWikiAndFacts(q, { trackSearch: true });
-          for (const p of (wikiPages || [])) {
-            allWiki.push({ type: 'wiki', slug: p.slug, title: p.title, excerpt: p.excerpt, last_built_at: p.last_built_at });
+    const useHybrid = typeof memory.hybridSearchWiki === 'function';
+    try {
+      const allWiki = [];
+      const seen = new Set();
+      for (const q of queries) {
+        const { wikiPages } = useHybrid
+          ? await memory.hybridSearchWiki(q, { ftsOnly, trackSearch: true })
+          : (typeof memory.searchWikiAndFacts === 'function'
+            ? memory.searchWikiAndFacts(q, { trackSearch: true })
+            : { wikiPages: [] });
+        for (const p of (wikiPages || [])) {
+          if (!seen.has(p.slug)) {
+            seen.add(p.slug);
+            allWiki.push({
+              type: 'wiki',
+              slug: p.slug,
+              title: p.title,
+              excerpt: p.excerpt,
+              score: p.score,
+              stale: p.stale,
+              source: p.source,
+            });
           }
         }
-        wikiResults = allWiki.slice(0, 5);
-      } catch { /* wiki not available */ }
-    }
+      }
+      wikiResults = allWiki.slice(0, 5);
+    } catch { /* wiki not available */ }
 
     console.log(JSON.stringify([...wikiResults, ...factResults, ...sessionResults], null, 2));
 

package/scripts/memory-wiki-schema.js

@@ -11,6 +11,8 @@
  *   wiki_pages       — topic knowledge pages
  *   wiki_topics      — controlled topic registry
  *   wiki_pages_fts   — FTS5 virtual table (content table, trigram tokenizer)
+ *   content_chunks   — chunked page content with optional vector embeddings
+ *   embedding_queue  — durable async queue for embedding generation
  *
  * Triggers:
  *   wiki_pages_fts_insert / wiki_pages_fts_update / wiki_pages_fts_delete
@@ -42,6 +44,9 @@ function applyWikiSchema(db) {
     )
   `);
 
+  // Migration: add timeline column for Compiled Truth + Timeline model (existing DBs)
+  try { db.exec("ALTER TABLE wiki_pages ADD COLUMN timeline TEXT DEFAULT ''"); } catch { /* column already exists */ }
+
   // ── wiki_topics ─────────────────────────────────────────────────────────────
   db.exec(`
     CREATE TABLE IF NOT EXISTS wiki_topics (
@@ -74,9 +79,14 @@ function applyWikiSchema(db) {
     END
   `);
 
+  // DROP+CREATE to upgrade existing unguarded trigger on deployed DBs
+  db.exec('DROP TRIGGER IF EXISTS wiki_pages_fts_update');
   db.exec(`
-    CREATE TRIGGER IF NOT EXISTS wiki_pages_fts_update
-      AFTER UPDATE ON wiki_pages BEGIN
+    CREATE TRIGGER wiki_pages_fts_update
+      AFTER UPDATE ON wiki_pages
+      WHEN old.slug IS NOT new.slug OR old.title IS NOT new.title
+        OR old.content IS NOT new.content OR old.topic_tags IS NOT new.topic_tags
+    BEGIN
       INSERT INTO wiki_pages_fts(wiki_pages_fts, rowid, slug, title, content, topic_tags)
         VALUES ('delete', old.rowid, old.slug, old.title, old.content, old.topic_tags);
       INSERT INTO wiki_pages_fts(rowid, slug, title, content, topic_tags)
@@ -91,6 +101,155 @@ function applyWikiSchema(db) {
         VALUES ('delete', old.rowid, old.slug, old.title, old.content, old.topic_tags);
     END
   `);
+
+  // ── content_chunks (vector embedding storage for wiki pages) ────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS content_chunks (
+      id              TEXT PRIMARY KEY,
+      page_slug       TEXT NOT NULL,
+      chunk_text      TEXT NOT NULL,
+      chunk_idx       INTEGER NOT NULL,
+      embedding       BLOB,
+      embedding_model TEXT,
+      embedding_dim   INTEGER,
+      created_at      TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  try { db.exec('CREATE INDEX IF NOT EXISTS idx_chunks_slug ON content_chunks(page_slug)'); } catch { }
+
+  // ── embedding_queue (durable async queue for embedding generation) ──────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS embedding_queue (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      item_type   TEXT NOT NULL,
+      item_id     TEXT NOT NULL,
+      model       TEXT DEFAULT 'text-embedding-3-small',
+      attempts    INTEGER DEFAULT 0,
+      last_error  TEXT,
+      created_at  TEXT DEFAULT (datetime('now'))
+    )
+  `);
+
+  // ── doc_sources ───────────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS doc_sources (
+      id                  INTEGER PRIMARY KEY,
+      file_path           TEXT UNIQUE NOT NULL,
+      file_hash           TEXT NOT NULL,
+      mtime_ms            INTEGER,
+      size_bytes          INTEGER,
+      extracted_text_hash TEXT,
+      file_type           TEXT NOT NULL CHECK (file_type IN ('md','txt','pdf')),
+      extractor           TEXT,
+      extract_status      TEXT DEFAULT 'pending'
+                          CHECK (extract_status IN ('ok','empty_or_scanned','error','pending')),
+      title               TEXT,
+      slug                TEXT UNIQUE NOT NULL,
+      status              TEXT DEFAULT 'active'
+                          CHECK (status IN ('active','orphaned','missing')),
+      error_message       TEXT,
+      indexed_at          TEXT NOT NULL,
+      last_seen_at        TEXT,
+      built_at            TEXT,
+      content_stale       INTEGER DEFAULT 1
+    )
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_doc_sources_status        ON doc_sources(status)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_doc_sources_file_hash     ON doc_sources(file_hash)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_doc_sources_slug          ON doc_sources(slug)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_doc_sources_content_stale ON doc_sources(content_stale)`);
+
+  // ── wiki_page_doc_sources ─────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS wiki_page_doc_sources (
+      page_slug     TEXT NOT NULL,
+      doc_source_id INTEGER NOT NULL,
+      role          TEXT NOT NULL CHECK (role IN ('primary','cluster_member')),
+      PRIMARY KEY (page_slug, doc_source_id, role),
+      FOREIGN KEY (page_slug)     REFERENCES wiki_pages(slug)  ON DELETE CASCADE,
+      FOREIGN KEY (doc_source_id) REFERENCES doc_sources(id)   ON DELETE CASCADE
+    )
+  `);
+
+  // ── wiki_pages additions (idempotent ALTER) ───────────────────────────────
+  for (const [col, def] of [
+    ['source_type',    "TEXT DEFAULT 'memory'"],
+    ['membership_hash','TEXT'],
+    ['cluster_size',   'INTEGER'],
+  ]) {
+    try { db.exec(`ALTER TABLE wiki_pages ADD COLUMN ${col} ${def}`); } catch { /* already exists */ }
+  }
+  db.exec("UPDATE wiki_pages SET source_type = 'memory' WHERE source_type IS NULL");
+
+  // ── doc_sources additions (idempotent ALTER) ──────────────────────────────
+  for (const [col, def] of [
+    ['doi',            'TEXT'],
+    ['year',           'INTEGER'],
+    ['venue',          'TEXT'],
+    ['zotero_key',     'TEXT'],
+    ['citation_count', 'INTEGER'],
+  ]) {
+    try { db.exec(`ALTER TABLE doc_sources ADD COLUMN ${col} ${def}`); } catch { /* already exists */ }
+  }
+
+  // ── paper_facts ───────────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS paper_facts (
+      id                TEXT PRIMARY KEY,
+      doc_source_id     INTEGER NOT NULL,
+      fact_type         TEXT NOT NULL CHECK (fact_type IN (
+                          'problem','method','claim','assumption',
+                          'dataset','metric','result','baseline',
+                          'limitation','future_work','contradiction_note'
+                        )),
+      subject           TEXT,
+      predicate         TEXT,
+      object            TEXT,
+      value             TEXT,
+      unit              TEXT,
+      context           TEXT,
+      evidence_text     TEXT NOT NULL,
+      section           TEXT,
+      extraction_source TEXT DEFAULT 'pdf_llm_section'
+                        CHECK (extraction_source IN (
+                          'pdf_llm_section',
+                          'zotero_deep_read',
+                          'manual'
+                        )),
+      confidence        REAL DEFAULT 0.7,
+      created_at        TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (doc_source_id) REFERENCES doc_sources(id) ON DELETE CASCADE
+    )
+  `);
+  db.exec('CREATE INDEX IF NOT EXISTS idx_paper_facts_doc     ON paper_facts(doc_source_id)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_paper_facts_type    ON paper_facts(fact_type)');
+  db.exec('CREATE INDEX IF NOT EXISTS idx_paper_facts_subject ON paper_facts(subject)');
+
+  // ── research_entities ─────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS research_entities (
+      id          TEXT PRIMARY KEY,
+      entity_type TEXT NOT NULL CHECK (entity_type IN (
+                    'problem','concept','method_family','dataset','metric','application'
+                  )),
+      name        TEXT NOT NULL UNIQUE,
+      aliases     TEXT DEFAULT '[]',
+      description TEXT,
+      created_at  TEXT DEFAULT (datetime('now'))
+    )
+  `);
+
+  // ── fact_entity_links ─────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS fact_entity_links (
+      fact_id   TEXT NOT NULL,
+      entity_id TEXT NOT NULL,
+      role      TEXT,
+      PRIMARY KEY (fact_id, entity_id),
+      FOREIGN KEY (fact_id)   REFERENCES paper_facts(id)       ON DELETE CASCADE,
+      FOREIGN KEY (entity_id) REFERENCES research_entities(id) ON DELETE CASCADE
+    )
+  `);
 }
 
 module.exports = { applyWikiSchema };

package/scripts/memory.js

@@ -47,6 +47,7 @@ function getDb() {
 
   _db.exec('PRAGMA journal_mode = WAL');
   _db.exec('PRAGMA busy_timeout = 3000');
+  _db.exec('PRAGMA foreign_keys = ON');
 
   _db.exec(`
     CREATE TABLE IF NOT EXISTS memory_items (
@@ -547,6 +548,19 @@ function searchWikiAndFacts(query, { trackSearch = true } = {}) {
   }
 }
 
+/**
+ * Hybrid wiki search (FTS5 + vector + RRF fusion).
+ * Falls back to pure FTS5 if hybrid-search module is unavailable.
+ */
+async function hybridSearchWiki(query, { ftsOnly = false, expand = false, trackSearch = true } = {}) {
+  try {
+    const { hybridSearchWiki: fn } = require('./core/hybrid-search');
+    return await fn(getDb(), query, { ftsOnly, trackSearch });
+  } catch {
+    return searchWikiAndFacts(query, { trackSearch });
+  }
+}
+
 module.exports = {
   // core
   saveMemoryItem,
@@ -558,6 +572,7 @@ module.exports = {
   assembleContext,
   // wiki
   searchWikiAndFacts,
+  hybridSearchWiki,
   // compatibility
   saveSession,
   saveFacts,