stellavault 0.2.0 → 0.2.1

package/packages/core/src/intelligence/predictive-gaps.ts

@@ -1,94 +0,0 @@
-// Predictive Gap Analysis (F-A14)
-// Based on graph topology, predict knowledge areas worth exploring
-
-import type { VectorStore } from '../store/types.js';
-
-export interface PredictedGap {
-  topic: string;
-  reason: string;
-  confidence: number; // 0-1
-  relatedTopics: string[];
-  category: 'adjacent' | 'bridging' | 'deepening';
-}
-
-/**
- * Analyze graph topology to predict knowledge worth acquiring.
- * Uses degree centrality, cluster density, and tag co-occurrence.
- */
-export async function predictKnowledgeGaps(
-  store: VectorStore,
-  limit = 10,
-): Promise<PredictedGap[]> {
-  const docs = await store.getAllDocuments();
-  const topics = await store.getTopics();
-
-  if (docs.length < 10) return [];
-
-  const predictions: PredictedGap[] = [];
-
-  // 1. Find isolated tags (topics that appear rarely and could be expanded)
-  const topicCounts = new Map(topics.map(t => [t.topic, t.count]));
-  const avgCount = topics.reduce((s, t) => s + t.count, 0) / (topics.length || 1);
-
-  // Tags that appear 1-2 times — potential deepening opportunities
-  const sparseTopics = topics.filter(t => t.count <= 2 && t.count > 0);
-  for (const t of sparseTopics.slice(0, 5)) {
-    predictions.push({
-      topic: t.topic,
-      reason: `Only ${t.count} note(s) on "${t.topic}" — deepening this area would strengthen your knowledge network`,
-      confidence: 0.6,
-      relatedTopics: findCoOccurring(t.topic, docs),
-      category: 'deepening',
-    });
-  }
-
-  // 2. Find tag pairs that never co-occur but are both frequent
-  const frequentTopics = topics.filter(t => t.count >= avgCount).slice(0, 20);
-  const coOccurrence = new Map<string, Set<string>>();
-
-  for (const doc of docs) {
-    for (const tagA of doc.tags) {
-      if (!coOccurrence.has(tagA)) coOccurrence.set(tagA, new Set());
-      for (const tagB of doc.tags) {
-        if (tagA !== tagB) coOccurrence.get(tagA)!.add(tagB);
-      }
-    }
-  }
-
-  for (let i = 0; i < frequentTopics.length; i++) {
-    for (let j = i + 1; j < frequentTopics.length; j++) {
-      const a = frequentTopics[i].topic;
-      const b = frequentTopics[j].topic;
-      const aCoOccurs = coOccurrence.get(a) ?? new Set();
-
-      if (!aCoOccurs.has(b)) {
-        predictions.push({
-          topic: `${a} × ${b}`,
-          reason: `"${a}" (${frequentTopics[i].count} notes) and "${b}" (${frequentTopics[j].count} notes) are both well-known but never connected — bridging them could reveal insights`,
-          confidence: 0.7,
-          relatedTopics: [a, b],
-          category: 'bridging',
-        });
-      }
-    }
-  }
-
-  // 3. Adjacent topics — topics that co-occur with many of your topics but you don't have
-  // (This would ideally use external knowledge, but we approximate with tag patterns)
-
-  return predictions
-    .sort((a, b) => b.confidence - a.confidence)
-    .slice(0, limit);
-}
-
-function findCoOccurring(topic: string, docs: Array<{ tags: string[] }>): string[] {
-  const coTopics = new Map<string, number>();
-  for (const doc of docs) {
-    if (doc.tags.includes(topic)) {
-      for (const t of doc.tags) {
-        if (t !== topic) coTopics.set(t, (coTopics.get(t) ?? 0) + 1);
-      }
-    }
-  }
-  return [...coTopics.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([t]) => t);
-}

package/packages/core/src/intelligence/semantic-versioning.ts

@@ -1,97 +0,0 @@
-// Knowledge Semantic Versioning (F-A13)
-// Track how a note's MEANING changes over time via embedding drift
-
-export interface SemanticVersion {
-  documentId: string;
-  timestamp: string;
-  embeddingHash: string; // first 8 chars of embedding vector hash
-  drift: number; // cosine distance from previous version (0 = identical, 2 = opposite)
-}
-
-export interface SemanticChangelog {
-  documentId: string;
-  title: string;
-  versions: SemanticVersion[];
-  totalDrift: number; // cumulative semantic drift
-  stability: number; // 0-1, how stable the meaning has been
-}
-
-/**
- * Compute semantic drift between two embedding vectors.
- * Returns cosine distance (0 = identical, 1 = orthogonal, 2 = opposite)
- */
-export function computeSemanticDrift(vecA: number[], vecB: number[]): number {
-  if (vecA.length !== vecB.length || vecA.length === 0) return 0;
-  let dot = 0, na = 0, nb = 0;
-  for (let i = 0; i < vecA.length; i++) {
-    dot += vecA[i] * vecB[i];
-    na += vecA[i] * vecA[i];
-    nb += vecB[i] * vecB[i];
-  }
-  const denom = Math.sqrt(na) * Math.sqrt(nb);
-  const similarity = denom === 0 ? 0 : dot / denom;
-  return 1 - similarity; // cosine distance
-}
-
-/**
- * Hash an embedding vector for quick comparison
- */
-export function hashEmbedding(vec: number[]): string {
-  let hash = 0;
-  for (let i = 0; i < Math.min(vec.length, 50); i++) {
-    hash = ((hash << 5) - hash + Math.round(vec[i] * 10000)) | 0;
-  }
-  return Math.abs(hash).toString(36).slice(0, 8);
-}
-
-/**
- * Analyze semantic stability of a document given its embedding history.
- * In practice, we compare current embedding vs initial embedding to measure total drift.
- */
-export function analyzeSemanticStability(
-  currentVec: number[],
-  title: string,
-  documentId: string,
-): SemanticChangelog {
-  // Single-point analysis (no history yet — foundation for future multi-version tracking)
-  const now = new Date().toISOString();
-  const hash = hashEmbedding(currentVec);
-
-  return {
-    documentId,
-    title,
-    versions: [{
-      documentId,
-      timestamp: now,
-      embeddingHash: hash,
-      drift: 0,
-    }],
-    totalDrift: 0,
-    stability: 1.0,
-  };
-}
-
-/**
- * Compare two sets of embeddings to find documents with the most semantic drift.
- * Useful for "what changed the most since last index?"
- */
-export function findMostDrifted(
-  previousEmbeddings: Map<string, number[]>,
-  currentEmbeddings: Map<string, number[]>,
-  titles: Map<string, string>,
-  limit = 10,
-): Array<{ documentId: string; title: string; drift: number }> {
-  const drifts: Array<{ documentId: string; title: string; drift: number }> = [];
-
-  for (const [docId, currentVec] of currentEmbeddings) {
-    const prevVec = previousEmbeddings.get(docId);
-    if (!prevVec) continue;
-
-    const drift = computeSemanticDrift(prevVec, currentVec);
-    if (drift > 0.01) { // ignore trivial changes
-      drifts.push({ documentId: docId, title: titles.get(docId) ?? docId, drift: Math.round(drift * 1000) / 1000 });
-    }
-  }
-
-  return drifts.sort((a, b) => b.drift - a.drift).slice(0, limit);
-}

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

@@ -1,28 +0,0 @@
-// Design Ref: §2.2 — FSRS 감쇠 타입 정의
-
-export interface DecayState {
-  documentId: string;
-  stability: number;      // days until R drops to 0.9
-  difficulty: number;      // 1~10
-  lastAccess: string;      // ISO timestamp
-  retrievability: number;  // 0~1 (computed)
-}
-
-export interface AccessEvent {
-  documentId: string;
-  type: 'view' | 'search' | 'mcp_query';
-  timestamp: string;
-}
-
-export interface DecayReport {
-  totalDocuments: number;
-  decayingCount: number;   // R < 0.5
-  criticalCount: number;   // R < 0.3
-  averageR: number;
-  topDecaying: Array<DecayState & { title: string; daysSinceAccess: number }>;
-  clusterHealth: Array<{
-    label: string;
-    avgR: number;
-    count: number;
-  }>;
-}

package/packages/core/src/mcp/custom-tools.ts

@@ -1,97 +0,0 @@
-// Custom MCP Tool Builder (F-A16)
-// Load YAML/JSON tool definitions without coding
-
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import type { SearchEngine } from '../search/index.js';
-
-export interface CustomToolDef {
-  name: string;
-  description: string;
-  query_template: string; // e.g. "{{topic}} best practices"
-  output_format?: 'full' | 'titles' | 'snippets';
-  limit?: number;
-  filter_tags?: string[];
-}
-
-export interface LoadedCustomTool {
-  name: string;
-  description: string;
-  inputSchema: {
-    type: 'object';
-    properties: Record<string, { type: string; description: string }>;
-    required?: string[];
-  };
-  handler: (args: Record<string, unknown>) => Promise<{ content: Array<{ type: 'text'; text: string }> }>;
-}
-
-export function loadCustomTools(toolsDir: string, searchEngine: SearchEngine): LoadedCustomTool[] {
-  if (!existsSync(toolsDir)) return [];
-
-  const tools: LoadedCustomTool[] = [];
-  const files = readdirSync(toolsDir).filter(f => f.endsWith('.json') || f.endsWith('.yaml') || f.endsWith('.yml'));
-
-  for (const file of files) {
-    try {
-      const raw = readFileSync(join(toolsDir, file), 'utf-8');
-      let def: CustomToolDef;
-
-      if (file.endsWith('.json')) {
-        def = JSON.parse(raw);
-      } else {
-        // Simple YAML parser for basic key:value format
-        def = parseSimpleYaml(raw);
-      }
-
-      if (!def.name || !def.description || !def.query_template) continue;
-
-      // Extract template variables ({{var}})
-      const vars = [...def.query_template.matchAll(/\{\{(\w+)\}\}/g)].map(m => m[1]);
-
-      tools.push({
-        name: def.name,
-        description: def.description,
-        inputSchema: {
-          type: 'object',
-          properties: Object.fromEntries(vars.map(v => [v, { type: 'string', description: `Value for ${v}` }])),
-          required: vars,
-        },
-        handler: async (args) => {
-          let query = def.query_template;
-          for (const [key, val] of Object.entries(args)) {
-            query = query.replace(`{{${key}}}`, String(val));
-          }
-
-          const results = await searchEngine.search({ query, limit: def.limit ?? 5 });
-          const format = def.output_format ?? 'snippets';
-
-          let text: string;
-          if (format === 'titles') {
-            text = results.map(r => `- ${r.document.title}`).join('\n');
-          } else if (format === 'full') {
-            text = results.map(r => `## ${r.document.title}\n\n${r.document.content.slice(0, 1000)}`).join('\n\n---\n\n');
-          } else {
-            text = results.map(r => `**${r.document.title}** (${Math.round(r.score * 100)}%)\n${r.chunk.content.slice(0, 200)}...`).join('\n\n');
-          }
-
-          return { content: [{ type: 'text' as const, text: text || 'No results found.' }] };
-        },
-      });
-    } catch {
-      // Skip invalid tool files
-    }
-  }
-
-  return tools;
-}
-
-function parseSimpleYaml(raw: string): CustomToolDef {
-  const result: Record<string, string> = {};
-  for (const line of raw.split('\n')) {
-    const match = line.match(/^(\w[\w_]*)\s*:\s*(.+)$/);
-    if (match) {
-      result[match[1]] = match[2].replace(/^["']|["']$/g, '').trim();
-    }
-  }
-  return result as unknown as CustomToolDef;
-}

package/packages/core/src/mcp/server.ts

@@ -1,142 +0,0 @@
-// Design Ref: §4.1 — MCP Server (stdio + SSE)
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import type { VectorStore } from '../store/types.js';
-import type { SearchEngine } from '../search/index.js';
-import { searchToolDef, handleSearch } from './tools/search.js';
-import { getDocumentToolDef, handleGetDocument } from './tools/get-document.js';
-import { listTopicsToolDef, handleListTopics } from './tools/list-topics.js';
-import { getRelatedToolDef, handleGetRelated } from './tools/get-related.js';
-import { generateClaudeMdToolDef, handleGenerateClaudeMd } from './tools/generate-claude-md.js';
-import { createSnapshotToolDef, loadSnapshotToolDef, handleCreateSnapshot, handleLoadSnapshot } from './tools/snapshot.js';
-import { logDecisionToolDef, findDecisionsToolDef, handleLogDecision, handleFindDecisions } from './tools/decision-journal.js';
-import { exportToolDef, handleExport } from './tools/export.js';
-import { getDecayStatusToolDef, handleGetDecayStatus } from './tools/decay.js';
-import { getMorningBriefToolDef, handleGetMorningBrief } from './tools/brief.js';
-import { createLearningPathTool } from './tools/learning-path.js';
-import type { DecayEngine } from '../intelligence/decay-engine.js';
-
-export interface McpServerOptions {
-  store: VectorStore;
-  searchEngine: SearchEngine;
-  vaultPath?: string;
-  decayEngine?: DecayEngine;
-}
-
-export function createMcpServer(options: McpServerOptions) {
-  const { store, searchEngine, vaultPath = '', decayEngine } = options;
-
-  const learningPathTool = createLearningPathTool(store);
-
-  const server = new Server(
-    { name: 'stellavault', version: '0.2.0' },
-    { capabilities: { tools: {} } },
-  );
-
-  // List tools
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-      searchToolDef, getDocumentToolDef, listTopicsToolDef, getRelatedToolDef,
-      generateClaudeMdToolDef, createSnapshotToolDef, loadSnapshotToolDef,
-      logDecisionToolDef, findDecisionsToolDef, exportToolDef,
-      ...(decayEngine ? [getDecayStatusToolDef, getMorningBriefToolDef] : []),
-      { name: learningPathTool.name, description: learningPathTool.description, inputSchema: learningPathTool.inputSchema },
-    ],
-  }));
-
-  // Call tool
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-
-    try {
-      let result: unknown;
-      switch (name) {
-        case 'search':
-          result = await handleSearch(searchEngine, args as any);
-          // MCP 검색 이벤트 기록
-          if (decayEngine && result && typeof result === 'object' && 'results' in (result as any)) {
-            const now = new Date().toISOString();
-            for (const r of (result as any).results ?? []) {
-              if (r.documentId) decayEngine.recordAccess({ documentId: r.documentId, type: 'mcp_query', timestamp: now }).catch(() => {});
-            }
-          }
-          break;
-        case 'get-document':
-          result = await handleGetDocument(store, args as any);
-          // MCP 문서 조회 이벤트 기록
-          if (decayEngine && result && typeof result === 'object' && 'id' in (result as any)) {
-            decayEngine.recordAccess({ documentId: (result as any).id, type: 'mcp_query', timestamp: new Date().toISOString() }).catch(() => {});
-          }
-          break;
-        case 'list-topics':
-          result = await handleListTopics(store);
-          break;
-        case 'get-related':
-          result = await handleGetRelated(store, searchEngine, args as any);
-          break;
-        case 'generate-claude-md':
-          result = await handleGenerateClaudeMd(searchEngine, store, args as any);
-          break;
-        case 'create-snapshot':
-          result = await handleCreateSnapshot(searchEngine, args as any);
-          break;
-        case 'load-snapshot':
-          result = await handleLoadSnapshot(args as any);
-          break;
-        case 'log-decision':
-          result = await handleLogDecision(vaultPath, args as any);
-          break;
-        case 'find-decisions':
-          result = await handleFindDecisions(vaultPath, args as any);
-          break;
-        case 'export':
-          result = await handleExport(store, args as any);
-          break;
-        case 'get-decay-status':
-          if (!decayEngine) { result = { error: 'Decay engine not available' }; break; }
-          result = await handleGetDecayStatus(decayEngine, args as any);
-          break;
-        case 'get-morning-brief':
-          if (!decayEngine) { result = { error: 'Decay engine not available' }; break; }
-          result = await handleGetMorningBrief(decayEngine, store);
-          break;
-        case 'get-learning-path':
-          result = await learningPathTool.handler(args as any);
-          return result as any;
-        default:
-          return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
-      }
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
-    }
-  });
-
-  return {
-    async startStdio() {
-      const transport = new StdioServerTransport();
-      await server.connect(transport);
-    },
-    async startHttp(port: number = 3334) {
-      const { createServer } = await import('node:http');
-      const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => `sv-${Date.now()}` });
-      await server.connect(transport);
-
-      const httpServer = createServer(async (req, res) => {
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-        if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
-        await transport.handleRequest(req, res);
-      });
-      httpServer.listen(port, '127.0.0.1', () => {
-        console.error(`🔌 MCP HTTP server running at http://127.0.0.1:${port}/mcp`);
-      });
-    },
-    server,
-  };
-}

package/packages/core/src/mcp/tools/agentic-graph.ts

@@ -1,96 +0,0 @@
-// Agentic Graph Construction (P3-F23)
-// AI가 MCP 세션 중 실시간으로 그래프 노드/엣지 생성
-
-import type { VectorStore } from '../../store/types.js';
-import type { Embedder } from '../../indexer/embedder.js';
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-export function createAgenticGraphTools(store: VectorStore, embedder: Embedder, vaultPath: string) {
-  return [
-    {
-      name: 'create-knowledge-node',
-      description: 'Create a new knowledge note in the vault. AI agents use this to capture decisions, insights, or summaries during a conversation. The note is automatically indexed and appears in the knowledge graph.',
-      inputSchema: {
-        type: 'object' as const,
-        properties: {
-          title: { type: 'string', description: 'Note title' },
-          content: { type: 'string', description: 'Note content (markdown)' },
-          tags: { type: 'array', items: { type: 'string' }, description: 'Tags for categorization' },
-          type: { type: 'string', description: 'Note type: note, decision, insight, summary' },
-          folder: { type: 'string', description: 'Vault subfolder (default: 01_Knowledge)' },
-        },
-        required: ['title', 'content'],
-      },
-      async handler(args: { title: string; content: string; tags?: string[]; type?: string; folder?: string }) {
-        const { title, content, tags = [], type = 'note', folder = '01_Knowledge' } = args;
-
-        // frontmatter 생성
-        const date = new Date().toISOString().slice(0, 10);
-        const fm = [
-          '---',
-          `title: "${title}"`,
-          `type: ${type}`,
-          `source: agent`,
-          `tags: [${tags.map(t => `"${t}"`).join(', ')}]`,
-          `created: ${date}`,
-          `auto_generated: true`,
-          '---',
-        ].join('\n');
-
-        const fullContent = `${fm}\n\n# ${title}\n\n${content}`;
-
-        // vault에 파일 저장
-        const safeTitle = title.replace(/[<>:"/\\|?*]/g, '').replace(/\s+/g, ' ').trim().slice(0, 80);
-        const dir = join(vaultPath, folder);
-        mkdirSync(dir, { recursive: true });
-        const filePath = join(dir, `${safeTitle}.md`);
-        writeFileSync(filePath, fullContent, 'utf-8');
-
-        return {
-          content: [{
-            type: 'text' as const,
-            text: `Created knowledge node: "${title}" at ${folder}/${safeTitle}.md\nTags: ${tags.join(', ') || 'none'}\nType: ${type}\n\nRun 'stellavault index' to add to the graph.`,
-          }],
-        };
-      },
-    },
-    {
-      name: 'create-knowledge-link',
-      description: 'Create a link between two existing notes by adding a wiki-link reference. Strengthens connections in the knowledge graph.',
-      inputSchema: {
-        type: 'object' as const,
-        properties: {
-          sourceTitle: { type: 'string', description: 'Title of the source note' },
-          targetTitle: { type: 'string', description: 'Title of the target note to link to' },
-          context: { type: 'string', description: 'Why these notes are related (added as a comment)' },
-        },
-        required: ['sourceTitle', 'targetTitle'],
-      },
-      async handler(args: { sourceTitle: string; targetTitle: string; context?: string }) {
-        const docs = await store.getAllDocuments();
-        const source = docs.find(d => d.title.toLowerCase().includes(args.sourceTitle.toLowerCase()));
-
-        if (!source) {
-          return { content: [{ type: 'text' as const, text: `Source note "${args.sourceTitle}" not found.` }] };
-        }
-
-        // 소스 노트에 링크 추가
-        const { readFileSync } = await import('node:fs');
-        const fullPath = join(vaultPath, source.filePath);
-        let existing = '';
-        try { existing = readFileSync(fullPath, 'utf-8'); } catch { /* new file */ }
-
-        const linkSection = `\n\n## Related\n\n- [[${args.targetTitle}]]${args.context ? ` — ${args.context}` : ''}\n`;
-        writeFileSync(fullPath, existing + linkSection, 'utf-8');
-
-        return {
-          content: [{
-            type: 'text' as const,
-            text: `Linked "${source.title}" → "${args.targetTitle}"${args.context ? ` (${args.context})` : ''}`,
-          }],
-        };
-      },
-    },
-  ];
-}

package/packages/core/src/mcp/tools/brief.ts

@@ -1,49 +0,0 @@
-// MCP tool: get-morning-brief — Claude 세션 시작 시 자동 브리핑
-
-import type { DecayEngine } from '../../intelligence/decay-engine.js';
-import type { VectorStore } from '../../store/types.js';
-
-export const getMorningBriefToolDef = {
-  name: 'get-morning-brief',
-  description: '오늘의 지식 브리핑을 제공합니다. 감쇠 상태, 리뷰 대상, 최근 활동을 요약합니다. 세션 시작 시 호출하면 유용합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {},
-  },
-};
-
-export async function handleGetMorningBrief(
-  decayEngine: DecayEngine,
-  store: VectorStore,
-) {
-  const stats = await store.getStats();
-  const report = await decayEngine.computeAll();
-
-  const reviewList = report.topDecaying.slice(0, 5).map(d => ({
-    title: d.title,
-    retrievability: Math.round(d.retrievability * 100) / 100,
-    daysSinceAccess: d.daysSinceAccess,
-  }));
-
-  const unhealthyClusters = report.clusterHealth
-    .filter(c => c.avgR < 0.6)
-    .slice(0, 3)
-    .map(c => ({ label: c.label, avgR: c.avgR, count: c.count }));
-
-  return {
-    greeting: `📚 ${stats.documentCount}개 노트, 전체 건강도 R=${report.averageR}`,
-    summary: {
-      totalDocs: stats.documentCount,
-      averageR: report.averageR,
-      decaying: report.decayingCount,
-      critical: report.criticalCount,
-    },
-    reviewSuggestions: reviewList,
-    unhealthyClusters,
-    tip: report.criticalCount > 0
-      ? `⚠️ ${report.criticalCount}개 노트가 위험 수준입니다. 'stellavault review'로 리뷰하세요.`
-      : report.decayingCount > 0
-        ? `📋 ${report.decayingCount}개 노트가 감쇠 중입니다.`
-        : '✨ 모든 지식이 건강합니다!',
-  };
-}

package/packages/core/src/mcp/tools/decay.ts

@@ -1,40 +0,0 @@
-// Design Ref: §4.2 — MCP tool: get-decay-status
-// Plan SC: SC-04
-
-import type { DecayEngine } from '../../intelligence/decay-engine.js';
-
-export const getDecayStatusToolDef = {
-  name: 'get-decay-status',
-  description: '잊어가는 지식 노트를 조회합니다. 기억 강도(retrievability)가 낮은 노트 목록을 반환하여 리마인드합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      threshold: { type: 'number', description: '감쇠 임계값 (0~1, default: 0.5). 이 값 이하인 노트를 반환' },
-      limit: { type: 'number', description: '반환할 최대 노트 수 (default: 20)' },
-    },
-  },
-};
-
-export async function handleGetDecayStatus(
-  decayEngine: DecayEngine,
-  args: { threshold?: number; limit?: number },
-) {
-  const threshold = args.threshold ?? 0.5;
-  const limit = args.limit ?? 20;
-
-  const decaying = await decayEngine.getDecaying(threshold, limit);
-
-  return {
-    count: decaying.length,
-    threshold,
-    notes: decaying.map(d => ({
-      title: d.title,
-      retrievability: Math.round(d.retrievability * 100) / 100,
-      stability: Math.round(d.stability * 10) / 10,
-      lastAccess: d.lastAccess,
-    })),
-    tip: decaying.length > 0
-      ? `${decaying.length}개의 노트를 잊어가고 있습니다. 리뷰를 권장합니다.`
-      : '모든 지식이 건강한 상태입니다!',
-  };
-}