@shahmilsaari/memory-core 0.2.7 → 0.2.10

package/dist/cli.js

@@ -1,14 +1,29 @@
 #!/usr/bin/env node
+import {
+  embed
+} from "./chunk-HAGRPKR3.js";
+import {
+  closePool,
+  deleteMemory,
+  getMemory,
+  listMemories,
+  runMigrations,
+  saveMemory,
+  searchMemories,
+  updateMemory,
+  upsertMemory
+} from "./chunk-73SRPNAL.js";
+import "./chunk-KSLFLWB4.js";
 
 // src/cli.ts
 import { Command } from "commander";
 import { input, select, confirm } from "@inquirer/prompts";
 import chalk3 from "chalk";
 import ora from "ora";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync6, mkdirSync as mkdirSync2, appendFileSync } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync2, appendFileSync, rmSync, unlinkSync as unlinkSync2 } from "fs";
 import { join as join6, dirname as dirname2 } from "path";
 import { homedir } from "os";
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync2 } from "child_process";
 
 // src/generator.ts
 import { readFileSync, readdirSync, writeFileSync, mkdirSync, existsSync } from "fs";
@@ -535,109 +550,6 @@ var seeds = [
   { type: "rule", scope: "global", architecture: "svelte", title: "Avoid options API style \u2014 runes only", content: "Do not use the Svelte 4 options-style patterns (export let, $: reactive statements, $store subscriptions) in new Svelte 5 components. Use runes throughout.", reason: "Mixing the two reactivity systems in the same codebase creates two mental models, confuses new developers, and makes future migrations harder. Svelte 5 runes supersede every Svelte 4 pattern.", tags: ["svelte", "runes", "anti-pattern"] }
 ];
 
-// src/config.ts
-import { config } from "dotenv";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-var localEnv = join2(process.cwd(), ".memory-core.env");
-config({ path: existsSync2(localEnv) ? localEnv : join2(process.cwd(), ".env") });
-var Config = {
-  get databaseUrl() {
-    return process.env.DATABASE_URL ?? "";
-  },
-  get ollamaUrl() {
-    return process.env.OLLAMA_URL ?? "http://localhost:11434";
-  },
-  get ollamaModel() {
-    return process.env.OLLAMA_MODEL ?? "nomic-embed-text";
-  },
-  get chatModel() {
-    return process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
-  }
-};
-
-// src/embedding.ts
-async function embed(text) {
-  let response;
-  try {
-    response = await fetch(`${Config.ollamaUrl}/api/embeddings`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ model: Config.ollamaModel, prompt: text })
-    });
-  } catch {
-    throw new Error(
-      `Cannot reach Ollama at ${Config.ollamaUrl}. Run: ollama serve`
-    );
-  }
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(`Ollama embedding failed (${response.status}): ${body}`);
-  }
-  const data = await response.json();
-  return data.embedding;
-}
-
-// src/db.ts
-import pg from "pg";
-var { Pool } = pg;
-var pool = null;
-function getPool() {
-  if (!pool) {
-    if (!Config.databaseUrl) {
-      throw new Error("DATABASE_URL is not set. Add it to your .env or .memory-core.env file.");
-    }
-    pool = new Pool({ connectionString: Config.databaseUrl });
-  }
-  return pool;
-}
-async function runMigrations() {
-  await getPool().query(
-    `ALTER TABLE memories ADD COLUMN IF NOT EXISTS reason TEXT`
-  );
-}
-async function saveMemory(memory) {
-  const { type, scope, architecture, projectName, title, content, reason, tags, embedding } = memory;
-  await getPool().query(
-    `INSERT INTO memories (type, scope, architecture, project_name, title, content, reason, tags, embedding)
-     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
-    [type, scope, architecture ?? null, projectName ?? null, title ?? null, content, reason ?? null, tags ?? [], `[${embedding.join(",")}]`]
-  );
-}
-async function searchMemories(embedding, architecture, limit = 10) {
-  const vector = `[${embedding.join(",")}]`;
-  const params = [vector];
-  let whereClause = "";
-  if (architecture) {
-    whereClause = `WHERE (architecture = $2 OR scope = 'global')`;
-    params.push(architecture);
-  }
-  const client = await getPool().connect();
-  try {
-    await client.query("BEGIN");
-    await client.query("SET LOCAL ivfflat.probes = 10");
-    const result = await client.query(
-      `SELECT id, type, scope, architecture, project_name, title, content, reason, tags,
-              1 - (embedding <=> $1) AS similarity
-       FROM memories
-       ${whereClause}
-       ORDER BY embedding <=> $1
-       LIMIT $${params.length + 1}`,
-      [...params, limit]
-    );
-    await client.query("COMMIT");
-    return result.rows;
-  } finally {
-    client.release();
-  }
-}
-async function closePool() {
-  if (pool) {
-    await pool.end();
-    pool = null;
-  }
-}
-
 // src/retriever.ts
 async function retrieve(query, architecture, limit = 10) {
   const embedding = await embed(query);
@@ -645,13 +557,13 @@ async function retrieve(query, architecture, limit = 10) {
 }
 
 // src/project-detector.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 function detectProject(cwd = process.cwd()) {
-  const has = (file) => existsSync3(join3(cwd, file));
+  const has = (file) => existsSync2(join2(cwd, file));
   const readJson = (file) => {
     try {
-      return JSON.parse(readFileSync2(join3(cwd, file), "utf-8"));
+      return JSON.parse(readFileSync2(join2(cwd, file), "utf-8"));
     } catch {
       return {};
     }
@@ -667,7 +579,7 @@ function detectProject(cwd = process.cwd()) {
   }
   if (has("manage.py")) {
     if (has("requirements.txt")) {
-      const req = readFileSync2(join3(cwd, "requirements.txt"), "utf-8");
+      const req = readFileSync2(join2(cwd, "requirements.txt"), "utf-8");
       if (req.includes("djangorestframework")) {
         return { language: "Python", framework: "Django REST Framework" };
       }
@@ -707,59 +619,273 @@ function detectProject(cwd = process.cwd()) {
 }
 
 // src/hook.ts
-import { execSync } from "child_process";
-import { writeFileSync as writeFileSync2, existsSync as existsSync4, unlinkSync, readFileSync as readFileSync3, chmodSync } from "fs";
+import { execSync, spawnSync } from "child_process";
+import { writeFileSync as writeFileSync3, existsSync as existsSync4, unlinkSync, readFileSync as readFileSync4, chmodSync } from "fs";
 import { join as join4 } from "path";
 import chalk from "chalk";
-async function resolveModel(ollamaUrl, chatModel) {
-  try {
-    const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(3e3) });
-    if (!res.ok) return chatModel;
-    const data = await res.json();
-    const models = data.models ?? [];
-    const exact = models.find((m) => m.name === chatModel);
-    if (exact) return exact.name;
-    const prefixed = models.find((m) => m.name.startsWith(`${chatModel}:`));
-    if (prefixed) return prefixed.name;
-  } catch {
+
+// src/chat.ts
+function getChatConfig() {
+  const provider = process.env.CHAT_PROVIDER ?? "ollama";
+  const model = process.env.CHAT_MODEL ?? process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
+  return {
+    provider,
+    model,
+    ollamaUrl: process.env.OLLAMA_URL ?? "http://localhost:11434",
+    apiKey: process.env.CHAT_API_KEY ?? ""
+  };
+}
+async function callOllama(cfg, messages) {
+  const res = await fetch(`${cfg.ollamaUrl}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model: cfg.model, messages, stream: false, format: "json" })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    if (body.includes("not found") || body.includes("model")) {
+      throw new Error(`MODEL_NOT_FOUND:${cfg.model}`);
+    }
+    throw new Error(body);
   }
-  return chatModel;
+  const data = await res.json();
+  return data.message.content.trim();
 }
+async function callOpenAI(cfg, messages) {
+  const res = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${cfg.apiKey}`
+    },
+    body: JSON.stringify({
+      model: cfg.model,
+      messages,
+      response_format: { type: "json_object" }
+    })
+  });
+  if (!res.ok) throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.choices[0].message.content.trim();
+}
+async function callAnthropic(cfg, messages) {
+  const system = messages.find((m) => m.role === "system")?.content ?? "";
+  const userMessages = messages.filter((m) => m.role !== "system");
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": cfg.apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: cfg.model,
+      max_tokens: 4096,
+      system,
+      messages: userMessages
+    })
+  });
+  if (!res.ok) throw new Error(`Anthropic API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.content[0].text.trim();
+}
+async function callMiniMax(cfg, messages) {
+  const res = await fetch("https://api.minimax.io/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${cfg.apiKey}`
+    },
+    body: JSON.stringify({
+      model: cfg.model,
+      messages,
+      response_format: { type: "json_object" }
+    })
+  });
+  if (!res.ok) throw new Error(`MiniMax API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.choices[0].message.content.trim();
+}
+async function callChatModel(messages) {
+  const cfg = getChatConfig();
+  switch (cfg.provider) {
+    case "openai":
+      return callOpenAI(cfg, messages);
+    case "anthropic":
+      return callAnthropic(cfg, messages);
+    case "minimax":
+      return callMiniMax(cfg, messages);
+    default:
+      return callOllama(cfg, messages);
+  }
+}
+function getChatProviderLabel() {
+  const cfg = getChatConfig();
+  if (cfg.provider === "ollama") return `ollama (${cfg.model})`;
+  return `${cfg.provider} (${cfg.model})`;
+}
+
+// src/memory-file.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+var MEMORY_FILE = "memories.json";
+function toPortableMemory(memory) {
+  return {
+    type: memory.type,
+    scope: memory.scope,
+    architecture: memory.architecture,
+    projectName: memory.project_name,
+    title: memory.title,
+    content: memory.content,
+    reason: memory.reason,
+    tags: memory.tags ?? []
+  };
+}
+function writeMemoryFile(memories, cwd = process.cwd()) {
+  const path = join3(cwd, MEMORY_FILE);
+  writeFileSync2(path, JSON.stringify(memories, null, 2) + "\n", "utf-8");
+  return path;
+}
+function readMemoryFile(cwd = process.cwd()) {
+  const path = join3(cwd, MEMORY_FILE);
+  if (!existsSync3(path)) {
+    throw new Error(`${MEMORY_FILE} not found. Run: memory-core export`);
+  }
+  return parseMemoryFile(readFileSync3(path, "utf-8"));
+}
+async function readMemoryFileFromUrl(url) {
+  const res = await fetch(url, { signal: AbortSignal.timeout(15e3) });
+  if (!res.ok) throw new Error(`Failed to download ${url}: HTTP ${res.status}`);
+  return parseMemoryFile(await res.text());
+}
+function parseMemoryFile(raw) {
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error(`${MEMORY_FILE} must be a JSON array`);
+  }
+  return parsed.map((item, index) => {
+    if (!item || typeof item !== "object") {
+      throw new Error(`Memory at index ${index} must be an object`);
+    }
+    const record = item;
+    if (typeof record.content !== "string" || record.content.trim() === "") {
+      throw new Error(`Memory at index ${index} is missing content`);
+    }
+    return {
+      type: typeof record.type === "string" ? record.type : "rule",
+      scope: typeof record.scope === "string" ? record.scope : "project",
+      architecture: typeof record.architecture === "string" ? record.architecture : void 0,
+      projectName: typeof record.projectName === "string" ? record.projectName : void 0,
+      title: typeof record.title === "string" ? record.title : void 0,
+      content: record.content,
+      reason: typeof record.reason === "string" ? record.reason : void 0,
+      tags: Array.isArray(record.tags) ? record.tags.filter((tag) => typeof tag === "string") : []
+    };
+  });
+}
+
+// src/hook.ts
 var reasonMap = new Map(
   seeds.filter((s) => s.reason).map((s) => [s.content, s.reason])
 );
 var HOOK_PATH = join4(".git", "hooks", "pre-commit");
 var HOOK_MARKER = "# archmind-memory-core";
-var HOOK_SCRIPT = `#!/bin/sh
-${HOOK_MARKER}
+function buildHookScript(advisory) {
+  const suffix = advisory ? " || true" : "";
+  return `#!/bin/sh
+${HOOK_MARKER}${advisory ? " advisory" : ""}
 if command -v memory-core >/dev/null 2>&1; then
-  memory-core check --staged
+  memory-core check --staged${suffix}
 elif [ -f "./node_modules/.bin/memory-core" ]; then
-  ./node_modules/.bin/memory-core check --staged
+  ./node_modules/.bin/memory-core check --staged${suffix}
 elif [ -f "./dist/cli.js" ]; then
-  node ./dist/cli.js check --staged
+  node ./dist/cli.js check --staged${suffix}
 else
   npx --no-install memory-core check --staged 2>/dev/null || exit 0
 fi
 `;
-function installHook() {
+}
+function recordViolations(violations) {
+  const statsPath = join4(process.cwd(), ".memory-core-stats.json");
+  let stats = { rules: {}, files: {} };
+  if (existsSync4(statsPath)) {
+    try {
+      stats = JSON.parse(readFileSync4(statsPath, "utf-8"));
+    } catch {
+      stats = { rules: {}, files: {} };
+    }
+  }
+  for (const violation of violations) {
+    stats.rules[violation.rule] = (stats.rules[violation.rule] ?? 0) + 1;
+    if (violation.file) stats.files[violation.file] = (stats.files[violation.file] ?? 0) + 1;
+  }
+  writeFileSync3(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+}
+async function promptToSaveViolations(violations) {
+  if (!process.stdin.isTTY || violations.length === 0) return;
+  try {
+    const { confirm: confirm2, input: input2 } = await import("@inquirer/prompts");
+    const save = await confirm2({
+      message: "Save a caught violation as a project rule?",
+      default: false
+    });
+    if (!save) return;
+    const choices = violations.map((violation, index) => `${index + 1}. ${violation.rule}`);
+    const selected = violations.length === 1 ? violations[0] : violations[Number(await input2({ message: `Which violation? ${choices.join(" | ")}`, default: "1" })) - 1] ?? violations[0];
+    const reason = await input2({
+      message: "Why should this rule exist?",
+      default: selected.reason ?? selected.issue ?? ""
+    });
+    const { embed: embed2 } = await import("./embedding-PAYD2JYW.js");
+    const { upsertMemory: upsertMemory2 } = await import("./db-KU4EEG4Y.js");
+    await upsertMemory2({
+      type: "rule",
+      scope: "project",
+      content: selected.rule,
+      reason: reason || void 0,
+      tags: ["violation"],
+      embedding: await embed2(selected.rule)
+    });
+    console.log(chalk.green("  \u2713 Saved as project rule. Run memory-core sync to propagate it.\n"));
+  } catch (err) {
+    console.log(chalk.yellow(`  Could not save violation: ${err.message}
+`));
+  }
+}
+async function loadIgnorePatterns() {
+  try {
+    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-KU4EEG4Y.js");
+    const ignores = await listMemories2({ type: "ignore", limit: 1e3 });
+    await closePool2();
+    return ignores.map((ignore) => ignore.content);
+  } catch {
+    return [];
+  }
+}
+function installHook(advisory = true) {
   if (!existsSync4(".git")) {
     console.error(chalk.red("\n  Not a git repository. Run from project root.\n"));
     process.exit(1);
   }
+  const script = buildHookScript(advisory);
   if (existsSync4(HOOK_PATH)) {
-    const existing = readFileSync3(HOOK_PATH, "utf-8");
+    const existing = readFileSync4(HOOK_PATH, "utf-8");
     if (existing.includes(HOOK_MARKER)) {
-      console.log(chalk.yellow("\n  Hook already installed.\n"));
+      const markerIndex = existing.indexOf(HOOK_MARKER);
+      const before = markerIndex > 1 ? existing.slice(0, markerIndex).trimEnd() + "\n\n" : "";
+      writeFileSync3(HOOK_PATH, before + script);
+      chmodSync(HOOK_PATH, 493);
+      const modeLabel2 = advisory ? chalk.cyan("advisory") : chalk.yellow("strict");
+      console.log(chalk.green("\n  \u2713 Pre-commit hook updated") + chalk.dim(` (${modeLabel2} mode)`));
       return;
     }
-    writeFileSync2(HOOK_PATH, existing.trimEnd() + "\n\n" + HOOK_SCRIPT);
+    writeFileSync3(HOOK_PATH, existing.trimEnd() + "\n\n" + script);
   } else {
-    writeFileSync2(HOOK_PATH, HOOK_SCRIPT);
+    writeFileSync3(HOOK_PATH, script);
   }
   chmodSync(HOOK_PATH, 493);
-  console.log(chalk.green("\n  \u2713 Pre-commit hook installed"));
-  console.log(chalk.gray("    Every commit will be checked against your architecture rules."));
+  const modeLabel = advisory ? "advisory (logs violations, never blocks)" : "strict (blocks commits on violations)";
+  console.log(chalk.green("\n  \u2713 Pre-commit hook installed") + chalk.dim(` \u2014 ${modeLabel}`));
   console.log(chalk.gray(`    Chat model: ${process.env.OLLAMA_CHAT_MODEL ?? "llama3.2"}`));
   console.log(chalk.gray("    To uninstall: memory-core hook uninstall\n"));
 }
@@ -768,14 +894,14 @@ function uninstallHook() {
     console.log(chalk.yellow("\n  No pre-commit hook found.\n"));
     return;
   }
-  const content = readFileSync3(HOOK_PATH, "utf-8");
+  const content = readFileSync4(HOOK_PATH, "utf-8");
   if (!content.includes(HOOK_MARKER)) {
     console.log(chalk.yellow("\n  ArchMind hook not found in pre-commit \u2014 nothing to remove.\n"));
     return;
   }
   const markerIndex = content.indexOf(HOOK_MARKER);
   if (markerIndex > 1) {
-    writeFileSync2(HOOK_PATH, content.slice(0, markerIndex).trimEnd() + "\n");
+    writeFileSync3(HOOK_PATH, content.slice(0, markerIndex).trimEnd() + "\n");
   } else {
     unlinkSync(HOOK_PATH);
   }
@@ -790,7 +916,8 @@ async function checkStaged(options = {}) {
       if (options.verbose) console.log(chalk.gray("  No source files staged \u2014 skipping rule check."));
       return;
     }
-    diff = execSync(`git diff --cached -- ${stagedFiles.map((f) => `"${f}"`).join(" ")}`, { encoding: "utf-8" });
+    const result = spawnSync("git", ["diff", "--cached", "--", ...stagedFiles], { encoding: "utf-8" });
+    diff = result.stdout ?? "";
   } catch {
     console.error(chalk.red("  Failed to read staged diff."));
     process.exit(1);
@@ -801,38 +928,37 @@ async function checkStaged(options = {}) {
   }
   const configPath = join4(process.cwd(), ".memory-core.json");
   if (!existsSync4(configPath)) return;
-  const config2 = JSON.parse(readFileSync3(configPath, "utf-8"));
+  const config = JSON.parse(readFileSync4(configPath, "utf-8"));
   const rules = [];
   const avoids = [];
-  if (config2.backendArchitecture) {
-    const profile = listProfiles("backend").find((p) => p.name === config2.backendArchitecture);
+  if (config.backendArchitecture) {
+    const profile = listProfiles("backend").find((p) => p.name === config.backendArchitecture);
     if (profile) {
       rules.push(...profile.rules);
       avoids.push(...profile.avoid);
     }
   }
-  if (config2.frontendFramework) {
-    const profile = listProfiles("frontend").find((p) => p.name === config2.frontendFramework);
+  if (config.frontendFramework) {
+    const profile = listProfiles("frontend").find((p) => p.name === config.frontendFramework);
     if (profile) {
       rules.push(...profile.rules);
       avoids.push(...profile.avoid);
     }
   }
   if (rules.length === 0) return;
-  const ollamaUrl = process.env.OLLAMA_URL ?? "http://localhost:11434";
-  const chatModel = await resolveModel(ollamaUrl, process.env.OLLAMA_CHAT_MODEL ?? "llama3.2");
   const MAX_DIFF = 8e3;
   const truncated = diff.length > MAX_DIFF;
   const diffToSend = truncated ? diff.slice(0, MAX_DIFF) + "\n\n[diff truncated]" : diff;
   console.log(chalk.cyan("\n  archmind \u2014 checking staged changes against rules\u2026"));
-  if (options.verbose) {
-    console.log(chalk.gray(`  model: ${chatModel}  rules: ${rules.length}  diff: ${diff.length} chars${truncated ? " (truncated)" : ""}`));
+  if (options.verbose || options.debug) {
+    console.log(chalk.gray(`  model: ${getChatProviderLabel()}  rules: ${rules.length}  diff: ${diff.length} chars${truncated ? " (truncated)" : ""}`));
   }
   const rulesWithReasons = rules.map((r, i) => {
     const why = reasonMap.get(r);
     return why ? `${i + 1}. ${r}
    WHY: ${why}` : `${i + 1}. ${r}`;
   }).join("\n");
+  const ignorePatterns = await loadIgnorePatterns();
   const systemPrompt = `You are a strict code reviewer enforcing architecture and framework rules.
 Analyze the git diff and identify ONLY clear, definite rule violations \u2014 not style preferences.
 Use the WHY for each rule to understand intent and judge edge cases correctly.
@@ -843,38 +969,34 @@ ${rulesWithReasons}
 Things that must never appear:
 ${avoids.map((a, i) => `${i + 1}. ${a}`).join("\n")}
 
+Never flag these accepted project patterns:
+${ignorePatterns.length ? ignorePatterns.map((a, i) => `${i + 1}. ${a}`).join("\n") : "(none)"}
+
 IMPORTANT: You MUST respond with a JSON object that has a "violations" key containing an array.
 For each violation include a "reason" field \u2014 copy the WHY from the rule to explain to the developer why this matters.
 Example with violations: {"violations":[{"rule":"Use functional components only","file":"User.tsx","line":3,"issue":"Class component used","suggestion":"Convert to a function component using hooks","reason":"Class components cannot use hooks and the entire React ecosystem now assumes functional components"}]}
 Example with no violations: {"violations":[]}
 Do not include any text outside the JSON object.`;
+  if (options.debug) {
+    console.log(chalk.gray("\n  [debug] prompt:"));
+    console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(systemPrompt);
+    console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk.gray(`  [debug] diff length: ${diff.length} chars`));
+    console.log(chalk.dim(diffToSend));
+    console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  }
   let violations = [];
   try {
-    const res = await fetch(`${ollamaUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: chatModel,
-        messages: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: `Review this diff:
+    const raw = await callChatModel([
+      { role: "system", content: systemPrompt },
+      { role: "user", content: `Review this diff:
 
 ${diffToSend}` }
-        ],
-        stream: false,
-        format: "json"
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      if (body.includes("not found") || body.includes("model")) {
-        printModelMissing(chatModel);
-        return;
-      }
-      throw new Error(body);
+    ]);
+    if (options.verbose || options.debug) {
+      console.log(chalk.gray(`  raw response: ${options.debug ? raw : raw.slice(0, 200)}`));
     }
-    const data = await res.json();
-    const raw = data.message.content.trim();
     try {
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed)) {
@@ -889,10 +1011,11 @@ ${diffToSend}` }
     } catch {
       violations = [];
     }
-    if (options.verbose) {
-      console.log(chalk.gray(`  raw response: ${raw.slice(0, 200)}`));
-    }
   } catch (err) {
+    if (err.message?.startsWith("MODEL_NOT_FOUND:")) {
+      printModelMissing(err.message.split(":")[1]);
+      return;
+    }
     if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
       console.log(chalk.yellow("\n  \u26A0  Ollama not running \u2014 skipping rule check."));
       console.log(chalk.gray("     Start it: ollama serve\n"));
@@ -928,6 +1051,96 @@ ${diffToSend}` }
   console.log(chalk.dim("  To bypass (not recommended): git commit --no-verify"));
   console.log(chalk.dim('  To save as memory: memory-core remember "<lesson>"'));
   console.log();
+  recordViolations(violations);
+  await promptToSaveViolations(violations);
+  process.exit(1);
+}
+function extractForbiddenPhrases(content) {
+  const phrases = [];
+  const normalized = content.replace(/\s+/g, " ");
+  const patterns = [
+    /\bnever\s+([^.;]+)/gi,
+    /\bmust not\s+([^.;]+)/gi,
+    /\bdo not\s+([^.;]+)/gi
+  ];
+  for (const pattern of patterns) {
+    for (const match of normalized.matchAll(pattern)) {
+      const phrase = match[1]?.trim();
+      if (phrase && phrase.split(/\s+/).length >= 2) phrases.push(phrase.toLowerCase());
+    }
+  }
+  return phrases;
+}
+function getCiDiff() {
+  const baseRef = process.env.GITHUB_BASE_REF;
+  const commands = [
+    baseRef ? `git diff --unified=0 --diff-filter=ACMRT origin/${baseRef}...HEAD` : "",
+    "git diff --unified=0 --diff-filter=ACMRT HEAD~1 HEAD",
+    "git diff --cached --unified=0 --diff-filter=ACMRT"
+  ].filter(Boolean);
+  for (const command of commands) {
+    try {
+      const diff = execSync(command, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+      if (diff.trim()) return diff;
+    } catch {
+    }
+  }
+  return "";
+}
+async function checkCi(options = {}) {
+  let memories;
+  try {
+    memories = readMemoryFile();
+  } catch (err) {
+    console.error(chalk.red(`
+  CI check failed: ${err.message}
+`));
+    process.exit(1);
+  }
+  const rules = memories.filter((memory) => memory.type !== "ignore");
+  const ignores = memories.filter((memory) => memory.type === "ignore").map((memory) => memory.content.toLowerCase());
+  const phrases = rules.flatMap(
+    (memory) => extractForbiddenPhrases(memory.content).map((phrase) => ({ rule: memory.content, phrase }))
+  );
+  const diff = getCiDiff();
+  const addedLines = diff.split("\n").filter((line) => line.startsWith("+") && !line.startsWith("+++")).map((line) => line.slice(1));
+  if (options.debug) {
+    console.log(chalk.gray(`
+  [debug] memories: ${memories.length}`));
+    console.log(chalk.gray(`  [debug] text rules: ${phrases.length}`));
+    console.log(chalk.gray(`  [debug] diff length: ${diff.length} chars
+`));
+  }
+  const violations = [];
+  for (const line of addedLines) {
+    const normalizedLine = line.toLowerCase();
+    if (ignores.some((ignore) => normalizedLine.includes(ignore))) continue;
+    for (const { rule, phrase } of phrases) {
+      if (normalizedLine.includes(phrase)) {
+        violations.push({
+          rule,
+          file: "diff",
+          issue: `Added line contains forbidden phrase: "${phrase}"`
+        });
+      }
+    }
+  }
+  if (violations.length === 0) {
+    console.log(chalk.green(`
+  \u2713 CI memory check passed (${rules.length} rules loaded from memories.json)
+`));
+    return;
+  }
+  console.log(chalk.red.bold(`
+  \u2717 ${violations.length} CI violation${violations.length > 1 ? "s" : ""} found
+`));
+  violations.forEach((violation, index) => {
+    console.log(chalk.bold(`  [${index + 1}] ${violation.file}`));
+    console.log(chalk.yellow("      Rule:   ") + violation.rule);
+    console.log(chalk.red("      Issue:  ") + violation.issue);
+    console.log();
+  });
+  recordViolations(violations);
   process.exit(1);
 }
 function printModelMissing(model) {
@@ -940,27 +1153,13 @@ function printModelMissing(model) {
 
 // src/watcher.ts
 import { watch } from "chokidar";
-import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { join as join5, relative } from "path";
 import chalk2 from "chalk";
-async function resolveModel2(ollamaUrl, chatModel) {
-  try {
-    const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(3e3) });
-    if (!res.ok) return chatModel;
-    const data = await res.json();
-    const models = data.models ?? [];
-    const exact = models.find((m) => m.name === chatModel);
-    if (exact) return exact.name;
-    const prefixed = models.find((m) => m.name.startsWith(`${chatModel}:`));
-    if (prefixed) return prefixed.name;
-  } catch {
-  }
-  return chatModel;
-}
 function getFileLines(filePath) {
   try {
-    return readFileSync4(filePath, "utf-8").split("\n");
+    return readFileSync5(filePath, "utf-8").split("\n");
   } catch {
     return [];
   }
@@ -986,27 +1185,43 @@ var SOURCE_EXTENSIONS = /\.(ts|tsx|js|jsx|py|php|rb|go|java|cs|swift|kt|rs|vue|s
 var reasonMap2 = new Map(
   seeds.filter((s) => s.reason).map((s) => [s.content, s.reason])
 );
+function recordViolations2(violations) {
+  const statsPath = join5(process.cwd(), ".memory-core-stats.json");
+  let stats = { rules: {}, files: {} };
+  if (existsSync5(statsPath)) {
+    try {
+      stats = JSON.parse(readFileSync5(statsPath, "utf-8"));
+    } catch {
+      stats = { rules: {}, files: {} };
+    }
+  }
+  for (const violation of violations) {
+    stats.rules[violation.rule] = (stats.rules[violation.rule] ?? 0) + 1;
+    if (violation.file) stats.files[violation.file] = (stats.files[violation.file] ?? 0) + 1;
+  }
+  writeFileSync4(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+}
 function loadConfig(cwd) {
   const configPath = join5(cwd, ".memory-core.json");
   if (!existsSync5(configPath)) return null;
   try {
-    return JSON.parse(readFileSync4(configPath, "utf-8"));
+    return JSON.parse(readFileSync5(configPath, "utf-8"));
   } catch {
     return null;
   }
 }
-function getProfileRules(config2) {
+function getProfileRules(config) {
   const rules = [];
   const avoids = [];
-  if (config2.backendArchitecture) {
-    const profile = listProfiles("backend").find((p) => p.name === config2.backendArchitecture);
+  if (config.backendArchitecture) {
+    const profile = listProfiles("backend").find((p) => p.name === config.backendArchitecture);
     if (profile) {
       rules.push(...profile.rules);
       avoids.push(...profile.avoid);
     }
   }
-  if (config2.frontendFramework) {
-    const profile = listProfiles("frontend").find((p) => p.name === config2.frontendFramework);
+  if (config.frontendFramework) {
+    const profile = listProfiles("frontend").find((p) => p.name === config.frontendFramework);
     if (profile) {
       rules.push(...profile.rules);
       avoids.push(...profile.avoid);
@@ -1014,30 +1229,33 @@ function getProfileRules(config2) {
   }
   return { rules, avoids };
 }
-async function checkFile(filePath, cwd, config2, verbose) {
-  const rel = relative(cwd, filePath);
-  let diff;
+async function loadIgnorePatterns2() {
   try {
-    diff = execSync2(`git diff HEAD -- "${rel}" 2>/dev/null || git diff --no-index /dev/null "${rel}" 2>/dev/null || true`, {
-      encoding: "utf-8",
-      cwd
-    });
+    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-KU4EEG4Y.js");
+    const ignores = await listMemories2({ type: "ignore", limit: 1e3 });
+    await closePool2();
+    return ignores.map((ignore) => ignore.content);
   } catch {
-    try {
-      diff = execSync2(`git diff --no-index /dev/null "${rel}"`, { encoding: "utf-8", cwd });
-    } catch (e) {
-      diff = e.stdout ?? "";
-    }
+    return [];
+  }
+}
+async function checkFile(filePath, cwd, config, verbose, debug) {
+  const rel = relative(cwd, filePath);
+  let diff;
+  const headResult = spawnSync2("git", ["diff", "HEAD", "--", rel], { encoding: "utf-8", cwd });
+  if (headResult.stdout?.trim()) {
+    diff = headResult.stdout;
+  } else {
+    const noIndexResult = spawnSync2("git", ["diff", "--no-index", "/dev/null", rel], { encoding: "utf-8", cwd });
+    diff = noIndexResult.stdout ?? "";
   }
   if (!diff.trim()) return;
-  const { rules, avoids } = getProfileRules(config2);
+  const { rules, avoids } = getProfileRules(config);
   if (rules.length === 0) return;
-  const ollamaUrl = process.env.OLLAMA_URL ?? "http://localhost:11434";
-  const chatModel = await resolveModel2(ollamaUrl, process.env.OLLAMA_CHAT_MODEL ?? "llama3.2");
   const MAX_DIFF = 6e3;
   const truncated = diff.length > MAX_DIFF;
   const diffToSend = truncated ? diff.slice(0, MAX_DIFF) + "\n\n[diff truncated]" : diff;
-  if (verbose) {
+  if (verbose || debug) {
     console.log(chalk2.dim(`
   [watch] checking ${rel} (${diff.length} chars)\u2026`));
   }
@@ -1046,6 +1264,7 @@ async function checkFile(filePath, cwd, config2, verbose) {
     return why ? `${i + 1}. ${r}
    WHY: ${why}` : `${i + 1}. ${r}`;
   }).join("\n");
+  const ignorePatterns = await loadIgnorePatterns2();
   const systemPrompt = `You are a strict code reviewer enforcing architecture rules.
 Analyze the file diff and identify ONLY clear, definite rule violations.
 Use the WHY for each rule to understand intent and judge edge cases.
@@ -1056,36 +1275,33 @@ ${rulesWithReasons}
 Things that must never appear:
 ${avoids.map((a, i) => `${i + 1}. ${a}`).join("\n")}
 
+Never flag these accepted project patterns:
+${ignorePatterns.length ? ignorePatterns.map((a, i) => `${i + 1}. ${a}`).join("\n") : "(none)"}
+
 IMPORTANT: Respond with JSON: {"violations":[...]} or {"violations":[]}.
 Each violation: {"rule":"...","file":"...","line":N,"issue":"...","suggestion":"...","reason":"..."}.
 No text outside the JSON.`;
+  if (debug) {
+    console.log(chalk2.gray("\n  [debug] prompt:"));
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(systemPrompt);
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk2.gray(`  [debug] diff length: ${diff.length} chars`));
+    console.log(chalk2.dim(diffToSend));
+    console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  }
   try {
-    const res = await fetch(`${ollamaUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: chatModel,
-        messages: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: `Review this diff for ${rel}:
+    const raw = await callChatModel([
+      { role: "system", content: systemPrompt },
+      { role: "user", content: `Review this diff for ${rel}:
 
 ${diffToSend}` }
-        ],
-        stream: false,
-        format: "json"
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      if (body.includes("not found") || body.includes("model")) {
-        console.log(chalk2.yellow(`
-  \u26A0  Chat model "${chatModel}" not found. Pull it: ollama pull ${chatModel}
-`));
-      }
-      return;
+    ]);
+    if (debug) {
+      console.log(chalk2.gray("  [debug] raw response:"));
+      console.log(chalk2.dim(raw));
+      console.log(chalk2.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     }
-    const data = await res.json();
-    const raw = data.message.content.trim();
     let violations = [];
     try {
       const parsed = JSON.parse(raw);
@@ -1121,6 +1337,7 @@ ${diffToSend}` }
       if (v.suggestion) console.log(chalk2.green("      Fix:    ") + v.suggestion);
       console.log();
     });
+    recordViolations2(violations);
     console.log(chalk2.dim('  Fix violations or run: memory-core remember "<lesson>"'));
     console.log();
   } catch (err) {
@@ -1134,22 +1351,20 @@ ${diffToSend}` }
 }
 async function startWatch(options = {}) {
   const cwd = process.cwd();
-  const config2 = loadConfig(cwd);
-  if (!config2) {
+  const config = loadConfig(cwd);
+  if (!config) {
     console.error(chalk2.red("\n  No .memory-core.json found. Run: memory-core init\n"));
     process.exit(1);
   }
-  const { rules } = getProfileRules(config2);
+  const { rules } = getProfileRules(config);
   if (rules.length === 0) {
     console.log(chalk2.yellow("\n  No architecture rules configured in .memory-core.json \u2014 nothing to watch.\n"));
     process.exit(0);
   }
   const watchPath = options.path ?? cwd;
-  const ollamaUrl = process.env.OLLAMA_URL ?? "http://localhost:11434";
-  const chatModel = await resolveModel2(ollamaUrl, process.env.OLLAMA_CHAT_MODEL ?? "llama3.2");
   console.log(chalk2.cyan("\n  archmind watch \u2014 real-time rule enforcement\n"));
   console.log(chalk2.dim(`  watching: ${watchPath}`));
-  console.log(chalk2.dim(`  model:    ${chatModel}`));
+  console.log(chalk2.dim(`  model:    ${getChatProviderLabel()}`));
   console.log(chalk2.dim(`  rules:    ${rules.length}`));
   console.log(chalk2.dim("  ctrl+c to stop\n"));
   const pending = /* @__PURE__ */ new Map();
@@ -1188,14 +1403,14 @@ async function startWatch(options = {}) {
         }
         return;
       }
-      await checkFile(filePath, cwd, config2, options.verbose ?? false);
+      await checkFile(filePath, cwd, config, options.verbose ?? false, options.debug ?? false);
     }, 300);
     pending.set(filePath, timer);
   };
   watcher.on("add", handle);
   watcher.on("change", handle);
   watcher.on("error", (err) => {
-    console.error(chalk2.red(`  watcher error: ${err.message}`));
+    console.error(chalk2.red(`  watcher error: ${err instanceof Error ? err.message : String(err)}`));
   });
   process.on("SIGINT", () => {
     console.log(chalk2.dim("\n\n  archmind watch stopped.\n"));
@@ -1207,7 +1422,7 @@ async function startWatch(options = {}) {
 
 // src/cli.ts
 function printBanner(projectName, agentCount, status) {
-  const pg2 = status ? status.postgresOk ? chalk3.green("  \u2713 PostgreSQL ") + chalk3.bold("connected") : chalk3.red("  \u2717 PostgreSQL ") + chalk3.bold("not connected \u2014 check DATABASE_URL") : chalk3.green("  \u2713 Memory    ") + chalk3.bold("PostgreSQL + pgvector ready");
+  const pg = status ? status.postgresOk ? chalk3.green("  \u2713 PostgreSQL ") + chalk3.bold("connected") : chalk3.red("  \u2717 PostgreSQL ") + chalk3.bold("not connected \u2014 check DATABASE_URL") : chalk3.green("  \u2713 Memory    ") + chalk3.bold("PostgreSQL + pgvector ready");
   const ol = status ? status.ollamaOk ? chalk3.green("  \u2713 Ollama    ") + chalk3.bold(`connected  (model: ${status.chatModel})`) : chalk3.red("  \u2717 Ollama    ") + chalk3.bold("not running \u2014 start with: ollama serve") : null;
   const lines = [
     "",
@@ -1222,7 +1437,7 @@ function printBanner(projectName, agentCount, status) {
     "",
     chalk3.green(`  \u2713 Project   `) + chalk3.bold(projectName),
     chalk3.green(`  \u2713 Agents    `) + chalk3.bold(`${agentCount} AI agents configured`),
-    pg2,
+    pg,
     ...ol ? [ol] : [],
     "",
     chalk3.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
@@ -1238,13 +1453,13 @@ function printBanner(projectName, agentCount, status) {
   ];
   lines.forEach((l) => console.log(l));
 }
-async function checkConnections(dbUrl, ollamaUrl, chatModel) {
+async function checkConnections(dbUrl, ollamaUrl2, chatModel) {
   const spinner = ora("Checking connections\u2026").start();
   let postgresOk = false;
   let ollamaOk = false;
   try {
-    const { Pool: Pool2 } = (await import("pg")).default;
-    const testPool = new Pool2({ connectionString: dbUrl, connectionTimeoutMillis: 5e3 });
+    const { Pool } = (await import("pg")).default;
+    const testPool = new Pool({ connectionString: dbUrl, connectionTimeoutMillis: 5e3 });
     await testPool.query("SELECT 1");
     await testPool.end();
     postgresOk = true;
@@ -1252,7 +1467,7 @@ async function checkConnections(dbUrl, ollamaUrl, chatModel) {
     postgresOk = false;
   }
   try {
-    const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+    const res = await fetch(`${ollamaUrl2}/api/tags`, { signal: AbortSignal.timeout(5e3) });
     ollamaOk = res.ok;
   } catch {
     ollamaOk = false;
@@ -1267,28 +1482,74 @@ async function checkConnections(dbUrl, ollamaUrl, chatModel) {
   console.log();
   return { postgresOk, ollamaOk, chatModel };
 }
-var { version } = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf-8"));
+var { version } = JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf-8"));
 var CONFIG_FILE = ".memory-core.json";
 function readProjectConfig() {
   const path = join6(process.cwd(), CONFIG_FILE);
   if (!existsSync6(path)) return null;
   try {
-    return JSON.parse(readFileSync5(path, "utf-8"));
+    return JSON.parse(readFileSync6(path, "utf-8"));
   } catch {
     return null;
   }
 }
-function writeProjectConfig(config2) {
-  writeFileSync3(join6(process.cwd(), CONFIG_FILE), JSON.stringify(config2, null, 2));
+function writeProjectConfig(config) {
+  writeFileSync5(join6(process.cwd(), CONFIG_FILE), JSON.stringify(config, null, 2));
+}
+function parseTags(tags) {
+  return tags ? tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+}
+function truncate(value, length) {
+  if (!value) return "";
+  return value.length > length ? `${value.slice(0, Math.max(0, length - 1))}\u2026` : value;
+}
+function printMemoryTable(memories, title = "Rules in memory") {
+  console.log(chalk3.bold(`
+  ${title} (${memories.length} total)
+`));
+  console.log(chalk3.dim("  ID   Type       Scope     Title / Content"));
+  console.log(chalk3.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  memories.forEach((memory) => {
+    const id = String(memory.id).padEnd(4);
+    const type = memory.type.padEnd(10);
+    const scope = memory.scope.padEnd(9);
+    const label = truncate(memory.title || memory.content, 64);
+    console.log(`  ${id} ${type} ${scope} ${label}`);
+  });
+  console.log(chalk3.gray("\n  Use: memory-core remove <id>  |  memory-core edit <id>\n"));
 }
 var program = new Command();
 program.name("memory-core").description("Universal AI memory core \u2014 generate AI context files for all coding agents").version(version);
-program.command("init").description("Initialize memory-core in the current project").action(async () => {
+program.command("init").description("Initialize memory-core in the current project").option("--quick", "Use smart defaults and skip optional prompts").action(async (opts) => {
   console.log(chalk3.bold.cyan("\n  memory-core init\n"));
   const detected = detectProject();
+  const quick = opts.quick ?? false;
   const envPath = join6(process.cwd(), ".memory-core.env");
   const hasEnv = existsSync6(envPath) || existsSync6(join6(process.cwd(), ".env")) || !!process.env.DATABASE_URL;
-  if (!hasEnv) {
+  if (!hasEnv && quick) {
+    const dbUser = process.env.USER ?? process.env.USERNAME ?? "postgres";
+    const dbUrl = `postgresql://${dbUser}@localhost:5432/memory_core`;
+    const ollamaUrl2 = "http://localhost:11434";
+    const chatModel = "llama3.2";
+    const envContent = [
+      `DATABASE_URL=${dbUrl}`,
+      `OLLAMA_URL=${ollamaUrl2}`,
+      `OLLAMA_MODEL=nomic-embed-text`,
+      `OLLAMA_CHAT_MODEL=${chatModel}`
+    ].join("\n") + "\n";
+    writeFileSync5(envPath, envContent);
+    process.env.DATABASE_URL = dbUrl;
+    process.env.OLLAMA_URL = ollamaUrl2;
+    process.env.OLLAMA_MODEL = "nomic-embed-text";
+    process.env.OLLAMA_CHAT_MODEL = chatModel;
+    const gitignorePath2 = join6(process.cwd(), ".gitignore");
+    const gitignore = existsSync6(gitignorePath2) ? readFileSync6(gitignorePath2, "utf-8") : "";
+    if (!gitignore.includes(".memory-core.env")) {
+      appendFileSync(gitignorePath2, `${gitignore ? "\n" : ""}.memory-core.env
+`);
+    }
+    console.log(chalk3.green("  \u2713 .memory-core.env created with local defaults"));
+  } else if (!hasEnv) {
     console.log(chalk3.dim("  No .memory-core.env found \u2014 let's set up your connection.\n"));
     const dbUser = process.env.USER ?? process.env.USERNAME ?? "postgres";
     let dbUrl = "";
@@ -1299,8 +1560,8 @@ program.command("init").description("Initialize memory-core in the current proje
       });
       const pgSpinner = ora("  Testing PostgreSQL connection\u2026").start();
       try {
-        const { Pool: Pool2 } = (await import("pg")).default;
-        const testPool = new Pool2({ connectionString: dbUrl, connectionTimeoutMillis: 5e3 });
+        const { Pool } = (await import("pg")).default;
+        const testPool = new Pool({ connectionString: dbUrl, connectionTimeoutMillis: 5e3 });
         await testPool.query("SELECT 1");
         await testPool.end();
         pgSpinner.succeed(chalk3.green("PostgreSQL connected"));
@@ -1310,15 +1571,15 @@ program.command("init").description("Initialize memory-core in the current proje
         console.log(chalk3.yellow("  Please check that PostgreSQL is running and the URL is correct.\n"));
       }
     }
-    let ollamaUrl = "";
+    let ollamaUrl2 = "";
     while (true) {
-      ollamaUrl = await input({
+      ollamaUrl2 = await input({
         message: "Ollama URL?",
-        default: ollamaUrl || "http://localhost:11434"
+        default: ollamaUrl2 || "http://localhost:11434"
       });
       const ollamaSpinner = ora("  Testing Ollama connection\u2026").start();
       try {
-        const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+        const res = await fetch(`${ollamaUrl2}/api/tags`, { signal: AbortSignal.timeout(5e3) });
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         ollamaSpinner.succeed(chalk3.green("Ollama connected"));
         break;
@@ -1327,69 +1588,117 @@ program.command("init").description("Initialize memory-core in the current proje
         console.log(chalk3.yellow("  Make sure Ollama is running: ollama serve\n"));
       }
     }
+    const chatProvider = await select({
+      message: "Which provider for code checking?",
+      choices: [
+        { name: "Local \u2014 Ollama (no API key, free)", value: "ollama" },
+        { name: "OpenAI \u2014 gpt-4o, gpt-4o-mini", value: "openai" },
+        { name: "Anthropic \u2014 claude-sonnet, claude-haiku", value: "anthropic" },
+        { name: "MiniMax \u2014 MiniMax-Text-01, abab6.5s-chat", value: "minimax" }
+      ]
+    });
     let chatModel = "";
-    while (true) {
-      const chatModelChoice = await select({
-        message: "Which Ollama model for code checking?",
-        choices: [
-          { name: "llama3.2        (fast, 2GB, recommended for most machines)", value: "llama3.2" },
-          { name: "qwen2.5-coder  (better code understanding, 4.7GB)", value: "qwen2.5-coder" },
-          { name: "mistral        (balanced, 4.1GB)", value: "mistral" },
-          { name: "codellama      (code-focused, 3.8GB)", value: "codellama" },
-          { name: "Other (enter manually)", value: "__custom__" }
-        ]
-      });
-      chatModel = chatModelChoice === "__custom__" ? await input({ message: "Model name?", default: "llama3.2" }) : chatModelChoice;
-      const modelSpinner = ora(`  Checking if ${chatModel} is installed\u2026`).start();
-      try {
-        const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
-        const data = await res.json();
-        const models = data.models ?? [];
-        const exact = models.find((m) => m.name === chatModel);
-        const prefixed = models.find((m) => m.name.startsWith(`${chatModel}:`));
-        const match = exact ?? prefixed;
-        if (match) {
-          chatModel = match.name;
-          modelSpinner.succeed(chalk3.green(`${chatModel} is installed and ready`));
-          break;
-        } else {
-          modelSpinner.fail(chalk3.red(`${chatModel} is not installed in your Ollama`));
-          console.log(chalk3.yellow(`  Run: ollama pull ${chatModel}    \u2014 or pick a different model.
+    let chatApiKey = "";
+    if (chatProvider === "ollama") {
+      while (true) {
+        const chatModelChoice = await select({
+          message: "Which Ollama model for code checking?",
+          choices: [
+            { name: "llama3.2        (fast, 2GB, recommended for most machines)", value: "llama3.2" },
+            { name: "qwen2.5-coder  (better code understanding, 4.7GB)", value: "qwen2.5-coder" },
+            { name: "mistral        (balanced, 4.1GB)", value: "mistral" },
+            { name: "codellama      (code-focused, 3.8GB)", value: "codellama" },
+            { name: "Other (enter manually)", value: "__custom__" }
+          ]
+        });
+        chatModel = chatModelChoice === "__custom__" ? await input({ message: "Model name?", default: "llama3.2" }) : chatModelChoice;
+        const modelSpinner = ora(`  Checking if ${chatModel} is installed\u2026`).start();
+        try {
+          const res = await fetch(`${ollamaUrl2}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+          const data = await res.json();
+          const models = data.models ?? [];
+          const exact = models.find((m) => m.name === chatModel);
+          const prefixed = models.find((m) => m.name.startsWith(`${chatModel}:`));
+          const match = exact ?? prefixed;
+          if (match) {
+            chatModel = match.name;
+            modelSpinner.succeed(chalk3.green(`${chatModel} is installed and ready`));
+            break;
+          } else {
+            modelSpinner.fail(chalk3.red(`${chatModel} is not installed in your Ollama`));
+            console.log(chalk3.yellow(`  Run: ollama pull ${chatModel}    \u2014 or pick a different model.
 `));
+          }
+        } catch {
+          modelSpinner.warn(chalk3.yellow("Could not verify model \u2014 continuing anyway"));
+          break;
         }
-      } catch {
-        modelSpinner.warn(chalk3.yellow("Could not verify model \u2014 continuing anyway"));
-        break;
       }
+    } else {
+      const modelChoices = {
+        openai: [
+          { name: "gpt-4o          (best accuracy)", value: "gpt-4o" },
+          { name: "gpt-4o-mini     (fast, cheaper)", value: "gpt-4o-mini" },
+          { name: "gpt-4-turbo     (powerful, slower)", value: "gpt-4-turbo" },
+          { name: "Other (enter manually)", value: "__custom__" }
+        ],
+        anthropic: [
+          { name: "claude-sonnet-4-5  (best accuracy)", value: "claude-sonnet-4-5-20251001" },
+          { name: "claude-haiku-4-5   (fast, cheaper)", value: "claude-haiku-4-5-20251001" },
+          { name: "Other (enter manually)", value: "__custom__" }
+        ],
+        minimax: [
+          { name: "MiniMax-Text-01  (flagship)", value: "MiniMax-Text-01" },
+          { name: "abab6.5s-chat    (fast, efficient)", value: "abab6.5s-chat" },
+          { name: "Other (enter manually)", value: "__custom__" }
+        ]
+      };
+      const modelChoice = await select({
+        message: `Which ${chatProvider} model?`,
+        choices: modelChoices[chatProvider]
+      });
+      chatModel = modelChoice === "__custom__" ? await input({ message: "Model name?" }) : modelChoice;
+      chatApiKey = await input({
+        message: `${chatProvider.charAt(0).toUpperCase() + chatProvider.slice(1)} API key?`
+      });
+      console.log(chalk3.green(`  \u2713 ${chatProvider} / ${chatModel} configured`));
     }
-    const envContent = [
+    const envLines = [
       `DATABASE_URL=${dbUrl}`,
-      `OLLAMA_URL=${ollamaUrl}`,
+      `OLLAMA_URL=${ollamaUrl2}`,
       `OLLAMA_MODEL=nomic-embed-text`,
-      `OLLAMA_CHAT_MODEL=${chatModel}`
-    ].join("\n") + "\n";
-    writeFileSync3(envPath, envContent);
+      `CHAT_PROVIDER=${chatProvider}`,
+      `CHAT_MODEL=${chatModel}`
+    ];
+    if (chatProvider === "ollama") envLines.push(`OLLAMA_CHAT_MODEL=${chatModel}`);
+    if (chatApiKey) envLines.push(`CHAT_API_KEY=${chatApiKey}`);
+    const envContent = envLines.join("\n") + "\n";
+    writeFileSync5(envPath, envContent);
     process.env.DATABASE_URL = dbUrl;
-    process.env.OLLAMA_URL = ollamaUrl;
+    process.env.OLLAMA_URL = ollamaUrl2;
     process.env.OLLAMA_MODEL = "nomic-embed-text";
-    process.env.OLLAMA_CHAT_MODEL = chatModel;
-    const gitignorePath = join6(process.cwd(), ".gitignore");
-    if (existsSync6(gitignorePath)) {
-      const gi = readFileSync5(gitignorePath, "utf-8");
+    process.env.CHAT_PROVIDER = chatProvider;
+    process.env.CHAT_MODEL = chatModel;
+    if (chatProvider === "ollama") process.env.OLLAMA_CHAT_MODEL = chatModel;
+    if (chatApiKey) process.env.CHAT_API_KEY = chatApiKey;
+    const gitignorePath2 = join6(process.cwd(), ".gitignore");
+    if (existsSync6(gitignorePath2)) {
+      const gi = readFileSync6(gitignorePath2, "utf-8");
       if (!gi.includes(".memory-core.env")) {
-        appendFileSync(gitignorePath, "\n.memory-core.env\n");
+        appendFileSync(gitignorePath2, "\n.memory-core.env\n");
       }
     } else {
-      writeFileSync3(gitignorePath, ".memory-core.env\n");
+      writeFileSync5(gitignorePath2, ".memory-core.env\n");
     }
     console.log(chalk3.green("\n  \u2713 .memory-core.env created"));
     console.log(chalk3.gray("    Added to .gitignore \u2014 your DB credentials stay local.\n"));
   }
-  const projectName = await input({
+  const projectName = quick ? process.cwd().split("/").pop() ?? "my-project" : await input({
     message: "Project name?",
     default: process.cwd().split("/").pop() ?? "my-project"
   });
-  const projectType = await select({
+  const inferredProjectType = ["Next.js", "Nuxt.js"].includes(detected.framework) ? "fullstack" : ["React", "Vue.js", "Svelte"].includes(detected.framework) ? "frontend" : "backend";
+  const projectType = quick ? inferredProjectType : await select({
     message: "Project type?",
     choices: [
       { value: "backend", name: "Backend    \u2014 API, server, microservice" },
@@ -1399,35 +1708,50 @@ program.command("init").description("Initialize memory-core in the current proje
   });
   let backendArchitecture;
   if (projectType === "backend" || projectType === "fullstack") {
-    const backendProfiles = listProfiles("backend");
-    backendArchitecture = await select({
-      message: "Backend architecture?",
-      choices: backendProfiles.map((p) => ({
-        value: p.name,
-        name: `${p.displayName} \u2014 ${p.description}`
-      }))
-    });
+    if (quick) {
+      backendArchitecture = detected.framework === "NestJS" ? "nestjs" : detected.framework === "Laravel" ? "laravel-service-repository" : "clean-architecture";
+    } else {
+      const backendProfiles = listProfiles("backend");
+      backendArchitecture = await select({
+        message: "Backend architecture?",
+        choices: backendProfiles.map((p) => ({
+          value: p.name,
+          name: `${p.displayName} \u2014 ${p.description}`
+        }))
+      });
+    }
   }
   let frontendFramework;
   if (projectType === "frontend" || projectType === "fullstack") {
-    const frontendProfiles = listProfiles("frontend");
-    frontendFramework = await select({
-      message: "Frontend framework?",
-      choices: frontendProfiles.map((p) => ({
-        value: p.name,
-        name: `${p.displayName} \u2014 ${p.description}`
-      }))
-    });
+    if (quick) {
+      const frameworkMap = {
+        "Next.js": "nextjs",
+        "Nuxt.js": "nuxt",
+        React: "react",
+        "Vue.js": "vue",
+        Svelte: "svelte"
+      };
+      frontendFramework = frameworkMap[detected.framework] ?? "react";
+    } else {
+      const frontendProfiles = listProfiles("frontend");
+      frontendFramework = await select({
+        message: "Frontend framework?",
+        choices: frontendProfiles.map((p) => ({
+          value: p.name,
+          name: `${p.displayName} \u2014 ${p.description}`
+        }))
+      });
+    }
   }
-  const language = await input({
+  const language = quick ? detected.language : await input({
     message: "Language?",
     default: detected.language
   });
-  const pullMemories = await confirm({
+  const pullMemories = quick ? true : await confirm({
     message: "Pull relevant memories from previous projects?",
     default: true
   });
-  const installCaveman = await confirm({
+  const installCaveman = quick ? false : await confirm({
     message: "Install caveman token saver? (~65-75% fewer tokens)",
     default: false
   });
@@ -1442,17 +1766,30 @@ program.command("init").description("Initialize memory-core in the current proje
       ]
     });
   }
-  const { checkbox } = await import("@inquirer/prompts");
-  const selectedAgents = await checkbox({
-    message: "Which AI agents do you want to generate files for?",
-    choices: AGENT_NAMES.filter((a) => a !== "Shared").map((name) => ({ name, value: name, checked: true })),
-    instructions: "  (Space to toggle, A to select all, Enter to confirm)"
-  });
-  const enableHook = await confirm({
-    message: "Enable pre-commit hook? (blocks commits that violate your rules)",
+  const selectedAgents = quick ? AGENT_NAMES.filter((a) => a !== "Shared") : await (async () => {
+    const { checkbox } = await import("@inquirer/prompts");
+    return checkbox({
+      message: "Which AI agents do you want to generate files for?",
+      choices: AGENT_NAMES.filter((a) => a !== "Shared").map((name) => ({ name, value: name, checked: true })),
+      instructions: "  (Space to toggle, A to select all, Enter to confirm)"
+    });
+  })();
+  const enableHook = quick ? true : await confirm({
+    message: "Enable pre-commit hook?",
     default: true
   });
-  const config2 = {
+  let hookAdvisory = true;
+  if (enableHook && !quick) {
+    const { select: selectMode } = await import("@inquirer/prompts");
+    hookAdvisory = await selectMode({
+      message: "Hook mode?",
+      choices: [
+        { value: true, name: "Advisory \u2014 logs violations, never blocks commits (recommended)" },
+        { value: false, name: "Strict   \u2014 blocks commits that violate your rules" }
+      ]
+    });
+  }
+  const config = {
     projectName,
     projectType,
     backendArchitecture,
@@ -1475,7 +1812,7 @@ program.command("init").description("Initialize memory-core in the current proje
   if (installCaveman) {
     const spinner2 = ora("Installing caveman token saver\u2026").start();
     try {
-      execSync3(
+      execSync2(
         "curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash",
         { stdio: "pipe", cwd: process.cwd() }
       );
@@ -1486,31 +1823,42 @@ program.command("init").description("Initialize memory-core in the current proje
   }
   const spinner = ora("Generating AI agent context files\u2026").start();
   const written = await generate(
-    { projectName, projectType, backendArchitecture, frontendFramework, language, memories, caveman: config2.caveman },
+    { projectName, projectType, backendArchitecture, frontendFramework, language, memories, caveman: config.caveman },
     process.cwd(),
     [...selectedAgents, "Shared"]
   );
-  writeProjectConfig(config2);
+  writeProjectConfig(config);
   spinner.succeed(`Generated ${written.written.length} files`);
+  const gitignorePath = join6(process.cwd(), ".gitignore");
+  const generatedPaths = written.written;
+  if (generatedPaths.length > 0) {
+    const existing = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
+    const toAdd = generatedPaths.filter((p) => !existing.includes(p));
+    if (toAdd.length > 0) {
+      const block = "\n# memory-core generated files\n" + toAdd.join("\n") + "\n";
+      appendFileSync(gitignorePath, block);
+      console.log(chalk3.green(`  \u2713 Added ${toAdd.length} generated files to .gitignore`));
+    }
+  }
   if (enableHook) {
-    installHook();
+    installHook(hookAdvisory);
   }
   const status = await checkConnections(
     process.env.DATABASE_URL ?? "",
     process.env.OLLAMA_URL ?? "http://localhost:11434",
     process.env.OLLAMA_CHAT_MODEL ?? "llama3.2"
   );
-  printBanner(config2.projectName, written.written.length, status);
+  printBanner(config.projectName, written.written.length, status);
   await closePool();
 });
 program.command("sync").description("Re-pull memories and regenerate AI agent files").action(async () => {
-  const config2 = readProjectConfig();
-  if (!config2) {
+  const config = readProjectConfig();
+  if (!config) {
     console.error(chalk3.red("No .memory-core.json found. Run: memory-core init"));
     process.exit(1);
   }
   const { checkbox } = await import("@inquirer/prompts");
-  const savedAgents = new Set(config2.agents ?? AGENT_NAMES.filter((a) => a !== "Shared"));
+  const savedAgents = new Set(config.agents ?? AGENT_NAMES.filter((a) => a !== "Shared"));
   const selectedAgents = await checkbox({
     message: "Which agents do you want to sync?",
     choices: AGENT_NAMES.filter((a) => a !== "Shared").map((name) => ({
@@ -1527,21 +1875,21 @@ program.command("sync").description("Re-pull memories and regenerate AI agent fi
   const spinner = ora("Syncing memories\u2026").start();
   let memories = [];
   try {
-    const archQuery = [config2.backendArchitecture, config2.frontendFramework, config2.language].filter(Boolean).join(" ");
-    memories = await retrieve(archQuery, config2.backendArchitecture ?? config2.frontendFramework, 10);
+    const archQuery = [config.backendArchitecture, config.frontendFramework, config.language].filter(Boolean).join(" ");
+    memories = await retrieve(archQuery, config.backendArchitecture ?? config.frontendFramework, 10);
     spinner.text = `Found ${memories.length} memories \u2014 regenerating files\u2026`;
   } catch (err) {
     spinner.warn(`Could not retrieve memories: ${err.message}`);
   }
   const result = await generate(
     {
-      projectName: config2.projectName,
-      projectType: config2.projectType,
-      backendArchitecture: config2.backendArchitecture,
-      frontendFramework: config2.frontendFramework,
-      language: config2.language,
+      projectName: config.projectName,
+      projectType: config.projectType,
+      backendArchitecture: config.backendArchitecture,
+      frontendFramework: config.frontendFramework,
+      language: config.language,
       memories,
-      caveman: config2.caveman
+      caveman: config.caveman
     },
     process.cwd(),
     [...selectedAgents, "Shared"]
@@ -1557,7 +1905,7 @@ program.command("sync").description("Re-pull memories and regenerate AI agent fi
   await closePool();
 });
 program.command("remember <text>").description("Save a new memory to the central database").option("-t, --type <type>", "Memory type (decision|rule|pattern|note)", "decision").option("-s, --scope <scope>", "Scope (global|project)", "project").option("--tags <tags>", "Comma-separated tags").option("-r, --reason <reason>", "Why this rule exists \u2014 helps agents understand intent and debug violations").action(async (text, opts) => {
-  const config2 = readProjectConfig();
+  const config = readProjectConfig();
   let reason = opts.reason;
   if (!reason) {
     reason = await input({
@@ -1571,8 +1919,8 @@ program.command("remember <text>").description("Save a new memory to the central
     await saveMemory({
       type: opts.type,
       scope: opts.scope,
-      architecture: config2?.backendArchitecture ?? config2?.frontendFramework,
-      projectName: config2?.projectName,
+      architecture: config?.backendArchitecture ?? config?.frontendFramework,
+      projectName: config?.projectName,
       content: text,
       reason: reason || void 0,
       tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : [],
@@ -1588,12 +1936,12 @@ program.command("remember <text>").description("Save a new memory to the central
   await closePool();
 });
 program.command("search <query>").description("Search memories using semantic similarity").option("-n, --limit <n>", "Number of results", "5").action(async (query, opts) => {
-  const config2 = readProjectConfig();
+  const config = readProjectConfig();
   const spinner = ora("Searching\u2026").start();
   try {
     const results = await retrieve(
       query,
-      config2?.backendArchitecture ?? config2?.frontendFramework,
+      config?.backendArchitecture ?? config?.frontendFramework,
       parseInt(opts.limit, 10)
     );
     spinner.stop();
@@ -1617,6 +1965,222 @@ program.command("search <query>").description("Search memories using semantic si
   }
   await closePool();
 });
+program.command("export").description(`Export DB memories to ${MEMORY_FILE}`).option("-o, --output <file>", `Output file (default: ${MEMORY_FILE})`).action(async (opts) => {
+  const spinner = ora("Exporting memories\u2026").start();
+  try {
+    const memories = await listMemories({ limit: 1e4 });
+    const portable = memories.map(toPortableMemory);
+    const outputPath = opts.output ? join6(process.cwd(), opts.output) : writeMemoryFile(portable);
+    if (opts.output) {
+      writeFileSync5(outputPath, JSON.stringify(portable, null, 2) + "\n", "utf-8");
+    }
+    spinner.succeed(`Exported ${portable.length} memories to ${outputPath}`);
+  } catch (err) {
+    spinner.fail(`Export failed: ${err.message}`);
+    process.exit(1);
+  } finally {
+    await closePool();
+  }
+});
+program.command("import").description(`Import memories from ${MEMORY_FILE}`).option("--url <url>", "Import memories from a remote URL").option("-f, --file <file>", `Import file (default: ${MEMORY_FILE})`).action(async (opts) => {
+  const spinner = ora("Reading memories\u2026").start();
+  try {
+    const memories = opts.url ? await readMemoryFileFromUrl(opts.url) : opts.file ? parseMemoryFile(readFileSync6(join6(process.cwd(), opts.file), "utf-8")) : readMemoryFile();
+    let inserted = 0;
+    let skipped = 0;
+    spinner.text = `Importing ${memories.length} memories\u2026`;
+    for (const memory of memories) {
+      const embedding = await embed(memory.content);
+      const result = await upsertMemory({
+        type: memory.type,
+        scope: memory.scope,
+        architecture: memory.architecture,
+        projectName: memory.projectName,
+        title: memory.title,
+        content: memory.content,
+        reason: memory.reason,
+        tags: memory.tags,
+        embedding
+      });
+      if (result === "inserted") inserted++;
+      else skipped++;
+    }
+    spinner.succeed(`Imported ${inserted} memories, skipped ${skipped} duplicates`);
+  } catch (err) {
+    spinner.fail(`Import failed: ${err.message}`);
+    process.exit(1);
+  } finally {
+    await closePool();
+  }
+});
+program.command("list").description("List memories from the local database").option("--type <type>", "Filter by type").option("--scope <scope>", "Filter by scope").option("--arch <architecture>", "Filter by architecture").option("-n, --limit <n>", "Maximum rows to show", "200").action(async (opts) => {
+  try {
+    const memories = await listMemories({
+      type: opts.type,
+      scope: opts.scope,
+      architecture: opts.arch,
+      limit: parseInt(opts.limit, 10)
+    });
+    printMemoryTable(memories);
+  } catch (err) {
+    console.error(chalk3.red(`List failed: ${err.message}`));
+    process.exit(1);
+  } finally {
+    await closePool();
+  }
+});
+program.command("remove <id>").description("Remove a memory by ID").action(async (id) => {
+  try {
+    const deleted = await deleteMemory(parseInt(id, 10));
+    if (!deleted) {
+      console.log(chalk3.yellow(`No memory found with ID ${id}`));
+      process.exit(1);
+    }
+    console.log(chalk3.green(`Removed memory ${id}`));
+  } catch (err) {
+    console.error(chalk3.red(`Remove failed: ${err.message}`));
+    process.exit(1);
+  } finally {
+    await closePool();
+  }
+});
+program.command("edit <id>").description("Edit a memory interactively").action(async (id) => {
+  const memoryId = parseInt(id, 10);
+  try {
+    const existing = await getMemory(memoryId);
+    if (!existing) {
+      console.log(chalk3.yellow(`No memory found with ID ${id}`));
+      process.exit(1);
+    }
+    const type = await input({ message: "Type?", default: existing.type });
+    const scope = await input({ message: "Scope?", default: existing.scope });
+    const title = await input({ message: "Title?", default: existing.title ?? "" });
+    const content = await input({ message: "Content?", default: existing.content });
+    const reason = await input({ message: "Reason?", default: existing.reason ?? "" });
+    const tags = await input({ message: "Tags?", default: existing.tags.join(",") });
+    const embedding = content === existing.content ? void 0 : await embed(content);
+    await updateMemory(memoryId, {
+      type,
+      scope,
+      title: title || void 0,
+      content,
+      reason: reason || void 0,
+      tags: parseTags(tags),
+      embedding
+    });
+    console.log(chalk3.green(`Updated memory ${id}`));
+  } catch (err) {
+    console.error(chalk3.red(`Edit failed: ${err.message}`));
+    process.exit(1);
+  } finally {
+    await closePool();
+  }
+});
+program.command("ignore [pattern]").description("Manage project-scoped false-positive ignore patterns").option("--list", "List ignored patterns").option("--remove <id>", "Remove an ignored pattern by ID").action(async (pattern, opts) => {
+  try {
+    if (opts.list) {
+      printMemoryTable(await listMemories({ type: "ignore", limit: 1e3 }), "Ignored patterns");
+      return;
+    }
+    if (opts.remove) {
+      const deleted = await deleteMemory(parseInt(opts.remove, 10));
+      if (!deleted) {
+        console.log(chalk3.yellow(`No ignore pattern found with ID ${opts.remove}`));
+        process.exit(1);
+      }
+      console.log(chalk3.green(`Removed ignore pattern ${opts.remove}`));
+      return;
+    }
+    if (!pattern) {
+      console.error(chalk3.red("Provide a pattern, --list, or --remove <id>"));
+      process.exit(1);
+    }
+    const config = readProjectConfig();
+    const embedding = await embed(pattern);
+    await upsertMemory({
+      type: "ignore",
+      scope: "project",
+      architecture: config?.backendArchitecture ?? config?.frontendFramework,
+      projectName: config?.projectName,
+      content: pattern,
+      tags: ["ignore"],
+      embedding
+    });
+    console.log(chalk3.green(`Ignored pattern saved: "${pattern}"`));
+  } catch (err) {
+    console.error(chalk3.red(`Ignore failed: ${err.message}`));
+    process.exit(1);
+  } finally {
+    await closePool();
+  }
+});
+program.command("ci-setup").description("Generate GitHub Actions workflow for memory-core").action(() => {
+  const workflowPath = join6(process.cwd(), ".github", "workflows", "memory-core.yml");
+  mkdirSync2(dirname2(workflowPath), { recursive: true });
+  writeFileSync5(workflowPath, `name: memory-core
+on: [pull_request]
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - run: npx @shahmilsaari/memory-core check --ci
+`, "utf-8");
+  console.log(chalk3.green(`Generated ${workflowPath}`));
+});
+program.command("reset").description("Remove memory-core generated files and local project config").option("--soft", "Only remove generated files; keep config and DB").option("--db", "Also drop the memories table after confirmation").action(async (opts) => {
+  const generated = [...new Set(OUTPUT_FILES.map((file) => file.path))];
+  let removed = 0;
+  for (const relativePath of generated) {
+    const target = join6(process.cwd(), relativePath);
+    if (existsSync6(target)) {
+      rmSync(target, { force: true });
+      removed++;
+    }
+  }
+  if (!opts.soft) {
+    const configPath = join6(process.cwd(), CONFIG_FILE);
+    if (existsSync6(configPath)) {
+      unlinkSync2(configPath);
+      removed++;
+    }
+    uninstallHook();
+  }
+  if (opts.db) {
+    const ok = await confirm({
+      message: "Drop the memories table from the configured database?",
+      default: false
+    });
+    if (ok) {
+      const { getPool } = await import("./db-KU4EEG4Y.js");
+      await getPool().query("DROP TABLE IF EXISTS memories");
+      await closePool();
+      console.log(chalk3.yellow("Dropped memories table"));
+    }
+  }
+  console.log(chalk3.green(`Reset complete. Removed ${removed} files.`));
+});
+program.command("stats").description("Show violation counters recorded by check and watch").action(() => {
+  const statsPath = join6(process.cwd(), ".memory-core-stats.json");
+  if (!existsSync6(statsPath)) {
+    console.log(chalk3.yellow("\n  No violation stats recorded yet.\n"));
+    return;
+  }
+  const stats = JSON.parse(readFileSync6(statsPath, "utf-8"));
+  const printTop = (label, values = {}) => {
+    console.log(chalk3.bold(`
+  ${label}
+`));
+    Object.entries(values).sort((a, b) => b[1] - a[1]).slice(0, 10).forEach(([name, count], index) => {
+      console.log(`  ${index + 1}. ${truncate(name, 44).padEnd(46)} ${count}`);
+    });
+  };
+  printTop("Top rules", stats.rules);
+  printTop("Top files", stats.files);
+  console.log();
+});
 program.command("seed").description("Load all predefined memories into the database").option("--arch <architecture>", "Only seed a specific architecture (e.g. clean-architecture)").option("--force", "Re-seed even if memories already exist", false).action(async (opts) => {
   await runMigrations();
   const filtered = opts.arch ? seeds.filter((s) => s.architecture === opts.arch || s.architecture === "global") : seeds;
@@ -1629,7 +2193,7 @@ program.command("seed").description("Load all predefined memories into the datab
     const spinner = ora(`[${seed.architecture}] ${seed.title}`).start();
     try {
       const embedding = await embed(seed.content);
-      await saveMemory({
+      const payload = {
         type: seed.type,
         scope: seed.scope,
         architecture: seed.architecture === "global" ? void 0 : seed.architecture,
@@ -1638,9 +2202,21 @@ program.command("seed").description("Load all predefined memories into the datab
         reason: seed.reason,
         tags: seed.tags,
         embedding
-      });
-      spinner.succeed(chalk3.gray(`[${seed.architecture}] ${seed.title}`));
-      saved++;
+      };
+      if (opts.force) {
+        await saveMemory(payload);
+        saved++;
+        spinner.succeed(chalk3.gray(`[${seed.architecture}] ${seed.title}`));
+      } else {
+        const result = await upsertMemory(payload);
+        if (result === "inserted") {
+          saved++;
+          spinner.succeed(chalk3.gray(`[${seed.architecture}] ${seed.title}`));
+        } else {
+          skipped++;
+          spinner.info(chalk3.gray(`Already exists \u2014 [${seed.architecture}] ${seed.title}`));
+        }
+      }
     } catch (err) {
       spinner.warn(`Skipped \u2014 ${err.message}`);
       skipped++;
@@ -1694,12 +2270,12 @@ ${rulesText}
   const skipped = [];
   const writeFile2 = (filePath, content) => {
     mkdirSync2(dirname2(filePath), { recursive: true });
-    writeFileSync3(filePath, content, "utf-8");
+    writeFileSync5(filePath, content, "utf-8");
   };
   const readJson = (filePath) => {
     if (!existsSync6(filePath)) return {};
     try {
-      return JSON.parse(readFileSync5(filePath, "utf-8"));
+      return JSON.parse(readFileSync6(filePath, "utf-8"));
     } catch {
       return {};
     }
@@ -1724,9 +2300,9 @@ ${rulesText}
         writeFile2(target.path, JSON.stringify(processedVscode.settings, null, 2));
         written.push(target.label);
       } else if (target.type === "continue") {
-        const config2 = readJson(target.path);
-        config2["systemMessage"] = systemPrompt;
-        writeFile2(target.path, JSON.stringify(config2, null, 2));
+        const config = readJson(target.path);
+        config["systemMessage"] = systemPrompt;
+        writeFile2(target.path, JSON.stringify(config, null, 2));
         written.push(target.label);
       } else if (target.type === "aider") {
         const aiderContent = `# Aider global config \u2014 synced by memory-core
@@ -1736,11 +2312,11 @@ read:
         writeFile2(target.path, aiderContent);
         written.push(target.label);
       } else if (target.type === "zed") {
-        const config2 = readJson(target.path);
-        const assistant = config2["assistant"] ?? {};
+        const config = readJson(target.path);
+        const assistant = config["assistant"] ?? {};
         assistant["system_prompt"] = systemPrompt;
-        config2["assistant"] = assistant;
-        writeFile2(target.path, JSON.stringify(config2, null, 2));
+        config["assistant"] = assistant;
+        writeFile2(target.path, JSON.stringify(config, null, 2));
         written.push(target.label);
       }
     } catch {
@@ -1758,16 +2334,21 @@ read:
   await closePool();
 });
 var hook = program.command("hook").description("Manage the pre-commit rule enforcement hook");
-hook.command("install").description("Install pre-commit hook \u2014 blocks commits that violate your architecture rules").action(() => {
-  installHook();
+hook.command("install").description("Install pre-commit hook (advisory mode by default \u2014 logs violations, never blocks)").option("--advisory", "Log violations but never block commits (default)").option("--strict", "Block commits that violate your rules").action((opts) => {
+  const advisory = opts.strict ? false : true;
+  installHook(advisory);
 });
 hook.command("uninstall").description("Remove the pre-commit hook").action(() => {
   uninstallHook();
 });
-program.command("check").description("Check staged changes against architecture rules (used by pre-commit hook)").option("--staged", "Check git staged diff (default behaviour)").option("--verbose", "Show model and diff details").action(async (opts) => {
-  await checkStaged({ verbose: opts.verbose ?? false });
+program.command("check").description("Check staged changes against architecture rules (used by pre-commit hook)").option("--staged", "Check git staged diff (default behaviour)").option("--ci", `Check CI diff using ${MEMORY_FILE}`).option("--verbose", "Show model and diff details").option("--debug", "Show prompt, diff, and raw model response").action(async (opts) => {
+  if (opts.ci) {
+    await checkCi({ verbose: opts.verbose ?? false, debug: opts.debug ?? false });
+    return;
+  }
+  await checkStaged({ verbose: opts.verbose ?? false, debug: opts.debug ?? false });
 });
-program.command("watch").description("Watch source files and check violations in real-time on every save").option("--path <dir>", "Directory to watch (default: current directory)").option("--verbose", "Show diff size and model details per file").action((opts) => {
-  startWatch({ path: opts.path, verbose: opts.verbose });
+program.command("watch").description("Watch source files and check violations in real-time on every save").option("--path <dir>", "Directory to watch (default: current directory)").option("--verbose", "Show diff size and model details per file").option("--debug", "Show prompt, diff, and raw model response").action((opts) => {
+  startWatch({ path: opts.path, verbose: opts.verbose, debug: opts.debug });
 });
 program.parseAsync(process.argv);