npm - @memories.sh/cli - Versions diffs - 0.3.0 → 0.4.0 - Mend

@memories.sh/cli 0.3.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +837 -550
package/package.json +2 -1

package/dist/index.js CHANGED Viewed

@@ -32,7 +32,8 @@ import { Command as Command29 } from "commander";
 // src/commands/init.ts
 import { Command } from "commander";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
+import { confirm, checkbox } from "@inquirer/prompts";
 // src/lib/auth.ts
 import { readFile, writeFile, mkdir, unlink } from "fs/promises";
@@ -76,8 +77,123 @@ function getApiClient(auth) {
   };
 }
-// src/lib/ui.ts
+// src/lib/setup.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
 import chalk from "chalk";
+var TOOLS = [
+  {
+    name: "Cursor",
+    configDir: ".cursor",
+    mcpConfigPath: ".cursor/mcp.json",
+    mcpConfigFormat: "cursor",
+    instructionFile: ".cursor/rules/memories.mdc",
+    generateCmd: "cursor"
+  },
+  {
+    name: "Claude Code",
+    configDir: ".claude",
+    mcpConfigPath: ".mcp.json",
+    mcpConfigFormat: "claude",
+    instructionFile: "CLAUDE.md",
+    generateCmd: "claude"
+  },
+  {
+    name: "Windsurf",
+    configDir: ".windsurf",
+    mcpConfigPath: ".windsurf/mcp.json",
+    mcpConfigFormat: "cursor",
+    instructionFile: ".windsurf/rules/memories.md",
+    generateCmd: "windsurf"
+  },
+  {
+    name: "VS Code",
+    configDir: ".vscode",
+    mcpConfigPath: ".vscode/mcp.json",
+    mcpConfigFormat: "vscode",
+    instructionFile: ".github/copilot-instructions.md",
+    generateCmd: "copilot"
+  }
+];
+var MEMORIES_MCP_CONFIG = {
+  command: "npx",
+  args: ["-y", "@memories.sh/cli", "serve"]
+};
+function getAllTools() {
+  return [...TOOLS];
+}
+function detectTools(cwd = process.cwd()) {
+  const home = homedir2();
+  const detected = [];
+  for (const tool of TOOLS) {
+    const projectConfigDir = join2(cwd, tool.configDir);
+    const projectMcpPath = join2(cwd, tool.mcpConfigPath);
+    const projectInstructionPath = join2(cwd, tool.instructionFile);
+    const globalConfigDir = join2(home, tool.configDir);
+    const globalMcpPath = join2(home, tool.mcpConfigPath);
+    const hasProjectConfig = existsSync2(projectConfigDir);
+    const hasGlobalConfig = existsSync2(globalConfigDir);
+    if (hasProjectConfig || hasGlobalConfig) {
+      detected.push({
+        tool,
+        hasConfig: hasProjectConfig || hasGlobalConfig,
+        hasMcp: existsSync2(projectMcpPath) || existsSync2(globalMcpPath),
+        hasInstructions: existsSync2(projectInstructionPath),
+        globalConfig: !hasProjectConfig && hasGlobalConfig
+      });
+    }
+  }
+  return detected;
+}
+async function setupMcp(tool, options = {}) {
+  const { cwd = process.cwd(), global: useGlobal = false, dryRun = false } = options;
+  const home = homedir2();
+  const configPath = useGlobal ? join2(home, tool.mcpConfigPath) : join2(cwd, tool.mcpConfigPath);
+  try {
+    let config = {};
+    if (existsSync2(configPath)) {
+      const content = await readFile2(configPath, "utf-8");
+      config = JSON.parse(content);
+    }
+    const serversKey = tool.mcpConfigFormat === "vscode" ? "servers" : "mcpServers";
+    const servers = config[serversKey] ?? {};
+    if (servers.memories) {
+      return {
+        success: true,
+        message: "MCP already configured",
+        path: configPath
+      };
+    }
+    config[serversKey] = {
+      ...servers,
+      memories: MEMORIES_MCP_CONFIG
+    };
+    if (dryRun) {
+      return {
+        success: true,
+        message: `Would add MCP config to ${configPath}`,
+        path: configPath
+      };
+    }
+    await mkdir2(dirname(configPath), { recursive: true });
+    await writeFile2(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return {
+      success: true,
+      message: "MCP configured",
+      path: configPath
+    };
+  } catch (error2) {
+    return {
+      success: false,
+      message: `Failed to setup MCP: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+    };
+  }
+}
+// src/lib/ui.ts
+import chalk2 from "chalk";
 import figlet from "figlet";
 import gradient from "gradient-string";
 import boxen from "boxen";
@@ -88,25 +204,25 @@ function banner() {
     horizontalLayout: "fitted"
   });
   console.log(memoriesGradient(text));
-  console.log(chalk.dim("  One memory, every AI tool\n"));
+  console.log(chalk2.dim("  One memory, every AI tool\n"));
 }
 function success(message) {
-  console.log(chalk.green("\u2713") + " " + message);
+  console.log(chalk2.green("\u2713") + " " + message);
 }
 function warn(message) {
-  console.log(chalk.yellow("\u26A0") + " " + message);
+  console.log(chalk2.yellow("\u26A0") + " " + message);
 }
 function error(message) {
-  console.log(chalk.red("\u2717") + " " + message);
+  console.log(chalk2.red("\u2717") + " " + message);
 }
 function info(message) {
-  console.log(chalk.blue("\u2139") + " " + message);
+  console.log(chalk2.blue("\u2139") + " " + message);
 }
 function step(num, total, message) {
-  console.log(chalk.dim(`[${num}/${total}]`) + " " + message);
+  console.log(chalk2.dim(`[${num}/${total}]`) + " " + message);
 }
 function dim(message) {
-  console.log(chalk.dim("  " + message));
+  console.log(chalk2.dim("  " + message));
 }
 function box(content, title) {
   console.log(
@@ -121,33 +237,28 @@ function box(content, title) {
   );
 }
 function nextSteps(steps) {
-  const content = steps.map((s) => chalk.dim("\u2192 ") + s).join("\n");
-  box(content, chalk.bold("Next steps"));
+  const content = steps.map((s) => chalk2.dim("\u2192 ") + s).join("\n");
+  box(content, chalk2.bold("Next steps"));
 }
 function proFeature(feature) {
   console.log(
-    chalk.yellow("\u2B50") + " " + chalk.dim(`${feature} requires `) + chalk.bold("Pro") + chalk.dim(". Run ") + chalk.cyan("memories login") + chalk.dim(" to upgrade.")
+    chalk2.yellow("\u2B50") + " " + chalk2.dim(`${feature} requires `) + chalk2.bold("Pro") + chalk2.dim(". Run ") + chalk2.cyan("memories login") + chalk2.dim(" to upgrade.")
   );
 }
 // src/commands/init.ts
-var SUPPORTED_TOOLS = [
-  { name: "Cursor", cmd: "cursor" },
-  { name: "Claude Code", cmd: "claude" },
-  { name: "GitHub Copilot", cmd: "copilot" },
-  { name: "Windsurf", cmd: "windsurf" },
-  { name: "Gemini CLI", cmd: "gemini" }
-];
-var initCommand = new Command("init").description("Initialize memories - one place for all your AI coding tools").option("-g, --global", "Initialize global rules (apply to all projects)").option("-r, --rule <rule>", "Add an initial rule", (val, acc) => [...acc, val], []).action(async (opts) => {
+import { execSync } from "child_process";
+var initCommand = new Command("init").description("Initialize memories - set up MCP and instruction files for your AI tools").option("-g, --global", "Initialize global rules (apply to all projects)").option("-r, --rule <rule>", "Add an initial rule", (val, acc) => [...acc, val], []).option("--skip-mcp", "Skip MCP configuration").option("--skip-generate", "Skip generating instruction files").option("-y, --yes", "Auto-confirm all prompts").action(async (opts) => {
   try {
     banner();
-    console.log(chalk2.dim("  One place for your rules. Works with every tool.\n"));
-    step(1, 3, "Setting up rule storage...");
+    console.log(chalk3.dim("  One place for your rules. Works with every tool.\n"));
+    step(1, 4, "Setting up local storage...");
     await getDb();
     const configDir = getConfigDir();
-    dim(`Location: ${configDir}/local.db`);
-    step(2, 3, "Detecting scope...");
+    dim(`Database: ${configDir}/local.db`);
+    step(2, 4, "Detecting scope...");
     let useGlobal = opts.global;
+    const cwd = process.cwd();
     if (!useGlobal) {
       const projectId = getProjectId();
       const gitRoot = getGitRoot();
@@ -158,48 +269,123 @@ var initCommand = new Command("init").description("Initialize memories - one pla
         success("Project scope detected");
         dim(`Project: ${projectId}`);
         dim(`Root: ${gitRoot}`);
-        dim("Use --global for rules that apply everywhere");
       }
     } else {
       success("Global scope (rules apply to all projects)");
     }
-    step(3, 3, "Supported tools...");
-    const toolList = SUPPORTED_TOOLS.map((t) => t.name).join(", ");
-    success(`${toolList}, + any MCP client`);
+    step(3, 4, "Detecting AI coding tools...");
+    let detected = detectTools(cwd);
+    if (detected.length === 0) {
+      dim("No AI coding tools auto-detected.");
+      if (!opts.skipMcp) {
+        const allTools = getAllTools();
+        const selected = await checkbox({
+          message: "Which tools do you want to configure?",
+          choices: allTools.map((t) => ({
+            name: t.name,
+            value: t,
+            checked: false
+          }))
+        });
+        if (selected.length > 0) {
+          detected = selected.map((tool) => ({
+            tool,
+            hasConfig: false,
+            hasMcp: false,
+            hasInstructions: false,
+            globalConfig: false
+          }));
+        }
+      }
+    }
+    if (detected.length === 0) {
+      dim("No tools selected. MCP will work with any tool that supports it.");
+    } else {
+      for (const d of detected) {
+        const scope = d.globalConfig ? chalk3.dim(" [global]") : "";
+        const mcpStatus = d.hasMcp ? chalk3.green("\u2713 MCP") : chalk3.dim("\u25CB MCP");
+        const rulesStatus = d.hasInstructions ? chalk3.green("\u2713 Rules") : chalk3.dim("\u25CB Rules");
+        console.log(`  ${chalk3.white(d.tool.name)}${scope} ${mcpStatus} ${rulesStatus}`);
+      }
+      if (!opts.skipMcp) {
+        const toolsNeedingMcp = detected.filter((d) => !d.hasMcp);
+        if (toolsNeedingMcp.length > 0) {
+          console.log("");
+          const shouldSetupMcp = opts.yes || await confirm({
+            message: `Configure MCP for ${toolsNeedingMcp.map((d) => d.tool.name).join(", ")}?`,
+            default: true
+          });
+          if (shouldSetupMcp) {
+            for (const d of toolsNeedingMcp) {
+              const result = await setupMcp(d.tool, {
+                cwd,
+                global: d.globalConfig
+              });
+              if (result.success) {
+                success(`${d.tool.name}: ${result.message}`);
+                if (result.path) dim(`  \u2192 ${result.path}`);
+              } else {
+                warn(`${d.tool.name}: ${result.message}`);
+              }
+            }
+          }
+        }
+      }
+      if (!opts.skipGenerate) {
+        const toolsNeedingInstructions = detected.filter((d) => !d.hasInstructions);
+        const memories = await listMemories({ limit: 1 });
+        if (toolsNeedingInstructions.length > 0 && memories.length > 0) {
+          console.log("");
+          const shouldGenerate = opts.yes || await confirm({
+            message: `Generate instruction files for ${toolsNeedingInstructions.map((d) => d.tool.name).join(", ")}?`,
+            default: true
+          });
+          if (shouldGenerate) {
+            for (const d of toolsNeedingInstructions) {
+              try {
+                execSync(`node ${process.argv[1]} generate ${d.tool.generateCmd} --force`, {
+                  cwd,
+                  stdio: "pipe"
+                });
+                success(`${d.tool.name}: Generated ${d.tool.instructionFile}`);
+              } catch {
+                warn(`${d.tool.name}: Failed to generate instructions`);
+              }
+            }
+          }
+        }
+      }
+    }
+    step(4, 4, "Finalizing...");
     if (opts.rule?.length) {
-      console.log("");
       info("Adding rules...");
       for (const rule of opts.rule) {
-        const memory = await addMemory(rule, {
+        await addMemory(rule, {
           type: "rule",
           global: useGlobal
         });
         dim(`+ ${rule}`);
       }
     }
-    console.log("");
     const auth = await readAuth();
     if (auth) {
-      success(`Syncing as ${chalk2.bold(auth.email)}`);
+      success(`Syncing as ${chalk3.bold(auth.email)}`);
     } else {
-      dim("Local only. Run " + chalk2.cyan("memories login") + " to sync across machines.");
+      dim("Local only. Run " + chalk3.cyan("memories login") + " to sync across machines.");
     }
     console.log("");
-    console.log(chalk2.bold("  Quick Start:"));
+    console.log(chalk3.bold("  Quick Start:"));
     console.log("");
-    console.log(chalk2.dim("  1. Add your rules:"));
-    console.log(`     ${chalk2.cyan("memories add --rule")} ${chalk2.dim('"Always use TypeScript strict mode"')}`);
-    console.log(`     ${chalk2.cyan("memories add --rule")} ${chalk2.dim('"Prefer functional components in React"')}`);
+    console.log(chalk3.dim("  Add rules:"));
+    console.log(`     ${chalk3.cyan("memories add --rule")} ${chalk3.dim('"Always use TypeScript strict mode"')}`);
     console.log("");
-    console.log(chalk2.dim("  2. Generate for your tools:"));
-    console.log(`     ${chalk2.cyan("memories generate cursor")}   ${chalk2.dim("\u2192 .cursor/rules/memories.mdc")}`);
-    console.log(`     ${chalk2.cyan("memories generate claude")}   ${chalk2.dim("\u2192 CLAUDE.md")}`);
-    console.log(`     ${chalk2.cyan("memories generate copilot")}  ${chalk2.dim("\u2192 .github/copilot-instructions.md")}`);
-    console.log(`     ${chalk2.cyan("memories generate all")}      ${chalk2.dim("\u2192 all tools at once")}`);
+    console.log(chalk3.dim("  Regenerate instruction files after adding rules:"));
+    console.log(`     ${chalk3.cyan("memories generate all")}`);
     console.log("");
-    console.log(chalk2.dim("  3. Switch tools anytime - your rules follow you."));
+    console.log(chalk3.dim("  Your rules will be available via MCP and in generated files."));
     console.log("");
   } catch (error2) {
+    if (error2.name === "ExitPromptError") return;
     error("Failed to initialize: " + (error2 instanceof Error ? error2.message : "Unknown error"));
     process.exit(1);
   }
@@ -207,7 +393,7 @@ var initCommand = new Command("init").description("Initialize memories - one pla
 // src/commands/add.ts
 import { Command as Command2 } from "commander";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 // src/lib/templates.ts
 import { input } from "@inquirer/prompts";
@@ -370,7 +556,7 @@ var addCommand = new Command2("add").description("Add a new memory").argument("[
     else if (opts.fact) type = "fact";
     else if (opts.type) {
       if (!VALID_TYPES.includes(opts.type)) {
-        console.error(chalk3.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES.join(", ")}`);
+        console.error(chalk4.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES.join(", ")}`);
         process.exit(1);
       }
       type = opts.type;
@@ -378,11 +564,11 @@ var addCommand = new Command2("add").description("Add a new memory").argument("[
     const memory = await addMemory(content, { tags, global: opts.global, type });
     const typeLabel = type === "rule" ? "Rule" : type === "decision" ? "Decision" : type === "fact" ? "Fact" : "Note";
     const scopeInfo = memory.scope === "global" ? "global" : "project";
-    success(`Stored ${chalk3.bold(typeLabel.toLowerCase())} ${chalk3.dim(memory.id)}`);
+    success(`Stored ${chalk4.bold(typeLabel.toLowerCase())} ${chalk4.dim(memory.id)}`);
     dim(`Scope: ${scopeInfo}${tags?.length ? ` \u2022 Tags: ${tags.join(", ")}` : ""}`);
     if (type === "rule") {
       console.log("");
-      dim(`Run ${chalk3.cyan("memories generate")} to update your IDE rule files`);
+      dim(`Run ${chalk4.cyan("memories generate")} to update your IDE rule files`);
     }
   } catch (error2) {
     error("Failed to add memory: " + (error2 instanceof Error ? error2.message : "Unknown error"));
@@ -392,7 +578,7 @@ var addCommand = new Command2("add").description("Add a new memory").argument("[
 // src/commands/recall.ts
 import { Command as Command3 } from "commander";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 var TYPE_ICONS = {
   rule: "\u{1F4CC}",
   decision: "\u{1F4A1}",
@@ -400,18 +586,18 @@ var TYPE_ICONS = {
   note: "\u{1F4DD}"
 };
 var TYPE_COLORS = {
-  rule: chalk4.yellow,
-  decision: chalk4.cyan,
-  fact: chalk4.green,
-  note: chalk4.white
+  rule: chalk5.yellow,
+  decision: chalk5.cyan,
+  fact: chalk5.green,
+  note: chalk5.white
 };
 function formatMemory(m, verbose) {
   const icon = TYPE_ICONS[m.type] || "\u{1F4DD}";
-  const colorFn = TYPE_COLORS[m.type] || chalk4.white;
-  const scope = m.scope === "global" ? chalk4.dim("G") : chalk4.dim("P");
-  const tags = m.tags ? chalk4.dim(` [${m.tags}]`) : "";
+  const colorFn = TYPE_COLORS[m.type] || chalk5.white;
+  const scope = m.scope === "global" ? chalk5.dim("G") : chalk5.dim("P");
+  const tags = m.tags ? chalk5.dim(` [${m.tags}]`) : "";
   if (verbose) {
-    return `${icon} ${scope} ${chalk4.dim(m.id)} ${colorFn(m.content)}${tags}`;
+    return `${icon} ${scope} ${chalk5.dim(m.id)} ${colorFn(m.content)}${tags}`;
   }
   return `${icon} ${colorFn(m.content)}`;
 }
@@ -425,11 +611,11 @@ var recallCommand = new Command3("recall").description("Recall context - get rul
         return;
       }
       if (rules2.length === 0) {
-        console.log(chalk4.dim("No rules defined."));
-        console.log(chalk4.dim('Add one with: memories add --rule "Your rule here"'));
+        console.log(chalk5.dim("No rules defined."));
+        console.log(chalk5.dim('Add one with: memories add --rule "Your rule here"'));
         return;
       }
-      console.log(chalk4.bold("Rules:"));
+      console.log(chalk5.bold("Rules:"));
       for (const rule of rules2) {
         console.log(formatMemory(rule, opts.verbose ?? false));
       }
@@ -444,26 +630,26 @@ var recallCommand = new Command3("recall").description("Recall context - get rul
       return;
     }
     if (rules.length > 0) {
-      console.log(chalk4.bold("Rules:"));
+      console.log(chalk5.bold("Rules:"));
       for (const rule of rules) {
         console.log(formatMemory(rule, opts.verbose ?? false));
       }
       console.log("");
     }
     if (memories.length > 0) {
-      console.log(chalk4.bold(query ? `Relevant to "${query}":` : "Recent memories:"));
+      console.log(chalk5.bold(query ? `Relevant to "${query}":` : "Recent memories:"));
       for (const m of memories) {
         console.log(formatMemory(m, opts.verbose ?? false));
       }
     } else if (query) {
-      console.log(chalk4.dim(`No memories found matching "${query}"`));
+      console.log(chalk5.dim(`No memories found matching "${query}"`));
     }
     if (rules.length === 0 && memories.length === 0) {
-      console.log(chalk4.dim("No memories found."));
-      console.log(chalk4.dim('Add some with: memories add "Your memory here"'));
+      console.log(chalk5.dim("No memories found."));
+      console.log(chalk5.dim('Add some with: memories add "Your memory here"'));
     }
   } catch (error2) {
-    console.error(chalk4.red("\u2717") + " Failed to recall:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk5.red("\u2717") + " Failed to recall:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -471,7 +657,7 @@ var recallCommand = new Command3("recall").description("Recall context - get rul
 // src/commands/prompt.ts
 import { Command as Command4 } from "commander";
 import { execFileSync } from "child_process";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 var VALID_TYPES2 = ["rule", "decision", "fact", "note"];
 function formatMarkdown(sections) {
   return sections.map(({ title, memories }) => {
@@ -514,7 +700,7 @@ var promptCommand = new Command4("prompt").description("Output memories formatte
   try {
     const format = opts.format ?? "markdown";
     if (!["markdown", "xml", "plain"].includes(format)) {
-      console.error(chalk5.red("\u2717") + ` Invalid format "${opts.format}". Use: markdown, xml, plain`);
+      console.error(chalk6.red("\u2717") + ` Invalid format "${opts.format}". Use: markdown, xml, plain`);
       process.exit(1);
     }
     const projectId = getProjectId() ?? void 0;
@@ -526,7 +712,7 @@ var promptCommand = new Command4("prompt").description("Output memories formatte
       for (const t of opts.include.split(",").map((s) => s.trim())) {
         const normalized = t.replace(/s$/, "");
         if (!VALID_TYPES2.includes(normalized)) {
-          console.error(chalk5.red("\u2717") + ` Invalid type "${t}". Valid: decisions, facts, notes`);
+          console.error(chalk6.red("\u2717") + ` Invalid type "${t}". Valid: decisions, facts, notes`);
           process.exit(1);
         }
         if (normalized !== "rule") extraTypes.push(normalized);
@@ -555,7 +741,7 @@ var promptCommand = new Command4("prompt").description("Output memories formatte
     }
     if (sections.length === 0) {
       if (!opts.quiet) {
-        console.error(chalk5.dim('No memories found. Add rules with: memories add --rule "Your rule"'));
+        console.error(chalk6.dim('No memories found. Add rules with: memories add --rule "Your rule"'));
       }
       return;
     }
@@ -575,26 +761,26 @@ var promptCommand = new Command4("prompt").description("Output memories formatte
       if (copied) {
         console.log(output);
         if (!opts.quiet) {
-          console.error(chalk5.green("\u2713") + " Copied to clipboard");
+          console.error(chalk6.green("\u2713") + " Copied to clipboard");
         }
       } else {
         console.log(output);
         if (!opts.quiet) {
-          console.error(chalk5.yellow("\u26A0") + " Could not copy to clipboard (unsupported platform)");
+          console.error(chalk6.yellow("\u26A0") + " Could not copy to clipboard (unsupported platform)");
         }
       }
     } else {
       console.log(output);
     }
   } catch (error2) {
-    console.error(chalk5.red("\u2717") + " Failed to generate prompt:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk6.red("\u2717") + " Failed to generate prompt:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/search.ts
 import { Command as Command5 } from "commander";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 var TYPE_ICONS2 = {
   rule: "\u{1F4CC}",
   decision: "\u{1F4A1}",
@@ -604,17 +790,17 @@ var TYPE_ICONS2 = {
 var VALID_TYPES3 = ["rule", "decision", "fact", "note"];
 function formatMemory2(m, score) {
   const icon = TYPE_ICONS2[m.type] || "\u{1F4DD}";
-  const scope = m.scope === "global" ? chalk6.dim("G") : chalk6.dim("P");
-  const tags = m.tags ? chalk6.dim(` [${m.tags}]`) : "";
-  const scoreStr = score !== void 0 ? chalk6.cyan(` (${Math.round(score * 100)}%)`) : "";
-  return `${icon} ${scope} ${chalk6.dim(m.id)}  ${m.content}${tags}${scoreStr}`;
+  const scope = m.scope === "global" ? chalk7.dim("G") : chalk7.dim("P");
+  const tags = m.tags ? chalk7.dim(` [${m.tags}]`) : "";
+  const scoreStr = score !== void 0 ? chalk7.cyan(` (${Math.round(score * 100)}%)`) : "";
+  return `${icon} ${scope} ${chalk7.dim(m.id)}  ${m.content}${tags}${scoreStr}`;
 }
 var searchCommand = new Command5("search").description("Search memories using full-text or semantic search").argument("<query>", "Search query").option("-l, --limit <n>", "Max results", "20").option("--type <type>", "Filter by type: rule, decision, fact, note").option("-g, --global", "Search only global memories").option("--project-only", "Search only project memories (exclude global)").option("-s, --semantic", "Use semantic (AI) search instead of keyword search").option("--json", "Output as JSON").action(async (query, opts) => {
   try {
     let types;
     if (opts.type) {
       if (!VALID_TYPES3.includes(opts.type)) {
-        console.error(chalk6.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES3.join(", ")}`);
+        console.error(chalk7.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES3.join(", ")}`);
         process.exit(1);
       }
       types = [opts.type];
@@ -628,7 +814,7 @@ var searchCommand = new Command5("search").description("Search memories using fu
       includeGlobal = false;
       projectId = getProjectId() ?? void 0;
       if (!projectId) {
-        console.log(chalk6.yellow("\u26A0") + " Not in a git repository. No project memories to search.");
+        console.log(chalk7.yellow("\u26A0") + " Not in a git repository. No project memories to search.");
         return;
       }
     }
@@ -636,7 +822,7 @@ var searchCommand = new Command5("search").description("Search memories using fu
       try {
         const { semanticSearch, isModelAvailable } = await import("./embeddings-6N2NZPRX.js");
         if (!await isModelAvailable()) {
-          console.log(chalk6.yellow("\u26A0") + " Loading embedding model for first time (this may take a moment)...");
+          console.log(chalk7.yellow("\u26A0") + " Loading embedding model for first time (this may take a moment)...");
         }
         const results = await semanticSearch(query, {
           limit: parseInt(opts.limit, 10),
@@ -647,11 +833,11 @@ var searchCommand = new Command5("search").description("Search memories using fu
           return;
         }
         if (results.length === 0) {
-          console.log(chalk6.dim(`No semantically similar memories found for "${query}"`));
-          console.log(chalk6.dim("Try running 'memories embed' to generate embeddings for existing memories."));
+          console.log(chalk7.dim(`No semantically similar memories found for "${query}"`));
+          console.log(chalk7.dim("Try running 'memories embed' to generate embeddings for existing memories."));
           return;
         }
-        console.log(chalk6.bold(`Semantic results for "${query}":`));
+        console.log(chalk7.bold(`Semantic results for "${query}":`));
         console.log("");
         for (const r of results) {
           const { getMemoryById: getMemoryById2 } = await import("./memory-B4NNFKXV.js");
@@ -660,12 +846,12 @@ var searchCommand = new Command5("search").description("Search memories using fu
             console.log(formatMemory2(m, r.score));
           }
         }
-        console.log(chalk6.dim(`
+        console.log(chalk7.dim(`
 ${results.length} results (semantic search)`));
         return;
       } catch (error2) {
-        console.error(chalk6.red("\u2717") + " Semantic search failed:", error2 instanceof Error ? error2.message : "Unknown error");
-        console.log(chalk6.dim("Falling back to keyword search..."));
+        console.error(chalk7.red("\u2717") + " Semantic search failed:", error2 instanceof Error ? error2.message : "Unknown error");
+        console.log(chalk7.dim("Falling back to keyword search..."));
       }
     }
     const memories = await searchMemories(query, {
@@ -680,30 +866,30 @@ ${results.length} results (semantic search)`));
       return;
     }
     if (memories.length === 0) {
-      console.log(chalk6.dim(`No memories found matching "${query}"`));
+      console.log(chalk7.dim(`No memories found matching "${query}"`));
       return;
     }
-    console.log(chalk6.bold(`Results for "${query}":`));
+    console.log(chalk7.bold(`Results for "${query}":`));
     console.log("");
     for (const m of memories) {
       console.log(formatMemory2(m));
     }
-    console.log(chalk6.dim(`
+    console.log(chalk7.dim(`
 ${memories.length} results`));
   } catch (error2) {
-    console.error(chalk6.red("\u2717") + " Failed to search:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk7.red("\u2717") + " Failed to search:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/list.ts
 import { Command as Command6 } from "commander";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 var TYPE_COLORS2 = {
-  rule: chalk7.blue,
-  decision: chalk7.yellow,
-  fact: chalk7.green,
-  note: chalk7.dim
+  rule: chalk8.blue,
+  decision: chalk8.yellow,
+  fact: chalk8.green,
+  note: chalk8.dim
 };
 var TYPE_LABELS = {
   rule: "rule",
@@ -718,12 +904,12 @@ function truncate(str, max) {
   return str.slice(0, max - 1) + "\u2026";
 }
 function formatMemory3(m) {
-  const typeColor = TYPE_COLORS2[m.type] ?? chalk7.dim;
+  const typeColor = TYPE_COLORS2[m.type] ?? chalk8.dim;
   const typeLabel = typeColor(TYPE_LABELS[m.type].padEnd(9));
-  const scope = m.scope === "global" ? chalk7.magenta("G") : chalk7.cyan("P");
-  const id = chalk7.dim(m.id);
+  const scope = m.scope === "global" ? chalk8.magenta("G") : chalk8.cyan("P");
+  const id = chalk8.dim(m.id);
   const content = truncate(m.content, MAX_CONTENT_WIDTH);
-  const tags = m.tags ? chalk7.dim(` [${m.tags}]`) : "";
+  const tags = m.tags ? chalk8.dim(` [${m.tags}]`) : "";
   return `  ${scope} ${typeLabel} ${id}  ${content}${tags}`;
 }
 var listCommand = new Command6("list").description("List memories").option("-l, --limit <n>", "Max results", "50").option("-t, --tags <tags>", "Filter by comma-separated tags").option("--type <type>", "Filter by type: rule, decision, fact, note").option("-g, --global", "Show only global memories").option("--project-only", "Show only project memories (exclude global)").option("--json", "Output as JSON").action(async (opts) => {
@@ -732,7 +918,7 @@ var listCommand = new Command6("list").description("List memories").option("-l,
     let types;
     if (opts.type) {
       if (!VALID_TYPES4.includes(opts.type)) {
-        console.error(chalk7.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES4.join(", ")}`);
+        console.error(chalk8.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES4.join(", ")}`);
         process.exit(1);
       }
       types = [opts.type];
@@ -746,7 +932,7 @@ var listCommand = new Command6("list").description("List memories").option("-l,
       includeGlobal = false;
       projectId = getProjectId() ?? void 0;
       if (!projectId) {
-        console.log(chalk7.yellow("\u26A0") + " Not in a git repository. No project memories to show.");
+        console.log(chalk8.yellow("\u26A0") + " Not in a git repository. No project memories to show.");
         return;
       }
     }
@@ -763,21 +949,21 @@ var listCommand = new Command6("list").description("List memories").option("-l,
       return;
     }
     if (memories.length === 0) {
-      console.log(chalk7.dim("No memories found."));
+      console.log(chalk8.dim("No memories found."));
       return;
     }
     const currentProject = getProjectId();
     if (currentProject && !opts.global) {
-      console.log(chalk7.dim(`  Project: ${currentProject}
+      console.log(chalk8.dim(`  Project: ${currentProject}
 `));
     }
     for (const m of memories) {
       console.log(formatMemory3(m));
     }
-    console.log(chalk7.dim(`
+    console.log(chalk8.dim(`
   ${memories.length} memories`));
   } catch (error2) {
-    console.error(chalk7.red("\u2717") + " Failed to list memories:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk8.red("\u2717") + " Failed to list memories:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -785,7 +971,7 @@ var listCommand = new Command6("list").description("List memories").option("-l,
 // src/commands/forget.ts
 import { Command as Command7 } from "commander";
 import { createInterface } from "readline";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 var VALID_TYPES5 = ["rule", "decision", "fact", "note"];
 var TYPE_ICONS3 = {
   rule: "\u{1F4CC}",
@@ -793,7 +979,7 @@ var TYPE_ICONS3 = {
   fact: "\u{1F4CB}",
   note: "\u{1F4DD}"
 };
-async function confirm(message) {
+async function confirm2(message) {
   const rl = createInterface({ input: process.stdin, output: process.stderr });
   return new Promise((resolve3) => {
     rl.question(message, (answer) => {
@@ -807,28 +993,28 @@ var forgetCommand = new Command7("forget").description("Soft-delete memories by
     if (id) {
       const deleted = await forgetMemory(id);
       if (deleted) {
-        console.log(chalk8.green("\u2713") + ` Forgot memory ${chalk8.dim(id)}`);
+        console.log(chalk9.green("\u2713") + ` Forgot memory ${chalk9.dim(id)}`);
       } else {
-        console.error(chalk8.red("\u2717") + ` Memory ${id} not found or already forgotten.`);
+        console.error(chalk9.red("\u2717") + ` Memory ${id} not found or already forgotten.`);
         process.exit(1);
       }
       return;
     }
     const hasBulkFilter = opts.type || opts.tag || opts.olderThan || opts.pattern || opts.all;
     if (!hasBulkFilter) {
-      console.error(chalk8.red("\u2717") + " Provide a memory ID or a bulk filter (--type, --tag, --older-than, --pattern, --all)");
+      console.error(chalk9.red("\u2717") + " Provide a memory ID or a bulk filter (--type, --tag, --older-than, --pattern, --all)");
       process.exit(1);
     }
     if (opts.all && (opts.type || opts.tag || opts.olderThan || opts.pattern)) {
-      console.error(chalk8.red("\u2717") + " --all cannot be combined with other filters. Use --all alone to delete everything.");
+      console.error(chalk9.red("\u2717") + " --all cannot be combined with other filters. Use --all alone to delete everything.");
       process.exit(1);
     }
     if (opts.type && !VALID_TYPES5.includes(opts.type)) {
-      console.error(chalk8.red("\u2717") + ` Invalid type "${opts.type}". Valid: ${VALID_TYPES5.join(", ")}`);
+      console.error(chalk9.red("\u2717") + ` Invalid type "${opts.type}". Valid: ${VALID_TYPES5.join(", ")}`);
       process.exit(1);
     }
     if (opts.olderThan && (isNaN(parseInt(opts.olderThan, 10)) || parseInt(opts.olderThan, 10) <= 0)) {
-      console.error(chalk8.red("\u2717") + " --older-than must be a positive number of days");
+      console.error(chalk9.red("\u2717") + " --older-than must be a positive number of days");
       process.exit(1);
     }
     const filter = {
@@ -841,27 +1027,27 @@ var forgetCommand = new Command7("forget").description("Soft-delete memories by
     };
     const matches = await findMemoriesToForget(filter);
     if (matches.length === 0) {
-      console.log(chalk8.dim("No memories match the filter."));
+      console.log(chalk9.dim("No memories match the filter."));
       return;
     }
-    console.log(chalk8.bold(`${matches.length} memories will be forgotten:
+    console.log(chalk9.bold(`${matches.length} memories will be forgotten:
 `));
     for (const m of matches.slice(0, 30)) {
       const icon = TYPE_ICONS3[m.type] || "\u{1F4DD}";
-      const scope = m.scope === "global" ? chalk8.dim("G") : chalk8.dim("P");
-      console.log(`  ${icon} ${scope} ${chalk8.dim(m.id)}  ${m.content}`);
+      const scope = m.scope === "global" ? chalk9.dim("G") : chalk9.dim("P");
+      console.log(`  ${icon} ${scope} ${chalk9.dim(m.id)}  ${m.content}`);
     }
     if (matches.length > 30) {
-      console.log(chalk8.dim(`  ... and ${matches.length - 30} more`));
+      console.log(chalk9.dim(`  ... and ${matches.length - 30} more`));
     }
     console.log("");
     if (opts.dryRun) {
-      console.log(chalk8.yellow("Dry run") + " \u2014 no memories were deleted.");
+      console.log(chalk9.yellow("Dry run") + " \u2014 no memories were deleted.");
       return;
     }
     if (!opts.force) {
-      const proceed = await confirm(
-        chalk8.yellow(`Forget ${matches.length} memories? This is a soft-delete. [y/N] `)
+      const proceed = await confirm2(
+        chalk9.yellow(`Forget ${matches.length} memories? This is a soft-delete. [y/N] `)
       );
       if (!proceed) {
         console.log("Cancelled.");
@@ -870,17 +1056,17 @@ var forgetCommand = new Command7("forget").description("Soft-delete memories by
     }
     const ids = matches.map((m) => m.id);
     const count = await bulkForgetByIds(ids);
-    console.log(chalk8.green("\u2713") + ` Forgot ${count} memories.`);
+    console.log(chalk9.green("\u2713") + ` Forgot ${count} memories.`);
   } catch (error2) {
-    console.error(chalk8.red("\u2717") + " Failed to forget:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk9.red("\u2717") + " Failed to forget:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/export.ts
 import { Command as Command8 } from "commander";
-import chalk9 from "chalk";
-import { writeFile as writeFile2 } from "fs/promises";
+import chalk10 from "chalk";
+import { writeFile as writeFile3 } from "fs/promises";
 var exportCommand = new Command8("export").description("Export memories to JSON or YAML file").option("-o, --output <file>", "Output file path (default: stdout)").option("-f, --format <format>", "Output format: json, yaml (default: json)", "json").option("-g, --global", "Export only global memories").option("--project-only", "Export only project memories").option("--type <type>", "Filter by type: rule, decision, fact, note").action(async (opts) => {
   try {
     const projectId = getProjectId();
@@ -893,7 +1079,7 @@ var exportCommand = new Command8("export").description("Export memories to JSON
       includeGlobal = false;
       queryProjectId = projectId ?? void 0;
       if (!queryProjectId) {
-        console.error(chalk9.red("\u2717") + " Not in a git repository. No project memories to export.");
+        console.error(chalk10.red("\u2717") + " Not in a git repository. No project memories to export.");
         process.exit(1);
       }
     }
@@ -927,24 +1113,24 @@ var exportCommand = new Command8("export").description("Export memories to JSON
       output = JSON.stringify(exportData, null, 2);
     }
     if (opts.output) {
-      await writeFile2(opts.output, output, "utf-8");
-      console.log(chalk9.green("\u2713") + ` Exported ${memories.length} memories to ${chalk9.dim(opts.output)}`);
+      await writeFile3(opts.output, output, "utf-8");
+      console.log(chalk10.green("\u2713") + ` Exported ${memories.length} memories to ${chalk10.dim(opts.output)}`);
     } else {
       console.log(output);
     }
   } catch (error2) {
-    console.error(chalk9.red("\u2717") + " Failed to export:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk10.red("\u2717") + " Failed to export:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/import.ts
 import { Command as Command9 } from "commander";
-import chalk10 from "chalk";
-import { readFile as readFile2 } from "fs/promises";
+import chalk11 from "chalk";
+import { readFile as readFile3 } from "fs/promises";
 var importCommand = new Command9("import").description("Import memories from JSON or YAML file").argument("<file>", "Input file path").option("-f, --format <format>", "Input format: json, yaml (auto-detected from extension)").option("-g, --global", "Import all as global memories (override file scope)").option("--dry-run", "Show what would be imported without actually importing").action(async (file, opts) => {
   try {
-    const content = await readFile2(file, "utf-8");
+    const content = await readFile3(file, "utf-8");
     let format = opts.format;
     if (!format) {
       if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -961,7 +1147,7 @@ var importCommand = new Command9("import").description("Import memories from JSO
       data = JSON.parse(content);
     }
     if (!data || typeof data !== "object" || !("memories" in data) || !Array.isArray(data.memories)) {
-      console.error(chalk10.red("\u2717") + " Invalid import file: missing 'memories' array");
+      console.error(chalk11.red("\u2717") + " Invalid import file: missing 'memories' array");
       process.exit(1);
     }
     const VALID_TYPES11 = ["rule", "decision", "fact", "note"];
@@ -974,23 +1160,23 @@ var importCommand = new Command9("import").description("Import memories from JSO
         continue;
       }
       if (m.type && !VALID_TYPES11.includes(m.type)) {
-        console.error(chalk10.yellow("\u26A0") + ` Skipping memory with invalid type "${m.type}": ${m.content.slice(0, 50)}`);
+        console.error(chalk11.yellow("\u26A0") + ` Skipping memory with invalid type "${m.type}": ${m.content.slice(0, 50)}`);
         skipped++;
         continue;
       }
       validMemories.push(m);
     }
     if (opts.dryRun) {
-      console.log(chalk10.blue("Dry run - would import:"));
+      console.log(chalk11.blue("Dry run - would import:"));
       for (const m of validMemories) {
         const type = m.type || "note";
         const scope = opts.global ? "global" : m.scope || "project";
         const tags = m.tags?.length ? ` [${m.tags.join(", ")}]` : "";
         console.log(`  ${type} (${scope}): ${m.content}${tags}`);
       }
-      console.log(chalk10.dim(`
+      console.log(chalk11.dim(`
 ${validMemories.length} memories would be imported`));
-      if (skipped > 0) console.log(chalk10.dim(`${skipped} entries skipped (invalid)`));
+      if (skipped > 0) console.log(chalk11.dim(`${skipped} entries skipped (invalid)`));
       return;
     }
     let imported = 0;
@@ -1004,19 +1190,19 @@ ${validMemories.length} memories would be imported`));
         });
         imported++;
       } catch (error2) {
-        console.error(chalk10.yellow("\u26A0") + ` Failed to import: ${m.content.slice(0, 50)}...`);
+        console.error(chalk11.yellow("\u26A0") + ` Failed to import: ${m.content.slice(0, 50)}...`);
         failed++;
       }
     }
-    console.log(chalk10.green("\u2713") + ` Imported ${imported} memories`);
+    console.log(chalk11.green("\u2713") + ` Imported ${imported} memories`);
     if (failed > 0) {
-      console.log(chalk10.yellow("\u26A0") + ` ${failed} memories failed to import`);
+      console.log(chalk11.yellow("\u26A0") + ` ${failed} memories failed to import`);
     }
     if (skipped > 0) {
-      console.log(chalk10.dim(`${skipped} entries skipped (invalid content or type)`));
+      console.log(chalk11.dim(`${skipped} entries skipped (invalid content or type)`));
     }
   } catch (error2) {
-    console.error(chalk10.red("\u2717") + " Failed to import:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk11.red("\u2717") + " Failed to import:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -1025,17 +1211,17 @@ ${validMemories.length} memories would be imported`));
 import { Command as Command10 } from "commander";
 // src/lib/config.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-import { join as join2 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+import { join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
 import { parse, stringify } from "yaml";
 var AGENTS_DIR = ".agents";
 var CONFIG_FILE = "config.yaml";
 async function initConfig(dir) {
-  const agentsDir = join2(dir, AGENTS_DIR);
-  await mkdir2(agentsDir, { recursive: true });
-  const configPath = join2(agentsDir, CONFIG_FILE);
-  if (!existsSync2(configPath)) {
+  const agentsDir = join3(dir, AGENTS_DIR);
+  await mkdir3(agentsDir, { recursive: true });
+  const configPath = join3(agentsDir, CONFIG_FILE);
+  if (!existsSync3(configPath)) {
     const defaultConfig = {
       name: "my-project",
       description: "Agent memory configuration",
@@ -1045,14 +1231,14 @@ async function initConfig(dir) {
         store: "~/.config/memories/local.db"
       }
     };
-    await writeFile3(configPath, stringify(defaultConfig), "utf-8");
+    await writeFile4(configPath, stringify(defaultConfig), "utf-8");
   }
   return configPath;
 }
 async function readConfig(dir) {
-  const configPath = join2(dir, AGENTS_DIR, CONFIG_FILE);
-  if (!existsSync2(configPath)) return null;
-  const raw = await readFile3(configPath, "utf-8");
+  const configPath = join3(dir, AGENTS_DIR, CONFIG_FILE);
+  if (!existsSync3(configPath)) return null;
+  const raw = await readFile4(configPath, "utf-8");
   return parse(raw);
 }
@@ -1077,6 +1263,8 @@ import { Command as Command11 } from "commander";
 // src/mcp/index.ts
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "http";
 import { z } from "zod";
 var TYPE_LABELS2 = {
   rule: "\u{1F4CC} RULE",
@@ -1100,7 +1288,7 @@ function formatMemoriesSection(memories, title) {
   return `## ${title}
 ${memories.map(formatMemory4).join("\n")}`;
 }
-async function startMcpServer() {
+async function createMcpServer() {
   const projectId = getProjectId();
   const server = new McpServer({
     name: "memories",
@@ -1458,19 +1646,93 @@ Find the memory ID first with search_memories or list_memories.`,
       }
     }
   );
+  return server;
+}
+async function startMcpServer() {
+  const server = await createMcpServer();
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
+async function startMcpHttpServer(options) {
+  const { port, host, cors } = options;
+  const server = await createMcpServer();
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: void 0
+    // Stateless mode
+  });
+  await server.connect(transport);
+  const httpServer = createServer(async (req, res) => {
+    if (cors) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Accept");
+    }
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url || "/", `http://${host}:${port}`);
+    if (url.pathname === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok" }));
+      return;
+    }
+    if (url.pathname === "/mcp" || url.pathname === "/") {
+      try {
+        let body = void 0;
+        if (req.method === "POST") {
+          const chunks = [];
+          for await (const chunk of req) {
+            chunks.push(chunk);
+          }
+          const rawBody = Buffer.concat(chunks).toString("utf-8");
+          if (rawBody) {
+            body = JSON.parse(rawBody);
+          }
+        }
+        await transport.handleRequest(req, res, body);
+      } catch (error2) {
+        console.error("[memories] Error handling MCP request:", error2);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Internal server error" }));
+      }
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+  httpServer.listen(port, host);
+  await new Promise(() => {
+  });
+}
 // src/commands/serve.ts
-var serveCommand = new Command11("serve").description("Start the MCP server (stdio transport)").action(async () => {
+var serveCommand = new Command11("serve").description("Start the MCP server").option("--sse", "Use SSE/HTTP transport instead of stdio (for web clients like v0)").option("-p, --port <port>", "Port for SSE server", "3030").option("--host <host>", "Host to bind to", "127.0.0.1").option("--cors", "Enable CORS for cross-origin requests").action(async (opts) => {
   const projectId = getProjectId();
-  if (projectId) {
-    console.error(`[memories] MCP server starting (project: ${projectId})`);
+  if (opts.sse) {
+    const port = parseInt(opts.port || "3030", 10);
+    const host = opts.host || "127.0.0.1";
+    console.log(`[memories] Starting MCP server with SSE transport`);
+    console.log(`[memories] Listening on http://${host}:${port}`);
+    if (projectId) {
+      console.log(`[memories] Project: ${projectId}`);
+    } else {
+      console.log(`[memories] Global only (not in a git repo)`);
+    }
+    if (opts.cors) {
+      console.log(`[memories] CORS enabled`);
+    }
+    console.log(`[memories] Connect v0 or other clients to: http://${host}:${port}/mcp`);
+    await startMcpHttpServer({ port, host, cors: opts.cors });
   } else {
-    console.error("[memories] MCP server starting (global only - not in a git repo)");
+    if (projectId) {
+      console.error(`[memories] MCP server starting (project: ${projectId})`);
+    } else {
+      console.error("[memories] MCP server starting (global only - not in a git repo)");
+    }
+    await startMcpServer();
   }
-  await startMcpServer();
 });
 // src/commands/sync.ts
@@ -1528,10 +1790,10 @@ async function createDatabaseToken(org, dbName) {
 }
 // src/commands/sync.ts
-import { unlinkSync, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
-var DB_PATH = join3(homedir2(), ".config", "memories", "local.db");
+import { unlinkSync, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+var DB_PATH = join4(homedir3(), ".config", "memories", "local.db");
 var syncCommand = new Command12("sync").description(
   "Manage remote sync"
 );
@@ -1554,7 +1816,7 @@ syncCommand.command("enable").description("Provision a cloud database and enable
         const profileRes = await apiFetch("/api/db/credentials");
         if (profileRes.ok) {
           const creds = await profileRes.json();
-          if (existsSync3(DB_PATH)) {
+          if (existsSync4(DB_PATH)) {
             resetDb();
             unlinkSync(DB_PATH);
           }
@@ -1590,7 +1852,7 @@ syncCommand.command("enable").description("Provision a cloud database and enable
   spinner.text = "Generating auth token...";
   const token = await createDatabaseToken(opts.org, db.name);
   const syncUrl = `libsql://${db.hostname}`;
-  if (existsSync3(DB_PATH)) {
+  if (existsSync4(DB_PATH)) {
     resetDb();
     unlinkSync(DB_PATH);
   }
@@ -1637,12 +1899,12 @@ syncCommand.command("status").description("Show sync configuration").action(asyn
 // src/commands/generate.ts
 import { Command as Command13 } from "commander";
-import chalk11 from "chalk";
-import { writeFile as writeFile4, readFile as readFile4, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync4, watch as fsWatch } from "fs";
-import { dirname, resolve, join as join4 } from "path";
-import { homedir as homedir3 } from "os";
-import { checkbox } from "@inquirer/prompts";
+import chalk12 from "chalk";
+import { writeFile as writeFile5, readFile as readFile5, mkdir as mkdir4 } from "fs/promises";
+import { existsSync as existsSync5, watch as fsWatch } from "fs";
+import { dirname as dirname2, resolve, join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import { checkbox as checkbox2 } from "@inquirer/prompts";
 var MARKER = "Generated by memories.sh";
 var VALID_TYPES6 = ["rule", "decision", "fact", "note"];
 function groupByType(memories) {
@@ -1778,7 +2040,7 @@ function makeFooter() {
 }
 async function hasOurMarker(filePath) {
   try {
-    const content = await readFile4(filePath, "utf-8");
+    const content = await readFile5(filePath, "utf-8");
     return content.includes(MARKER);
   } catch {
     return false;
@@ -1789,13 +2051,13 @@ async function checkGitignore(filePath) {
   if (TRACK_BY_DEFAULT.has(filePath)) return;
   const gitignorePath = resolve(".gitignore");
   try {
-    const content = existsSync4(gitignorePath) ? await readFile4(gitignorePath, "utf-8") : "";
+    const content = existsSync5(gitignorePath) ? await readFile5(gitignorePath, "utf-8") : "";
     const lines = content.split("\n");
     const parentDir = filePath.split("/")[0];
     if (lines.some((l) => l.trim() === filePath || l.trim() === parentDir || l.trim() === `${parentDir}/`)) {
       return;
     }
-    console.log(chalk11.dim(`  hint: add "${filePath}" to .gitignore if you don't want it tracked`));
+    console.log(chalk12.dim(`  hint: add "${filePath}" to .gitignore if you don't want it tracked`));
   } catch {
   }
 }
@@ -1803,23 +2065,23 @@ async function writeTarget(target, memories, opts) {
   const outPath = resolve(opts.output ?? target.defaultPath);
   const content = target.format(memories) + makeFooter();
   if (opts.dryRun) {
-    console.log(chalk11.dim(`\u2500\u2500 ${target.name} \u2192 ${outPath} \u2500\u2500`));
+    console.log(chalk12.dim(`\u2500\u2500 ${target.name} \u2192 ${outPath} \u2500\u2500`));
     console.log(content);
     console.log();
     return;
   }
-  if (existsSync4(outPath)) {
+  if (existsSync5(outPath)) {
     const ours = await hasOurMarker(outPath);
     if (!ours && !opts.force) {
       console.error(
-        chalk11.yellow("\u26A0") + ` ${outPath} exists and was not generated by memories.sh. Use ${chalk11.bold("--force")} to overwrite.`
+        chalk12.yellow("\u26A0") + ` ${outPath} exists and was not generated by memories.sh. Use ${chalk12.bold("--force")} to overwrite.`
       );
       return;
     }
   }
-  await mkdir3(dirname(outPath), { recursive: true });
-  await writeFile4(outPath, content, "utf-8");
-  console.log(chalk11.green("\u2713") + ` Wrote ${target.name} \u2192 ${chalk11.dim(outPath)}`);
+  await mkdir4(dirname2(outPath), { recursive: true });
+  await writeFile5(outPath, content, "utf-8");
+  console.log(chalk12.green("\u2713") + ` Wrote ${target.name} \u2192 ${chalk12.dim(outPath)}`);
   await checkGitignore(opts.output ?? target.defaultPath);
 }
 async function fetchMemories(types) {
@@ -1835,23 +2097,23 @@ function parseTypes(raw) {
   const types = raw.split(",").map((s) => s.trim());
   for (const t of types) {
     if (!VALID_TYPES6.includes(t)) {
-      console.error(chalk11.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES6.join(", ")}`);
+      console.error(chalk12.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES6.join(", ")}`);
       process.exit(1);
     }
   }
   return types;
 }
 function getDbPath() {
-  const dataDir = process.env.MEMORIES_DATA_DIR ?? join4(homedir3(), ".config", "memories");
-  return join4(dataDir, "local.db");
+  const dataDir = process.env.MEMORIES_DATA_DIR ?? join5(homedir4(), ".config", "memories");
+  return join5(dataDir, "local.db");
 }
 async function runWatch(targets, memories, opts) {
   const dbPath = getDbPath();
-  if (!existsSync4(dbPath)) {
-    console.error(chalk11.red("\u2717") + " Database not found. Run: memories init");
+  if (!existsSync5(dbPath)) {
+    console.error(chalk12.red("\u2717") + " Database not found. Run: memories init");
     process.exit(1);
   }
-  console.log(chalk11.dim(`Watching ${dbPath} for changes... (Ctrl+C to stop)
+  console.log(chalk12.dim(`Watching ${dbPath} for changes... (Ctrl+C to stop)
 `));
   const mems = await memories();
   if (mems.length > 0) {
@@ -1871,7 +2133,7 @@ async function runWatch(targets, memories, opts) {
           }
         }
       } catch (err) {
-        console.error(chalk11.red("\u2717") + " Watch error:", err.message);
+        console.error(chalk12.red("\u2717") + " Watch error:", err.message);
       }
     }, 500);
   });
@@ -1884,22 +2146,22 @@ var generateCommand = new Command13("generate").description("Generate IDE rule/i
       generateCommand.outputHelp();
       return;
     }
-    const selected = await checkbox({
+    const selected = await checkbox2({
       message: "Select targets to generate",
       choices: TARGETS.map((t) => ({
-        name: `${t.name} ${chalk11.dim(`\u2192 ${t.defaultPath}`)}`,
+        name: `${t.name} ${chalk12.dim(`\u2192 ${t.defaultPath}`)}`,
         value: t.name,
         checked: true
       }))
     });
     if (selected.length === 0) {
-      console.log(chalk11.dim("No targets selected."));
+      console.log(chalk12.dim("No targets selected."));
       return;
     }
     const types = parseTypes(opts.types);
     const memories = await fetchMemories(types);
     if (memories.length === 0) {
-      console.error(chalk11.dim('No memories found. Add some with: memories add --rule "Your rule"'));
+      console.error(chalk12.dim('No memories found. Add some with: memories add --rule "Your rule"'));
       return;
     }
     const selectedSet = new Set(selected);
@@ -1911,7 +2173,7 @@ var generateCommand = new Command13("generate").description("Generate IDE rule/i
     }
   } catch (error2) {
     if (error2.name === "ExitPromptError") return;
-    console.error(chalk11.red("\u2717") + " Failed to generate:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk12.red("\u2717") + " Failed to generate:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -1922,12 +2184,12 @@ for (const target of TARGETS) {
         const types = parseTypes(opts.types);
         const memories = await fetchMemories(types);
         if (memories.length === 0) {
-          console.error(chalk11.dim('No memories found. Add some with: memories add --rule "Your rule"'));
+          console.error(chalk12.dim('No memories found. Add some with: memories add --rule "Your rule"'));
           return;
         }
         await writeTarget(target, memories, opts);
       } catch (error2) {
-        console.error(chalk11.red("\u2717") + ` Failed to generate ${target.name}:`, error2 instanceof Error ? error2.message : "Unknown error");
+        console.error(chalk12.red("\u2717") + ` Failed to generate ${target.name}:`, error2 instanceof Error ? error2.message : "Unknown error");
         process.exit(1);
       }
     })
@@ -1943,14 +2205,14 @@ generateCommand.addCommand(
       }
       const memories = await fetchMemories(types);
       if (memories.length === 0) {
-        console.error(chalk11.dim('No memories found. Add some with: memories add --rule "Your rule"'));
+        console.error(chalk12.dim('No memories found. Add some with: memories add --rule "Your rule"'));
         return;
       }
       for (const target of TARGETS) {
         await writeTarget(target, memories, opts);
       }
     } catch (error2) {
-      console.error(chalk11.red("\u2717") + " Failed to generate:", error2 instanceof Error ? error2.message : "Unknown error");
+      console.error(chalk12.red("\u2717") + " Failed to generate:", error2 instanceof Error ? error2.message : "Unknown error");
       process.exit(1);
     }
   })
@@ -1958,11 +2220,11 @@ generateCommand.addCommand(
 // src/commands/edit.ts
 import { Command as Command14 } from "commander";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 import { execFileSync as execFileSync2 } from "child_process";
 import { writeFileSync, readFileSync, unlinkSync as unlinkSync2 } from "fs";
 import { tmpdir } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { nanoid as nanoid2 } from "nanoid";
 import { select } from "@inquirer/prompts";
 var VALID_TYPES7 = ["rule", "decision", "fact", "note"];
@@ -1974,13 +2236,13 @@ async function pickMemory() {
   const projectId = getProjectId() ?? void 0;
   const memories = await listMemories({ limit: 100, projectId });
   if (memories.length === 0) {
-    console.error(chalk12.dim("No memories found."));
+    console.error(chalk13.dim("No memories found."));
     process.exit(0);
   }
   const id = await select({
     message: "Select a memory to edit",
     choices: memories.map((m) => ({
-      name: `${chalk12.dim(m.type.padEnd(9))} ${truncate2(m.content, 60)} ${chalk12.dim(m.id)}`,
+      name: `${chalk13.dim(m.type.padEnd(9))} ${truncate2(m.content, 60)} ${chalk13.dim(m.id)}`,
       value: m.id
     }))
   });
@@ -1990,7 +2252,7 @@ var editCommand = new Command14("edit").description("Edit an existing memory").a
   try {
     if (!id) {
       if (!process.stdin.isTTY) {
-        console.error(chalk12.red("\u2717") + " Memory ID required in non-interactive mode");
+        console.error(chalk13.red("\u2717") + " Memory ID required in non-interactive mode");
         process.exit(1);
       }
       id = await pickMemory();
@@ -2001,18 +2263,18 @@ var editCommand = new Command14("edit").description("Edit an existing memory").a
       args: [id]
     });
     if (result.rows.length === 0) {
-      console.error(chalk12.red("\u2717") + ` Memory ${chalk12.dim(id)} not found`);
+      console.error(chalk13.red("\u2717") + ` Memory ${chalk13.dim(id)} not found`);
       process.exit(1);
     }
     const memory = result.rows[0];
     if (opts.type && !VALID_TYPES7.includes(opts.type)) {
-      console.error(chalk12.red("\u2717") + ` Invalid type "${opts.type}". Valid: ${VALID_TYPES7.join(", ")}`);
+      console.error(chalk13.red("\u2717") + ` Invalid type "${opts.type}". Valid: ${VALID_TYPES7.join(", ")}`);
       process.exit(1);
     }
     let newContent = opts.content;
     if (newContent === void 0 && opts.tags === void 0 && opts.type === void 0) {
       const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-      const tmpFile = join5(tmpdir(), `memories-edit-${nanoid2(6)}.md`);
+      const tmpFile = join6(tmpdir(), `memories-edit-${nanoid2(6)}.md`);
       writeFileSync(tmpFile, memory.content, "utf-8");
       try {
         execFileSync2(editor, [tmpFile], { stdio: "inherit" });
@@ -2024,7 +2286,7 @@ var editCommand = new Command14("edit").description("Edit an existing memory").a
         }
       }
       if (newContent === memory.content) {
-        console.log(chalk12.dim("No changes made."));
+        console.log(chalk13.dim("No changes made."));
         return;
       }
     }
@@ -2034,24 +2296,24 @@ var editCommand = new Command14("edit").description("Edit an existing memory").a
     if (opts.type !== void 0) updates.type = opts.type;
     const updated = await updateMemory(id, updates);
     if (!updated) {
-      console.error(chalk12.red("\u2717") + ` Failed to update memory ${chalk12.dim(id)}`);
+      console.error(chalk13.red("\u2717") + ` Failed to update memory ${chalk13.dim(id)}`);
       process.exit(1);
     }
     const changes = [];
     if (updates.content !== void 0) changes.push("content");
     if (updates.tags !== void 0) changes.push("tags");
     if (updates.type !== void 0) changes.push(`type\u2192${updates.type}`);
-    console.log(chalk12.green("\u2713") + ` Updated ${chalk12.dim(id)} (${changes.join(", ")})`);
+    console.log(chalk13.green("\u2713") + ` Updated ${chalk13.dim(id)} (${changes.join(", ")})`);
   } catch (error2) {
     if (error2.name === "ExitPromptError") return;
-    console.error(chalk12.red("\u2717") + " Failed to edit memory:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk13.red("\u2717") + " Failed to edit memory:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/stats.ts
 import { Command as Command15 } from "commander";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 var statsCommand = new Command15("stats").description("Show memory statistics").option("--json", "Output as JSON").action(async (opts) => {
   try {
     const db = await getDb();
@@ -2088,46 +2350,46 @@ var statsCommand = new Command15("stats").description("Show memory statistics").
       console.log(JSON.stringify(data, null, 2));
       return;
     }
-    console.log(chalk13.bold("Memory Statistics\n"));
+    console.log(chalk14.bold("Memory Statistics\n"));
     if (projectId) {
-      console.log(`  Project: ${chalk13.dim(projectId)}`);
+      console.log(`  Project: ${chalk14.dim(projectId)}`);
     }
-    console.log(`  Total:   ${chalk13.bold(String(total))} active, ${chalk13.dim(String(deleted))} deleted
+    console.log(`  Total:   ${chalk14.bold(String(total))} active, ${chalk14.dim(String(deleted))} deleted
 `);
     if (rows.length === 0) {
-      console.log(chalk13.dim('  No memories yet. Add one with: memories add "Your memory"'));
+      console.log(chalk14.dim('  No memories yet. Add one with: memories add "Your memory"'));
       return;
     }
     const typeWidths = { rule: 8, decision: 8, fact: 8, note: 8 };
     console.log(
-      `  ${chalk13.dim("Type".padEnd(12))}${chalk13.dim("Scope".padEnd(10))}${chalk13.dim("Count")}`
+      `  ${chalk14.dim("Type".padEnd(12))}${chalk14.dim("Scope".padEnd(10))}${chalk14.dim("Count")}`
     );
-    console.log(chalk13.dim("  " + "\u2500".repeat(30)));
+    console.log(chalk14.dim("  " + "\u2500".repeat(30)));
     for (const row of rows) {
       const type = row.type.padEnd(12);
       const scope = row.scope.padEnd(10);
       console.log(`  ${type}${scope}${Number(row.count)}`);
     }
   } catch (error2) {
-    console.error(chalk13.red("\u2717") + " Failed to get stats:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk14.red("\u2717") + " Failed to get stats:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/doctor.ts
 import { Command as Command16 } from "commander";
-import chalk14 from "chalk";
-import { existsSync as existsSync5 } from "fs";
-import { join as join6 } from "path";
+import chalk15 from "chalk";
+import { existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
 var doctorCommand = new Command16("doctor").description("Check memories health and diagnose issues").option("--fix", "Attempt to fix issues found").action(async (opts) => {
   try {
-    console.log(chalk14.bold("memories doctor\n"));
+    console.log(chalk15.bold("memories doctor\n"));
     const checks = [
       {
         name: "Database file",
         run: async () => {
-          const dbPath = join6(getConfigDir(), "local.db");
-          if (existsSync5(dbPath)) {
+          const dbPath = join7(getConfigDir(), "local.db");
+          if (existsSync6(dbPath)) {
             return { ok: true, message: `Found at ${dbPath}` };
           }
           return { ok: false, message: `Not found at ${dbPath}. Run: memories init` };
@@ -2225,43 +2487,43 @@ var doctorCommand = new Command16("doctor").description("Check memories health a
     let hasIssues = false;
     for (const check of checks) {
       const { ok, message } = await check.run();
-      const icon = ok ? chalk14.green("\u2713") : chalk14.red("\u2717");
-      console.log(`  ${icon} ${chalk14.bold(check.name)}: ${message}`);
+      const icon = ok ? chalk15.green("\u2713") : chalk15.red("\u2717");
+      console.log(`  ${icon} ${chalk15.bold(check.name)}: ${message}`);
       if (!ok) hasIssues = true;
     }
     if (opts.fix) {
-      console.log(chalk14.bold("\nRunning fixes...\n"));
+      console.log(chalk15.bold("\nRunning fixes...\n"));
       const db = await getDb();
       const purged = await db.execute(
         "DELETE FROM memories WHERE deleted_at IS NOT NULL"
       );
-      console.log(`  ${chalk14.green("\u2713")} Purged ${purged.rowsAffected} soft-deleted records`);
+      console.log(`  ${chalk15.green("\u2713")} Purged ${purged.rowsAffected} soft-deleted records`);
       try {
         await db.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
-        console.log(`  ${chalk14.green("\u2713")} Rebuilt FTS index`);
+        console.log(`  ${chalk15.green("\u2713")} Rebuilt FTS index`);
       } catch {
-        console.log(`  ${chalk14.yellow("\u26A0")} Could not rebuild FTS index`);
+        console.log(`  ${chalk15.yellow("\u26A0")} Could not rebuild FTS index`);
       }
     }
     console.log();
     if (hasIssues) {
-      console.log(chalk14.yellow("Some issues detected.") + (opts.fix ? "" : " Run with --fix to attempt repairs."));
+      console.log(chalk15.yellow("Some issues detected.") + (opts.fix ? "" : " Run with --fix to attempt repairs."));
     } else {
-      console.log(chalk14.green("All checks passed."));
+      console.log(chalk15.green("All checks passed."));
     }
   } catch (error2) {
-    console.error(chalk14.red("\u2717") + " Doctor failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk15.red("\u2717") + " Doctor failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/hook.ts
 import { Command as Command17 } from "commander";
-import chalk15 from "chalk";
-import { readFile as readFile5, writeFile as writeFile5, chmod } from "fs/promises";
-import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
+import chalk16 from "chalk";
+import { readFile as readFile6, writeFile as writeFile6, chmod } from "fs/promises";
+import { existsSync as existsSync7, readFileSync as readFileSync2 } from "fs";
 import { execFileSync as execFileSync3 } from "child_process";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var HOOK_MARKER_START = "# >>> memories.sh hook >>>";
 var HOOK_MARKER_END = "# <<< memories.sh hook <<<";
 var HOOK_SNIPPET = `
@@ -2282,22 +2544,22 @@ function getGitDir() {
 function getHookLocation(hookName) {
   const gitDir = getGitDir();
   if (!gitDir) return null;
-  const huskyPath = join7(".husky", hookName);
-  if (existsSync6(".husky") && !existsSync6(join7(".husky", "_"))) {
+  const huskyPath = join8(".husky", hookName);
+  if (existsSync7(".husky") && !existsSync7(join8(".husky", "_"))) {
     return { path: huskyPath, type: "husky" };
   }
-  const huskyLegacyPath = join7(".husky", "_", hookName);
-  if (existsSync6(join7(".husky", "_"))) {
+  const huskyLegacyPath = join8(".husky", "_", hookName);
+  if (existsSync7(join8(".husky", "_"))) {
     return { path: huskyLegacyPath, type: "husky" };
   }
-  if (existsSync6(huskyPath)) {
+  if (existsSync7(huskyPath)) {
     return { path: huskyPath, type: "husky" };
   }
-  return { path: join7(gitDir, "hooks", hookName), type: "git" };
+  return { path: join8(gitDir, "hooks", hookName), type: "git" };
 }
 function detectLintStaged() {
   try {
-    if (!existsSync6("package.json")) return false;
+    if (!existsSync7("package.json")) return false;
     const pkg = JSON.parse(readFileSync2("package.json", "utf-8"));
     return !!(pkg["lint-staged"] || pkg.devDependencies?.["lint-staged"] || pkg.dependencies?.["lint-staged"]);
   } catch {
@@ -2310,31 +2572,31 @@ hookCommand.addCommand(
     try {
       const location = getHookLocation(opts.hook);
       if (!location) {
-        console.error(chalk15.red("\u2717") + " Not in a git repository");
+        console.error(chalk16.red("\u2717") + " Not in a git repository");
         process.exit(1);
       }
       const hookPath = location.path;
-      if (existsSync6(hookPath)) {
-        const content = await readFile5(hookPath, "utf-8");
+      if (existsSync7(hookPath)) {
+        const content = await readFile6(hookPath, "utf-8");
         if (content.includes(HOOK_MARKER_START)) {
-          console.log(chalk15.dim("Hook already installed. Use 'memories hook uninstall' first to reinstall."));
+          console.log(chalk16.dim("Hook already installed. Use 'memories hook uninstall' first to reinstall."));
           return;
         }
-        await writeFile5(hookPath, content.trimEnd() + "\n" + HOOK_SNIPPET + "\n", "utf-8");
+        await writeFile6(hookPath, content.trimEnd() + "\n" + HOOK_SNIPPET + "\n", "utf-8");
       } else {
-        await writeFile5(hookPath, "#!/bin/sh\n" + HOOK_SNIPPET + "\n", "utf-8");
+        await writeFile6(hookPath, "#!/bin/sh\n" + HOOK_SNIPPET + "\n", "utf-8");
       }
       await chmod(hookPath, 493);
       const locationLabel = location.type === "husky" ? "Husky" : ".git/hooks";
-      console.log(chalk15.green("\u2713") + ` Installed memories hook in ${chalk15.dim(opts.hook)} (${locationLabel})`);
-      console.log(chalk15.dim("  Rule files will auto-generate on each commit."));
+      console.log(chalk16.green("\u2713") + ` Installed memories hook in ${chalk16.dim(opts.hook)} (${locationLabel})`);
+      console.log(chalk16.dim("  Rule files will auto-generate on each commit."));
       if (detectLintStaged()) {
         console.log(
-          chalk15.dim("\n  lint-staged detected. You can also add to your lint-staged config:") + chalk15.dim('\n  "*.md": "memories generate all --force"')
+          chalk16.dim("\n  lint-staged detected. You can also add to your lint-staged config:") + chalk16.dim('\n  "*.md": "memories generate all --force"')
         );
       }
     } catch (error2) {
-      console.error(chalk15.red("\u2717") + " Failed to install hook:", error2 instanceof Error ? error2.message : "Unknown error");
+      console.error(chalk16.red("\u2717") + " Failed to install hook:", error2 instanceof Error ? error2.message : "Unknown error");
       process.exit(1);
     }
   })
@@ -2344,17 +2606,17 @@ hookCommand.addCommand(
     try {
       const location = getHookLocation(opts.hook);
       if (!location) {
-        console.error(chalk15.red("\u2717") + " Not in a git repository");
+        console.error(chalk16.red("\u2717") + " Not in a git repository");
         process.exit(1);
       }
       const hookPath = location.path;
-      if (!existsSync6(hookPath)) {
-        console.log(chalk15.dim("No hook file found."));
+      if (!existsSync7(hookPath)) {
+        console.log(chalk16.dim("No hook file found."));
         return;
       }
-      const content = await readFile5(hookPath, "utf-8");
+      const content = await readFile6(hookPath, "utf-8");
       if (!content.includes(HOOK_MARKER_START)) {
-        console.log(chalk15.dim("No memories hook found in " + opts.hook));
+        console.log(chalk16.dim("No memories hook found in " + opts.hook));
         return;
       }
       const regex = new RegExp(
@@ -2364,13 +2626,13 @@ hookCommand.addCommand(
       if (cleaned.trim() === "#!/bin/sh" || cleaned.trim() === "") {
         const { unlink: unlink2 } = await import("fs/promises");
         await unlink2(hookPath);
-        console.log(chalk15.green("\u2713") + ` Removed ${chalk15.dim(opts.hook)} hook (was memories-only)`);
+        console.log(chalk16.green("\u2713") + ` Removed ${chalk16.dim(opts.hook)} hook (was memories-only)`);
       } else {
-        await writeFile5(hookPath, cleaned, "utf-8");
-        console.log(chalk15.green("\u2713") + ` Removed memories section from ${chalk15.dim(opts.hook)}`);
+        await writeFile6(hookPath, cleaned, "utf-8");
+        console.log(chalk16.green("\u2713") + ` Removed memories section from ${chalk16.dim(opts.hook)}`);
       }
     } catch (error2) {
-      console.error(chalk15.red("\u2717") + " Failed to uninstall hook:", error2 instanceof Error ? error2.message : "Unknown error");
+      console.error(chalk16.red("\u2717") + " Failed to uninstall hook:", error2 instanceof Error ? error2.message : "Unknown error");
       process.exit(1);
     }
   })
@@ -2380,21 +2642,21 @@ hookCommand.addCommand(
     try {
       const hookPath = getHookLocation(opts.hook)?.path;
       if (!hookPath) {
-        console.error(chalk15.red("\u2717") + " Not in a git repository");
+        console.error(chalk16.red("\u2717") + " Not in a git repository");
         process.exit(1);
       }
-      if (!existsSync6(hookPath)) {
-        console.log(chalk15.dim("Not installed") + ` \u2014 no ${opts.hook} hook found`);
+      if (!existsSync7(hookPath)) {
+        console.log(chalk16.dim("Not installed") + ` \u2014 no ${opts.hook} hook found`);
         return;
       }
-      const content = await readFile5(hookPath, "utf-8");
+      const content = await readFile6(hookPath, "utf-8");
       if (content.includes(HOOK_MARKER_START)) {
-        console.log(chalk15.green("\u2713") + ` Installed in ${chalk15.dim(hookPath)}`);
+        console.log(chalk16.green("\u2713") + ` Installed in ${chalk16.dim(hookPath)}`);
       } else {
-        console.log(chalk15.dim("Not installed") + ` \u2014 ${opts.hook} exists but has no memories section`);
+        console.log(chalk16.dim("Not installed") + ` \u2014 ${opts.hook} exists but has no memories section`);
       }
     } catch (error2) {
-      console.error(chalk15.red("\u2717") + " Failed to check hook:", error2 instanceof Error ? error2.message : "Unknown error");
+      console.error(chalk16.red("\u2717") + " Failed to check hook:", error2 instanceof Error ? error2.message : "Unknown error");
       process.exit(1);
     }
   })
@@ -2405,9 +2667,9 @@ function escapeRegex(str) {
 // src/commands/ingest.ts
 import { Command as Command18 } from "commander";
-import chalk16 from "chalk";
-import { readFile as readFile6 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
+import chalk17 from "chalk";
+import { readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
 var SOURCES = [
   { name: "cursor", paths: [".cursor/rules/memories.mdc", ".cursorrules"], description: "Cursor rules" },
   { name: "claude", paths: ["CLAUDE.md"], description: "Claude Code instructions" },
@@ -2467,14 +2729,14 @@ function normalize(s) {
 var ingestCommand = new Command18("ingest").description("Import memories from existing IDE rule files").argument("[source]", "Source to import from (cursor, claude, agents, copilot, windsurf, cline, roo, gemini, or file path)").option("--type <type>", "Override type for all imported memories").option("--dry-run", "Preview without importing").option("--all", "Scan all known IDE rule file locations").option("--no-dedup", "Skip duplicate detection").action(async (source, opts) => {
   try {
     if (opts.type && !VALID_TYPES8.includes(opts.type)) {
-      console.error(chalk16.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES8.join(", ")}`);
+      console.error(chalk17.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES8.join(", ")}`);
       process.exit(1);
     }
     const filesToProcess = [];
     if (opts.all) {
       for (const src of SOURCES) {
         for (const p of src.paths) {
-          if (existsSync7(p)) {
+          if (existsSync8(p)) {
             filesToProcess.push({ name: src.name, path: p });
           }
         }
@@ -2483,27 +2745,27 @@ var ingestCommand = new Command18("ingest").description("Import memories from ex
       const known = SOURCES.find((s) => s.name === source);
       if (known) {
         for (const p of known.paths) {
-          if (existsSync7(p)) {
+          if (existsSync8(p)) {
             filesToProcess.push({ name: known.name, path: p });
             break;
           }
         }
         if (filesToProcess.length === 0) {
-          console.error(chalk16.red("\u2717") + ` No ${known.description} file found at: ${known.paths.join(", ")}`);
+          console.error(chalk17.red("\u2717") + ` No ${known.description} file found at: ${known.paths.join(", ")}`);
           process.exit(1);
         }
-      } else if (existsSync7(source)) {
+      } else if (existsSync8(source)) {
         filesToProcess.push({ name: "file", path: source });
       } else {
-        console.error(chalk16.red("\u2717") + ` Unknown source "${source}". Valid: ${SOURCES.map((s) => s.name).join(", ")}, or a file path`);
+        console.error(chalk17.red("\u2717") + ` Unknown source "${source}". Valid: ${SOURCES.map((s) => s.name).join(", ")}, or a file path`);
         process.exit(1);
       }
     } else {
-      console.error(chalk16.red("\u2717") + " Specify a source or use --all");
+      console.error(chalk17.red("\u2717") + " Specify a source or use --all");
       process.exit(1);
     }
     if (filesToProcess.length === 0) {
-      console.log(chalk16.dim("No IDE rule files found."));
+      console.log(chalk17.dim("No IDE rule files found."));
       return;
     }
     const existingSet = /* @__PURE__ */ new Set();
@@ -2517,29 +2779,29 @@ var ingestCommand = new Command18("ingest").description("Import memories from ex
     let totalImported = 0;
     let totalSkipped = 0;
     for (const file of filesToProcess) {
-      const content = await readFile6(file.path, "utf-8");
+      const content = await readFile7(file.path, "utf-8");
       if (content.includes(MARKER2)) {
-        console.log(chalk16.dim(`  Skipping ${file.path} (generated by memories.sh)`));
+        console.log(chalk17.dim(`  Skipping ${file.path} (generated by memories.sh)`));
         continue;
       }
       const memories = extractMemories(content);
       if (memories.length === 0) {
-        console.log(chalk16.dim(`  No importable memories found in ${file.path}`));
+        console.log(chalk17.dim(`  No importable memories found in ${file.path}`));
         continue;
       }
-      console.log(chalk16.bold(`
-  ${file.name}`) + chalk16.dim(` (${file.path}) \u2014 ${memories.length} items`));
+      console.log(chalk17.bold(`
+  ${file.name}`) + chalk17.dim(` (${file.path}) \u2014 ${memories.length} items`));
       for (const mem of memories) {
         const type = opts.type ?? mem.type;
         if (opts.dedup !== false && existingSet.has(normalize(mem.content))) {
           if (opts.dryRun) {
-            console.log(`    ${chalk16.dim("skip")}      ${chalk16.dim(mem.content)}`);
+            console.log(`    ${chalk17.dim("skip")}      ${chalk17.dim(mem.content)}`);
           }
           totalSkipped++;
           continue;
         }
         if (opts.dryRun) {
-          const typeColor = type === "rule" ? chalk16.blue : type === "decision" ? chalk16.yellow : type === "fact" ? chalk16.green : chalk16.dim;
+          const typeColor = type === "rule" ? chalk17.blue : type === "decision" ? chalk17.yellow : type === "fact" ? chalk17.green : chalk17.dim;
           console.log(`    ${typeColor(type.padEnd(9))} ${mem.content}`);
         } else {
           await addMemory(mem.content, { type });
@@ -2550,23 +2812,23 @@ var ingestCommand = new Command18("ingest").description("Import memories from ex
     }
     if (opts.dryRun) {
       const skipMsg = totalSkipped > 0 ? ` (${totalSkipped} duplicates skipped)` : "";
-      console.log(chalk16.dim(`
+      console.log(chalk17.dim(`
   Dry run \u2014 no memories imported.${skipMsg} Remove --dry-run to import.`));
     } else {
-      const skipMsg = totalSkipped > 0 ? chalk16.dim(` (${totalSkipped} duplicates skipped)`) : "";
-      console.log(chalk16.green("\n\u2713") + ` Imported ${totalImported} memories` + skipMsg);
+      const skipMsg = totalSkipped > 0 ? chalk17.dim(` (${totalSkipped} duplicates skipped)`) : "";
+      console.log(chalk17.green("\n\u2713") + ` Imported ${totalImported} memories` + skipMsg);
     }
   } catch (error2) {
-    console.error(chalk16.red("\u2717") + " Failed to ingest:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk17.red("\u2717") + " Failed to ingest:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/diff.ts
 import { Command as Command19 } from "commander";
-import chalk17 from "chalk";
-import { readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import chalk18 from "chalk";
+import { readFile as readFile8 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
 import { resolve as resolve2 } from "path";
 var MARKER3 = "Generated by memories.sh";
 var VALID_TYPES9 = ["rule", "decision", "fact", "note"];
@@ -2599,7 +2861,7 @@ function parseTypes2(raw) {
   const types = raw.split(",").map((s) => s.trim());
   for (const t of types) {
     if (!VALID_TYPES9.includes(t)) {
-      console.error(chalk17.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES9.join(", ")}`);
+      console.error(chalk18.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES9.join(", ")}`);
       process.exit(1);
     }
   }
@@ -2611,7 +2873,7 @@ async function fetchMemories2(types) {
 }
 async function diffTarget(target, currentMemories, outputPath) {
   const filePath = resolve2(outputPath ?? target.defaultPath);
-  if (!existsSync8(filePath)) {
+  if (!existsSync9(filePath)) {
     return {
       added: currentMemories.map((m) => m.content),
       removed: [],
@@ -2622,7 +2884,7 @@ async function diffTarget(target, currentMemories, outputPath) {
       generatedAt: null
     };
   }
-  const content = await readFile7(filePath, "utf-8");
+  const content = await readFile8(filePath, "utf-8");
   const isOurs = content.includes(MARKER3);
   const generatedAt = extractTimestamp(content);
   const fileMemories = extractFileMemories(content);
@@ -2638,7 +2900,7 @@ var diffCommand = new Command19("diff").description("Show what changed since las
     const memories = await fetchMemories2(types);
     const targetsToCheck = target && target !== "all" ? TARGETS2.filter((t) => t.name === target) : TARGETS2;
     if (target && target !== "all" && targetsToCheck.length === 0) {
-      console.error(chalk17.red("\u2717") + ` Unknown target "${target}". Valid: ${TARGETS2.map((t) => t.name).join(", ")}`);
+      console.error(chalk18.red("\u2717") + ` Unknown target "${target}". Valid: ${TARGETS2.map((t) => t.name).join(", ")}`);
       process.exit(1);
     }
     let anyStale = false;
@@ -2647,54 +2909,54 @@ var diffCommand = new Command19("diff").description("Show what changed since las
       if (!result.exists && !target) continue;
       const hasChanges = result.added.length > 0 || result.removed.length > 0;
       if (!result.exists) {
-        console.log(chalk17.bold(`
-  ${t.name}`) + chalk17.dim(` \u2192 ${result.filePath}`));
-        console.log(chalk17.yellow("    Not generated yet.") + chalk17.dim(` Run: memories generate ${t.name}`));
+        console.log(chalk18.bold(`
+  ${t.name}`) + chalk18.dim(` \u2192 ${result.filePath}`));
+        console.log(chalk18.yellow("    Not generated yet.") + chalk18.dim(` Run: memories generate ${t.name}`));
         anyStale = true;
         continue;
       }
       if (!result.isOurs) {
-        console.log(chalk17.bold(`
-  ${t.name}`) + chalk17.dim(` \u2192 ${result.filePath}`));
-        console.log(chalk17.dim("    Not managed by memories.sh (no marker found)"));
+        console.log(chalk18.bold(`
+  ${t.name}`) + chalk18.dim(` \u2192 ${result.filePath}`));
+        console.log(chalk18.dim("    Not managed by memories.sh (no marker found)"));
         continue;
       }
       if (!hasChanges) {
         if (target) {
-          console.log(chalk17.bold(`
-  ${t.name}`) + chalk17.dim(` \u2192 ${result.filePath}`));
-          const since = result.generatedAt ? chalk17.dim(` (generated ${formatRelative(result.generatedAt)})`) : "";
-          console.log(chalk17.green("    Up to date.") + since);
+          console.log(chalk18.bold(`
+  ${t.name}`) + chalk18.dim(` \u2192 ${result.filePath}`));
+          const since = result.generatedAt ? chalk18.dim(` (generated ${formatRelative(result.generatedAt)})`) : "";
+          console.log(chalk18.green("    Up to date.") + since);
         }
         continue;
       }
       anyStale = true;
-      console.log(chalk17.bold(`
-  ${t.name}`) + chalk17.dim(` \u2192 ${result.filePath}`));
+      console.log(chalk18.bold(`
+  ${t.name}`) + chalk18.dim(` \u2192 ${result.filePath}`));
       if (result.generatedAt) {
-        console.log(chalk17.dim(`    Generated ${formatRelative(result.generatedAt)}`));
+        console.log(chalk18.dim(`    Generated ${formatRelative(result.generatedAt)}`));
       }
       for (const a of result.added) {
-        console.log(chalk17.green(`    + ${a}`));
+        console.log(chalk18.green(`    + ${a}`));
       }
       for (const r of result.removed) {
-        console.log(chalk17.red(`    - ${r}`));
+        console.log(chalk18.red(`    - ${r}`));
       }
       if (result.unchanged > 0) {
-        console.log(chalk17.dim(`    ${result.unchanged} unchanged`));
+        console.log(chalk18.dim(`    ${result.unchanged} unchanged`));
       }
     }
     if (!anyStale) {
       if (target) {
       } else {
-        console.log(chalk17.green("\n  All generated files are up to date."));
+        console.log(chalk18.green("\n  All generated files are up to date."));
       }
     } else {
-      console.log(chalk17.dim(`
-  Run ${chalk17.bold("memories generate")} to update stale files.`));
+      console.log(chalk18.dim(`
+  Run ${chalk18.bold("memories generate")} to update stale files.`));
     }
   } catch (error2) {
-    console.error(chalk17.red("\u2717") + " Diff failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk18.red("\u2717") + " Diff failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -2715,7 +2977,7 @@ function formatRelative(isoDate) {
 // src/commands/tag.ts
 import { Command as Command20 } from "commander";
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 var VALID_TYPES10 = ["rule", "decision", "fact", "note"];
 function buildWhere(filters) {
   const conditions = ["deleted_at IS NULL"];
@@ -2767,12 +3029,12 @@ tagCommand.addCommand(
         updated++;
       }
       if (opts.dryRun) {
-        console.log(chalk18.dim(`Dry run \u2014 would tag ${updated} memories with "${tag}" (${skipped} already tagged)`));
+        console.log(chalk19.dim(`Dry run \u2014 would tag ${updated} memories with "${tag}" (${skipped} already tagged)`));
       } else {
-        console.log(chalk18.green("\u2713") + ` Tagged ${updated} memories with "${tag}"` + (skipped > 0 ? chalk18.dim(` (${skipped} already tagged)`) : ""));
+        console.log(chalk19.green("\u2713") + ` Tagged ${updated} memories with "${tag}"` + (skipped > 0 ? chalk19.dim(` (${skipped} already tagged)`) : ""));
       }
     } catch (error2) {
-      console.error(chalk18.red("\u2717") + ` Failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+      console.error(chalk19.red("\u2717") + ` Failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
       process.exit(1);
     }
   })
@@ -2801,12 +3063,12 @@ tagCommand.addCommand(
         updated++;
       }
       if (opts.dryRun) {
-        console.log(chalk18.dim(`Dry run \u2014 would remove "${tag}" from ${updated} memories`));
+        console.log(chalk19.dim(`Dry run \u2014 would remove "${tag}" from ${updated} memories`));
       } else {
-        console.log(chalk18.green("\u2713") + ` Removed "${tag}" from ${updated} memories`);
+        console.log(chalk19.green("\u2713") + ` Removed "${tag}" from ${updated} memories`);
       }
     } catch (error2) {
-      console.error(chalk18.red("\u2717") + ` Failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+      console.error(chalk19.red("\u2717") + ` Failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
       process.exit(1);
     }
   })
@@ -2827,15 +3089,15 @@ tagCommand.addCommand(
         }
       }
       if (counts.size === 0) {
-        console.log(chalk18.dim("No tags found."));
+        console.log(chalk19.dim("No tags found."));
         return;
       }
       const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]);
       for (const [tag, count] of sorted) {
-        console.log(`  ${chalk18.bold(tag)} ${chalk18.dim(`(${count})`)}`);
+        console.log(`  ${chalk19.bold(tag)} ${chalk19.dim(`(${count})`)}`);
       }
     } catch (error2) {
-      console.error(chalk18.red("\u2717") + ` Failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+      console.error(chalk19.red("\u2717") + ` Failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
       process.exit(1);
     }
   })
@@ -2843,7 +3105,7 @@ tagCommand.addCommand(
 // src/commands/validate.ts
 import { Command as Command21 } from "commander";
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 function levenshtein(a, b) {
   const m = a.length, n = b.length;
   const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
@@ -2904,10 +3166,10 @@ var validateCommand = new Command21("validate").description("Check for conflicti
     const projectId = getProjectId() ?? void 0;
     const rules = await getRules({ projectId });
     if (rules.length === 0) {
-      console.log(chalk19.dim("No rules to validate."));
+      console.log(chalk20.dim("No rules to validate."));
       return;
     }
-    console.log(chalk19.bold("\u{1F50D} Validating rules...\n"));
+    console.log(chalk20.bold("\u{1F50D} Validating rules...\n"));
     const issues = [];
     for (let i = 0; i < rules.length; i++) {
       for (let j = i + 1; j < rules.length; j++) {
@@ -2939,41 +3201,41 @@ var validateCommand = new Command21("validate").description("Check for conflicti
       }
     }
     if (issues.length === 0) {
-      console.log(chalk19.green("\u2713") + ` ${rules.length} rules validated, no issues found.`);
+      console.log(chalk20.green("\u2713") + ` ${rules.length} rules validated, no issues found.`);
       return;
     }
-    console.log(chalk19.yellow("\u26A0\uFE0F  Potential Issues Found:\n"));
+    console.log(chalk20.yellow("\u26A0\uFE0F  Potential Issues Found:\n"));
     let num = 1;
     for (const issue of issues) {
       const typeLabel = issue.type === "duplicate" ? "Exact duplicate" : issue.type === "near-duplicate" ? "Near duplicate" : "Potential conflict";
-      const color = issue.type === "conflict" ? chalk19.red : chalk19.yellow;
+      const color = issue.type === "conflict" ? chalk20.red : chalk20.yellow;
       console.log(color(`${num}. ${typeLabel}${issue.detail ? ` (${issue.detail})` : ""}:`));
       console.log(`   \u{1F4CC} "${issue.memory1.content}"`);
       console.log(`   \u{1F4CC} "${issue.memory2.content}"`);
       if (issue.type === "duplicate" || issue.type === "near-duplicate") {
-        console.log(chalk19.dim("   \u2192 Consider merging these rules\n"));
+        console.log(chalk20.dim("   \u2192 Consider merging these rules\n"));
       } else {
-        console.log(chalk19.dim("   \u2192 These rules may contradict each other\n"));
+        console.log(chalk20.dim("   \u2192 These rules may contradict each other\n"));
       }
       num++;
     }
     const duplicates = issues.filter((i) => i.type === "duplicate" || i.type === "near-duplicate").length;
     const conflicts = issues.filter((i) => i.type === "conflict").length;
-    console.log(chalk19.bold(`${rules.length} rules validated, ${issues.length} issues found`));
-    if (duplicates > 0) console.log(chalk19.dim(`  ${duplicates} duplicate(s)`));
-    if (conflicts > 0) console.log(chalk19.dim(`  ${conflicts} conflict(s)`));
+    console.log(chalk20.bold(`${rules.length} rules validated, ${issues.length} issues found`));
+    if (duplicates > 0) console.log(chalk20.dim(`  ${duplicates} duplicate(s)`));
+    if (conflicts > 0) console.log(chalk20.dim(`  ${conflicts} conflict(s)`));
     if (opts.fix) {
-      console.log(chalk19.dim("\n--fix mode not yet implemented. Review issues above manually."));
+      console.log(chalk20.dim("\n--fix mode not yet implemented. Review issues above manually."));
     }
   } catch (error2) {
-    console.error(chalk19.red("\u2717") + " Validation failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk20.red("\u2717") + " Validation failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/stale.ts
 import { Command as Command22 } from "commander";
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 import { createInterface as createInterface2 } from "readline";
 var TYPE_ICONS4 = {
   rule: "\u{1F4CC}",
@@ -2996,7 +3258,7 @@ var staleCommand = new Command22("stale").description("Find memories that haven'
     const days = parseInt(opts.days, 10);
     const projectId = getProjectId() ?? void 0;
     if (isNaN(days) || days <= 0) {
-      console.error(chalk20.red("\u2717") + " --days must be a positive number");
+      console.error(chalk21.red("\u2717") + " --days must be a positive number");
       process.exit(1);
     }
     let sql = `
@@ -3019,25 +3281,25 @@ var staleCommand = new Command22("stale").description("Find memories that haven'
       return;
     }
     if (stale.length === 0) {
-      console.log(chalk20.green("\u2713") + ` No memories older than ${days} days.`);
+      console.log(chalk21.green("\u2713") + ` No memories older than ${days} days.`);
       return;
     }
-    console.log(chalk20.bold(`\u23F0 Stale Memories (not updated in ${days}+ days)
+    console.log(chalk21.bold(`\u23F0 Stale Memories (not updated in ${days}+ days)
 `));
     for (const m of stale.slice(0, 30)) {
       const icon = TYPE_ICONS4[m.type] || "\u{1F4DD}";
-      const scope = m.scope === "global" ? chalk20.dim("G") : chalk20.dim("P");
+      const scope = m.scope === "global" ? chalk21.dim("G") : chalk21.dim("P");
       const preview = m.content.length > 50 ? m.content.slice(0, 47) + "..." : m.content;
-      console.log(`  ${icon} ${scope} ${chalk20.dim(m.id)}  ${preview}  ${chalk20.yellow(`${m.days_old}d`)}`);
+      console.log(`  ${icon} ${scope} ${chalk21.dim(m.id)}  ${preview}  ${chalk21.yellow(`${m.days_old}d`)}`);
     }
     if (stale.length > 30) {
-      console.log(chalk20.dim(`  ... and ${stale.length - 30} more`));
+      console.log(chalk21.dim(`  ... and ${stale.length - 30} more`));
     }
     console.log("");
     console.log(`${stale.length} stale ${stale.length === 1 ? "memory" : "memories"} found`);
-    console.log(chalk20.dim("Run 'memories review' to clean up interactively"));
+    console.log(chalk21.dim("Run 'memories review' to clean up interactively"));
   } catch (error2) {
-    console.error(chalk20.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk21.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -3058,18 +3320,18 @@ var reviewCommand = new Command22("review").description("Interactively review an
     });
     const stale = result.rows;
     if (stale.length === 0) {
-      console.log(chalk20.green("\u2713") + ` No stale memories to review.`);
+      console.log(chalk21.green("\u2713") + ` No stale memories to review.`);
       return;
     }
-    console.log(chalk20.bold(`
+    console.log(chalk21.bold(`
 Reviewing ${stale.length} stale memories...
 `));
     let kept = 0, deleted = 0, skipped = 0;
     for (const m of stale) {
       const icon = TYPE_ICONS4[m.type] || "\u{1F4DD}";
-      console.log(`${icon} ${chalk20.bold(m.type.toUpperCase())} (${m.scope})`);
+      console.log(`${icon} ${chalk21.bold(m.type.toUpperCase())} (${m.scope})`);
       console.log(`   "${m.content}"`);
-      console.log(chalk20.dim(`   Last updated: ${m.days_old} days ago`));
+      console.log(chalk21.dim(`   Last updated: ${m.days_old} days ago`));
       console.log("");
       const answer = await prompt("   [k]eep  [d]elete  [s]kip  [q]uit > ");
       if (answer === "q") {
@@ -3077,31 +3339,31 @@ Reviewing ${stale.length} stale memories...
         break;
       } else if (answer === "d") {
         await forgetMemory(m.id);
-        console.log(chalk20.green("   \u2713 Deleted\n"));
+        console.log(chalk21.green("   \u2713 Deleted\n"));
         deleted++;
       } else if (answer === "k") {
         await db.execute({
           sql: "UPDATE memories SET updated_at = datetime('now') WHERE id = ?",
           args: [m.id]
         });
-        console.log(chalk20.green("   \u2713 Kept (marked as reviewed)\n"));
+        console.log(chalk21.green("   \u2713 Kept (marked as reviewed)\n"));
         kept++;
       } else {
-        console.log(chalk20.dim("   Skipped\n"));
+        console.log(chalk21.dim("   Skipped\n"));
         skipped++;
       }
     }
-    console.log(chalk20.bold("\nReview Summary:"));
+    console.log(chalk21.bold("\nReview Summary:"));
     console.log(`  Kept: ${kept}, Deleted: ${deleted}, Skipped: ${skipped}`);
   } catch (error2) {
-    console.error(chalk20.red("\u2717") + " Review failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk21.red("\u2717") + " Review failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/link.ts
 import { Command as Command23 } from "commander";
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 import { nanoid as nanoid3 } from "nanoid";
 var LINK_TYPES = ["related", "supports", "supersedes", "contradicts"];
 var TYPE_ICONS5 = {
@@ -3167,17 +3429,17 @@ var linkCommand = new Command23("link").description("Link two related memories t
     await ensureLinksTable();
     const db = await getDb();
     if (!LINK_TYPES.includes(opts.type)) {
-      console.error(chalk21.red("\u2717") + ` Invalid link type. Valid: ${LINK_TYPES.join(", ")}`);
+      console.error(chalk22.red("\u2717") + ` Invalid link type. Valid: ${LINK_TYPES.join(", ")}`);
       process.exit(1);
     }
     const m1 = await getMemoryById(id1);
     const m2 = await getMemoryById(id2);
     if (!m1) {
-      console.error(chalk21.red("\u2717") + ` Memory ${id1} not found`);
+      console.error(chalk22.red("\u2717") + ` Memory ${id1} not found`);
       process.exit(1);
     }
     if (!m2) {
-      console.error(chalk21.red("\u2717") + ` Memory ${id2} not found`);
+      console.error(chalk22.red("\u2717") + ` Memory ${id2} not found`);
       process.exit(1);
     }
     const existing = await db.execute({
@@ -3186,7 +3448,7 @@ var linkCommand = new Command23("link").description("Link two related memories t
       args: [id1, id2, id2, id1]
     });
     if (existing.rows.length > 0) {
-      console.log(chalk21.yellow("!") + " These memories are already linked");
+      console.log(chalk22.yellow("!") + " These memories are already linked");
       return;
     }
     const linkId = nanoid3(12);
@@ -3196,12 +3458,12 @@ var linkCommand = new Command23("link").description("Link two related memories t
     });
     const icon1 = TYPE_ICONS5[m1.type] || "\u{1F4DD}";
     const icon2 = TYPE_ICONS5[m2.type] || "\u{1F4DD}";
-    console.log(chalk21.green("\u2713") + " Linked memories:");
-    console.log(`  ${icon1} ${chalk21.dim(id1)} "${m1.content.slice(0, 40)}..."`);
-    console.log(`    \u2193 ${chalk21.cyan(opts.type)}`);
-    console.log(`  ${icon2} ${chalk21.dim(id2)} "${m2.content.slice(0, 40)}..."`);
+    console.log(chalk22.green("\u2713") + " Linked memories:");
+    console.log(`  ${icon1} ${chalk22.dim(id1)} "${m1.content.slice(0, 40)}..."`);
+    console.log(`    \u2193 ${chalk22.cyan(opts.type)}`);
+    console.log(`  ${icon2} ${chalk22.dim(id2)} "${m2.content.slice(0, 40)}..."`);
   } catch (error2) {
-    console.error(chalk21.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk22.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -3215,12 +3477,12 @@ var unlinkCommand = new Command23("unlink").description("Remove link between two
       args: [id1, id2, id2, id1]
     });
     if (result.rowsAffected === 0) {
-      console.log(chalk21.yellow("!") + " No link found between these memories");
+      console.log(chalk22.yellow("!") + " No link found between these memories");
     } else {
-      console.log(chalk21.green("\u2713") + ` Unlinked ${id1} and ${id2}`);
+      console.log(chalk22.green("\u2713") + ` Unlinked ${id1} and ${id2}`);
     }
   } catch (error2) {
-    console.error(chalk21.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk22.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -3228,16 +3490,16 @@ var showCommand = new Command23("show").description("Show a memory with its link
   try {
     const memory = await getMemoryById(id);
     if (!memory) {
-      console.error(chalk21.red("\u2717") + ` Memory ${id} not found`);
+      console.error(chalk22.red("\u2717") + ` Memory ${id} not found`);
       process.exit(1);
     }
     const icon = TYPE_ICONS5[memory.type] || "\u{1F4DD}";
     const scope = memory.scope === "global" ? "Global" : "Project";
     console.log("");
-    console.log(`${icon} ${chalk21.bold(memory.type.toUpperCase())} (${scope})`);
-    console.log(chalk21.dim(`ID: ${memory.id}`));
-    console.log(chalk21.dim(`Created: ${memory.created_at}`));
-    if (memory.tags) console.log(chalk21.dim(`Tags: ${memory.tags}`));
+    console.log(`${icon} ${chalk22.bold(memory.type.toUpperCase())} (${scope})`);
+    console.log(chalk22.dim(`ID: ${memory.id}`));
+    console.log(chalk22.dim(`Created: ${memory.created_at}`));
+    if (memory.tags) console.log(chalk22.dim(`Tags: ${memory.tags}`));
     console.log("");
     console.log(memory.content);
     if (opts.links) {
@@ -3245,52 +3507,52 @@ var showCommand = new Command23("show").description("Show a memory with its link
       const linked = await getLinkedMemories(id);
       if (linked.length > 0) {
         console.log("");
-        console.log(chalk21.bold("Linked Memories:"));
+        console.log(chalk22.bold("Linked Memories:"));
         for (const { memory: m, linkType, direction } of linked) {
           const mIcon = TYPE_ICONS5[m.type] || "\u{1F4DD}";
           const arrow = direction === "to" ? "\u2192" : "\u2190";
           const preview = m.content.length > 50 ? m.content.slice(0, 47) + "..." : m.content;
-          console.log(`  ${arrow} ${chalk21.cyan(linkType)}: ${mIcon} ${preview}`);
+          console.log(`  ${arrow} ${chalk22.cyan(linkType)}: ${mIcon} ${preview}`);
         }
       }
     }
     console.log("");
   } catch (error2) {
-    console.error(chalk21.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk22.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/template.ts
 import { Command as Command24 } from "commander";
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 var templateCommand = new Command24("template").description("Manage and use memory templates");
 templateCommand.command("list").description("List available templates").action(() => {
   const templates = listTemplates();
-  console.log(chalk22.bold("\nAvailable Templates:\n"));
+  console.log(chalk23.bold("\nAvailable Templates:\n"));
   for (const t of templates) {
     const typeIcon = t.type === "rule" ? "\u{1F4CC}" : t.type === "decision" ? "\u{1F4A1}" : t.type === "fact" ? "\u{1F4CB}" : "\u{1F4DD}";
-    console.log(`  ${chalk22.cyan(t.name.padEnd(15))} ${typeIcon} ${t.description}`);
+    console.log(`  ${chalk23.cyan(t.name.padEnd(15))} ${typeIcon} ${t.description}`);
   }
   console.log("");
-  console.log(chalk22.dim("Use: memories template use <name>"));
+  console.log(chalk23.dim("Use: memories template use <name>"));
   console.log("");
 });
 templateCommand.command("show <name>").description("Show template details and fields").action((name) => {
   const template = getTemplate(name);
   if (!template) {
-    console.error(chalk22.red("\u2717") + ` Template "${name}" not found`);
-    console.log(chalk22.dim("Run 'memories template list' to see available templates"));
+    console.error(chalk23.red("\u2717") + ` Template "${name}" not found`);
+    console.log(chalk23.dim("Run 'memories template list' to see available templates"));
     process.exit(1);
   }
   const typeIcon = template.type === "rule" ? "\u{1F4CC}" : template.type === "decision" ? "\u{1F4A1}" : template.type === "fact" ? "\u{1F4CB}" : "\u{1F4DD}";
   console.log("");
-  console.log(chalk22.bold(template.name) + ` ${typeIcon} ${template.type}`);
-  console.log(chalk22.dim(template.description));
+  console.log(chalk23.bold(template.name) + ` ${typeIcon} ${template.type}`);
+  console.log(chalk23.dim(template.description));
   console.log("");
-  console.log(chalk22.bold("Fields:"));
+  console.log(chalk23.bold("Fields:"));
   for (const field of template.fields) {
-    const required = field.required ? chalk22.red("*") : chalk22.dim("(optional)");
+    const required = field.required ? chalk23.red("*") : chalk23.dim("(optional)");
     console.log(`  ${field.name.padEnd(15)} ${required}  ${field.prompt}`);
   }
   console.log("");
@@ -3298,13 +3560,13 @@ templateCommand.command("show <name>").description("Show template details and fi
 templateCommand.command("use <name>").description("Create a memory using a template").option("-g, --global", "Store as global memory").action(async (name, opts) => {
   const template = getTemplate(name);
   if (!template) {
-    console.error(chalk22.red("\u2717") + ` Template "${name}" not found`);
-    console.log(chalk22.dim("Run 'memories template list' to see available templates"));
+    console.error(chalk23.red("\u2717") + ` Template "${name}" not found`);
+    console.log(chalk23.dim("Run 'memories template list' to see available templates"));
     process.exit(1);
   }
   console.log("");
-  console.log(chalk22.bold(`Using template: ${template.name}`));
-  console.log(chalk22.dim(template.description));
+  console.log(chalk23.bold(`Using template: ${template.name}`));
+  console.log(chalk23.dim(template.description));
   console.log("");
   try {
     const content = await fillTemplate(template);
@@ -3313,8 +3575,8 @@ templateCommand.command("use <name>").description("Create a memory using a templ
       global: opts.global
     });
     console.log("");
-    console.log(chalk22.green("\u2713") + ` Created ${template.type}: ${chalk22.dim(memory.id)}`);
-    console.log(chalk22.dim(`  "${content}"`));
+    console.log(chalk23.green("\u2713") + ` Created ${template.type}: ${chalk23.dim(memory.id)}`);
+    console.log(chalk23.dim(`  "${content}"`));
   } catch (error2) {
     if (error2.message?.includes("User force closed")) {
       console.log("\nCancelled.");
@@ -3326,7 +3588,7 @@ templateCommand.command("use <name>").description("Create a memory using a templ
 // src/commands/history.ts
 import { Command as Command25 } from "commander";
-import chalk23 from "chalk";
+import chalk24 from "chalk";
 var TYPE_ICONS6 = {
   rule: "\u{1F4CC}",
   decision: "\u{1F4A1}",
@@ -3375,38 +3637,38 @@ var historyCommand = new Command25("history").description("View version history
       return;
     }
     if (!memory && history.length === 0) {
-      console.error(chalk23.red("\u2717") + ` Memory ${id} not found`);
+      console.error(chalk24.red("\u2717") + ` Memory ${id} not found`);
       process.exit(1);
     }
     const icon = memory ? TYPE_ICONS6[memory.type] || "\u{1F4DD}" : "\u{1F4DD}";
     console.log("");
     if (memory) {
-      console.log(`${icon} ${chalk23.bold(memory.content)}`);
-      console.log(chalk23.dim(`ID: ${id}`));
+      console.log(`${icon} ${chalk24.bold(memory.content)}`);
+      console.log(chalk24.dim(`ID: ${id}`));
     } else {
-      console.log(chalk23.dim(`Memory ${id} (deleted)`));
+      console.log(chalk24.dim(`Memory ${id} (deleted)`));
     }
     console.log("");
     if (history.length === 0) {
-      console.log(chalk23.dim("No version history recorded."));
-      console.log(chalk23.dim("History is recorded when memories are updated."));
+      console.log(chalk24.dim("No version history recorded."));
+      console.log(chalk24.dim("History is recorded when memories are updated."));
       return;
     }
-    console.log(chalk23.bold("History:"));
-    console.log(chalk23.dim("\u2500".repeat(60)));
+    console.log(chalk24.bold("History:"));
+    console.log(chalk24.dim("\u2500".repeat(60)));
     for (const entry of history) {
       const changeIcon = entry.change_type === "created" ? "+" : entry.change_type === "updated" ? "~" : "-";
-      const changeColor = entry.change_type === "created" ? chalk23.green : entry.change_type === "updated" ? chalk23.yellow : chalk23.red;
+      const changeColor = entry.change_type === "created" ? chalk24.green : entry.change_type === "updated" ? chalk24.yellow : chalk24.red;
       const date = new Date(entry.changed_at).toLocaleDateString();
       const time = new Date(entry.changed_at).toLocaleTimeString();
-      console.log(`  ${changeColor(changeIcon)} v${entry.version}  ${chalk23.dim(date + " " + time)}`);
+      console.log(`  ${changeColor(changeIcon)} v${entry.version}  ${chalk24.dim(date + " " + time)}`);
       console.log(`    "${entry.content.slice(0, 60)}${entry.content.length > 60 ? "..." : ""}"`);
     }
-    console.log(chalk23.dim("\u2500".repeat(60)));
-    console.log(chalk23.dim(`
+    console.log(chalk24.dim("\u2500".repeat(60)));
+    console.log(chalk24.dim(`
 Use 'memories revert ${id} --to <version>' to restore a previous version`));
   } catch (error2) {
-    console.error(chalk23.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk24.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -3416,7 +3678,7 @@ var revertCommand = new Command25("revert").description("Revert a memory to a pr
     const db = await getDb();
     const version = parseInt(opts.to.replace("v", ""), 10);
     if (isNaN(version) || version < 1) {
-      console.error(chalk23.red("\u2717") + " Invalid version number");
+      console.error(chalk24.red("\u2717") + " Invalid version number");
       process.exit(1);
     }
     const result = await db.execute({
@@ -3428,7 +3690,7 @@ var revertCommand = new Command25("revert").description("Revert a memory to a pr
     const history = result.rows;
     const targetEntry = history.find((h) => h.version === version);
     if (!targetEntry) {
-      console.error(chalk23.red("\u2717") + ` Version ${version} not found for memory ${id}`);
+      console.error(chalk24.red("\u2717") + ` Version ${version} not found for memory ${id}`);
       process.exit(1);
     }
     const current = await getMemoryById(id);
@@ -3440,20 +3702,20 @@ var revertCommand = new Command25("revert").description("Revert a memory to a pr
       tags: targetEntry.tags ? targetEntry.tags.split(",") : void 0
     });
     if (!updated) {
-      console.error(chalk23.red("\u2717") + ` Failed to revert memory ${id}`);
+      console.error(chalk24.red("\u2717") + ` Failed to revert memory ${id}`);
       process.exit(1);
     }
-    console.log(chalk23.green("\u2713") + ` Reverted memory ${chalk23.dim(id)} to version ${version}`);
-    console.log(chalk23.dim(`  "${targetEntry.content.slice(0, 60)}${targetEntry.content.length > 60 ? "..." : ""}"`));
+    console.log(chalk24.green("\u2713") + ` Reverted memory ${chalk24.dim(id)} to version ${version}`);
+    console.log(chalk24.dim(`  "${targetEntry.content.slice(0, 60)}${targetEntry.content.length > 60 ? "..." : ""}"`));
   } catch (error2) {
-    console.error(chalk23.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk24.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/embed.ts
 import { Command as Command26 } from "commander";
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 import ora2 from "ora";
 var embedCommand = new Command26("embed").description("Generate embeddings for memories (enables semantic search)").option("--all", "Re-embed all memories, even those with existing embeddings").option("--dry-run", "Show what would be embedded without doing it").action(async (opts) => {
   try {
@@ -3466,24 +3728,24 @@ var embedCommand = new Command26("embed").description("Generate embeddings for m
     const result = await db.execute(sql);
     const memories = result.rows;
     if (memories.length === 0) {
-      console.log(chalk24.green("\u2713") + " All memories already have embeddings.");
+      console.log(chalk25.green("\u2713") + " All memories already have embeddings.");
       return;
     }
     if (opts.dryRun) {
-      console.log(chalk24.bold(`Would embed ${memories.length} memories:
+      console.log(chalk25.bold(`Would embed ${memories.length} memories:
 `));
       for (const m of memories.slice(0, 10)) {
         const preview = m.content.length > 60 ? m.content.slice(0, 57) + "..." : m.content;
-        console.log(`  ${chalk24.dim(m.id)}  ${preview}`);
+        console.log(`  ${chalk25.dim(m.id)}  ${preview}`);
       }
       if (memories.length > 10) {
-        console.log(chalk24.dim(`  ... and ${memories.length - 10} more`));
+        console.log(chalk25.dim(`  ... and ${memories.length - 10} more`));
       }
       return;
     }
-    console.log(chalk24.bold(`Embedding ${memories.length} memories...
+    console.log(chalk25.bold(`Embedding ${memories.length} memories...
 `));
-    console.log(chalk24.dim("First run downloads the model (~30MB). Subsequent runs are faster.\n"));
+    console.log(chalk25.dim("First run downloads the model (~30MB). Subsequent runs are faster.\n"));
     const spinner = ora2("Loading embedding model...").start();
     let embedded = 0;
     let failed = 0;
@@ -3498,22 +3760,22 @@ var embedCommand = new Command26("embed").description("Generate embeddings for m
       }
     }
     spinner.stop();
-    console.log(chalk24.green("\u2713") + ` Embedded ${embedded} memories`);
+    console.log(chalk25.green("\u2713") + ` Embedded ${embedded} memories`);
     if (failed > 0) {
-      console.log(chalk24.yellow("\u26A0") + ` ${failed} memories failed to embed`);
+      console.log(chalk25.yellow("\u26A0") + ` ${failed} memories failed to embed`);
     }
     console.log("");
-    console.log(chalk24.dim("Now you can use semantic search:"));
-    console.log(chalk24.cyan('  memories search --semantic "your query"'));
+    console.log(chalk25.dim("Now you can use semantic search:"));
+    console.log(chalk25.cyan('  memories search --semantic "your query"'));
   } catch (error2) {
-    console.error(chalk24.red("\u2717") + " Embedding failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    console.error(chalk25.red("\u2717") + " Embedding failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
 // src/commands/login.ts
 import { Command as Command27 } from "commander";
-import chalk25 from "chalk";
+import chalk26 from "chalk";
 import ora3 from "ora";
 import { randomBytes } from "crypto";
 import { execFile } from "child_process";
@@ -3528,18 +3790,18 @@ var loginCommand = new Command27("login").description("Log in to memories.sh to
   banner();
   const existing = await readAuth();
   if (existing) {
-    warn(`Already logged in as ${chalk25.bold(existing.email)}`);
-    dim(`Run ${chalk25.cyan("memories logout")} to sign out first.`);
+    warn(`Already logged in as ${chalk26.bold(existing.email)}`);
+    dim(`Run ${chalk26.cyan("memories logout")} to sign out first.`);
     return;
   }
   box(
-    chalk25.bold("Pro features include:\n\n") + chalk25.dim("\u2192 ") + "Cloud sync & backup\n" + chalk25.dim("\u2192 ") + "Cross-device access\n" + chalk25.dim("\u2192 ") + "Web dashboard\n" + chalk25.dim("\u2192 ") + "Priority support",
+    chalk26.bold("Pro features include:\n\n") + chalk26.dim("\u2192 ") + "Cloud sync & backup\n" + chalk26.dim("\u2192 ") + "Cross-device access\n" + chalk26.dim("\u2192 ") + "Web dashboard\n" + chalk26.dim("\u2192 ") + "Priority support",
     "Upgrade to Pro"
   );
   const code = randomBytes(16).toString("hex");
   const authUrl = `${opts.apiUrl}/app/auth/cli?code=${code}`;
-  console.log(chalk25.bold("Open this URL in your browser:\n"));
-  console.log(`  ${chalk25.cyan(authUrl)}
+  console.log(chalk26.bold("Open this URL in your browser:\n"));
+  console.log(`  ${chalk26.cyan(authUrl)}
 `);
   try {
     openBrowser(authUrl);
@@ -3569,11 +3831,11 @@ var loginCommand = new Command27("login").description("Log in to memories.sh to
         });
         spinner.stop();
         console.log("");
-        success(`Logged in as ${chalk25.bold(data.email)}`);
+        success(`Logged in as ${chalk26.bold(data.email)}`);
         dim("Your cloud database has been provisioned automatically.");
         nextSteps([
-          `${chalk25.cyan("memories sync")} ${chalk25.dim("to sync your memories")}`,
-          `${chalk25.cyan("memories.sh/app")} ${chalk25.dim("to view your dashboard")}`
+          `${chalk26.cyan("memories sync")} ${chalk26.dim("to sync your memories")}`,
+          `${chalk26.cyan("memories.sh/app")} ${chalk26.dim("to view your dashboard")}`
         ]);
         return;
       }
@@ -3601,77 +3863,112 @@ var logoutCommand = new Command27("logout").description("Log out of memories.sh"
 // src/commands/files.ts
 import { Command as Command28 } from "commander";
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 import ora4 from "ora";
 import { nanoid as nanoid4 } from "nanoid";
 import { createHash } from "crypto";
-import { readFile as readFile8, writeFile as writeFile6, mkdir as mkdir4, readdir } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import { join as join8, dirname as dirname2 } from "path";
-import { homedir as homedir4 } from "os";
+import { readFile as readFile9, writeFile as writeFile7, mkdir as mkdir5, readdir, stat } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import { join as join9, dirname as dirname3 } from "path";
+import { homedir as homedir5 } from "os";
 function hashContent(content) {
   return createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
-var CONFIG_DIRS = [
-  { dir: ".agents", name: "Agents" },
-  { dir: ".claude", name: "Claude" },
-  { dir: ".cursor", name: "Cursor" },
-  { dir: ".github/copilot", name: "Copilot" },
-  { dir: ".windsurf", name: "Windsurf" },
-  { dir: ".cline", name: "Cline" },
-  { dir: ".codex", name: "Codex" },
-  { dir: ".gemini", name: "Gemini" },
-  { dir: ".roo", name: "Roo" },
-  { dir: ".amp", name: "Amp" }
+var SYNC_TARGETS = [
+  // .agents - Agent instruction files, commands, tasks, and skills
+  { dir: ".agents", files: ["AGENTS.md"] },
+  { dir: ".agents/commands", pattern: /\.md$/ },
+  { dir: ".agents/tasks", pattern: /\.(md|txt)$/ },
+  { dir: ".agents/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .claude - Claude Code instructions, commands, rules, hooks, and tasks
+  { dir: ".claude", files: ["CLAUDE.md", "settings.json", "settings.local.json"] },
+  { dir: ".claude/commands", pattern: /\.md$/ },
+  { dir: ".claude/rules", pattern: /\.(md|rules)$/ },
+  { dir: ".claude/hooks", pattern: /\.(json|sh)$/ },
+  { dir: ".claude/tasks", pattern: /\.(md|txt)$/ },
+  { dir: ".claude/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .cursor - Cursor rules and MCP config
+  { dir: ".cursor", files: ["mcp.json", "rules.md"] },
+  { dir: ".cursor/rules", pattern: /\.(md|mdc|txt)$/ },
+  { dir: ".cursor/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .codex - Codex config, rules, and tasks
+  { dir: ".codex", files: ["config.toml", "AGENTS.md", "instructions.md"] },
+  { dir: ".codex/rules", pattern: /\.(md|rules)$/ },
+  { dir: ".codex/tasks", pattern: /\.(md|txt)$/ },
+  { dir: ".codex/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .windsurf - Windsurf rules
+  { dir: ".windsurf", files: ["rules.md", "cascade.json"] },
+  { dir: ".windsurf/rules", pattern: /\.(md|txt)$/ },
+  { dir: ".windsurf/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .cline - Cline rules
+  { dir: ".cline", files: ["rules.md", "CLINE.md", "cline_rules.md"] },
+  { dir: ".cline/rules", pattern: /\.(md|txt)$/ },
+  { dir: ".cline/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .github/copilot - Copilot instructions
+  { dir: ".github/copilot", files: ["instructions.md"] },
+  // .gemini - Gemini instructions
+  { dir: ".gemini", files: ["GEMINI.md", "settings.json"] },
+  { dir: ".gemini/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .roo - Roo config and rules
+  { dir: ".roo", files: ["config.json", "rules.md"] },
+  { dir: ".roo/rules", pattern: /\.(md|txt)$/ },
+  { dir: ".roo/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .amp - Amp rules
+  { dir: ".amp", files: ["AGENTS.md", "rules.md"] },
+  { dir: ".amp/rules", pattern: /\.(md|txt)$/ },
+  { dir: ".amp/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .opencode - OpenCode instructions
+  { dir: ".opencode", files: ["instructions.md"] },
+  { dir: ".opencode/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true },
+  // .factory - Factory/Droid config
+  { dir: ".factory", files: ["config.json", "instructions.md"] },
+  { dir: ".factory/droids", pattern: /\.(md|yaml|yml)$/ },
+  { dir: ".factory/tasks", pattern: /\.(md|txt)$/ },
+  { dir: ".factory/skills", pattern: /\.(md|json|yaml|yml|toml|txt)$/, recurse: true }
 ];
-var INCLUDE_PATTERNS = [
-  /\.md$/,
-  /\.txt$/,
-  /\.json$/,
-  /\.yaml$/,
-  /\.yml$/,
-  /\.toml$/,
-  /rules$/,
-  /config$/
-];
-var EXCLUDE_PATTERNS = [
-  /node_modules/,
-  /\.git\//,
-  /\.DS_Store/,
-  /\.log$/,
-  /cache/i,
-  /history/i,
-  /session/i,
-  /debug/i,
-  /\.lock$/,
-  /stats-cache/,
-  /telemetry/,
-  /todos/
-];
-function shouldIncludeFile(filePath) {
-  for (const pattern of EXCLUDE_PATTERNS) {
-    if (pattern.test(filePath)) return false;
-  }
-  for (const pattern of INCLUDE_PATTERNS) {
-    if (pattern.test(filePath)) return true;
+async function scanTarget(baseDir, target, relativeTo = "") {
+  const results = [];
+  const targetDir = join9(baseDir, target.dir);
+  if (!existsSync10(targetDir)) return results;
+  const source = target.dir.split("/")[0].replace(/^\./, "").replace(/^(.)/, (_, c) => c.toUpperCase());
+  if (target.files) {
+    for (const file of target.files) {
+      const fullPath = join9(targetDir, file);
+      if (existsSync10(fullPath)) {
+        const stats = await stat(fullPath);
+        if (stats.isFile()) {
+          results.push({
+            path: join9(target.dir, file),
+            fullPath,
+            source
+          });
+        }
+      }
+    }
+    return results;
   }
-  return false;
-}
-async function scanDirectory(dir, basePath = "") {
-  const files = [];
-  if (!existsSync9(dir)) return files;
-  const entries = await readdir(dir, { withFileTypes: true });
+  if (!target.pattern) return results;
+  const entries = await readdir(targetDir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join8(dir, entry.name);
-    const relativePath = basePath ? join8(basePath, entry.name) : entry.name;
-    if (entry.isDirectory()) {
-      const subFiles = await scanDirectory(fullPath, relativePath);
-      files.push(...subFiles);
-    } else if (entry.isFile() && shouldIncludeFile(relativePath)) {
-      files.push({ path: relativePath, fullPath });
+    const fullPath = join9(targetDir, entry.name);
+    const relativePath = join9(target.dir, entry.name);
+    if (entry.isDirectory() && target.recurse) {
+      const subTarget = { dir: relativePath, pattern: target.pattern, recurse: true };
+      const subResults = await scanTarget(baseDir, subTarget, relativeTo);
+      results.push(...subResults);
+    } else if (entry.isFile() && target.pattern.test(entry.name)) {
+      results.push({ path: relativePath, fullPath, source });
     }
   }
-  return files;
+  return results;
+}
+async function scanAllTargets(baseDir) {
+  const results = [];
+  for (const target of SYNC_TARGETS) {
+    const targetResults = await scanTarget(baseDir, target);
+    results.push(...targetResults);
+  }
+  return results;
 }
 var filesCommand = new Command28("files").description("Manage synced config files (.agents, .cursor, .claude, etc.)");
 filesCommand.command("list").alias("ls").description("List synced files").option("-s, --scope <scope>", "Filter by scope (global or project path)").action(async (opts) => {
@@ -3686,8 +3983,8 @@ filesCommand.command("list").alias("ls").description("List synced files").option
   const result = await db.execute({ sql, args });
   const files = result.rows;
   if (files.length === 0) {
-    console.log(chalk26.dim("No synced files yet."));
-    console.log(chalk26.dim(`Run ${chalk26.cyan("memories files ingest")} to import config files.`));
+    console.log(chalk27.dim("No synced files yet."));
+    console.log(chalk27.dim(`Run ${chalk27.cyan("memories files ingest")} to import config files.`));
     return;
   }
   const byScope = /* @__PURE__ */ new Map();
@@ -3697,61 +3994,51 @@ filesCommand.command("list").alias("ls").description("List synced files").option
     byScope.get(scope).push(file);
   }
   for (const [scope, scopeFiles] of byScope) {
-    const scopeLabel = scope === "global" ? chalk26.blue("Global") : chalk26.yellow(scope.replace("github.com/", ""));
+    const scopeLabel = scope === "global" ? chalk27.blue("Global") : chalk27.yellow(scope.replace("github.com/", ""));
     console.log(`
-${scopeLabel} ${chalk26.dim(`(${scopeFiles.length} files)`)}`);
-    console.log(chalk26.dim("\u2500".repeat(50)));
+${scopeLabel} ${chalk27.dim(`(${scopeFiles.length} files)`)}`);
+    console.log(chalk27.dim("\u2500".repeat(50)));
     for (const file of scopeFiles) {
-      const source = file.source ? chalk26.dim(` [${file.source}]`) : "";
-      console.log(`  ${chalk26.white(file.path)}${source}`);
+      const source = file.source ? chalk27.dim(` [${file.source}]`) : "";
+      console.log(`  ${chalk27.white(file.path)}${source}`);
     }
   }
   console.log();
 });
 filesCommand.command("ingest").description("Import files from .agents, .cursor, .claude and other config directories").option("-g, --global", "Ingest global configs from home directory", true).option("-p, --project", "Ingest project configs from current directory").option("--dry-run", "Show what would be imported without making changes").action(async (opts) => {
   const db = await getDb();
-  const home = homedir4();
+  const home = homedir5();
   const cwd = process.cwd();
   const filesToIngest = [];
   if (opts.global !== false) {
-    for (const { dir, name } of CONFIG_DIRS) {
-      const globalDir = join8(home, dir);
-      const files = await scanDirectory(globalDir);
-      for (const file of files) {
-        filesToIngest.push({
-          path: join8(dir, file.path),
-          fullPath: file.fullPath,
-          scope: "global",
-          source: name
-        });
-      }
+    const files = await scanAllTargets(home);
+    for (const file of files) {
+      filesToIngest.push({
+        ...file,
+        scope: "global"
+      });
     }
   }
   if (opts.project) {
-    for (const { dir, name } of CONFIG_DIRS) {
-      const projectDir = join8(cwd, dir);
-      const files = await scanDirectory(projectDir);
-      for (const file of files) {
-        filesToIngest.push({
-          path: join8(dir, file.path),
-          fullPath: file.fullPath,
-          scope: "project",
-          // Will be resolved to git remote
-          source: name
-        });
-      }
+    const files = await scanAllTargets(cwd);
+    for (const file of files) {
+      filesToIngest.push({
+        ...file,
+        scope: "project"
+        // Will be resolved to git remote
+      });
     }
   }
   if (filesToIngest.length === 0) {
-    console.log(chalk26.dim("No config files found to import."));
+    console.log(chalk27.dim("No config files found to import."));
     return;
   }
   if (opts.dryRun) {
-    console.log(chalk26.bold(`Would import ${filesToIngest.length} files:
+    console.log(chalk27.bold(`Would import ${filesToIngest.length} files:
 `));
     for (const file of filesToIngest) {
-      const scopeLabel = file.scope === "global" ? chalk26.blue("G") : chalk26.yellow("P");
-      console.log(`  ${scopeLabel} ${file.path} ${chalk26.dim(`[${file.source}]`)}`);
+      const scopeLabel = file.scope === "global" ? chalk27.blue("G") : chalk27.yellow("P");
+      console.log(`  ${scopeLabel} ${file.path} ${chalk27.dim(`[${file.source}]`)}`);
     }
     return;
   }
@@ -3761,7 +4048,7 @@ filesCommand.command("ingest").description("Import files from .agents, .cursor,
   let skipped = 0;
   for (const file of filesToIngest) {
     try {
-      const content = await readFile8(file.fullPath, "utf-8");
+      const content = await readFile9(file.fullPath, "utf-8");
       const hash = hashContent(content);
       const existing = await db.execute({
         sql: "SELECT id, hash FROM files WHERE path = ? AND scope = ? AND deleted_at IS NULL",
@@ -3798,7 +4085,7 @@ filesCommand.command("ingest").description("Import files from .agents, .cursor,
 });
 filesCommand.command("apply").description("Write synced files to disk (restore from cloud)").option("-g, --global", "Apply global files to home directory").option("-p, --project", "Apply project files to current directory").option("--dry-run", "Show what would be written without making changes").option("-f, --force", "Overwrite existing files without prompting").action(async (opts) => {
   const db = await getDb();
-  const home = homedir4();
+  const home = homedir5();
   const cwd = process.cwd();
   let sql = "SELECT id, path, content, scope, source FROM files WHERE deleted_at IS NULL";
   const args = [];
@@ -3810,17 +4097,17 @@ filesCommand.command("apply").description("Write synced files to disk (restore f
   const result = await db.execute({ sql, args });
   const files = result.rows;
   if (files.length === 0) {
-    console.log(chalk26.dim("No files to apply."));
+    console.log(chalk27.dim("No files to apply."));
     return;
   }
   if (opts.dryRun) {
-    console.log(chalk26.bold(`Would write ${files.length} files:
+    console.log(chalk27.bold(`Would write ${files.length} files:
 `));
     for (const file of files) {
       const baseDir = file.scope === "global" ? home : cwd;
-      const targetPath = join8(baseDir, file.path);
-      const exists = existsSync9(targetPath);
-      const status = exists ? chalk26.yellow("(overwrite)") : chalk26.green("(new)");
+      const targetPath = join9(baseDir, file.path);
+      const exists = existsSync10(targetPath);
+      const status = exists ? chalk27.yellow("(overwrite)") : chalk27.green("(new)");
       console.log(`  ${targetPath} ${status}`);
     }
     return;
@@ -3830,9 +4117,9 @@ filesCommand.command("apply").description("Write synced files to disk (restore f
   let skippedExisting = 0;
   for (const file of files) {
     const baseDir = file.scope === "global" ? home : cwd;
-    const targetPath = join8(baseDir, file.path);
-    if (existsSync9(targetPath) && !opts.force) {
-      const existingContent = await readFile8(targetPath, "utf-8");
+    const targetPath = join9(baseDir, file.path);
+    if (existsSync10(targetPath) && !opts.force) {
+      const existingContent = await readFile9(targetPath, "utf-8");
       const existingHash = hashContent(existingContent);
       const newHash = hashContent(file.content);
       if (existingHash !== newHash) {
@@ -3840,8 +4127,8 @@ filesCommand.command("apply").description("Write synced files to disk (restore f
         continue;
       }
     }
-    await mkdir4(dirname2(targetPath), { recursive: true });
-    await writeFile6(targetPath, file.content, "utf-8");
+    await mkdir5(dirname3(targetPath), { recursive: true });
+    await writeFile7(targetPath, file.content, "utf-8");
     written++;
   }
   if (skippedExisting > 0) {
@@ -3857,14 +4144,14 @@ filesCommand.command("show <path>").description("Show content of a synced file")
     args: [path]
   });
   if (result.rows.length === 0) {
-    console.log(chalk26.red(`File not found: ${path}`));
+    console.log(chalk27.red(`File not found: ${path}`));
     return;
   }
   const file = result.rows[0];
-  console.log(chalk26.dim(`# ${path}`));
-  console.log(chalk26.dim(`# Scope: ${file.scope} | Source: ${file.source || "unknown"}`));
-  console.log(chalk26.dim(`# Updated: ${file.updated_at}`));
-  console.log(chalk26.dim("\u2500".repeat(50)));
+  console.log(chalk27.dim(`# ${path}`));
+  console.log(chalk27.dim(`# Scope: ${file.scope} | Source: ${file.source || "unknown"}`));
+  console.log(chalk27.dim(`# Updated: ${file.updated_at}`));
+  console.log(chalk27.dim("\u2500".repeat(50)));
   console.log(file.content);
 });
 filesCommand.command("forget <path>").description("Remove a file from sync (soft delete)").action(async (path) => {
@@ -3874,14 +4161,14 @@ filesCommand.command("forget <path>").description("Remove a file from sync (soft
     args: [path]
   });
   if (result.rowsAffected === 0) {
-    console.log(chalk26.red(`File not found: ${path}`));
+    console.log(chalk27.red(`File not found: ${path}`));
     return;
   }
   const sync = await readSyncConfig();
   if (sync) {
     await syncDb();
   }
-  console.log(chalk26.green(`\u2713 Removed ${path} from sync`));
+  console.log(chalk27.green(`\u2713 Removed ${path} from sync`));
 });
 // src/index.ts