stellavault 0.2.0 → 0.2.1

package/packages/core/src/intelligence/decay-engine.ts

@@ -1,229 +0,0 @@
-// Design Ref: §3.2 — 감쇠 엔진 (DB 연동)
-// Plan SC: SC-01, SC-02, SC-04
-
-import type { Database } from 'better-sqlite3';
-import type { DecayState, AccessEvent, DecayReport } from './types.js';
-import {
-  computeRetrievability,
-  updateStability,
-  estimateInitialStability,
-  elapsedDays,
-  FSRS_PARAMS,
-} from './fsrs.js';
-
-export class DecayEngine {
-  constructor(private db: Database) {
-    this.ensureTables();
-  }
-
-  private ensureTables() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS access_log (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        document_id TEXT NOT NULL,
-        access_type TEXT NOT NULL,
-        accessed_at TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_access_log_doc ON access_log(document_id);
-      CREATE INDEX IF NOT EXISTS idx_access_log_time ON access_log(accessed_at);
-
-      CREATE TABLE IF NOT EXISTS decay_state (
-        document_id TEXT PRIMARY KEY,
-        stability REAL NOT NULL DEFAULT 7.0,
-        difficulty REAL NOT NULL DEFAULT 5.0,
-        last_access TEXT NOT NULL,
-        retrievability REAL NOT NULL DEFAULT 1.0,
-        updated_at TEXT NOT NULL
-      );
-    `);
-  }
-
-  /**
-   * Record an access event and update decay state.
-   */
-  async recordAccess(event: AccessEvent): Promise<void> {
-    const now = event.timestamp || new Date().toISOString();
-
-    // Log the event
-    this.db.prepare(
-      'INSERT INTO access_log (document_id, access_type, accessed_at) VALUES (?, ?, ?)'
-    ).run(event.documentId, event.type, now);
-
-    // Get or create decay state
-    const existing = this.db.prepare(
-      'SELECT * FROM decay_state WHERE document_id = ?'
-    ).get(event.documentId) as any;
-
-    if (existing) {
-      const elapsed = elapsedDays(existing.last_access, now);
-      const currentR = computeRetrievability(existing.stability, elapsed);
-      const newS = updateStability(existing.stability, existing.difficulty, currentR);
-
-      this.db.prepare(`
-        UPDATE decay_state SET stability = ?, last_access = ?, retrievability = 1.0, updated_at = ?
-        WHERE document_id = ?
-      `).run(newS, now, now, event.documentId);
-    } else {
-      // New document — estimate initial stability
-      const doc = this.db.prepare('SELECT content FROM documents WHERE id = ?').get(event.documentId) as any;
-      const contentLen = doc?.content?.length ?? 500;
-      const connCount = (this.db.prepare(
-        'SELECT COUNT(*) as c FROM chunks WHERE document_id = ?'
-      ).get(event.documentId) as any)?.c ?? 1;
-      const initS = estimateInitialStability(contentLen, connCount);
-
-      this.db.prepare(`
-        INSERT INTO decay_state (document_id, stability, difficulty, last_access, retrievability, updated_at)
-        VALUES (?, ?, ?, ?, 1.0, ?)
-      `).run(event.documentId, initS, FSRS_PARAMS.difficulty, now, now);
-    }
-  }
-
-  /**
-   * Batch compute retrievability for all documents.
-   */
-  async computeAll(): Promise<DecayReport> {
-    const now = new Date().toISOString();
-
-    // Initialize documents that don't have decay state yet
-    await this.initializeNewDocuments();
-
-    // Compute R for all
-    const states = this.db.prepare('SELECT * FROM decay_state').all() as any[];
-    const docs = this.db.prepare('SELECT id, title FROM documents').all() as any[];
-    const titleMap = new Map(docs.map((d: any) => [d.id, d.title]));
-
-    const updated: DecayState[] = [];
-    const updateStmt = this.db.prepare(
-      'UPDATE decay_state SET retrievability = ?, updated_at = ? WHERE document_id = ?'
-    );
-
-    const tx = this.db.transaction(() => {
-      for (const s of states) {
-        const elapsed = elapsedDays(s.last_access, now);
-        const r = computeRetrievability(s.stability, elapsed);
-        updateStmt.run(r, now, s.document_id);
-        updated.push({
-          documentId: s.document_id,
-          stability: s.stability,
-          difficulty: s.difficulty,
-          lastAccess: s.last_access,
-          retrievability: r,
-        });
-      }
-    });
-    tx();
-
-    // Build report
-    const decaying = updated.filter(s => s.retrievability < 0.5);
-    const critical = updated.filter(s => s.retrievability < 0.3);
-    const avgR = updated.length > 0
-      ? updated.reduce((sum, s) => sum + s.retrievability, 0) / updated.length
-      : 1.0;
-
-    // Top decaying (sorted by R ascending)
-    const topDecaying = [...decaying]
-      .sort((a, b) => a.retrievability - b.retrievability)
-      .slice(0, 20)
-      .map(s => ({
-        ...s,
-        title: titleMap.get(s.documentId) ?? s.documentId,
-        daysSinceAccess: Math.round(elapsedDays(s.lastAccess, now)),
-      }));
-
-    // Cluster health
-    const clusterData = this.db.prepare(`
-      SELECT ds.document_id, ds.retrievability
-      FROM decay_state ds
-      JOIN documents d ON d.id = ds.document_id
-    `).all() as any[];
-
-    // Get cluster info from graph data cache (simplified: group by first folder)
-    const clusterHealth = this.computeClusterHealth(clusterData);
-
-    return {
-      totalDocuments: updated.length,
-      decayingCount: decaying.length,
-      criticalCount: critical.length,
-      averageR: Math.round(avgR * 100) / 100,
-      topDecaying,
-      clusterHealth,
-    };
-  }
-
-  private computeClusterHealth(data: any[]): DecayReport['clusterHealth'] {
-    // Group by document's top-level folder as proxy for cluster
-    const groups = new Map<string, number[]>();
-    for (const row of data) {
-      const doc = this.db.prepare('SELECT file_path FROM documents WHERE id = ?').get(row.document_id) as any;
-      const folder = doc?.file_path?.split('/')[0] ?? 'unknown';
-      if (!groups.has(folder)) groups.set(folder, []);
-      groups.get(folder)!.push(row.retrievability);
-    }
-
-    return [...groups.entries()]
-      .map(([label, rs]) => ({
-        label,
-        avgR: Math.round((rs.reduce((a, b) => a + b, 0) / rs.length) * 100) / 100,
-        count: rs.length,
-      }))
-      .sort((a, b) => a.avgR - b.avgR);
-  }
-
-  /**
-   * Get documents below decay threshold.
-   */
-  async getDecaying(threshold = 0.5, limit = 20): Promise<Array<DecayState & { title: string }>> {
-    await this.computeAll(); // refresh R values
-
-    const rows = this.db.prepare(`
-      SELECT ds.*, d.title FROM decay_state ds
-      JOIN documents d ON d.id = ds.document_id
-      WHERE ds.retrievability < ?
-      ORDER BY ds.retrievability ASC
-      LIMIT ?
-    `).all(threshold, limit) as any[];
-
-    return rows.map(r => ({
-      documentId: r.document_id,
-      stability: r.stability,
-      difficulty: r.difficulty,
-      lastAccess: r.last_access,
-      retrievability: r.retrievability,
-      title: r.title,
-    }));
-  }
-
-  /**
-   * Initialize decay state for documents that don't have one yet.
-   */
-  async initializeNewDocuments(): Promise<number> {
-    const missing = this.db.prepare(`
-      SELECT d.id, d.content, d.last_modified
-      FROM documents d
-      LEFT JOIN decay_state ds ON d.id = ds.document_id
-      WHERE ds.document_id IS NULL
-    `).all() as any[];
-
-    if (missing.length === 0) return 0;
-
-    const insert = this.db.prepare(`
-      INSERT OR IGNORE INTO decay_state (document_id, stability, difficulty, last_access, retrievability, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-
-    const tx = this.db.transaction(() => {
-      for (const doc of missing) {
-        const contentLen = doc.content?.length ?? 500;
-        const initS = estimateInitialStability(contentLen, 1);
-        const lastAccess = doc.last_modified || new Date().toISOString();
-        const elapsed = elapsedDays(lastAccess);
-        const r = computeRetrievability(initS, elapsed);
-        insert.run(doc.id, initS, FSRS_PARAMS.difficulty, lastAccess, r, new Date().toISOString());
-      }
-    });
-    tx();
-
-    return missing.length;
-  }
-}

package/packages/core/src/intelligence/duplicate-detector.ts

@@ -1,71 +0,0 @@
-// Design Ref: 중복/유사 노트 탐지
-// 기존 벡터 임베딩의 cosine similarity 활용
-
-import type { VectorStore } from '../store/types.js';
-
-export interface DuplicatePair {
-  docA: { id: string; title: string; filePath: string };
-  docB: { id: string; title: string; filePath: string };
-  similarity: number;
-}
-
-/**
- * 벡터 유사도 기반 중복 노트 탐지.
- * 문서별 평균 임베딩을 비교하여 threshold 이상인 쌍을 반환.
- */
-export async function detectDuplicates(
-  store: VectorStore,
-  threshold = 0.88,
-  limit = 20,
-): Promise<DuplicatePair[]> {
-  const docs = await store.getAllDocuments();
-  const embeddings = await store.getDocumentEmbeddings();
-
-  if (docs.length < 2) return [];
-
-  // 문서별 평균 임베딩 계산
-  const docVecs = new Map<string, { vec: number[]; title: string; filePath: string }>();
-  for (const doc of docs) {
-    const vec = embeddings.get(doc.id);
-    if (!vec || vec.length === 0) continue;
-    docVecs.set(doc.id, { vec: Array.from(vec), title: doc.title, filePath: doc.filePath });
-  }
-
-  const ids = [...docVecs.keys()];
-  const pairs: DuplicatePair[] = [];
-
-  // O(n²) — 1,200 문서면 ~720K 비교, 수 초 이내
-  for (let i = 0; i < ids.length; i++) {
-    for (let j = i + 1; j < ids.length; j++) {
-      const a = docVecs.get(ids[i])!;
-      const b = docVecs.get(ids[j])!;
-      const sim = cosineSimilarity(a.vec, b.vec);
-
-      if (sim >= threshold) {
-        pairs.push({
-          docA: { id: ids[i], title: a.title, filePath: a.filePath },
-          docB: { id: ids[j], title: b.title, filePath: b.filePath },
-          similarity: Math.round(sim * 1000) / 1000,
-        });
-      }
-    }
-
-    if (pairs.length >= limit * 2) break; // 충분히 찾으면 중단
-  }
-
-  return pairs
-    .sort((a, b) => b.similarity - a.similarity)
-    .slice(0, limit);
-}
-
-function cosineSimilarity(a: number[], b: number[]): number {
-  if (a.length !== b.length) return 0;
-  let dot = 0, normA = 0, normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom === 0 ? 0 : dot / denom;
-}

package/packages/core/src/intelligence/fsrs.ts

@@ -1,79 +0,0 @@
-// Design Ref: §1 — FSRS-6 알고리즘 (순수 함수)
-// Plan SC: SC-01 (R값 계산), SC-02 (stability 업데이트)
-
-/**
- * FSRS parameters tuned for knowledge notes (not flashcards).
- * Knowledge notes have longer natural retention than flashcards.
- */
-export const FSRS_PARAMS = {
-  initialStability: 7.0,  // 7 days for new notes
-  difficulty: 5.0,         // default difficulty (1~10)
-  // Stability growth factors
-  a: 0.4,
-  b: 0.6,
-  c: 0.2,
-  d: 1.0,
-  // Stability bonus for large/connected notes
-  sizeFactor: 0.5,        // additional days per 1000 chars
-  connectionFactor: 1.0,  // additional days per connection
-} as const;
-
-/**
- * Compute retrievability R(t) using FSRS power forgetting curve.
- * R(t) = (1 + t / (9 * S))^(-1)
- *
- * @param stabilityDays - Stability S (days until R drops to ~0.9)
- * @param elapsedDays - Days since last access
- * @returns Retrievability 0~1
- */
-export function computeRetrievability(stabilityDays: number, elapsedDays: number): number {
-  if (elapsedDays <= 0) return 1.0;
-  if (stabilityDays <= 0) return 0.0;
-  return Math.pow(1 + elapsedDays / (9 * stabilityDays), -1);
-}
-
-/**
- * Update stability after an access event (successful recall).
- * S' = S * (1 + a * D^(-b) * S^(-c) * (e^(d*(1-R)) - 1))
- *
- * @param currentS - Current stability
- * @param difficulty - Note difficulty (1~10)
- * @param currentR - Retrievability at access time
- * @returns New stability (always >= currentS)
- */
-export function updateStability(
-  currentS: number,
-  difficulty: number,
-  currentR: number,
-): number {
-  const { a, b, c, d } = FSRS_PARAMS;
-  const growth = a
-    * Math.pow(difficulty, -b)
-    * Math.pow(currentS, -c)
-    * (Math.exp(d * (1 - currentR)) - 1);
-  const newS = currentS * (1 + Math.max(0, growth));
-  // Cap at 365 days (1 year max stability)
-  return Math.min(newS, 365);
-}
-
-/**
- * Estimate initial stability based on note characteristics.
- * Longer notes and more connected notes are more stable.
- */
-export function estimateInitialStability(
-  contentLength: number,
-  connectionCount: number,
-): number {
-  const base = FSRS_PARAMS.initialStability;
-  const sizeBonus = Math.min(contentLength / 1000, 10) * FSRS_PARAMS.sizeFactor;
-  const connBonus = Math.min(connectionCount, 10) * FSRS_PARAMS.connectionFactor;
-  return base + sizeBonus + connBonus;
-}
-
-/**
- * Compute elapsed days between two ISO timestamps.
- */
-export function elapsedDays(from: string, to: string = new Date().toISOString()): number {
-  const msPerDay = 86400000;
-  return Math.max(0, (new Date(to).getTime() - new Date(from).getTime()) / msPerDay);
-}

package/packages/core/src/intelligence/gap-detector.ts

@@ -1,109 +0,0 @@
-// Design Ref: F01 — 지식 갭 탐지기
-// 클러스터 간 브릿지 노드 부족 영역 식별
-
-import type { VectorStore } from '../store/types.js';
-
-export interface KnowledgeGap {
-  clusterA: string;
-  clusterB: string;
-  bridgeCount: number;      // 연결 노드 수 (적을수록 갭)
-  suggestedTopic: string;   // 학습 추천 주제
-  severity: 'high' | 'medium' | 'low';
-}
-
-export interface GapReport {
-  totalClusters: number;
-  totalGaps: number;
-  gaps: KnowledgeGap[];
-  isolatedNodes: Array<{ id: string; title: string; connections: number }>;
-}
-
-/**
- * 그래프 데이터에서 지식 갭을 탐지.
- * - 클러스터 간 연결이 약한 영역
- * - 고립된 노드 (연결 0~1개)
- */
-export async function detectKnowledgeGaps(
-  store: VectorStore,
-  graphData?: any, // buildGraphData 결과 (없으면 직접 계산)
-): Promise<GapReport> {
-  const docs = await store.getAllDocuments();
-  const embeddings = await store.getDocumentEmbeddings();
-
-  // 그래프 데이터가 없으면 간단히 계산
-  if (!graphData) {
-    const { buildGraphData } = await import('../api/graph-data.js');
-    graphData = await buildGraphData(store);
-  }
-
-  const { nodes, edges, clusters } = graphData;
-
-  // 1. 클러스터 간 연결 수 매트릭스
-  const clusterEdges = new Map<string, number>();
-  for (const edge of edges) {
-    const nodeA = nodes.find((n: any) => n.id === edge.source);
-    const nodeB = nodes.find((n: any) => n.id === edge.target);
-    if (!nodeA || !nodeB || nodeA.clusterId === nodeB.clusterId) continue;
-
-    const key = [
-      Math.min(nodeA.clusterId, nodeB.clusterId),
-      Math.max(nodeA.clusterId, nodeB.clusterId),
-    ].join('-');
-    clusterEdges.set(key, (clusterEdges.get(key) ?? 0) + 1);
-  }
-
-  // 2. 갭 식별 (클러스터 쌍 중 연결이 적은 것)
-  const gaps: KnowledgeGap[] = [];
-  const clusterLabels = new Map<number, string>(clusters.map((c: any) => [c.id, c.label as string]));
-
-  for (let i = 0; i < clusters.length; i++) {
-    for (let j = i + 1; j < clusters.length; j++) {
-      const key = `${Math.min(clusters[i].id, clusters[j].id)}-${Math.max(clusters[i].id, clusters[j].id)}`;
-      const bridgeCount = clusterEdges.get(key) ?? 0;
-
-      // 연결이 3개 미만이면 갭
-      if (bridgeCount < 3) {
-        const labelA = clusterLabels.get(clusters[i].id) ?? `Cluster ${clusters[i].id}`;
-        const labelB = clusterLabels.get(clusters[j].id) ?? `Cluster ${clusters[j].id}`;
-
-        // 제안 주제: 두 클러스터 이름에서 추출
-        const nameA = labelA.replace(/\s*\(\d+\)$/, '');
-        const nameB = labelB.replace(/\s*\(\d+\)$/, '');
-
-        gaps.push({
-          clusterA: labelA,
-          clusterB: labelB,
-          bridgeCount,
-          suggestedTopic: `${nameA} + ${nameB} 연결 지식`,
-          severity: bridgeCount === 0 ? 'high' : bridgeCount < 2 ? 'medium' : 'low',
-        });
-      }
-    }
-  }
-
-  // 3. 고립 노드 (연결 1개 이하)
-  const connectionCounts = new Map<string, number>();
-  for (const edge of edges) {
-    connectionCounts.set(edge.source, (connectionCounts.get(edge.source) ?? 0) + 1);
-    connectionCounts.set(edge.target, (connectionCounts.get(edge.target) ?? 0) + 1);
-  }
-
-  const isolatedNodes = nodes
-    .filter((n: any) => (connectionCounts.get(n.id) ?? 0) <= 1)
-    .map((n: any) => ({
-      id: n.id,
-      title: n.label,
-      connections: connectionCounts.get(n.id) ?? 0,
-    }))
-    .slice(0, 20);
-
-  return {
-    totalClusters: clusters.length,
-    totalGaps: gaps.filter(g => g.severity !== 'low').length,
-    gaps: gaps.sort((a, b) => {
-      const sev = { high: 0, medium: 1, low: 2 };
-      return sev[a.severity] - sev[b.severity];
-    }).slice(0, 15),
-    isolatedNodes,
-  };
-}

package/packages/core/src/intelligence/learning-path.ts

@@ -1,86 +0,0 @@
-// AI Learning Path Generator (F-A11)
-// Analyzes decay + gaps + relationships to recommend what to review/learn next
-
-import type { DecayReport, DecayState } from './types.js';
-
-export interface LearningItem {
-  documentId: string;
-  title: string;
-  reason: string;
-  priority: 'critical' | 'important' | 'suggested';
-  score: number; // 0-100, higher = more urgent
-  category: 'review' | 'explore' | 'bridge';
-}
-
-export interface LearningPath {
-  items: LearningItem[];
-  summary: {
-    reviewCount: number;
-    exploreCount: number;
-    bridgeCount: number;
-    estimatedMinutes: number;
-  };
-  generatedAt: string;
-}
-
-export interface LearningPathInput {
-  decayReport: DecayReport;
-  gaps?: Array<{ clusterA: string; clusterB: string; severity: string; suggestedTopic: string }>;
-  recentSearches?: string[];
-}
-
-export function generateLearningPath(input: LearningPathInput, limit = 15): LearningPath {
-  const items: LearningItem[] = [];
-
-  // 1. Review: decaying notes (highest priority)
-  if (input.decayReport.topDecaying) {
-    for (const d of input.decayReport.topDecaying) {
-      const r = d.retrievability ?? 0;
-      const urgency = (1 - r) * 100;
-      items.push({
-        documentId: d.documentId,
-        title: d.title,
-        reason: r < 0.3
-          ? `Critical: ${Math.round(r * 100)}% retrievability, ${d.daysSinceAccess}d since last access`
-          : `Fading: ${Math.round(r * 100)}% retrievability, review to strengthen memory`,
-        priority: r < 0.3 ? 'critical' : r < 0.5 ? 'important' : 'suggested',
-        score: Math.round(urgency),
-        category: 'review',
-      });
-    }
-  }
-
-  // 2. Bridge: knowledge gaps
-  if (input.gaps) {
-    for (const gap of input.gaps) {
-      const severityScore = gap.severity === 'high' ? 80 : gap.severity === 'medium' ? 60 : 40;
-      items.push({
-        documentId: '',
-        title: gap.suggestedTopic || `${gap.clusterA} × ${gap.clusterB}`,
-        reason: `Gap between "${gap.clusterA}" and "${gap.clusterB}" — creating a bridge note strengthens your knowledge network`,
-        priority: gap.severity === 'high' ? 'important' : 'suggested',
-        score: severityScore,
-        category: 'bridge',
-      });
-    }
-  }
-
-  // Sort by score descending
-  items.sort((a, b) => b.score - a.score);
-
-  const selected = items.slice(0, limit);
-  const reviewCount = selected.filter(i => i.category === 'review').length;
-  const exploreCount = selected.filter(i => i.category === 'explore').length;
-  const bridgeCount = selected.filter(i => i.category === 'bridge').length;
-
-  return {
-    items: selected,
-    summary: {
-      reviewCount,
-      exploreCount,
-      bridgeCount,
-      estimatedMinutes: reviewCount * 3 + exploreCount * 5 + bridgeCount * 8,
-    },
-    generatedAt: new Date().toISOString(),
-  };
-}

package/packages/core/src/intelligence/notifications.ts

@@ -1,106 +0,0 @@
-// Notification Center (F-A05)
-// Configurable alerts for decay thresholds, gap detection, weekly digest
-
-import type { DecayReport } from './types.js';
-
-export interface NotificationConfig {
-  decay: {
-    enabled: boolean;
-    criticalThreshold: number; // R value (0-1), default 0.3
-    warningThreshold: number;  // default 0.5
-  };
-  gaps: {
-    enabled: boolean;
-    minSeverity: 'low' | 'medium' | 'high'; // default 'medium'
-  };
-  digest: {
-    enabled: boolean;
-    frequency: 'daily' | 'weekly' | 'off'; // default 'weekly'
-  };
-}
-
-export interface Notification {
-  id: string;
-  type: 'decay_critical' | 'decay_warning' | 'gap_detected' | 'digest';
-  title: string;
-  message: string;
-  timestamp: string;
-  priority: 'high' | 'medium' | 'low';
-  data?: Record<string, unknown>;
-}
-
-const DEFAULT_CONFIG: NotificationConfig = {
-  decay: { enabled: true, criticalThreshold: 0.3, warningThreshold: 0.5 },
-  gaps: { enabled: true, minSeverity: 'medium' },
-  digest: { enabled: true, frequency: 'weekly' },
-};
-
-export function checkNotifications(
-  decayReport: DecayReport,
-  gaps: Array<{ severity: string; clusterA: string; clusterB: string }>,
-  config: Partial<NotificationConfig> = {},
-): Notification[] {
-  const cfg = {
-    decay: { ...DEFAULT_CONFIG.decay, ...config.decay },
-    gaps: { ...DEFAULT_CONFIG.gaps, ...config.gaps },
-    digest: { ...DEFAULT_CONFIG.digest, ...config.digest },
-  };
-  const notifications: Notification[] = [];
-  const now = new Date().toISOString();
-
-  // Decay alerts
-  if (cfg.decay.enabled && decayReport.topDecaying) {
-    const criticals = decayReport.topDecaying.filter(d => d.retrievability < cfg.decay.criticalThreshold);
-    const warnings = decayReport.topDecaying.filter(d =>
-      d.retrievability >= cfg.decay.criticalThreshold && d.retrievability < cfg.decay.warningThreshold
-    );
-
-    if (criticals.length > 0) {
-      notifications.push({
-        id: `decay-critical-${Date.now()}`,
-        type: 'decay_critical',
-        title: `${criticals.length} notes critically fading`,
-        message: criticals.slice(0, 3).map(d => `"${d.title}" (${Math.round(d.retrievability * 100)}%)`).join(', '),
-        timestamp: now,
-        priority: 'high',
-        data: { count: criticals.length, notes: criticals.slice(0, 5).map(d => d.title) },
-      });
-    }
-
-    if (warnings.length > 0) {
-      notifications.push({
-        id: `decay-warning-${Date.now()}`,
-        type: 'decay_warning',
-        title: `${warnings.length} notes starting to fade`,
-        message: `Average retrievability: ${Math.round(decayReport.averageR * 100)}%`,
-        timestamp: now,
-        priority: 'medium',
-        data: { count: warnings.length },
-      });
-    }
-  }
-
-  // Gap alerts
-  if (cfg.gaps.enabled) {
-    const severityOrder = { high: 3, medium: 2, low: 1 };
-    const minLevel = severityOrder[cfg.gaps.minSeverity] ?? 2;
-    const significantGaps = gaps.filter(g => (severityOrder[g.severity as keyof typeof severityOrder] ?? 0) >= minLevel);
-
-    if (significantGaps.length > 0) {
-      notifications.push({
-        id: `gap-${Date.now()}`,
-        type: 'gap_detected',
-        title: `${significantGaps.length} knowledge gaps detected`,
-        message: significantGaps.slice(0, 2).map(g => `${g.clusterA} ↔ ${g.clusterB}`).join(', '),
-        timestamp: now,
-        priority: significantGaps.some(g => g.severity === 'high') ? 'high' : 'medium',
-        data: { count: significantGaps.length },
-      });
-    }
-  }
-
-  return notifications.sort((a, b) => {
-    const p = { high: 3, medium: 2, low: 1 };
-    return (p[b.priority] ?? 0) - (p[a.priority] ?? 0);
-  });
-}