mindlink 1.0.0

package/dist/cli.js

@@ -0,0 +1,1811 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command14 } from "commander";
+import chalk15 from "chalk";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import {
+  intro,
+  multiselect,
+  select,
+  spinner,
+  note,
+  cancel,
+  isCancel
+} from "@clack/prompts";
+import chalk2 from "chalk";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  appendFileSync
+} from "fs";
+import { join as join2, resolve, dirname as dirname2, basename } from "path";
+
+// src/utils/paths.ts
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var TEMPLATES_DIR = join(__dirname, "templates");
+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";
+
+// src/utils/banner.ts
+import chalk from "chalk";
+function printBanner() {
+  console.log("");
+  console.log(chalk.dim("  \u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B"));
+  console.log(`    ${chalk.cyan("\u25C9")}  ${chalk.bold("M I N D L I N K")}`);
+  console.log(chalk.dim("  \u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B\u224B"));
+  console.log("");
+}
+
+// src/utils/agents.ts
+var AGENTS = [
+  { value: "claude", label: "Claude Code", hint: "CLAUDE.md", templateFile: "CLAUDE.md", destFile: "CLAUDE.md", selected: true },
+  { value: "cursor", label: "Cursor", hint: "CURSOR.md", templateFile: "CURSOR.md", destFile: "CURSOR.md", selected: true },
+  { value: "codex", label: "Codex / OpenAI", hint: "AGENTS.md", templateFile: "AGENTS.md", destFile: "AGENTS.md", selected: true },
+  { value: "gemini", label: "Gemini CLI", hint: "GEMINI.md", templateFile: "GEMINI.md", destFile: "GEMINI.md", selected: true },
+  { 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 }
+];
+
+// 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 = "";
+  const pkgPath = join2(projectPath, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      if (pkg.name) name = pkg.name;
+      if (pkg.description) description = pkg.description;
+      stack = "Node.js";
+    } catch {
+    }
+  }
+  if (!stack) {
+    if (existsSync(join2(projectPath, "Cargo.toml"))) stack = "Rust";
+    else if (existsSync(join2(projectPath, "go.mod"))) stack = "Go";
+    else if (existsSync(join2(projectPath, "pyproject.toml")) || existsSync(join2(projectPath, "requirements.txt"))) stack = "Python";
+    else if (existsSync(join2(projectPath, "pom.xml"))) stack = "Java (Maven)";
+    else if (existsSync(join2(projectPath, "build.gradle")) || existsSync(join2(projectPath, "build.gradle.kts"))) stack = "Kotlin/Java (Gradle)";
+    else if (existsSync(join2(projectPath, "composer.json"))) stack = "PHP";
+    else if (existsSync(join2(projectPath, "Gemfile"))) stack = "Ruby";
+  }
+  return { name, description, stack, date };
+}
+function buildMemoryMd(templateContent, info2) {
+  let content = templateContent;
+  const whatLine = info2.description ? `**${info2.name}** \u2014 ${info2.description}` : `**${info2.name}**`;
+  content = content.replace(
+    /### What this project is\n<!--[^]*?-->/,
+    `### What this project is
+${whatLine}
+<!-- 2\u20133 lines: what it does, who it's for, what problem it solves -->`
+  );
+  if (info2.stack) {
+    content = content.replace(
+      /### Stack\n<!--[^]*?-->/,
+      `### Stack
+${info2.stack}
+<!-- Add layers: Frontend, Backend, Infra, etc. -->`
+    );
+  }
+  content = content.replace(
+    /### Current focus\n<!--[^]*?-->/,
+    `### Current focus
+<!-- Initialized ${info2.date} \u2014 ask your AI to fill this in after your first session -->`
+  );
+  return content;
+}
+var BRAIN_FILES = [
+  { templateFile: "MEMORY.md", label: ".brain/MEMORY.md", desc: "permanent project facts" },
+  { templateFile: "SESSION.md", label: ".brain/SESSION.md", desc: "current session state" },
+  { templateFile: "SHARED.md", label: ".brain/SHARED.md", desc: "shared across sessions" },
+  { templateFile: "LOG.md", label: ".brain/LOG.md", desc: "full session history" }
+];
+var DEFAULT_MAX_LOG_ENTRIES = 50;
+var initCommand = new Command("init").description("Set up memory for the current project").option("-y, --yes", "Skip all prompts, use defaults").addHelpText("after", `
+Examples:
+  mindlink init
+  mindlink init --yes
+  `).action(async (opts) => {
+  const projectPath = resolve(process.cwd());
+  const brainDir = join2(projectPath, BRAIN_DIR);
+  printBanner();
+  if (existsSync(brainDir)) {
+    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 {
+      }
+    }
+    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("");
+  let selectedAgents;
+  if (opts.yes) {
+    selectedAgents = AGENTS.filter((a) => a.selected).map((a) => a.value);
+  } else {
+    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);
+    }
+    selectedAgents = agentResult;
+    console.log(`  ${chalk2.dim("\u21A9  Add or remove agents anytime: mindlink config \u2192 Agent instruction files")}`);
+    console.log("");
+  }
+  let gitTracking;
+  if (opts.yes) {
+    gitTracking = true;
+  } else {
+    console.log(`  ${chalk2.dim(".brain/ is your AI's memory \u2014 MEMORY.md, SESSION.md, SHARED.md, LOG.md.")}`);
+    console.log(`  ${chalk2.dim("Plain Markdown files. Commit them to share with your team, or keep them local.")}`);
+    console.log("");
+    const gitResult = await select({
+      message: "Should .brain/ be committed to git?",
+      options: [
+        { value: "enable", label: "Enable", hint: "team shares the same AI memory" },
+        { value: "disable", label: "Disable", hint: "add to .gitignore \u2014 personal memory only" }
+      ]
+    });
+    if (isCancel(gitResult)) {
+      cancel("Cancelled.");
+      process.exit(0);
+    }
+    gitTracking = gitResult === "enable";
+    console.log(`  ${chalk2.dim("\u21A9  Change anytime: mindlink config \u2192 Git tracking")}`);
+    console.log("");
+  }
+  let autoSync;
+  if (opts.yes) {
+    autoSync = true;
+  } else {
+    const syncResult = await select({
+      message: "Auto-sync between sessions?",
+      options: [
+        { value: "enable", label: "Enable", hint: "watch for changes, sync automatically (recommended)" },
+        { value: "disable", label: "Disable", hint: "run mindlink sync manually when needed" }
+      ]
+    });
+    if (isCancel(syncResult)) {
+      cancel("Cancelled.");
+      process.exit(0);
+    }
+    autoSync = syncResult === "enable";
+    console.log(`  ${chalk2.dim("\u21A9  Change anytime: mindlink config \u2192 Auto-sync")}`);
+    console.log("");
+  }
+  const s = spinner();
+  s.start("Creating memory files...");
+  const created = [];
+  const errors = [];
+  try {
+    mkdirSync(brainDir, { recursive: true });
+    const projectInfo = detectProjectInfo(projectPath);
+    for (const file of BRAIN_FILES) {
+      const dest = join2(brainDir, file.templateFile);
+      const templateContent = readFileSync(join2(BRAIN_TEMPLATES_DIR, file.templateFile), "utf8");
+      const content = file.templateFile === "MEMORY.md" ? buildMemoryMd(templateContent, projectInfo) : templateContent;
+      writeFileSync(dest, content);
+      created.push(`${file.label.padEnd(32)} ${chalk2.dim(file.desc)}`);
+    }
+    for (const agentValue of selectedAgents) {
+      const agent = AGENTS.find((a) => a.value === agentValue);
+      if (!agent) continue;
+      const destPath = join2(projectPath, agent.destFile);
+      mkdirSync(dirname2(destPath), { recursive: true });
+      writeFileSync(destPath, readFileSync(join2(AGENT_TEMPLATES_DIR, agent.templateFile), "utf8"));
+      created.push(`${agent.destFile.padEnd(32)} ${chalk2.dim(agent.label)}`);
+    }
+    if (selectedAgents.includes("claude")) {
+      const hookDest = join2(projectPath, ".claude", "settings.json");
+      if (!existsSync(hookDest)) {
+        mkdirSync(dirname2(hookDest), { recursive: true });
+        writeFileSync(hookDest, readFileSync(join2(HOOKS_TEMPLATES_DIR, "claude-settings.json"), "utf8"));
+        created.push(`.claude/settings.json${" ".repeat(14)} ${chalk2.dim("Claude Code compact hook")}`);
+      }
+    }
+    if (!gitTracking) {
+      const gitignorePath = join2(projectPath, ".gitignore");
+      const entry = "\n# MindLink memory (personal \u2014 not shared with team)\n.brain/\n";
+      if (existsSync(gitignorePath)) {
+        const current = readFileSync(gitignorePath, "utf8");
+        if (!current.includes(".brain/")) appendFileSync(gitignorePath, entry);
+      } else {
+        writeFileSync(gitignorePath, entry.trim() + "\n");
+      }
+      created.push(`.gitignore${" ".repeat(23)} ${chalk2.dim(".brain/ excluded")}`);
+    }
+    const config = {
+      gitTracking,
+      autoSync,
+      agents: selectedAgents,
+      maxLogEntries: DEFAULT_MAX_LOG_ENTRIES
+    };
+    writeFileSync(join2(brainDir, "config.json"), JSON.stringify(config, null, 2));
+  } catch (err) {
+    errors.push(err instanceof Error ? err.message : String(err));
+  }
+  s.stop("Done.");
+  console.log("");
+  for (const line of created) {
+    console.log(`  ${chalk2.green("\u2713")}  ${line}`);
+  }
+  if (errors.length > 0) {
+    console.log("");
+    for (const err of errors) console.log(`  ${chalk2.red("\u2717")}  ${err}`);
+  }
+  console.log("");
+  note(
+    `Your AI finally has a brain.
+
+Every new session wakes up knowing the project, past decisions,
+current task, and what other sessions have shared. No more
+re-explaining from scratch. No more goldfish moments.
+
+Like any good brain, it remembers what matters and quietly
+lets go of the old stuff \u2014 that's what MEMORY.md is for:
+promote anything important there and it stays forever.
+
+Start a new AI session \u2014 it'll hit the ground running.
+
+Run ${chalk2.cyan("mindlink help")} to see all commands.`,
+    "\u25C9 MindLink active"
+  );
+  console.log("");
+});
+
+// src/commands/status.ts
+import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+
+// src/utils/parser.ts
+function extractSection(markdown, heading) {
+  const lines = markdown.split("\n");
+  let inSection = false;
+  let headingLevel = 0;
+  const result = [];
+  for (const line of lines) {
+    const match = line.match(/^(#{1,6})\s+(.+)/);
+    if (match) {
+      const level = match[1].length;
+      const title = match[2].trim();
+      if (title.toLowerCase() === heading.toLowerCase()) {
+        inSection = true;
+        headingLevel = level;
+        continue;
+      }
+      if (inSection && level <= headingLevel) {
+        break;
+      }
+    }
+    if (inSection) {
+      result.push(line);
+    }
+  }
+  return result.join("\n").trim();
+}
+function extractBullets(text3) {
+  return text3.split("\n").filter((l) => /^[-*]\s+/.test(l.trim())).map((l) => l.replace(/^[-*]\s+/, "").trim()).filter((l) => l.length > 0 && !l.startsWith("<!--"));
+}
+function countLogEntries(markdown) {
+  return (markdown.match(/^##\s+/gm) ?? []).length;
+}
+function lastLogDate(markdown) {
+  const matches = markdown.match(/^##\s+(.+)/m);
+  return matches ? matches[1].trim() : null;
+}
+function countDecisions(markdown) {
+  const section = extractSection(markdown, "Key Decisions");
+  return section.split("\n").filter((l) => l.startsWith("|") && !l.includes("---") && !l.toLowerCase().includes("decision")).filter((l) => {
+    const cols = l.split("|").map((c) => c.trim()).filter(Boolean);
+    return cols.some((c) => c.length > 0);
+  }).length;
+}
+function parseLogEntries(markdown) {
+  const blocks = markdown.split(/(?=^## )/m).filter((b) => b.trimStart().startsWith("## "));
+  return blocks.map((block) => {
+    const newline = block.indexOf("\n");
+    const heading = newline === -1 ? block.slice(3).trim() : block.slice(3, newline).trim();
+    const body = newline === -1 ? "" : block.slice(newline + 1).trim();
+    return { heading, body };
+  });
+}
+function relativeTime(date) {
+  const diff = Date.now() - date.getTime();
+  const minutes = Math.floor(diff / 6e4);
+  const hours = Math.floor(diff / 36e5);
+  const days = Math.floor(diff / 864e5);
+  if (minutes < 2) return "just now";
+  if (minutes < 60) return `${minutes} minutes ago`;
+  if (hours < 24) return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+  return `${days} day${days > 1 ? "s" : ""} ago`;
+}
+
+// src/commands/status.ts
+var statusCommand = new Command2("status").description("Show last session summary and what's next").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  mindlink status
+  mindlink status --json
+  `).action((opts) => {
+  const projectPath = resolve2(process.cwd());
+  const brainDir = join3(projectPath, BRAIN_DIR);
+  if (!existsSync2(brainDir)) {
+    console.log(`  ${chalk3.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk3.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  const sessionPath = join3(brainDir, "SESSION.md");
+  const logPath = join3(brainDir, "LOG.md");
+  const memoryPath = join3(brainDir, "MEMORY.md");
+  const sessionMd = existsSync2(sessionPath) ? readFileSync2(sessionPath, "utf8") : "";
+  const logMd = existsSync2(logPath) ? readFileSync2(logPath, "utf8") : "";
+  const memoryMd = existsSync2(memoryPath) ? readFileSync2(memoryPath, "utf8") : "";
+  const rawTask = extractSection(sessionMd, "Current Task");
+  const currentTask = rawTask.startsWith("<!--") ? "" : rawTask;
+  const inProgress = extractBullets(extractSection(sessionMd, "In Progress"));
+  const decisions = extractBullets(extractSection(sessionMd, "Decisions Made This Session"));
+  const blockers = extractBullets(extractSection(sessionMd, "Blockers"));
+  const upNext = extractBullets(extractSection(sessionMd, "Up Next"));
+  const sessionCount = countLogEntries(logMd);
+  const lastSession = lastLogDate(logMd);
+  const decisionCount = countDecisions(memoryMd);
+  const lastUpdated = existsSync2(sessionPath) ? relativeTime(statSync(sessionPath).mtime) : "never";
+  const isEmpty = !currentTask && inProgress.length === 0 && decisions.length === 0 && blockers.length === 0 && upNext.length === 0 && sessionCount === 0;
+  if (opts.json) {
+    console.log(JSON.stringify({
+      currentTask,
+      inProgress,
+      decisions,
+      blockers,
+      upNext,
+      stats: { sessionsLogged: sessionCount, decisionsMade: decisionCount, lastUpdated }
+    }, null, 2));
+    return;
+  }
+  console.log("");
+  if (isEmpty) {
+    console.log(`  ${chalk3.dim("No sessions logged yet.")}`);
+    console.log(`  Start an AI session \u2014 it will read ${chalk3.cyan(".brain/")} automatically.`);
+    console.log("");
+    return;
+  }
+  if (lastSession) {
+    console.log(`  ${chalk3.bold("Last session")} ${chalk3.dim("\u2014")} ${lastSession}`);
+    console.log("");
+  }
+  if (currentTask && !currentTask.startsWith("<!--")) {
+    console.log(`  ${chalk3.bold("Current task")}`);
+    console.log(`  ${chalk3.cyan("\u25CE")}  ${currentTask}`);
+    console.log("");
+  }
+  if (inProgress.length > 0) {
+    console.log(`  ${chalk3.bold("In progress")}`);
+    for (const item of inProgress) {
+      console.log(`  ${chalk3.yellow("\u25CF")}  ${item}`);
+    }
+    console.log("");
+  }
+  if (decisions.length > 0) {
+    console.log(`  ${chalk3.bold("Decided this session")}`);
+    for (const item of decisions) {
+      console.log(`  ${chalk3.green("\u2713")}  ${item}`);
+    }
+    console.log("");
+  }
+  if (blockers.length > 0) {
+    console.log(`  ${chalk3.bold("Blockers")}`);
+    for (const item of blockers) {
+      console.log(`  ${chalk3.red("\u2717")}  ${item}`);
+    }
+    console.log("");
+  }
+  if (upNext.length > 0) {
+    console.log(`  ${chalk3.bold("Up next")}`);
+    for (const item of upNext) {
+      console.log(`  ${chalk3.dim("\u2192")}  ${item}`);
+    }
+    console.log("");
+  }
+  console.log(`  ${chalk3.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`);
+  console.log(`  ${chalk3.dim("Sessions logged")}  ${String(sessionCount).padStart(4)}`);
+  console.log(`  ${chalk3.dim("Decisions made")}   ${String(decisionCount).padStart(4)}`);
+  console.log(`  ${chalk3.dim("Last updated")}     ${lastUpdated}`);
+  console.log("");
+  console.log(`  Run ${chalk3.cyan("mindlink log")} to see full history.`);
+  console.log("");
+});
+
+// src/commands/log.ts
+import { Command as Command3 } from "commander";
+import chalk4 from "chalk";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync } from "fs";
+import { join as join4, 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:
+  mindlink log
+  mindlink log --all
+  mindlink log --limit 20
+  mindlink log --since "Apr 1"
+  mindlink log --json
+  `).action((opts) => {
+  const projectPath = resolve3(process.cwd());
+  const brainDir = join4(projectPath, BRAIN_DIR);
+  if (!existsSync3(brainDir)) {
+    console.log(`  ${chalk4.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk4.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  const logPath = join4(brainDir, "LOG.md");
+  const logMd = existsSync3(logPath) ? readFileSync3(logPath, "utf8") : "";
+  let entries = parseLogEntries(logMd);
+  if (entries.length === 0) {
+    console.log("");
+    console.log(`  ${chalk4.dim("No sessions logged yet.")}`);
+    console.log(`  ${chalk4.dim("Your AI will append an entry here at the end of each session.")}`);
+    console.log("");
+    return;
+  }
+  if (opts.since) {
+    const since = opts.since.toLowerCase();
+    entries = entries.filter((e) => e.heading.toLowerCase().includes(since));
+  }
+  const limit = opts.all ? entries.length : parseInt(opts.limit, 10);
+  const total = entries.length;
+  const shown = entries.slice(0, limit);
+  if (opts.json) {
+    console.log(JSON.stringify(shown, null, 2));
+    return;
+  }
+  console.log("");
+  if (!opts.all) {
+    const rest = total - shown.length;
+    const hint = rest > 0 ? `  ${chalk4.dim(`${rest} more \u2014 run mindlink log --all to see everything`)}` : "";
+    console.log(`  ${chalk4.dim(`Showing last ${shown.length} of ${total} session${total !== 1 ? "s" : ""}`)}${hint ? "" : ""}`);
+    if (rest > 0) console.log(`  ${chalk4.dim(`${rest} more \u2014 run mindlink log --all to see everything`)}`);
+    console.log("");
+  }
+  for (const entry of shown) {
+    console.log(`  ${chalk4.bold("\u2500\u2500")} ${chalk4.cyan(entry.heading)} ${"\u2500".repeat(Math.max(0, 40 - entry.heading.length))}`);
+    if (entry.body) {
+      const lines = entry.body.split("\n");
+      for (const line of lines) {
+        console.log(`  ${chalk4.dim(line)}`);
+      }
+    }
+    console.log("");
+  }
+  const archiveFiles = readdirSync(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")}`);
+    console.log(`  ${chalk4.dim("that haven't come up in a while \u2014 that's by design.")}`);
+    console.log(`  ${chalk4.dim(`Older entries archived to: ${archiveFiles.join(", ")}`)}`);
+    console.log(`  ${chalk4.dim("Anything that truly matters belongs in MEMORY.md.")}`);
+    console.log("");
+  }
+});
+
+// src/commands/clear.ts
+import { Command as Command4 } from "commander";
+import chalk5 from "chalk";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5, resolve as resolve4 } from "path";
+var clearCommand = new Command4("clear").description("Reset SESSION.md for a fresh session start").option("-y, --yes", "Skip confirmation prompt").addHelpText("after", `
+What it does:
+  Resets SESSION.md to a blank template \u2014 wipes current task, in-progress items,
+  blockers, and up-next. MEMORY.md, LOG.md, and SHARED.md are untouched.
+
+Not what you need?
+  mindlink reset     \u2014 wipe ALL memory files back to blank (scorched earth)
+  mindlink uninstall \u2014 remove MindLink from this project entirely
+
+Examples:
+  mindlink clear
+  mindlink clear --yes
+  `).action(async (_opts) => {
+  const projectPath = resolve4(process.cwd());
+  const brainDir = join5(projectPath, BRAIN_DIR);
+  if (!existsSync4(brainDir)) {
+    console.log("");
+    console.log(`  ${chalk5.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk5.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  console.log("");
+  try {
+    const templatePath = join5(BRAIN_TEMPLATES_DIR, "SESSION.md");
+    const destPath = join5(brainDir, "SESSION.md");
+    writeFileSync2(destPath, readFileSync4(templatePath, "utf8"));
+  } catch (err) {
+    console.log(`  ${chalk5.red("\u2717")}  ${err instanceof Error ? err.message : String(err)}`);
+    console.log("");
+    process.exit(1);
+  }
+  console.log(`  ${chalk5.green("\u2713")}  SESSION.md cleared. Ready for a clean session.`);
+  console.log(`     ${chalk5.dim("MEMORY.md, LOG.md, and SHARED.md are untouched.")}`);
+  console.log("");
+});
+
+// src/commands/reset.ts
+import { Command as Command5 } from "commander";
+import { confirm, isCancel as isCancel2, cancel as cancel2 } from "@clack/prompts";
+import chalk6 from "chalk";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6, resolve as resolve5 } from "path";
+var BRAIN_FILES2 = ["MEMORY.md", "SESSION.md", "SHARED.md", "LOG.md"];
+var resetCommand = new Command5("reset").description("Wipe all .brain/ memory files and start completely fresh").option("-y, --yes", "Skip confirmation prompt").addHelpText("after", `
+What it does:
+  Resets MEMORY.md, SESSION.md, SHARED.md, and LOG.md to blank templates.
+  Your settings (config.json) and agent instruction files are untouched.
+
+Not what you need?
+  mindlink clear     \u2014 reset SESSION.md only (lighter option)
+  mindlink uninstall \u2014 remove MindLink from this project entirely
+
+Examples:
+  mindlink reset
+  mindlink reset --yes
+  `).action(async (opts) => {
+  const projectPath = resolve5(process.cwd());
+  const brainDir = join6(projectPath, BRAIN_DIR);
+  if (!existsSync5(brainDir)) {
+    console.log(`  ${chalk6.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk6.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  console.log("");
+  if (!opts.yes) {
+    console.log(`  ${chalk6.yellow("!")}  This will wipe ALL .brain/ memory files and start fresh.`);
+    console.log(`     ${chalk6.dim("MEMORY.md, SESSION.md, SHARED.md, and LOG.md \u2192 reset to blank templates.")}`);
+    console.log(`     ${chalk6.dim("Settings and agent instruction files are untouched.")}`);
+    console.log("");
+    console.log(`  ${chalk6.dim("Lighter option: mindlink clear  \u2014 resets SESSION.md only")}`);
+    console.log(`  ${chalk6.dim("Remove entirely: mindlink uninstall  \u2014 removes MindLink from this project")}`);
+    console.log("");
+    const confirmed = await confirm({
+      message: "Reset everything? This cannot be undone (unless .brain/ is tracked by git)."
+    });
+    if (isCancel2(confirmed) || !confirmed) {
+      cancel2("Cancelled.");
+      process.exit(0);
+    }
+    console.log("");
+  }
+  const errors = [];
+  for (const file of BRAIN_FILES2) {
+    try {
+      const templatePath = join6(BRAIN_TEMPLATES_DIR, file);
+      const destPath = join6(brainDir, file);
+      if (existsSync5(templatePath)) {
+        writeFileSync3(destPath, readFileSync5(templatePath, "utf8"));
+      }
+    } catch (err) {
+      errors.push(`${file}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (errors.length > 0) {
+    for (const err of errors) console.log(`  ${chalk6.red("\u2717")}  ${err}`);
+    console.log("");
+    process.exit(1);
+  }
+  console.log(`  ${chalk6.green("\u2713")}  .brain/ reset. All memory files are blank.`);
+  console.log(`     ${chalk6.dim("Your AI will wake up with no memory of past sessions.")}`);
+  console.log("");
+});
+
+// src/commands/config.ts
+import { Command as Command6 } from "commander";
+import { select as select2, multiselect as multiselect2, text, isCancel as isCancel3 } from "@clack/prompts";
+import chalk7 from "chalk";
+import {
+  existsSync as existsSync6,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync4,
+  appendFileSync as appendFileSync2,
+  mkdirSync as mkdirSync2,
+  unlinkSync
+} from "fs";
+import { join as join7, resolve as resolve6, dirname as dirname3 } from "path";
+function readConfig(brainDir) {
+  return JSON.parse(readFileSync6(join7(brainDir, "config.json"), "utf8"));
+}
+function saveConfig(brainDir, config) {
+  writeFileSync4(join7(brainDir, "config.json"), JSON.stringify(config, null, 2));
+}
+function enableGitTracking(projectPath) {
+  const gitignorePath = join7(projectPath, ".gitignore");
+  if (!existsSync6(gitignorePath)) return;
+  const content = readFileSync6(gitignorePath, "utf8");
+  const cleaned = content.replace(/\n# MindLink memory[^\n]*\n\.brain\/\n?/g, "").replace(/\n?\.brain\/\n?/g, "\n");
+  writeFileSync4(gitignorePath, cleaned.trimEnd() + "\n");
+}
+function disableGitTracking(projectPath) {
+  const gitignorePath = join7(projectPath, ".gitignore");
+  const entry = "\n# MindLink memory (personal \u2014 not shared with team)\n.brain/\n";
+  if (existsSync6(gitignorePath)) {
+    const content = readFileSync6(gitignorePath, "utf8");
+    if (!content.includes(".brain/")) appendFileSync2(gitignorePath, entry);
+  } else {
+    writeFileSync4(gitignorePath, entry.trim() + "\n");
+  }
+}
+function addAgentFile(projectPath, agentValue) {
+  const agent = AGENTS.find((a) => a.value === agentValue);
+  if (!agent) return null;
+  const destPath = join7(projectPath, agent.destFile);
+  if (existsSync6(destPath)) return null;
+  mkdirSync2(dirname3(destPath), { recursive: true });
+  writeFileSync4(destPath, readFileSync6(join7(AGENT_TEMPLATES_DIR, agent.templateFile), "utf8"));
+  return agent.destFile;
+}
+function removeAgentFile(projectPath, agentValue) {
+  const agent = AGENTS.find((a) => a.value === agentValue);
+  if (!agent) return null;
+  const destPath = join7(projectPath, agent.destFile);
+  if (!existsSync6(destPath)) return null;
+  unlinkSync(destPath);
+  return agent.destFile;
+}
+function addClaudeHook(projectPath) {
+  const hookDest = join7(projectPath, ".claude", "settings.json");
+  if (existsSync6(hookDest)) return false;
+  mkdirSync2(dirname3(hookDest), { recursive: true });
+  writeFileSync4(hookDest, readFileSync6(join7(HOOKS_TEMPLATES_DIR, "claude-settings.json"), "utf8"));
+  return true;
+}
+var configCommand = new Command6("config").description("Change settings for the current project").addHelpText("after", `
+Examples:
+  mindlink config
+  `).action(async () => {
+  const projectPath = resolve6(process.cwd());
+  const brainDir = join7(projectPath, BRAIN_DIR);
+  if (!existsSync6(brainDir)) {
+    console.log(`  ${chalk7.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk7.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  if (!process.stdin.isTTY) {
+    const cfg = readConfig(brainDir);
+    const agentLabels = cfg.agents.map((v) => AGENTS.find((a) => a.value === v)?.hint ?? v).join(", ");
+    console.log(JSON.stringify({ ...cfg, agentFiles: agentLabels }, null, 2));
+    return;
+  }
+  let config = readConfig(brainDir);
+  while (true) {
+    console.log("");
+    console.log(`  ${chalk7.bold("Current settings")}  ${chalk7.dim("\xB7")}  ${chalk7.dim(projectPath)}`);
+    console.log("");
+    console.log(`  Git tracking   : ${config.gitTracking ? chalk7.green("enabled") : chalk7.dim("disabled")}   ${chalk7.dim(config.gitTracking ? "(team shares memory)" : "(.brain/ excluded from git)")}`);
+    console.log(`  Auto-sync      : ${config.autoSync ? chalk7.green("enabled") : chalk7.dim("disabled")}   ${chalk7.dim(config.autoSync ? "(watch mode)" : "(run mindlink sync manually)")}`);
+    console.log(`  Max log entries: ${chalk7.dim(String(config.maxLogEntries))}   ${chalk7.dim("(archive rotation threshold)")}`);
+    const agentLabels = config.agents.map((v) => AGENTS.find((a) => a.value === v)?.hint ?? v).join(", ");
+    console.log(`  Agent files    : ${chalk7.dim(agentLabels || "none")}`);
+    console.log("");
+    const action = await select2({
+      message: "What would you like to change?",
+      options: [
+        { value: "git", label: "Git tracking" },
+        { value: "sync", label: "Auto-sync" },
+        { value: "memory", label: "Memory settings", hint: "log rotation threshold" },
+        { value: "agents", label: "Agent instruction files" },
+        { value: "exit", label: "Exit" }
+      ]
+    });
+    if (isCancel3(action) || action === "exit") break;
+    if (action === "git") {
+      const choice = await select2({
+        message: "Git tracking \u2014 should .brain/ be committed to git?",
+        options: [
+          { value: "enable", label: "Enable", hint: "commit memory (share with your team)" },
+          { value: "disable", label: "Disable", hint: "add to .gitignore (keep memory personal)" },
+          { value: "back", label: "\u21A9  Back" }
+        ],
+        initialValue: config.gitTracking ? "enable" : "disable"
+      });
+      if (isCancel3(choice) || choice === "back") continue;
+      const newValue = choice === "enable";
+      if (newValue === config.gitTracking) {
+        console.log(`  ${chalk7.dim("No change.")}`);
+        continue;
+      }
+      if (newValue) {
+        enableGitTracking(projectPath);
+        console.log(`  ${chalk7.green("\u2713")}  Git tracking enabled. .brain/ will be committed.`);
+      } else {
+        disableGitTracking(projectPath);
+        console.log(`  ${chalk7.green("\u2713")}  .gitignore updated. .brain/ will no longer be tracked.`);
+      }
+      config.gitTracking = newValue;
+      saveConfig(brainDir, config);
+      console.log(`  ${chalk7.dim("\u21A9  Change anytime: mindlink config \u2192 Git tracking")}`);
+    }
+    if (action === "sync") {
+      const choice = await select2({
+        message: "Auto-sync mode",
+        options: [
+          { value: "enable", label: "Enable", hint: "watch for changes, sync automatically" },
+          { value: "disable", label: "Disable", hint: "run mindlink sync manually" },
+          { value: "back", label: "\u21A9  Back" }
+        ],
+        initialValue: config.autoSync ? "enable" : "disable"
+      });
+      if (isCancel3(choice) || choice === "back") continue;
+      const newValue = choice === "enable";
+      if (newValue === config.autoSync) {
+        console.log(`  ${chalk7.dim("No change.")}`);
+        continue;
+      }
+      config.autoSync = newValue;
+      saveConfig(brainDir, config);
+      console.log(`  ${chalk7.green("\u2713")}  Auto-sync ${newValue ? "enabled" : "disabled"}.`);
+      console.log(`  ${chalk7.dim("\u21A9  Change anytime: mindlink config \u2192 Auto-sync")}`);
+    }
+    if (action === "memory") {
+      console.log("");
+      console.log(`  ${chalk7.dim("How many session entries to keep in LOG.md before archiving older ones.")}`);
+      console.log(`  ${chalk7.dim("Archived entries move to LOG-YYYY-MM-DD.md \u2014 never deleted.")}`);
+      console.log(`  ${chalk7.dim("Lower = lighter context for your AI. Higher = more history visible.")}`);
+      console.log("");
+      const input = await text({
+        message: `Max log entries before archiving (current: ${config.maxLogEntries})`,
+        placeholder: String(config.maxLogEntries),
+        validate(value) {
+          const n = parseInt(value, 10);
+          if (isNaN(n) || n < 1) return "Enter a number greater than 0";
+        }
+      });
+      if (isCancel3(input)) continue;
+      const newValue = parseInt(input, 10);
+      if (newValue === config.maxLogEntries) {
+        console.log(`  ${chalk7.dim("No change.")}`);
+        continue;
+      }
+      config.maxLogEntries = newValue;
+      saveConfig(brainDir, config);
+      console.log(`  ${chalk7.green("\u2713")}  Max log entries set to ${newValue}.`);
+      console.log(`  ${chalk7.dim("\u21A9  Change anytime: mindlink config \u2192 Memory settings")}`);
+    }
+    if (action === "agents") {
+      const agentChoices = AGENTS.map((a) => ({
+        value: a.value,
+        label: `${a.label.padEnd(18)} ${chalk7.dim(a.hint)}`,
+        hint: a.selected ? "recommended" : void 0
+      }));
+      const result = await multiselect2({
+        message: "Which AI agents do you use?",
+        options: agentChoices,
+        initialValues: config.agents,
+        required: false
+      });
+      if (isCancel3(result)) continue;
+      const newAgents = result;
+      const added = newAgents.filter((v) => !config.agents.includes(v));
+      const removed = config.agents.filter((v) => !newAgents.includes(v));
+      const addedFiles = [];
+      const removedFiles = [];
+      for (const v of added) {
+        const f = addAgentFile(projectPath, v);
+        if (f) addedFiles.push(f);
+        if (v === "claude") {
+          if (addClaudeHook(projectPath)) addedFiles.push(".claude/settings.json");
+        }
+      }
+      for (const v of removed) {
+        const f = removeAgentFile(projectPath, v);
+        if (f) removedFiles.push(f);
+      }
+      config.agents = newAgents;
+      saveConfig(brainDir, config);
+      if (addedFiles.length === 0 && removedFiles.length === 0) {
+        console.log(`  ${chalk7.dim("No change.")}`);
+      } else {
+        for (const f of addedFiles) console.log(`  ${chalk7.green("\u2713")}  ${f} added.`);
+        for (const f of removedFiles) console.log(`  ${chalk7.dim("\u2717")}  ${f} removed.`);
+      }
+      console.log(`  ${chalk7.dim("\u21A9  Change anytime: mindlink config \u2192 Agent instruction files")}`);
+    }
+  }
+  console.log("");
+});
+
+// src/commands/sync.ts
+import { Command as Command7 } from "commander";
+import chalk8 from "chalk";
+import { existsSync as existsSync7, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { join as join8, resolve as resolve7, basename as basename2 } from "path";
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const month = d.toLocaleString("default", { month: "short" });
+  const day = d.getDate();
+  const time = d.toTimeString().slice(0, 5);
+  return `${month} ${day} ${time}`;
+}
+function describeFile(filePath) {
+  if (!existsSync7(filePath)) return chalk8.dim("(missing)");
+  const stat = statSync2(filePath);
+  const kb = (stat.size / 1024).toFixed(1);
+  const content = readFileSync7(filePath, "utf8");
+  const entries = (content.match(/^## /gm) ?? []).length;
+  const name = basename2(filePath);
+  if (name === "LOG.md") return entries > 0 ? `${entries} session${entries !== 1 ? "s" : ""}` : chalk8.dim("empty");
+  if (name === "SHARED.md") {
+    const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#") && !l.startsWith("<!--") && !l.startsWith(">") && l !== "---").length;
+    return lines > 0 ? `${lines} line${lines !== 1 ? "s" : ""}` : chalk8.dim("empty");
+  }
+  if (name === "SESSION.md") {
+    const hasTask = content.includes("## Current Task") && !content.includes("<!-- ");
+    return hasTask ? chalk8.green("active") : chalk8.dim("idle");
+  }
+  return `${kb} KB`;
+}
+var syncCommand = new Command7("sync").description("Sync shared context between sessions").option("--once", "Sync once and exit (default: watch mode)").addHelpText("after", `
+Examples:
+  mindlink sync
+  mindlink sync --once
+  `).action(async (opts) => {
+  const projectPath = resolve7(process.cwd());
+  const brainDir = join8(projectPath, BRAIN_DIR);
+  if (!existsSync7(brainDir)) {
+    console.log(`  ${chalk8.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk8.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  const sharedPath = join8(brainDir, "SHARED.md");
+  const sessionPath = join8(brainDir, "SESSION.md");
+  const logPath = join8(brainDir, "LOG.md");
+  const memoryPath = join8(brainDir, "MEMORY.md");
+  if (opts.once) {
+    console.log("");
+    console.log(`  ${chalk8.dim("Checking shared context...")}`);
+    console.log("");
+    const files = [
+      { label: "SHARED.md  ", path: sharedPath },
+      { label: "SESSION.md ", path: sessionPath },
+      { label: "LOG.md     ", path: logPath },
+      { label: "MEMORY.md  ", path: memoryPath }
+    ];
+    for (const { label, path } of files) {
+      const desc = describeFile(path);
+      const mtime = existsSync7(path) ? statSync2(path).mtime : null;
+      const age = mtime ? (() => {
+        const diff = Date.now() - mtime.getTime();
+        const min = Math.floor(diff / 6e4);
+        const hr = Math.floor(diff / 36e5);
+        if (min < 2) return "just now";
+        if (min < 60) return `${min}m ago`;
+        return `${hr}h ago`;
+      })() : "";
+      console.log(`  ${chalk8.dim(label)}  ${desc}  ${chalk8.dim(age)}`);
+    }
+    console.log("");
+    console.log(`  ${chalk8.green("\u2713")}  All sessions share the same .brain/ folder.`);
+    console.log(`     ${chalk8.dim("Any session that writes to SHARED.md is immediately visible to all others.")}`);
+    console.log("");
+    return;
+  }
+  const { watch } = await import("chokidar");
+  console.log("");
+  console.log(`  ${chalk8.dim("Watching for changes...")}  ${chalk8.dim("(Ctrl+C to stop)")}`);
+  console.log("");
+  const watcher = watch(brainDir, {
+    ignoreInitial: true,
+    ignored: /(^|[/\\])\../,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
+  });
+  watcher.on("change", (filePath) => {
+    const name = basename2(filePath);
+    const stat = statSync2(filePath);
+    const kb = (stat.size / 1024).toFixed(1);
+    console.log(`  ${chalk8.dim("[" + timestamp() + "]")}  ${chalk8.cyan(name)} updated  ${chalk8.dim(kb + " KB")}  ${chalk8.green("\u2192 synced \u2713")}`);
+  });
+  watcher.on("add", (filePath) => {
+    const name = basename2(filePath);
+    console.log(`  ${chalk8.dim("[" + timestamp() + "]")}  ${chalk8.cyan(name)} created  ${chalk8.green("\u2192 synced \u2713")}`);
+  });
+  watcher.on("error", (err) => {
+    console.log(`  ${chalk8.red("\u2717")}  Watch error: ${err instanceof Error ? err.message : String(err)}`);
+  });
+  process.on("SIGINT", () => {
+    watcher.close();
+    console.log("");
+    console.log(`  ${chalk8.dim("Stopped.")}`);
+    console.log("");
+    process.exit(0);
+  });
+});
+
+// src/commands/update.ts
+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 { createRequire } from "module";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname4, join as join9 } from "path";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname4(__filename2);
+var require2 = createRequire(import.meta.url);
+function currentVersion() {
+  try {
+    const pkg = require2(join9(__dirname2, "..", "..", "package.json"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+async function latestVersion() {
+  try {
+    const { default: https } = await import("https");
+    return new Promise((resolve13) => {
+      const req = https.get(
+        "https://registry.npmjs.org/mindlink/latest",
+        { headers: { "User-Agent": "mindlink-cli" } },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk;
+          });
+          res.on("end", () => {
+            try {
+              const parsed = JSON.parse(data);
+              resolve13(parsed.version ?? null);
+            } catch {
+              resolve13(null);
+            }
+          });
+        }
+      );
+      req.on("error", () => resolve13(null));
+      req.setTimeout(8e3, () => {
+        req.destroy();
+        resolve13(null);
+      });
+    });
+  } catch {
+    return null;
+  }
+}
+function semverGt(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return true;
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return false;
+  }
+  return false;
+}
+var updateCommand = new Command8("update").description("Update mindlink to the latest version").addHelpText("after", `
+Examples:
+  mindlink update
+  `).action(async () => {
+  const current = currentVersion();
+  if (!process.stdin.isTTY) {
+    const latest2 = await latestVersion();
+    if (!latest2) {
+      console.log(JSON.stringify({ current, latest: null, upToDate: null }));
+      process.exit(1);
+    }
+    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("");
+    return;
+  }
+  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 {
+    execSync(`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);
+  }
+  console.log("");
+});
+
+// src/commands/summary.ts
+import { Command as Command9 } from "commander";
+import chalk10 from "chalk";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { join as join10, resolve as resolve8 } from "path";
+var summaryCommand = new Command9("summary").description("Print a full briefing of what your AI knows \u2014 great for sharing or reviewing context").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  mindlink summary
+  mindlink summary --json
+
+Tip: your AI agent can run this itself \u2014 ask it to run "mindlink summary"
+to get a full briefing on the current project state.
+  `).action((opts) => {
+  const projectPath = resolve8(process.cwd());
+  const brainDir = join10(projectPath, BRAIN_DIR);
+  if (!existsSync8(brainDir)) {
+    console.log(`  ${chalk10.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk10.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  const memoryPath = join10(brainDir, "MEMORY.md");
+  const sessionPath = join10(brainDir, "SESSION.md");
+  const logPath = join10(brainDir, "LOG.md");
+  const sharedPath = join10(brainDir, "SHARED.md");
+  const memoryMd = existsSync8(memoryPath) ? readFileSync8(memoryPath, "utf8") : "";
+  const sessionMd = existsSync8(sessionPath) ? readFileSync8(sessionPath, "utf8") : "";
+  const logMd = existsSync8(logPath) ? readFileSync8(logPath, "utf8") : "";
+  const sharedMd = existsSync8(sharedPath) ? readFileSync8(sharedPath, "utf8") : "";
+  const projectOverview = extractSection(memoryMd, "Project Overview") || extractSection(memoryMd, "Project Identity") || extractSection(memoryMd, "What Is This Project");
+  const techStack = extractSection(memoryMd, "Tech Stack") || extractSection(memoryMd, "Stack");
+  const decisions = extractBullets(
+    extractSection(memoryMd, "Key Decisions") || extractSection(memoryMd, "Decisions")
+  );
+  const rawTask = extractSection(sessionMd, "Current Task");
+  const task = rawTask.startsWith("<!--") ? "" : rawTask;
+  const inProg = extractBullets(extractSection(sessionMd, "In Progress"));
+  const upNext = extractBullets(extractSection(sessionMd, "Up Next"));
+  const blockers = extractBullets(extractSection(sessionMd, "Blockers"));
+  const sessionCount = countLogEntries(logMd);
+  const lastDate = lastLogDate(logMd);
+  const recentLogs = parseLogEntries(logMd).slice(0, 3);
+  const sharedLines = sharedMd.split("\n").filter((l) => l.trim() && !l.startsWith("#") && !l.startsWith("<!--") && !l.startsWith(">") && l !== "---").slice(0, 10);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      project: { overview: projectOverview, techStack, decisions },
+      session: { currentTask: task, inProgress: inProg, upNext, blockers },
+      log: { totalSessions: sessionCount, lastSession: lastDate, recent: recentLogs },
+      shared: sharedLines
+    }, null, 2));
+    return;
+  }
+  console.log("");
+  console.log(`  ${chalk10.bold("\u25C9 MindLink Memory Summary")}  ${chalk10.dim("\xB7")}  ${chalk10.dim(projectPath)}`);
+  console.log("");
+  if (projectOverview) {
+    console.log(`  ${chalk10.bold("Project")}`);
+    for (const line of projectOverview.split("\n").filter(Boolean)) {
+      console.log(`  ${chalk10.dim(line)}`);
+    }
+    console.log("");
+  }
+  if (techStack) {
+    console.log(`  ${chalk10.bold("Tech stack")}`);
+    for (const line of techStack.split("\n").filter(Boolean)) {
+      console.log(`  ${chalk10.dim(line)}`);
+    }
+    console.log("");
+  }
+  if (decisions.length > 0) {
+    console.log(`  ${chalk10.bold("Key decisions")}`);
+    for (const d of decisions.slice(0, 5)) {
+      console.log(`  ${chalk10.dim("\xB7")}  ${d}`);
+    }
+    if (decisions.length > 5) {
+      console.log(`  ${chalk10.dim(`  \u2026and ${decisions.length - 5} more in MEMORY.md`)}`);
+    }
+    console.log("");
+  }
+  if (task || inProg.length > 0 || upNext.length > 0) {
+    console.log(`  ${chalk10.bold("Current session")}`);
+    if (task) console.log(`  ${chalk10.cyan("\u25CE")}  ${task}`);
+    for (const item of inProg) console.log(`  ${chalk10.yellow("\u25CF")}  ${item}`);
+    for (const item of blockers) console.log(`  ${chalk10.red("\u2717")}  ${item}`);
+    for (const item of upNext) console.log(`  ${chalk10.dim("\u2192")}  ${item}`);
+    console.log("");
+  }
+  if (sharedLines.length > 0) {
+    console.log(`  ${chalk10.bold("Shared context")}  ${chalk10.dim("(from other sessions)")}`);
+    for (const line of sharedLines) {
+      console.log(`  ${chalk10.dim(line)}`);
+    }
+    console.log("");
+  }
+  if (recentLogs.length > 0) {
+    console.log(`  ${chalk10.bold("Recent sessions")}  ${chalk10.dim(`(${sessionCount} total)`)}`);
+    for (const entry of recentLogs) {
+      console.log(`  ${chalk10.dim("\u2500\u2500")} ${chalk10.cyan(entry.heading)}`);
+      if (entry.body) {
+        const preview = entry.body.split("\n").filter(Boolean)[0] ?? "";
+        if (preview) console.log(`     ${chalk10.dim(preview.slice(0, 72))}`);
+      }
+    }
+    console.log("");
+  }
+  if (!projectOverview && !task && sessionCount === 0 && sharedLines.length === 0) {
+    console.log(`  ${chalk10.dim("Memory files are blank \u2014 your AI hasn't written anything yet.")}`);
+    console.log(`  ${chalk10.dim("Start a session and let it run \u2014 it will fill these in automatically.")}`);
+    console.log("");
+  }
+  console.log(`  ${chalk10.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`);
+  console.log(`  ${chalk10.dim("Powered by MindLink \u2014 github.com/404-not-found/mindlink")}`);
+  console.log("");
+});
+
+// src/commands/uninstall.ts
+import { Command as Command10 } from "commander";
+import { select as select4, isCancel as isCancel5, cancel as cancel5 } from "@clack/prompts";
+import chalk11 from "chalk";
+import { existsSync as existsSync9, readFileSync as readFileSync9, rmSync, unlinkSync as unlinkSync2 } from "fs";
+import { join as join11, resolve as resolve9 } from "path";
+var uninstallCommand = new Command10("uninstall").description("Remove MindLink from the current project").option("-y, --yes", "Skip confirmation and remove all project files").addHelpText("after", `
+What gets removed:
+  - .brain/ folder (all memory files)
+  - Agent instruction files (CLAUDE.md, CURSOR.md, etc.)
+  - .claude/settings.json hook (if it was created by MindLink)
+
+What stays:
+  - The mindlink CLI itself (run: npm uninstall -g mindlink)
+  - Any files MindLink did not create
+
+Not what you need?
+  mindlink clear  \u2014 reset SESSION.md only (fresh session, keep everything else)
+  mindlink reset  \u2014 wipe memory back to blank (keep MindLink installed)
+
+Examples:
+  mindlink uninstall
+  mindlink uninstall --yes
+  `).action(async (opts) => {
+  const projectPath = resolve9(process.cwd());
+  const brainDir = join11(projectPath, BRAIN_DIR);
+  if (!existsSync9(brainDir)) {
+    console.log(`  ${chalk11.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Nothing to uninstall here.`);
+    console.log("");
+    process.exit(1);
+  }
+  let agents = [];
+  try {
+    const cfg = JSON.parse(readFileSync9(join11(brainDir, "config.json"), "utf8"));
+    agents = cfg.agents ?? [];
+  } catch {
+    agents = AGENTS.map((a) => a.value);
+  }
+  console.log("");
+  if (!opts.yes) {
+    console.log(`  ${chalk11.yellow("!")}  This will remove MindLink from this project:`);
+    console.log(`     ${chalk11.dim("\xB7 .brain/              (all memory files)")}`);
+    for (const v of agents) {
+      const agent = AGENTS.find((a) => a.value === v);
+      if (agent) console.log(`     ${chalk11.dim("\xB7 " + agent.destFile)}`);
+    }
+    if (agents.includes("claude")) {
+      console.log(`     ${chalk11.dim("\xB7 .claude/settings.json  (hook)")}`);
+    }
+    console.log("");
+    console.log(`  ${chalk11.dim("The mindlink CLI itself is NOT removed.")}`);
+    console.log(`  ${chalk11.dim("To remove the CLI: npm uninstall -g mindlink")}`);
+    console.log("");
+    console.log(`  ${chalk11.dim("Lighter options:")}`);
+    console.log(`  ${chalk11.dim("  mindlink clear  \u2014 fresh session only (keeps all memory)")}`);
+    console.log(`  ${chalk11.dim("  mindlink reset  \u2014 wipe memory (keeps MindLink installed)")}`);
+    console.log("");
+    const action = await select4({
+      message: "Remove MindLink from this project?",
+      options: [
+        { value: "remove", label: "Yes, remove everything listed above" },
+        { value: "cancel", label: "Cancel" }
+      ]
+    });
+    if (isCancel5(action) || action === "cancel") {
+      cancel5("Cancelled.");
+      console.log("");
+      return;
+    }
+    console.log("");
+  }
+  const removed = [];
+  const errors = [];
+  try {
+    rmSync(brainDir, { recursive: true, force: true });
+    removed.push(".brain/");
+  } catch (err) {
+    errors.push(`.brain/: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  for (const v of agents) {
+    const agent = AGENTS.find((a) => a.value === v);
+    if (!agent) continue;
+    const destPath = join11(projectPath, agent.destFile);
+    if (existsSync9(destPath)) {
+      try {
+        unlinkSync2(destPath);
+        removed.push(agent.destFile);
+      } catch (err) {
+        errors.push(`${agent.destFile}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  if (agents.includes("claude")) {
+    const hookPath = join11(projectPath, ".claude", "settings.json");
+    if (existsSync9(hookPath)) {
+      try {
+        unlinkSync2(hookPath);
+        removed.push(".claude/settings.json");
+      } catch {
+      }
+    }
+  }
+  for (const f of removed) console.log(`  ${chalk11.green("\u2713")}  ${f} removed.`);
+  for (const e of errors) console.log(`  ${chalk11.red("\u2717")}  ${e}`);
+  console.log("");
+  console.log(`  ${chalk11.dim("MindLink removed from this project.")}`);
+  console.log(`  ${chalk11.dim("To remove the CLI itself: npm uninstall -g mindlink")}`);
+  console.log("");
+});
+
+// src/commands/export.ts
+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 existsSync10, readdirSync as readdirSync2 } from "fs";
+import { join as join12, 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", `
+What gets exported:
+  - .brain/MEMORY.md   \u2014 permanent project facts
+  - .brain/SESSION.md  \u2014 current session state
+  - .brain/SHARED.md   \u2014 shared context across sessions
+  - .brain/LOG.md      \u2014 full session history
+  - .brain/config.json \u2014 settings (excluded by default; use --include-agents for agent files)
+
+Use cases:
+  Onboard a new teammate  \u2014 send them the zip; they run: mindlink import brain.zip
+  Back up before reset    \u2014 export first, then mindlink reset
+  Share project context   \u2014 hand off to a consultant without giving repo access
+
+Examples:
+  mindlink export
+  mindlink export --output ~/Desktop
+  mindlink export --output ~/Desktop/my-app-brain.zip
+  mindlink export --include-agents
+  `).action(async (opts) => {
+  const projectPath = resolve10(process.cwd());
+  const brainDir = join12(projectPath, BRAIN_DIR);
+  if (!existsSync10(brainDir)) {
+    console.log("");
+    console.log(`  ${chalk12.red("\u2717")}  No .brain/ found in this directory.`);
+    console.log(`     Run ${chalk12.cyan("mindlink init")} to get started.`);
+    console.log("");
+    process.exit(1);
+  }
+  console.log("");
+  const projectName = basename3(projectPath);
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const defaultFilename = `${projectName}-brain-${date}.zip`;
+  let outputPath;
+  if (opts.output) {
+    const given = resolve10(opts.output);
+    if (existsSync10(given) && !given.endsWith(".zip")) {
+      outputPath = join12(given, defaultFilename);
+    } else {
+      outputPath = given;
+    }
+  } else if (process.stdin.isTTY) {
+    const answer = await text2({
+      message: "Where should the zip be saved?",
+      placeholder: projectPath,
+      initialValue: projectPath,
+      hint: `default filename: ${defaultFilename}`
+    });
+    if (isCancel6(answer)) {
+      cancel6("Cancelled.");
+      process.exit(0);
+    }
+    const dest = resolve10(answer);
+    if (!dest.endsWith(".zip")) {
+      outputPath = join12(dest, defaultFilename);
+    } else {
+      outputPath = dest;
+    }
+  } else {
+    outputPath = join12(projectPath, defaultFilename);
+  }
+  const zip = new AdmZip();
+  const brainFiles = ["MEMORY.md", "SESSION.md", "SHARED.md", "LOG.md"];
+  const included = [];
+  const skipped = [];
+  for (const file of brainFiles) {
+    const filePath = join12(brainDir, file);
+    if (existsSync10(filePath)) {
+      zip.addLocalFile(filePath, ".brain");
+      included.push(`.brain/${file}`);
+    } else {
+      skipped.push(`.brain/${file}`);
+    }
+  }
+  const archiveFiles = readdirSync2(brainDir).filter((f) => /^LOG-\d{4}-\d{2}-\d{2}\.md$/.test(f));
+  for (const file of archiveFiles) {
+    zip.addLocalFile(join12(brainDir, file), ".brain");
+    included.push(`.brain/${file}`);
+  }
+  if (opts.includeAgents) {
+    for (const agent of AGENTS) {
+      const agentPath = join12(projectPath, agent.destFile);
+      if (existsSync10(agentPath)) {
+        const dir = agent.destFile.includes("/") ? agent.destFile.split("/").slice(0, -1).join("/") : "";
+        zip.addLocalFile(agentPath, dir);
+        included.push(agent.destFile);
+      }
+    }
+  }
+  try {
+    zip.writeZip(outputPath);
+  } catch (err) {
+    console.log(`  ${chalk12.red("\u2717")}  Could not write zip: ${err instanceof Error ? err.message : String(err)}`);
+    console.log("");
+    process.exit(1);
+  }
+  for (const f of included) console.log(`  ${chalk12.green("\u2713")}  ${f}`);
+  if (skipped.length > 0) {
+    for (const f of skipped) console.log(`  ${chalk12.dim("\u2013")}  ${f} ${chalk12.dim("(not found, skipped)")}`);
+  }
+  console.log("");
+  console.log(`  ${chalk12.green("\u2713")}  Exported to: ${chalk12.bold(outputPath)}`);
+  console.log("");
+  console.log(`  ${chalk12.dim("To import on another machine or project:")}`);
+  console.log(`  ${chalk12.cyan(`mindlink import ${basename3(outputPath)}`)}`);
+  console.log("");
+});
+
+// src/commands/import.ts
+import { Command as Command12 } from "commander";
+import { select as select5, isCancel as isCancel7, cancel as cancel7 } from "@clack/prompts";
+import chalk13 from "chalk";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3 } from "fs";
+import { join as join13, resolve as resolve11, extname } from "path";
+import AdmZip2 from "adm-zip";
+var importCommand = new Command12("import").description("Import a MindLink memory zip into the current project").argument("<file>", "Path to the .zip file exported by mindlink export").option("-y, --yes", "Skip confirmation and overwrite existing memory").addHelpText("after", `
+What gets imported:
+  All .brain/ files found in the zip (MEMORY.md, SESSION.md, SHARED.md, LOG.md,
+  and any LOG archive files). Agent instruction files are also imported if the zip
+  contains them.
+
+If .brain/ already exists, you will be asked whether to:
+  Merge     \u2014 import only files that don't exist yet (keeps your current memory)
+  Overwrite \u2014 replace everything (use when onboarding from a teammate's export)
+  Cancel    \u2014 do nothing
+
+Use cases:
+  Onboard on a new machine \u2014 copy the zip, run: mindlink import brain.zip
+  Restore from backup      \u2014 mindlink import my-app-brain-2026-04-10.zip
+  Accept a colleague's brain \u2014 merge their context into your project
+
+Examples:
+  mindlink import my-app-brain-2026-04-10.zip
+  mindlink import ~/Desktop/my-app-brain-2026-04-10.zip --yes
+  `).action(async (file, opts) => {
+  const projectPath = resolve11(process.cwd());
+  const brainDir = join13(projectPath, BRAIN_DIR);
+  const zipPath = resolve11(file);
+  console.log("");
+  if (!existsSync11(zipPath)) {
+    console.log(`  ${chalk13.red("\u2717")}  File not found: ${zipPath}`);
+    console.log("");
+    process.exit(1);
+  }
+  if (extname(zipPath) !== ".zip") {
+    console.log(`  ${chalk13.red("\u2717")}  Expected a .zip file. Got: ${zipPath}`);
+    console.log("");
+    process.exit(1);
+  }
+  let zip;
+  try {
+    zip = new AdmZip2(zipPath);
+  } catch (err) {
+    console.log(`  ${chalk13.red("\u2717")}  Could not read zip: ${err instanceof Error ? err.message : String(err)}`);
+    console.log("");
+    process.exit(1);
+  }
+  const entries = zip.getEntries();
+  const brainEntries = entries.filter((e) => e.entryName.startsWith(".brain/") && !e.isDirectory);
+  if (brainEntries.length === 0) {
+    console.log(`  ${chalk13.red("\u2717")}  This zip doesn't contain any .brain/ files.`);
+    console.log(`     Make sure it was created with ${chalk13.cyan("mindlink export")}.`);
+    console.log("");
+    process.exit(1);
+  }
+  let mode = "overwrite";
+  if (existsSync11(brainDir)) {
+    if (opts.yes) {
+      mode = "overwrite";
+    } else {
+      console.log(`  ${chalk13.yellow("!")}  .brain/ already exists in this project.`);
+      console.log("");
+      const action = await select5({
+        message: "How should the import handle existing memory?",
+        options: [
+          { value: "merge", label: "Merge", hint: "add files that don't exist yet \u2014 keep your current memory" },
+          { value: "overwrite", label: "Overwrite", hint: "replace everything with the imported version" },
+          { value: "cancel", label: "Cancel", hint: "" }
+        ]
+      });
+      if (isCancel7(action) || action === "cancel") {
+        cancel7("Cancelled.");
+        console.log("");
+        return;
+      }
+      mode = action;
+      console.log("");
+    }
+  }
+  mkdirSync3(brainDir, { recursive: true });
+  const written = [];
+  const skipped = [];
+  for (const entry of entries) {
+    if (entry.isDirectory) continue;
+    const destPath = join13(projectPath, entry.entryName);
+    const destDir = join13(projectPath, entry.entryName.split("/").slice(0, -1).join("/"));
+    if (mode === "merge" && existsSync11(destPath)) {
+      skipped.push(entry.entryName);
+      continue;
+    }
+    mkdirSync3(destDir, { recursive: true });
+    zip.extractEntryTo(entry, destDir, false, true);
+    written.push(entry.entryName);
+  }
+  for (const f of written) console.log(`  ${chalk13.green("\u2713")}  ${f}`);
+  for (const f of skipped) console.log(`  ${chalk13.dim("\u2013")}  ${f} ${chalk13.dim("(already exists, kept)")}`);
+  console.log("");
+  if (written.length === 0) {
+    console.log(`  ${chalk13.dim("Nothing imported \u2014 all files already exist (merge mode).")}`);
+  } else {
+    console.log(`  ${chalk13.green("\u2713")}  Brain transplant complete. Your AI wakes up knowing everything.`);
+    if (!existsSync11(join13(brainDir, "../CLAUDE.md")) && !existsSync11(join13(brainDir, "../CURSOR.md"))) {
+      console.log(`  ${chalk13.dim("No agent instruction files found \u2014 run mindlink init to wire them up.")}`);
+    }
+  }
+  console.log("");
+});
+
+// src/commands/doctor.ts
+import { Command as Command13 } from "commander";
+import chalk14 from "chalk";
+import { existsSync as existsSync12, readFileSync as readFileSync10, statSync as statSync3, readdirSync as readdirSync3 } from "fs";
+import { join as join14, resolve as resolve12 } from "path";
+var CORE_LINE_LIMIT = 50;
+var CORE_WARN_THRESHOLD = 40;
+function ok(label, detail) {
+  return { status: "ok", label, detail };
+}
+function warn(label, detail) {
+  return { status: "warn", label, detail };
+}
+function fail(label, detail) {
+  return { status: "fail", label, detail };
+}
+function info(label, detail) {
+  return { status: "info", label, detail };
+}
+function icon(status) {
+  switch (status) {
+    case "ok":
+      return chalk14.green("\u2713");
+    case "warn":
+      return chalk14.yellow("!");
+    case "fail":
+      return chalk14.red("\u2717");
+    case "info":
+      return chalk14.dim("\xB7");
+  }
+}
+var doctorCommand = new Command13("doctor").description("Check that your MindLink setup is healthy").addHelpText("after", `
+What gets checked:
+  .brain/        \u2014 exists and contains all expected files
+  MEMORY.md      \u2014 Core has content; warns if Core is getting too long to reliably read
+  SESSION.md     \u2014 has content (agent is updating it)
+  LOG.md         \u2014 session count, how far back history goes, warns when oldest sessions near rotation
+  Agent files    \u2014 instruction files exist per your config.json
+  Hook           \u2014 .claude/settings.json exists (if Claude Code is configured)
+
+Examples:
+  mindlink doctor
+  `).action(() => {
+  const projectPath = resolve12(process.cwd());
+  const brainDir = join14(projectPath, BRAIN_DIR);
+  console.log("");
+  console.log(`  ${chalk14.bold("\u25C9 MindLink Doctor")}`);
+  console.log(`  ${chalk14.dim(projectPath)}`);
+  console.log("");
+  const checks = [];
+  let failCount = 0;
+  let warnCount = 0;
+  if (!existsSync12(brainDir)) {
+    checks.push(fail(".brain/ missing", `Run ${chalk14.cyan("mindlink init")} to get started.`));
+    printChecks(checks);
+    process.exit(1);
+  }
+  checks.push(ok(".brain/ found"));
+  const configPath = join14(brainDir, "config.json");
+  let config = {};
+  if (!existsSync12(configPath)) {
+    checks.push(warn("config.json missing", `Run ${chalk14.cyan("mindlink config")} to repair.`));
+  } else {
+    try {
+      config = JSON.parse(readFileSync10(configPath, "utf8"));
+      checks.push(ok("config.json valid"));
+    } catch {
+      checks.push(warn("config.json unreadable", "File may be corrupted \u2014 delete and re-run mindlink init."));
+    }
+  }
+  const memoryPath = join14(brainDir, "MEMORY.md");
+  if (!existsSync12(memoryPath)) {
+    checks.push(fail("MEMORY.md missing", `Run ${chalk14.cyan("mindlink init")} to recreate it.`));
+  } else {
+    const memoryMd = readFileSync10(memoryPath, "utf8");
+    const coreSection = extractSection(memoryMd, "Core");
+    const coreLines = coreSection.split("\n").filter((l) => l.trim().length > 0 && !l.startsWith("<!--")).length;
+    if (coreLines === 0) {
+      checks.push(warn("MEMORY.md Core is empty", "Your AI has no permanent facts yet \u2014 ask it to fill in MEMORY.md after your next session."));
+    } else if (coreLines >= CORE_LINE_LIMIT) {
+      checks.push(warn(
+        "MEMORY.md Core is getting too long",
+        "Ask your AI to consolidate \u2014 Core is read every session start, so keep it tight."
+      ));
+    } else if (coreLines >= CORE_WARN_THRESHOLD) {
+      checks.push(warn(
+        "MEMORY.md Core is getting long",
+        "Consider asking your AI to consolidate \u2014 Core is read on every session start."
+      ));
+    } else {
+      checks.push(ok("MEMORY.md Core has content"));
+    }
+  }
+  const sessionPath = join14(brainDir, "SESSION.md");
+  if (!existsSync12(sessionPath)) {
+    checks.push(fail("SESSION.md missing", `Run ${chalk14.cyan("mindlink init")} to recreate it.`));
+  } else {
+    const sessionMd = readFileSync10(sessionPath, "utf8");
+    const hasContent = sessionMd.split("\n").some((l) => l.trim().length > 0 && !l.startsWith("<!--") && !l.startsWith("#"));
+    const mtime = statSync3(sessionPath).mtime;
+    const age = relativeTime(mtime);
+    if (!hasContent) {
+      checks.push(warn("SESSION.md has no content yet", "Start an AI session \u2014 it will fill this in automatically."));
+    } else {
+      checks.push(ok(`SESSION.md \u2014 updated ${age}`));
+    }
+  }
+  const logPath = join14(brainDir, "LOG.md");
+  if (!existsSync12(logPath)) {
+    checks.push(fail("LOG.md missing", `Run ${chalk14.cyan("mindlink init")} to recreate it.`));
+  } else {
+    const logMd = readFileSync10(logPath, "utf8");
+    const entries = parseLogEntries(logMd);
+    const entryCount = entries.length;
+    const maxEntries = config.maxLogEntries ?? 50;
+    if (entryCount === 0) {
+      checks.push(info("LOG.md \u2014 no sessions yet, start your first AI session"));
+    } else {
+      const newestHeading = entries[entries.length - 1].heading;
+      const oldestHeading = entries[0].heading;
+      const remaining = maxEntries - entryCount;
+      if (remaining <= 3 && remaining > 0) {
+        checks.push(warn(
+          `LOG.md \u2014 ${entryCount}/${maxEntries} sessions, ${remaining} until oldest start archiving`,
+          `Oldest session on record: ${oldestHeading} \u2014 it will be archived soon. Important decisions belong in MEMORY.md where they never rotate out.`
+        ));
+      } else if (remaining <= 0) {
+        checks.push(warn(
+          `LOG.md \u2014 at ${maxEntries}-session limit, oldest are being archived`,
+          `Oldest session on record: ${oldestHeading}. Anything important should be in MEMORY.md.`
+        ));
+      } else {
+        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));
+    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`));
+    }
+  }
+  const configuredAgents = config.agents ?? [];
+  if (configuredAgents.length === 0) {
+    checks.push(warn("No agents configured", `Run ${chalk14.cyan("mindlink config")} \u2192 Agent instruction files.`));
+  } else {
+    for (const agentValue of configuredAgents) {
+      const agent = AGENTS.find((a) => a.value === agentValue);
+      if (!agent) continue;
+      const destPath = join14(projectPath, agent.destFile);
+      if (!existsSync12(destPath)) {
+        checks.push(fail(`${agent.destFile} missing`, `Run ${chalk14.cyan("mindlink config")} \u2192 Agent instruction files to recreate.`));
+      } else {
+        checks.push(ok(`${agent.destFile} \u2014 ${agent.label}`));
+      }
+    }
+  }
+  if (configuredAgents.includes("claude")) {
+    const hookPath = join14(projectPath, ".claude", "settings.json");
+    if (!existsSync12(hookPath)) {
+      checks.push(warn(
+        ".claude/settings.json missing",
+        `Claude Code won't auto-reload after context compaction. Run ${chalk14.cyan("mindlink config")} \u2192 Agent instruction files to restore.`
+      ));
+    } else {
+      try {
+        const settings = JSON.parse(readFileSync10(hookPath, "utf8"));
+        const hasHook = settings?.hooks?.UserPromptSubmit != null;
+        if (!hasHook) {
+          checks.push(warn(".claude/settings.json exists but MindLink hook not found", "Hook may have been removed \u2014 check the file manually."));
+        } else {
+          checks.push(ok(".claude/settings.json \u2014 UserPromptSubmit hook active"));
+        }
+      } catch {
+        checks.push(warn(".claude/settings.json is not valid JSON", "Fix or delete it to restore the hook."));
+      }
+    }
+  }
+  if (config.gitTracking === false) {
+    checks.push(info(".brain/ is excluded from git (personal memory only)"));
+  } else if (config.gitTracking === true) {
+    checks.push(info(".brain/ is committed to git (shared team memory)"));
+  }
+  for (const c of checks) {
+    if (c.status === "fail") failCount++;
+    if (c.status === "warn") warnCount++;
+  }
+  printChecks(checks);
+  if (failCount > 0) {
+    console.log(`  ${chalk14.red.bold(`${failCount} problem${failCount !== 1 ? "s" : ""} found`)} \u2014 fix the issues above and re-run ${chalk14.cyan("mindlink doctor")}.`);
+  } else if (warnCount > 0) {
+    console.log(`  ${chalk14.yellow.bold(`${warnCount} warning${warnCount !== 1 ? "s" : ""}`)}, no critical issues. Your AI will still work.`);
+  } else {
+    console.log(`  ${chalk14.green.bold("All good.")} Your AI has a healthy brain.`);
+  }
+  console.log("");
+  if (failCount > 0) process.exit(1);
+});
+function printChecks(checks) {
+  for (const c of checks) {
+    const prefix = `  ${icon(c.status)}  `;
+    console.log(`${prefix}${c.label}`);
+    if (c.detail) {
+      console.log(`     ${chalk14.dim(c.detail)}`);
+    }
+  }
+  console.log("");
+}
+
+// src/cli.ts
+var program = new Command14();
+program.name("mindlink").description("Give your AI a brain.").version("1.0.0", "-v, --version");
+program.addCommand(initCommand);
+program.addCommand(statusCommand);
+program.addCommand(logCommand);
+program.addCommand(clearCommand);
+program.addCommand(resetCommand);
+program.addCommand(configCommand);
+program.addCommand(syncCommand);
+program.addCommand(updateCommand);
+program.addCommand(summaryCommand);
+program.addCommand(uninstallCommand);
+program.addCommand(exportCommand);
+program.addCommand(importCommand);
+program.addCommand(doctorCommand);
+program.on("command:*", (operands) => {
+  const unknown = operands[0];
+  const known = ["init", "status", "log", "clear", "reset", "config", "sync", "update", "summary", "uninstall", "export", "import", "doctor"];
+  function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from(
+      { length: m + 1 },
+      (_, i) => Array.from({ length: n + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+    );
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+      }
+    }
+    return dp[m][n];
+  }
+  const closest = known.map((cmd) => ({ cmd, dist: levenshtein(unknown, cmd) })).sort((a, b) => a.dist - b.dist)[0];
+  console.log("");
+  console.log(`  ${chalk15.red("\u2717")}  Unknown command: ${chalk15.bold(unknown)}`);
+  if (closest && closest.dist <= 3) {
+    console.log(`     Did you mean ${chalk15.cyan("mindlink " + closest.cmd)}?`);
+  }
+  console.log(`     Run ${chalk15.cyan("mindlink --help")} to see all commands.`);
+  console.log("");
+  process.exit(1);
+});
+program.parse();
+//# sourceMappingURL=cli.js.map