metame-cli 1.5.19 → 1.5.21

package/scripts/memory-extract.js

@@ -108,68 +108,6 @@ function saveSessionTag(sessionId, sessionName, facts) {
   }
 }
 
-function normalizeConceptList(input) {
-  if (!Array.isArray(input)) return [];
-  const out = [];
-  const seen = new Set();
-  for (const raw of input) {
-    const v = String(raw || '').trim();
-    if (!v || v.length > 40) continue;
-    if (seen.has(v)) continue;
-    seen.add(v);
-    out.push(v);
-    if (out.length >= 3) break;
-  }
-  return out;
-}
-
-function normalizeDomain(input) {
-  const v = String(input || '').trim();
-  if (!v) return null;
-  return v.length > 40 ? v.slice(0, 40) : v;
-}
-
-function factFingerprint(fact) {
-  if (!fact || typeof fact !== 'object') return '';
-  const entity = String(fact.entity || '').trim();
-  const relation = String(fact.relation || '').trim();
-  const value = String(fact.value || '').trim().slice(0, 100);
-  if (!entity || !relation || !value) return '';
-  return `${entity}||${relation}||${value}`;
-}
-
-function buildFactLabelRows(extractedFacts, savedFacts) {
-  const source = Array.isArray(extractedFacts) ? extractedFacts : [];
-  const saved = Array.isArray(savedFacts) ? savedFacts : [];
-  if (source.length === 0 || saved.length === 0) return [];
-
-  const byFp = new Map();
-  for (const fact of source) {
-    const fp = factFingerprint(fact);
-    if (!fp) continue;
-    if (!byFp.has(fp)) byFp.set(fp, fact);
-  }
-
-  const rows = [];
-  const dedup = new Set();
-  for (const sf of saved) {
-    const fp = factFingerprint(sf);
-    if (!fp) continue;
-    const src = byFp.get(fp);
-    if (!src) continue;
-    const concepts = normalizeConceptList(src.concepts);
-    if (concepts.length === 0) continue;
-    const domain = normalizeDomain(src.domain);
-    for (const label of concepts) {
-      const rowKey = `${sf.id}::${label}`;
-      if (dedup.has(rowKey)) continue;
-      dedup.add(rowKey);
-      rows.push({ fact_id: sf.id, label, domain });
-    }
-  }
-  return rows;
-}
-
 const VAGUE_PATTERNS = [
   /^用户(问|提|说|提到)/, /^我们(讨论|分析|查看)/,
   /这个问题/, /上面(提到|说的|的)/, /可能是因为/,
@@ -216,13 +154,7 @@ async function extractFacts(skeleton, evidence, distillEnv) {
     return true;
   });
 
-  const normalizedFacts = filteredFacts.map(f => ({
-    ...f,
-    concepts: normalizeConceptList(f.concepts),
-    domain: normalizeDomain(f.domain),
-  }));
-
-  return { ok: true, facts: normalizedFacts, session_name };
+  return { ok: true, facts: filteredFacts, session_name };
 }
 
 /**
@@ -313,25 +245,16 @@ async function run() {
           const fallbackScope = skeleton.session_id
             ? `sess_${String(skeleton.session_id).replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 24)}`
             : null;
-          const { saved, skipped, superseded, savedFacts } = memory.saveFacts(
+          const { saved, skipped, superseded } = memory.saveFacts(
             skeleton.session_id,
             skeleton.project || 'unknown',
             facts,
             { scope: skeleton.project_id || fallbackScope }
           );
-          let labelsSaved = 0;
-          if (typeof memory.saveFactLabels === 'function' && Array.isArray(savedFacts) && savedFacts.length > 0) {
-            const labelRows = buildFactLabelRows(facts, savedFacts);
-            if (labelRows.length > 0) {
-              const labelResult = memory.saveFactLabels(labelRows);
-              labelsSaved = Number(labelResult && labelResult.saved) || 0;
-            }
-          }
           totalSaved += saved;
           totalSkipped += skipped;
           const superMsg = superseded > 0 ? `, ${superseded} superseded` : '';
-          const labelMsg = labelsSaved > 0 ? `, ${labelsSaved} labels` : '';
-          console.log(`[memory-extract] Session ${skeleton.session_id.slice(0, 8)}: ${saved} facts saved, ${skipped} skipped${superMsg}${labelMsg}`);
+          console.log(`[memory-extract] Session ${skeleton.session_id.slice(0, 8)}: ${saved} facts saved, ${skipped} skipped${superMsg}`);
         } else {
           console.log(`[memory-extract] Session ${skeleton.session_id.slice(0, 8)} (${session_name}): no facts extracted`);
         }
@@ -386,25 +309,16 @@ async function run() {
 
           if (facts.length > 0) {
             const fallbackScope = `codex_${String(cs.session_id).replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 24)}`;
-            const { saved, skipped, superseded, savedFacts } = memory.saveFacts(
+            const { saved, skipped, superseded } = memory.saveFacts(
               cs.session_id,
               skeleton.project || 'unknown',
               facts,
               { scope: skeleton.project_id || fallbackScope, source_type: 'codex' }
             );
-            let labelsSaved = 0;
-            if (typeof memory.saveFactLabels === 'function' && Array.isArray(savedFacts) && savedFacts.length > 0) {
-              const labelRows = buildFactLabelRows(facts, savedFacts);
-              if (labelRows.length > 0) {
-                const lr = memory.saveFactLabels(labelRows);
-                labelsSaved = Number(lr && lr.saved) || 0;
-              }
-            }
             totalSaved += saved;
             totalSkipped += skipped;
             const superMsg = superseded > 0 ? `, ${superseded} superseded` : '';
-            const labelMsg = labelsSaved > 0 ? `, ${labelsSaved} labels` : '';
-            console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): ${saved} facts saved${superMsg}${labelMsg}`);
+            console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): ${saved} facts saved${superMsg}`);
 
             // Persist Codex session summary to memory.db sessions table
             try {
@@ -456,10 +370,4 @@ if (require.main === module) {
 module.exports = {
   run,
   extractFacts,
-  _private: {
-    normalizeConceptList,
-    normalizeDomain,
-    buildFactLabelRows,
-    factFingerprint,
-  },
 };

package/scripts/memory-gc.js

@@ -1,20 +1,10 @@
 #!/usr/bin/env node
 
 /**
- * memory-gc.js — Nightly Fact Garbage Collection
+ * memory-gc.js — Nightly Memory Garbage Collection
  *
- * Archives stale, low-frequency facts from memory.db by marking them
- * with conflict_status = 'ARCHIVED' (soft delete, fully auditable).
- *
- * GC criteria (ALL must be true):
- *   1. last_searched_at older than 30 days (i.e. datetime < now-30d), OR NULL and created_at also older than 30 days
- *   2. search_count < 3
- *   3. superseded_by IS NULL          (already-superseded facts excluded)
- *   4. conflict_status IS NULL OR conflict_status = 'OK'  (skip CONFLICT/ARCHIVED)
- *   5. relation NOT IN protected set  (workflow_rule, arch_convention, config_fact never archived)
- *
- * Protected relations are permanently excluded — they are high-value guardrails
- * that must survive regardless of search frequency.
+ * Promotes hot candidates and archives stale items in memory.db
+ * using the memory_items table and core/memory-model.js heuristics.
  *
  * Designed to run nightly at 02:00 via daemon.yaml scheduler.
  */
@@ -31,13 +21,6 @@ const DB_PATH = path.join(METAME_DIR, 'memory.db');
 const LOCK_FILE = path.join(METAME_DIR, 'memory-gc.lock');
 const GC_LOG_FILE = path.join(METAME_DIR, 'memory_gc_log.jsonl');
 
-// Relations that are permanently protected from archival
-const PROTECTED_RELATIONS = ['workflow_rule', 'arch_convention', 'config_fact'];
-
-// GC threshold: facts older than this many days are candidates
-const STALE_DAYS = 30;
-// GC threshold: facts with fewer searches than this are candidates
-const MIN_SEARCH_COUNT = 3;
 // Lock timeout: if a lock is older than this, it's stale and safe to break
 const LOCK_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
 
@@ -127,84 +110,49 @@ function run() {
 
     const dbSizeBefore = getDbSizeBytes();
 
-    // ── Ensure ARCHIVED status column accepts the new value ──
-    // conflict_status was created with NOT NULL DEFAULT 'OK'; ARCHIVED is a new valid state.
-    // No schema change needed — we just write the string value directly.
-
-    const protectedPlaceholders = PROTECTED_RELATIONS.map(() => '?').join(', ');
-
-    // ── DRY RUN: count candidates and protected exclusions ──
-    console.log(`[MEMORY-GC] Scanning facts older than ${STALE_DAYS} days with search_count < ${MIN_SEARCH_COUNT}...`);
-
-    const countCandidatesStmt = db.prepare(`
-      SELECT COUNT(*) AS cnt
-      FROM facts
-      WHERE (
-        (last_searched_at IS NOT NULL AND last_searched_at < datetime('now', '-${STALE_DAYS} days'))
-        OR
-        (last_searched_at IS NULL AND created_at < datetime('now', '-${STALE_DAYS} days'))
-      )
-      AND search_count < ${MIN_SEARCH_COUNT}
-      AND superseded_by IS NULL
-      AND (conflict_status IS NULL OR conflict_status = 'OK')
-      AND relation NOT IN (${protectedPlaceholders})
-      AND source_type != 'manual'
-    `);
-    const candidateCount = countCandidatesStmt.get(...PROTECTED_RELATIONS).cnt;
-
-    // Count how many facts would be skipped due to the protected-relation guard
-    const countProtectedStmt = db.prepare(`
-      SELECT COUNT(*) AS cnt
-      FROM facts
-      WHERE (
-        (last_searched_at IS NOT NULL AND last_searched_at < datetime('now', '-${STALE_DAYS} days'))
-        OR
-        (last_searched_at IS NULL AND created_at < datetime('now', '-${STALE_DAYS} days'))
-      )
-      AND search_count < ${MIN_SEARCH_COUNT}
-      AND superseded_by IS NULL
-      AND (conflict_status IS NULL OR conflict_status = 'OK')
-      AND (relation IN (${protectedPlaceholders}) OR source_type = 'manual')
-    `);
-    const protectedCount = countProtectedStmt.get(...PROTECTED_RELATIONS).cnt;
-
-    console.log(`[MEMORY-GC] Found ${candidateCount} candidates (excluded ${protectedCount} protected facts)`);
+    const memoryModel = require('./core/memory-model');
 
+    let promoted = 0;
     let archivedCount = 0;
 
     db.exec('BEGIN IMMEDIATE');
     try {
-      if (candidateCount > 0) {
-        // ── EXECUTE: archive the candidates ──
-        const updateStmt = db.prepare(`
-          UPDATE facts
-          SET conflict_status = 'ARCHIVED',
-              updated_at = datetime('now')
-          WHERE (
-            (last_searched_at IS NOT NULL AND last_searched_at < datetime('now', '-${STALE_DAYS} days'))
-            OR
-            (last_searched_at IS NULL AND created_at < datetime('now', '-${STALE_DAYS} days'))
-          )
-          AND search_count < ${MIN_SEARCH_COUNT}
-          AND superseded_by IS NULL
-          AND (conflict_status IS NULL OR conflict_status = 'OK')
-          AND relation NOT IN (${protectedPlaceholders})
-          AND source_type != 'manual'
-        `);
-
-        const result = updateStmt.run(...PROTECTED_RELATIONS);
-        archivedCount = result.changes;
-
-        console.log(`[MEMORY-GC] Archived ${archivedCount} facts → conflict_status = 'ARCHIVED'`);
-      } else {
-        console.log('[MEMORY-GC] No candidates to archive.');
+      // Phase 1: Promote hot candidates
+      const candidates = db.prepare(
+        `SELECT * FROM memory_items WHERE state = 'candidate'`
+      ).all();
+      for (const item of candidates) {
+        if (memoryModel.shouldPromote(item)) {
+          db.prepare(
+            `UPDATE memory_items SET state = 'active', updated_at = datetime('now') WHERE id = ?`
+          ).run(item.id);
+          promoted++;
+        }
       }
+      if (promoted > 0) console.log(`[MEMORY-GC] Promoted ${promoted} candidates`);
+
+      // Phase 2: Archive stale items
+      const allItems = db.prepare(
+        `SELECT * FROM memory_items WHERE state IN ('candidate', 'active')`
+      ).all();
+      for (const item of allItems) {
+        if (memoryModel.shouldArchive(item)) {
+          db.prepare(
+            `UPDATE memory_items SET state = 'archived', updated_at = datetime('now') WHERE id = ?`
+          ).run(item.id);
+          archivedCount++;
+        }
+      }
+      if (archivedCount > 0) console.log(`[MEMORY-GC] Archived ${archivedCount} stale items`);
+
       db.exec('COMMIT');
     } catch (e) {
       try { db.exec('ROLLBACK'); } catch {}
       throw e;
     }
 
+    console.log(`[MEMORY-GC] Promoted ${promoted}, archived ${archivedCount}`);
+
     // Run VACUUM to reclaim space (only if we archived something) — outside transaction
     if (archivedCount > 0) {
       try {
@@ -216,11 +164,8 @@ function run() {
 
     // ── Write audit log ──
     writeGcLog({
+      promoted,
       archived: archivedCount,
-      skipped_protected: protectedCount,
-      candidates_found: candidateCount,
-      stale_days_threshold: STALE_DAYS,
-      min_search_count_threshold: MIN_SEARCH_COUNT,
       db_size_before: dbSizeBefore,
       db_size_after: dbSizeAfter,
     });

package/scripts/memory-migrate-v2.js

@@ -0,0 +1,304 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const DB_PATH = path.join(os.homedir(), '.metame', 'memory.db');
+
+function log(msg) { process.stderr.write(`[migrate-v2] ${msg}\n`); }
+
+function die(msg) {
+  log(`FATAL: ${msg}`);
+  process.exit(1);
+}
+
+// ── Mapping helpers ──
+
+const KIND_MAP_CONVENTION = new Set([
+  'bug_lesson', 'arch_convention', 'workflow_rule', 'config_fact', 'config_change',
+]);
+const KIND_MAP_INSIGHT = new Set([
+  'tech_decision', 'project_milestone',
+]);
+
+function mapKind(relation) {
+  if (KIND_MAP_CONVENTION.has(relation)) return 'convention';
+  if (KIND_MAP_INSIGHT.has(relation)) return 'insight';
+  return 'insight';
+}
+
+function mapState(conflictStatus) {
+  if (conflictStatus === 'OK') return 'active';
+  if (conflictStatus === 'ARCHIVED') return 'archived';
+  if (conflictStatus === 'CONFLICT') return 'candidate';
+  return 'active';
+}
+
+function mapConfidence(text) {
+  if (text === 'high') return 0.9;
+  if (text === 'medium') return 0.7;
+  if (text === 'low') return 0.4;
+  return 0.7;
+}
+
+// ── Main ──
+
+function main() {
+  if (!fs.existsSync(DB_PATH)) die(`DB not found: ${DB_PATH}`);
+
+  // Backup
+  const ts = Date.now();
+  const backupPath = `${DB_PATH}.backup-v2-${ts}`;
+  fs.copyFileSync(DB_PATH, backupPath);
+  log(`Backup created: ${backupPath}`);
+
+  const { DatabaseSync } = require('node:sqlite');
+  const db = new DatabaseSync(DB_PATH);
+  db.exec('PRAGMA journal_mode = WAL');
+  db.exec('PRAGMA busy_timeout = 5000');
+  db.exec('PRAGMA foreign_keys = OFF');
+
+  // Safety check
+  try {
+    const row = db.prepare('SELECT COUNT(*) AS n FROM memory_items').get();
+    if (row.n > 0) die('Already migrated — memory_items has rows');
+  } catch {
+    // table doesn't exist yet, good
+  }
+
+  db.exec('BEGIN');
+
+  try {
+    // ── Step 1: Create new table ──
+    log('Step 1: Creating memory_items table...');
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_items (
+        id              TEXT PRIMARY KEY,
+        kind            TEXT NOT NULL,
+        state           TEXT NOT NULL DEFAULT 'candidate',
+        title           TEXT,
+        content         TEXT NOT NULL,
+        summary         TEXT,
+        confidence      REAL DEFAULT 0.5,
+        project         TEXT DEFAULT '*',
+        scope           TEXT,
+        task_key        TEXT,
+        session_id      TEXT,
+        agent_key       TEXT,
+        supersedes_id   TEXT,
+        source_type     TEXT,
+        source_id       TEXT,
+        search_count    INTEGER DEFAULT 0,
+        last_searched_at TEXT,
+        tags            TEXT DEFAULT '[]',
+        created_at      TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at      TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+    try {
+      db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS memory_items_fts USING fts5(
+          title, content, tags,
+          content='memory_items',
+          content_rowid='rowid',
+          tokenize='trigram'
+        )
+      `);
+    } catch { /* already exists */ }
+
+    db.exec('CREATE INDEX IF NOT EXISTS idx_mi_kind_state ON memory_items(kind, state)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_mi_project ON memory_items(project)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_mi_scope ON memory_items(scope)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_mi_supersedes ON memory_items(supersedes_id)');
+
+    const ftsTriggers = [
+      `CREATE TRIGGER IF NOT EXISTS mi_ai AFTER INSERT ON memory_items BEGIN
+         INSERT INTO memory_items_fts(rowid, title, content, tags)
+         VALUES (new.rowid, new.title, new.content, new.tags);
+       END`,
+      `CREATE TRIGGER IF NOT EXISTS mi_ad AFTER DELETE ON memory_items BEGIN
+         INSERT INTO memory_items_fts(memory_items_fts, rowid, title, content, tags)
+         VALUES ('delete', old.rowid, old.title, old.content, old.tags);
+       END`,
+      `CREATE TRIGGER IF NOT EXISTS mi_au AFTER UPDATE ON memory_items BEGIN
+         INSERT INTO memory_items_fts(memory_items_fts, rowid, title, content, tags)
+         VALUES ('delete', old.rowid, old.title, old.content, old.tags);
+         INSERT INTO memory_items_fts(rowid, title, content, tags)
+         VALUES (new.rowid, new.title, new.content, new.tags);
+       END`,
+    ];
+    for (const t of ftsTriggers) {
+      try { db.exec(t); } catch { /* already exists */ }
+    }
+
+    // ── Step 2: Migrate facts ──
+    log('Step 2: Migrating facts...');
+
+    const insertMi = db.prepare(`
+      INSERT INTO memory_items
+        (id, kind, state, title, content, confidence, project, scope,
+         source_type, source_id, search_count, last_searched_at, tags,
+         created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    const facts = db.prepare('SELECT * FROM facts').all();
+    let factsMigrated = 0;
+
+    for (const f of facts) {
+      const newId = 'mi_' + f.id;
+      insertMi.run(
+        newId,
+        mapKind(f.relation),
+        mapState(f.conflict_status || 'OK'),
+        (f.entity || '') + ' \u00b7 ' + (f.relation || ''),
+        f.value,
+        mapConfidence(f.confidence),
+        f.project || '*',
+        f.scope || null,
+        f.source_type || null,
+        f.source_id || null,
+        f.search_count || 0,
+        f.last_searched_at || null,
+        f.tags || '[]',
+        f.created_at,
+        f.updated_at || f.created_at
+      );
+      factsMigrated++;
+    }
+
+    // Second pass: supersedes_id (reverse pointer)
+    const updateSupersedes = db.prepare(
+      'UPDATE memory_items SET supersedes_id = ? WHERE id = ?'
+    );
+    for (const f of facts) {
+      if (f.superseded_by) {
+        const newNewId = 'mi_' + f.superseded_by;
+        const oldNewId = 'mi_' + f.id;
+        updateSupersedes.run(oldNewId, newNewId);
+      }
+    }
+
+    // ── Step 3: Migrate sessions ──
+    log('Step 3: Migrating sessions...');
+
+    const sessions = db.prepare('SELECT * FROM sessions').all();
+    let sessionsMigrated = 0;
+
+    const insertEpisode = db.prepare(`
+      INSERT INTO memory_items
+        (id, kind, state, title, content, confidence, project, scope,
+         session_id, source_type, source_id, tags, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    for (const s of sessions) {
+      const newId = 'mi_ses_' + s.id;
+      const title = (s.summary || '').slice(0, 80);
+      const kw = (s.keywords || '').split(',').map(k => k.trim()).filter(Boolean);
+      const tags = JSON.stringify(kw);
+
+      insertEpisode.run(
+        newId,
+        'episode',
+        'active',
+        title,
+        s.summary || '',
+        0.7,
+        s.project || '*',
+        s.scope || null,
+        s.id,
+        'session',
+        s.id,
+        tags,
+        s.created_at,
+        s.created_at
+      );
+      sessionsMigrated++;
+    }
+
+    // ── Step 4: Merge fact_labels into tags ──
+    log('Step 4: Merging fact_labels into tags...');
+
+    let labelsTable = false;
+    try {
+      db.prepare("SELECT 1 FROM fact_labels LIMIT 1").get();
+      labelsTable = true;
+    } catch { /* table doesn't exist */ }
+
+    if (labelsTable) {
+      const labels = db.prepare('SELECT fact_id, label FROM fact_labels').all();
+      const labelMap = new Map();
+      for (const row of labels) {
+        if (!labelMap.has(row.fact_id)) labelMap.set(row.fact_id, []);
+        labelMap.get(row.fact_id).push(row.label);
+      }
+
+      const readTags = db.prepare('SELECT tags FROM memory_items WHERE id = ?');
+      const writeTags = db.prepare('UPDATE memory_items SET tags = ? WHERE id = ?');
+
+      for (const [factId, lbls] of labelMap) {
+        const miId = 'mi_' + factId;
+        const existing = readTags.get(miId);
+        if (!existing) continue;
+
+        let arr = [];
+        try { arr = JSON.parse(existing.tags || '[]'); } catch { arr = []; }
+        const merged = [...new Set([...arr, ...lbls])];
+        writeTags.run(JSON.stringify(merged), miId);
+      }
+      log(`  Merged labels for ${labelMap.size} facts`);
+    }
+
+    // ── Step 5: Verify counts ──
+    log('Step 5: Verifying counts...');
+
+    const miFactCount = db.prepare(
+      "SELECT COUNT(*) AS n FROM memory_items WHERE kind IN ('insight','convention')"
+    ).get().n;
+    const miEpisodeCount = db.prepare(
+      "SELECT COUNT(*) AS n FROM memory_items WHERE kind = 'episode'"
+    ).get().n;
+
+    log(`  Migrated ${facts.length} facts -> ${miFactCount} memory_items (insight/convention)`);
+    log(`  Migrated ${sessions.length} sessions -> ${miEpisodeCount} memory_items (episode)`);
+
+    if (miFactCount !== factsMigrated) die(`Fact count mismatch: expected ${factsMigrated}, got ${miFactCount}`);
+    if (miEpisodeCount !== sessionsMigrated) die(`Session count mismatch: expected ${sessionsMigrated}, got ${miEpisodeCount}`);
+
+    // ── Step 6: Rename old tables ──
+    log('Step 6: Renaming old tables...');
+
+    db.exec('DROP TRIGGER IF EXISTS facts_ai');
+    db.exec('DROP TRIGGER IF EXISTS facts_ad');
+    db.exec('DROP TRIGGER IF EXISTS facts_au');
+    db.exec('DROP TRIGGER IF EXISTS sessions_ai');
+    db.exec('DROP TRIGGER IF EXISTS sessions_ad');
+    db.exec('DROP TRIGGER IF EXISTS sessions_au');
+
+    db.exec('DROP TABLE IF EXISTS facts_fts');
+    db.exec('DROP TABLE IF EXISTS sessions_fts');
+
+    db.exec('ALTER TABLE facts RENAME TO facts_v1');
+    db.exec('ALTER TABLE sessions RENAME TO sessions_v1');
+    if (labelsTable) db.exec('ALTER TABLE fact_labels RENAME TO fact_labels_v1');
+
+    // ── Step 7: Rebuild FTS5 ──
+    log('Step 7: Rebuilding FTS5 index...');
+    db.exec("INSERT INTO memory_items_fts(memory_items_fts) VALUES('rebuild')");
+
+    db.exec('COMMIT');
+    log('Migration complete.');
+    db.close();
+    process.exit(0);
+
+  } catch (err) {
+    try { db.exec('ROLLBACK'); } catch { /* ignore */ }
+    die(err.stack || err.message);
+  }
+}
+
+main();