mindlink 1.1.5 → 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 Command15 } from "commander";
-import chalk16 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";
@@ -24,13 +25,16 @@ import {
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync2,
   writeFileSync as writeFileSync2,
-  appendFileSync
+  appendFileSync,
+  readdirSync
 } from "fs";
+import { execSync } from "child_process";
 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");
@@ -38,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";
@@ -58,14 +65,18 @@ var AGENTS = [
   { value: "copilot", label: "GitHub Copilot", hint: ".github/copilot-instructions.md", templateFile: "copilot-instructions.md", destFile: ".github/copilot-instructions.md", selected: true },
   { value: "windsurf", label: "Windsurf", hint: ".windsurfrules", templateFile: ".windsurfrules", destFile: ".windsurfrules", selected: true },
   { value: "cline", label: "Cline", hint: ".clinerules", templateFile: ".clinerules", destFile: ".clinerules", selected: false },
-  { value: "aider", label: "Aider", hint: "CONVENTIONS.md", templateFile: "CONVENTIONS.md", destFile: "CONVENTIONS.md", selected: false }
+  { value: "aider", label: "Aider", hint: "CONVENTIONS.md", templateFile: "CONVENTIONS.md", destFile: "CONVENTIONS.md", selected: false },
+  { value: "zed", label: "Zed", hint: ".rules", templateFile: ".rules", destFile: ".rules", selected: false },
+  { value: "kiro", label: "Kiro", hint: ".kiro/steering/mindlink.md", templateFile: "kiro-steering.md", destFile: ".kiro/steering/mindlink.md", selected: false },
+  { value: "continue", label: "Continue.dev", hint: ".continue/rules/mindlink.md", templateFile: "continue-rules.md", destFile: ".continue/rules/mindlink.md", selected: false },
+  { value: "trae", label: "Trae", hint: ".trae/rules/mindlink.md", templateFile: "trae-rules.md", destFile: ".trae/rules/mindlink.md", selected: false }
 ];
 
 // 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 {
@@ -94,19 +105,86 @@ 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" });
   let name = basename(projectPath);
   let description = "";
   let stack = "";
+  let recentActivity = "";
+  let topDirs = "";
   const pkgPath = join3(projectPath, "package.json");
   if (existsSync2(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
       if (pkg.name) name = pkg.name;
       if (pkg.description) description = pkg.description;
-      stack = "Node.js";
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const layers = ["Node.js"];
+      if (deps["typescript"] || deps["ts-node"] || deps["tsup"]) layers.push("TypeScript");
+      if (deps["react"] || deps["next"]) layers.push(deps["next"] ? "Next.js" : "React");
+      if (deps["express"] || deps["fastify"] || deps["koa"]) layers.push("Express/Fastify");
+      if (deps["vite"]) layers.push("Vite");
+      stack = layers.join(" + ");
     } catch {
     }
   }
@@ -119,7 +197,83 @@ function detectProjectInfo(projectPath) {
     else if (existsSync2(join3(projectPath, "composer.json"))) stack = "PHP";
     else if (existsSync2(join3(projectPath, "Gemfile"))) stack = "Ruby";
   }
-  return { name, description, stack, date };
+  if (!description) {
+    const readmePath = join3(projectPath, "README.md");
+    if (existsSync2(readmePath)) {
+      try {
+        const lines = readFileSync2(readmePath, "utf8").split("\n");
+        for (const line of lines.slice(0, 30)) {
+          const trimmed = line.trim();
+          if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("!") && !trimmed.startsWith("<") && trimmed.length > 10) {
+            description = trimmed.replace(/\*\*/g, "").slice(0, 120);
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    const log = execSync("git log --oneline -5", { cwd: projectPath, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (log) {
+      recentActivity = log.split("\n").slice(0, 3).join(" \xB7 ");
+    }
+  } catch {
+  }
+  const SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".brain", "binaries", ".cache", "coverage", ".next", "out"]);
+  try {
+    const entries = readdirSync(projectPath, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory() && !SKIP_DIRS.has(e.name) && !e.name.startsWith(".")).map((e) => e.name).slice(0, 6);
+    if (dirs.length > 0) topDirs = dirs.join(", ");
+  } catch {
+  }
+  return { name, description, stack, recentActivity, topDirs, date };
+}
+function memoryHasRealContent(memoryPath) {
+  try {
+    const lines = readFileSync2(memoryPath, "utf8").split("\n");
+    return lines.some((line) => {
+      const t = line.trim();
+      return t.length > 0 && !t.startsWith("#") && !t.startsWith("<!--") && !t.startsWith(">") && !t.startsWith("|") && t !== "---";
+    });
+  } catch {
+    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;
@@ -138,10 +292,15 @@ ${info2.stack}
 <!-- Add layers: Frontend, Backend, Infra, etc. -->`
     );
   }
+  const focusLines = [];
+  if (info2.topDirs) focusLines.push(`Directories: ${info2.topDirs}`);
+  if (info2.recentActivity) focusLines.push(`Recent commits: ${info2.recentActivity}`);
+  const focusBlock = focusLines.length > 0 ? focusLines.join("\n") + `
+<!-- Initialized ${info2.date} \u2014 update to reflect the current active focus -->` : `<!-- Initialized ${info2.date} \u2014 ask your AI to fill this in after your first session -->`;
   content = content.replace(
     /### Current focus\n<!--[^]*?-->/,
     `### Current focus
-<!-- Initialized ${info2.date} \u2014 ask your AI to fill this in after your first session -->`
+${focusBlock}`
   );
   return content;
 }
@@ -161,41 +320,159 @@ Examples:
   const brainDir = join3(projectPath, BRAIN_DIR);
   printBanner();
   if (existsSync2(brainDir)) {
-    if (opts.yes) {
+    const memoryPath = join3(brainDir, "MEMORY.md");
+    const hasMemory = existsSync2(memoryPath) && memoryHasRealContent(memoryPath);
+    if (!opts.yes && hasMemory) {
+      const hasAnyAgentFile = AGENTS.some((a) => existsSync2(join3(projectPath, a.destFile)));
+      if (!hasAnyAgentFile) {
+        console.log("");
+        console.log(`  ${chalk2.cyan("\u25C9")}  MindLink memory found in this project.`);
+        console.log(`     ${chalk2.dim("MEMORY.md has content \u2014 this looks like a team project.")}`);
+        console.log("");
+        const action = await select({
+          message: "What would you like to do?",
+          options: [
+            { value: "restore", label: "Set up agent files", hint: "recommended for new team members \u2014 writes CLAUDE.md, .cursorrules, etc." },
+            { value: "reinit", label: "Full re-init", hint: "recreate everything, reconfigure settings" },
+            { value: "exit", label: "Cancel", hint: "" }
+          ]
+        });
+        if (isCancel(action) || action === "exit") {
+          process.exit(0);
+        }
+        if (action === "restore") {
+          const agentChoices = AGENTS.map((a) => ({
+            value: a.value,
+            label: `${a.label.padEnd(18)} ${chalk2.dim(a.hint)}`,
+            hint: a.selected ? "recommended" : void 0
+          }));
+          const agentResult = await multiselect({
+            message: "Which AI agents do you use?",
+            options: agentChoices,
+            initialValues: AGENTS.filter((a) => a.selected).map((a) => a.value),
+            required: false
+          });
+          if (isCancel(agentResult)) {
+            cancel("Cancelled.");
+            process.exit(0);
+          }
+          const toRestore = agentResult;
+          const restored = [];
+          for (const agentValue of toRestore) {
+            const agent = AGENTS.find((a) => a.value === agentValue);
+            if (!agent) continue;
+            const destPath = join3(projectPath, agent.destFile);
+            mkdirSync2(dirname2(destPath), { recursive: true });
+            writeFileSync2(destPath, readFileSync2(join3(AGENT_TEMPLATES_DIR, agent.templateFile), "utf8"));
+            restored.push(agent.destFile);
+          }
+          if (toRestore.includes("claude")) {
+            const hookDest = join3(projectPath, ".claude", "settings.json");
+            if (!existsSync2(hookDest)) {
+              mkdirSync2(dirname2(hookDest), { recursive: true });
+              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");
+            }
+          }
+          const configPath = join3(brainDir, "config.json");
+          if (!existsSync2(configPath)) {
+            const config = {
+              gitTracking: true,
+              autoSync: true,
+              agents: toRestore,
+              maxLogEntries: DEFAULT_MAX_LOG_ENTRIES
+            };
+            writeFileSync2(configPath, JSON.stringify(config, null, 2));
+            restored.push(".brain/config.json");
+          }
+          try {
+            registerProject(projectPath);
+          } catch {
+          }
+          console.log("");
+          for (const f of restored) console.log(`  ${chalk2.green("\u2713")}  ${f}`);
+          console.log("");
+          console.log(`  ${chalk2.green("\u2713")}  Agent files ready. Start a new session \u2014 your AI is already briefed.`);
+          console.log("");
+          process.exit(0);
+        }
+      } else {
+        if (opts.yes) {
+          console.log(`  ${chalk2.red("\u2717")}  Already initialized at this path.`);
+          console.log(`     Run ${chalk2.cyan("mindlink config")} to change settings.`);
+          console.log("");
+          process.exit(1);
+        }
+        const action = await select({
+          message: ".brain/ already exists at this path. What would you like to do?",
+          options: [
+            { value: "config", label: "Change settings", hint: "mindlink config" },
+            { value: "status", label: "View current status", hint: "mindlink status" },
+            { value: "exit", label: "Nothing \u2014 exit", hint: "" }
+          ]
+        });
+        if (isCancel(action) || action === "exit") {
+          process.exit(0);
+        }
+        if (action === "status") {
+          try {
+            execSync("mindlink status", { cwd: projectPath, stdio: "inherit" });
+          } catch {
+          }
+        }
+        if (action === "config") {
+          console.log(`  Run ${chalk2.cyan("mindlink config")} to change settings.`);
+        }
+        console.log("");
+        process.exit(0);
+      }
+    } else if (opts.yes) {
       console.log(`  ${chalk2.red("\u2717")}  Already initialized at this path.`);
       console.log(`     Run ${chalk2.cyan("mindlink config")} to change settings.`);
       console.log("");
       process.exit(1);
-    }
-    const action = await select({
-      message: ".brain/ already exists at this path. What would you like to do?",
-      options: [
-        { value: "config", label: "Change settings", hint: "mindlink config" },
-        { value: "status", label: "View current status", hint: "mindlink status" },
-        { value: "exit", label: "Nothing \u2014 exit", hint: "" }
-      ]
-    });
-    if (isCancel(action) || action === "exit") {
-      process.exit(0);
-    }
-    if (action === "status") {
-      const { execSync: execSync2 } = await import("child_process");
-      try {
-        execSync2("mindlink status", { stdio: "inherit" });
-      } catch {
+    } else if (!hasMemory) {
+    } else {
+      const action = await select({
+        message: ".brain/ already exists at this path. What would you like to do?",
+        options: [
+          { value: "config", label: "Change settings", hint: "mindlink config" },
+          { value: "status", label: "View current status", hint: "mindlink status" },
+          { value: "exit", label: "Nothing \u2014 exit", hint: "" }
+        ]
+      });
+      if (isCancel(action) || action === "exit") {
+        process.exit(0);
       }
+      if (action === "status") {
+        try {
+          execSync("mindlink status", { cwd: projectPath, stdio: "inherit" });
+        } catch {
+        }
+      }
+      if (action === "config") {
+        console.log(`  Run ${chalk2.cyan("mindlink config")} to change settings.`);
+      }
+      console.log("");
+      process.exit(0);
     }
-    if (action === "config") {
-      console.log(`  Run ${chalk2.cyan("mindlink config")} to change settings.`);
-    }
-    console.log("");
-    process.exit(0);
   }
   intro(chalk2.bold("Initializing memory for this project:"));
   console.log(`  ${chalk2.dim(projectPath)}`);
   console.log(`  ${chalk2.dim("This creates a .brain/ folder scoped to this project only.")}`);
   console.log(`  ${chalk2.dim("Run mindlink init once per project \u2014 never needs to be run again.")}`);
   console.log("");
+  if (process.platform === "win32") {
+    console.log(`  ${chalk2.yellow("\u26A0")}  ${chalk2.bold("Windows detected")}`);
+    console.log(`     Claude Code hooks use bash and won't run on Windows.`);
+    console.log(`     Memory enforcement (Stop hook, session timestamps) will be disabled.`);
+    console.log(`     All other features work normally.`);
+    console.log("");
+  }
   let selectedAgents;
   if (opts.yes) {
     selectedAgents = AGENTS.filter((a) => a.selected).map((a) => a.value);
@@ -278,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;
@@ -290,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) {
@@ -324,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.
 
@@ -511,7 +870,7 @@ Examples:
 // src/commands/log.ts
 import { Command as Command3 } from "commander";
 import chalk4 from "chalk";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2 } from "fs";
 import { join as join5, resolve as resolve3 } from "path";
 var logCommand = new Command3("log").description("Print session history").option("--all", "Show full history").option("--limit <n>", "Show last N sessions", "10").option("--since <date>", "Show sessions from a date (matched against heading text)").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
@@ -568,7 +927,7 @@ Examples:
     }
     console.log("");
   }
-  const archiveFiles = readdirSync(brainDir).filter((f) => /^LOG-\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
+  const archiveFiles = readdirSync2(brainDir).filter((f) => /^LOG-\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
   if (archiveFiles.length > 0) {
     console.log(`  ${chalk4.dim("\u2500".repeat(44))}`);
     console.log(`  ${chalk4.dim("Like all human brains, MindLink forgets old sessions")}`);
@@ -1019,13 +1378,14 @@ Examples:
 import { Command as Command8 } from "commander";
 import { select as select3, isCancel as isCancel4, cancel as cancel4, spinner as spinner2 } from "@clack/prompts";
 import chalk9 from "chalk";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import { join as join10, dirname as dirname4 } from "path";
 import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync4 } from "fs";
+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((resolve13) => {
+    return new Promise((resolve17) => {
       const req = https.get(
         "https://registry.npmjs.org/mindlink/latest",
         { headers: { "User-Agent": "mindlink-cli" } },
@@ -1037,17 +1397,17 @@ async function latestVersion() {
           res.on("end", () => {
             try {
               const parsed = JSON.parse(data);
-              resolve13(parsed.version ?? null);
+              resolve17(parsed.version ?? null);
             } catch {
-              resolve13(null);
+              resolve17(null);
             }
           });
         }
       );
-      req.on("error", () => resolve13(null));
+      req.on("error", () => resolve17(null));
       req.setTimeout(8e3, () => {
         req.destroy();
-        resolve13(null);
+        resolve17(null);
       });
     });
   } catch {
@@ -1068,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 {
-      execSync(`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();
@@ -1153,6 +1515,19 @@ Examples:
       }
       const agentValues = config.agents ?? AGENTS.filter((a) => a.selected).map((a) => a.value);
       const refreshed = [];
+      for (const brainFile of REQUIRED_BRAIN_FILES) {
+        const dest = join10(projectPath, BRAIN_DIR, brainFile);
+        if (!existsSync9(dest)) {
+          try {
+            const template = join10(BRAIN_TEMPLATES_DIR, brainFile);
+            if (existsSync9(template)) {
+              writeFileSync6(dest, readFileSync9(template, "utf8"));
+              refreshed.push(`.brain/${brainFile}`);
+            }
+          } catch {
+          }
+        }
+      }
       for (const agentValue of agentValues) {
         const agent = AGENTS.find((a) => a.value === agentValue);
         if (!agent) continue;
@@ -1168,17 +1543,142 @@ 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 {
-          const content = readFileSync9(memoryPath, "utf8");
-          if (!content.includes("## User Profile") && content.includes("## Important Context")) {
-            const userProfileBlock = `## User Profile  <!-- READ EVERY SESSION \u2014 personal facts about the user -->
+          let content = readFileSync9(memoryPath, "utf8");
+          let memoryChanged = false;
+          const migrations = [
+            {
+              // v1.1.5: Add ## User Profile section
+              marker: "## User Profile",
+              block: `## User Profile  <!-- READ EVERY SESSION \u2014 personal facts about the user -->
 
 <!-- Job, company, level, years of experience, immigration status -->
 <!-- Age, health, physical details -->
@@ -1190,13 +1690,45 @@ Examples:
 
 ---
 
-`;
-            writeFileSync6(memoryPath, content.replace("## Important Context", userProfileBlock + "## Important Context"));
+`,
+              before: "## Important Context"
+            }
+            // Future migrations go here — same pattern:
+            // { marker: '## New Section', block: '## New Section\n\n<!-- ... -->\n\n\n---\n\n', before: '## Some Existing Section' },
+          ];
+          for (const m of migrations) {
+            if (!content.includes(m.marker) && content.includes(m.before)) {
+              content = content.replace(m.before, m.block + m.before);
+              memoryChanged = true;
+            }
+          }
+          if (memoryChanged) {
+            writeFileSync6(memoryPath, content);
             refreshed.push(".brain/MEMORY.md");
           }
         } 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}`);
@@ -1206,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
@@ -1438,7 +1971,7 @@ Examples:
 import { Command as Command11 } from "commander";
 import { text as text2, isCancel as isCancel6, cancel as cancel6 } from "@clack/prompts";
 import chalk12 from "chalk";
-import { existsSync as existsSync12, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync3 } from "fs";
 import { join as join13, resolve as resolve10, basename as basename3 } from "path";
 import AdmZip from "adm-zip";
 var exportCommand = new Command11("export").description("Export .brain/ memory to a shareable zip file").option("--output <path>", "Directory or full path to save the zip file").option("--include-agents", "Also include agent instruction files (CLAUDE.md, CURSOR.md, etc.)").addHelpText("after", `
@@ -1485,8 +2018,7 @@ Examples:
     const answer = await text2({
       message: "Where should the zip be saved?",
       placeholder: projectPath,
-      initialValue: projectPath,
-      hint: `default filename: ${defaultFilename}`
+      initialValue: projectPath
     });
     if (isCancel6(answer)) {
       cancel6("Cancelled.");
@@ -1514,7 +2046,7 @@ Examples:
       skipped.push(`.brain/${file}`);
     }
   }
-  const archiveFiles = readdirSync2(brainDir).filter((f) => /^LOG-\d{4}-\d{2}-\d{2}\.md$/.test(f));
+  const archiveFiles = readdirSync3(brainDir).filter((f) => /^LOG-\d{4}-\d{2}-\d{2}\.md$/.test(f));
   for (const file of archiveFiles) {
     zip.addLocalFile(join13(brainDir, file), ".brain");
     included.push(`.brain/${file}`);
@@ -1661,7 +2193,7 @@ Examples:
 // src/commands/doctor.ts
 import { Command as Command13 } from "commander";
 import chalk14 from "chalk";
-import { existsSync as existsSync14, readFileSync as readFileSync12, statSync as statSync3, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync12, statSync as statSync3, readdirSync as readdirSync4 } from "fs";
 import { join as join15, resolve as resolve12 } from "path";
 var CORE_LINE_LIMIT = 50;
 var CORE_WARN_THRESHOLD = 40;
@@ -1793,7 +2325,7 @@ Examples:
         checks.push(ok(`LOG.md \u2014 ${entryCount} sessions logged (last: ${newestHeading}, going back to: ${oldestHeading})`));
       }
     }
-    const archives = readdirSync3(brainDir).filter((f) => /^LOG-\d{4}-\d{2}\.md$/.test(f));
+    const archives = readdirSync4(brainDir).filter((f) => /^LOG-\d{4}-\d{2}\.md$/.test(f));
     if (archives.length > 0) {
       checks.push(info(`${archives.length} archive file${archives.length !== 1 ? "s" : ""} \u2014 old sessions are stored in LOG-*.md, not gone`));
     }
@@ -1876,8 +2408,919 @@ var versionCommand = new Command14("version").description("Show the current Mind
   console.log("");
 });
 
+// src/commands/diff.ts
+import { Command as Command15 } from "commander";
+import chalk16 from "chalk";
+import { existsSync as existsSync15, readFileSync as readFileSync13, statSync as statSync4 } from "fs";
+import { join as join16, resolve as resolve13 } from "path";
+import { execSync as execSync3 } from "child_process";
+var BRAIN_FILES3 = ["MEMORY.md", "SESSION.md", "LOG.md", "SHARED.md"];
+function relativeTime2(ms) {
+  const secs = Math.floor(ms / 1e3);
+  if (secs < 60) return `${secs}s ago`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+function getGitDiff(filePath, since) {
+  try {
+    const dir = resolve13(filePath, "..");
+    execSync3("git rev-parse --is-inside-work-tree", { cwd: dir, stdio: "pipe" });
+    const ref = since || "HEAD~1";
+    const diff = execSync3(`git diff ${ref} -- "${filePath}"`, {
+      cwd: dir,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return diff || null;
+  } catch {
+    return null;
+  }
+}
+function parseDiffSummary(diff) {
+  const added = [];
+  const removed = [];
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      const t = line.slice(1).trim();
+      if (t && !t.startsWith("<!--") && !t.startsWith("#") && t !== "---") added.push(t);
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      const t = line.slice(1).trim();
+      if (t && !t.startsWith("<!--") && !t.startsWith("#") && t !== "---") removed.push(t);
+    }
+  }
+  return { added, removed };
+}
+var diffCommand = new Command15("diff").description("Show what changed in .brain/ since last session").option("--since <ref>", "Git ref or date to diff against (default: last mindlink clear or HEAD~1)").option("--json", "Output as JSON").addHelpText("after", `
+What it does:
+  Shows what changed in each .brain/ file since your last session.
+  Uses git diff when .brain/ is tracked; falls back to file modification times.
+
+Examples:
+  mindlink diff
+  mindlink diff --since HEAD~3
+  mindlink diff --since "2026-04-10"
+  `).action((opts) => {
+  const projectPath = resolve13(process.cwd());
+  const brainDir = join16(projectPath, BRAIN_DIR);
+  if (!existsSync15(brainDir)) {
+    console.log("");
+    console.log(`  ${chalk16.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk16.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  const results = {};
+  const sessionTsPath = join16(brainDir, ".session_ts");
+  const sessionTs = existsSync15(sessionTsPath) ? parseInt(readFileSync13(sessionTsPath, "utf8").trim(), 10) * 1e3 : null;
+  const now = Date.now();
+  const isGitTracked = (() => {
+    try {
+      execSync3("git rev-parse --is-inside-work-tree", { cwd: projectPath, stdio: "pipe" });
+      const tracked = execSync3("git ls-files --error-unmatch .brain/MEMORY.md", {
+        cwd: projectPath,
+        stdio: "pipe"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  for (const file of BRAIN_FILES3) {
+    const filePath = join16(brainDir, file);
+    if (!existsSync15(filePath)) {
+      results[file] = { exists: false };
+      continue;
+    }
+    const stat = statSync4(filePath);
+    const mtime = stat.mtimeMs;
+    const content = readFileSync13(filePath, "utf8");
+    const sizeLines = content.split("\n").length;
+    let diff = null;
+    let added = [];
+    let removed = [];
+    if (isGitTracked) {
+      diff = getGitDiff(filePath, opts.since);
+      if (diff) {
+        const summary = parseDiffSummary(diff);
+        added = summary.added.slice(0, 5);
+        removed = summary.removed.slice(0, 5);
+      }
+    }
+    results[file] = { exists: true, mtime, diff, added, removed, sizeLines };
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  console.log("");
+  console.log(`  ${chalk16.bold(".brain/ changes")}`);
+  if (sessionTs) {
+    console.log(`  ${chalk16.dim(`Session started ${relativeTime2(now - sessionTs)}`)}`);
+  }
+  if (isGitTracked) {
+    const sinceRef = opts.since || "HEAD~1";
+    console.log(`  ${chalk16.dim(`Git diff against: ${sinceRef}`)}`);
+  } else {
+    console.log(`  ${chalk16.dim(".brain/ is not git-tracked \u2014 showing modification times only")}`);
+  }
+  console.log("");
+  for (const file of BRAIN_FILES3) {
+    const r = results[file];
+    if (!r.exists) {
+      console.log(`  ${chalk16.dim("\u2014")}  ${file}  ${chalk16.dim("(not found)")}`);
+      continue;
+    }
+    const age = r.mtime ? relativeTime2(now - r.mtime) : "";
+    const changedThisSession = sessionTs && r.mtime ? r.mtime > sessionTs : false;
+    const indicator = changedThisSession ? chalk16.green("\u25CF") : chalk16.dim("\u25CB");
+    const label = changedThisSession ? chalk16.green(file) : chalk16.dim(file);
+    console.log(`  ${indicator}  ${label}  ${chalk16.dim(`${r.sizeLines} lines \xB7 modified ${age}`)}`);
+    if (isGitTracked && r.diff) {
+      for (const line of (r.added ?? []).slice(0, 3)) {
+        console.log(`       ${chalk16.green("+")} ${line.length > 80 ? line.slice(0, 80) + "\u2026" : line}`);
+      }
+      for (const line of (r.removed ?? []).slice(0, 3)) {
+        console.log(`       ${chalk16.red("-")} ${line.length > 80 ? line.slice(0, 80) + "\u2026" : line}`);
+      }
+    } else if (!isGitTracked && changedThisSession) {
+      console.log(`       ${chalk16.dim("(content diff unavailable \u2014 commit .brain/ to git for line-level diff)")}`);
+    } else if (isGitTracked && !r.diff) {
+      console.log(`       ${chalk16.dim("no changes since last commit")}`);
+    }
+  }
+  console.log("");
+  const changedCount = BRAIN_FILES3.filter((f) => {
+    const r = results[f];
+    return r.exists && sessionTs && r.mtime && r.mtime > sessionTs;
+  }).length;
+  if (changedCount === 0) {
+    console.log(`  ${chalk16.dim("No .brain/ files were modified this session.")}`);
+    if (sessionTs) {
+      console.log(`  ${chalk16.dim("If the session just started, this is expected.")}`);
+    }
+  } else {
+    console.log(`  ${chalk16.green("\u2713")}  ${changedCount} file${changedCount !== 1 ? "s" : ""} updated this session.`);
+  }
+  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 Command15();
+var program = new Command20();
 program.name("mindlink").description("Give your AI a brain.").version(VERSION, "-v, --version");
 program.addCommand(initCommand);
 program.addCommand(statusCommand);
@@ -1893,9 +3336,14 @@ program.addCommand(exportCommand);
 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"];
+  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(
@@ -1911,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(`  ${chalk16.red("\u2717")}  Unknown command: ${chalk16.bold(unknown)}`);
+  console.log(`  ${chalk20.red("\u2717")}  Unknown command: ${chalk20.bold(unknown)}`);
   if (closest && closest.dist <= 3) {
-    console.log(`     Did you mean ${chalk16.cyan("mindlink " + closest.cmd)}?`);
+    console.log(`     Did you mean ${chalk20.cyan("mindlink " + closest.cmd)}?`);
   }
-  console.log(`     Run ${chalk16.cyan("mindlink --help")} to see all commands.`);
+  console.log(`     Run ${chalk20.cyan("mindlink --help")} to see all commands.`);
   console.log("");
   process.exit(1);
 });