wayfind 2.0.28 → 2.0.30

package/bin/distill.js

@@ -0,0 +1,355 @@
+'use strict';
+
+const contentStore = require('./content-store');
+const llm = require('./connectors/llm');
+
+// ── Tier definitions ────────────────────────────────────────────────────────
+
+const TIERS = {
+  daily: { minAgeDays: 3, maxAgeDays: 14 },
+  weekly: { minAgeDays: 14, maxAgeDays: 60 },
+  archive: { minAgeDays: 60, maxAgeDays: Infinity },
+};
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function daysAgo(dateStr) {
+  const now = new Date();
+  const then = new Date(dateStr + 'T00:00:00Z');
+  return Math.floor((now - then) / (1000 * 60 * 60 * 24));
+}
+
+function today() {
+  return new Date().toISOString().split('T')[0];
+}
+
+/**
+ * Compute Jaccard similarity between two titles (word-level).
+ * @param {string} a
+ * @param {string} b
+ * @returns {number} 0-1
+ */
+function titleSimilarity(a, b) {
+  const wordsA = new Set((a || '').toLowerCase().split(/\s+/).filter(w => w.length > 2));
+  const wordsB = new Set((b || '').toLowerCase().split(/\s+/).filter(w => w.length > 2));
+  if (wordsA.size === 0 && wordsB.size === 0) return 1;
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  const union = new Set([...wordsA, ...wordsB]).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+// ── Grouping ────────────────────────────────────────────────────────────────
+
+/**
+ * Group entries by (date, repo), then cluster by title similarity within each group.
+ * @param {Array<{id: string, entry: Object}>} entries
+ * @returns {Array<Array<{id: string, entry: Object}>>} Clusters of related entries
+ */
+function groupEntries(entries) {
+  // Group by date+repo
+  const groups = {};
+  for (const item of entries) {
+    const key = `${item.entry.date}|${item.entry.repo}`;
+    if (!groups[key]) groups[key] = [];
+    groups[key].push(item);
+  }
+
+  // Within each group, cluster by title similarity
+  const clusters = [];
+  for (const items of Object.values(groups)) {
+    if (items.length === 1) {
+      clusters.push(items);
+      continue;
+    }
+
+    const assigned = new Set();
+    for (let i = 0; i < items.length; i++) {
+      if (assigned.has(i)) continue;
+      const cluster = [items[i]];
+      assigned.add(i);
+      for (let j = i + 1; j < items.length; j++) {
+        if (assigned.has(j)) continue;
+        if (titleSimilarity(items[i].entry.title, items[j].entry.title) > 0.8) {
+          cluster.push(items[j]);
+          assigned.add(j);
+        }
+      }
+      clusters.push(cluster);
+    }
+  }
+
+  return clusters;
+}
+
+// ── Deduplication ───────────────────────────────────────────────────────────
+
+/**
+ * Deduplicate a cluster of entries.
+ * - Exact content_hash matches: keep highest quality_score
+ * - Returns { canonical: [{id, entry}], absorbed: [ids] }
+ */
+function deduplicateGroup(cluster) {
+  if (cluster.length <= 1) {
+    return { canonical: cluster, absorbed: [] };
+  }
+
+  // Group by content hash
+  const byHash = {};
+  for (const item of cluster) {
+    const hash = item.entry.contentHash;
+    if (!byHash[hash]) byHash[hash] = [];
+    byHash[hash].push(item);
+  }
+
+  const canonical = [];
+  const absorbed = [];
+
+  for (const items of Object.values(byHash)) {
+    if (items.length === 1) {
+      canonical.push(items[0]);
+      continue;
+    }
+    // Keep the one with highest quality score
+    items.sort((a, b) => (b.entry.qualityScore || 0) - (a.entry.qualityScore || 0));
+    canonical.push(items[0]);
+    for (let i = 1; i < items.length; i++) {
+      absorbed.push(items[i].id);
+    }
+  }
+
+  return { canonical, absorbed };
+}
+
+// ── Merging ─────────────────────────────────────────────────────────────────
+
+const MERGE_PROMPTS = {
+  daily: `You are merging duplicate decision entries from the same day and repo.
+Remove exact duplicates. Keep all distinct decisions with full reasoning.
+Return a single markdown entry that preserves all unique information.
+Format: Start with the repo and title, then include all distinct decisions with their reasoning.`,
+
+  weekly: `You are creating a weekly summary for a repo.
+Combine related decisions into a concise per-repo weekly summary.
+Preserve key reasoning and alternatives that were considered.
+Remove redundancy and boilerplate.
+Format: A clean markdown summary organized by topic.`,
+
+  archive: `You are creating a monthly archive summary.
+Compress multiple entries into a brief summary with key decisions and outcomes only.
+Focus on what was decided and why, not the details of how.
+Format: A compact markdown summary, max 500 words.`,
+};
+
+/**
+ * Merge 2+ related entries into a single distilled entry via LLM.
+ * @param {Array<{id: string, entry: Object}>} entries
+ * @param {Object} llmConfig - { provider, model, api_key_env }
+ * @param {string} tier - 'daily', 'weekly', or 'archive'
+ * @returns {Promise<{content: string, title: string}>}
+ */
+async function mergeEntries(entries, llmConfig, tier) {
+  const storePath = contentStore.DEFAULT_STORE_PATH;
+  const journalDir = contentStore.DEFAULT_JOURNAL_DIR;
+  const signalsDir = contentStore.DEFAULT_SIGNALS_DIR;
+
+  const parts = entries.map(({ id, entry }) => {
+    const content = contentStore.getEntryContent(id, { storePath, journalDir, signalsDir });
+    return content || `${entry.date} — ${entry.repo} — ${entry.title}`;
+  });
+
+  const systemPrompt = MERGE_PROMPTS[tier] || MERGE_PROMPTS.daily;
+  const userContent = parts.join('\n\n---\n\n');
+
+  const config = {
+    provider: llmConfig.provider || 'anthropic',
+    model: llmConfig.model || 'claude-haiku-4-5-20251001',
+    api_key_env: llmConfig.api_key_env || 'ANTHROPIC_API_KEY',
+    max_tokens: 2000,
+  };
+  const result = await llm.call(config, systemPrompt, userContent);
+
+  // Extract title from first line or generate one
+  const firstEntry = entries[0].entry;
+  const title = `[${tier}] ${firstEntry.repo} — ${firstEntry.date}`;
+
+  return { content: result, title };
+}
+
+// ── Main Pipeline ───────────────────────────────────────────────────────────
+
+/**
+ * Run the distillation pipeline.
+ * @param {Object} options
+ * @param {string} [options.tier] - 'daily', 'weekly', 'archive', or 'all'
+ * @param {boolean} [options.dryRun] - If true, don't write changes
+ * @param {Object} [options.llmConfig] - LLM config for merge operations
+ * @param {string} [options.storePath] - Content store path
+ * @returns {Promise<Object>} Stats: { grouped, deduped, merged, llmCalls }
+ */
+async function distillEntries(options = {}) {
+  const tierName = options.tier || 'daily';
+  const dryRun = options.dryRun || false;
+  const storePath = options.storePath || contentStore.DEFAULT_STORE_PATH;
+
+  const tiersToRun = tierName === 'all'
+    ? ['daily', 'weekly', 'archive']
+    : [tierName];
+
+  const totalStats = { grouped: 0, deduped: 0, merged: 0, llmCalls: 0 };
+
+  for (const tier of tiersToRun) {
+    const tierDef = TIERS[tier];
+    if (!tierDef) {
+      console.log(`Unknown tier: ${tier}`);
+      continue;
+    }
+
+    // Calculate date range for this tier
+    const now = new Date();
+    const sinceDate = new Date(now);
+    sinceDate.setDate(sinceDate.getDate() - tierDef.maxAgeDays);
+    const untilDate = new Date(now);
+    untilDate.setDate(untilDate.getDate() - tierDef.minAgeDays);
+
+    const since = sinceDate.toISOString().split('T')[0];
+    const until = untilDate.toISOString().split('T')[0];
+
+    // Query entries eligible for this tier
+    const entries = contentStore.queryMetadata({ since, until, storePath });
+
+    // Filter: only raw entries that haven't been distilled yet
+    const eligible = entries.filter(({ entry }) => {
+      return (entry.distillTier === 'raw' || !entry.distillTier)
+        && !entry.distilledAt
+        && !entry.distilledFrom;  // not already a distilled entry
+    });
+
+    if (eligible.length === 0) {
+      console.log(`  ${tier}: no eligible entries`);
+      continue;
+    }
+
+    console.log(`  ${tier}: ${eligible.length} eligible entries (${since} to ${until})`);
+
+    // Group and cluster
+    const clusters = groupEntries(eligible);
+    totalStats.grouped += clusters.length;
+
+    // Deduplicate within each cluster
+    let totalDeduped = 0;
+    const mergeableClusters = [];
+
+    for (const cluster of clusters) {
+      const { canonical, absorbed } = deduplicateGroup(cluster);
+      totalDeduped += absorbed.length;
+
+      if (!dryRun && absorbed.length > 0) {
+        // Mark absorbed entries
+        const backend = contentStore.getBackend(storePath);
+        const index = backend.loadIndex();
+        for (const absorbedId of absorbed) {
+          if (index.entries[absorbedId]) {
+            index.entries[absorbedId].distilledAt = Date.now();
+            index.entries[absorbedId].distillTier = tier;
+          }
+        }
+        backend.saveIndex(index);
+      }
+
+      // Only merge if there are 2+ canonical entries in the cluster
+      if (canonical.length >= 2) {
+        mergeableClusters.push(canonical);
+      }
+    }
+
+    totalStats.deduped += totalDeduped;
+
+    if (dryRun) {
+      console.log(`    Would dedup: ${totalDeduped} entries`);
+      console.log(`    Would merge: ${mergeableClusters.length} clusters (${mergeableClusters.reduce((s, c) => s + c.length, 0)} entries)`);
+      continue;
+    }
+
+    // Merge clusters via LLM
+    if (mergeableClusters.length > 0 && options.llmConfig) {
+      for (const cluster of mergeableClusters) {
+        try {
+          const { content, title } = await mergeEntries(cluster, options.llmConfig, tier);
+          totalStats.llmCalls++;
+
+          // Create distilled entry in the content store
+          const firstEntry = cluster[0].entry;
+          const absorbedIds = cluster.map(c => c.id);
+          const id = contentStore.generateEntryId(firstEntry.date, firstEntry.repo, title);
+          const hash = contentStore.contentHash(content);
+
+          const backend = contentStore.getBackend(storePath);
+          const index = backend.loadIndex();
+
+          index.entries[id] = {
+            date: firstEntry.date,
+            repo: firstEntry.repo,
+            title,
+            source: 'distilled',
+            user: '',
+            drifted: false,
+            contentHash: hash,
+            contentLength: content.length,
+            tags: firstEntry.tags || [],
+            hasEmbedding: false,
+            hasReasoning: true,
+            hasAlternatives: false,
+            qualityScore: 3, // distilled entries are high quality by definition
+            distillTier: tier,
+            distilledFrom: absorbedIds,
+            distilledAt: Date.now(),
+          };
+
+          // Mark source entries as absorbed
+          for (const item of cluster) {
+            if (index.entries[item.id]) {
+              index.entries[item.id].distilledAt = Date.now();
+              index.entries[item.id].distillTier = tier;
+            }
+          }
+
+          index.entryCount = Object.keys(index.entries).length;
+          backend.saveIndex(index);
+          totalStats.merged += cluster.length;
+        } catch (err) {
+          console.log(`    Merge failed for cluster: ${err.message}`);
+        }
+      }
+    }
+
+    // Log the distillation run
+    if (!dryRun) {
+      try {
+        const backend = contentStore.getBackend(storePath);
+        if (backend.db) {
+          backend.db.prepare(`
+            INSERT INTO distillation_log (run_at, tier, entries_input, entries_output, entries_merged, entries_deduped, llm_calls)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+          `).run(Date.now(), tier, eligible.length, eligible.length - totalDeduped - totalStats.merged, totalStats.merged, totalDeduped, totalStats.llmCalls);
+        }
+      } catch { /* non-fatal */ }
+    }
+  }
+
+  return totalStats;
+}
+
+// ── Exports ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  distillEntries,
+  groupEntries,
+  deduplicateGroup,
+  mergeEntries,
+  titleSimilarity,
+  TIERS,
+};

package/bin/memory-compare.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const HOME = process.env.HOME || process.env.USERPROFILE;
+
+/**
+ * Compare Claude Code auto-memory vs Wayfind global memory.
+ * Shows overlap, unique content in each, and freshness.
+ */
+function compare() {
+  const autoMemoryRoot = path.join(HOME, '.claude', 'projects');
+  const wayfindMemory = path.join(HOME, '.claude', 'memory');
+
+  // Collect auto-memory entries
+  const autoEntries = [];
+  if (fs.existsSync(autoMemoryRoot)) {
+    for (const proj of fs.readdirSync(autoMemoryRoot)) {
+      const memDir = path.join(autoMemoryRoot, proj, 'memory');
+      if (!fs.existsSync(memDir)) continue;
+      for (const file of fs.readdirSync(memDir).filter(f => f.endsWith('.md') && f !== 'MEMORY.md')) {
+        const fp = path.join(memDir, file);
+        const content = fs.readFileSync(fp, 'utf8');
+        const typeMatch = content.match(/^type:\s*(.+)$/m);
+        const descMatch = content.match(/^description:\s*(.+)$/m);
+        const stat = fs.statSync(fp);
+        autoEntries.push({
+          project: proj,
+          file,
+          type: typeMatch ? typeMatch[1].trim() : 'unknown',
+          description: descMatch ? descMatch[1].trim() : '',
+          size: content.length,
+          modified: stat.mtime,
+          daysAgo: Math.floor((Date.now() - stat.mtime) / (1000 * 60 * 60 * 24)),
+        });
+      }
+    }
+  }
+
+  // Collect Wayfind global memory entries
+  const wayfindEntries = [];
+  if (fs.existsSync(wayfindMemory)) {
+    for (const file of fs.readdirSync(wayfindMemory).filter(f => f.endsWith('.md'))) {
+      const fp = path.join(wayfindMemory, file);
+      const content = fs.readFileSync(fp, 'utf8');
+      const stat = fs.statSync(fp);
+      wayfindEntries.push({
+        file,
+        size: content.length,
+        modified: stat.mtime,
+        daysAgo: Math.floor((Date.now() - stat.mtime) / (1000 * 60 * 60 * 24)),
+      });
+    }
+  }
+
+  // Journal stats
+  const journalDir = path.join(wayfindMemory, 'journal');
+  let journalCount = 0;
+  let journalSize = 0;
+  let latestJournal = null;
+  if (fs.existsSync(journalDir)) {
+    const journals = fs.readdirSync(journalDir).filter(f => f.endsWith('.md'));
+    journalCount = journals.length;
+    for (const j of journals) {
+      const fp = path.join(journalDir, j);
+      journalSize += fs.statSync(fp).size;
+      const stat = fs.statSync(fp);
+      if (!latestJournal || stat.mtime > latestJournal) latestJournal = stat.mtime;
+    }
+  }
+
+  // Report
+  console.log('');
+  console.log('=== Memory Systems Comparison ===');
+  console.log('');
+
+  console.log('Claude Code Auto-Memory (per-project):');
+  const byType = {};
+  for (const e of autoEntries) {
+    byType[e.type] = (byType[e.type] || 0) + 1;
+  }
+  console.log(`  ${autoEntries.length} entries across ${new Set(autoEntries.map(e => e.project)).size} projects`);
+  for (const [type, count] of Object.entries(byType).sort((a, b) => b[1] - a[1])) {
+    console.log(`    ${type}: ${count}`);
+  }
+  const recentAuto = autoEntries.filter(e => e.daysAgo <= 7);
+  const staleAuto = autoEntries.filter(e => e.daysAgo > 30);
+  console.log(`  Fresh (≤7d): ${recentAuto.length} | Stale (>30d): ${staleAuto.length}`);
+  console.log('');
+
+  console.log('Wayfind Global Memory:');
+  console.log(`  ${wayfindEntries.length} topic files`);
+  console.log(`  ${journalCount} journal entries (${Math.round(journalSize / 1024)}KB)`);
+  const recentWf = wayfindEntries.filter(e => e.daysAgo <= 7);
+  const staleWf = wayfindEntries.filter(e => e.daysAgo > 30);
+  console.log(`  Fresh (≤7d): ${recentWf.length} | Stale (>30d): ${staleWf.length}`);
+  if (latestJournal) {
+    const jDaysAgo = Math.floor((Date.now() - latestJournal) / (1000 * 60 * 60 * 24));
+    console.log(`  Latest journal: ${jDaysAgo}d ago`);
+  }
+  console.log('');
+
+  // Overlap detection: look for similar topics
+  console.log('Potential Overlap (auto-memory projects with Wayfind topic files on same subject):');
+  let overlapCount = 0;
+  for (const auto of autoEntries) {
+    const keywords = auto.file.replace(/\.md$/, '').replace(/^(feedback|project|reference|user)_/, '').split(/[-_]/).filter(w => w.length > 2);
+    for (const wf of wayfindEntries) {
+      const wfWords = wf.file.replace(/\.md$/, '').split(/[-_]/).filter(w => w.length > 2);
+      const overlap = keywords.filter(k => wfWords.some(w => w.includes(k) || k.includes(w)));
+      if (overlap.length >= 2) {
+        console.log(`  AUTO: ${auto.file} (${auto.project.slice(-30)}) <-> WF: ${wf.file}`);
+        overlapCount++;
+      }
+    }
+  }
+  if (overlapCount === 0) console.log('  None detected');
+  console.log('');
+
+  // Secret scan across both memory systems
+  const SECRET_PATTERNS = [
+    /xoxb-[0-9A-Za-z-]+/,        // Slack bot token
+    /xapp-[0-9A-Za-z-]+/,        // Slack app token
+    /ghp_[0-9A-Za-z]+/,          // GitHub PAT
+    /gho_[0-9A-Za-z]+/,          // GitHub OAuth
+    /sk-[0-9A-Za-z]{20,}/,       // OpenAI / generic secret key
+    /pat-na1-[0-9a-f-]+/,        // HubSpot PAT
+    /ntn_[0-9A-Za-z]+/,          // Notion token
+    /dG9r[0-9A-Za-z+/=]{20,}/,   // Base64 "tok:" prefix (Intercom-style)
+    /AKIA[0-9A-Z]{16}/,          // AWS access key
+    /\b[A-Za-z0-9_]{10,}\.[A-Za-z0-9_-]{20,}/,  // Azure function key pattern (xxx.yyy)
+  ];
+
+  console.log('Secret Scan:');
+  let secretsFound = 0;
+  const allFiles = [
+    ...autoEntries.map(e => ({
+      path: path.join(autoMemoryRoot, e.project, 'memory', e.file),
+      label: `auto:${e.project.slice(-25)}/${e.file}`,
+    })),
+    ...wayfindEntries.map(e => ({
+      path: path.join(wayfindMemory, e.file),
+      label: `wayfind:${e.file}`,
+    })),
+  ];
+  for (const { path: fp, label } of allFiles) {
+    try {
+      const content = fs.readFileSync(fp, 'utf8');
+      for (const pattern of SECRET_PATTERNS) {
+        const match = content.match(pattern);
+        if (match) {
+          // Skip if it's inside a code example or command template (has $ prefix or is in backtick-quoted env var reference)
+          const line = content.split('\n').find(l => l.includes(match[0])) || '';
+          if (line.includes('$') && !line.includes('`' + match[0])) continue;
+          console.log(`  ⚠ ${label} — matches ${pattern.source.slice(0, 20)}...`);
+          secretsFound++;
+          break;
+        }
+      }
+    } catch { /* skip unreadable */ }
+  }
+  if (secretsFound === 0) {
+    console.log('  Clean — no secrets detected in memory files');
+  }
+}
+
+if (require.main === module) {
+  compare();
+}
+
+module.exports = { compare };

package/bin/memory-report.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+# Daily memory systems comparison report — posts to Slack via bot token.
+# Add to crontab: 43 8 * * * /home/greg/repos/greg/wayfind/bin/memory-report.sh
+#
+# Runs on host (needs access to ~/.claude/projects for auto-memory).
+# Pulls SLACK_BOT_TOKEN from the wayfind container if not set locally.
+
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+CHANNEL="${SLACK_MEMORY_REPORT_CHANNEL:-C0AHV3UUW67}"
+DATE=$(date +%Y-%m-%d)
+PATH="$HOME/.npm-global/bin:$HOME/.local/bin:/usr/local/bin:/usr/bin:/bin:$PATH"
+
+# Get Slack token from container if not in environment
+if [ -z "${SLACK_BOT_TOKEN:-}" ]; then
+  SLACK_BOT_TOKEN=$(docker exec wayfind printenv SLACK_BOT_TOKEN 2>/dev/null || true)
+fi
+if [ -z "${SLACK_BOT_TOKEN:-}" ]; then
+  echo "[$DATE] No SLACK_BOT_TOKEN available — skipping report"
+  exit 0
+fi
+
+# Generate comparison
+REPORT=$(node "$SCRIPT_DIR/memory-compare.js" 2>&1)
+
+# Format for Slack
+PAYLOAD=$(node -e "
+const report = process.argv[1];
+const date = process.argv[2];
+const msg = ':brain: *Daily Memory Systems Report — ' + date + '*\n\`\`\`\n' + report.replace(/=== Memory Systems Comparison ===\n\n/, '') + '\n\`\`\`';
+const body = JSON.stringify({ channel: process.argv[3], text: msg });
+process.stdout.write(body);
+" "$REPORT" "$DATE" "$CHANNEL")
+
+# Post to Slack
+curl -s -X POST https://slack.com/api/chat.postMessage \
+  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d "$PAYLOAD" > /dev/null
+
+echo "[$DATE] Memory report posted to Slack"

package/bin/slack-bot.js

@@ -639,7 +639,8 @@ async function searchDecisionTrail(query, config) {
     }
   }
 
-  return results || [];
+  // Deduplicate: prefer distilled entries over their raw sources
+  return contentStore.deduplicateResults(results || []);
 }
 
 /**

package/bin/storage/sqlite-backend.js

@@ -40,6 +40,10 @@ CREATE TABLE IF NOT EXISTS decisions (
   has_embedding INTEGER DEFAULT 0,
   has_reasoning INTEGER DEFAULT 0,
   has_alternatives INTEGER DEFAULT 0,
+  quality_score INTEGER DEFAULT 0,
+  distill_tier TEXT DEFAULT 'raw',
+  distilled_from TEXT DEFAULT NULL,
+  distilled_at INTEGER DEFAULT NULL,
   created_at INTEGER,
   updated_at INTEGER
 );
@@ -48,6 +52,19 @@ CREATE INDEX IF NOT EXISTS idx_decisions_date ON decisions(date);
 CREATE INDEX IF NOT EXISTS idx_decisions_repo ON decisions(repo);
 CREATE INDEX IF NOT EXISTS idx_decisions_source ON decisions(source);
 CREATE INDEX IF NOT EXISTS idx_decisions_user ON decisions(user);
+CREATE INDEX IF NOT EXISTS idx_decisions_quality ON decisions(quality_score);
+CREATE INDEX IF NOT EXISTS idx_decisions_tier ON decisions(distill_tier);
+
+CREATE TABLE IF NOT EXISTS distillation_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_at INTEGER NOT NULL,
+  tier TEXT NOT NULL,
+  entries_input INTEGER DEFAULT 0,
+  entries_output INTEGER DEFAULT 0,
+  entries_merged INTEGER DEFAULT 0,
+  entries_deduped INTEGER DEFAULT 0,
+  llm_calls INTEGER DEFAULT 0
+);
 
 CREATE TABLE IF NOT EXISTS embeddings (
   id TEXT PRIMARY KEY,
@@ -90,6 +107,10 @@ function entryToRow(id, entry) {
     has_embedding: entry.hasEmbedding ? 1 : 0,
     has_reasoning: entry.hasReasoning ? 1 : 0,
     has_alternatives: entry.hasAlternatives ? 1 : 0,
+    quality_score: entry.qualityScore || 0,
+    distill_tier: entry.distillTier || 'raw',
+    distilled_from: entry.distilledFrom ? JSON.stringify(entry.distilledFrom) : null,
+    distilled_at: entry.distilledAt || null,
     created_at: entry.createdAt || Date.now(),
     updated_at: Date.now(),
   };
@@ -109,6 +130,10 @@ function rowToEntry(row) {
     hasEmbedding: !!row.has_embedding,
     hasReasoning: !!row.has_reasoning,
     hasAlternatives: !!row.has_alternatives,
+    qualityScore: row.quality_score || 0,
+    distillTier: row.distill_tier || 'raw',
+    distilledFrom: row.distilled_from ? JSON.parse(row.distilled_from) : null,
+    distilledAt: row.distilled_at || null,
   };
 }
 
@@ -137,6 +162,21 @@ class SqliteBackend {
     if (!existing) {
       this.db.prepare('INSERT INTO metadata (key, value) VALUES (?, ?)').run('schema_version', SCHEMA_VERSION);
     }
+
+    // Migrate existing databases: add new columns if they don't exist
+    const cols = this.db.prepare('PRAGMA table_info(decisions)').all().map(c => c.name);
+    if (!cols.includes('quality_score')) {
+      this.db.exec('ALTER TABLE decisions ADD COLUMN quality_score INTEGER DEFAULT 0');
+    }
+    if (!cols.includes('distill_tier')) {
+      this.db.exec('ALTER TABLE decisions ADD COLUMN distill_tier TEXT DEFAULT \'raw\'');
+    }
+    if (!cols.includes('distilled_from')) {
+      this.db.exec('ALTER TABLE decisions ADD COLUMN distilled_from TEXT DEFAULT NULL');
+    }
+    if (!cols.includes('distilled_at')) {
+      this.db.exec('ALTER TABLE decisions ADD COLUMN distilled_at INTEGER DEFAULT NULL');
+    }
   }
 
   close() {
@@ -173,10 +213,12 @@ class SqliteBackend {
       const stmt = this.db.prepare(`
         INSERT INTO decisions (id, date, repo, title, source, user, drifted,
           content_hash, content_length, tags, has_embedding, has_reasoning,
-          has_alternatives, created_at, updated_at)
+          has_alternatives, quality_score, distill_tier, distilled_from, distilled_at,
+          created_at, updated_at)
         VALUES (@id, @date, @repo, @title, @source, @user, @drifted,
           @content_hash, @content_length, @tags, @has_embedding, @has_reasoning,
-          @has_alternatives, @created_at, @updated_at)
+          @has_alternatives, @quality_score, @distill_tier, @distilled_from, @distilled_at,
+          @created_at, @updated_at)
       `);
       for (const [id, entry] of Object.entries(entries)) {
         stmt.run(entryToRow(id, entry));