@memories.sh/cli 0.2.1 → 0.2.2

package/dist/index.js

@@ -1,492 +1,64 @@
 #!/usr/bin/env node
+import {
+  ensureEmbeddingsSchema,
+  getEmbedding,
+  storeEmbedding
+} from "./chunk-4GNYCHD4.js";
+import {
+  addMemory,
+  bulkForgetByIds,
+  findMemoriesToForget,
+  forgetMemory,
+  getContext,
+  getGitRoot,
+  getMemoryById,
+  getProjectId,
+  getRules,
+  listMemories,
+  searchMemories,
+  updateMemory
+} from "./chunk-JMN3U7AI.js";
+import {
+  getConfigDir,
+  getDb,
+  readSyncConfig,
+  resetDb,
+  saveSyncConfig,
+  syncDb
+} from "./chunk-BDPB4ABQ.js";
 
 // src/index.ts
-import { Command as Command22 } from "commander";
+import { Command as Command28 } from "commander";
 
 // src/commands/init.ts
 import { Command } from "commander";
 import chalk2 from "chalk";
 
-// src/lib/db.ts
-import { createClient } from "@libsql/client";
-import { mkdir, readFile, writeFile } from "fs/promises";
+// src/lib/auth.ts
+import { readFile, writeFile, mkdir, unlink } from "fs/promises";
 import { existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-function resolveConfigDir() {
-  return process.env.MEMORIES_DATA_DIR ?? join(homedir(), ".config", "memories");
-}
-function getConfigDir() {
-  return resolveConfigDir();
-}
-function getDbPath() {
-  return join(resolveConfigDir(), "local.db");
-}
-function getSyncConfigPath() {
-  return join(resolveConfigDir(), "sync.json");
-}
-var client;
-async function getDb() {
-  if (client) return client;
-  const configDir = resolveConfigDir();
-  const dbPath = getDbPath();
-  await mkdir(configDir, { recursive: true });
-  const sync = await readSyncConfig();
-  if (sync) {
-    client = createClient({
-      url: `file:${dbPath}`,
-      syncUrl: sync.syncUrl,
-      authToken: sync.syncToken
-    });
-    await runMigrations(client);
-    await client.sync();
-  } else {
-    client = createClient({ url: `file:${dbPath}` });
-    await runMigrations(client);
-  }
-  return client;
-}
-function resetDb() {
-  client?.close();
-  client = void 0;
-}
-async function syncDb() {
-  const db = await getDb();
-  await db.sync();
-}
-async function saveSyncConfig(config) {
-  const configDir = resolveConfigDir();
-  await mkdir(configDir, { recursive: true });
-  await writeFile(getSyncConfigPath(), JSON.stringify(config, null, 2), "utf-8");
-}
-async function readSyncConfig() {
-  const syncPath = getSyncConfigPath();
-  if (!existsSync(syncPath)) return null;
-  const raw = await readFile(syncPath, "utf-8");
-  return JSON.parse(raw);
-}
-async function runMigrations(db) {
-  await db.execute(
-    `CREATE TABLE IF NOT EXISTS memories (
-      id TEXT PRIMARY KEY,
-      content TEXT NOT NULL,
-      tags TEXT,
-      scope TEXT NOT NULL DEFAULT 'global',
-      project_id TEXT,
-      type TEXT NOT NULL DEFAULT 'note',
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-      deleted_at TEXT
-    )`
-  );
-  try {
-    await db.execute(`ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'global'`);
-  } catch {
-  }
-  try {
-    await db.execute(`ALTER TABLE memories ADD COLUMN project_id TEXT`);
-  } catch {
-  }
-  try {
-    await db.execute(`ALTER TABLE memories ADD COLUMN type TEXT NOT NULL DEFAULT 'note'`);
-  } catch {
-  }
-  await db.execute(
-    `CREATE TABLE IF NOT EXISTS configs (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    )`
-  );
-  await db.execute(
-    `CREATE TABLE IF NOT EXISTS projects (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      path TEXT,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    )`
-  );
-  await db.execute(
-    `CREATE TABLE IF NOT EXISTS sync_state (
-      id TEXT PRIMARY KEY,
-      last_synced_at TEXT,
-      remote_url TEXT
-    )`
-  );
-  await db.execute(
-    `CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      content,
-      tags,
-      content='memories',
-      content_rowid='rowid'
-    )`
-  );
-  await db.execute(`DROP TRIGGER IF EXISTS memories_ai`);
-  await db.execute(`DROP TRIGGER IF EXISTS memories_ad`);
-  await db.execute(`DROP TRIGGER IF EXISTS memories_au`);
-  await db.execute(`
-    CREATE TRIGGER memories_ai AFTER INSERT ON memories
-    WHEN NEW.deleted_at IS NULL
-    BEGIN
-      INSERT INTO memories_fts(rowid, content, tags) VALUES (NEW.rowid, NEW.content, NEW.tags);
-    END
-  `);
-  await db.execute(`
-    CREATE TRIGGER memories_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, content, tags) VALUES('delete', OLD.rowid, OLD.content, OLD.tags);
-    END
-  `);
-  await db.execute(`
-    CREATE TRIGGER memories_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, content, tags) VALUES('delete', OLD.rowid, OLD.content, OLD.tags);
-      INSERT INTO memories_fts(rowid, content, tags)
-        SELECT NEW.rowid, NEW.content, NEW.tags WHERE NEW.deleted_at IS NULL;
-    END
-  `);
-  try {
-    await db.execute(`CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type)`);
-  } catch {
-  }
-  try {
-    await db.execute(`CREATE INDEX IF NOT EXISTS idx_memories_scope_project ON memories(scope, project_id)`);
-  } catch {
-  }
-}
-
-// src/lib/git.ts
-import { execSync } from "child_process";
-function getGitRemoteUrl(cwd) {
-  try {
-    const remote = execSync("git remote get-url origin", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return remote || null;
-  } catch {
-    return null;
-  }
-}
-function getGitRoot(cwd) {
-  try {
-    const root = execSync("git rev-parse --show-toplevel", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return root || null;
-  } catch {
-    return null;
-  }
-}
-function normalizeGitUrl(url) {
-  let normalized = url.trim();
-  if (normalized.endsWith(".git")) {
-    normalized = normalized.slice(0, -4);
-  }
-  const sshMatch = normalized.match(/^git@([^:]+):(.+)$/);
-  if (sshMatch) {
-    return `${sshMatch[1]}/${sshMatch[2]}`;
-  }
-  const httpsMatch = normalized.match(/^https?:\/\/([^/]+)\/(.+)$/);
-  if (httpsMatch) {
-    return `${httpsMatch[1]}/${httpsMatch[2]}`;
-  }
-  return normalized;
-}
-function getProjectId(cwd) {
-  const remoteUrl = getGitRemoteUrl(cwd);
-  if (!remoteUrl) return null;
-  return normalizeGitUrl(remoteUrl);
-}
-
-// src/lib/memory.ts
-import { nanoid } from "nanoid";
-async function addMemory(content, opts) {
-  const db = await getDb();
-  const id = nanoid(12);
-  const tags = opts?.tags?.length ? opts.tags.join(",") : null;
-  const type = opts?.type ?? "note";
-  let scope = "global";
-  let projectId = null;
-  if (!opts?.global) {
-    projectId = opts?.projectId ?? getProjectId();
-    if (projectId) {
-      scope = "project";
-    }
-  }
-  await db.execute({
-    sql: `INSERT INTO memories (id, content, tags, scope, project_id, type) VALUES (?, ?, ?, ?, ?, ?)`,
-    args: [id, content, tags, scope, projectId, type]
-  });
-  const result = await db.execute({
-    sql: `SELECT * FROM memories WHERE id = ?`,
-    args: [id]
-  });
-  return result.rows[0];
-}
-async function searchMemories(query, opts) {
-  const db = await getDb();
-  const limit = opts?.limit ?? 20;
-  const includeGlobal = opts?.includeGlobal ?? true;
-  const projectId = opts?.globalOnly ? void 0 : opts?.projectId ?? getProjectId();
-  const scopeConditions = [];
-  const args = [];
-  if (includeGlobal) {
-    scopeConditions.push("m.scope = 'global'");
-  }
-  if (projectId) {
-    scopeConditions.push("(m.scope = 'project' AND m.project_id = ?)");
-    args.push(projectId);
-  }
-  if (scopeConditions.length === 0) {
-    return [];
-  }
-  let typeFilter = "";
-  if (opts?.types?.length) {
-    const placeholders = opts.types.map(() => "?").join(", ");
-    typeFilter = `AND m.type IN (${placeholders})`;
-    args.push(...opts.types);
-  }
-  const ftsQuery = query.split(/\s+/).filter(Boolean).map((term) => `"${term}"*`).join(" OR ");
-  args.push(limit);
-  try {
-    const result = await db.execute({
-      sql: `
-        SELECT m.*, bm25(memories_fts) as rank
-        FROM memories m
-        JOIN memories_fts fts ON m.rowid = fts.rowid
-        WHERE memories_fts MATCH ?
-          AND m.deleted_at IS NULL
-          AND (${scopeConditions.join(" OR ")})
-          ${typeFilter}
-        ORDER BY rank ASC, m.created_at DESC
-        LIMIT ?
-      `,
-      args: [ftsQuery, ...args]
-    });
-    return result.rows;
-  } catch (error2) {
-    console.error("FTS search failed, falling back to LIKE:", error2);
-    return searchMemoriesLike(query, opts);
-  }
-}
-async function searchMemoriesLike(query, opts) {
-  const db = await getDb();
-  const limit = opts?.limit ?? 20;
-  const includeGlobal = opts?.includeGlobal ?? true;
-  const projectId = opts?.globalOnly ? void 0 : opts?.projectId ?? getProjectId();
-  const conditions = ["deleted_at IS NULL", "content LIKE ?"];
-  const args = [`%${query}%`];
-  const scopeConditions = [];
-  if (includeGlobal) {
-    scopeConditions.push("scope = 'global'");
-  }
-  if (projectId) {
-    scopeConditions.push("(scope = 'project' AND project_id = ?)");
-    args.push(projectId);
-  }
-  if (scopeConditions.length === 0) {
-    return [];
-  }
-  conditions.push(`(${scopeConditions.join(" OR ")})`);
-  if (opts?.types?.length) {
-    const placeholders = opts.types.map(() => "?").join(", ");
-    conditions.push(`type IN (${placeholders})`);
-    args.push(...opts.types);
-  }
-  args.push(limit);
-  const result = await db.execute({
-    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC LIMIT ?`,
-    args
-  });
-  return result.rows;
-}
-async function listMemories(opts) {
-  const db = await getDb();
-  const limit = opts?.limit ?? 50;
-  const includeGlobal = opts?.includeGlobal ?? true;
-  const projectId = opts?.globalOnly ? void 0 : opts?.projectId ?? getProjectId();
-  const conditions = ["deleted_at IS NULL"];
-  const args = [];
-  const scopeConditions = [];
-  if (includeGlobal) {
-    scopeConditions.push("scope = 'global'");
-  }
-  if (projectId) {
-    scopeConditions.push("(scope = 'project' AND project_id = ?)");
-    args.push(projectId);
-  }
-  if (scopeConditions.length === 0) {
-    return [];
-  }
-  conditions.push(`(${scopeConditions.join(" OR ")})`);
-  if (opts?.tags?.length) {
-    const tagClauses = opts.tags.map(() => `tags LIKE ?`).join(" OR ");
-    conditions.push(`(${tagClauses})`);
-    args.push(...opts.tags.map((t) => `%${t}%`));
-  }
-  if (opts?.types?.length) {
-    const placeholders = opts.types.map(() => "?").join(", ");
-    conditions.push(`type IN (${placeholders})`);
-    args.push(...opts.types);
-  }
-  args.push(limit);
-  const result = await db.execute({
-    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY type ASC, scope ASC, created_at DESC LIMIT ?`,
-    args
-  });
-  return result.rows;
-}
-async function getRules(opts) {
-  const db = await getDb();
-  const projectId = opts?.projectId ?? getProjectId();
-  const conditions = ["deleted_at IS NULL", "type = 'rule'"];
-  const args = [];
-  const scopeConditions = ["scope = 'global'"];
-  if (projectId) {
-    scopeConditions.push("(scope = 'project' AND project_id = ?)");
-    args.push(projectId);
-  }
-  conditions.push(`(${scopeConditions.join(" OR ")})`);
-  const result = await db.execute({
-    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY scope ASC, created_at ASC`,
-    args
-  });
-  return result.rows;
-}
-async function getContext(query, opts) {
-  const projectId = opts?.projectId ?? getProjectId();
-  const limit = opts?.limit ?? 10;
-  const rules = await getRules({ projectId: projectId ?? void 0 });
-  let memories = [];
-  if (query) {
-    memories = await searchMemories(query, {
-      projectId: projectId ?? void 0,
-      limit,
-      types: ["decision", "fact", "note"]
-      // Exclude rules, they're already included
-    });
-  }
-  return { rules, memories };
-}
-async function updateMemory(id, updates) {
-  const db = await getDb();
-  const existing = await db.execute({
-    sql: `SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL`,
-    args: [id]
-  });
-  if (existing.rows.length === 0) return null;
-  const setClauses = ["updated_at = datetime('now')"];
-  const args = [];
-  if (updates.content !== void 0) {
-    setClauses.push("content = ?");
-    args.push(updates.content);
-  }
-  if (updates.tags !== void 0) {
-    setClauses.push("tags = ?");
-    args.push(updates.tags.length ? updates.tags.join(",") : null);
-  }
-  if (updates.type !== void 0) {
-    setClauses.push("type = ?");
-    args.push(updates.type);
-  }
-  args.push(id);
-  await db.execute({
-    sql: `UPDATE memories SET ${setClauses.join(", ")} WHERE id = ?`,
-    args
-  });
-  const result = await db.execute({
-    sql: `SELECT * FROM memories WHERE id = ?`,
-    args: [id]
-  });
-  return result.rows[0];
-}
-async function forgetMemory(id) {
-  const db = await getDb();
-  const existing = await db.execute({
-    sql: `SELECT id FROM memories WHERE id = ? AND deleted_at IS NULL`,
-    args: [id]
-  });
-  if (existing.rows.length === 0) return false;
-  await db.execute({
-    sql: `UPDATE memories SET deleted_at = datetime('now') WHERE id = ?`,
-    args: [id]
-  });
-  return true;
-}
-async function findMemoriesToForget(filter) {
-  const db = await getDb();
-  const conditions = ["deleted_at IS NULL"];
-  const args = [];
-  if (filter.types?.length) {
-    const placeholders = filter.types.map(() => "?").join(", ");
-    conditions.push(`type IN (${placeholders})`);
-    args.push(...filter.types);
-  }
-  if (filter.tags?.length) {
-    const tagClauses = filter.tags.map(() => `tags LIKE ?`).join(" OR ");
-    conditions.push(`(${tagClauses})`);
-    args.push(...filter.tags.map((t) => `%${t}%`));
-  }
-  if (filter.olderThanDays !== void 0) {
-    conditions.push(`created_at < datetime('now', ?)`);
-    args.push(`-${filter.olderThanDays} days`);
-  }
-  if (filter.pattern) {
-    const likePattern = filter.pattern.replace(/%/g, "\\%").replace(/_/g, "\\_").replace(/\*/g, "%").replace(/\?/g, "_");
-    conditions.push(`content LIKE ? ESCAPE '\\'`);
-    args.push(`%${likePattern}%`);
-  }
-  if (filter.projectId) {
-    conditions.push("(scope = 'project' AND project_id = ?)");
-    args.push(filter.projectId);
-  }
-  const result = await db.execute({
-    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC`,
-    args
-  });
-  return result.rows;
-}
-async function bulkForgetByIds(ids) {
-  if (ids.length === 0) return 0;
-  const db = await getDb();
-  const batchSize = 500;
-  for (let i = 0; i < ids.length; i += batchSize) {
-    const batch = ids.slice(i, i + batchSize);
-    const placeholders = batch.map(() => "?").join(", ");
-    await db.execute({
-      sql: `UPDATE memories SET deleted_at = datetime('now') WHERE id IN (${placeholders})`,
-      args: batch
-    });
-  }
-  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");
+var AUTH_DIR = join(homedir(), ".config", "memories");
+var AUTH_FILE = join(AUTH_DIR, "auth.json");
 async function readAuth() {
-  if (!existsSync2(AUTH_FILE)) return null;
+  if (!existsSync(AUTH_FILE)) return null;
   try {
-    const raw = await readFile2(AUTH_FILE, "utf-8");
+    const raw = await readFile(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), {
+  await mkdir(AUTH_DIR, { recursive: true });
+  await writeFile(AUTH_FILE, JSON.stringify(data, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
 }
 async function clearAuth() {
-  if (existsSync2(AUTH_FILE)) {
+  if (existsSync(AUTH_FILE)) {
     await unlink(AUTH_FILE);
   }
 }
@@ -559,56 +131,74 @@ function proFeature(feature) {
 }
 
 // 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) => {
+var SUPPORTED_TOOLS = [
+  { name: "Cursor", cmd: "cursor" },
+  { name: "Claude Code", cmd: "claude" },
+  { name: "GitHub Copilot", cmd: "copilot" },
+  { name: "Windsurf", cmd: "windsurf" },
+  { name: "Gemini CLI", cmd: "gemini" }
+];
+var initCommand = new Command("init").description("Initialize memories - one place for all your AI coding tools").option("-g, --global", "Initialize global rules (apply to all projects)").option("-r, --rule <rule>", "Add an initial rule", (val, acc) => [...acc, val], []).action(async (opts) => {
   try {
     banner();
-    step(1, 3, "Initializing database...");
+    console.log(chalk2.dim("  One place for your rules. Works with every tool.\n"));
+    step(1, 3, "Setting up rule storage...");
     await getDb();
     const configDir = getConfigDir();
-    dim(`Database: ${configDir}/local.db`);
+    dim(`Location: ${configDir}/local.db`);
     step(2, 3, "Detecting scope...");
     let useGlobal = opts.global;
     if (!useGlobal) {
       const projectId = getProjectId();
       const gitRoot = getGitRoot();
       if (!projectId) {
-        warn("Not in a git repository - using global scope");
-        dim("Global memories apply to all projects");
         useGlobal = true;
+        success("Global scope (rules apply to all projects)");
       } else {
-        success("Using project scope");
+        success("Project scope detected");
         dim(`Project: ${projectId}`);
         dim(`Root: ${gitRoot}`);
+        dim("Use --global for rules that apply everywhere");
       }
-    }
-    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");
+      success("Global scope (rules apply to all projects)");
     }
+    step(3, 3, "Supported tools...");
+    const toolList = SUPPORTED_TOOLS.map((t) => t.name).join(", ");
+    success(`${toolList}, + any MCP client`);
     if (opts.rule?.length) {
       console.log("");
-      info("Adding initial rules...");
+      info("Adding rules...");
       for (const rule of opts.rule) {
         const memory = await addMemory(rule, {
           type: "rule",
           global: useGlobal
         });
-        dim(`${memory.id}: ${rule}`);
+        dim(`+ ${rule}`);
       }
     }
-    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")}`
-    ]);
+    console.log("");
+    const auth = await readAuth();
+    if (auth) {
+      success(`Syncing as ${chalk2.bold(auth.email)}`);
+    } else {
+      dim("Local only. Run " + chalk2.cyan("memories login") + " to sync across machines.");
+    }
+    console.log("");
+    console.log(chalk2.bold("  Quick Start:"));
+    console.log("");
+    console.log(chalk2.dim("  1. Add your rules:"));
+    console.log(`     ${chalk2.cyan("memories add --rule")} ${chalk2.dim('"Always use TypeScript strict mode"')}`);
+    console.log(`     ${chalk2.cyan("memories add --rule")} ${chalk2.dim('"Prefer functional components in React"')}`);
+    console.log("");
+    console.log(chalk2.dim("  2. Generate for your tools:"));
+    console.log(`     ${chalk2.cyan("memories generate cursor")}   ${chalk2.dim("\u2192 .cursor/rules/memories.mdc")}`);
+    console.log(`     ${chalk2.cyan("memories generate claude")}   ${chalk2.dim("\u2192 CLAUDE.md")}`);
+    console.log(`     ${chalk2.cyan("memories generate copilot")}  ${chalk2.dim("\u2192 .github/copilot-instructions.md")}`);
+    console.log(`     ${chalk2.cyan("memories generate all")}      ${chalk2.dim("\u2192 all tools at once")}`);
+    console.log("");
+    console.log(chalk2.dim("  3. Switch tools anytime - your rules follow you."));
+    console.log("");
   } catch (error2) {
     error("Failed to initialize: " + (error2 instanceof Error ? error2.message : "Unknown error"));
     process.exit(1);
@@ -618,9 +208,145 @@ var initCommand = new Command("init").description("Initialize memories for the c
 // src/commands/add.ts
 import { Command as Command2 } from "commander";
 import chalk3 from "chalk";
+
+// src/lib/templates.ts
+import { input } from "@inquirer/prompts";
+var BUILT_IN_TEMPLATES = [
+  {
+    name: "decision",
+    description: "Document an architectural or technical decision",
+    type: "decision",
+    fields: [
+      { name: "what", prompt: "What did you decide?", required: true },
+      { name: "why", prompt: "Why this choice?", required: true },
+      { name: "alternatives", prompt: "What alternatives were considered? (optional)", required: false }
+    ],
+    format: (v) => {
+      let result = `${v.what}. Rationale: ${v.why}`;
+      if (v.alternatives) result += `. Alternatives considered: ${v.alternatives}`;
+      return result;
+    }
+  },
+  {
+    name: "error-fix",
+    description: "Document a bug and its solution",
+    type: "fact",
+    fields: [
+      { name: "error", prompt: "What was the error/bug?", required: true },
+      { name: "cause", prompt: "What caused it?", required: true },
+      { name: "solution", prompt: "How did you fix it?", required: true }
+    ],
+    format: (v) => `Bug: ${v.error}. Cause: ${v.cause}. Fix: ${v.solution}`
+  },
+  {
+    name: "api-endpoint",
+    description: "Document an API endpoint",
+    type: "fact",
+    fields: [
+      { name: "method", prompt: "HTTP method (GET, POST, etc.)?", required: true },
+      { name: "path", prompt: "Endpoint path?", required: true },
+      { name: "description", prompt: "What does it do?", required: true },
+      { name: "notes", prompt: "Any important notes? (optional)", required: false }
+    ],
+    format: (v) => {
+      let result = `${v.method.toUpperCase()} ${v.path} - ${v.description}`;
+      if (v.notes) result += `. Note: ${v.notes}`;
+      return result;
+    }
+  },
+  {
+    name: "dependency",
+    description: "Document why a dependency was added",
+    type: "decision",
+    fields: [
+      { name: "name", prompt: "Package/library name?", required: true },
+      { name: "purpose", prompt: "Why do we use it?", required: true },
+      { name: "version", prompt: "Version constraint? (optional)", required: false }
+    ],
+    format: (v) => {
+      let result = `Using ${v.name} for ${v.purpose}`;
+      if (v.version) result += ` (${v.version})`;
+      return result;
+    }
+  },
+  {
+    name: "pattern",
+    description: "Document a code pattern or convention",
+    type: "rule",
+    fields: [
+      { name: "name", prompt: "Pattern name?", required: true },
+      { name: "when", prompt: "When to use it?", required: true },
+      { name: "example", prompt: "Brief example? (optional)", required: false }
+    ],
+    format: (v) => {
+      let result = `${v.name}: ${v.when}`;
+      if (v.example) result += `. Example: ${v.example}`;
+      return result;
+    }
+  },
+  {
+    name: "gotcha",
+    description: "Document a non-obvious issue or gotcha",
+    type: "fact",
+    fields: [
+      { name: "issue", prompt: "What's the gotcha?", required: true },
+      { name: "context", prompt: "When does it happen?", required: true },
+      { name: "workaround", prompt: "How to avoid/handle it?", required: false }
+    ],
+    format: (v) => {
+      let result = `Gotcha: ${v.issue} (${v.context})`;
+      if (v.workaround) result += `. Workaround: ${v.workaround}`;
+      return result;
+    }
+  }
+];
+function getTemplate(name) {
+  return BUILT_IN_TEMPLATES.find((t) => t.name === name);
+}
+function listTemplates() {
+  return BUILT_IN_TEMPLATES;
+}
+async function fillTemplate(template) {
+  const values = {};
+  for (const field of template.fields) {
+    const value = await input({
+      message: field.prompt,
+      validate: (v) => {
+        if (field.required && !v.trim()) return "This field is required";
+        return true;
+      }
+    });
+    if (value.trim()) {
+      values[field.name] = value.trim();
+    }
+  }
+  return template.format(values);
+}
+
+// src/commands/add.ts
 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) => {
+var addCommand = new Command2("add").description("Add a new memory").argument("[content]", "Memory content (optional if using --template)").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").option("--template <name>", "Use a template (run 'memories template list' to see options)").action(async (contentArg, opts) => {
   try {
+    let content = contentArg;
+    let typeFromTemplate;
+    if (opts.template) {
+      const template = getTemplate(opts.template);
+      if (!template) {
+        error(`Template "${opts.template}" not found`);
+        dim("Run 'memories template list' to see available templates");
+        process.exit(1);
+      }
+      console.log("");
+      info(`Using template: ${template.name}`);
+      dim(template.description);
+      console.log("");
+      content = await fillTemplate(template);
+      typeFromTemplate = template.type;
+    }
+    if (!content) {
+      error("Content is required. Provide content or use --template");
+      process.exit(1);
+    }
     const auth = await readAuth();
     if (auth) {
       try {
@@ -638,7 +364,7 @@ var addCommand = new Command2("add").description("Add a new memory").argument("<
       }
     }
     const tags = opts.tags?.split(",").map((t) => t.trim());
-    let type = "note";
+    let type = typeFromTemplate ?? "note";
     if (opts.rule) type = "rule";
     else if (opts.decision) type = "decision";
     else if (opts.fact) type = "fact";
@@ -876,13 +602,14 @@ var TYPE_ICONS2 = {
   note: "\u{1F4DD}"
 };
 var VALID_TYPES3 = ["rule", "decision", "fact", "note"];
-function formatMemory2(m) {
+function formatMemory2(m, score) {
   const icon = TYPE_ICONS2[m.type] || "\u{1F4DD}";
   const scope = m.scope === "global" ? chalk6.dim("G") : chalk6.dim("P");
   const tags = m.tags ? chalk6.dim(` [${m.tags}]`) : "";
-  return `${icon} ${scope} ${chalk6.dim(m.id)}  ${m.content}${tags}`;
+  const scoreStr = score !== void 0 ? chalk6.cyan(` (${Math.round(score * 100)}%)`) : "";
+  return `${icon} ${scope} ${chalk6.dim(m.id)}  ${m.content}${tags}${scoreStr}`;
 }
-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) => {
+var searchCommand = new Command5("search").description("Search memories using full-text or semantic search").argument("<query>", "Search query").option("-l, --limit <n>", "Max results", "20").option("--type <type>", "Filter by type: rule, decision, fact, note").option("-g, --global", "Search only global memories").option("--project-only", "Search only project memories (exclude global)").option("-s, --semantic", "Use semantic (AI) search instead of keyword search").option("--json", "Output as JSON").action(async (query, opts) => {
   try {
     let types;
     if (opts.type) {
@@ -905,6 +632,42 @@ var searchCommand = new Command5("search").description("Search memories using fu
         return;
       }
     }
+    if (opts.semantic) {
+      try {
+        const { semanticSearch, isModelAvailable } = await import("./embeddings-GH4HB6X7.js");
+        if (!await isModelAvailable()) {
+          console.log(chalk6.yellow("\u26A0") + " Loading embedding model for first time (this may take a moment)...");
+        }
+        const results = await semanticSearch(query, {
+          limit: parseInt(opts.limit, 10),
+          projectId
+        });
+        if (opts.json) {
+          console.log(JSON.stringify(results, null, 2));
+          return;
+        }
+        if (results.length === 0) {
+          console.log(chalk6.dim(`No semantically similar memories found for "${query}"`));
+          console.log(chalk6.dim("Try running 'memories embed' to generate embeddings for existing memories."));
+          return;
+        }
+        console.log(chalk6.bold(`Semantic results for "${query}":`));
+        console.log("");
+        for (const r of results) {
+          const { getMemoryById: getMemoryById2 } = await import("./memory-57CD5DYG.js");
+          const m = await getMemoryById2(r.id);
+          if (m) {
+            console.log(formatMemory2(m, r.score));
+          }
+        }
+        console.log(chalk6.dim(`
+${results.length} results (semantic search)`));
+        return;
+      } catch (error2) {
+        console.error(chalk6.red("\u2717") + " Semantic search failed:", error2 instanceof Error ? error2.message : "Unknown error");
+        console.log(chalk6.dim("Falling back to keyword search..."));
+      }
+    }
     const memories = await searchMemories(query, {
       limit: parseInt(opts.limit, 10),
       types,
@@ -1117,7 +880,7 @@ var forgetCommand = new Command7("forget").description("Soft-delete memories by
 // src/commands/export.ts
 import { Command as Command8 } from "commander";
 import chalk9 from "chalk";
-import { writeFile as writeFile3 } from "fs/promises";
+import { writeFile as writeFile2 } 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();
@@ -1164,7 +927,7 @@ var exportCommand = new Command8("export").description("Export memories to JSON
       output = JSON.stringify(exportData, null, 2);
     }
     if (opts.output) {
-      await writeFile3(opts.output, output, "utf-8");
+      await writeFile2(opts.output, output, "utf-8");
       console.log(chalk9.green("\u2713") + ` Exported ${memories.length} memories to ${chalk9.dim(opts.output)}`);
     } else {
       console.log(output);
@@ -1178,10 +941,10 @@ var exportCommand = new Command8("export").description("Export memories to JSON
 // src/commands/import.ts
 import { Command as Command9 } from "commander";
 import chalk10 from "chalk";
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } 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 readFile3(file, "utf-8");
+    const content = await readFile2(file, "utf-8");
     let format = opts.format;
     if (!format) {
       if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -1262,17 +1025,17 @@ ${validMemories.length} memories would be imported`));
 import { Command as Command10 } from "commander";
 
 // src/lib/config.ts
-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 { 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 { parse, stringify } from "yaml";
 var AGENTS_DIR = ".agents";
 var CONFIG_FILE = "config.yaml";
 async function initConfig(dir) {
-  const agentsDir = join3(dir, AGENTS_DIR);
-  await mkdir3(agentsDir, { recursive: true });
-  const configPath = join3(agentsDir, CONFIG_FILE);
-  if (!existsSync3(configPath)) {
+  const agentsDir = join2(dir, AGENTS_DIR);
+  await mkdir2(agentsDir, { recursive: true });
+  const configPath = join2(agentsDir, CONFIG_FILE);
+  if (!existsSync2(configPath)) {
     const defaultConfig = {
       name: "my-project",
       description: "Agent memory configuration",
@@ -1282,14 +1045,14 @@ async function initConfig(dir) {
         store: "~/.config/memories/local.db"
       }
     };
-    await writeFile4(configPath, stringify(defaultConfig), "utf-8");
+    await writeFile3(configPath, stringify(defaultConfig), "utf-8");
   }
   return configPath;
 }
 async function readConfig(dir) {
-  const configPath = join3(dir, AGENTS_DIR, CONFIG_FILE);
-  if (!existsSync3(configPath)) return null;
-  const raw = await readFile4(configPath, "utf-8");
+  const configPath = join2(dir, AGENTS_DIR, CONFIG_FILE);
+  if (!existsSync2(configPath)) return null;
+  const raw = await readFile3(configPath, "utf-8");
   return parse(raw);
 }
 
@@ -1715,7 +1478,7 @@ import { Command as Command12 } from "commander";
 import ora from "ora";
 
 // src/lib/turso.ts
-import { nanoid as nanoid2 } from "nanoid";
+import { nanoid } from "nanoid";
 var API_BASE = "https://api.turso.tech/v1";
 function getApiToken() {
   const token = process.env.TURSO_PLATFORM_API_TOKEN;
@@ -1742,7 +1505,7 @@ async function api(path, opts) {
   return res.json();
 }
 async function createDatabase(org) {
-  const name = `memories-${nanoid2(8).toLowerCase()}`;
+  const name = `memories-${nanoid(8).toLowerCase()}`;
   const { database } = await api(
     `/organizations/${org}/databases`,
     {
@@ -1765,10 +1528,10 @@ async function createDatabaseToken(org, dbName) {
 }
 
 // src/commands/sync.ts
-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");
+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");
 var syncCommand = new Command12("sync").description(
   "Manage remote sync"
 );
@@ -1791,7 +1554,7 @@ syncCommand.command("enable").description("Provision a cloud database and enable
         const profileRes = await apiFetch("/api/db/credentials");
         if (profileRes.ok) {
           const creds = await profileRes.json();
-          if (existsSync4(DB_PATH)) {
+          if (existsSync3(DB_PATH)) {
             resetDb();
             unlinkSync(DB_PATH);
           }
@@ -1827,7 +1590,7 @@ syncCommand.command("enable").description("Provision a cloud database and enable
   spinner.text = "Generating auth token...";
   const token = await createDatabaseToken(opts.org, db.name);
   const syncUrl = `libsql://${db.hostname}`;
-  if (existsSync4(DB_PATH)) {
+  if (existsSync3(DB_PATH)) {
     resetDb();
     unlinkSync(DB_PATH);
   }
@@ -1875,10 +1638,10 @@ syncCommand.command("status").description("Show sync configuration").action(asyn
 // src/commands/generate.ts
 import { Command as Command13 } from "commander";
 import chalk11 from "chalk";
-import { writeFile as 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 { writeFile as writeFile4, readFile as readFile4, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync4, watch as fsWatch } from "fs";
+import { dirname, resolve, join as join4 } from "path";
+import { homedir as homedir3 } from "os";
 import { checkbox } from "@inquirer/prompts";
 var MARKER = "Generated by memories.sh";
 var VALID_TYPES6 = ["rule", "decision", "fact", "note"];
@@ -2015,7 +1778,7 @@ function makeFooter() {
 }
 async function hasOurMarker(filePath) {
   try {
-    const content = await readFile5(filePath, "utf-8");
+    const content = await readFile4(filePath, "utf-8");
     return content.includes(MARKER);
   } catch {
     return false;
@@ -2026,7 +1789,7 @@ async function checkGitignore(filePath) {
   if (TRACK_BY_DEFAULT.has(filePath)) return;
   const gitignorePath = resolve(".gitignore");
   try {
-    const content = existsSync5(gitignorePath) ? await readFile5(gitignorePath, "utf-8") : "";
+    const content = existsSync4(gitignorePath) ? await readFile4(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}/`)) {
@@ -2045,7 +1808,7 @@ async function writeTarget(target, memories, opts) {
     console.log();
     return;
   }
-  if (existsSync5(outPath)) {
+  if (existsSync4(outPath)) {
     const ours = await hasOurMarker(outPath);
     if (!ours && !opts.force) {
       console.error(
@@ -2054,8 +1817,8 @@ async function writeTarget(target, memories, opts) {
       return;
     }
   }
-  await mkdir4(dirname(outPath), { recursive: true });
-  await writeFile5(outPath, content, "utf-8");
+  await mkdir3(dirname(outPath), { recursive: true });
+  await writeFile4(outPath, content, "utf-8");
   console.log(chalk11.green("\u2713") + ` Wrote ${target.name} \u2192 ${chalk11.dim(outPath)}`);
   await checkGitignore(opts.output ?? target.defaultPath);
 }
@@ -2078,13 +1841,13 @@ function parseTypes(raw) {
   }
   return types;
 }
-function getDbPath2() {
-  const dataDir = process.env.MEMORIES_DATA_DIR ?? join5(homedir4(), ".config", "memories");
-  return join5(dataDir, "local.db");
+function getDbPath() {
+  const dataDir = process.env.MEMORIES_DATA_DIR ?? join4(homedir3(), ".config", "memories");
+  return join4(dataDir, "local.db");
 }
 async function runWatch(targets, memories, opts) {
-  const dbPath = getDbPath2();
-  if (!existsSync5(dbPath)) {
+  const dbPath = getDbPath();
+  if (!existsSync4(dbPath)) {
     console.error(chalk11.red("\u2717") + " Database not found. Run: memories init");
     process.exit(1);
   }
@@ -2199,8 +1962,8 @@ 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 join6 } from "path";
-import { nanoid as nanoid3 } from "nanoid";
+import { join as join5 } from "path";
+import { nanoid as nanoid2 } from "nanoid";
 import { select } from "@inquirer/prompts";
 var VALID_TYPES7 = ["rule", "decision", "fact", "note"];
 function truncate2(str, max) {
@@ -2249,7 +2012,7 @@ var editCommand = new Command14("edit").description("Edit an existing memory").a
     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 = join6(tmpdir(), `memories-edit-${nanoid3(6)}.md`);
+      const tmpFile = join5(tmpdir(), `memories-edit-${nanoid2(6)}.md`);
       writeFileSync(tmpFile, memory.content, "utf-8");
       try {
         execFileSync2(editor, [tmpFile], { stdio: "inherit" });
@@ -2354,8 +2117,8 @@ var statsCommand = new Command15("stats").description("Show memory statistics").
 // src/commands/doctor.ts
 import { Command as Command16 } from "commander";
 import chalk14 from "chalk";
-import { existsSync as existsSync6 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
 var doctorCommand = new Command16("doctor").description("Check memories health and diagnose issues").option("--fix", "Attempt to fix issues found").action(async (opts) => {
   try {
     console.log(chalk14.bold("memories doctor\n"));
@@ -2363,8 +2126,8 @@ var doctorCommand = new Command16("doctor").description("Check memories health a
       {
         name: "Database file",
         run: async () => {
-          const dbPath = join7(getConfigDir(), "local.db");
-          if (existsSync6(dbPath)) {
+          const dbPath = join6(getConfigDir(), "local.db");
+          if (existsSync5(dbPath)) {
             return { ok: true, message: `Found at ${dbPath}` };
           }
           return { ok: false, message: `Not found at ${dbPath}. Run: memories init` };
@@ -2495,10 +2258,10 @@ var doctorCommand = new Command16("doctor").description("Check memories health a
 // src/commands/hook.ts
 import { Command as Command17 } from "commander";
 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 { readFile as readFile5, writeFile as writeFile5, chmod } from "fs/promises";
+import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
 import { execFileSync as execFileSync3 } from "child_process";
-import { join as join8 } from "path";
+import { join as join7 } from "path";
 var HOOK_MARKER_START = "# >>> memories.sh hook >>>";
 var HOOK_MARKER_END = "# <<< memories.sh hook <<<";
 var HOOK_SNIPPET = `
@@ -2519,22 +2282,22 @@ function getGitDir() {
 function getHookLocation(hookName) {
   const gitDir = getGitDir();
   if (!gitDir) return null;
-  const huskyPath = join8(".husky", hookName);
-  if (existsSync7(".husky") && !existsSync7(join8(".husky", "_"))) {
+  const huskyPath = join7(".husky", hookName);
+  if (existsSync6(".husky") && !existsSync6(join7(".husky", "_"))) {
     return { path: huskyPath, type: "husky" };
   }
-  const huskyLegacyPath = join8(".husky", "_", hookName);
-  if (existsSync7(join8(".husky", "_"))) {
+  const huskyLegacyPath = join7(".husky", "_", hookName);
+  if (existsSync6(join7(".husky", "_"))) {
     return { path: huskyLegacyPath, type: "husky" };
   }
-  if (existsSync7(huskyPath)) {
+  if (existsSync6(huskyPath)) {
     return { path: huskyPath, type: "husky" };
   }
-  return { path: join8(gitDir, "hooks", hookName), type: "git" };
+  return { path: join7(gitDir, "hooks", hookName), type: "git" };
 }
 function detectLintStaged() {
   try {
-    if (!existsSync7("package.json")) return false;
+    if (!existsSync6("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 {
@@ -2551,15 +2314,15 @@ hookCommand.addCommand(
         process.exit(1);
       }
       const hookPath = location.path;
-      if (existsSync7(hookPath)) {
-        const content = await readFile6(hookPath, "utf-8");
+      if (existsSync6(hookPath)) {
+        const content = await readFile5(hookPath, "utf-8");
         if (content.includes(HOOK_MARKER_START)) {
           console.log(chalk15.dim("Hook already installed. Use 'memories hook uninstall' first to reinstall."));
           return;
         }
-        await writeFile6(hookPath, content.trimEnd() + "\n" + HOOK_SNIPPET + "\n", "utf-8");
+        await writeFile5(hookPath, content.trimEnd() + "\n" + HOOK_SNIPPET + "\n", "utf-8");
       } else {
-        await writeFile6(hookPath, "#!/bin/sh\n" + HOOK_SNIPPET + "\n", "utf-8");
+        await writeFile5(hookPath, "#!/bin/sh\n" + HOOK_SNIPPET + "\n", "utf-8");
       }
       await chmod(hookPath, 493);
       const locationLabel = location.type === "husky" ? "Husky" : ".git/hooks";
@@ -2585,11 +2348,11 @@ hookCommand.addCommand(
         process.exit(1);
       }
       const hookPath = location.path;
-      if (!existsSync7(hookPath)) {
+      if (!existsSync6(hookPath)) {
         console.log(chalk15.dim("No hook file found."));
         return;
       }
-      const content = await readFile6(hookPath, "utf-8");
+      const content = await readFile5(hookPath, "utf-8");
       if (!content.includes(HOOK_MARKER_START)) {
         console.log(chalk15.dim("No memories hook found in " + opts.hook));
         return;
@@ -2603,7 +2366,7 @@ hookCommand.addCommand(
         await unlink2(hookPath);
         console.log(chalk15.green("\u2713") + ` Removed ${chalk15.dim(opts.hook)} hook (was memories-only)`);
       } else {
-        await writeFile6(hookPath, cleaned, "utf-8");
+        await writeFile5(hookPath, cleaned, "utf-8");
         console.log(chalk15.green("\u2713") + ` Removed memories section from ${chalk15.dim(opts.hook)}`);
       }
     } catch (error2) {
@@ -2620,11 +2383,11 @@ hookCommand.addCommand(
         console.error(chalk15.red("\u2717") + " Not in a git repository");
         process.exit(1);
       }
-      if (!existsSync7(hookPath)) {
+      if (!existsSync6(hookPath)) {
         console.log(chalk15.dim("Not installed") + ` \u2014 no ${opts.hook} hook found`);
         return;
       }
-      const content = await readFile6(hookPath, "utf-8");
+      const content = await readFile5(hookPath, "utf-8");
       if (content.includes(HOOK_MARKER_START)) {
         console.log(chalk15.green("\u2713") + ` Installed in ${chalk15.dim(hookPath)}`);
       } else {
@@ -2643,8 +2406,8 @@ function escapeRegex(str) {
 // src/commands/ingest.ts
 import { Command as Command18 } from "commander";
 import chalk16 from "chalk";
-import { readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
 var SOURCES = [
   { name: "cursor", paths: [".cursor/rules/memories.mdc", ".cursorrules"], description: "Cursor rules" },
   { name: "claude", paths: ["CLAUDE.md"], description: "Claude Code instructions" },
@@ -2711,7 +2474,7 @@ var ingestCommand = new Command18("ingest").description("Import memories from ex
     if (opts.all) {
       for (const src of SOURCES) {
         for (const p of src.paths) {
-          if (existsSync8(p)) {
+          if (existsSync7(p)) {
             filesToProcess.push({ name: src.name, path: p });
           }
         }
@@ -2720,7 +2483,7 @@ 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 (existsSync8(p)) {
+          if (existsSync7(p)) {
             filesToProcess.push({ name: known.name, path: p });
             break;
           }
@@ -2729,7 +2492,7 @@ var ingestCommand = new Command18("ingest").description("Import memories from ex
           console.error(chalk16.red("\u2717") + ` No ${known.description} file found at: ${known.paths.join(", ")}`);
           process.exit(1);
         }
-      } else if (existsSync8(source)) {
+      } else if (existsSync7(source)) {
         filesToProcess.push({ name: "file", path: source });
       } else {
         console.error(chalk16.red("\u2717") + ` Unknown source "${source}". Valid: ${SOURCES.map((s) => s.name).join(", ")}, or a file path`);
@@ -2754,7 +2517,7 @@ var ingestCommand = new Command18("ingest").description("Import memories from ex
     let totalImported = 0;
     let totalSkipped = 0;
     for (const file of filesToProcess) {
-      const content = await readFile7(file.path, "utf-8");
+      const content = await readFile6(file.path, "utf-8");
       if (content.includes(MARKER2)) {
         console.log(chalk16.dim(`  Skipping ${file.path} (generated by memories.sh)`));
         continue;
@@ -2802,8 +2565,8 @@ var ingestCommand = new Command18("ingest").description("Import memories from ex
 // src/commands/diff.ts
 import { Command as Command19 } from "commander";
 import chalk17 from "chalk";
-import { readFile as readFile8 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
 import { resolve as resolve2 } from "path";
 var MARKER3 = "Generated by memories.sh";
 var VALID_TYPES9 = ["rule", "decision", "fact", "note"];
@@ -2848,7 +2611,7 @@ async function fetchMemories2(types) {
 }
 async function diffTarget(target, currentMemories, outputPath) {
   const filePath = resolve2(outputPath ?? target.defaultPath);
-  if (!existsSync9(filePath)) {
+  if (!existsSync8(filePath)) {
     return {
       added: currentMemories.map((m) => m.content),
       removed: [],
@@ -2859,7 +2622,7 @@ async function diffTarget(target, currentMemories, outputPath) {
       generatedAt: null
     };
   }
-  const content = await readFile8(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   const isOurs = content.includes(MARKER3);
   const generatedAt = extractTimestamp(content);
   const fileMemories = extractFileMemories(content);
@@ -3078,10 +2841,680 @@ tagCommand.addCommand(
   })
 );
 
-// src/commands/login.ts
+// src/commands/validate.ts
 import { Command as Command21 } from "commander";
 import chalk19 from "chalk";
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+function similarity(a, b) {
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  return 1 - levenshtein(a.toLowerCase(), b.toLowerCase()) / maxLen;
+}
+var CONFLICT_PAIRS = [
+  ["always", "never"],
+  ["use", "avoid"],
+  ["prefer", "avoid"],
+  ["enable", "disable"],
+  ["tabs", "spaces"],
+  ["single", "double"],
+  ["require", "forbid"],
+  ["must", "must not"],
+  ["should", "should not"]
+];
+function extractKeywords(text) {
+  return text.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+}
+function findTopicOverlap(a, b) {
+  const wordsA = new Set(extractKeywords(a));
+  const wordsB = new Set(extractKeywords(b));
+  const overlap = [];
+  for (const w of wordsA) {
+    if (wordsB.has(w) && w.length > 3) overlap.push(w);
+  }
+  return overlap;
+}
+function checkForConflict(a, b) {
+  const lowerA = a.toLowerCase();
+  const lowerB = b.toLowerCase();
+  for (const [pos, neg] of CONFLICT_PAIRS) {
+    const aHasPos = lowerA.includes(pos);
+    const aHasNeg = lowerA.includes(neg);
+    const bHasPos = lowerB.includes(pos);
+    const bHasNeg = lowerB.includes(neg);
+    if (aHasPos && bHasNeg || aHasNeg && bHasPos) {
+      const overlap = findTopicOverlap(a, b);
+      if (overlap.length > 0) return true;
+    }
+  }
+  return false;
+}
+var validateCommand = new Command21("validate").description("Check for conflicting or duplicate rules").option("--fix", "Interactive mode to resolve issues").action(async (opts) => {
+  try {
+    const projectId = getProjectId() ?? void 0;
+    const rules = await getRules({ projectId });
+    if (rules.length === 0) {
+      console.log(chalk19.dim("No rules to validate."));
+      return;
+    }
+    console.log(chalk19.bold("\u{1F50D} Validating rules...\n"));
+    const issues = [];
+    for (let i = 0; i < rules.length; i++) {
+      for (let j = i + 1; j < rules.length; j++) {
+        const a = rules[i];
+        const b = rules[j];
+        if (a.content.toLowerCase() === b.content.toLowerCase()) {
+          issues.push({ type: "duplicate", memory1: a, memory2: b });
+          continue;
+        }
+        const sim = similarity(a.content, b.content);
+        if (sim > 0.85) {
+          issues.push({
+            type: "near-duplicate",
+            memory1: a,
+            memory2: b,
+            detail: `${Math.round(sim * 100)}% similar`
+          });
+          continue;
+        }
+        if (checkForConflict(a.content, b.content)) {
+          const overlap = findTopicOverlap(a.content, b.content);
+          issues.push({
+            type: "conflict",
+            memory1: a,
+            memory2: b,
+            detail: `Topic: ${overlap.join(", ")}`
+          });
+        }
+      }
+    }
+    if (issues.length === 0) {
+      console.log(chalk19.green("\u2713") + ` ${rules.length} rules validated, no issues found.`);
+      return;
+    }
+    console.log(chalk19.yellow("\u26A0\uFE0F  Potential Issues Found:\n"));
+    let num = 1;
+    for (const issue of issues) {
+      const typeLabel = issue.type === "duplicate" ? "Exact duplicate" : issue.type === "near-duplicate" ? "Near duplicate" : "Potential conflict";
+      const color = issue.type === "conflict" ? chalk19.red : chalk19.yellow;
+      console.log(color(`${num}. ${typeLabel}${issue.detail ? ` (${issue.detail})` : ""}:`));
+      console.log(`   \u{1F4CC} "${issue.memory1.content}"`);
+      console.log(`   \u{1F4CC} "${issue.memory2.content}"`);
+      if (issue.type === "duplicate" || issue.type === "near-duplicate") {
+        console.log(chalk19.dim("   \u2192 Consider merging these rules\n"));
+      } else {
+        console.log(chalk19.dim("   \u2192 These rules may contradict each other\n"));
+      }
+      num++;
+    }
+    const duplicates = issues.filter((i) => i.type === "duplicate" || i.type === "near-duplicate").length;
+    const conflicts = issues.filter((i) => i.type === "conflict").length;
+    console.log(chalk19.bold(`${rules.length} rules validated, ${issues.length} issues found`));
+    if (duplicates > 0) console.log(chalk19.dim(`  ${duplicates} duplicate(s)`));
+    if (conflicts > 0) console.log(chalk19.dim(`  ${conflicts} conflict(s)`));
+    if (opts.fix) {
+      console.log(chalk19.dim("\n--fix mode not yet implemented. Review issues above manually."));
+    }
+  } catch (error2) {
+    console.error(chalk19.red("\u2717") + " Validation failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/stale.ts
+import { Command as Command22 } from "commander";
+import chalk20 from "chalk";
+import { createInterface as createInterface2 } from "readline";
+var TYPE_ICONS4 = {
+  rule: "\u{1F4CC}",
+  decision: "\u{1F4A1}",
+  fact: "\u{1F4CB}",
+  note: "\u{1F4DD}"
+};
+async function prompt(message) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve3) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve3(answer.toLowerCase().trim());
+    });
+  });
+}
+var staleCommand = new Command22("stale").description("Find memories that haven't been updated in a while").option("--days <n>", "Staleness threshold in days (default: 90)", "90").option("--type <type>", "Filter by memory type: rule, decision, fact, note").option("--json", "Output as JSON").action(async (opts) => {
+  try {
+    const db = await getDb();
+    const days = parseInt(opts.days, 10);
+    const projectId = getProjectId() ?? void 0;
+    if (isNaN(days) || days <= 0) {
+      console.error(chalk20.red("\u2717") + " --days must be a positive number");
+      process.exit(1);
+    }
+    let sql = `
+        SELECT id, content, type, scope, created_at, updated_at,
+               CAST((julianday('now') - julianday(COALESCE(updated_at, created_at))) AS INTEGER) as days_old
+        FROM memories 
+        WHERE deleted_at IS NULL 
+          AND (julianday('now') - julianday(COALESCE(updated_at, created_at))) > ?
+      `;
+    const args = [days];
+    if (opts.type) {
+      sql += " AND type = ?";
+      args.push(opts.type);
+    }
+    sql += " ORDER BY days_old DESC";
+    const result = await db.execute({ sql, args });
+    const stale = result.rows;
+    if (opts.json) {
+      console.log(JSON.stringify(stale, null, 2));
+      return;
+    }
+    if (stale.length === 0) {
+      console.log(chalk20.green("\u2713") + ` No memories older than ${days} days.`);
+      return;
+    }
+    console.log(chalk20.bold(`\u23F0 Stale Memories (not updated in ${days}+ days)
+`));
+    for (const m of stale.slice(0, 30)) {
+      const icon = TYPE_ICONS4[m.type] || "\u{1F4DD}";
+      const scope = m.scope === "global" ? chalk20.dim("G") : chalk20.dim("P");
+      const preview = m.content.length > 50 ? m.content.slice(0, 47) + "..." : m.content;
+      console.log(`  ${icon} ${scope} ${chalk20.dim(m.id)}  ${preview}  ${chalk20.yellow(`${m.days_old}d`)}`);
+    }
+    if (stale.length > 30) {
+      console.log(chalk20.dim(`  ... and ${stale.length - 30} more`));
+    }
+    console.log("");
+    console.log(`${stale.length} stale ${stale.length === 1 ? "memory" : "memories"} found`);
+    console.log(chalk20.dim("Run 'memories review' to clean up interactively"));
+  } catch (error2) {
+    console.error(chalk20.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+var reviewCommand = new Command22("review").description("Interactively review and clean up stale memories").option("--days <n>", "Staleness threshold in days (default: 90)", "90").action(async (opts) => {
+  try {
+    const db = await getDb();
+    const days = parseInt(opts.days, 10);
+    const result = await db.execute({
+      sql: `
+          SELECT id, content, type, scope, created_at, updated_at,
+                 CAST((julianday('now') - julianday(COALESCE(updated_at, created_at))) AS INTEGER) as days_old
+          FROM memories 
+          WHERE deleted_at IS NULL 
+            AND (julianday('now') - julianday(COALESCE(updated_at, created_at))) > ?
+          ORDER BY days_old DESC
+        `,
+      args: [days]
+    });
+    const stale = result.rows;
+    if (stale.length === 0) {
+      console.log(chalk20.green("\u2713") + ` No stale memories to review.`);
+      return;
+    }
+    console.log(chalk20.bold(`
+Reviewing ${stale.length} stale memories...
+`));
+    let kept = 0, deleted = 0, skipped = 0;
+    for (const m of stale) {
+      const icon = TYPE_ICONS4[m.type] || "\u{1F4DD}";
+      console.log(`${icon} ${chalk20.bold(m.type.toUpperCase())} (${m.scope})`);
+      console.log(`   "${m.content}"`);
+      console.log(chalk20.dim(`   Last updated: ${m.days_old} days ago`));
+      console.log("");
+      const answer = await prompt("   [k]eep  [d]elete  [s]kip  [q]uit > ");
+      if (answer === "q") {
+        console.log("\nExiting review.");
+        break;
+      } else if (answer === "d") {
+        await forgetMemory(m.id);
+        console.log(chalk20.green("   \u2713 Deleted\n"));
+        deleted++;
+      } else if (answer === "k") {
+        await db.execute({
+          sql: "UPDATE memories SET updated_at = datetime('now') WHERE id = ?",
+          args: [m.id]
+        });
+        console.log(chalk20.green("   \u2713 Kept (marked as reviewed)\n"));
+        kept++;
+      } else {
+        console.log(chalk20.dim("   Skipped\n"));
+        skipped++;
+      }
+    }
+    console.log(chalk20.bold("\nReview Summary:"));
+    console.log(`  Kept: ${kept}, Deleted: ${deleted}, Skipped: ${skipped}`);
+  } catch (error2) {
+    console.error(chalk20.red("\u2717") + " Review failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/link.ts
+import { Command as Command23 } from "commander";
+import chalk21 from "chalk";
+import { nanoid as nanoid3 } from "nanoid";
+var LINK_TYPES = ["related", "supports", "supersedes", "contradicts"];
+var TYPE_ICONS5 = {
+  rule: "\u{1F4CC}",
+  decision: "\u{1F4A1}",
+  fact: "\u{1F4CB}",
+  note: "\u{1F4DD}"
+};
+async function ensureLinksTable() {
+  const db = await getDb();
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS memory_links (
+      id TEXT PRIMARY KEY,
+      source_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      link_type TEXT NOT NULL DEFAULT 'related',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS idx_links_source ON memory_links(source_id)`);
+  await db.execute(`CREATE INDEX IF NOT EXISTS idx_links_target ON memory_links(target_id)`);
+}
+async function getLinkedMemories(memoryId) {
+  const db = await getDb();
+  await ensureLinksTable();
+  const outgoing = await db.execute({
+    sql: `
+      SELECT m.*, ml.link_type 
+      FROM memory_links ml 
+      JOIN memories m ON ml.target_id = m.id 
+      WHERE ml.source_id = ? AND m.deleted_at IS NULL
+    `,
+    args: [memoryId]
+  });
+  const incoming = await db.execute({
+    sql: `
+      SELECT m.*, ml.link_type 
+      FROM memory_links ml 
+      JOIN memories m ON ml.source_id = m.id 
+      WHERE ml.target_id = ? AND m.deleted_at IS NULL
+    `,
+    args: [memoryId]
+  });
+  const results = [];
+  for (const row of outgoing.rows) {
+    results.push({
+      memory: row,
+      linkType: row.link_type,
+      direction: "to"
+    });
+  }
+  for (const row of incoming.rows) {
+    results.push({
+      memory: row,
+      linkType: row.link_type,
+      direction: "from"
+    });
+  }
+  return results;
+}
+var linkCommand = new Command23("link").description("Link two related memories together").argument("<id1>", "First memory ID").argument("<id2>", "Second memory ID").option("-t, --type <type>", "Link type: related, supports, supersedes, contradicts", "related").action(async (id1, id2, opts) => {
+  try {
+    await ensureLinksTable();
+    const db = await getDb();
+    if (!LINK_TYPES.includes(opts.type)) {
+      console.error(chalk21.red("\u2717") + ` Invalid link type. Valid: ${LINK_TYPES.join(", ")}`);
+      process.exit(1);
+    }
+    const m1 = await getMemoryById(id1);
+    const m2 = await getMemoryById(id2);
+    if (!m1) {
+      console.error(chalk21.red("\u2717") + ` Memory ${id1} not found`);
+      process.exit(1);
+    }
+    if (!m2) {
+      console.error(chalk21.red("\u2717") + ` Memory ${id2} not found`);
+      process.exit(1);
+    }
+    const existing = await db.execute({
+      sql: `SELECT id FROM memory_links WHERE 
+              (source_id = ? AND target_id = ?) OR (source_id = ? AND target_id = ?)`,
+      args: [id1, id2, id2, id1]
+    });
+    if (existing.rows.length > 0) {
+      console.log(chalk21.yellow("!") + " These memories are already linked");
+      return;
+    }
+    const linkId = nanoid3(12);
+    await db.execute({
+      sql: `INSERT INTO memory_links (id, source_id, target_id, link_type) VALUES (?, ?, ?, ?)`,
+      args: [linkId, id1, id2, opts.type]
+    });
+    const icon1 = TYPE_ICONS5[m1.type] || "\u{1F4DD}";
+    const icon2 = TYPE_ICONS5[m2.type] || "\u{1F4DD}";
+    console.log(chalk21.green("\u2713") + " Linked memories:");
+    console.log(`  ${icon1} ${chalk21.dim(id1)} "${m1.content.slice(0, 40)}..."`);
+    console.log(`    \u2193 ${chalk21.cyan(opts.type)}`);
+    console.log(`  ${icon2} ${chalk21.dim(id2)} "${m2.content.slice(0, 40)}..."`);
+  } catch (error2) {
+    console.error(chalk21.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+var unlinkCommand = new Command23("unlink").description("Remove link between two memories").argument("<id1>", "First memory ID").argument("<id2>", "Second memory ID").action(async (id1, id2) => {
+  try {
+    await ensureLinksTable();
+    const db = await getDb();
+    const result = await db.execute({
+      sql: `DELETE FROM memory_links WHERE 
+              (source_id = ? AND target_id = ?) OR (source_id = ? AND target_id = ?)`,
+      args: [id1, id2, id2, id1]
+    });
+    if (result.rowsAffected === 0) {
+      console.log(chalk21.yellow("!") + " No link found between these memories");
+    } else {
+      console.log(chalk21.green("\u2713") + ` Unlinked ${id1} and ${id2}`);
+    }
+  } catch (error2) {
+    console.error(chalk21.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+var showCommand = new Command23("show").description("Show a memory with its linked memories").argument("<id>", "Memory ID").option("--links", "Include linked memories").action(async (id, opts) => {
+  try {
+    const memory = await getMemoryById(id);
+    if (!memory) {
+      console.error(chalk21.red("\u2717") + ` Memory ${id} not found`);
+      process.exit(1);
+    }
+    const icon = TYPE_ICONS5[memory.type] || "\u{1F4DD}";
+    const scope = memory.scope === "global" ? "Global" : "Project";
+    console.log("");
+    console.log(`${icon} ${chalk21.bold(memory.type.toUpperCase())} (${scope})`);
+    console.log(chalk21.dim(`ID: ${memory.id}`));
+    console.log(chalk21.dim(`Created: ${memory.created_at}`));
+    if (memory.tags) console.log(chalk21.dim(`Tags: ${memory.tags}`));
+    console.log("");
+    console.log(memory.content);
+    if (opts.links) {
+      await ensureLinksTable();
+      const linked = await getLinkedMemories(id);
+      if (linked.length > 0) {
+        console.log("");
+        console.log(chalk21.bold("Linked Memories:"));
+        for (const { memory: m, linkType, direction } of linked) {
+          const mIcon = TYPE_ICONS5[m.type] || "\u{1F4DD}";
+          const arrow = direction === "to" ? "\u2192" : "\u2190";
+          const preview = m.content.length > 50 ? m.content.slice(0, 47) + "..." : m.content;
+          console.log(`  ${arrow} ${chalk21.cyan(linkType)}: ${mIcon} ${preview}`);
+        }
+      }
+    }
+    console.log("");
+  } catch (error2) {
+    console.error(chalk21.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/template.ts
+import { Command as Command24 } from "commander";
+import chalk22 from "chalk";
+var templateCommand = new Command24("template").description("Manage and use memory templates");
+templateCommand.command("list").description("List available templates").action(() => {
+  const templates = listTemplates();
+  console.log(chalk22.bold("\nAvailable Templates:\n"));
+  for (const t of templates) {
+    const typeIcon = t.type === "rule" ? "\u{1F4CC}" : t.type === "decision" ? "\u{1F4A1}" : t.type === "fact" ? "\u{1F4CB}" : "\u{1F4DD}";
+    console.log(`  ${chalk22.cyan(t.name.padEnd(15))} ${typeIcon} ${t.description}`);
+  }
+  console.log("");
+  console.log(chalk22.dim("Use: memories template use <name>"));
+  console.log("");
+});
+templateCommand.command("show <name>").description("Show template details and fields").action((name) => {
+  const template = getTemplate(name);
+  if (!template) {
+    console.error(chalk22.red("\u2717") + ` Template "${name}" not found`);
+    console.log(chalk22.dim("Run 'memories template list' to see available templates"));
+    process.exit(1);
+  }
+  const typeIcon = template.type === "rule" ? "\u{1F4CC}" : template.type === "decision" ? "\u{1F4A1}" : template.type === "fact" ? "\u{1F4CB}" : "\u{1F4DD}";
+  console.log("");
+  console.log(chalk22.bold(template.name) + ` ${typeIcon} ${template.type}`);
+  console.log(chalk22.dim(template.description));
+  console.log("");
+  console.log(chalk22.bold("Fields:"));
+  for (const field of template.fields) {
+    const required = field.required ? chalk22.red("*") : chalk22.dim("(optional)");
+    console.log(`  ${field.name.padEnd(15)} ${required}  ${field.prompt}`);
+  }
+  console.log("");
+});
+templateCommand.command("use <name>").description("Create a memory using a template").option("-g, --global", "Store as global memory").action(async (name, opts) => {
+  const template = getTemplate(name);
+  if (!template) {
+    console.error(chalk22.red("\u2717") + ` Template "${name}" not found`);
+    console.log(chalk22.dim("Run 'memories template list' to see available templates"));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(chalk22.bold(`Using template: ${template.name}`));
+  console.log(chalk22.dim(template.description));
+  console.log("");
+  try {
+    const content = await fillTemplate(template);
+    const memory = await addMemory(content, {
+      type: template.type,
+      global: opts.global
+    });
+    console.log("");
+    console.log(chalk22.green("\u2713") + ` Created ${template.type}: ${chalk22.dim(memory.id)}`);
+    console.log(chalk22.dim(`  "${content}"`));
+  } catch (error2) {
+    if (error2.message?.includes("User force closed")) {
+      console.log("\nCancelled.");
+      return;
+    }
+    throw error2;
+  }
+});
+
+// src/commands/history.ts
+import { Command as Command25 } from "commander";
+import chalk23 from "chalk";
+var TYPE_ICONS6 = {
+  rule: "\u{1F4CC}",
+  decision: "\u{1F4A1}",
+  fact: "\u{1F4CB}",
+  note: "\u{1F4DD}"
+};
+async function ensureHistoryTable() {
+  const db = await getDb();
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS memory_history (
+      id TEXT PRIMARY KEY,
+      memory_id TEXT NOT NULL,
+      content TEXT NOT NULL,
+      tags TEXT,
+      type TEXT NOT NULL,
+      changed_at TEXT NOT NULL DEFAULT (datetime('now')),
+      change_type TEXT NOT NULL
+    )
+  `);
+  await db.execute(`CREATE INDEX IF NOT EXISTS idx_history_memory ON memory_history(memory_id)`);
+}
+async function recordHistory(memory, changeType) {
+  await ensureHistoryTable();
+  const db = await getDb();
+  const id = `${memory.id}-${Date.now()}`;
+  await db.execute({
+    sql: `INSERT INTO memory_history (id, memory_id, content, tags, type, change_type) VALUES (?, ?, ?, ?, ?, ?)`,
+    args: [id, memory.id, memory.content, memory.tags, memory.type, changeType]
+  });
+}
+var historyCommand = new Command25("history").description("View version history of a memory").argument("<id>", "Memory ID").option("--json", "Output as JSON").action(async (id, opts) => {
+  try {
+    await ensureHistoryTable();
+    const db = await getDb();
+    const memory = await getMemoryById(id);
+    const result = await db.execute({
+      sql: `SELECT *, ROW_NUMBER() OVER (ORDER BY changed_at ASC) as version 
+              FROM memory_history 
+              WHERE memory_id = ? 
+              ORDER BY changed_at DESC`,
+      args: [id]
+    });
+    const history = result.rows;
+    if (opts.json) {
+      console.log(JSON.stringify({ current: memory, history }, null, 2));
+      return;
+    }
+    if (!memory && history.length === 0) {
+      console.error(chalk23.red("\u2717") + ` Memory ${id} not found`);
+      process.exit(1);
+    }
+    const icon = memory ? TYPE_ICONS6[memory.type] || "\u{1F4DD}" : "\u{1F4DD}";
+    console.log("");
+    if (memory) {
+      console.log(`${icon} ${chalk23.bold(memory.content)}`);
+      console.log(chalk23.dim(`ID: ${id}`));
+    } else {
+      console.log(chalk23.dim(`Memory ${id} (deleted)`));
+    }
+    console.log("");
+    if (history.length === 0) {
+      console.log(chalk23.dim("No version history recorded."));
+      console.log(chalk23.dim("History is recorded when memories are updated."));
+      return;
+    }
+    console.log(chalk23.bold("History:"));
+    console.log(chalk23.dim("\u2500".repeat(60)));
+    for (const entry of history) {
+      const changeIcon = entry.change_type === "created" ? "+" : entry.change_type === "updated" ? "~" : "-";
+      const changeColor = entry.change_type === "created" ? chalk23.green : entry.change_type === "updated" ? chalk23.yellow : chalk23.red;
+      const date = new Date(entry.changed_at).toLocaleDateString();
+      const time = new Date(entry.changed_at).toLocaleTimeString();
+      console.log(`  ${changeColor(changeIcon)} v${entry.version}  ${chalk23.dim(date + " " + time)}`);
+      console.log(`    "${entry.content.slice(0, 60)}${entry.content.length > 60 ? "..." : ""}"`);
+    }
+    console.log(chalk23.dim("\u2500".repeat(60)));
+    console.log(chalk23.dim(`
+Use 'memories revert ${id} --to <version>' to restore a previous version`));
+  } catch (error2) {
+    console.error(chalk23.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+var revertCommand = new Command25("revert").description("Revert a memory to a previous version").argument("<id>", "Memory ID").requiredOption("--to <version>", "Version number to revert to").action(async (id, opts) => {
+  try {
+    await ensureHistoryTable();
+    const db = await getDb();
+    const version = parseInt(opts.to.replace("v", ""), 10);
+    if (isNaN(version) || version < 1) {
+      console.error(chalk23.red("\u2717") + " Invalid version number");
+      process.exit(1);
+    }
+    const result = await db.execute({
+      sql: `SELECT *, ROW_NUMBER() OVER (ORDER BY changed_at ASC) as version 
+              FROM memory_history 
+              WHERE memory_id = ?`,
+      args: [id]
+    });
+    const history = result.rows;
+    const targetEntry = history.find((h) => h.version === version);
+    if (!targetEntry) {
+      console.error(chalk23.red("\u2717") + ` Version ${version} not found for memory ${id}`);
+      process.exit(1);
+    }
+    const current = await getMemoryById(id);
+    if (current) {
+      await recordHistory(current, "updated");
+    }
+    const updated = await updateMemory(id, {
+      content: targetEntry.content,
+      tags: targetEntry.tags ? targetEntry.tags.split(",") : void 0
+    });
+    if (!updated) {
+      console.error(chalk23.red("\u2717") + ` Failed to revert memory ${id}`);
+      process.exit(1);
+    }
+    console.log(chalk23.green("\u2713") + ` Reverted memory ${chalk23.dim(id)} to version ${version}`);
+    console.log(chalk23.dim(`  "${targetEntry.content.slice(0, 60)}${targetEntry.content.length > 60 ? "..." : ""}"`));
+  } catch (error2) {
+    console.error(chalk23.red("\u2717") + " Failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/embed.ts
+import { Command as Command26 } from "commander";
+import chalk24 from "chalk";
 import ora2 from "ora";
+var embedCommand = new Command26("embed").description("Generate embeddings for memories (enables semantic search)").option("--all", "Re-embed all memories, even those with existing embeddings").option("--dry-run", "Show what would be embedded without doing it").action(async (opts) => {
+  try {
+    await ensureEmbeddingsSchema();
+    const db = await getDb();
+    let sql = "SELECT id, content FROM memories WHERE deleted_at IS NULL";
+    if (!opts.all) {
+      sql += " AND embedding IS NULL";
+    }
+    const result = await db.execute(sql);
+    const memories = result.rows;
+    if (memories.length === 0) {
+      console.log(chalk24.green("\u2713") + " All memories already have embeddings.");
+      return;
+    }
+    if (opts.dryRun) {
+      console.log(chalk24.bold(`Would embed ${memories.length} memories:
+`));
+      for (const m of memories.slice(0, 10)) {
+        const preview = m.content.length > 60 ? m.content.slice(0, 57) + "..." : m.content;
+        console.log(`  ${chalk24.dim(m.id)}  ${preview}`);
+      }
+      if (memories.length > 10) {
+        console.log(chalk24.dim(`  ... and ${memories.length - 10} more`));
+      }
+      return;
+    }
+    console.log(chalk24.bold(`Embedding ${memories.length} memories...
+`));
+    console.log(chalk24.dim("First run downloads the model (~30MB). Subsequent runs are faster.\n"));
+    const spinner = ora2("Loading embedding model...").start();
+    let embedded = 0;
+    let failed = 0;
+    for (const m of memories) {
+      try {
+        spinner.text = `Embedding ${embedded + 1}/${memories.length}: ${m.content.slice(0, 40)}...`;
+        const embedding = await getEmbedding(m.content);
+        await storeEmbedding(m.id, embedding);
+        embedded++;
+      } catch (error2) {
+        failed++;
+      }
+    }
+    spinner.stop();
+    console.log(chalk24.green("\u2713") + ` Embedded ${embedded} memories`);
+    if (failed > 0) {
+      console.log(chalk24.yellow("\u26A0") + ` ${failed} memories failed to embed`);
+    }
+    console.log("");
+    console.log(chalk24.dim("Now you can use semantic search:"));
+    console.log(chalk24.cyan('  memories search --semantic "your query"'));
+  } catch (error2) {
+    console.error(chalk24.red("\u2717") + " Embedding failed:", error2 instanceof Error ? error2.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/login.ts
+import { Command as Command27 } from "commander";
+import chalk25 from "chalk";
+import ora3 from "ora";
 import { randomBytes } from "crypto";
 import { execFile } from "child_process";
 var DEFAULT_API_URL = "https://memories.sh";
@@ -3091,29 +3524,29 @@ function openBrowser(url) {
   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) => {
+var loginCommand = new Command27("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.`);
+    warn(`Already logged in as ${chalk25.bold(existing.email)}`);
+    dim(`Run ${chalk25.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",
+    chalk25.bold("Pro features include:\n\n") + chalk25.dim("\u2192 ") + "Cloud sync & backup\n" + chalk25.dim("\u2192 ") + "Cross-device access\n" + chalk25.dim("\u2192 ") + "Web dashboard\n" + chalk25.dim("\u2192 ") + "Priority support",
     "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)}
+  console.log(chalk25.bold("Open this URL in your browser:\n"));
+  console.log(`  ${chalk25.cyan(authUrl)}
 `);
   try {
     openBrowser(authUrl);
     dim("Browser opened automatically");
   } catch {
   }
-  const spinner = ora2({
+  const spinner = ora3({
     text: "Waiting for authorization...",
     color: "magenta"
   }).start();
@@ -3136,11 +3569,11 @@ var loginCommand = new Command21("login").description("Log in to memories.sh to
         });
         spinner.stop();
         console.log("");
-        success(`Logged in as ${chalk19.bold(data.email)}`);
+        success(`Logged in as ${chalk25.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")}`
+          `${chalk25.cyan("memories sync")} ${chalk25.dim("to sync your memories")}`,
+          `${chalk25.cyan("memories.sh/app")} ${chalk25.dim("to view your dashboard")}`
         ]);
         return;
       }
@@ -3156,7 +3589,7 @@ var loginCommand = new Command21("login").description("Log in to memories.sh to
   spinner.stop();
   error("Authorization timed out. Please try again.");
 });
-var logoutCommand = new Command21("logout").description("Log out of memories.sh").action(async () => {
+var logoutCommand = new Command27("logout").description("Log out of memories.sh").action(async () => {
   const existing = await readAuth();
   if (!existing) {
     info("Not logged in.");
@@ -3167,7 +3600,7 @@ var logoutCommand = new Command21("logout").description("Log out of memories.sh"
 });
 
 // src/index.ts
-var program = new Command22().name("memories").description("A local-first memory layer for AI agents").version("0.2.1");
+var program = new Command28().name("memories").description("A local-first memory layer for AI agents").version("0.2.2");
 program.addCommand(initCommand);
 program.addCommand(addCommand);
 program.addCommand(recallCommand);
@@ -3188,6 +3621,16 @@ program.addCommand(hookCommand);
 program.addCommand(ingestCommand);
 program.addCommand(diffCommand);
 program.addCommand(tagCommand);
+program.addCommand(validateCommand);
+program.addCommand(staleCommand);
+program.addCommand(reviewCommand);
+program.addCommand(linkCommand);
+program.addCommand(unlinkCommand);
+program.addCommand(showCommand);
+program.addCommand(templateCommand);
+program.addCommand(historyCommand);
+program.addCommand(revertCommand);
+program.addCommand(embedCommand);
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.parse();