@memories.sh/cli 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 
 // src/commands/init.ts
 import { Command } from "commander";
-import chalk from "chalk";
+import chalk2 from "chalk";
 
 // src/lib/db.ts
 import { createClient } from "@libsql/client";
@@ -265,8 +265,8 @@ async function searchMemories(query, opts) {
       args: [ftsQuery, ...args]
     });
     return result.rows;
-  } catch (error) {
-    console.error("FTS search failed, falling back to LIKE:", error);
+  } catch (error2) {
+    console.error("FTS search failed, falling back to LIKE:", error2);
     return searchMemoriesLike(query, opts);
   }
 }
@@ -462,55 +462,181 @@ async function bulkForgetByIds(ids) {
   return ids.length;
 }
 
+// src/lib/auth.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, unlink } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var AUTH_DIR = join2(homedir2(), ".config", "memories");
+var AUTH_FILE = join2(AUTH_DIR, "auth.json");
+async function readAuth() {
+  if (!existsSync2(AUTH_FILE)) return null;
+  try {
+    const raw = await readFile2(AUTH_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveAuth(data) {
+  await mkdir2(AUTH_DIR, { recursive: true });
+  await writeFile2(AUTH_FILE, JSON.stringify(data, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+async function clearAuth() {
+  if (existsSync2(AUTH_FILE)) {
+    await unlink(AUTH_FILE);
+  }
+}
+function getApiClient(auth) {
+  return async function apiFetch(path, opts) {
+    const url = `${auth.apiUrl}${path}`;
+    return fetch(url, {
+      ...opts,
+      headers: {
+        ...opts?.headers,
+        Authorization: `Bearer ${auth.token}`,
+        "Content-Type": "application/json"
+      }
+    });
+  };
+}
+
+// src/lib/ui.ts
+import chalk from "chalk";
+import figlet from "figlet";
+import gradient from "gradient-string";
+import boxen from "boxen";
+var memoriesGradient = gradient(["#a855f7", "#6366f1"]);
+function banner() {
+  const text = figlet.textSync("memories", {
+    font: "Small",
+    horizontalLayout: "fitted"
+  });
+  console.log(memoriesGradient(text));
+  console.log(chalk.dim("  One memory, every AI tool\n"));
+}
+function success(message) {
+  console.log(chalk.green("\u2713") + " " + message);
+}
+function warn(message) {
+  console.log(chalk.yellow("\u26A0") + " " + message);
+}
+function error(message) {
+  console.log(chalk.red("\u2717") + " " + message);
+}
+function info(message) {
+  console.log(chalk.blue("\u2139") + " " + message);
+}
+function step(num, total, message) {
+  console.log(chalk.dim(`[${num}/${total}]`) + " " + message);
+}
+function dim(message) {
+  console.log(chalk.dim("  " + message));
+}
+function box(content, title) {
+  console.log(
+    boxen(content, {
+      padding: 1,
+      margin: { top: 1, bottom: 1, left: 0, right: 0 },
+      borderStyle: "round",
+      borderColor: "gray",
+      title,
+      titleAlignment: "left"
+    })
+  );
+}
+function nextSteps(steps) {
+  const content = steps.map((s) => chalk.dim("\u2192 ") + s).join("\n");
+  box(content, chalk.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.")
+  );
+}
+
 // src/commands/init.ts
 var initCommand = new Command("init").description("Initialize memories for the current project or globally").option("-g, --global", "Initialize global memories (user-wide)").option("-r, --rule <rule>", "Add an initial rule", (val, acc) => [...acc, val], []).action(async (opts) => {
   try {
+    banner();
+    step(1, 3, "Initializing database...");
     await getDb();
     const configDir = getConfigDir();
-    if (opts.global) {
-      console.log(chalk.green("\u2713") + " Initialized global memories");
-      console.log(chalk.dim(`  Database: ${configDir}/local.db`));
-    } else {
+    dim(`Database: ${configDir}/local.db`);
+    step(2, 3, "Detecting scope...");
+    let useGlobal = opts.global;
+    if (!useGlobal) {
       const projectId = getProjectId();
       const gitRoot = getGitRoot();
       if (!projectId) {
-        console.log(chalk.yellow("\u26A0") + " Not in a git repository.");
-        console.log(chalk.dim("  Run from a git repo for project-scoped memories, or use --global"));
-        return;
+        warn("Not in a git repository - using global scope");
+        dim("Global memories apply to all projects");
+        useGlobal = true;
+      } else {
+        success("Using project scope");
+        dim(`Project: ${projectId}`);
+        dim(`Root: ${gitRoot}`);
       }
-      console.log(chalk.green("\u2713") + " Initialized project memories");
-      console.log(chalk.dim(`  Project: ${projectId}`));
-      console.log(chalk.dim(`  Root: ${gitRoot}`));
-      console.log(chalk.dim(`  Database: ${configDir}/local.db`));
+    }
+    if (useGlobal) {
+      success("Using global scope (applies to all projects)");
+    }
+    step(3, 3, "Checking account...");
+    const auth = await readAuth();
+    if (auth) {
+      success(`Logged in as ${chalk2.bold(auth.email)}`);
+    } else {
+      dim("Not logged in (local-only mode)");
+      dim("Run " + chalk2.cyan("memories login") + " for cloud sync");
     }
     if (opts.rule?.length) {
       console.log("");
-      console.log(chalk.blue("Adding rules:"));
+      info("Adding initial rules...");
       for (const rule of opts.rule) {
         const memory = await addMemory(rule, {
           type: "rule",
-          global: opts.global
+          global: useGlobal
         });
-        console.log(chalk.dim(`  ${memory.id}: ${rule}`));
+        dim(`${memory.id}: ${rule}`);
       }
     }
-    console.log("");
-    console.log(chalk.dim("Quick start:"));
-    console.log(chalk.dim(`  memories add "Your first memory"`));
-    console.log(chalk.dim(`  memories add --rule "Always use TypeScript strict mode"`));
-    console.log(chalk.dim(`  memories recall "what are my coding preferences"`));
-  } catch (error) {
-    console.error(chalk.red("\u2717") + " Failed to initialize:", error instanceof Error ? error.message : "Unknown error");
+    nextSteps([
+      `${chalk2.cyan("memories add")} ${chalk2.dim('"Your first memory"')}`,
+      `${chalk2.cyan("memories add --rule")} ${chalk2.dim('"Always use TypeScript"')}`,
+      `${chalk2.cyan("memories generate")} ${chalk2.dim("to create IDE rule files")}`,
+      `${chalk2.cyan("memories serve")} ${chalk2.dim("to start MCP server")}`
+    ]);
+  } catch (error2) {
+    error("Failed to initialize: " + (error2 instanceof Error ? error2.message : "Unknown error"));
     process.exit(1);
   }
 });
 
 // src/commands/add.ts
 import { Command as Command2 } from "commander";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 var VALID_TYPES = ["rule", "decision", "fact", "note"];
 var addCommand = new Command2("add").description("Add a new memory").argument("<content>", "Memory content").option("-t, --tags <tags>", "Comma-separated tags").option("-g, --global", "Store as global memory (default: project-scoped if in git repo)").option("--type <type>", "Memory type: rule, decision, fact, note (default: note)").option("-r, --rule", "Shorthand for --type rule").option("-d, --decision", "Shorthand for --type decision").option("-f, --fact", "Shorthand for --type fact").action(async (content, opts) => {
   try {
+    const auth = await readAuth();
+    if (auth) {
+      try {
+        const apiFetch = getApiClient(auth);
+        const res = await apiFetch("/api/db/limits");
+        if (res.ok) {
+          const limits = await res.json();
+          if (limits.memoryLimit !== null && limits.memoryCount >= limits.memoryLimit) {
+            warn(`You've reached the free plan limit of ${limits.memoryLimit.toLocaleString()} memories.`);
+            proFeature("Unlimited memories");
+            process.exit(1);
+          }
+        }
+      } catch {
+      }
+    }
     const tags = opts.tags?.split(",").map((t) => t.trim());
     let type = "note";
     if (opts.rule) type = "rule";
@@ -518,24 +644,29 @@ 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(chalk2.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES.join(", ")}`);
+        console.error(chalk3.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES.join(", ")}`);
         process.exit(1);
       }
       type = opts.type;
     }
     const memory = await addMemory(content, { tags, global: opts.global, type });
-    const typeIcon = type === "rule" ? "\u{1F4CC}" : type === "decision" ? "\u{1F4A1}" : type === "fact" ? "\u{1F4CB}" : "\u{1F4DD}";
-    const scopeInfo = memory.scope === "global" ? chalk2.dim("(global)") : chalk2.dim(`(project)`);
-    console.log(chalk2.green("\u2713") + ` ${typeIcon} Stored ${type} ${chalk2.dim(memory.id)} ${scopeInfo}`);
-  } catch (error) {
-    console.error(chalk2.red("\u2717") + " Failed to add memory:", error instanceof Error ? error.message : "Unknown error");
+    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)}`);
+    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`);
+    }
+  } catch (error2) {
+    error("Failed to add memory: " + (error2 instanceof Error ? error2.message : "Unknown error"));
     process.exit(1);
   }
 });
 
 // src/commands/recall.ts
 import { Command as Command3 } from "commander";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 var TYPE_ICONS = {
   rule: "\u{1F4CC}",
   decision: "\u{1F4A1}",
@@ -543,18 +674,18 @@ var TYPE_ICONS = {
   note: "\u{1F4DD}"
 };
 var TYPE_COLORS = {
-  rule: chalk3.yellow,
-  decision: chalk3.cyan,
-  fact: chalk3.green,
-  note: chalk3.white
+  rule: chalk4.yellow,
+  decision: chalk4.cyan,
+  fact: chalk4.green,
+  note: chalk4.white
 };
 function formatMemory(m, verbose) {
   const icon = TYPE_ICONS[m.type] || "\u{1F4DD}";
-  const colorFn = TYPE_COLORS[m.type] || chalk3.white;
-  const scope = m.scope === "global" ? chalk3.dim("G") : chalk3.dim("P");
-  const tags = m.tags ? chalk3.dim(` [${m.tags}]`) : "";
+  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}]`) : "";
   if (verbose) {
-    return `${icon} ${scope} ${chalk3.dim(m.id)} ${colorFn(m.content)}${tags}`;
+    return `${icon} ${scope} ${chalk4.dim(m.id)} ${colorFn(m.content)}${tags}`;
   }
   return `${icon} ${colorFn(m.content)}`;
 }
@@ -568,11 +699,11 @@ var recallCommand = new Command3("recall").description("Recall context - get rul
         return;
       }
       if (rules2.length === 0) {
-        console.log(chalk3.dim("No rules defined."));
-        console.log(chalk3.dim('Add one with: memories add --rule "Your rule here"'));
+        console.log(chalk4.dim("No rules defined."));
+        console.log(chalk4.dim('Add one with: memories add --rule "Your rule here"'));
         return;
       }
-      console.log(chalk3.bold("Rules:"));
+      console.log(chalk4.bold("Rules:"));
       for (const rule of rules2) {
         console.log(formatMemory(rule, opts.verbose ?? false));
       }
@@ -587,26 +718,26 @@ var recallCommand = new Command3("recall").description("Recall context - get rul
       return;
     }
     if (rules.length > 0) {
-      console.log(chalk3.bold("Rules:"));
+      console.log(chalk4.bold("Rules:"));
       for (const rule of rules) {
         console.log(formatMemory(rule, opts.verbose ?? false));
       }
       console.log("");
     }
     if (memories.length > 0) {
-      console.log(chalk3.bold(query ? `Relevant to "${query}":` : "Recent memories:"));
+      console.log(chalk4.bold(query ? `Relevant to "${query}":` : "Recent memories:"));
       for (const m of memories) {
         console.log(formatMemory(m, opts.verbose ?? false));
       }
     } else if (query) {
-      console.log(chalk3.dim(`No memories found matching "${query}"`));
+      console.log(chalk4.dim(`No memories found matching "${query}"`));
     }
     if (rules.length === 0 && memories.length === 0) {
-      console.log(chalk3.dim("No memories found."));
-      console.log(chalk3.dim('Add some with: memories add "Your memory here"'));
+      console.log(chalk4.dim("No memories found."));
+      console.log(chalk4.dim('Add some with: memories add "Your memory here"'));
     }
-  } catch (error) {
-    console.error(chalk3.red("\u2717") + " Failed to recall:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk4.red("\u2717") + " Failed to recall:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -614,7 +745,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 chalk4 from "chalk";
+import chalk5 from "chalk";
 var VALID_TYPES2 = ["rule", "decision", "fact", "note"];
 function formatMarkdown(sections) {
   return sections.map(({ title, memories }) => {
@@ -657,7 +788,7 @@ var promptCommand = new Command4("prompt").description("Output memories formatte
   try {
     const format = opts.format ?? "markdown";
     if (!["markdown", "xml", "plain"].includes(format)) {
-      console.error(chalk4.red("\u2717") + ` Invalid format "${opts.format}". Use: markdown, xml, plain`);
+      console.error(chalk5.red("\u2717") + ` Invalid format "${opts.format}". Use: markdown, xml, plain`);
       process.exit(1);
     }
     const projectId = getProjectId() ?? void 0;
@@ -669,7 +800,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(chalk4.red("\u2717") + ` Invalid type "${t}". Valid: decisions, facts, notes`);
+          console.error(chalk5.red("\u2717") + ` Invalid type "${t}". Valid: decisions, facts, notes`);
           process.exit(1);
         }
         if (normalized !== "rule") extraTypes.push(normalized);
@@ -698,7 +829,7 @@ var promptCommand = new Command4("prompt").description("Output memories formatte
     }
     if (sections.length === 0) {
       if (!opts.quiet) {
-        console.error(chalk4.dim('No memories found. Add rules with: memories add --rule "Your rule"'));
+        console.error(chalk5.dim('No memories found. Add rules with: memories add --rule "Your rule"'));
       }
       return;
     }
@@ -718,26 +849,26 @@ var promptCommand = new Command4("prompt").description("Output memories formatte
       if (copied) {
         console.log(output);
         if (!opts.quiet) {
-          console.error(chalk4.green("\u2713") + " Copied to clipboard");
+          console.error(chalk5.green("\u2713") + " Copied to clipboard");
         }
       } else {
         console.log(output);
         if (!opts.quiet) {
-          console.error(chalk4.yellow("\u26A0") + " Could not copy to clipboard (unsupported platform)");
+          console.error(chalk5.yellow("\u26A0") + " Could not copy to clipboard (unsupported platform)");
         }
       }
     } else {
       console.log(output);
     }
-  } catch (error) {
-    console.error(chalk4.red("\u2717") + " Failed to generate prompt:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk5.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 chalk5 from "chalk";
+import chalk6 from "chalk";
 var TYPE_ICONS2 = {
   rule: "\u{1F4CC}",
   decision: "\u{1F4A1}",
@@ -747,16 +878,16 @@ var TYPE_ICONS2 = {
 var VALID_TYPES3 = ["rule", "decision", "fact", "note"];
 function formatMemory2(m) {
   const icon = TYPE_ICONS2[m.type] || "\u{1F4DD}";
-  const scope = m.scope === "global" ? chalk5.dim("G") : chalk5.dim("P");
-  const tags = m.tags ? chalk5.dim(` [${m.tags}]`) : "";
-  return `${icon} ${scope} ${chalk5.dim(m.id)}  ${m.content}${tags}`;
+  const scope = m.scope === "global" ? chalk6.dim("G") : chalk6.dim("P");
+  const tags = m.tags ? chalk6.dim(` [${m.tags}]`) : "";
+  return `${icon} ${scope} ${chalk6.dim(m.id)}  ${m.content}${tags}`;
 }
 var searchCommand = new Command5("search").description("Search memories using full-text 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("--json", "Output as JSON").action(async (query, opts) => {
   try {
     let types;
     if (opts.type) {
       if (!VALID_TYPES3.includes(opts.type)) {
-        console.error(chalk5.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES3.join(", ")}`);
+        console.error(chalk6.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES3.join(", ")}`);
         process.exit(1);
       }
       types = [opts.type];
@@ -770,7 +901,7 @@ var searchCommand = new Command5("search").description("Search memories using fu
       includeGlobal = false;
       projectId = getProjectId() ?? void 0;
       if (!projectId) {
-        console.log(chalk5.yellow("\u26A0") + " Not in a git repository. No project memories to search.");
+        console.log(chalk6.yellow("\u26A0") + " Not in a git repository. No project memories to search.");
         return;
       }
     }
@@ -786,30 +917,30 @@ var searchCommand = new Command5("search").description("Search memories using fu
       return;
     }
     if (memories.length === 0) {
-      console.log(chalk5.dim(`No memories found matching "${query}"`));
+      console.log(chalk6.dim(`No memories found matching "${query}"`));
       return;
     }
-    console.log(chalk5.bold(`Results for "${query}":`));
+    console.log(chalk6.bold(`Results for "${query}":`));
     console.log("");
     for (const m of memories) {
       console.log(formatMemory2(m));
     }
-    console.log(chalk5.dim(`
+    console.log(chalk6.dim(`
 ${memories.length} results`));
-  } catch (error) {
-    console.error(chalk5.red("\u2717") + " Failed to search:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk6.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 chalk6 from "chalk";
+import chalk7 from "chalk";
 var TYPE_COLORS2 = {
-  rule: chalk6.blue,
-  decision: chalk6.yellow,
-  fact: chalk6.green,
-  note: chalk6.dim
+  rule: chalk7.blue,
+  decision: chalk7.yellow,
+  fact: chalk7.green,
+  note: chalk7.dim
 };
 var TYPE_LABELS = {
   rule: "rule",
@@ -824,12 +955,12 @@ function truncate(str, max) {
   return str.slice(0, max - 1) + "\u2026";
 }
 function formatMemory3(m) {
-  const typeColor = TYPE_COLORS2[m.type] ?? chalk6.dim;
+  const typeColor = TYPE_COLORS2[m.type] ?? chalk7.dim;
   const typeLabel = typeColor(TYPE_LABELS[m.type].padEnd(9));
-  const scope = m.scope === "global" ? chalk6.magenta("G") : chalk6.cyan("P");
-  const id = chalk6.dim(m.id);
+  const scope = m.scope === "global" ? chalk7.magenta("G") : chalk7.cyan("P");
+  const id = chalk7.dim(m.id);
   const content = truncate(m.content, MAX_CONTENT_WIDTH);
-  const tags = m.tags ? chalk6.dim(` [${m.tags}]`) : "";
+  const tags = m.tags ? chalk7.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) => {
@@ -838,7 +969,7 @@ var listCommand = new Command6("list").description("List memories").option("-l,
     let types;
     if (opts.type) {
       if (!VALID_TYPES4.includes(opts.type)) {
-        console.error(chalk6.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES4.join(", ")}`);
+        console.error(chalk7.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES4.join(", ")}`);
         process.exit(1);
       }
       types = [opts.type];
@@ -852,7 +983,7 @@ var listCommand = new Command6("list").description("List memories").option("-l,
       includeGlobal = false;
       projectId = getProjectId() ?? void 0;
       if (!projectId) {
-        console.log(chalk6.yellow("\u26A0") + " Not in a git repository. No project memories to show.");
+        console.log(chalk7.yellow("\u26A0") + " Not in a git repository. No project memories to show.");
         return;
       }
     }
@@ -869,21 +1000,21 @@ var listCommand = new Command6("list").description("List memories").option("-l,
       return;
     }
     if (memories.length === 0) {
-      console.log(chalk6.dim("No memories found."));
+      console.log(chalk7.dim("No memories found."));
       return;
     }
     const currentProject = getProjectId();
     if (currentProject && !opts.global) {
-      console.log(chalk6.dim(`  Project: ${currentProject}
+      console.log(chalk7.dim(`  Project: ${currentProject}
 `));
     }
     for (const m of memories) {
       console.log(formatMemory3(m));
     }
-    console.log(chalk6.dim(`
+    console.log(chalk7.dim(`
   ${memories.length} memories`));
-  } catch (error) {
-    console.error(chalk6.red("\u2717") + " Failed to list memories:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk7.red("\u2717") + " Failed to list memories:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -891,7 +1022,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 chalk7 from "chalk";
+import chalk8 from "chalk";
 var VALID_TYPES5 = ["rule", "decision", "fact", "note"];
 var TYPE_ICONS3 = {
   rule: "\u{1F4CC}",
@@ -913,28 +1044,28 @@ var forgetCommand = new Command7("forget").description("Soft-delete memories by
     if (id) {
       const deleted = await forgetMemory(id);
       if (deleted) {
-        console.log(chalk7.green("\u2713") + ` Forgot memory ${chalk7.dim(id)}`);
+        console.log(chalk8.green("\u2713") + ` Forgot memory ${chalk8.dim(id)}`);
       } else {
-        console.error(chalk7.red("\u2717") + ` Memory ${id} not found or already forgotten.`);
+        console.error(chalk8.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(chalk7.red("\u2717") + " Provide a memory ID or a bulk filter (--type, --tag, --older-than, --pattern, --all)");
+      console.error(chalk8.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(chalk7.red("\u2717") + " --all cannot be combined with other filters. Use --all alone to delete everything.");
+      console.error(chalk8.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(chalk7.red("\u2717") + ` Invalid type "${opts.type}". Valid: ${VALID_TYPES5.join(", ")}`);
+      console.error(chalk8.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(chalk7.red("\u2717") + " --older-than must be a positive number of days");
+      console.error(chalk8.red("\u2717") + " --older-than must be a positive number of days");
       process.exit(1);
     }
     const filter = {
@@ -947,27 +1078,27 @@ var forgetCommand = new Command7("forget").description("Soft-delete memories by
     };
     const matches = await findMemoriesToForget(filter);
     if (matches.length === 0) {
-      console.log(chalk7.dim("No memories match the filter."));
+      console.log(chalk8.dim("No memories match the filter."));
       return;
     }
-    console.log(chalk7.bold(`${matches.length} memories will be forgotten:
+    console.log(chalk8.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" ? chalk7.dim("G") : chalk7.dim("P");
-      console.log(`  ${icon} ${scope} ${chalk7.dim(m.id)}  ${m.content}`);
+      const scope = m.scope === "global" ? chalk8.dim("G") : chalk8.dim("P");
+      console.log(`  ${icon} ${scope} ${chalk8.dim(m.id)}  ${m.content}`);
     }
     if (matches.length > 30) {
-      console.log(chalk7.dim(`  ... and ${matches.length - 30} more`));
+      console.log(chalk8.dim(`  ... and ${matches.length - 30} more`));
     }
     console.log("");
     if (opts.dryRun) {
-      console.log(chalk7.yellow("Dry run") + " \u2014 no memories were deleted.");
+      console.log(chalk8.yellow("Dry run") + " \u2014 no memories were deleted.");
       return;
     }
     if (!opts.force) {
       const proceed = await confirm(
-        chalk7.yellow(`Forget ${matches.length} memories? This is a soft-delete. [y/N] `)
+        chalk8.yellow(`Forget ${matches.length} memories? This is a soft-delete. [y/N] `)
       );
       if (!proceed) {
         console.log("Cancelled.");
@@ -976,17 +1107,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(chalk7.green("\u2713") + ` Forgot ${count} memories.`);
-  } catch (error) {
-    console.error(chalk7.red("\u2717") + " Failed to forget:", error instanceof Error ? error.message : "Unknown error");
+    console.log(chalk8.green("\u2713") + ` Forgot ${count} memories.`);
+  } catch (error2) {
+    console.error(chalk8.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 chalk8 from "chalk";
-import { writeFile as writeFile2 } from "fs/promises";
+import chalk9 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();
@@ -999,7 +1130,7 @@ var exportCommand = new Command8("export").description("Export memories to JSON
       includeGlobal = false;
       queryProjectId = projectId ?? void 0;
       if (!queryProjectId) {
-        console.error(chalk8.red("\u2717") + " Not in a git repository. No project memories to export.");
+        console.error(chalk9.red("\u2717") + " Not in a git repository. No project memories to export.");
         process.exit(1);
       }
     }
@@ -1033,24 +1164,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(chalk8.green("\u2713") + ` Exported ${memories.length} memories to ${chalk8.dim(opts.output)}`);
+      await writeFile3(opts.output, output, "utf-8");
+      console.log(chalk9.green("\u2713") + ` Exported ${memories.length} memories to ${chalk9.dim(opts.output)}`);
     } else {
       console.log(output);
     }
-  } catch (error) {
-    console.error(chalk8.red("\u2717") + " Failed to export:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk9.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 chalk9 from "chalk";
-import { readFile as readFile2 } from "fs/promises";
+import chalk10 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")) {
@@ -1067,7 +1198,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(chalk9.red("\u2717") + " Invalid import file: missing 'memories' array");
+      console.error(chalk10.red("\u2717") + " Invalid import file: missing 'memories' array");
       process.exit(1);
     }
     const VALID_TYPES11 = ["rule", "decision", "fact", "note"];
@@ -1080,23 +1211,23 @@ var importCommand = new Command9("import").description("Import memories from JSO
         continue;
       }
       if (m.type && !VALID_TYPES11.includes(m.type)) {
-        console.error(chalk9.yellow("\u26A0") + ` Skipping memory with invalid type "${m.type}": ${m.content.slice(0, 50)}`);
+        console.error(chalk10.yellow("\u26A0") + ` Skipping memory with invalid type "${m.type}": ${m.content.slice(0, 50)}`);
         skipped++;
         continue;
       }
       validMemories.push(m);
     }
     if (opts.dryRun) {
-      console.log(chalk9.blue("Dry run - would import:"));
+      console.log(chalk10.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(chalk9.dim(`
+      console.log(chalk10.dim(`
 ${validMemories.length} memories would be imported`));
-      if (skipped > 0) console.log(chalk9.dim(`${skipped} entries skipped (invalid)`));
+      if (skipped > 0) console.log(chalk10.dim(`${skipped} entries skipped (invalid)`));
       return;
     }
     let imported = 0;
@@ -1109,20 +1240,20 @@ ${validMemories.length} memories would be imported`));
           global: opts.global || m.scope === "global"
         });
         imported++;
-      } catch (error) {
-        console.error(chalk9.yellow("\u26A0") + ` Failed to import: ${m.content.slice(0, 50)}...`);
+      } catch (error2) {
+        console.error(chalk10.yellow("\u26A0") + ` Failed to import: ${m.content.slice(0, 50)}...`);
         failed++;
       }
     }
-    console.log(chalk9.green("\u2713") + ` Imported ${imported} memories`);
+    console.log(chalk10.green("\u2713") + ` Imported ${imported} memories`);
     if (failed > 0) {
-      console.log(chalk9.yellow("\u26A0") + ` ${failed} memories failed to import`);
+      console.log(chalk10.yellow("\u26A0") + ` ${failed} memories failed to import`);
     }
     if (skipped > 0) {
-      console.log(chalk9.dim(`${skipped} entries skipped (invalid content or type)`));
+      console.log(chalk10.dim(`${skipped} entries skipped (invalid content or type)`));
     }
-  } catch (error) {
-    console.error(chalk9.red("\u2717") + " Failed to import:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk10.red("\u2717") + " Failed to import:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -1131,17 +1262,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",
@@ -1151,14 +1282,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);
 }
 
@@ -1240,9 +1371,9 @@ ${projectRules.map((r) => `- ${r.content}`).join("\n")}`);
         return {
           contents: [{ uri: "memories://rules", mimeType: "text/markdown", text: parts.join("\n\n") }]
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          contents: [{ uri: "memories://rules", mimeType: "text/markdown", text: `Error loading rules: ${error instanceof Error ? error.message : "Unknown error"}` }]
+          contents: [{ uri: "memories://rules", mimeType: "text/markdown", text: `Error loading rules: ${error2 instanceof Error ? error2.message : "Unknown error"}` }]
         };
       }
     }
@@ -1268,9 +1399,9 @@ ${projectRules.map((r) => `- ${r.content}`).join("\n")}`);
 
 ${text}` }]
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          contents: [{ uri: "memories://recent", mimeType: "text/markdown", text: `Error loading memories: ${error instanceof Error ? error.message : "Unknown error"}` }]
+          contents: [{ uri: "memories://recent", mimeType: "text/markdown", text: `Error loading memories: ${error2 instanceof Error ? error2.message : "Unknown error"}` }]
         };
       }
     }
@@ -1297,9 +1428,9 @@ ${text}` }]
 
 ${text}` }]
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          contents: [{ uri: uri.href, mimeType: "text/markdown", text: `Error loading project memories: ${error instanceof Error ? error.message : "Unknown error"}` }]
+          contents: [{ uri: uri.href, mimeType: "text/markdown", text: `Error loading project memories: ${error2 instanceof Error ? error2.message : "Unknown error"}` }]
         };
       }
     }
@@ -1337,9 +1468,9 @@ Use this at the start of tasks to understand project conventions and recall past
         return {
           content: [{ type: "text", text: parts.join("\n\n") }]
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          content: [{ type: "text", text: `Failed to get context: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          content: [{ type: "text", text: `Failed to get context: ${error2 instanceof Error ? error2.message : "Unknown error"}` }],
           isError: true
         };
       }
@@ -1376,9 +1507,9 @@ By default, memories are project-scoped when in a git repo. Use global: true for
             }
           ]
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          content: [{ type: "text", text: `Failed to add memory: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          content: [{ type: "text", text: `Failed to add memory: ${error2 instanceof Error ? error2.message : "Unknown error"}` }],
           isError: true
         };
       }
@@ -1415,9 +1546,9 @@ ${formatted}`
             }
           ]
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          content: [{ type: "text", text: `Failed to search memories: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          content: [{ type: "text", text: `Failed to search memories: ${error2 instanceof Error ? error2.message : "Unknown error"}` }],
           isError: true
         };
       }
@@ -1449,9 +1580,9 @@ ${projectRules.map((r) => `- ${r.content}`).join("\n")}`);
         return {
           content: [{ type: "text", text: parts.join("\n\n") }]
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          content: [{ type: "text", text: `Failed to get rules: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          content: [{ type: "text", text: `Failed to get rules: ${error2 instanceof Error ? error2.message : "Unknown error"}` }],
           isError: true
         };
       }
@@ -1489,9 +1620,9 @@ ${formatted}`
             }
           ]
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          content: [{ type: "text", text: `Failed to list memories: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          content: [{ type: "text", text: `Failed to list memories: ${error2 instanceof Error ? error2.message : "Unknown error"}` }],
           isError: true
         };
       }
@@ -1530,9 +1661,9 @@ Find the memory ID first with search_memories or list_memories.`,
           content: [{ type: "text", text: `Memory ${id} not found or already deleted.` }],
           isError: true
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          content: [{ type: "text", text: `Failed to edit memory: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          content: [{ type: "text", text: `Failed to edit memory: ${error2 instanceof Error ? error2.message : "Unknown error"}` }],
           isError: true
         };
       }
@@ -1556,9 +1687,9 @@ Find the memory ID first with search_memories or list_memories.`,
           content: [{ type: "text", text: `Memory ${id} not found or already forgotten.` }],
           isError: true
         };
-      } catch (error) {
+      } catch (error2) {
         return {
-          content: [{ type: "text", text: `Failed to forget memory: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          content: [{ type: "text", text: `Failed to forget memory: ${error2 instanceof Error ? error2.message : "Unknown error"}` }],
           isError: true
         };
       }
@@ -1581,6 +1712,7 @@ var serveCommand = new Command11("serve").description("Start the MCP server (std
 
 // src/commands/sync.ts
 import { Command as Command12 } from "commander";
+import ora from "ora";
 
 // src/lib/turso.ts
 import { nanoid as nanoid2 } from "nanoid";
@@ -1633,27 +1765,69 @@ 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"
 );
-syncCommand.command("enable").description("Provision a Turso database and enable sync").option("-o, --org <org>", "Turso organization", "webrenew").action(async (opts) => {
+syncCommand.command("enable").description("Provision a cloud database and enable sync").option("-o, --org <org>", "Turso organization", "webrenew").action(async (opts) => {
   const existing = await readSyncConfig();
   if (existing) {
-    console.log(`Sync already enabled: ${existing.syncUrl}`);
-    console.log('Run "memories sync push" to sync now.');
+    info(`Sync already enabled`);
+    dim(`Remote: ${existing.syncUrl}`);
+    dim(`Run ${success} memories sync push to sync now.`);
     return;
   }
-  console.log(`Creating database in ${opts.org}...`);
+  const auth = await readAuth();
+  if (auth) {
+    const spinner2 = ora("Fetching cloud database credentials...").start();
+    try {
+      const apiFetch = getApiClient(auth);
+      const res = await apiFetch("/api/db/provision", { method: "POST" });
+      if (res.ok) {
+        const data = await res.json();
+        const profileRes = await apiFetch("/api/db/credentials");
+        if (profileRes.ok) {
+          const creds = await profileRes.json();
+          if (existsSync4(DB_PATH)) {
+            resetDb();
+            unlinkSync(DB_PATH);
+          }
+          await saveSyncConfig({
+            syncUrl: creds.url,
+            syncToken: creds.token,
+            org: opts.org,
+            dbName: creds.dbName
+          });
+          spinner2.text = "Waiting for database to be ready...";
+          await new Promise((r) => setTimeout(r, 3e3));
+          resetDb();
+          await syncDb();
+          spinner2.stop();
+          success("Cloud sync enabled");
+          dim(`Remote: ${data.url}`);
+          dim(`Database: ${creds.dbName}`);
+          return;
+        }
+      }
+      spinner2.stop();
+    } catch {
+      spinner2.stop();
+      warn("Could not fetch credentials from web, provisioning directly...");
+    }
+  } else {
+    warn("Not logged in");
+    proFeature("Cloud sync");
+    return;
+  }
+  const spinner = ora(`Creating database in ${opts.org}...`).start();
   const db = await createDatabase(opts.org);
-  console.log(`Created database: ${db.name} (${db.hostname})`);
-  console.log("Generating auth token...");
+  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);
   }
@@ -1663,40 +1837,48 @@ syncCommand.command("enable").description("Provision a Turso database and enable
     org: opts.org,
     dbName: db.name
   });
-  console.log("Waiting for database to be ready...");
+  spinner.text = "Waiting for database to be ready...";
   await new Promise((r) => setTimeout(r, 3e3));
   resetDb();
   await syncDb();
-  console.log(`Sync enabled: ${syncUrl}`);
+  spinner.stop();
+  success("Cloud sync enabled");
+  dim(`Remote: ${syncUrl}`);
+  dim(`Database: ${db.name}`);
 });
 syncCommand.command("push").description("Push local changes to remote").action(async () => {
   const config = await readSyncConfig();
   if (!config) {
-    console.error('Sync not enabled. Run "memories sync enable" first.');
+    error("Sync not enabled");
+    dim(`Run ${"memories sync enable"} first, or ${"memories login"} to set up cloud sync.`);
     process.exitCode = 1;
     return;
   }
+  const spinner = ora("Syncing to remote...").start();
   await syncDb();
-  console.log("Synced to remote.");
+  spinner.stop();
+  success("Synced to remote");
 });
 syncCommand.command("status").description("Show sync configuration").action(async () => {
   const config = await readSyncConfig();
   if (!config) {
-    console.log("Sync not enabled.");
+    info("Sync not enabled (local-only mode)");
+    dim(`Run ${"memories login"} to enable cloud sync.`);
     return;
   }
-  console.log(`Remote: ${config.syncUrl}`);
-  console.log(`Org: ${config.org}`);
-  console.log(`Database: ${config.dbName}`);
+  success("Cloud sync enabled");
+  dim(`Remote: ${config.syncUrl}`);
+  dim(`Org: ${config.org}`);
+  dim(`Database: ${config.dbName}`);
 });
 
 // src/commands/generate.ts
 import { Command as Command13 } from "commander";
-import chalk10 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 chalk11 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, 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"];
@@ -1709,18 +1891,40 @@ function groupByType(memories) {
   const order = ["Rules", "Key Decisions", "Project Facts", "Notes"];
   return order.filter((t) => groups[t]?.length).map((title) => ({ title, memories: groups[title] }));
 }
-function formatMemoriesAsMarkdown(memories) {
+var AGENT_INSTRUCTIONS = `## Memory Management
+
+When you learn something important about this project, save it for future sessions.
+
+**Via CLI:**
+- \`memories add "<decision>" --type decision\` \u2014 Architectural decisions
+- \`memories add "<convention>" --type rule\` \u2014 Coding conventions
+- \`memories add "<fact>" --type fact\` \u2014 Project facts
+
+**Via MCP (if connected):**
+Use the \`add_memory\` tool with content and type parameters.
+
+**When to save:**
+- Architectural decisions and their rationale
+- Project-specific patterns or conventions
+- Non-obvious setup, configuration, or gotchas
+- Tricky bugs and how they were resolved`;
+function formatMemoriesAsMarkdown(memories, includeAgentInstructions = true) {
   const sections = groupByType(memories);
-  if (sections.length === 0) return "";
-  return sections.map(({ title, memories: mems }) => {
+  const memoriesContent = sections.length === 0 ? "" : sections.map(({ title, memories: mems }) => {
     const items = mems.map((m) => `- ${m.content}`).join("\n");
     return `## ${title}
 
 ${items}`;
   }).join("\n\n");
+  if (includeAgentInstructions) {
+    return memoriesContent ? `${memoriesContent}
+
+${AGENT_INSTRUCTIONS}` : AGENT_INSTRUCTIONS;
+  }
+  return memoriesContent;
 }
 function formatCursorMdc(memories) {
-  const body = formatMemoriesAsMarkdown(memories);
+  const body = formatMemoriesAsMarkdown(memories, true);
   const frontmatter = [
     "---",
     "description: Project memories and rules from memories.sh",
@@ -1735,7 +1939,7 @@ function formatCursorMdc(memories) {
 ${body}`;
 }
 function formatWindsurf(memories) {
-  const full = formatMemoriesAsMarkdown(memories);
+  const full = formatMemoriesAsMarkdown(memories, true);
   const LIMIT = 6e3;
   if (full.length <= LIMIT) return full;
   const truncated = full.slice(0, LIMIT);
@@ -1811,7 +2015,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;
@@ -1822,13 +2026,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(chalk10.dim(`  hint: add "${filePath}" to .gitignore if you don't want it tracked`));
+    console.log(chalk11.dim(`  hint: add "${filePath}" to .gitignore if you don't want it tracked`));
   } catch {
   }
 }
@@ -1836,23 +2040,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(chalk10.dim(`\u2500\u2500 ${target.name} \u2192 ${outPath} \u2500\u2500`));
+    console.log(chalk11.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(
-        chalk10.yellow("\u26A0") + ` ${outPath} exists and was not generated by memories.sh. Use ${chalk10.bold("--force")} to overwrite.`
+        chalk11.yellow("\u26A0") + ` ${outPath} exists and was not generated by memories.sh. Use ${chalk11.bold("--force")} to overwrite.`
       );
       return;
     }
   }
-  await mkdir3(dirname(outPath), { recursive: true });
-  await writeFile4(outPath, content, "utf-8");
-  console.log(chalk10.green("\u2713") + ` Wrote ${target.name} \u2192 ${chalk10.dim(outPath)}`);
+  await mkdir4(dirname(outPath), { recursive: true });
+  await writeFile5(outPath, content, "utf-8");
+  console.log(chalk11.green("\u2713") + ` Wrote ${target.name} \u2192 ${chalk11.dim(outPath)}`);
   await checkGitignore(opts.output ?? target.defaultPath);
 }
 async function fetchMemories(types) {
@@ -1868,23 +2072,23 @@ function parseTypes(raw) {
   const types = raw.split(",").map((s) => s.trim());
   for (const t of types) {
     if (!VALID_TYPES6.includes(t)) {
-      console.error(chalk10.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES6.join(", ")}`);
+      console.error(chalk11.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES6.join(", ")}`);
       process.exit(1);
     }
   }
   return types;
 }
 function getDbPath2() {
-  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 = getDbPath2();
-  if (!existsSync4(dbPath)) {
-    console.error(chalk10.red("\u2717") + " Database not found. Run: memories init");
+  if (!existsSync5(dbPath)) {
+    console.error(chalk11.red("\u2717") + " Database not found. Run: memories init");
     process.exit(1);
   }
-  console.log(chalk10.dim(`Watching ${dbPath} for changes... (Ctrl+C to stop)
+  console.log(chalk11.dim(`Watching ${dbPath} for changes... (Ctrl+C to stop)
 `));
   const mems = await memories();
   if (mems.length > 0) {
@@ -1904,7 +2108,7 @@ async function runWatch(targets, memories, opts) {
           }
         }
       } catch (err) {
-        console.error(chalk10.red("\u2717") + " Watch error:", err.message);
+        console.error(chalk11.red("\u2717") + " Watch error:", err.message);
       }
     }, 500);
   });
@@ -1920,19 +2124,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} ${chalk10.dim(`\u2192 ${t.defaultPath}`)}`,
+        name: `${t.name} ${chalk11.dim(`\u2192 ${t.defaultPath}`)}`,
         value: t.name,
         checked: true
       }))
     });
     if (selected.length === 0) {
-      console.log(chalk10.dim("No targets selected."));
+      console.log(chalk11.dim("No targets selected."));
       return;
     }
     const types = parseTypes(opts.types);
     const memories = await fetchMemories(types);
     if (memories.length === 0) {
-      console.error(chalk10.dim('No memories found. Add some with: memories add --rule "Your rule"'));
+      console.error(chalk11.dim('No memories found. Add some with: memories add --rule "Your rule"'));
       return;
     }
     const selectedSet = new Set(selected);
@@ -1942,9 +2146,9 @@ var generateCommand = new Command13("generate").description("Generate IDE rule/i
     if (opts.watch) {
       await runWatch(TARGETS, () => fetchMemories(types), opts);
     }
-  } catch (error) {
-    if (error.name === "ExitPromptError") return;
-    console.error(chalk10.red("\u2717") + " Failed to generate:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    if (error2.name === "ExitPromptError") return;
+    console.error(chalk11.red("\u2717") + " Failed to generate:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -1955,12 +2159,12 @@ for (const target of TARGETS) {
         const types = parseTypes(opts.types);
         const memories = await fetchMemories(types);
         if (memories.length === 0) {
-          console.error(chalk10.dim('No memories found. Add some with: memories add --rule "Your rule"'));
+          console.error(chalk11.dim('No memories found. Add some with: memories add --rule "Your rule"'));
           return;
         }
         await writeTarget(target, memories, opts);
-      } catch (error) {
-        console.error(chalk10.red("\u2717") + ` Failed to generate ${target.name}:`, error instanceof Error ? error.message : "Unknown error");
+      } catch (error2) {
+        console.error(chalk11.red("\u2717") + ` Failed to generate ${target.name}:`, error2 instanceof Error ? error2.message : "Unknown error");
         process.exit(1);
       }
     })
@@ -1976,14 +2180,14 @@ generateCommand.addCommand(
       }
       const memories = await fetchMemories(types);
       if (memories.length === 0) {
-        console.error(chalk10.dim('No memories found. Add some with: memories add --rule "Your rule"'));
+        console.error(chalk11.dim('No memories found. Add some with: memories add --rule "Your rule"'));
         return;
       }
       for (const target of TARGETS) {
         await writeTarget(target, memories, opts);
       }
-    } catch (error) {
-      console.error(chalk10.red("\u2717") + " Failed to generate:", error instanceof Error ? error.message : "Unknown error");
+    } catch (error2) {
+      console.error(chalk11.red("\u2717") + " Failed to generate:", error2 instanceof Error ? error2.message : "Unknown error");
       process.exit(1);
     }
   })
@@ -1991,11 +2195,11 @@ generateCommand.addCommand(
 
 // src/commands/edit.ts
 import { Command as Command14 } from "commander";
-import chalk11 from "chalk";
+import chalk12 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 nanoid3 } from "nanoid";
 import { select } from "@inquirer/prompts";
 var VALID_TYPES7 = ["rule", "decision", "fact", "note"];
@@ -2007,13 +2211,13 @@ async function pickMemory() {
   const projectId = getProjectId() ?? void 0;
   const memories = await listMemories({ limit: 100, projectId });
   if (memories.length === 0) {
-    console.error(chalk11.dim("No memories found."));
+    console.error(chalk12.dim("No memories found."));
     process.exit(0);
   }
   const id = await select({
     message: "Select a memory to edit",
     choices: memories.map((m) => ({
-      name: `${chalk11.dim(m.type.padEnd(9))} ${truncate2(m.content, 60)} ${chalk11.dim(m.id)}`,
+      name: `${chalk12.dim(m.type.padEnd(9))} ${truncate2(m.content, 60)} ${chalk12.dim(m.id)}`,
       value: m.id
     }))
   });
@@ -2023,7 +2227,7 @@ var editCommand = new Command14("edit").description("Edit an existing memory").a
   try {
     if (!id) {
       if (!process.stdin.isTTY) {
-        console.error(chalk11.red("\u2717") + " Memory ID required in non-interactive mode");
+        console.error(chalk12.red("\u2717") + " Memory ID required in non-interactive mode");
         process.exit(1);
       }
       id = await pickMemory();
@@ -2034,18 +2238,18 @@ var editCommand = new Command14("edit").description("Edit an existing memory").a
       args: [id]
     });
     if (result.rows.length === 0) {
-      console.error(chalk11.red("\u2717") + ` Memory ${chalk11.dim(id)} not found`);
+      console.error(chalk12.red("\u2717") + ` Memory ${chalk12.dim(id)} not found`);
       process.exit(1);
     }
     const memory = result.rows[0];
     if (opts.type && !VALID_TYPES7.includes(opts.type)) {
-      console.error(chalk11.red("\u2717") + ` Invalid type "${opts.type}". Valid: ${VALID_TYPES7.join(", ")}`);
+      console.error(chalk12.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-${nanoid3(6)}.md`);
+      const tmpFile = join6(tmpdir(), `memories-edit-${nanoid3(6)}.md`);
       writeFileSync(tmpFile, memory.content, "utf-8");
       try {
         execFileSync2(editor, [tmpFile], { stdio: "inherit" });
@@ -2057,7 +2261,7 @@ var editCommand = new Command14("edit").description("Edit an existing memory").a
         }
       }
       if (newContent === memory.content) {
-        console.log(chalk11.dim("No changes made."));
+        console.log(chalk12.dim("No changes made."));
         return;
       }
     }
@@ -2067,24 +2271,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(chalk11.red("\u2717") + ` Failed to update memory ${chalk11.dim(id)}`);
+      console.error(chalk12.red("\u2717") + ` Failed to update memory ${chalk12.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(chalk11.green("\u2713") + ` Updated ${chalk11.dim(id)} (${changes.join(", ")})`);
-  } catch (error) {
-    if (error.name === "ExitPromptError") return;
-    console.error(chalk11.red("\u2717") + " Failed to edit memory:", error instanceof Error ? error.message : "Unknown error");
+    console.log(chalk12.green("\u2713") + ` Updated ${chalk12.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");
     process.exit(1);
   }
 });
 
 // src/commands/stats.ts
 import { Command as Command15 } from "commander";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 var statsCommand = new Command15("stats").description("Show memory statistics").option("--json", "Output as JSON").action(async (opts) => {
   try {
     const db = await getDb();
@@ -2121,46 +2325,46 @@ var statsCommand = new Command15("stats").description("Show memory statistics").
       console.log(JSON.stringify(data, null, 2));
       return;
     }
-    console.log(chalk12.bold("Memory Statistics\n"));
+    console.log(chalk13.bold("Memory Statistics\n"));
     if (projectId) {
-      console.log(`  Project: ${chalk12.dim(projectId)}`);
+      console.log(`  Project: ${chalk13.dim(projectId)}`);
     }
-    console.log(`  Total:   ${chalk12.bold(String(total))} active, ${chalk12.dim(String(deleted))} deleted
+    console.log(`  Total:   ${chalk13.bold(String(total))} active, ${chalk13.dim(String(deleted))} deleted
 `);
     if (rows.length === 0) {
-      console.log(chalk12.dim('  No memories yet. Add one with: memories add "Your memory"'));
+      console.log(chalk13.dim('  No memories yet. Add one with: memories add "Your memory"'));
       return;
     }
     const typeWidths = { rule: 8, decision: 8, fact: 8, note: 8 };
     console.log(
-      `  ${chalk12.dim("Type".padEnd(12))}${chalk12.dim("Scope".padEnd(10))}${chalk12.dim("Count")}`
+      `  ${chalk13.dim("Type".padEnd(12))}${chalk13.dim("Scope".padEnd(10))}${chalk13.dim("Count")}`
     );
-    console.log(chalk12.dim("  " + "\u2500".repeat(30)));
+    console.log(chalk13.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 (error) {
-    console.error(chalk12.red("\u2717") + " Failed to get stats:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk13.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 chalk13 from "chalk";
-import { existsSync as existsSync5 } from "fs";
-import { join as join6 } from "path";
+import chalk14 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(chalk13.bold("memories doctor\n"));
+    console.log(chalk14.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` };
@@ -2258,43 +2462,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 ? chalk13.green("\u2713") : chalk13.red("\u2717");
-      console.log(`  ${icon} ${chalk13.bold(check.name)}: ${message}`);
+      const icon = ok ? chalk14.green("\u2713") : chalk14.red("\u2717");
+      console.log(`  ${icon} ${chalk14.bold(check.name)}: ${message}`);
       if (!ok) hasIssues = true;
     }
     if (opts.fix) {
-      console.log(chalk13.bold("\nRunning fixes...\n"));
+      console.log(chalk14.bold("\nRunning fixes...\n"));
       const db = await getDb();
       const purged = await db.execute(
         "DELETE FROM memories WHERE deleted_at IS NOT NULL"
       );
-      console.log(`  ${chalk13.green("\u2713")} Purged ${purged.rowsAffected} soft-deleted records`);
+      console.log(`  ${chalk14.green("\u2713")} Purged ${purged.rowsAffected} soft-deleted records`);
       try {
         await db.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
-        console.log(`  ${chalk13.green("\u2713")} Rebuilt FTS index`);
+        console.log(`  ${chalk14.green("\u2713")} Rebuilt FTS index`);
       } catch {
-        console.log(`  ${chalk13.yellow("\u26A0")} Could not rebuild FTS index`);
+        console.log(`  ${chalk14.yellow("\u26A0")} Could not rebuild FTS index`);
       }
     }
     console.log();
     if (hasIssues) {
-      console.log(chalk13.yellow("Some issues detected.") + (opts.fix ? "" : " Run with --fix to attempt repairs."));
+      console.log(chalk14.yellow("Some issues detected.") + (opts.fix ? "" : " Run with --fix to attempt repairs."));
     } else {
-      console.log(chalk13.green("All checks passed."));
+      console.log(chalk14.green("All checks passed."));
     }
-  } catch (error) {
-    console.error(chalk13.red("\u2717") + " Doctor failed:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk14.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 chalk14 from "chalk";
-import { readFile as readFile5, writeFile as writeFile5, chmod } from "fs/promises";
-import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
+import chalk15 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 = `
@@ -2315,22 +2519,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 {
@@ -2343,31 +2547,31 @@ hookCommand.addCommand(
     try {
       const location = getHookLocation(opts.hook);
       if (!location) {
-        console.error(chalk14.red("\u2717") + " Not in a git repository");
+        console.error(chalk15.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(chalk14.dim("Hook already installed. Use 'memories hook uninstall' first to reinstall."));
+          console.log(chalk15.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(chalk14.green("\u2713") + ` Installed memories hook in ${chalk14.dim(opts.hook)} (${locationLabel})`);
-      console.log(chalk14.dim("  Rule files will auto-generate on each commit."));
+      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."));
       if (detectLintStaged()) {
         console.log(
-          chalk14.dim("\n  lint-staged detected. You can also add to your lint-staged config:") + chalk14.dim('\n  "*.md": "memories generate all --force"')
+          chalk15.dim("\n  lint-staged detected. You can also add to your lint-staged config:") + chalk15.dim('\n  "*.md": "memories generate all --force"')
         );
       }
-    } catch (error) {
-      console.error(chalk14.red("\u2717") + " Failed to install hook:", error instanceof Error ? error.message : "Unknown error");
+    } catch (error2) {
+      console.error(chalk15.red("\u2717") + " Failed to install hook:", error2 instanceof Error ? error2.message : "Unknown error");
       process.exit(1);
     }
   })
@@ -2377,17 +2581,17 @@ hookCommand.addCommand(
     try {
       const location = getHookLocation(opts.hook);
       if (!location) {
-        console.error(chalk14.red("\u2717") + " Not in a git repository");
+        console.error(chalk15.red("\u2717") + " Not in a git repository");
         process.exit(1);
       }
       const hookPath = location.path;
-      if (!existsSync6(hookPath)) {
-        console.log(chalk14.dim("No hook file found."));
+      if (!existsSync7(hookPath)) {
+        console.log(chalk15.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(chalk14.dim("No memories hook found in " + opts.hook));
+        console.log(chalk15.dim("No memories hook found in " + opts.hook));
         return;
       }
       const regex = new RegExp(
@@ -2395,15 +2599,15 @@ hookCommand.addCommand(
       );
       const cleaned = content.replace(regex, "\n");
       if (cleaned.trim() === "#!/bin/sh" || cleaned.trim() === "") {
-        const { unlink } = await import("fs/promises");
-        await unlink(hookPath);
-        console.log(chalk14.green("\u2713") + ` Removed ${chalk14.dim(opts.hook)} hook (was memories-only)`);
+        const { unlink: unlink2 } = await import("fs/promises");
+        await unlink2(hookPath);
+        console.log(chalk15.green("\u2713") + ` Removed ${chalk15.dim(opts.hook)} hook (was memories-only)`);
       } else {
-        await writeFile5(hookPath, cleaned, "utf-8");
-        console.log(chalk14.green("\u2713") + ` Removed memories section from ${chalk14.dim(opts.hook)}`);
+        await writeFile6(hookPath, cleaned, "utf-8");
+        console.log(chalk15.green("\u2713") + ` Removed memories section from ${chalk15.dim(opts.hook)}`);
       }
-    } catch (error) {
-      console.error(chalk14.red("\u2717") + " Failed to uninstall hook:", error instanceof Error ? error.message : "Unknown error");
+    } catch (error2) {
+      console.error(chalk15.red("\u2717") + " Failed to uninstall hook:", error2 instanceof Error ? error2.message : "Unknown error");
       process.exit(1);
     }
   })
@@ -2413,21 +2617,21 @@ hookCommand.addCommand(
     try {
       const hookPath = getHookLocation(opts.hook)?.path;
       if (!hookPath) {
-        console.error(chalk14.red("\u2717") + " Not in a git repository");
+        console.error(chalk15.red("\u2717") + " Not in a git repository");
         process.exit(1);
       }
-      if (!existsSync6(hookPath)) {
-        console.log(chalk14.dim("Not installed") + ` \u2014 no ${opts.hook} hook found`);
+      if (!existsSync7(hookPath)) {
+        console.log(chalk15.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(chalk14.green("\u2713") + ` Installed in ${chalk14.dim(hookPath)}`);
+        console.log(chalk15.green("\u2713") + ` Installed in ${chalk15.dim(hookPath)}`);
       } else {
-        console.log(chalk14.dim("Not installed") + ` \u2014 ${opts.hook} exists but has no memories section`);
+        console.log(chalk15.dim("Not installed") + ` \u2014 ${opts.hook} exists but has no memories section`);
       }
-    } catch (error) {
-      console.error(chalk14.red("\u2717") + " Failed to check hook:", error instanceof Error ? error.message : "Unknown error");
+    } catch (error2) {
+      console.error(chalk15.red("\u2717") + " Failed to check hook:", error2 instanceof Error ? error2.message : "Unknown error");
       process.exit(1);
     }
   })
@@ -2438,9 +2642,9 @@ function escapeRegex(str) {
 
 // src/commands/ingest.ts
 import { Command as Command18 } from "commander";
-import chalk15 from "chalk";
-import { readFile as readFile6 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
+import chalk16 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" },
@@ -2500,14 +2704,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(chalk15.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES8.join(", ")}`);
+      console.error(chalk16.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 });
           }
         }
@@ -2516,27 +2720,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(chalk15.red("\u2717") + ` No ${known.description} file found at: ${known.paths.join(", ")}`);
+          console.error(chalk16.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(chalk15.red("\u2717") + ` Unknown source "${source}". Valid: ${SOURCES.map((s) => s.name).join(", ")}, or a file path`);
+        console.error(chalk16.red("\u2717") + ` Unknown source "${source}". Valid: ${SOURCES.map((s) => s.name).join(", ")}, or a file path`);
         process.exit(1);
       }
     } else {
-      console.error(chalk15.red("\u2717") + " Specify a source or use --all");
+      console.error(chalk16.red("\u2717") + " Specify a source or use --all");
       process.exit(1);
     }
     if (filesToProcess.length === 0) {
-      console.log(chalk15.dim("No IDE rule files found."));
+      console.log(chalk16.dim("No IDE rule files found."));
       return;
     }
     const existingSet = /* @__PURE__ */ new Set();
@@ -2550,29 +2754,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(chalk15.dim(`  Skipping ${file.path} (generated by memories.sh)`));
+        console.log(chalk16.dim(`  Skipping ${file.path} (generated by memories.sh)`));
         continue;
       }
       const memories = extractMemories(content);
       if (memories.length === 0) {
-        console.log(chalk15.dim(`  No importable memories found in ${file.path}`));
+        console.log(chalk16.dim(`  No importable memories found in ${file.path}`));
         continue;
       }
-      console.log(chalk15.bold(`
-  ${file.name}`) + chalk15.dim(` (${file.path}) \u2014 ${memories.length} items`));
+      console.log(chalk16.bold(`
+  ${file.name}`) + chalk16.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(`    ${chalk15.dim("skip")}      ${chalk15.dim(mem.content)}`);
+            console.log(`    ${chalk16.dim("skip")}      ${chalk16.dim(mem.content)}`);
           }
           totalSkipped++;
           continue;
         }
         if (opts.dryRun) {
-          const typeColor = type === "rule" ? chalk15.blue : type === "decision" ? chalk15.yellow : type === "fact" ? chalk15.green : chalk15.dim;
+          const typeColor = type === "rule" ? chalk16.blue : type === "decision" ? chalk16.yellow : type === "fact" ? chalk16.green : chalk16.dim;
           console.log(`    ${typeColor(type.padEnd(9))} ${mem.content}`);
         } else {
           await addMemory(mem.content, { type });
@@ -2583,23 +2787,23 @@ var ingestCommand = new Command18("ingest").description("Import memories from ex
     }
     if (opts.dryRun) {
       const skipMsg = totalSkipped > 0 ? ` (${totalSkipped} duplicates skipped)` : "";
-      console.log(chalk15.dim(`
+      console.log(chalk16.dim(`
   Dry run \u2014 no memories imported.${skipMsg} Remove --dry-run to import.`));
     } else {
-      const skipMsg = totalSkipped > 0 ? chalk15.dim(` (${totalSkipped} duplicates skipped)`) : "";
-      console.log(chalk15.green("\n\u2713") + ` Imported ${totalImported} memories` + skipMsg);
+      const skipMsg = totalSkipped > 0 ? chalk16.dim(` (${totalSkipped} duplicates skipped)`) : "";
+      console.log(chalk16.green("\n\u2713") + ` Imported ${totalImported} memories` + skipMsg);
     }
-  } catch (error) {
-    console.error(chalk15.red("\u2717") + " Failed to ingest:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk16.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 chalk16 from "chalk";
-import { readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import chalk17 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"];
@@ -2632,7 +2836,7 @@ function parseTypes2(raw) {
   const types = raw.split(",").map((s) => s.trim());
   for (const t of types) {
     if (!VALID_TYPES9.includes(t)) {
-      console.error(chalk16.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES9.join(", ")}`);
+      console.error(chalk17.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES9.join(", ")}`);
       process.exit(1);
     }
   }
@@ -2644,7 +2848,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: [],
@@ -2655,7 +2859,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);
@@ -2671,7 +2875,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(chalk16.red("\u2717") + ` Unknown target "${target}". Valid: ${TARGETS2.map((t) => t.name).join(", ")}`);
+      console.error(chalk17.red("\u2717") + ` Unknown target "${target}". Valid: ${TARGETS2.map((t) => t.name).join(", ")}`);
       process.exit(1);
     }
     let anyStale = false;
@@ -2680,54 +2884,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(chalk16.bold(`
-  ${t.name}`) + chalk16.dim(` \u2192 ${result.filePath}`));
-        console.log(chalk16.yellow("    Not generated yet.") + chalk16.dim(` Run: memories generate ${t.name}`));
+        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}`));
         anyStale = true;
         continue;
       }
       if (!result.isOurs) {
-        console.log(chalk16.bold(`
-  ${t.name}`) + chalk16.dim(` \u2192 ${result.filePath}`));
-        console.log(chalk16.dim("    Not managed by memories.sh (no marker found)"));
+        console.log(chalk17.bold(`
+  ${t.name}`) + chalk17.dim(` \u2192 ${result.filePath}`));
+        console.log(chalk17.dim("    Not managed by memories.sh (no marker found)"));
         continue;
       }
       if (!hasChanges) {
         if (target) {
-          console.log(chalk16.bold(`
-  ${t.name}`) + chalk16.dim(` \u2192 ${result.filePath}`));
-          const since = result.generatedAt ? chalk16.dim(` (generated ${formatRelative(result.generatedAt)})`) : "";
-          console.log(chalk16.green("    Up to date.") + since);
+          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);
         }
         continue;
       }
       anyStale = true;
-      console.log(chalk16.bold(`
-  ${t.name}`) + chalk16.dim(` \u2192 ${result.filePath}`));
+      console.log(chalk17.bold(`
+  ${t.name}`) + chalk17.dim(` \u2192 ${result.filePath}`));
       if (result.generatedAt) {
-        console.log(chalk16.dim(`    Generated ${formatRelative(result.generatedAt)}`));
+        console.log(chalk17.dim(`    Generated ${formatRelative(result.generatedAt)}`));
       }
       for (const a of result.added) {
-        console.log(chalk16.green(`    + ${a}`));
+        console.log(chalk17.green(`    + ${a}`));
       }
       for (const r of result.removed) {
-        console.log(chalk16.red(`    - ${r}`));
+        console.log(chalk17.red(`    - ${r}`));
       }
       if (result.unchanged > 0) {
-        console.log(chalk16.dim(`    ${result.unchanged} unchanged`));
+        console.log(chalk17.dim(`    ${result.unchanged} unchanged`));
       }
     }
     if (!anyStale) {
       if (target) {
       } else {
-        console.log(chalk16.green("\n  All generated files are up to date."));
+        console.log(chalk17.green("\n  All generated files are up to date."));
       }
     } else {
-      console.log(chalk16.dim(`
-  Run ${chalk16.bold("memories generate")} to update stale files.`));
+      console.log(chalk17.dim(`
+  Run ${chalk17.bold("memories generate")} to update stale files.`));
     }
-  } catch (error) {
-    console.error(chalk16.red("\u2717") + " Diff failed:", error instanceof Error ? error.message : "Unknown error");
+  } catch (error2) {
+    console.error(chalk17.red("\u2717") + " Diff failed:", error2 instanceof Error ? error2.message : "Unknown error");
     process.exit(1);
   }
 });
@@ -2748,7 +2952,7 @@ function formatRelative(isoDate) {
 
 // src/commands/tag.ts
 import { Command as Command20 } from "commander";
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 var VALID_TYPES10 = ["rule", "decision", "fact", "note"];
 function buildWhere(filters) {
   const conditions = ["deleted_at IS NULL"];
@@ -2800,12 +3004,12 @@ tagCommand.addCommand(
         updated++;
       }
       if (opts.dryRun) {
-        console.log(chalk17.dim(`Dry run \u2014 would tag ${updated} memories with "${tag}" (${skipped} already tagged)`));
+        console.log(chalk18.dim(`Dry run \u2014 would tag ${updated} memories with "${tag}" (${skipped} already tagged)`));
       } else {
-        console.log(chalk17.green("\u2713") + ` Tagged ${updated} memories with "${tag}"` + (skipped > 0 ? chalk17.dim(` (${skipped} already tagged)`) : ""));
+        console.log(chalk18.green("\u2713") + ` Tagged ${updated} memories with "${tag}"` + (skipped > 0 ? chalk18.dim(` (${skipped} already tagged)`) : ""));
       }
-    } catch (error) {
-      console.error(chalk17.red("\u2717") + ` Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    } catch (error2) {
+      console.error(chalk18.red("\u2717") + ` Failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
       process.exit(1);
     }
   })
@@ -2834,12 +3038,12 @@ tagCommand.addCommand(
         updated++;
       }
       if (opts.dryRun) {
-        console.log(chalk17.dim(`Dry run \u2014 would remove "${tag}" from ${updated} memories`));
+        console.log(chalk18.dim(`Dry run \u2014 would remove "${tag}" from ${updated} memories`));
       } else {
-        console.log(chalk17.green("\u2713") + ` Removed "${tag}" from ${updated} memories`);
+        console.log(chalk18.green("\u2713") + ` Removed "${tag}" from ${updated} memories`);
       }
-    } catch (error) {
-      console.error(chalk17.red("\u2717") + ` Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    } catch (error2) {
+      console.error(chalk18.red("\u2717") + ` Failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
       process.exit(1);
     }
   })
@@ -2860,22 +3064,110 @@ tagCommand.addCommand(
         }
       }
       if (counts.size === 0) {
-        console.log(chalk17.dim("No tags found."));
+        console.log(chalk18.dim("No tags found."));
         return;
       }
       const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]);
       for (const [tag, count] of sorted) {
-        console.log(`  ${chalk17.bold(tag)} ${chalk17.dim(`(${count})`)}`);
+        console.log(`  ${chalk18.bold(tag)} ${chalk18.dim(`(${count})`)}`);
       }
-    } catch (error) {
-      console.error(chalk17.red("\u2717") + ` Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    } catch (error2) {
+      console.error(chalk18.red("\u2717") + ` Failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
       process.exit(1);
     }
   })
 );
 
+// src/commands/login.ts
+import { Command as Command21 } from "commander";
+import chalk19 from "chalk";
+import ora2 from "ora";
+import { randomBytes } from "crypto";
+import { execFile } from "child_process";
+var DEFAULT_API_URL = "https://memories.sh";
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  execFile(cmd, [url], () => {
+  });
+}
+var loginCommand = new Command21("login").description("Log in to memories.sh to enable cloud sync").option("--api-url <url>", "API base URL", DEFAULT_API_URL).action(async (opts) => {
+  banner();
+  const existing = await readAuth();
+  if (existing) {
+    warn(`Already logged in as ${chalk19.bold(existing.email)}`);
+    dim(`Run ${chalk19.cyan("memories logout")} to sign out first.`);
+    return;
+  }
+  box(
+    chalk19.bold("Pro features include:\n\n") + chalk19.dim("\u2192 ") + "Cloud sync & backup\n" + chalk19.dim("\u2192 ") + "Cross-device access\n" + chalk19.dim("\u2192 ") + "Web dashboard\n" + chalk19.dim("\u2192 ") + "Priority support",
+    "Upgrade to Pro"
+  );
+  const code = randomBytes(16).toString("hex");
+  const authUrl = `${opts.apiUrl}/app/auth/cli?code=${code}`;
+  console.log(chalk19.bold("Open this URL in your browser:\n"));
+  console.log(`  ${chalk19.cyan(authUrl)}
+`);
+  try {
+    openBrowser(authUrl);
+    dim("Browser opened automatically");
+  } catch {
+  }
+  const spinner = ora2({
+    text: "Waiting for authorization...",
+    color: "magenta"
+  }).start();
+  const maxAttempts = 60;
+  for (let i = 0; i < maxAttempts; i++) {
+    await new Promise((r) => setTimeout(r, 5e3));
+    spinner.text = `Waiting for authorization... (${Math.floor((maxAttempts - i) * 5 / 60)}m remaining)`;
+    try {
+      const res = await fetch(`${opts.apiUrl}/api/auth/cli`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "poll", code })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        await saveAuth({
+          token: data.token,
+          email: data.email,
+          apiUrl: opts.apiUrl
+        });
+        spinner.stop();
+        console.log("");
+        success(`Logged in as ${chalk19.bold(data.email)}`);
+        dim("Your cloud database has been provisioned automatically.");
+        nextSteps([
+          `${chalk19.cyan("memories sync")} ${chalk19.dim("to sync your memories")}`,
+          `${chalk19.cyan("memories.sh/app")} ${chalk19.dim("to view your dashboard")}`
+        ]);
+        return;
+      }
+      if (res.status !== 202) {
+        const text = await res.text();
+        spinner.stop();
+        error(`Authorization failed: ${text}`);
+        return;
+      }
+    } catch {
+    }
+  }
+  spinner.stop();
+  error("Authorization timed out. Please try again.");
+});
+var logoutCommand = new Command21("logout").description("Log out of memories.sh").action(async () => {
+  const existing = await readAuth();
+  if (!existing) {
+    info("Not logged in.");
+    return;
+  }
+  await clearAuth();
+  success("Logged out successfully.");
+});
+
 // src/index.ts
-var program = new Command21().name("memories").description("A local-first memory layer for AI agents").version("0.1.0");
+var program = new Command22().name("memories").description("A local-first memory layer for AI agents").version("0.2.1");
 program.addCommand(initCommand);
 program.addCommand(addCommand);
 program.addCommand(recallCommand);
@@ -2896,4 +3188,6 @@ program.addCommand(hookCommand);
 program.addCommand(ingestCommand);
 program.addCommand(diffCommand);
 program.addCommand(tagCommand);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
 program.parse();