metame-cli 1.5.26 → 1.6.1

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 {
@@ -66,7 +79,7 @@ async function main() {
       return;
     }
 
-    // Default: search both facts and sessions, all queries in parallel
+    // Default: search facts, sessions, and wiki pages in parallel
     const factResults = await searchMulti(queries, {
       searchFn: q => useAsync ? memory.searchFactsAsync(q, { limit: 5 }) : Promise.resolve(memory.searchFacts(q, { limit: 5 })),
       type: 'fact',
@@ -79,7 +92,37 @@ async function main() {
       limit: 3,
     });
 
-    console.log(JSON.stringify([...factResults, ...sessionResults], null, 2));
+    // Wiki pages — hybrid search (FTS5 + vector + RRF) when available
+    let wikiResults = [];
+    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 */ }
+
+    console.log(JSON.stringify([...wikiResults, ...factResults, ...sessionResults], null, 2));
 
   } catch (e) {
     console.log('[]');

package/scripts/memory-wiki-schema.js

@@ -0,0 +1,255 @@
+'use strict';
+
+/**
+ * memory-wiki-schema.js — Wiki DB schema initializer
+ *
+ * Exports:
+ *   applyWikiSchema(db) — accepts a DatabaseSync instance, applies all DDL
+ *                         (IF NOT EXISTS, idempotent — safe to call multiple times)
+ *
+ * Tables:
+ *   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
+ */
+
+/**
+ * Apply wiki schema to a DatabaseSync instance.
+ * @param {import('node:sqlite').DatabaseSync} db
+ */
+function applyWikiSchema(db) {
+  // ── wiki_pages ──────────────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS wiki_pages (
+      id                    TEXT PRIMARY KEY,
+      slug                  TEXT UNIQUE NOT NULL,
+      title                 TEXT NOT NULL,
+      content               TEXT NOT NULL,
+      primary_topic         TEXT NOT NULL,
+      topic_tags            TEXT DEFAULT '[]',
+      raw_source_ids        TEXT DEFAULT '[]',
+      capsule_refs          TEXT DEFAULT '[]',
+      staleness             REAL DEFAULT 0.0,
+      raw_source_count      INTEGER DEFAULT 0,
+      new_facts_since_build INTEGER DEFAULT 0,
+      word_count            INTEGER DEFAULT 0,
+      last_built_at         TEXT,
+      created_at            TEXT DEFAULT (datetime('now')),
+      updated_at            TEXT DEFAULT (datetime('now'))
+    )
+  `);
+
+  // 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 (
+      tag        TEXT PRIMARY KEY,
+      slug       TEXT UNIQUE NOT NULL,
+      label      TEXT NOT NULL,
+      pinned     INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+
+  // ── wiki_pages_fts (FTS5 content table) ─────────────────────────────────────
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS wiki_pages_fts USING fts5(
+        slug, title, content, topic_tags,
+        content='wiki_pages',
+        content_rowid='rowid',
+        tokenize='trigram'
+      )
+    `);
+  } catch { /* already exists */ }
+
+  // ── FTS5 sync triggers ───────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS wiki_pages_fts_insert
+      AFTER INSERT ON wiki_pages BEGIN
+      INSERT INTO wiki_pages_fts(rowid, slug, title, content, topic_tags)
+        VALUES (new.rowid, new.slug, new.title, new.content, new.topic_tags);
+    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 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)
+        VALUES (new.rowid, new.slug, new.title, new.content, new.topic_tags);
+    END
+  `);
+
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS wiki_pages_fts_delete
+      AFTER DELETE ON wiki_pages 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);
+    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 (
@@ -108,6 +109,18 @@ function getDb() {
   try { _db.exec('CREATE INDEX IF NOT EXISTS idx_mi_scope ON memory_items(scope)'); } catch { }
   try { _db.exec('CREATE INDEX IF NOT EXISTS idx_mi_supersedes ON memory_items(supersedes_id)'); } catch { }
 
+  // Migration: add relation column if not present (existing DBs)
+  try { _db.exec('ALTER TABLE memory_items ADD COLUMN relation TEXT'); } catch { /* column already exists */ }
+  try { _db.exec('CREATE INDEX IF NOT EXISTS idx_mi_relation ON memory_items(relation)'); } catch { }
+
+  // Apply wiki schema after memory_items is fully initialized (idempotent, non-fatal)
+  try {
+    const { applyWikiSchema } = require('./memory-wiki-schema');
+    applyWikiSchema(_db);
+  } catch (err) {
+    process.stderr.write(`[memory] wiki schema init failed: ${err.message}\n`);
+  }
+
   return _db;
 }
 
@@ -128,16 +141,16 @@ function saveMemoryItem(item) {
   const stmt = db.prepare(`
     INSERT INTO memory_items (id, kind, state, title, content, summary, confidence,
       project, scope, task_key, session_id, agent_key, supersedes_id,
-      source_type, source_id, search_count, last_searched_at, tags,
+      source_type, source_id, relation, search_count, last_searched_at, tags,
       created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
     ON CONFLICT(id) DO UPDATE SET
       kind=excluded.kind, state=excluded.state, title=excluded.title,
       content=excluded.content, summary=excluded.summary, confidence=excluded.confidence,
       project=excluded.project, scope=excluded.scope, task_key=excluded.task_key,
       session_id=excluded.session_id, agent_key=excluded.agent_key,
       supersedes_id=excluded.supersedes_id, source_type=excluded.source_type,
-      source_id=excluded.source_id, tags=excluded.tags,
+      source_id=excluded.source_id, relation=excluded.relation, tags=excluded.tags,
       updated_at=datetime('now')
   `);
   stmt.run(
@@ -156,6 +169,7 @@ function saveMemoryItem(item) {
     item.supersedes_id || null,
     item.source_type || null,
     item.source_id || null,
+    item.relation || null,
     item.search_count || 0,
     item.last_searched_at || null,
     typeof item.tags === 'string' ? item.tags : JSON.stringify(Array.isArray(item.tags) ? item.tags : []),
@@ -350,6 +364,7 @@ function saveFacts(sessionId, project, facts, { scope = null, source_type = null
         session_id: sessionId,
         source_type: f.source_type || source_type || 'session',
         source_id: sessionId,
+        relation: f.relation,
         tags,
       });
       savedFacts.push({
@@ -359,6 +374,39 @@ function saveFacts(sessionId, project, facts, { scope = null, source_type = null
       saved++;
     } catch { skipped++; }
   }
+  // Wiki integration: update staleness + promote eligible topics (non-fatal)
+  if (savedFacts.length > 0) {
+    try {
+      const { updateStalenessForTags, checkTopicThreshold, upsertWikiTopic } = require('./core/wiki-db');
+      const db = getDb();
+
+      // Build tag → new-fact count map from saved facts' tags
+      const dirtyTagCounts = new Map();
+      for (const f of savedFacts) {
+        const tags = Array.isArray(f.tags) ? f.tags : [];
+        for (const tag of tags) {
+          if (tag && typeof tag === 'string') {
+            dirtyTagCounts.set(tag, (dirtyTagCounts.get(tag) || 0) + 1);
+          }
+        }
+      }
+
+      if (dirtyTagCounts.size > 0) {
+        updateStalenessForTags(db, dirtyTagCounts);
+
+        // Promote tags that cross the threshold to wiki topics
+        // Use force:true since we already checked the threshold — avoids double-query
+        for (const [tag] of dirtyTagCounts) {
+          try {
+            if (checkTopicThreshold(db, tag)) {
+              upsertWikiTopic(db, tag, { force: true });
+            }
+          } catch { /* slug error or collision: skip */ }
+        }
+      }
+    } catch { /* wiki not available: non-fatal */ }
+  }
+
   return { saved, skipped, superseded: 0, savedFacts };
 }
 
@@ -431,6 +479,27 @@ function recentSessions({ limit = 3, project = null, scope = null } = {}) {
   }));
 }
 
+function recentFacts({ limit = 5, project = null, scope = null } = {}) {
+  return searchMemoryItems(null, {
+    state: 'active',
+    project: project || null,
+    scope: scope || null,
+    limit,
+  })
+    .filter(r => r.kind === 'insight' || r.kind === 'convention')
+    .map(r => ({
+      id: r.id,
+      entity: (r.title || '').split(' · ')[0] || r.title || '',
+      relation: (r.title || '').split(' · ')[1] || '',
+      value: r.content,
+      confidence: r.confidence >= 0.9 ? 'high' : r.confidence >= 0.6 ? 'medium' : 'low',
+      project: r.project,
+      scope: r.scope,
+      tags: _parseTags(r.tags),
+      created_at: r.created_at,
+    }));
+}
+
 function stats() {
   const db = getDb();
   const row = db.prepare(
@@ -465,6 +534,33 @@ function forceClose() {
   if (_db) { _db.close(); _db = null; }
 }
 
+/**
+ * Search wiki pages + memory facts via FTS5.
+ * Thin wrapper over core/wiki-db::searchWikiAndFacts that provides the DB instance.
+ * trackSearch: true → increments search_count on matched facts.
+ */
+function searchWikiAndFacts(query, { trackSearch = true } = {}) {
+  try {
+    const { searchWikiAndFacts: fn } = require('./core/wiki-db');
+    return fn(getDb(), query, { trackSearch });
+  } catch {
+    return { wikiPages: [], facts: [] };
+  }
+}
+
+/**
+ * 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,
@@ -474,6 +570,9 @@ module.exports = {
   bumpSearchCount,
   readWorkingMemory,
   assembleContext,
+  // wiki
+  searchWikiAndFacts,
+  hybridSearchWiki,
   // compatibility
   saveSession,
   saveFacts,
@@ -482,6 +581,7 @@ module.exports = {
   searchFactsAsync,
   searchSessions,
   recentSessions,
+  recentFacts,
   stats,
   // lifecycle
   acquire,

package/scripts/signal-capture.js

@@ -101,7 +101,7 @@ function withBufferLock(fn) {
       acquired = true;
       break;
     } catch (e) {
-      if (e.code !== 'EEXIST') return false; // non-EEXIST errors (EMFILE, EACCES) → skip lock gracefully
+      if (e.code !== 'EEXIST') throw e;
       try {
         const age = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
         if (age > LOCK_STALE_MS) {

package/scripts/skill-evolution.js

@@ -75,7 +75,6 @@ const DEFAULT_POLICY = {
   min_evidence_for_gap: 3,
   max_updates_per_analysis: 3,
   max_gaps_per_analysis: 2,
-  max_signals_per_analysis: 30,  // cap signals sent to Haiku per run
 
   // Workflow discovery
   workflow_discovery_interval: 2,   // every N cold-path cycles
@@ -201,7 +200,6 @@ function sanitizePolicy(input) {
     min_evidence_for_gap: clampInt(merged.min_evidence_for_gap, DEFAULT_POLICY.min_evidence_for_gap, 1, 20),
     max_updates_per_analysis: clampInt(merged.max_updates_per_analysis, DEFAULT_POLICY.max_updates_per_analysis, 1, 20),
     max_gaps_per_analysis: clampInt(merged.max_gaps_per_analysis, DEFAULT_POLICY.max_gaps_per_analysis, 1, 20),
-    max_signals_per_analysis: clampInt(merged.max_signals_per_analysis, DEFAULT_POLICY.max_signals_per_analysis, 5, 100),
     workflow_discovery_interval: clampInt(merged.workflow_discovery_interval, DEFAULT_POLICY.workflow_discovery_interval, 1, 100),
     min_signals_for_workflow: clampInt(merged.min_signals_for_workflow, DEFAULT_POLICY.min_signals_for_workflow, 1, 100),
     workflow_proposal_threshold: clampInt(merged.workflow_proposal_threshold, DEFAULT_POLICY.workflow_proposal_threshold, 2, 50),
@@ -612,15 +610,8 @@ async function distillSkills() {
   if (!content) return null;
 
   const lines = content.split('\n');
-  const allSignals = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-  if (allSignals.length < policy.min_signals_for_distill) return null;
-
-  // Cap signals sent to Haiku to avoid prompt bloat / timeout.
-  // Keep most recent signals (higher relevance); overflow is still cleared.
-  const maxSignals = policy.max_signals_per_analysis || 30;
-  const signals = allSignals.length > maxSignals
-    ? allSignals.slice(-maxSignals)
-    : allSignals;
+  const signals = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  if (signals.length < policy.min_signals_for_distill) return null;
 
   // Get installed skills list
   const installedSkills = listInstalledSkills();