lore-memory 0.4.0 → 0.5.1

package/bin/lore.js

@@ -164,8 +164,9 @@ program
 
 program
   .command('serve')
-  .description('Start the Lore MCP server (stdio) for use with Claude Code')
+  .description('Start the Lore MCP server (stdio) and UI dashboard for use with Claude Code')
   .option('-q, --quiet', 'Suppress startup messages (use when piped into MCP client)')
+  .option('-p, --port <port>', 'Port for the UI dashboard', '3333')
   .action(require('../src/commands/serve'));
 
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lore-memory",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Persistent project memory for developers. Captures decisions, invariants, gotchas, and graveyard entries — automatically and manually — and injects them into AI coding sessions.",
   "main": "bin/lore.js",
   "bin": {

package/src/commands/init.js

@@ -6,20 +6,6 @@ const yaml = require('js-yaml');
 const chalk = require('chalk');
 const { LORE_DIR, emptyIndex } = require('../lib/index');
 
-const HOOK_CONTENT = `#!/bin/bash
-LINECOUNT=$(git diff HEAD~1 --shortstat 2>/dev/null | grep -o '[0-9]* insertion' | grep -o '[0-9]*' || echo 0)
-if [ "\${LINECOUNT:-0}" -gt 50 ]; then
-  # Only prompt if running in an interactive terminal
-  if [ -t 1 ] || [ -t 0 ]; then
-    echo "📖 Lore: Significant change detected. Log it? (y/n)"
-    read -r answer </dev/tty
-    if [ "$answer" = "y" ]; then
-      lore log </dev/tty
-    fi
-  fi
-fi
-`;
-
 async function init() {
   try {
     const dirs = ['decisions', 'invariants', 'graveyard', 'gotchas', 'modules', 'sessions', 'drafts'];
@@ -44,6 +30,7 @@ async function init() {
         },
         mcp: {
           tokenBudget: 4000,
+          confirmEntries: true,
         },
         watchMode: false,
         watchIgnore: ['node_modules', 'dist', '.git', 'coverage'],
@@ -64,33 +51,6 @@ async function init() {
       );
     }
 
-    const hookDir = path.join('.git', 'hooks');
-    if (fs.existsSync(hookDir)) {
-      const hookPath = path.join(hookDir, 'post-commit');
-      let writeHook = true;
-
-      if (fs.existsSync(hookPath)) {
-        const existingHook = await fs.readFile(hookPath, 'utf8');
-        if (existingHook.includes('Lore: Significant change detected')) {
-          writeHook = false;
-          console.log(chalk.dim('✓ Git post-commit hook already installed'));
-        } else {
-          // Append to existing hook
-          await fs.appendFile(hookPath, '\n' + HOOK_CONTENT.replace('#!/bin/bash\n', ''));
-          console.log(chalk.green('✓ Lore appended to existing Git post-commit hook'));
-          writeHook = false;
-        }
-      }
-
-      if (writeHook) {
-        await fs.writeFile(hookPath, HOOK_CONTENT);
-        await fs.chmod(hookPath, '0755');
-        console.log(chalk.green('✓ Git post-commit hook installed'));
-      }
-    } else {
-      console.log(chalk.yellow('⚠ Not a git repo — hook not installed'));
-    }
-
     console.log(chalk.green(`✓ Lore initialized at ${LORE_DIR}/`));
     console.log(chalk.cyan('  Run: lore mine .       to scan codebase for lore-worthy comments'));
     console.log(chalk.cyan('  Run: lore log          to create your first entry manually'));

package/src/commands/log.js

@@ -4,7 +4,7 @@ const chalk = require('chalk');
 const inquirer = require('inquirer');
 const { readIndex, writeIndex, addEntryToIndex } = require('../lib/index');
 const { requireInit } = require('../lib/guard');
-const { writeEntry, generateId } = require('../lib/entries');
+const { writeEntry, generateId, findDuplicate } = require('../lib/entries');
 const { getRecentFiles } = require('../lib/git');
 
 async function log(options) {
@@ -103,6 +103,32 @@ async function log(options) {
       process.exit(1);
     }
 
+    // Deduplication check
+    const duplicate = findDuplicate(index, type, title);
+    if (duplicate) {
+      const matchLabel = duplicate.match === 'exact' ? 'Exact duplicate' : 'Similar entry';
+      console.log(chalk.yellow(`\n⚠ ${matchLabel} found: ${chalk.bold(duplicate.entry.id)}`));
+      console.log(chalk.dim(`  Title: "${duplicate.entry.title}"\n`));
+
+      // In inline mode (flags), just warn and exit
+      if (options.type && options.title && options.context) {
+        console.log(chalk.yellow('Skipping to avoid duplicate. Use a different title or edit the existing entry.'));
+        return;
+      }
+
+      // In interactive mode, ask user
+      const { proceed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'proceed',
+        message: 'Create entry anyway?',
+        default: false,
+      }]);
+      if (!proceed) {
+        console.log(chalk.dim('Aborted.'));
+        return;
+      }
+    }
+
     const id = generateId(type, title);
     const entry = {
       id,

package/src/commands/serve.js

@@ -2,16 +2,38 @@
 
 const chalk = require('chalk');
 const { requireInit } = require('../lib/guard');
+const { getServerStatus } = require('../mcp/status');
 
 async function serve(options) {
   requireInit();
+
+  // Prevent double-start
+  const existing = getServerStatus();
+  if (existing) {
+    process.stderr.write(chalk.yellow(`\n⚠ Lore MCP server is already running (PID: ${existing.pid}, started: ${existing.startedAt})\n`));
+    process.stderr.write(chalk.dim(`  Tools: ${existing.tools.join(', ')}\n\n`));
+    process.exit(1);
+  }
+
   try {
+    // Start the MCP server (communicates via stdio)
     const { startServer } = require('../mcp/server');
     if (!options.quiet) {
       process.stderr.write(chalk.green('📖 Lore MCP server starting on stdio\n'));
       process.stderr.write(chalk.cyan('   Add to Claude Code settings: { "command": "lore serve", "args": [] }\n'));
     }
     await startServer();
+
+    // Also start the UI dashboard in the same process
+    const uiPort = options.port || 3333;
+    try {
+      const { startDashboard } = require('./ui');
+      // Pass quiet: true to prevent stdout corruption of the MCP protocol stream
+      // and prevent the UI from calling process.exit() if the port is in use.
+      startDashboard(uiPort, { quiet: true, openBrowser: false });
+    } catch (e) {
+      process.stderr.write(chalk.yellow(`⚠ Could not start UI dashboard: ${e.message}\n`));
+    }
   } catch (e) {
     process.stderr.write(chalk.red(`Failed to start server: ${e.message}\n`));
     process.exit(1);
@@ -19,3 +41,4 @@ async function serve(options) {
 }
 
 module.exports = serve;
+

package/src/commands/ui.js

@@ -8,6 +8,7 @@ const { readIndex, LORE_DIR } = require('../lib/index');
 const { readEntry } = require('../lib/entries');
 const { computeScore } = require('../lib/scorer');
 const { listDrafts, acceptDraft, deleteDraft } = require('../lib/drafts');
+const { getServerStatus } = require('../mcp/status');
 
 // Only load 'open' dynamically to avoid overhead on other CLI commands if not needed
 async function openBrowser(url) {
@@ -15,11 +16,9 @@ async function openBrowser(url) {
     await open(url);
 }
 
-function ui(options) {
-    requireInit();
-
+function createApp(portNum, options = {}) {
     const app = express();
-    const PORT = options.port || 3333;
+    const PORT = portNum || 3333;
 
     app.use(express.json());
 
@@ -56,6 +55,18 @@ function ui(options) {
         }
     });
 
+    app.get('/api/mcp-status', (req, res) => {
+        try {
+            const status = getServerStatus();
+            res.json({
+                active: !!status,
+                ...(status || {}),
+            });
+        } catch (e) {
+            res.json({ active: false });
+        }
+    });
+
     app.get('/api/entries', (req, res) => {
         try {
             const index = readIndex();
@@ -142,30 +153,59 @@ function ui(options) {
     });
 
     const server = app.listen(PORT, () => {
-        const url = `http://localhost:${PORT}`;
-        console.log(chalk.green(`\n🚀 Lore UI Dashboard running at ${chalk.bold(url)}\n`));
-        console.log(chalk.cyan(`  Press Ctrl+C to stop the server.`));
-
-        // Use native exec to open browser to avoid ESM import issues with 'open'
-        const { exec } = require('child_process');
-        const startPath = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-        exec(`${startPath} ${url}`, (err) => {
-            if (err) {
-                console.log(chalk.dim(`  (Could not open browser automatically. Please visit ${url} manually)`));
+        if (!options.quiet) {
+            const url = `http://localhost:${PORT}`;
+            console.log(chalk.green(`\n🚀 Lore UI Dashboard running at ${chalk.bold(url)}\n`));
+            console.log(chalk.cyan(`  Press Ctrl+C to stop the server.`));
+
+            // Use native exec to open browser to avoid ESM import issues with 'open'
+            if (options.openBrowser !== false) {
+                const { exec } = require('child_process');
+                const startPath = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+                exec(`${startPath} ${url}`, (err) => {
+                    if (err) {
+                        console.log(chalk.dim(`  (Could not open browser automatically. Please visit ${url} manually)`));
+                    }
+                });
             }
-        });
+        }
     });
 
     server.on('error', (e) => {
         if (e.code === 'EADDRINUSE') {
-            console.error(chalk.red(`\nPort ${PORT} is already in use by another process.`));
-            console.error(chalk.yellow(`Use 'lore ui --port <number>' to specify a different port.\n`));
-            process.exit(1);
+            if (!options.quiet) {
+                console.error(chalk.red(`\nPort ${PORT} is already in use by another process.`));
+                console.error(chalk.yellow(`Use 'lore ui --port <number>' to specify a different port.\n`));
+                process.exit(1);
+            } else {
+                process.stderr.write(chalk.yellow(`\n⚠ Lore UI dashboard port ${PORT} is in use; dashboard disabled for this instance.\n`));
+            }
         } else {
-            console.error(chalk.red(`\nFailed to start server: ${e.message}\n`));
-            process.exit(1);
+            if (!options.quiet) {
+                console.error(chalk.red(`\nFailed to start server: ${e.message}\n`));
+                process.exit(1);
+            } else {
+                process.stderr.write(chalk.red(`\n⚠ Failed to start Lore UI dashboard: ${e.message}\n`));
+            }
         }
     });
+
+    return server;
+}
+
+/**
+ * Start just the dashboard Express server (called from serve.js).
+ * @param {number} port
+ * @returns {object} Express server instance
+ */
+function startDashboard(port, options = {}) {
+    return createApp(port || 3333, options);
+}
+
+function ui(options) {
+    requireInit();
+    createApp(options.port || 3333, { quiet: false, openBrowser: true });
 }
 
 module.exports = ui;
+module.exports.startDashboard = startDashboard;

package/src/lib/config.js

@@ -14,6 +14,7 @@ const DEFAULTS = {
   },
   mcp: {
     tokenBudget: 4000,
+    confirmEntries: true,
   },
 };
 

package/src/lib/drafts.js

@@ -44,41 +44,82 @@ function listDrafts() {
 }
 
 /**
- * Promote a draft to a real Lore entry.
+ * Promote a draft to a real Lore entry, or apply it as an update to an existing entry.
  * @param {string} draftId
- * @returns {object} the created entry
+ * @returns {object} the created or updated entry
  */
 function acceptDraft(draftId) {
   const draftPath = path.join(DRAFTS_DIR(), `${draftId}.json`);
   const draft = fs.readJsonSync(draftPath);
 
-  const type = draft.suggestedType || 'decision';
-  const title = draft.suggestedTitle || 'Untitled';
-  const id = generateId(type, title);
-
-  const entry = {
-    id,
-    type,
-    title,
-    context: draft.evidence || '',
-    files: draft.files || [],
-    tags: draft.tags || [],
-    alternatives: [],
-    tradeoffs: '',
-    date: new Date().toISOString(),
-  };
-
-  writeEntry(entry);
-  const index = readIndex();
-  addEntryToIndex(index, entry);
-  writeIndex(index);
-
-  // Auto-embed if Ollama available
-  try {
-    const { generateEmbedding, storeEmbedding } = require('./embeddings');
-    const text = [title, entry.context, ...entry.tags].join(' ');
-    generateEmbedding(text).then(vec => storeEmbedding(id, vec)).catch(() => {});
-  } catch (e) {}
+  let entry;
+
+  if (draft.updatesEntryId) {
+    // This draft is an update to an existing entry — modify in place
+    const index = readIndex();
+    const existingPath = index.entries[draft.updatesEntryId];
+    if (!existingPath) {
+      throw new Error(`Original entry "${draft.updatesEntryId}" not found. It may have been deleted.`);
+    }
+
+    const { readEntry: readExisting } = require('./entries');
+    entry = readExisting(existingPath);
+    if (!entry) {
+      throw new Error(`Failed to read original entry "${draft.updatesEntryId}".`);
+    }
+
+    // Apply updates from draft — only override fields that have meaningful values
+    if (draft.suggestedTitle && draft.suggestedTitle !== entry.title) entry.title = draft.suggestedTitle;
+    if (draft.evidence && !draft.evidence.startsWith('[UPDATE to ')) entry.context = draft.evidence;
+    else if (draft.evidence) {
+      // Strip the "[UPDATE to xxx] " prefix from the context
+      entry.context = draft.evidence.replace(/^\[UPDATE to [^\]]+\]\s*/, '');
+    }
+    if (draft.files && draft.files.length > 0) entry.files = draft.files;
+    if (draft.tags && draft.tags.length > 0) entry.tags = draft.tags;
+    if (draft.alternatives && draft.alternatives.length > 0) entry.alternatives = draft.alternatives;
+    if (draft.tradeoffs) entry.tradeoffs = draft.tradeoffs;
+    entry.lastUpdated = new Date().toISOString();
+
+    writeEntry(entry);
+    writeIndex(index);
+
+    // Re-embed
+    try {
+      const { generateEmbedding, storeEmbedding } = require('./embeddings');
+      const text = [entry.title, entry.context, ...(entry.alternatives || []), entry.tradeoffs || '', ...(entry.tags || [])].join(' ');
+      generateEmbedding(text).then(vec => storeEmbedding(entry.id, vec)).catch(() => {});
+    } catch (e) {}
+  } else {
+    // Standard draft → new entry
+    const type = draft.suggestedType || 'decision';
+    const title = draft.suggestedTitle || 'Untitled';
+    const id = generateId(type, title);
+
+    entry = {
+      id,
+      type,
+      title,
+      context: draft.evidence || '',
+      files: draft.files || [],
+      tags: draft.tags || [],
+      alternatives: draft.alternatives || [],
+      tradeoffs: draft.tradeoffs || '',
+      date: new Date().toISOString(),
+    };
+
+    writeEntry(entry);
+    const index = readIndex();
+    addEntryToIndex(index, entry);
+    writeIndex(index);
+
+    // Auto-embed if Ollama available
+    try {
+      const { generateEmbedding, storeEmbedding } = require('./embeddings');
+      const text = [title, entry.context, ...entry.alternatives, entry.tradeoffs, ...entry.tags].join(' ');
+      generateEmbedding(text).then(vec => storeEmbedding(id, vec)).catch(() => {});
+    } catch (e) {}
+  }
 
   fs.removeSync(draftPath);
   return entry;

package/src/lib/entries.js

@@ -50,10 +50,71 @@ function readAllEntries(index) {
   return entries;
 }
 
+/**
+ * Check if a similar entry or draft already exists.
+ * @param {object} index - The lore index
+ * @param {string} type - Entry type
+ * @param {string} title - Entry title
+ * @returns {{ match: 'exact'|'fuzzy', entry: object, source: 'entry'|'draft' }|null}
+ */
+function findDuplicate(index, type, title) {
+  const normalizedTitle = title.toLowerCase().trim();
+  const titleWords = new Set(normalizedTitle.split(/\s+/).filter(w => w.length > 2));
+
+  function checkTitle(candidateTitle) {
+    const candidate = (candidateTitle || '').toLowerCase().trim();
+
+    // Exact match (case-insensitive)
+    if (candidate === normalizedTitle) return 'exact';
+
+    // Fuzzy match: ≥60% word overlap
+    if (titleWords.size > 0) {
+      const candidateWords = new Set(candidate.split(/\s+/).filter(w => w.length > 2));
+      if (candidateWords.size === 0) return null;
+
+      let overlap = 0;
+      for (const w of titleWords) {
+        if (candidateWords.has(w)) overlap++;
+      }
+
+      const similarity = overlap / Math.max(titleWords.size, candidateWords.size);
+      if (similarity >= 0.6) return 'fuzzy';
+    }
+
+    return null;
+  }
+
+  // Check approved entries
+  for (const entryPath of Object.values(index.entries)) {
+    const entry = readEntry(entryPath);
+    if (!entry || entry.type !== type) continue;
+
+    const match = checkTitle(entry.title);
+    if (match) return { match, entry, source: 'entry' };
+  }
+
+  // Check pending drafts
+  try {
+    const { listDrafts } = require('./drafts');
+    const drafts = listDrafts();
+    for (const draft of drafts) {
+      if (draft.suggestedType !== type) continue;
+
+      const match = checkTitle(draft.suggestedTitle);
+      if (match) return { match, entry: { id: draft.draftId, title: draft.suggestedTitle, type: draft.suggestedType }, source: 'draft' };
+    }
+  } catch (e) {
+    // drafts module not available — skip
+  }
+
+  return null;
+}
+
 module.exports = {
   getEntryPath,
   readEntry,
   writeEntry,
   generateId,
   readAllEntries,
+  findDuplicate,
 };

package/src/mcp/server.js

@@ -10,15 +10,17 @@ const {
 const why = require('./tools/why');
 const search = require('./tools/search');
 const log = require('./tools/log');
+const update = require('./tools/update');
 const stale = require('./tools/stale');
 const overview = require('./tools/overview');
 const drafts = require('./tools/drafts');
+const { announceStartup } = require('./status');
 
-const TOOLS = [why, search, log, stale, overview, drafts];
+const TOOLS = [why, search, log, update, stale, overview, drafts];
 
 async function startServer() {
   const server = new Server(
-    { name: 'lore', version: '0.3.0' },
+    { name: 'lore', version: '0.4.0' },
     { capabilities: { tools: {} } }
   );
 
@@ -45,8 +47,12 @@ async function startServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
 
+  announceStartup(TOOLS);
+
   // Keep process alive
   process.stdin.resume();
 }
 
 module.exports = { startServer };
+
+

package/src/mcp/status.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const LORE_DIR = path.join(process.cwd(), '.lore');
+const PID_FILE = path.join(LORE_DIR, 'mcp.pid');
+
+/**
+ * Write a status file so other tools can detect if the MCP server is running.
+ */
+function writePidFile(tools) {
+  try {
+    fs.ensureDirSync(LORE_DIR);
+    fs.writeJsonSync(PID_FILE, {
+      pid: process.pid,
+      startedAt: new Date().toISOString(),
+      tools: tools.map(t => t.toolDefinition.name),
+    }, { spaces: 2 });
+  } catch (e) {
+    // Non-fatal
+  }
+}
+
+/**
+ * Remove the status file on shutdown.
+ */
+function removePidFile() {
+  try { fs.removeSync(PID_FILE); } catch (e) {}
+}
+
+/**
+ * Print startup banner to stderr (safe — MCP only reads stdout).
+ * Register cleanup handlers.
+ */
+function announceStartup(tools) {
+  writePidFile(tools);
+
+  const toolNames = tools.map(t => t.toolDefinition.name).join(', ');
+  process.stderr.write(`\n📖 Lore MCP server active (PID: ${process.pid})\n`);
+  process.stderr.write(`   ${tools.length} tools available: ${toolNames}\n`);
+  process.stderr.write(`   Serving project: ${path.basename(process.cwd())}\n\n`);
+
+  process.on('SIGINT', () => { removePidFile(); process.exit(0); });
+  process.on('SIGTERM', () => { removePidFile(); process.exit(0); });
+  process.on('exit', removePidFile);
+}
+
+/**
+ * Check if the MCP server is currently running.
+ * @returns {{ pid: number, startedAt: string, tools: string[] }|null}
+ */
+function getServerStatus() {
+  try {
+    if (!fs.existsSync(PID_FILE)) return null;
+    const info = fs.readJsonSync(PID_FILE);
+
+    // Verify the process is actually alive
+    try {
+      process.kill(info.pid, 0); // Signal 0 = just check if process exists
+      return info;
+    } catch (e) {
+      // Process is dead, clean up stale PID file
+      removePidFile();
+      return null;
+    }
+  } catch (e) {
+    return null;
+  }
+}
+
+module.exports = { announceStartup, getServerStatus };

package/src/mcp/tools/log.js

@@ -1,11 +1,13 @@
 'use strict';
 
 const { readIndex, writeIndex, addEntryToIndex } = require('../../lib/index');
-const { generateId, writeEntry } = require('../../lib/entries');
+const { generateId, writeEntry, findDuplicate } = require('../../lib/entries');
+const { readConfig } = require('../../lib/config');
+const { saveDraft } = require('../../lib/drafts');
 
 const toolDefinition = {
   name: 'lore_log',
-  description: 'Create a new Lore entry to record an architectural decision, invariant, gotcha, or graveyard item. Use this when you make a significant technical decision that future developers (or AI) should know about.',
+  description: 'Create a new Lore entry to record an architectural decision, invariant, gotcha, or graveyard item. Use this when you make a significant technical decision that future developers (or AI) should know about. Note: entries may be saved as drafts pending human review depending on project configuration.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -50,6 +52,40 @@ async function handler(args) {
   const { type, title, context, files = [], tags = [], alternatives = [], tradeoffs = '' } = args;
 
   try {
+    const index = readIndex();
+
+    // Deduplication check
+    const duplicate = findDuplicate(index, type, title);
+    if (duplicate) {
+      const matchLabel = duplicate.match === 'exact' ? 'Exact duplicate' : 'Similar entry';
+      return {
+        content: [{ type: 'text', text: `${matchLabel} already exists: "${duplicate.entry.title}" (${duplicate.entry.id}). No new entry created.` }],
+      };
+    }
+
+    const config = readConfig();
+    const requireConfirmation = config.mcp && config.mcp.confirmEntries !== false;
+
+    if (requireConfirmation) {
+      // Route to drafts for human review
+      const draftId = saveDraft({
+        suggestedType: type,
+        suggestedTitle: title,
+        evidence: context,
+        files,
+        tags,
+        alternatives,
+        tradeoffs,
+        confidence: 0.9,
+        source: 'mcp-log',
+      });
+
+      return {
+        content: [{ type: 'text', text: `Draft created for human review: "${title}" (${draftId}). The developer can approve it with: lore drafts` }],
+      };
+    }
+
+    // Direct entry creation (confirmEntries is explicitly false)
     const id = generateId(type, title);
     const entry = {
       id,
@@ -64,8 +100,6 @@ async function handler(args) {
     };
 
     writeEntry(entry);
-
-    const index = readIndex();
     addEntryToIndex(index, entry);
     writeIndex(index);
 
@@ -91,3 +125,4 @@ async function handler(args) {
 }
 
 module.exports = { toolDefinition, handler };
+

package/src/mcp/tools/update.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const { readIndex, writeIndex } = require('../../lib/index');
+const { readEntry, writeEntry } = require('../../lib/entries');
+const { saveDraft } = require('../../lib/drafts');
+const { readConfig } = require('../../lib/config');
+
+const toolDefinition = {
+  name: 'lore_update',
+  description: 'Update an existing Lore entry. Use this when a previous decision, invariant, gotcha, or graveyard item needs to be revised because the context has changed. Updates may be saved as drafts pending human review depending on project configuration.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      id: {
+        type: 'string',
+        description: 'The ID of the existing entry to update (e.g. "decision-use-postgres-1709876543")',
+      },
+      context: {
+        type: 'string',
+        description: 'Updated context/explanation. If provided, replaces the existing context.',
+      },
+      title: {
+        type: 'string',
+        description: 'Updated title. If provided, replaces the existing title.',
+      },
+      files: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Updated list of related files. If provided, replaces the existing file list.',
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Updated tags. If provided, replaces existing tags.',
+      },
+      alternatives: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Updated alternatives considered.',
+      },
+      tradeoffs: {
+        type: 'string',
+        description: 'Updated tradeoffs.',
+      },
+    },
+    required: ['id'],
+  },
+};
+
+async function handler(args) {
+  const { id, context, title, files, tags, alternatives, tradeoffs } = args;
+
+  try {
+    const index = readIndex();
+    const entryPath = index.entries[id];
+
+    if (!entryPath) {
+      return {
+        content: [{ type: 'text', text: `Entry not found: "${id}". Use lore_search to find the correct entry ID.` }],
+        isError: true,
+      };
+    }
+
+    const entry = readEntry(entryPath);
+    if (!entry) {
+      return {
+        content: [{ type: 'text', text: `Failed to read entry: "${id}".` }],
+        isError: true,
+      };
+    }
+
+    const config = readConfig();
+    const requireConfirmation = config.mcp && config.mcp.confirmEntries !== false;
+
+    // Build a summary of what's changing
+    const changes = [];
+    if (title !== undefined && title !== entry.title) changes.push(`title: "${entry.title}" → "${title}"`);
+    if (context !== undefined && context !== entry.context) changes.push('context updated');
+    if (files !== undefined) changes.push(`files: [${files.join(', ')}]`);
+    if (tags !== undefined) changes.push(`tags: [${tags.join(', ')}]`);
+    if (alternatives !== undefined) changes.push(`alternatives: [${alternatives.join(', ')}]`);
+    if (tradeoffs !== undefined) changes.push('tradeoffs updated');
+
+    if (changes.length === 0) {
+      return {
+        content: [{ type: 'text', text: `No changes provided for entry "${id}".` }],
+      };
+    }
+
+    if (requireConfirmation) {
+      // Route update through drafts for human review
+      const draftId = saveDraft({
+        suggestedType: entry.type,
+        suggestedTitle: title || entry.title,
+        evidence: `[UPDATE to ${id}] ${context || entry.context}`,
+        files: files || entry.files,
+        tags: tags || entry.tags,
+        alternatives: alternatives || entry.alternatives,
+        tradeoffs: tradeoffs !== undefined ? tradeoffs : entry.tradeoffs,
+        confidence: 0.95,
+        source: 'mcp-update',
+        updatesEntryId: id,
+      });
+
+      return {
+        content: [{ type: 'text', text: `Update drafted for human review (${draftId}). Changes: ${changes.join('; ')}. The developer can approve it with: lore drafts` }],
+      };
+    }
+
+    // Direct update (confirmEntries is explicitly false)
+    if (title !== undefined) entry.title = title;
+    if (context !== undefined) entry.context = context;
+    if (files !== undefined) entry.files = files;
+    if (tags !== undefined) entry.tags = tags;
+    if (alternatives !== undefined) entry.alternatives = alternatives;
+    if (tradeoffs !== undefined) entry.tradeoffs = tradeoffs;
+    entry.lastUpdated = new Date().toISOString();
+
+    writeEntry(entry);
+    writeIndex(index);
+
+    // Re-embed
+    try {
+      const { generateEmbedding, storeEmbedding } = require('../../lib/embeddings');
+      const text = [entry.title, entry.context, ...(entry.alternatives || []), entry.tradeoffs || '', ...(entry.tags || [])].join(' ');
+      const vector = await generateEmbedding(text);
+      storeEmbedding(id, vector);
+    } catch (e) {
+      // Ollama not available — skip
+    }
+
+    return {
+      content: [{ type: 'text', text: `Updated entry "${id}". Changes: ${changes.join('; ')}` }],
+    };
+  } catch (e) {
+    return {
+      content: [{ type: 'text', text: `Error updating entry: ${e.message}` }],
+      isError: true,
+    };
+  }
+}
+
+module.exports = { toolDefinition, handler };