mindlink 1.2.0 → 2.0.0

package/dist/cli.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
+import "./chunk-2H7UOFLK.js";
 
 // src/cli.ts
-import { Command as Command16 } from "commander";
-import chalk17 from "chalk";
+import { Command as Command20 } from "commander";
+import chalk20 from "chalk";
 
 // src/utils/version.ts
-var VERSION = "1.1.5";
+var VERSION = "2.0.0";
 
 // src/commands/init.ts
 import { Command } from "commander";
@@ -33,6 +34,7 @@ import { join as join3, resolve, dirname as dirname2, basename } from "path";
 // src/utils/paths.ts
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
+import { homedir } from "os";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 var TEMPLATES_DIR = join(__dirname, "templates");
@@ -40,6 +42,9 @@ var BRAIN_TEMPLATES_DIR = join(TEMPLATES_DIR, "brain");
 var AGENT_TEMPLATES_DIR = join(TEMPLATES_DIR, "agents");
 var HOOKS_TEMPLATES_DIR = join(TEMPLATES_DIR, "hooks");
 var BRAIN_DIR = ".brain";
+var GLOBAL_MINDLINK_DIR = join(homedir(), ".mindlink");
+var GLOBAL_USER_PROFILE_PATH = join(GLOBAL_MINDLINK_DIR, "USER.md");
+var GLOBAL_WINDSURF_MCP_PATH = join(homedir(), ".codeium", "windsurf", "mcp_config.json");
 
 // src/utils/banner.ts
 import chalk from "chalk";
@@ -70,8 +75,8 @@ var AGENTS = [
 // src/utils/registry.ts
 import { readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join as join2 } from "path";
-import { homedir } from "os";
-var REGISTRY_DIR = join2(homedir(), ".mindlink");
+import { homedir as homedir2 } from "os";
+var REGISTRY_DIR = join2(homedir2(), ".mindlink");
 var REGISTRY_PATH = join2(REGISTRY_DIR, "projects.json");
 function load() {
   try {
@@ -100,6 +105,65 @@ function pruneRegistry(isValid) {
   if (pruned.length !== paths.length) save(pruned);
 }
 
+// src/utils/content.ts
+function sectionHasRealContent(markdown, heading) {
+  const lines = markdown.split("\n");
+  let inSection = false;
+  let headingLevel = 0;
+  for (const line of lines) {
+    const match = line.match(/^(#{1,6})\s+(.+)/);
+    if (match) {
+      const level = match[1].length;
+      const title = match[2].replace(/<!--.*?-->/g, "").trim();
+      if (title.toLowerCase() === heading.toLowerCase()) {
+        inSection = true;
+        headingLevel = level;
+        continue;
+      }
+      if (inSection && level <= headingLevel) {
+        break;
+      }
+    }
+    if (inSection) {
+      const t = line.trim();
+      if (t.length > 0 && !t.startsWith("#") && !t.startsWith("<!--") && !t.startsWith(">") && !t.startsWith("|") && t !== "---") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function replaceSection(markdown, heading, newBody) {
+  const lines = markdown.split("\n");
+  let headingIdx = -1;
+  let nextSectionIdx = lines.length;
+  let headingLevel = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(/^(#{1,6})\s+(.+)/);
+    if (match) {
+      const level = match[1].length;
+      const title = match[2].replace(/<!--.*?-->/g, "").trim();
+      if (headingIdx < 0 && title.toLowerCase() === heading.toLowerCase()) {
+        headingIdx = i;
+        headingLevel = level;
+      } else if (headingIdx >= 0 && level <= headingLevel) {
+        nextSectionIdx = i;
+        break;
+      }
+    }
+  }
+  if (headingIdx < 0) return markdown;
+  const before = lines.slice(0, headingIdx + 1);
+  const after = lines.slice(nextSectionIdx);
+  return [...before, "", newBody.trim(), "", ...after].join("\n");
+}
+function countRealLines(markdown) {
+  return markdown.split("\n").filter((line) => {
+    const t = line.trim();
+    return t.length > 0 && !t.startsWith("#") && !t.startsWith("<!--") && !t.startsWith(">") && t !== "---";
+  }).length;
+}
+
 // src/commands/init.ts
 function detectProjectInfo(projectPath) {
   const date = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { year: "numeric", month: "short", day: "numeric" });
@@ -176,6 +240,41 @@ function memoryHasRealContent(memoryPath) {
     return false;
   }
 }
+function injectUserProfile(memoryContent, profileContent) {
+  const profileLines = profileContent.split("\n");
+  const contentStart = profileLines.findIndex((l) => {
+    const t = l.trim();
+    return t.length > 0 && !t.startsWith("#") && !t.startsWith(">") && !t.startsWith("<!--");
+  });
+  const profileBody = contentStart >= 0 ? profileLines.slice(contentStart).join("\n").trim() : "";
+  if (!profileBody) return memoryContent;
+  const lines = memoryContent.split("\n");
+  let insertAt = -1;
+  let inProfile = false;
+  let profileHeadingLevel = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(/^(#{1,6})\s+(.+)/);
+    if (match) {
+      const level = match[1].length;
+      const title = match[2].replace(/<!--.*?-->/g, "").trim();
+      if (title.toLowerCase() === "user profile") {
+        inProfile = true;
+        profileHeadingLevel = level;
+        continue;
+      }
+      if (inProfile && level <= profileHeadingLevel) {
+        insertAt = i;
+        break;
+      }
+    }
+    if (inProfile && insertAt < 0 && i === lines.length - 1) {
+      insertAt = lines.length;
+    }
+  }
+  if (insertAt < 0) return memoryContent;
+  lines.splice(insertAt, 0, profileBody, "");
+  return lines.join("\n");
+}
 function buildMemoryMd(templateContent, info2) {
   let content = templateContent;
   const whatLine = info2.description ? `**${info2.name}** \u2014 ${info2.description}` : `**${info2.name}**`;
@@ -271,7 +370,11 @@ Examples:
             const hookDest = join3(projectPath, ".claude", "settings.json");
             if (!existsSync2(hookDest)) {
               mkdirSync2(dirname2(hookDest), { recursive: true });
-              writeFileSync2(hookDest, readFileSync2(join3(HOOKS_TEMPLATES_DIR, "claude-settings.json"), "utf8"));
+              const settings = JSON.parse(readFileSync2(join3(HOOKS_TEMPLATES_DIR, "claude-settings.json"), "utf8"));
+              settings.mcpServers = {
+                mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } }
+              };
+              writeFileSync2(hookDest, JSON.stringify(settings, null, 2));
               restored.push(".claude/settings.json");
             }
           }
@@ -452,6 +555,18 @@ Examples:
       writeFileSync2(dest, content);
       created.push(`${file.label.padEnd(32)} ${chalk2.dim(file.desc)}`);
     }
+    const memoryDest = join3(brainDir, "MEMORY.md");
+    if (existsSync2(GLOBAL_USER_PROFILE_PATH)) {
+      const profileContent = readFileSync2(GLOBAL_USER_PROFILE_PATH, "utf8");
+      if (sectionHasRealContent(profileContent, "MindLink \u2014 Global User Profile") || profileContent.split("\n").some((l) => {
+        const t = l.trim();
+        return t.length > 0 && !t.startsWith("#") && !t.startsWith(">") && !t.startsWith("<!--");
+      })) {
+        const injected = injectUserProfile(readFileSync2(memoryDest, "utf8"), profileContent);
+        writeFileSync2(memoryDest, injected);
+        created.push(`User Profile imported from ~/.mindlink/USER.md`);
+      }
+    }
     for (const agentValue of selectedAgents) {
       const agent = AGENTS.find((a) => a.value === agentValue);
       if (!agent) continue;
@@ -464,8 +579,70 @@ Examples:
       const hookDest = join3(projectPath, ".claude", "settings.json");
       if (!existsSync2(hookDest)) {
         mkdirSync2(dirname2(hookDest), { recursive: true });
-        writeFileSync2(hookDest, readFileSync2(join3(HOOKS_TEMPLATES_DIR, "claude-settings.json"), "utf8"));
-        created.push(`.claude/settings.json${" ".repeat(14)} ${chalk2.dim("Claude Code compact hook")}`);
+        const settings = JSON.parse(readFileSync2(join3(HOOKS_TEMPLATES_DIR, "claude-settings.json"), "utf8"));
+        settings.mcpServers = {
+          mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } }
+        };
+        writeFileSync2(hookDest, JSON.stringify(settings, null, 2));
+        created.push(`.claude/settings.json${" ".repeat(14)} ${chalk2.dim("Claude Code hooks + MCP server")}`);
+      }
+    }
+    if (selectedAgents.includes("cursor")) {
+      const cursorMcpDest = join3(projectPath, ".cursor", "mcp.json");
+      if (!existsSync2(cursorMcpDest)) {
+        mkdirSync2(join3(projectPath, ".cursor"), { recursive: true });
+        const cursorMcp = { mcpServers: { mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } } } };
+        writeFileSync2(cursorMcpDest, JSON.stringify(cursorMcp, null, 2));
+        created.push(`.cursor/mcp.json${" ".repeat(20)} ${chalk2.dim("Cursor MCP server")}`);
+      }
+    }
+    if (selectedAgents.includes("continue")) {
+      const continueMcpDest = join3(projectPath, ".continue", "mcpServers", "mindlink.json");
+      if (!existsSync2(continueMcpDest)) {
+        mkdirSync2(join3(projectPath, ".continue", "mcpServers"), { recursive: true });
+        const continueMcp = { mcpServers: { mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } } } };
+        writeFileSync2(continueMcpDest, JSON.stringify(continueMcp, null, 2));
+        created.push(`.continue/mcpServers/mindlink.json ${chalk2.dim("Continue MCP server")}`);
+      }
+    }
+    if (selectedAgents.includes("copilot")) {
+      const copilotMcpDest = join3(projectPath, ".vscode", "mcp.json");
+      if (!existsSync2(copilotMcpDest)) {
+        mkdirSync2(join3(projectPath, ".vscode"), { recursive: true });
+        const copilotMcp = { mcpServers: { mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } } } };
+        writeFileSync2(copilotMcpDest, JSON.stringify(copilotMcp, null, 2));
+        created.push(`.vscode/mcp.json${" ".repeat(19)} ${chalk2.dim("GitHub Copilot MCP server")}`);
+      }
+    }
+    if (selectedAgents.includes("kiro")) {
+      const kiroMcpDest = join3(projectPath, ".kiro", "settings", "mcp.json");
+      if (!existsSync2(kiroMcpDest)) {
+        mkdirSync2(join3(projectPath, ".kiro", "settings"), { recursive: true });
+        const kiroMcp = { mcpServers: { mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } } } };
+        writeFileSync2(kiroMcpDest, JSON.stringify(kiroMcp, null, 2));
+        created.push(`.kiro/settings/mcp.json${" ".repeat(13)} ${chalk2.dim("Kiro MCP server")}`);
+      }
+    }
+    if (selectedAgents.includes("windsurf")) {
+      try {
+        mkdirSync2(dirname2(GLOBAL_WINDSURF_MCP_PATH), { recursive: true });
+        let existingWindsurf = {};
+        if (existsSync2(GLOBAL_WINDSURF_MCP_PATH)) {
+          try {
+            existingWindsurf = JSON.parse(readFileSync2(GLOBAL_WINDSURF_MCP_PATH, "utf8"));
+          } catch {
+          }
+        }
+        const mergedWindsurf = {
+          ...existingWindsurf,
+          mcpServers: {
+            ...typeof existingWindsurf.mcpServers === "object" && existingWindsurf.mcpServers !== null ? existingWindsurf.mcpServers : {},
+            mindlink: { command: "mindlink", args: ["mcp"] }
+          }
+        };
+        writeFileSync2(GLOBAL_WINDSURF_MCP_PATH, JSON.stringify(mergedWindsurf, null, 2));
+        created.push(`~/.codeium/windsurf/mcp_config.json ${chalk2.dim("Windsurf MCP server (global)")}`);
+      } catch {
       }
     }
     if (!gitTracking) {
@@ -498,7 +675,15 @@ Examples:
     console.log("");
     for (const err of errors) console.log(`  ${chalk2.red("\u2717")}  ${err}`);
   }
-  console.log("");
+  if (selectedAgents.includes("cline")) {
+    console.log(`  ${chalk2.yellow("\u2192")}  Cline: add the MCP server manually in Cline's settings UI (MCP Servers tab)`);
+    console.log(`     ${chalk2.dim("Command: mindlink  Args: mcp  Env: MINDLINK_PROJECT_PATH=" + projectPath)}`);
+    console.log("");
+  }
+  if (!existsSync2(GLOBAL_USER_PROFILE_PATH)) {
+    console.log(`  ${chalk2.dim("\u2192")}  Run ${chalk2.cyan("mindlink profile")} to set up a global user profile \u2014 imported into every new project automatically.`);
+    console.log("");
+  }
   note(
     `Your AI finally has a brain.
 
@@ -1200,7 +1385,7 @@ var REQUIRED_BRAIN_FILES = ["MEMORY.md", "SESSION.md", "SHARED.md", "LOG.md"];
 async function latestVersion() {
   try {
     const { default: https } = await import("https");
-    return new Promise((resolve14) => {
+    return new Promise((resolve17) => {
       const req = https.get(
         "https://registry.npmjs.org/mindlink/latest",
         { headers: { "User-Agent": "mindlink-cli" } },
@@ -1212,17 +1397,17 @@ async function latestVersion() {
           res.on("end", () => {
             try {
               const parsed = JSON.parse(data);
-              resolve14(parsed.version ?? null);
+              resolve17(parsed.version ?? null);
             } catch {
-              resolve14(null);
+              resolve17(null);
             }
           });
         }
       );
-      req.on("error", () => resolve14(null));
+      req.on("error", () => resolve17(null));
       req.setTimeout(8e3, () => {
         req.destroy();
-        resolve14(null);
+        resolve17(null);
       });
     });
   } catch {
@@ -1243,71 +1428,73 @@ Examples:
   mindlink update
   `).action(async () => {
   const current = VERSION;
+  let nonTtyExitCode = null;
   if (!process.stdin.isTTY) {
-    const latest2 = await latestVersion();
-    if (!latest2) {
+    const latest = await latestVersion();
+    if (!latest) {
       console.log(JSON.stringify({ current, latest: null, upToDate: null }));
-      process.exit(1);
+      nonTtyExitCode = 1;
+    } else {
+      const upToDate = !semverGt(latest, current);
+      console.log(JSON.stringify({ current, latest, upToDate }));
+      if (!upToDate) nonTtyExitCode = 2;
     }
-    const upToDate = !semverGt(latest2, current);
-    console.log(JSON.stringify({ current, latest: latest2, upToDate }));
-    if (!upToDate) process.exit(2);
-    return;
-  }
-  const s = spinner2();
-  s.start("Checking for updates...");
-  const latest = await latestVersion();
-  if (!latest) {
-    s.stop("Could not reach npm registry.");
-    console.log("");
-    console.log(`  ${chalk9.red("\u2717")}  Could not check for updates. Check your internet connection.`);
-    console.log(`     ${chalk9.dim("Latest releases: github.com/404-not-found/mindlink/releases")}`);
-    console.log("");
-    process.exit(1);
-  }
-  s.stop("Done.");
-  console.log("");
-  console.log(`  Current version   : ${chalk9.dim(current)}`);
-  console.log(`  Latest version    : ${semverGt(latest, current) ? chalk9.green(latest) : chalk9.dim(latest)}`);
-  console.log("");
-  if (!semverGt(latest, current)) {
-    console.log(`  ${chalk9.green("\u2713")}  You're on the latest version (${current}).`);
-    console.log("");
   } else {
-    const action = await select3({
-      message: `Update to ${latest}?`,
-      options: [
-        { value: "update", label: `Update to ${latest}` },
-        { value: "skip", label: "Skip this version" },
-        { value: "cancel", label: "Cancel" }
-      ]
-    });
-    if (isCancel4(action) || action === "cancel" || action === "skip") {
-      if (action === "skip") {
-        console.log(`  ${chalk9.dim("Skipped. Run mindlink update again to install later.")}`);
-      } else {
-        cancel4("Cancelled.");
-      }
+    const s = spinner2();
+    s.start("Checking for updates...");
+    const latest = await latestVersion();
+    if (!latest) {
+      s.stop("Could not reach npm registry.");
       console.log("");
-      return;
-    }
-    const s2 = spinner2();
-    s2.start(`Installing mindlink@${latest}...`);
-    try {
-      execSync2(`npm install -g mindlink@${latest}`, { stdio: "pipe" });
-      s2.stop("Done.");
+      console.log(`  ${chalk9.red("\u2717")}  Could not check for updates. Check your internet connection.`);
+      console.log(`     ${chalk9.dim("Latest releases: github.com/404-not-found/mindlink/releases")}`);
       console.log("");
-      console.log(`  ${chalk9.green("\u2713")}  Updated to ${latest}.`);
-      console.log(`     ${chalk9.dim("See what's new: github.com/404-not-found/mindlink/releases")}`);
-    } catch (err) {
-      s2.stop("Failed.");
+      process.exit(1);
+    }
+    s.stop("Done.");
+    console.log("");
+    console.log(`  Current version   : ${chalk9.dim(current)}`);
+    console.log(`  Latest version    : ${semverGt(latest, current) ? chalk9.green(latest) : chalk9.dim(latest)}`);
+    console.log("");
+    if (!semverGt(latest, current)) {
+      console.log(`  ${chalk9.green("\u2713")}  You're on the latest version (${current}).`);
       console.log("");
-      console.log(`  ${chalk9.red("\u2717")}  Update failed.`);
-      console.log(`     ${chalk9.dim("Try: npm install -g mindlink@" + latest)}`);
-      if (err instanceof Error && err.message.includes("EACCES")) {
-        console.log(`     ${chalk9.dim("Permission error \u2014 try: sudo npm install -g mindlink@" + latest)}`);
+    } else {
+      const action = await select3({
+        message: `Update to ${latest}?`,
+        options: [
+          { value: "update", label: `Update to ${latest}` },
+          { value: "skip", label: "Skip this version" },
+          { value: "cancel", label: "Cancel" }
+        ]
+      });
+      if (isCancel4(action) || action === "cancel" || action === "skip") {
+        if (action === "skip") {
+          console.log(`  ${chalk9.dim("Skipped. Run mindlink update again to install later.")}`);
+        } else {
+          cancel4("Cancelled.");
+        }
+        console.log("");
+        return;
+      }
+      const s2 = spinner2();
+      s2.start(`Installing mindlink@${latest}...`);
+      try {
+        execSync2(`npm install -g mindlink@${latest}`, { stdio: "pipe" });
+        s2.stop("Done.");
+        console.log("");
+        console.log(`  ${chalk9.green("\u2713")}  Updated to ${latest}.`);
+        console.log(`     ${chalk9.dim("See what's new: github.com/404-not-found/mindlink/releases")}`);
+      } catch (err) {
+        s2.stop("Failed.");
+        console.log("");
+        console.log(`  ${chalk9.red("\u2717")}  Update failed.`);
+        console.log(`     ${chalk9.dim("Try: npm install -g mindlink@" + latest)}`);
+        if (err instanceof Error && err.message.includes("EACCES")) {
+          console.log(`     ${chalk9.dim("Permission error \u2014 try: sudo npm install -g mindlink@" + latest)}`);
+        }
+        process.exit(1);
       }
-      process.exit(1);
     }
   }
   const cwd = process.cwd();
@@ -1356,11 +1543,132 @@ Examples:
         const hookDest = join10(projectPath, ".claude", "settings.json");
         try {
           mkdirSync4(join10(projectPath, ".claude"), { recursive: true });
-          writeFileSync6(hookDest, readFileSync9(join10(HOOKS_TEMPLATES_DIR, "claude-settings.json"), "utf8"));
+          const template = JSON.parse(readFileSync9(join10(HOOKS_TEMPLATES_DIR, "claude-settings.json"), "utf8"));
+          let existing = {};
+          if (existsSync9(hookDest)) {
+            try {
+              existing = JSON.parse(readFileSync9(hookDest, "utf8"));
+            } catch {
+            }
+          }
+          const merged = {
+            ...template,
+            ...existing,
+            // Always refresh hooks and permissions from template
+            hooks: template.hooks,
+            permissions: template.permissions,
+            // Merge mcpServers: keep user's other servers, update mindlink entry
+            mcpServers: {
+              ...typeof existing.mcpServers === "object" && existing.mcpServers !== null ? existing.mcpServers : {},
+              mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } }
+            }
+          };
+          writeFileSync6(hookDest, JSON.stringify(merged, null, 2));
           refreshed.push(".claude/settings.json");
         } catch {
         }
       }
+      if (agentValues.includes("cursor")) {
+        const cursorMcpDest = join10(projectPath, ".cursor", "mcp.json");
+        try {
+          mkdirSync4(join10(projectPath, ".cursor"), { recursive: true });
+          let existing = {};
+          if (existsSync9(cursorMcpDest)) {
+            try {
+              existing = JSON.parse(readFileSync9(cursorMcpDest, "utf8"));
+            } catch {
+            }
+          }
+          const merged = {
+            ...existing,
+            mcpServers: {
+              ...typeof existing.mcpServers === "object" && existing.mcpServers !== null ? existing.mcpServers : {},
+              mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } }
+            }
+          };
+          writeFileSync6(cursorMcpDest, JSON.stringify(merged, null, 2));
+          refreshed.push(".cursor/mcp.json");
+        } catch {
+        }
+      }
+      if (agentValues.includes("continue")) {
+        const continueMcpDest = join10(projectPath, ".continue", "mcpServers", "mindlink.json");
+        try {
+          mkdirSync4(join10(projectPath, ".continue", "mcpServers"), { recursive: true });
+          const continueMcp = { mcpServers: { mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } } } };
+          writeFileSync6(continueMcpDest, JSON.stringify(continueMcp, null, 2));
+          refreshed.push(".continue/mcpServers/mindlink.json");
+        } catch {
+        }
+      }
+      if (agentValues.includes("copilot")) {
+        const copilotMcpDest = join10(projectPath, ".vscode", "mcp.json");
+        try {
+          mkdirSync4(join10(projectPath, ".vscode"), { recursive: true });
+          let existing = {};
+          if (existsSync9(copilotMcpDest)) {
+            try {
+              existing = JSON.parse(readFileSync9(copilotMcpDest, "utf8"));
+            } catch {
+            }
+          }
+          const merged = {
+            ...existing,
+            mcpServers: {
+              ...typeof existing.mcpServers === "object" && existing.mcpServers !== null ? existing.mcpServers : {},
+              mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } }
+            }
+          };
+          writeFileSync6(copilotMcpDest, JSON.stringify(merged, null, 2));
+          refreshed.push(".vscode/mcp.json");
+        } catch {
+        }
+      }
+      if (agentValues.includes("kiro")) {
+        const kiroMcpDest = join10(projectPath, ".kiro", "settings", "mcp.json");
+        try {
+          mkdirSync4(join10(projectPath, ".kiro", "settings"), { recursive: true });
+          let existing = {};
+          if (existsSync9(kiroMcpDest)) {
+            try {
+              existing = JSON.parse(readFileSync9(kiroMcpDest, "utf8"));
+            } catch {
+            }
+          }
+          const merged = {
+            ...existing,
+            mcpServers: {
+              ...typeof existing.mcpServers === "object" && existing.mcpServers !== null ? existing.mcpServers : {},
+              mindlink: { command: "mindlink", args: ["mcp"], env: { MINDLINK_PROJECT_PATH: projectPath } }
+            }
+          };
+          writeFileSync6(kiroMcpDest, JSON.stringify(merged, null, 2));
+          refreshed.push(".kiro/settings/mcp.json");
+        } catch {
+        }
+      }
+      if (agentValues.includes("windsurf")) {
+        try {
+          mkdirSync4(dirname4(GLOBAL_WINDSURF_MCP_PATH), { recursive: true });
+          let existing = {};
+          if (existsSync9(GLOBAL_WINDSURF_MCP_PATH)) {
+            try {
+              existing = JSON.parse(readFileSync9(GLOBAL_WINDSURF_MCP_PATH, "utf8"));
+            } catch {
+            }
+          }
+          const merged = {
+            ...existing,
+            mcpServers: {
+              ...typeof existing.mcpServers === "object" && existing.mcpServers !== null ? existing.mcpServers : {},
+              mindlink: { command: "mindlink", args: ["mcp"] }
+            }
+          };
+          writeFileSync6(GLOBAL_WINDSURF_MCP_PATH, JSON.stringify(merged, null, 2));
+          refreshed.push("~/.codeium/windsurf/mcp_config.json");
+        } catch {
+        }
+      }
       const memoryPath = join10(projectPath, BRAIN_DIR, "MEMORY.md");
       if (existsSync9(memoryPath)) {
         try {
@@ -1401,6 +1709,26 @@ Examples:
         } catch {
         }
       }
+      if (existsSync9(GLOBAL_USER_PROFILE_PATH) && existsSync9(memoryPath)) {
+        try {
+          const profileRaw = readFileSync9(GLOBAL_USER_PROFILE_PATH, "utf8");
+          const profileLines = profileRaw.split("\n");
+          const bodyStart = profileLines.findIndex((l) => {
+            const t = l.trim();
+            return t.length > 0 && !t.startsWith("#") && !t.startsWith(">") && !t.startsWith("<!--");
+          });
+          const profileBody = bodyStart >= 0 ? profileLines.slice(bodyStart).join("\n").trim() : "";
+          if (profileBody) {
+            const memContent = readFileSync9(memoryPath, "utf8");
+            const updated = replaceSection(memContent, "User Profile", profileBody);
+            if (updated !== memContent) {
+              writeFileSync6(memoryPath, updated);
+              if (!refreshed.includes(".brain/MEMORY.md")) refreshed.push(".brain/MEMORY.md (profile synced)");
+            }
+          }
+        } catch {
+        }
+      }
       console.log(`  ${chalk9.bold(projectPath)}`);
       for (const f of refreshed) {
         console.log(`    ${chalk9.green("\u2713")}  ${f}`);
@@ -1410,6 +1738,7 @@ Examples:
     console.log(`  ${chalk9.dim("All agent files are up to date.")}`);
   }
   console.log("");
+  if (nonTtyExitCode !== null) process.exit(nonTtyExitCode);
 });
 
 // src/commands/summary.ts
@@ -2238,8 +2567,760 @@ Examples:
   console.log("");
 });
 
+// src/commands/verify.ts
+import { Command as Command16 } from "commander";
+import chalk17 from "chalk";
+import { existsSync as existsSync16, readFileSync as readFileSync14, statSync as statSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname5 } from "path";
+import { join as join17, resolve as resolve14 } from "path";
+var SESSION_WARN_DAYS = 3;
+var SESSION_FAIL_DAYS = 7;
+var MEMORY_WARN_LINES = 100;
+var MEMORY_FAIL_LINES = 200;
+function pass(id, label, message) {
+  return { id, label, status: "pass", message, fixable: false };
+}
+function warn2(id, label, message, fixable = false) {
+  return { id, label, status: "warn", message, fixable };
+}
+function fail2(id, label, message, fixable = false) {
+  return { id, label, status: "fail", message, fixable };
+}
+function icon2(status) {
+  switch (status) {
+    case "pass":
+      return chalk17.green("\u2713");
+    case "warn":
+      return chalk17.yellow("\u26A0");
+    case "fail":
+      return chalk17.red("\u2717");
+  }
+}
+function runChecks(projectPath) {
+  const brainDir = join17(projectPath, BRAIN_DIR);
+  const results = [];
+  if (!existsSync16(brainDir)) {
+    results.push(fail2("brain_missing", ".brain/ missing", `Run ${chalk17.cyan("mindlink init")} to set up memory.`));
+    return results;
+  }
+  const configPath = join17(brainDir, "config.json");
+  let config = {};
+  if (existsSync16(configPath)) {
+    try {
+      config = JSON.parse(readFileSync14(configPath, "utf8"));
+    } catch {
+    }
+  }
+  const memoryPath = join17(brainDir, "MEMORY.md");
+  if (!existsSync16(memoryPath)) {
+    results.push(fail2("core", "Core section", `MEMORY.md is missing \u2014 run ${chalk17.cyan("mindlink init")}.`));
+  } else {
+    const memMd = readFileSync14(memoryPath, "utf8");
+    if (!sectionHasRealContent(memMd, "Core")) {
+      results.push(fail2("core", "Core section \u2014 empty", "Start a session and tell your AI to fill in the Core section."));
+    } else {
+      results.push(pass("core", "Core section \u2014 filled", ""));
+    }
+  }
+  if (existsSync16(memoryPath)) {
+    const memMd = readFileSync14(memoryPath, "utf8");
+    if (!sectionHasRealContent(memMd, "User Profile")) {
+      results.push(fail2("user_profile", "User Profile \u2014 empty", `Run ${chalk17.cyan("mindlink profile")} to set up your global profile and import it here.`));
+    } else {
+      results.push(pass("user_profile", "User Profile \u2014 filled", ""));
+    }
+  }
+  const sessionPath = join17(brainDir, "SESSION.md");
+  if (!existsSync16(sessionPath)) {
+    results.push(fail2("session_fresh", "SESSION.md \u2014 missing", `Run ${chalk17.cyan("mindlink init")} to recreate it.`));
+  } else {
+    const ageDays = (Date.now() - statSync5(sessionPath).mtime.getTime()) / 864e5;
+    const hasContent = readFileSync14(sessionPath, "utf8").split("\n").some((l) => l.trim().length > 0 && !l.startsWith("#") && !l.startsWith("<!--"));
+    if (!hasContent) {
+      results.push(warn2("session_fresh", "SESSION.md \u2014 no content yet", "Start a session \u2014 your AI will fill this in automatically."));
+    } else if (ageDays > SESSION_FAIL_DAYS) {
+      const days = Math.floor(ageDays);
+      results.push(fail2("session_fresh", `SESSION.md \u2014 last updated ${days} days ago`, "SESSION.md has not been updated in a week. Your AI may not be writing session state. Check that it is completing the REQUIRED session-end steps."));
+    } else if (ageDays > SESSION_WARN_DAYS) {
+      const days = Math.floor(ageDays);
+      results.push(warn2("session_fresh", `SESSION.md \u2014 last updated ${days} days ago`, "SESSION.md is getting stale. If you have active sessions, your AI should be updating this after each response."));
+    } else {
+      const mins = Math.floor((Date.now() - statSync5(sessionPath).mtime.getTime()) / 6e4);
+      const age = mins < 60 ? `${mins}m ago` : mins < 1440 ? `${Math.floor(mins / 60)}h ago` : `${Math.floor(mins / 1440)}d ago`;
+      results.push(pass("session_fresh", `SESSION.md \u2014 updated ${age}`, ""));
+    }
+  }
+  const logPath = join17(brainDir, "LOG.md");
+  if (!existsSync16(logPath)) {
+    results.push(fail2("log_present", "LOG.md \u2014 missing", `Run ${chalk17.cyan("mindlink init")} to recreate it.`));
+  } else {
+    const entries = (readFileSync14(logPath, "utf8").match(/^##\s+/gm) ?? []).length;
+    if (entries === 0) {
+      results.push(pass("log_present", "LOG.md \u2014 no sessions yet", ""));
+    } else {
+      results.push(pass("log_present", `LOG.md \u2014 ${entries} session${entries !== 1 ? "s" : ""} logged`, ""));
+    }
+  }
+  if (existsSync16(memoryPath)) {
+    const memMd = readFileSync14(memoryPath, "utf8");
+    const lines = countRealLines(memMd);
+    if (lines > MEMORY_FAIL_LINES) {
+      results.push(fail2("memory_size", `MEMORY.md \u2014 ${lines} lines (target: under ${MEMORY_FAIL_LINES})`, `Run ${chalk17.cyan("mindlink prune")} to consolidate stale entries.`));
+    } else if (lines > MEMORY_WARN_LINES) {
+      results.push(warn2("memory_size", `MEMORY.md \u2014 ${lines} lines (getting long)`, `Consider running ${chalk17.cyan("mindlink prune")} to retire old entries.`));
+    } else {
+      results.push(pass("memory_size", `MEMORY.md \u2014 ${lines} line${lines !== 1 ? "s" : ""} (healthy)`, ""));
+    }
+  }
+  const configuredAgents = config.agents ?? [];
+  if (configuredAgents.length === 0) {
+    results.push(warn2("agent_files", "No agents configured", `Run ${chalk17.cyan("mindlink config")} \u2192 Agent instruction files.`, false));
+  } else {
+    const missing = [];
+    for (const agentValue of configuredAgents) {
+      const agent = AGENTS.find((a) => a.value === agentValue);
+      if (!agent) continue;
+      if (!existsSync16(join17(projectPath, agent.destFile))) missing.push(agent.destFile);
+    }
+    if (missing.length === configuredAgents.length) {
+      results.push(fail2("agent_files", "Agent files \u2014 none present", `All configured agent files are missing. Run ${chalk17.cyan("mindlink verify --fix")} to regenerate.`, true));
+    } else if (missing.length > 0) {
+      results.push(warn2("agent_files", `Agent files \u2014 ${missing.length} missing: ${missing.join(", ")}`, `Run ${chalk17.cyan("mindlink verify --fix")} to regenerate.`, true));
+    } else {
+      results.push(pass("agent_files", `Agent files \u2014 all ${configuredAgents.length} present`, ""));
+    }
+  }
+  return results;
+}
+function applyFix(projectPath, results) {
+  const brainDir = join17(projectPath, BRAIN_DIR);
+  const configPath = join17(brainDir, "config.json");
+  let config = {};
+  if (existsSync16(configPath)) {
+    try {
+      config = JSON.parse(readFileSync14(configPath, "utf8"));
+    } catch {
+    }
+  }
+  const fixable = results.filter((r) => r.fixable && r.status !== "pass");
+  if (fixable.length === 0) {
+    console.log(`  ${chalk17.dim("Nothing to auto-fix. Address the issues above manually.")}`);
+    return;
+  }
+  let fixed = 0;
+  for (const r of fixable) {
+    if (r.id === "agent_files") {
+      const configuredAgents = config.agents ?? [];
+      for (const agentValue of configuredAgents) {
+        const agent = AGENTS.find((a) => a.value === agentValue);
+        if (!agent) continue;
+        const destPath = join17(projectPath, agent.destFile);
+        if (!existsSync16(destPath)) {
+          try {
+            mkdirSync6(dirname5(destPath), { recursive: true });
+            writeFileSync7(destPath, readFileSync14(join17(AGENT_TEMPLATES_DIR, agent.templateFile), "utf8"));
+            console.log(`  ${chalk17.green("\u2713")}  Regenerated ${agent.destFile}`);
+            fixed++;
+          } catch (err) {
+            console.log(`  ${chalk17.red("\u2717")}  Failed to regenerate ${agent.destFile}: ${err instanceof Error ? err.message : err}`);
+          }
+        }
+      }
+      if (configuredAgents.includes("claude")) {
+        const hookPath = join17(projectPath, ".claude", "settings.json");
+        if (!existsSync16(hookPath)) {
+          try {
+            mkdirSync6(dirname5(hookPath), { recursive: true });
+            writeFileSync7(hookPath, readFileSync14(join17(HOOKS_TEMPLATES_DIR, "claude-settings.json"), "utf8"));
+            console.log(`  ${chalk17.green("\u2713")}  Regenerated .claude/settings.json`);
+            fixed++;
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  for (const r of results) {
+    if (r.status === "fail" || r.status === "warn") {
+      if (r.id === "core" || r.id === "user_profile") {
+        console.log(`  ${chalk17.dim("\u2192")}  ${r.id === "core" ? "Core" : "User Profile"}: start a session and tell your AI to fill this in.`);
+      } else if (r.id === "memory_size") {
+        console.log(`  ${chalk17.dim("\u2192")}  MEMORY.md too large: run ${chalk17.cyan("mindlink prune")} to consolidate.`);
+      }
+    }
+  }
+  if (fixed > 0) console.log("");
+}
+var verifyCommand = new Command16("verify").description("Check that .brain/ memory is healthy and up-to-date").option("--json", "Output results as JSON").option("--fix", "Auto-fix recoverable issues (regenerate missing agent files)").addHelpText("after", `
+What is checked:
+  Core            \u2014 MEMORY.md Core section has real content
+  User Profile    \u2014 MEMORY.md User Profile has real content
+  SESSION.md      \u2014 was updated recently (warn >3 days, fail >7 days)
+  LOG.md          \u2014 present and readable
+  MEMORY.md size  \u2014 line count (warn >100, fail >200)
+  Agent files     \u2014 all files from config.json are present on disk
+
+Examples:
+  mindlink verify
+  mindlink verify --json
+  mindlink verify --fix
+  `).action((opts) => {
+  const projectPath = resolve14(process.cwd());
+  const results = runChecks(projectPath);
+  if (opts.json) {
+    console.log(JSON.stringify({ ok: results.every((r) => r.status === "pass"), checks: results }, null, 2));
+    const hasFailure = results.some((r) => r.status === "fail");
+    process.exit(hasFailure ? 1 : 0);
+  }
+  console.log("");
+  console.log(`  ${chalk17.bold("\u25C9 MindLink Verify")}`);
+  console.log(`  ${chalk17.dim(projectPath)}`);
+  console.log("");
+  for (const r of results) {
+    console.log(`  ${icon2(r.status)}  ${r.label}`);
+    if (r.message) console.log(`     ${chalk17.dim(r.message)}`);
+  }
+  console.log("");
+  const failCount = results.filter((r) => r.status === "fail").length;
+  const warnCount = results.filter((r) => r.status === "warn").length;
+  const fixableCount = results.filter((r) => r.fixable && r.status !== "pass").length;
+  if (opts.fix) {
+    applyFix(projectPath, results);
+  }
+  if (failCount > 0) {
+    console.log(`  ${chalk17.red.bold(`${failCount} error${failCount !== 1 ? "s" : ""}`)}, ${warnCount} warning${warnCount !== 1 ? "s" : ""}.`);
+    if (!opts.fix && fixableCount > 0) {
+      console.log(`  ${chalk17.dim(`Run ${chalk17.cyan("mindlink verify --fix")} to auto-repair ${fixableCount} issue${fixableCount !== 1 ? "s" : ""}.`)}`);
+    }
+  } else if (warnCount > 0) {
+    console.log(`  ${chalk17.yellow.bold(`${warnCount} warning${warnCount !== 1 ? "s" : ""}`)}, no critical errors.`);
+  } else {
+    console.log(`  ${chalk17.green.bold("All good.")} Your AI's memory is healthy.`);
+  }
+  console.log("");
+  if (failCount > 0) process.exit(1);
+});
+
+// src/commands/profile.ts
+import { Command as Command17 } from "commander";
+import chalk18 from "chalk";
+import { existsSync as existsSync17, readFileSync as readFileSync15, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
+import { execSync as execSync4 } from "child_process";
+var PROFILE_TEMPLATE = `# MindLink \u2014 Global User Profile
+
+> This file is imported into every new project's MEMORY.md on \`mindlink init\`.
+> Edit it with \`mindlink profile\`. Run \`mindlink update\` to sync changes to all projects.
+
+<!-- Role, company, title, level, years of experience -->
+<!-- Primary languages and tools -->
+<!-- Communication style and preferences -->
+<!-- Editor, OS, shell setup -->
+<!-- Added: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)} -->
+`;
+function ensureProfileExists() {
+  if (!existsSync17(GLOBAL_MINDLINK_DIR)) {
+    mkdirSync7(GLOBAL_MINDLINK_DIR, { recursive: true });
+  }
+  if (!existsSync17(GLOBAL_USER_PROFILE_PATH)) {
+    writeFileSync8(GLOBAL_USER_PROFILE_PATH, PROFILE_TEMPLATE);
+  }
+}
+var profileCommand = new Command17("profile").description("Manage your global user profile (imported into every new project)").option("--show", "Print current profile to stdout").option("--path", "Print profile file path only").addHelpText("after", `
+Your profile is stored at ~/.mindlink/USER.md and auto-imported into
+MEMORY.md when you run \`mindlink init\` on a new project.
+
+Run \`mindlink update\` to sync profile changes to all registered projects.
+
+Examples:
+  mindlink profile            # open profile in $EDITOR
+  mindlink profile --show     # print profile to stdout
+  mindlink profile --path     # print file path
+  `).action((opts) => {
+  if (opts.path) {
+    console.log(GLOBAL_USER_PROFILE_PATH);
+    return;
+  }
+  if (opts.show) {
+    if (!existsSync17(GLOBAL_USER_PROFILE_PATH)) {
+      console.log("");
+      console.log(`  ${chalk18.yellow("\u26A0")}  No global profile yet.`);
+      console.log(`     Run ${chalk18.cyan("mindlink profile")} to create one.`);
+      console.log("");
+      return;
+    }
+    console.log("");
+    console.log(readFileSync15(GLOBAL_USER_PROFILE_PATH, "utf8"));
+    return;
+  }
+  ensureProfileExists();
+  const editor = process.env.EDITOR || process.env.VISUAL || "nano";
+  console.log("");
+  console.log(`  ${chalk18.dim(`Opening ${GLOBAL_USER_PROFILE_PATH} in ${editor}...`)}`);
+  console.log(`  ${chalk18.dim("Run mindlink update after saving to sync to all registered projects.")}`);
+  console.log("");
+  try {
+    execSync4(`${editor} "${GLOBAL_USER_PROFILE_PATH}"`, { stdio: "inherit" });
+    console.log("");
+    console.log(`  ${chalk18.green("\u2713")}  Profile saved.`);
+    console.log(`  ${chalk18.dim("\u2192  Run mindlink update to sync to all registered projects.")}`);
+    console.log("");
+  } catch {
+    console.log("");
+  }
+});
+
+// src/commands/prune.ts
+import { Command as Command18 } from "commander";
+import { select as select6, isCancel as isCancel8 } from "@clack/prompts";
+import chalk19 from "chalk";
+import { existsSync as existsSync18, readFileSync as readFileSync16, writeFileSync as writeFileSync9 } from "fs";
+import { join as join18, resolve as resolve15 } from "path";
+var STALENESS_THRESHOLDS = {
+  "current focus": 14,
+  "decisions": 180,
+  "conventions": 180,
+  "architecture": 365
+  // 'user profile' and 'important context' have no expiry
+};
+var TIMESTAMP_RE = /<!--\s*added:\s*(\d{4}-\d{2}-\d{2})\s*-->/;
+var SECTION_RE = /^(#{1,6})\s+(.+)/;
+function parseTimestampedEntries(content) {
+  const lines = content.split("\n");
+  const entries = [];
+  let currentSection = "";
+  let currentHeadingLevel = 0;
+  let entryLines = [];
+  let entryStart = -1;
+  function flushEntry(lineEnd) {
+    if (entryStart < 0 || entryLines.length === 0) return;
+    const fullText = entryLines.join("\n");
+    const timestampMatch = fullText.match(TIMESTAMP_RE);
+    if (!timestampMatch) {
+      entryLines = [];
+      entryStart = -1;
+      return;
+    }
+    const addedDate = /* @__PURE__ */ new Date(timestampMatch[1] + "T00:00:00Z");
+    const ageInDays = (Date.now() - addedDate.getTime()) / 864e5;
+    const sectionKey = currentSection.toLowerCase().replace(/\s*<!--.*?-->\s*/g, "").trim();
+    const threshold = STALENESS_THRESHOLDS[sectionKey] ?? Infinity;
+    const isStale = isFinite(threshold) && ageInDays > threshold;
+    const trimmedLines = entryLines.filter((l) => l.trim().length > 0);
+    const displayText = trimmedLines.join("\n");
+    entries.push({
+      section: currentSection.replace(/<!--.*?-->/g, "").trim(),
+      text: displayText,
+      addedDate,
+      lineStart: entryStart,
+      lineEnd,
+      ageInDays,
+      threshold,
+      isStale
+    });
+    entryLines = [];
+    entryStart = -1;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const sectionMatch = line.match(SECTION_RE);
+    if (sectionMatch) {
+      const level = sectionMatch[1].length;
+      const title = sectionMatch[2];
+      flushEntry(i);
+      if (level <= 2) {
+        currentSection = title;
+        currentHeadingLevel = level;
+      }
+      continue;
+    }
+    if (line.trim() === "---") {
+      flushEntry(i);
+      continue;
+    }
+    if (line.trim().startsWith("<!--") && line.trim().endsWith("-->")) {
+      if (entryStart < 0) continue;
+    }
+    if (TIMESTAMP_RE.test(line)) {
+      if (entryStart < 0) entryStart = i;
+      entryLines.push(line);
+      flushEntry(i + 1);
+      continue;
+    }
+    if (line.trim().length > 0 && !line.trim().startsWith(">")) {
+      if (entryStart < 0) entryStart = i;
+      entryLines.push(line);
+    } else if (entryStart >= 0) {
+      entryLines.push(line);
+    }
+  }
+  flushEntry(lines.length);
+  return entries;
+}
+function removeLines(content, lineStart, lineEnd) {
+  const lines = content.split("\n");
+  lines.splice(lineStart, lineEnd - lineStart);
+  return lines.join("\n");
+}
+function appendToArchive(content, entryText, pruneDate) {
+  const archiveHeading = "## Archive";
+  const archiveEntry = `${entryText} <!-- archived: ${pruneDate} -->`;
+  if (content.includes(archiveHeading)) {
+    return content.replace(
+      /(## Archive\n(?:<!--[^>]*-->\n)*)/,
+      `$1
+${archiveEntry}
+`
+    );
+  } else {
+    return content.trimEnd() + `
+
+${archiveHeading}
+
+<!-- Entries moved here by mindlink prune \u2014 kept for reference -->
+
+${archiveEntry}
+`;
+  }
+}
+function formatAge(days) {
+  if (days < 30) return `${Math.round(days)} days`;
+  if (days < 365) return `${Math.round(days / 30)} months`;
+  return `${(days / 365).toFixed(1)} years`;
+}
+var pruneCommand = new Command18("prune").description("Review and retire stale MEMORY.md entries interactively").option("--dry-run", "Show stale entries without making any changes").option("--all", "Show all timestamped entries regardless of age").addHelpText("after", `
+Scans MEMORY.md for entries with <!-- added: YYYY-MM-DD --> timestamps.
+Entries older than their section's staleness threshold are flagged for review.
+
+Staleness thresholds:
+  Current Focus   \u2014 14 days
+  Decisions       \u2014 180 days
+  Conventions     \u2014 180 days
+  Architecture    \u2014 365 days
+  User Profile    \u2014 never expires
+
+Archived entries are moved to ## Archive at the bottom of MEMORY.md.
+They are never permanently deleted unless you choose "Delete".
+
+Examples:
+  mindlink prune
+  mindlink prune --dry-run
+  mindlink prune --all
+  `).action(async (opts) => {
+  const projectPath = resolve15(process.cwd());
+  const brainDir = join18(projectPath, BRAIN_DIR);
+  const memoryPath = join18(brainDir, "MEMORY.md");
+  console.log("");
+  console.log(`  ${chalk19.bold("\u25C9 MindLink Prune")}`);
+  console.log(`  ${chalk19.dim(memoryPath)}`);
+  console.log("");
+  if (!existsSync18(memoryPath)) {
+    console.log(`  ${chalk19.red("\u2717")}  MEMORY.md not found. Run ${chalk19.cyan("mindlink init")} first.`);
+    console.log("");
+    process.exit(1);
+  }
+  const allEntries = parseTimestampedEntries(readFileSync16(memoryPath, "utf8"));
+  const toReview = opts.all ? allEntries.filter((e) => e.addedDate !== null) : allEntries.filter((e) => e.isStale);
+  if (toReview.length === 0) {
+    if (allEntries.length === 0) {
+      console.log(`  ${chalk19.dim("No timestamped entries found in MEMORY.md.")}`);
+      console.log(`  ${chalk19.dim("Entries are timestamped when your AI writes them (<!-- added: YYYY-MM-DD -->).")}`);
+    } else {
+      console.log(`  ${chalk19.green("\u2713")}  No stale entries found. ${allEntries.length} entry${allEntries.length !== 1 ? "ies" : "y"} all within threshold.`);
+      console.log(`  ${chalk19.dim("Run mindlink prune --all to review all timestamped entries.")}`);
+    }
+    console.log("");
+    return;
+  }
+  console.log(`  Scanning MEMORY.md for ${opts.all ? "timestamped" : "stale"} entries...`);
+  console.log(`  Found ${toReview.length} entr${toReview.length !== 1 ? "ies" : "y"} to review.`);
+  console.log("");
+  if (opts.dryRun) {
+    for (const entry of toReview) {
+      const age = entry.ageInDays !== null ? formatAge(entry.ageInDays) : "undated";
+      const thresholdStr = isFinite(entry.threshold) ? ` \u2014 threshold: ${entry.threshold} days` : "";
+      console.log(`  ${chalk19.yellow("\u26A0")}  [${entry.section}] ${entry.text.split("\n")[0].slice(0, 80)}`);
+      console.log(`     ${chalk19.dim(`Added: ${entry.addedDate?.toISOString().slice(0, 10) ?? "unknown"} (${age} ago)${thresholdStr}`)}`);
+      console.log("");
+    }
+    console.log(`  ${chalk19.dim("Dry run \u2014 no changes made.")}`);
+    console.log("");
+    return;
+  }
+  const pruneDate = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  let content = readFileSync16(memoryPath, "utf8");
+  let archived = 0;
+  let deleted = 0;
+  let kept = 0;
+  let skippedAll = false;
+  const sorted = [...toReview].sort((a, b) => b.lineStart - a.lineStart);
+  for (const entry of sorted) {
+    if (skippedAll) {
+      kept++;
+      continue;
+    }
+    const age = entry.ageInDays !== null ? formatAge(entry.ageInDays) : "undated";
+    const thresholdStr = isFinite(entry.threshold) ? ` \u2014 threshold: ${entry.threshold} days` : "";
+    const displayLines = entry.text.split("\n").slice(0, 3).join("\n");
+    console.log(`  ${chalk19.bold("\u2500".repeat(55))}`);
+    console.log(`  ${chalk19.bold("Section:")} ${entry.section}`);
+    console.log(`  ${chalk19.bold("Entry:")}`);
+    for (const l of displayLines.split("\n")) console.log(`    ${chalk19.dim(l)}`);
+    console.log(`  ${chalk19.bold("Added:")} ${entry.addedDate?.toISOString().slice(0, 10) ?? "unknown"} (${age} ago)${thresholdStr}`);
+    console.log("");
+    const action = await select6({
+      message: "What would you like to do?",
+      options: [
+        { value: "keep", label: "Keep", hint: "leave as-is" },
+        { value: "archive", label: "Archive", hint: "move to ## Archive section" },
+        { value: "delete", label: "Delete", hint: "remove permanently" },
+        { value: "skip_all", label: "Skip remaining", hint: "keep all remaining entries unchanged" }
+      ]
+    });
+    if (isCancel8(action)) {
+      console.log("");
+      break;
+    }
+    if (action === "skip_all") {
+      skippedAll = true;
+      kept++;
+      continue;
+    }
+    if (action === "archive") {
+      const entryText = content.split("\n").slice(entry.lineStart, entry.lineEnd).join("\n").trim();
+      content = removeLines(content, entry.lineStart, entry.lineEnd);
+      content = appendToArchive(content, entryText, pruneDate);
+      archived++;
+    } else if (action === "delete") {
+      content = removeLines(content, entry.lineStart, entry.lineEnd);
+      deleted++;
+    } else {
+      kept++;
+    }
+    console.log("");
+  }
+  if (archived > 0 || deleted > 0) {
+    writeFileSync9(memoryPath, content);
+  }
+  console.log(`  ${chalk19.bold("\u2500".repeat(55))}`);
+  if (archived > 0) console.log(`  ${chalk19.green("\u2713")}  ${archived} entry${archived !== 1 ? "ies" : ""} archived`);
+  if (deleted > 0) console.log(`  ${chalk19.green("\u2713")}  ${deleted} entry${deleted !== 1 ? "ies" : ""} deleted`);
+  if (kept > 0) console.log(`  ${chalk19.dim("\xB7")}  ${kept} entry${kept !== 1 ? "ies" : ""} kept`);
+  if (archived > 0 || deleted > 0) {
+    console.log(`  ${chalk19.green("\u2713")}  MEMORY.md updated.`);
+  }
+  console.log("");
+});
+
+// src/commands/mcp.ts
+import { Command as Command19 } from "commander";
+import { existsSync as existsSync19, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "fs";
+import { join as join19, resolve as resolve16, dirname as dirname6 } from "path";
+function resolveProjectPath() {
+  const envPath = process.env.MINDLINK_PROJECT_PATH;
+  if (envPath && existsSync19(join19(envPath, BRAIN_DIR))) return envPath;
+  let current = resolve16(process.cwd());
+  for (let i = 0; i < 10; i++) {
+    if (existsSync19(join19(current, BRAIN_DIR))) return current;
+    const parent = dirname6(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function readMemorySection(memoryPath, section) {
+  const content = readFileSync17(memoryPath, "utf8");
+  if (!section) {
+    const core = extractSection(content, "Core");
+    const profile = extractSection(content, "User Profile");
+    return `## Core
+
+${core}
+
+## User Profile
+
+${profile}`.trim();
+  }
+  return extractSection(content, section);
+}
+function appendToSection(memoryPath, section, newContent) {
+  let content = readFileSync17(memoryPath, "utf8");
+  const sectionBody = extractSection(content, section);
+  const lines = content.split("\n");
+  let headingIdx = -1;
+  let nextSectionIdx = lines.length;
+  let headingLevel = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(/^(#{1,6})\s+(.+)/);
+    if (match) {
+      const level = match[1].length;
+      const title = match[2].replace(/<!--.*?-->/g, "").trim();
+      if (headingIdx < 0 && title.toLowerCase() === section.toLowerCase()) {
+        headingIdx = i;
+        headingLevel = level;
+      } else if (headingIdx >= 0 && level <= headingLevel) {
+        nextSectionIdx = i;
+        break;
+      }
+    }
+  }
+  if (headingIdx < 0) {
+    content = content.trimEnd() + `
+
+## ${section}
+
+${newContent.trim()}
+`;
+  } else {
+    const insertAt = nextSectionIdx > 0 && lines[nextSectionIdx - 1].trim() === "---" ? nextSectionIdx - 1 : nextSectionIdx;
+    lines.splice(insertAt, 0, "", newContent.trim(), "");
+    content = lines.join("\n");
+  }
+  writeFileSync10(memoryPath, content);
+  void sectionBody;
+}
+var mcpCommand = new Command19("mcp").description("Start the MindLink MCP server (stdio transport for AI tool integration)").addHelpText("after", `
+The MCP server runs as a local process launched by Claude Code.
+It exposes 4 tools for auditable, schema-validated memory reads and writes.
+
+Tools:
+  mindlink_read_memory(section?)   \u2014 read a section of MEMORY.md
+  mindlink_write_memory(section, content) \u2014 append to a MEMORY.md section
+  mindlink_session_update(summary) \u2014 overwrite SESSION.md
+  mindlink_verify()                \u2014 run health check, return JSON
+
+Configure in .claude/settings.json (done automatically by mindlink init):
+  { "mcpServers": { "mindlink": { "command": "mindlink", "args": ["mcp"] } } }
+
+Examples:
+  mindlink mcp    # (launched by Claude Code, not by hand)
+  `).action(async () => {
+  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const { z } = await import("./zod-FDOV7Y2P.js");
+  const server = new McpServer({ name: "mindlink", version: VERSION });
+  server.tool(
+    "mindlink_read_memory",
+    "Read a section of this project's MEMORY.md. If section is omitted, returns Core + User Profile only.",
+    {
+      section: z.enum(["Core", "Architecture", "Decisions", "Conventions", "User Profile", "Important Context"]).optional().describe("Section to read. Omit for Core + User Profile (recommended default).")
+    },
+    async ({ section }) => {
+      const projectPath = resolveProjectPath();
+      if (!projectPath) {
+        return {
+          content: [{ type: "text", text: "Error: No MindLink project found at this path. Run mindlink init first." }],
+          isError: true
+        };
+      }
+      const memoryPath = join19(projectPath, BRAIN_DIR, "MEMORY.md");
+      if (!existsSync19(memoryPath)) {
+        return {
+          content: [{ type: "text", text: "Error: MEMORY.md not found. Run mindlink init to create it." }],
+          isError: true
+        };
+      }
+      try {
+        const content = readMemorySection(memoryPath, section);
+        return { content: [{ type: "text", text: content || "(section is empty)" }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error reading MEMORY.md: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "mindlink_write_memory",
+    "Append a fact or decision to a section of MEMORY.md. Never overwrites existing content. Always include a <!-- added: YYYY-MM-DD --> timestamp.",
+    {
+      section: z.enum(["Core", "Architecture", "Decisions", "Conventions", "User Profile", "Important Context"]).describe("Section to append to."),
+      content: z.string().describe("The markdown content to append. Include <!-- added: YYYY-MM-DD --> timestamp.")
+    },
+    async ({ section, content }) => {
+      const projectPath = resolveProjectPath();
+      if (!projectPath) {
+        return {
+          content: [{ type: "text", text: "Error: No MindLink project found. Run mindlink init first." }],
+          isError: true
+        };
+      }
+      const memoryPath = join19(projectPath, BRAIN_DIR, "MEMORY.md");
+      if (!existsSync19(memoryPath)) {
+        return {
+          content: [{ type: "text", text: "Error: MEMORY.md not found. Run mindlink init to create it." }],
+          isError: true
+        };
+      }
+      try {
+        appendToSection(memoryPath, section, content);
+        return { content: [{ type: "text", text: `\u2713 Appended to ## ${section} in MEMORY.md.` }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error writing MEMORY.md: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "mindlink_session_update",
+    "Update SESSION.md with the current session summary. Call this as the last action of every response.",
+    {
+      summary: z.string().describe("Current task state \u2014 what was asked, what you answered, any decisions made, what's next.")
+    },
+    async ({ summary }) => {
+      const projectPath = resolveProjectPath();
+      if (!projectPath) {
+        return {
+          content: [{ type: "text", text: "Error: No MindLink project found. Run mindlink init first." }],
+          isError: true
+        };
+      }
+      const sessionPath = join19(projectPath, BRAIN_DIR, "SESSION.md");
+      try {
+        const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        const content = `# Session State
+
+<!-- Last updated: ${date} -->
+
+${summary.trim()}
+`;
+        writeFileSync10(sessionPath, content);
+        return { content: [{ type: "text", text: "\u2713 SESSION.md updated." }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error writing SESSION.md: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "mindlink_verify",
+    "Run a health check on .brain/. Returns pass/warn/fail status for each check. Call this to verify your memory writes succeeded.",
+    {},
+    async () => {
+      const projectPath = resolveProjectPath();
+      if (!projectPath) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ ok: false, error: "No MindLink project found. Run mindlink init first." }) }],
+          isError: true
+        };
+      }
+      const checks = runChecks(projectPath);
+      const ok2 = checks.every((c) => c.status === "pass");
+      return {
+        content: [{ type: "text", text: JSON.stringify({ ok: ok2, checks }, null, 2) }]
+      };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+});
+
 // src/cli.ts
-var program = new Command16();
+var program = new Command20();
 program.name("mindlink").description("Give your AI a brain.").version(VERSION, "-v, --version");
 program.addCommand(initCommand);
 program.addCommand(statusCommand);
@@ -2256,9 +3337,13 @@ program.addCommand(importCommand);
 program.addCommand(doctorCommand);
 program.addCommand(versionCommand);
 program.addCommand(diffCommand);
+program.addCommand(verifyCommand);
+program.addCommand(profileCommand);
+program.addCommand(pruneCommand);
+program.addCommand(mcpCommand);
 program.on("command:*", (operands) => {
   const unknown = operands[0];
-  const known = ["init", "status", "log", "clear", "reset", "config", "sync", "update", "summary", "uninstall", "export", "import", "doctor", "version", "diff"];
+  const known = ["init", "status", "log", "clear", "reset", "config", "sync", "update", "summary", "uninstall", "export", "import", "doctor", "version", "diff", "verify", "profile", "prune", "mcp"];
   function levenshtein(a, b) {
     const m = a.length, n = b.length;
     const dp = Array.from(
@@ -2274,11 +3359,11 @@ program.on("command:*", (operands) => {
   }
   const closest = known.map((cmd) => ({ cmd, dist: levenshtein(unknown, cmd) })).sort((a, b) => a.dist - b.dist)[0];
   console.log("");
-  console.log(`  ${chalk17.red("\u2717")}  Unknown command: ${chalk17.bold(unknown)}`);
+  console.log(`  ${chalk20.red("\u2717")}  Unknown command: ${chalk20.bold(unknown)}`);
   if (closest && closest.dist <= 3) {
-    console.log(`     Did you mean ${chalk17.cyan("mindlink " + closest.cmd)}?`);
+    console.log(`     Did you mean ${chalk20.cyan("mindlink " + closest.cmd)}?`);
   }
-  console.log(`     Run ${chalk17.cyan("mindlink --help")} to see all commands.`);
+  console.log(`     Run ${chalk20.cyan("mindlink --help")} to see all commands.`);
   console.log("");
   process.exit(1);
 });