@jungjaehoon/mama-server 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jungjaehoon/mama-server",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "MAMA MCP Server - Memory-Augmented MCP Assistant for Claude Code & Desktop",
   "main": "src/server.js",
   "bin": {

package/src/db/migrations/008-fix-auto-link-defaults.sql

@@ -0,0 +1,43 @@
+-- Migration: 008-fix-auto-link-defaults.sql
+-- Description: Fix auto-generated links and update default values
+-- Date: 2025-11-25
+--
+-- Problem: Migration 006 set incorrect defaults:
+--   - created_by DEFAULT 'user' (should be 'llm' for auto-generated)
+--   - approved_by_user DEFAULT 1 (should be 0 for pending approval)
+--
+-- This caused auto-generated links to be indistinguishable from user-approved links.
+--
+-- Solution:
+-- 1. Identify auto-generated links by pattern matching reason field
+-- 2. Mark them as created_by='llm', approved_by_user=0
+-- 3. Note: Cannot change column defaults in SQLite, so application code must handle this
+
+-- Step 1: Mark auto-generated links (identifiable by pattern in reason field)
+-- Pattern: "Refines previous approach (similarity: X.XX)" or similar auto-generated reasons
+UPDATE decision_edges
+SET
+  created_by = 'llm',
+  approved_by_user = 0
+WHERE reason LIKE '%similarity:%'
+   OR reason LIKE '%Refines previous approach%'
+   OR reason LIKE '%auto%'
+   OR reason LIKE '%Auto%';
+
+-- Step 2: Log the migration action
+INSERT INTO link_audit_log (from_id, to_id, relationship, action, actor, reason, created_at)
+SELECT
+  from_id,
+  to_id,
+  relationship,
+  'deprecated',
+  'system',
+  'Migration 008: Marked as auto-generated link requiring approval',
+  unixepoch()
+FROM decision_edges
+WHERE created_by = 'llm' AND approved_by_user = 0;
+
+-- Note: After this migration:
+-- - Auto-generated links will require explicit approval via approve_link tool
+-- - Users can review pending links with get_pending_links tool
+-- - New auto-generated links should set created_by='llm', approved_by_user=0

package/src/db/migrations/009-remove-auto-links.sql

@@ -0,0 +1,40 @@
+-- Migration: 009-remove-auto-links.sql
+-- Description: Remove all auto-generated links (noise cleanup)
+-- Date: 2025-11-25
+--
+-- Context: 2025-11-25 architecture decision
+-- - Analyzed 462 links: 366 refines (100% cross-topic noise), 56 supersedes (valid), 40 contradicts (mostly noise)
+-- - Key insight: LLM can infer decision evolution from time-ordered search results
+-- - Auto-link generation removed from decision-tracker.js
+-- - MCP tools consolidated from 11 to 4 (save, search, update, load_checkpoint)
+--
+-- This migration removes:
+-- 1. All 'refines' links (100% cross-topic noise)
+-- 2. All 'contradicts' links (unreliable without LLM judgment)
+-- 3. Keeps 'supersedes' links (same-topic, reliable)
+
+-- Step 1: Backup to audit log before deletion
+INSERT INTO link_audit_log (from_id, to_id, relationship, action, actor, reason, created_at)
+SELECT
+  from_id,
+  to_id,
+  relationship,
+  'deprecated',
+  'system',
+  'Migration 009: Removed auto-generated noise links (refines, contradicts)',
+  unixepoch()
+FROM decision_edges
+WHERE relationship IN ('refines', 'contradicts');
+
+-- Step 2: Delete noise links
+DELETE FROM decision_edges
+WHERE relationship IN ('refines', 'contradicts');
+
+-- Step 3: Verify remaining links are valid (supersedes only)
+-- This is a sanity check - should only have supersedes links remaining
+-- SELECT relationship, COUNT(*) FROM decision_edges GROUP BY relationship;
+
+-- Note: After this migration:
+-- - Only 'supersedes' edges remain (same-topic, created when decision replaces previous)
+-- - LLM will infer refines/contradicts from search results
+-- - No more auto-link generation in decision-tracker.js

package/src/mama/decision-tracker.js

@@ -87,9 +87,11 @@ async function createSupersedesEdge(fromId, toId, reason) {
   const adapter = getAdapter();
 
   try {
+    // Auto-generated links: created_by='llm', approved_by_user=0 (pending approval)
+    // This ensures they appear in get_pending_links and require explicit approval
     const stmt = adapter.prepare(`
-      INSERT INTO decision_edges (from_id, to_id, relationship, reason, created_at)
-      VALUES (?, ?, 'supersedes', ?, ?)
+      INSERT INTO decision_edges (from_id, to_id, relationship, reason, created_at, created_by, approved_by_user)
+      VALUES (?, ?, 'supersedes', ?, ?, 'llm', 0)
     `);
 
     await stmt.run(fromId, toId, reason, Date.now());
@@ -173,154 +175,22 @@ function detectRefinement(_detection, _sessionContext) {
   return null;
 }
 
-/**
- * Create refines edge (multi-parent relationship)
- *
- * Task 5.3: Implement refines edge creation
- * AC #5: Multi-parent refinement
- *
- * @param {string} fromId - New decision ID
- * @param {string} toId - Parent decision ID
- * @param {string} reason - Reason for refinement
- */
-async function createRefinesEdge(fromId, toId, reason) {
-  const adapter = getAdapter();
-
-  try {
-    const stmt = adapter.prepare(`
-      INSERT INTO decision_edges (from_id, to_id, relationship, reason, created_at)
-      VALUES (?, ?, 'refines', ?, ?)
-    `);
-
-    await stmt.run(fromId, toId, reason, Date.now());
-  } catch (error) {
-    throw new Error(`Failed to create refines edge: ${error.message}`);
-  }
-}
-
-/**
- * Detect conflicting decisions (same topic, different decision)
- *
- * Task 5.4: Detect conflicting decisions
- * AC #2, #5: Relationship types
- *
- * @param {string} topic - Decision topic
- * @param {string} newDecision - New decision value
- * @param {string} newId - New decision ID (to exclude from search)
- * @returns {Promise<Array<Object>>} Conflicting decisions
- */
-async function detectConflicts(topic, newDecision, newId) {
-  const adapter = getAdapter();
-
-  try {
-    // Find active decisions on same topic with different decision value
-    const stmt = adapter.prepare(`
-      SELECT * FROM decisions
-      WHERE topic = ?
-        AND decision != ?
-        AND id != ?
-        AND superseded_by IS NULL
-        AND outcome IS NULL
-      ORDER BY created_at DESC
-    `);
-
-    const conflicts = await stmt.all(topic, newDecision, newId);
-    return conflicts || [];
-  } catch (error) {
-    throw new Error(`Failed to detect conflicts: ${error.message}`);
-  }
-}
-
-/**
- * Create contradicts edge (conflicting relationship)
- *
- * Task 5.5: Create contradicts edges for conflicts
- * AC #2, #5: Relationship types
- *
- * @param {string} fromId - New decision ID
- * @param {string} toId - Conflicting decision ID
- * @param {string} reason - Reason for contradiction
- */
-async function createContradictsEdge(fromId, toId, reason) {
-  const adapter = getAdapter();
-
-  try {
-    const stmt = adapter.prepare(`
-      INSERT INTO decision_edges (from_id, to_id, relationship, reason, created_at)
-      VALUES (?, ?, 'contradicts', ?, ?)
-    `);
-
-    await stmt.run(fromId, toId, reason, Date.now());
-  } catch (error) {
-    throw new Error(`Failed to create contradicts edge: ${error.message}`);
-  }
-}
-
-/**
- * Find semantically related decisions using vector search
- *
- * Story 014.14: AC #1 - Vector Search for Related Decisions
- *
- * @param {string} decisionId - New decision ID (exclude from search)
- * @param {string} topic - Decision topic
- * @param {string} decision - Decision text
- * @param {string} reasoning - Decision reasoning
- * @returns {Promise<Array<Object>>} Related decisions with similarity scores
- */
-async function findRelatedDecisions(decisionId, topic, decision, reasoning) {
-  const { queryVectorSearch } = require('./memory-store');
-
-  try {
-    // Combine decision + reasoning for semantic search
-    const searchText = `${decision}. ${reasoning}`;
-
-    // Vector search params
-    const params = {
-      query: searchText,
-      limit: 10, // Get more candidates for filtering
-      threshold: 0.75, // Minimum similarity (Story 014.14: AC #1)
-      timeWindow: 90 * 24 * 60 * 60 * 1000, // Last 90 days (Story 014.14: AC #1)
-    };
-
-    // Query vector database
-    const results = await queryVectorSearch(params);
-
-    // Filter out self and return top 5
-    return results.filter((r) => r.id !== decisionId).slice(0, 5);
-  } catch (error) {
-    info(`[decision-tracker] Vector search failed, returning empty: ${error.message}`);
-    return []; // Graceful degradation
-  }
-}
-
-/**
- * Detect if reasoning contains conflict keywords
- *
- * Story 014.14: AC #3 - Contradicts Edge Detection
- *
- * @param {string} newReasoning - New decision reasoning
- * @param {string} oldReasoning - Previous decision reasoning
- * @returns {boolean} True if conflicting
- */
-function isConflicting(newReasoning, oldReasoning) {
-  const conflictKeywords = [
-    'instead of',
-    'replace',
-    'not',
-    'contrary to',
-    'different from',
-    'opposite',
-    'revert',
-    'undo',
-    'abandon',
-    'deprecate',
-    'remove',
-  ];
-
-  const combined = `${newReasoning} ${oldReasoning}`.toLowerCase();
-
-  return conflictKeywords.some((keyword) => combined.includes(keyword));
-}
+// ════════════════════════════════════════════════════════════════════════════
+// NOTE: Auto-link functions REMOVED in v1.2.0
+//
+// Removed functions:
+//   - createRefinesEdge
+//   - detectConflicts
+//   - createContradictsEdge
+//   - findRelatedDecisions
+//   - isConflicting
+//
+// Reason: LLM can infer decision evolution from time-ordered search results.
+// Auto-links created 366 noise edges (100% cross-topic).
+// Only supersedes (same topic) is reliable.
+//
+// See: CHANGELOG.md v1.2.0 - 2025-11-25
+// ════════════════════════════════════════════════════════════════════════════
 
 /**
  * Learn Decision Function (Main API)
@@ -447,62 +317,14 @@ async function learnDecision(detection, toolExecution, sessionContext) {
     }
 
     // ════════════════════════════════════════════════════════
-    // Story 014.14: Semantic Similarity Edge Detection
-    // ════════════════════════════════════════════════════════
-    const relatedDecisions = await findRelatedDecisions(
-      decisionId,
-      detection.topic,
-      detection.decision,
-      detection.reasoning
-    );
-
-    for (const related of relatedDecisions) {
-      const similarity = related.similarity;
-
-      // Skip if already has supersedes relationship
-      if (related.superseded_by || related.id === previous?.id) {
-        continue;
-      }
-
-      // High similarity → refines edge (Story 014.14: AC #2)
-      if (similarity > 0.85) {
-        const reason = `Refines previous approach (similarity: ${similarity.toFixed(2)})`;
-        await createRefinesEdge(decisionId, related.id, reason);
-      }
-
-      // Medium similarity + conflict keywords → contradicts edge (Story 014.14: AC #3)
-      else if (similarity > 0.75 && isConflicting(detection.reasoning, related.reasoning)) {
-        const reason = `Contradicts previous approach (similarity: ${similarity.toFixed(2)})`;
-        await createContradictsEdge(decisionId, related.id, reason);
-      }
-    }
-
-    // ════════════════════════════════════════════════════════
-    // Task 5.3: Create Refines Edges (if multi-parent refinement)
-    // ════════════════════════════════════════════════════════
-    if (refinedFrom && refinedFrom.length > 0) {
-      // AC #5: Multi-parent refinement
-      await Promise.all(
-        refinedFrom.map(async (parentId) => {
-          const reason = `Refined decision from multiple parents`;
-          await createRefinesEdge(decisionId, parentId, reason);
-        })
-      );
-    }
-
-    // ════════════════════════════════════════════════════════
-    // Task 5.4, 5.5: Detect and Create Contradicts Edges
+    // NOTE: Auto-link generation (refines, contradicts) REMOVED
+    //
+    // Reason: LLM can infer decision evolution from time-ordered
+    // search results. Auto-links created 366 noise edges (100%
+    // cross-topic). Only supersedes (same topic) is reliable.
+    //
+    // See: 2025-11-25 discussion on decision tracking algorithm
     // ════════════════════════════════════════════════════════
-    const conflicts = await detectConflicts(detection.topic, detection.decision, decisionId);
-    if (conflicts.length > 0) {
-      // AC #2, #5: Conflicting decisions
-      await Promise.all(
-        conflicts.map(async (conflict) => {
-          const reason = `Conflicting decision: "${conflict.decision}" vs "${detection.decision}"`;
-          await createContradictsEdge(decisionId, conflict.id, reason);
-        })
-      );
-    }
 
     // ════════════════════════════════════════════════════════
     // Story 014.7.6: Generate notification if needs validation
@@ -562,6 +384,9 @@ function updateConfidence(prior, evidence) {
 }
 
 // Export API
+// NOTE: Auto-link functions (createRefinesEdge, createContradictsEdge,
+// findRelatedDecisions, isConflicting, detectConflicts) removed from exports.
+// LLM infers relationships from search results instead.
 module.exports = {
   learnDecision,
   generateDecisionId,
@@ -571,9 +396,4 @@ module.exports = {
   calculateCombinedConfidence,
   detectRefinement,
   updateConfidence,
-  createRefinesEdge,
-  detectConflicts,
-  createContradictsEdge,
-  findRelatedDecisions, // Story 014.14: AC #1
-  isConflicting, // Story 014.14: AC #3
 };

package/src/mama/mama-api.js

@@ -905,6 +905,36 @@ async function loadCheckpoint() {
   }
 }
 
+/**
+ * List recent checkpoints (New Feature: Session Continuity)
+ *
+ * @param {number} limit - Max number of checkpoints to return
+ * @returns {Promise<Array>} Recent checkpoints
+ */
+async function listCheckpoints(limit = 10) {
+  try {
+    const adapter = getAdapter();
+    const stmt = adapter.prepare(`
+      SELECT * FROM checkpoints
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `);
+
+    const checkpoints = stmt.all(limit);
+
+    return checkpoints.map((c) => {
+      try {
+        c.open_files = JSON.parse(c.open_files);
+      } catch (e) {
+        c.open_files = [];
+      }
+      return c;
+    });
+  } catch (error) {
+    throw new Error(`Failed to list checkpoints: ${error.message}`);
+  }
+}
+
 /**
  * Propose a new link between decisions (Epic 3 - Story 3.1)
  *
@@ -2307,35 +2337,42 @@ function formatQualityReportMarkdown(report) {
  * 3. Claude-First Design - Claude decides what to save
  * 4. Non-Intrusive - Silent failures for helpers (suggest)
  */
+// ════════════════════════════════════════════════════════════════════════════
+// MAMA API - Simplified to 4 MCP tools (2025-11-25)
+//
+// Design: LLM can infer decision evolution from time-ordered search results
+// More tools = more constraints = less LLM flexibility
+//
+// Retained internal functions for future use, but MCP exposes only:
+//   save, search, update, load_checkpoint
+// ════════════════════════════════════════════════════════════════════════════
 const mama = {
+  // Core functions (used by 4 MCP tools)
   save,
-  recall,
-  updateOutcome,
   suggest,
   list: listDecisions,
+  listCheckpoints,
+  updateOutcome,
   saveCheckpoint,
   loadCheckpoint,
-  // Epic 3: Link Collaboration & Governance
+  // Legacy functions (retained for internal use, not exposed via MCP)
+  recall,
   proposeLink,
   approveLink,
   rejectLink,
   getPendingLinks,
   deprecateAutoLinks,
-  // Epic 4: Quality Metrics & Observability
   calculateCoverage,
   calculateQuality,
   generateQualityReport,
-  // Epic 4: Restart Metrics (Story 4.2)
   logRestartAttempt,
   calculateRestartSuccessRate,
   calculateRestartLatency,
   getRestartMetrics,
-  // Epic 5: Migration & Cleanup (Story 5.1)
   scanAutoLinks,
   createLinkBackup,
   generatePreCleanupReport,
   restoreLinkBackup,
-  // Epic 5: Migration & Cleanup (Story 5.2)
   verifyBackupExists,
   deleteAutoLinks,
   validateCleanupResult,

package/src/server.js

@@ -27,30 +27,10 @@ const {
   ListToolsRequestSchema,
 } = require('@modelcontextprotocol/sdk/types.js');
 
-// Import MAMA tools
-const { saveDecisionTool } = require('./tools/save-decision.js');
-const { recallDecisionTool } = require('./tools/recall-decision.js');
-const { suggestDecisionTool } = require('./tools/suggest-decision.js');
-const { listDecisionsTool } = require('./tools/list-decisions.js');
-const { updateOutcomeTool } = require('./tools/update-outcome.js');
-const { saveCheckpointTool, loadCheckpointTool } = require('./tools/checkpoint-tools.js');
-const {
-  proposeLinkTool,
-  approveLinkTool,
-  rejectLinkTool,
-  getPendingLinksTool,
-  deprecateAutoLinksTool,
-  scanAutoLinksTool,
-  createLinkBackupTool,
-  generateCleanupReportTool,
-  restoreLinkBackupTool,
-  executeLinkCleanupTool,
-  validateCleanupResultTool,
-} = require('./tools/link-tools.js');
-const {
-  generateQualityReportTool,
-  getRestartMetricsTool,
-} = require('./tools/quality-metrics-tools.js');
+// Import MAMA tools - Simplified to 4 core tools (2025-11-25 refactor)
+// Rationale: LLM can infer relationships from search results, fewer tools = more flexibility
+const { loadCheckpointTool } = require('./tools/checkpoint-tools.js');
+const mama = require('./mama/mama-api.js');
 
 // Import core modules
 const { initDB } = require('./mama/db-manager.js');
@@ -162,227 +142,129 @@ class MAMAServer {
   }
 
   setupHandlers() {
-    // List available tools
+    // List available tools - Simplified to 4 core tools (2025-11-25)
+    // Design principle: LLM infers relationships from search results
+    // Fewer tools = more flexibility, less constraint
     this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
       tools: [
+        // 1. SAVE - Unified save for decisions and checkpoints
         {
-          name: 'save_decision',
-          description: "Save a decision or insight to MAMA's memory for future reference.",
+          name: 'save',
+          description:
+            "Save a decision or checkpoint to MAMA's memory. type='decision': architectural choices, lessons learned (same topic = newer supersedes older, tracking evolution). type='checkpoint': session state to resume later.",
           inputSchema: {
             type: 'object',
             properties: {
+              type: {
+                type: 'string',
+                enum: ['decision', 'checkpoint'],
+                description: "What to save: 'decision' or 'checkpoint'",
+              },
+              // Decision fields
               topic: {
                 type: 'string',
                 description:
-                  "Decision topic identifier (e.g., 'auth_strategy'). Use lowercase with underscores.",
+                  "[Decision] Topic identifier (e.g., 'auth_strategy'). Same topic = new decision supersedes previous, creating evolution chain.",
               },
               decision: {
                 type: 'string',
-                description: "The decision made (e.g., 'Use JWT with refresh tokens').",
+                description: "[Decision] The decision made (e.g., 'Use JWT with refresh tokens').",
               },
               reasoning: {
                 type: 'string',
                 description:
-                  'Why this decision was made. REQUIRED - explain the context and rationale.',
+                  '[Decision] Why this decision was made. Include 5-layer narrative: (1) Context - what problem/situation; (2) Evidence - what proves this works (tests, benchmarks, prior experience); (3) Alternatives - what other options were considered and why rejected; (4) Risks - known limitations or failure modes; (5) Rationale - final reasoning for this choice.',
               },
               confidence: {
                 type: 'number',
-                description: 'Confidence score 0.0-1.0. Default: 0.5',
+                description: '[Decision] Confidence 0.0-1.0. Default: 0.5',
                 minimum: 0,
                 maximum: 1,
               },
-              type: {
+              // Checkpoint fields
+              summary: {
                 type: 'string',
-                enum: ['user_decision', 'assistant_insight'],
-                description: "Decision type. Default: 'user_decision'",
+                description:
+                  '[Checkpoint] Session state summary. Use 4-section format: (1) 🎯 Goal & Progress - what was the goal, where did you stop; (2) ✅ Evidence - mark each item as Verified/Not run/Assumed with proof; (3) ⏳ Unfinished & Risks - incomplete work, blockers, unknowns; (4) 🚦 Next Agent Briefing - Definition of Done, quick health checks to run first.',
               },
-              outcome: {
+              next_steps: {
                 type: 'string',
-                enum: ['pending', 'success', 'failure', 'partial', 'superseded'],
-                description: "Outcome status. Default: 'pending'",
+                description:
+                  '[Checkpoint] Instructions for next session: DoD (Definition of Done), quick verification commands (npm test, curl health), constraints/cautions.',
               },
-            },
-            required: ['topic', 'decision', 'reasoning'],
-          },
-        },
-        {
-          name: 'recall_decision',
-          description: 'Recall full decision history for a specific topic.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              topic: {
-                type: 'string',
-                description: 'Decision topic to recall',
+              open_files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: '[Checkpoint] Currently relevant files.',
               },
             },
-            required: ['topic'],
+            required: ['type'],
           },
         },
+        // 2. SEARCH - Unified search across decisions and checkpoints
         {
-          name: 'suggest_decision',
-          description: 'Auto-suggest relevant past decisions based on user question.',
+          name: 'search',
+          description:
+            'Search decisions and checkpoints. With query: semantic search. Without query: returns recent items by time.',
           inputSchema: {
             type: 'object',
             properties: {
-              userQuestion: {
+              query: {
                 type: 'string',
-                description: "User's question or intent",
+                description:
+                  'Search query (optional). If empty, returns recent items sorted by time.',
               },
-              recencyWeight: {
-                type: 'number',
-                description: 'Weight for recency (0-1). Default: 0.3',
-                minimum: 0,
-                maximum: 1,
+              type: {
+                type: 'string',
+                enum: ['all', 'decision', 'checkpoint'],
+                description: "Filter by type. Default: 'all'",
               },
-            },
-            required: ['userQuestion'],
-          },
-        },
-        {
-          name: 'list_decisions',
-          description: 'List recent decisions with optional limit',
-          inputSchema: {
-            type: 'object',
-            properties: {
               limit: {
                 type: 'number',
-                description: 'Maximum number of decisions (default: 10)',
+                description: 'Maximum results. Default: 10',
               },
             },
           },
         },
+        // 3. UPDATE - Update decision outcome
         {
-          name: 'update_outcome',
-          description: 'Update the outcome status of an existing decision',
+          name: 'update',
+          description:
+            'Update an existing decision outcome (success/failure/partial). Use after trying a decision to track what worked.',
           inputSchema: {
             type: 'object',
             properties: {
-              decisionId: {
+              id: {
                 type: 'string',
-                description: "Decision ID to update (e.g., 'decision_auth_strategy_123456_abc').",
+                description: 'Decision ID to update.',
               },
               outcome: {
                 type: 'string',
-                enum: ['SUCCESS', 'FAILED', 'PARTIAL'],
-                description: 'New outcome status',
-              },
-              failure_reason: {
-                type: 'string',
-                description: "Why the decision failed (REQUIRED if outcome='FAILED').",
+                enum: ['success', 'failure', 'partial'],
+                description: 'New outcome status.',
               },
-              limitation: {
+              reason: {
                 type: 'string',
-                description: "What limitations were discovered (OPTIONAL for outcome='PARTIAL').",
+                description: 'Why it succeeded/failed/was partial.',
               },
             },
-            required: ['decisionId', 'outcome'],
-          },
-        },
-        {
-          name: 'save_checkpoint',
-          description:
-            'Save the current session state (checkpoint). Format: 1) Goal & Progress (honest about unfinished), 2) Evidence with status [Verified/Not run/Assumed], 3) Unfinished & Risks, 4) Next Agent briefing (Definition of Done + quick health-check commands).',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              summary: {
-                type: 'string',
-                description:
-                  'Summary of the current session state, what was accomplished, and what is pending.',
-              },
-              open_files: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'List of currently relevant or open files.',
-              },
-              next_steps: {
-                type: 'string',
-                description: 'Clear instructions for the next session on what to do next.',
-              },
-            },
-            required: ['summary'],
+            required: ['id', 'outcome'],
           },
         },
+        // 4. LOAD_CHECKPOINT - Resume previous session
         {
           name: 'load_checkpoint',
           description:
-            'Load the latest active session checkpoint. Use this at the start of a new session to resume work seamlessly.',
+            'Load the latest checkpoint to resume a previous session. Use at session start.',
           inputSchema: {
             type: 'object',
             properties: {},
           },
         },
-        // Epic 3: Link Collaboration & Governance
-        {
-          name: 'propose_link',
-          description: proposeLinkTool.description,
-          inputSchema: proposeLinkTool.inputSchema,
-        },
-        {
-          name: 'approve_link',
-          description: approveLinkTool.description,
-          inputSchema: approveLinkTool.inputSchema,
-        },
-        {
-          name: 'reject_link',
-          description: rejectLinkTool.description,
-          inputSchema: rejectLinkTool.inputSchema,
-        },
-        {
-          name: 'get_pending_links',
-          description: getPendingLinksTool.description,
-          inputSchema: getPendingLinksTool.inputSchema,
-        },
-        {
-          name: 'deprecate_auto_links',
-          description: deprecateAutoLinksTool.description,
-          inputSchema: deprecateAutoLinksTool.inputSchema,
-        },
-        {
-          name: 'scan_auto_links',
-          description: scanAutoLinksTool.description,
-          inputSchema: scanAutoLinksTool.inputSchema,
-        },
-        {
-          name: 'create_link_backup',
-          description: createLinkBackupTool.description,
-          inputSchema: createLinkBackupTool.inputSchema,
-        },
-        {
-          name: 'generate_cleanup_report',
-          description: generateCleanupReportTool.description,
-          inputSchema: generateCleanupReportTool.inputSchema,
-        },
-        {
-          name: 'restore_link_backup',
-          description: restoreLinkBackupTool.description,
-          inputSchema: restoreLinkBackupTool.inputSchema,
-        },
-        {
-          name: 'generate_quality_report',
-          description: generateQualityReportTool.description,
-          inputSchema: generateQualityReportTool.inputSchema,
-        },
-        {
-          name: 'get_restart_metrics',
-          description: getRestartMetricsTool.description,
-          inputSchema: getRestartMetricsTool.inputSchema,
-        },
-        {
-          name: 'execute_link_cleanup',
-          description: executeLinkCleanupTool.description,
-          inputSchema: executeLinkCleanupTool.inputSchema,
-        },
-        {
-          name: 'validate_cleanup_result',
-          description: validateCleanupResultTool.description,
-          inputSchema: validateCleanupResultTool.inputSchema,
-        },
       ],
     }));
 
-    // Handle tool execution
+    // Handle tool execution - 4 core tools only
     this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
       const { name, arguments: args } = request.params;
 
@@ -390,66 +272,18 @@ class MAMAServer {
         let result;
 
         switch (name) {
-          case 'save_decision':
-            result = await saveDecisionTool.handler(args);
-            break;
-          case 'recall_decision':
-            result = await recallDecisionTool.handler(args);
+          case 'save':
+            result = await this.handleSave(args);
             break;
-          case 'suggest_decision':
-            result = await suggestDecisionTool.handler(args);
+          case 'search':
+            result = await this.handleSearch(args);
             break;
-          case 'list_decisions':
-            result = await listDecisionsTool.handler(args);
-            break;
-          case 'update_outcome':
-            result = await updateOutcomeTool.handler(args);
-            break;
-          case 'save_checkpoint':
-            result = await saveCheckpointTool.handler(args);
+          case 'update':
+            result = await this.handleUpdate(args);
             break;
           case 'load_checkpoint':
             result = await loadCheckpointTool.handler(args);
             break;
-          case 'propose_link':
-            result = await proposeLinkTool.handler(args);
-            break;
-          case 'approve_link':
-            result = await approveLinkTool.handler(args);
-            break;
-          case 'reject_link':
-            result = await rejectLinkTool.handler(args);
-            break;
-          case 'get_pending_links':
-            result = await getPendingLinksTool.handler(args);
-            break;
-          case 'deprecate_auto_links':
-            result = await deprecateAutoLinksTool.handler(args);
-            break;
-          case 'scan_auto_links':
-            result = await scanAutoLinksTool.handler(args);
-            break;
-          case 'create_link_backup':
-            result = await createLinkBackupTool.handler(args);
-            break;
-          case 'generate_cleanup_report':
-            result = await generateCleanupReportTool.handler(args);
-            break;
-          case 'restore_link_backup':
-            result = await restoreLinkBackupTool.handler(args);
-            break;
-          case 'generate_quality_report':
-            result = await generateQualityReportTool.handler(args);
-            break;
-          case 'get_restart_metrics':
-            result = await getRestartMetricsTool.handler(args);
-            break;
-          case 'execute_link_cleanup':
-            result = await executeLinkCleanupTool.handler(args);
-            break;
-          case 'validate_cleanup_result':
-            result = await validateCleanupResultTool.handler(args);
-            break;
           default:
             throw new Error(`Unknown tool: ${name}`);
         }
@@ -477,6 +311,114 @@ class MAMAServer {
     });
   }
 
+  /**
+   * Handle unified save (decision or checkpoint)
+   */
+  async handleSave(args) {
+    const { type } = args;
+
+    if (type === 'decision') {
+      const { topic, decision, reasoning, confidence = 0.5 } = args;
+      if (!topic || !decision || !reasoning) {
+        return { success: false, message: '❌ Decision requires: topic, decision, reasoning' };
+      }
+      const id = await mama.save({ topic, decision, reasoning, confidence });
+      return {
+        success: true,
+        id,
+        type: 'decision',
+        message: `✅ Decision saved: ${topic}`,
+      };
+    }
+
+    if (type === 'checkpoint') {
+      const { summary, next_steps, open_files } = args;
+      if (!summary) {
+        return { success: false, message: '❌ Checkpoint requires: summary' };
+      }
+      const id = await mama.saveCheckpoint({ summary, next_steps, open_files });
+      return {
+        success: true,
+        id,
+        type: 'checkpoint',
+        message: '✅ Checkpoint saved',
+      };
+    }
+
+    return { success: false, message: "❌ type must be 'decision' or 'checkpoint'" };
+  }
+
+  /**
+   * Handle unified search (decisions + checkpoints)
+   */
+  async handleSearch(args) {
+    const { query, type = 'all', limit = 10 } = args;
+
+    const results = [];
+
+    // Search decisions
+    if (type === 'all' || type === 'decision') {
+      let decisions;
+      if (query) {
+        // suggest() returns { results: [...] } object or null
+        const suggestResult = await mama.suggest(query, limit);
+        decisions = suggestResult?.results || [];
+      } else {
+        decisions = await mama.list(limit);
+      }
+      // Ensure decisions is an array
+      if (Array.isArray(decisions)) {
+        results.push(
+          ...decisions.map((d) => ({
+            ...d,
+            _type: 'decision',
+          }))
+        );
+      }
+    }
+
+    // Search checkpoints
+    if (type === 'all' || type === 'checkpoint') {
+      const checkpoints = await mama.listCheckpoints(limit);
+      results.push(
+        ...checkpoints.map((c) => ({
+          id: `checkpoint_${c.id}`,
+          summary: c.summary,
+          next_steps: c.next_steps,
+          created_at: c.timestamp,
+          _type: 'checkpoint',
+        }))
+      );
+    }
+
+    // Sort by time (newest first) and limit
+    results.sort((a, b) => (b.created_at || 0) - (a.created_at || 0));
+    const limited = results.slice(0, limit);
+
+    return {
+      success: true,
+      count: limited.length,
+      results: limited,
+    };
+  }
+
+  /**
+   * Handle update (decision outcome)
+   */
+  async handleUpdate(args) {
+    const { id, outcome, reason } = args;
+
+    if (!id || !outcome) {
+      return { success: false, message: '❌ Update requires: id, outcome' };
+    }
+
+    await mama.updateOutcome(id, outcome.toUpperCase(), reason);
+    return {
+      success: true,
+      message: `✅ Updated ${id} → ${outcome}`,
+    };
+  }
+
   async start() {
     try {
       setupLogging();