@memories.sh/cli 0.3.0 → 0.3.2

package/dist/index.js

@@ -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 } from "@inquirer/prompts";
 
 // src/lib/auth.ts
 import { readFile, writeFile, mkdir, unlink } from "fs/promises";
@@ -76,8 +77,120 @@ 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 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 +201,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 +234,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 +266,101 @@ 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...");
+    const detected = detectTools(cwd);
+    if (detected.length === 0) {
+      dim("No AI coding tools detected (.cursor/, .claude/, .windsurf/, .vscode/)");
+      dim("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 +368,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 +531,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 +539,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 +553,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 +561,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 +586,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 +605,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 +632,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 +675,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 +687,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 +716,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 +736,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 +765,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 +789,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 +797,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 +808,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 +821,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 +841,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 +879,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 +893,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 +907,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 +924,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 +946,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 +954,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 +968,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 +1002,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 +1031,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 +1054,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 +1088,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 +1122,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 +1135,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 +1165,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 +1186,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 +1206,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);
 }
 
@@ -1528,10 +1689,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 +1715,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 +1751,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,11 +1798,11 @@ 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 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 } from "@inquirer/prompts";
 var MARKER = "Generated by memories.sh";
 var VALID_TYPES6 = ["rule", "decision", "fact", "note"];
@@ -1778,7 +1939,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 +1950,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 +1964,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 +1996,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 +2032,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);
   });
@@ -1887,19 +2048,19 @@ var generateCommand = new Command13("generate").description("Generate IDE rule/i
     const selected = await checkbox({
       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 +2072,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 +2083,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 +2104,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 +2119,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 +2135,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 +2151,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 +2162,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 +2185,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 +2195,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 +2249,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 +2386,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 +2443,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 +2471,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 +2505,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 +2525,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 +2541,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 +2566,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 +2628,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 +2644,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 +2678,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 +2711,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 +2760,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 +2772,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 +2783,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 +2799,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 +2808,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 +2876,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 +2928,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 +2962,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 +2988,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 +3004,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 +3065,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 +3100,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 +3157,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 +3180,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 +3219,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 +3238,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 +3328,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 +3347,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 +3357,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 +3376,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 +3389,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 +3406,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 +3459,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 +3474,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 +3487,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 +3536,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 +3577,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 +3589,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 +3601,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 +3627,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 +3659,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 +3689,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 +3730,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 +3762,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 +3882,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 +3893,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 +3947,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 +3984,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 +3996,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 +4016,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 +4026,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 +4043,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 +4060,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