@shahmilsaari/memory-core 0.2.8 → 0.2.11

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";
@@ -317,30 +332,34 @@ var seeds = [
   { type: "rule", scope: "global", architecture: "hexagonal", title: "Port naming convention", content: "Name ports as I + [Action] + [Resource]: ICreateUser, IFindOrderById, ISendEmail. Adapters use the technology name: PostgresCreateUser, StripeCharge.", tags: ["naming", "ports", "hexagonal"] },
   { type: "decision", scope: "global", architecture: "hexagonal", title: "Test core without infrastructure", content: "Core unit tests run in milliseconds with no DB or network. Integration tests add adapters one at a time. E2E tests use real infrastructure.", tags: ["testing", "hexagonal"] },
   // ══════════════════════════════════════════════════════════════════════════
-  // NEXT.JS APP ROUTER
+  // GO REST API
   // ══════════════════════════════════════════════════════════════════════════
-  // ── Rendering Strategy ───────────────────────────────────────────────────
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Server Components by default", content: 'Every component is a Server Component unless it requires interactivity (onClick, useState, useEffect). Add "use client" only when necessary, as low in the tree as possible.', tags: ["server-components", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Fetch in Server Components", content: "Fetch data directly in async Server Components. Never use useEffect, SWR, or React Query for initial server-side data. Client-side fetching is for user-triggered updates only.", tags: ["data-fetching", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Server Actions for mutations", content: "All form submissions and data mutations use Server Actions. API routes are only for third-party webhooks or browser clients that cannot use Server Actions.", tags: ["server-actions", "mutations", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Static by default, dynamic when needed", content: 'Pages are statically rendered unless they use cookies(), headers(), or searchParams. Opt into dynamic rendering explicitly with export const dynamic = "force-dynamic".', tags: ["rendering", "performance", "nextjs"] },
-  { type: "pattern", scope: "global", architecture: "nextjs", title: "Suspense boundaries for streaming", content: "Wrap slow data-fetching sections in <Suspense fallback={<Skeleton />}>. This enables streaming and progressive hydration. Do not block the entire page on one slow query.", tags: ["suspense", "streaming", "nextjs"] },
-  { type: "pattern", scope: "global", architecture: "nextjs", title: "Parallel data fetching", content: "Use Promise.all() for independent data fetches in the same Server Component. Sequential awaits in a single component waterfall unnecessarily.", tags: ["performance", "data-fetching", "nextjs"] },
-  // ── Structure ─────────────────────────────────────────────────────────────
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Thin page.tsx files", content: "page.tsx fetches data and passes it to a feature component. No JSX logic, no conditionals, no business logic in page files.", tags: ["structure", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Colocate by route", content: "Components used only by one route live next to that route. Components used across 3+ routes move to src/components/. Utils used across routes go to src/lib/.", tags: ["structure", "colocation", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Route groups for organization", content: "Use (groupName) folders to organize routes without affecting URLs. Group by concern: (marketing), (dashboard), (auth). Each group can have its own layout.", tags: ["route-groups", "structure", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "loading.tsx and error.tsx always", content: "Every dynamic route segment must have a loading.tsx (Suspense fallback) and error.tsx (error boundary). Never let routes fail or hang without user feedback.", tags: ["loading", "error-handling", "nextjs"] },
-  // ── Security & Config ────────────────────────────────────────────────────
-  { type: "rule", scope: "global", architecture: "nextjs", title: "No secrets in NEXT_PUBLIC_", content: "NEXT_PUBLIC_ variables are embedded in the client bundle. Never put API keys, tokens, or DB credentials there. Server-only secrets stay in Server Components and Actions.", tags: ["security", "env", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Auth in middleware.ts", content: "Route protection and session validation happens in middleware.ts at the edge. Never rely on page-level checks as the only auth guard.", tags: ["auth", "middleware", "security", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Validate Server Action inputs", content: "Always validate and sanitize inputs inside Server Actions using zod or similar. Server Actions are public endpoints \u2014 treat them like API routes.", tags: ["validation", "server-actions", "security", "nextjs"] },
-  // ── Performance ──────────────────────────────────────────────────────────
-  { type: "rule", scope: "global", architecture: "nextjs", title: "next/image for all images", content: "Use next/image for all images. It provides automatic WebP conversion, lazy loading, and size optimization. Never use raw <img> tags.", tags: ["performance", "images", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "next/font for typography", content: "Use next/font for fonts. It eliminates layout shift, self-hosts, and applies font-display: swap automatically. Never load fonts from Google Fonts CDN directly.", tags: ["performance", "fonts", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Cache fetch calls with tags", content: 'Tag fetch() calls with cache tags: fetch(url, { next: { tags: ["products"] } }). Revalidate by tag on mutation with revalidateTag("products").', tags: ["caching", "performance", "nextjs"] },
-  { type: "pattern", scope: "global", architecture: "nextjs", title: "ISR for semi-static pages", content: "Use Incremental Static Regeneration for pages that change infrequently: export const revalidate = 3600. Combine with revalidatePath() on writes.", tags: ["isr", "performance", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Metadata API for SEO", content: "Define page metadata using the Metadata API (export const metadata) or generateMetadata(). Never use next/head or raw <Head> in App Router.", tags: ["seo", "metadata", "nextjs"] },
+  // ── Package Structure ────────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "cmd/internal/pkg layout", content: "Organize code into cmd/ (main packages), internal/ (private app code), pkg/ (reusable public packages). cmd/api/main.go is the only entry point. Never put business logic in main.go.", tags: ["structure", "packages", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Thin HTTP handlers", content: "Handlers parse the request, call a service method, and write the response. No business logic, no DB calls, no conditional branching beyond input validation in handlers.", tags: ["handler", "structure", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Service layer owns business logic", content: "Services accept and return domain types, not http.Request or http.ResponseWriter. Services are fully testable without starting an HTTP server.", tags: ["service", "business-logic", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Repository layer for data access", content: "All database calls live in a repository layer. Services depend on repository interfaces, never on database drivers (database/sql, pgx, gorm) directly.", tags: ["repository", "database", "go"] },
+  // ── Error Handling ───────────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Always return errors explicitly", content: "Return errors as the last return value. Never use panic in library, service, or handler code. Reserve panic only for unrecoverable failures at startup (e.g., missing config).", tags: ["error-handling", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Wrap errors with context", content: 'Wrap errors at each layer boundary: fmt.Errorf("createUser: %w", err). This preserves the original error for errors.Is/errors.As and adds context to stack traces.', tags: ["error-handling", "wrapping", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Never ignore returned errors", content: "Every returned error must be handled or explicitly discarded with a comment. Silently assigning to _ hides bugs. Lint with errcheck to enforce this.", tags: ["error-handling", "go"] },
+  { type: "pattern", scope: "global", architecture: "go-api", title: "Sentinel errors for known cases", content: 'Define sentinel errors (var ErrNotFound = errors.New("not found")) for expected failure cases. Callers use errors.Is() to check. Never compare error strings.', tags: ["error-handling", "sentinel", "go"] },
+  // ── Interfaces & Types ───────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Small interfaces at the point of use", content: "Define interfaces where they are consumed, not where implementations live. Prefer single-method interfaces. A 10-method interface is a sign the consumer needs too much.", tags: ["interfaces", "design", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Request/response structs for all handlers", content: "Define explicit request and response structs for every handler. Never bind directly to domain models. This decouples API shape from internal representation.", tags: ["dto", "handler", "go"] },
+  // ── Context & Concurrency ────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "context.Context as first parameter", content: "Every function that may block, make a network call, or query a database accepts context.Context as its first parameter. Never store Context in a struct.", tags: ["context", "concurrency", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Graceful shutdown", content: "Catch SIGINT and SIGTERM via signal.NotifyContext. Call server.Shutdown(ctx) to drain in-flight requests before exiting. Never call os.Exit(1) directly in the server loop.", tags: ["shutdown", "reliability", "go"] },
+  // ── Configuration & Logging ──────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Config struct loaded at startup", content: "Read all configuration from environment variables into a validated Config struct in main.go before starting the server. Fail fast on missing required values. Never read env vars inside handlers or services.", tags: ["config", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Structured logging only", content: "Use slog (stdlib) or zerolog for all logging. Log with key-value fields, not format strings. Never use fmt.Println or log.Printf in production paths.", tags: ["logging", "observability", "go"] },
+  // ── Testing ──────────────────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Table-driven tests", content: "Write unit tests as table-driven tests using t.Run(). Each test case has a name, input, and expected output. This keeps tests readable and easy to extend.", tags: ["testing", "go"] },
+  { type: "pattern", scope: "global", architecture: "go-api", title: "Test handlers with httptest", content: "Test HTTP handlers using httptest.NewRecorder() and httptest.NewRequest(). Never spin up a real server in unit tests.", tags: ["testing", "handler", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Mock with interfaces, not libraries", content: "Inject mock implementations via interfaces rather than using reflection-based mock libraries. Write mocks by hand or use mockery \u2014 keep them simple.", tags: ["testing", "mocking", "go"] },
+  // ── Middleware & Security ────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Middleware registered at router level", content: "Register all middleware (auth, logging, CORS, recovery) at the router, not inside individual handlers. Middleware wraps the handler chain \u2014 it should never be called manually.", tags: ["middleware", "structure", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Validate all incoming data", content: "Validate and sanitize all request inputs before passing to the service layer. Return 400 Bad Request with a structured error body for invalid input. Never trust client data.", tags: ["validation", "security", "go"] },
   // ══════════════════════════════════════════════════════════════════════════
   // LARAVEL SERVICE REPOSITORY
   // ══════════════════════════════════════════════════════════════════════════
@@ -535,109 +554,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,20 +561,17 @@ 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 {};
     }
   };
-  if (has("next.config.js") || has("next.config.ts") || has("next.config.mjs")) {
-    return { language: "TypeScript", framework: "Next.js" };
-  }
   if (has("artisan") && has("composer.json")) {
     return { language: "PHP", framework: "Laravel" };
   }
@@ -667,7 +580,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,24 +620,172 @@ 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);
+  }
+  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 chatModel;
+  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])
 );
@@ -745,6 +806,63 @@ else
 fi
 `;
 }
+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"));
@@ -752,19 +870,19 @@ function installHook(advisory = true) {
   }
   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)) {
       const markerIndex = existing.indexOf(HOOK_MARKER);
       const before = markerIndex > 1 ? existing.slice(0, markerIndex).trimEnd() + "\n\n" : "";
-      writeFileSync2(HOOK_PATH, before + script);
+      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" + script);
+    writeFileSync3(HOOK_PATH, existing.trimEnd() + "\n\n" + script);
   } else {
-    writeFileSync2(HOOK_PATH, script);
+    writeFileSync3(HOOK_PATH, script);
   }
   chmodSync(HOOK_PATH, 493);
   const modeLabel = advisory ? "advisory (logs violations, never blocks)" : "strict (blocks commits on violations)";
@@ -777,14 +895,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);
   }
@@ -799,7 +917,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);
@@ -810,38 +929,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.
@@ -852,38 +970,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)) {
@@ -898,10 +1012,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"));
@@ -937,6 +1052,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) {
@@ -949,27 +1154,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 [];
   }
@@ -995,27 +1186,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);
@@ -1023,30 +1230,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`));
   }
@@ -1055,6 +1265,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.
@@ -1065,36 +1276,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);
@@ -1130,6 +1338,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) {
@@ -1143,22 +1352,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();
@@ -1197,14 +1404,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"));
@@ -1216,7 +1423,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 = [
     "",
@@ -1231,7 +1438,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"),
@@ -1247,13 +1454,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;
@@ -1261,7 +1468,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;
@@ -1276,28 +1483,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 = "";
@@ -1308,8 +1561,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"));
@@ -1319,15 +1572,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;
@@ -1336,69 +1589,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;
+    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 = readFileSync5(gitignorePath2, "utf-8");
+      const gi = readFileSync6(gitignorePath2, "utf-8");
       if (!gi.includes(".memory-core.env")) {
         appendFileSync(gitignorePath2, "\n.memory-core.env\n");
       }
     } else {
-      writeFileSync3(gitignorePath2, ".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 = ["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" },
@@ -1408,35 +1709,49 @@ 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" : detected.framework === "Go" ? "go-api" : "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 = {
+        "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
   });
@@ -1451,18 +1766,20 @@ 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({
+  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
   });
   let hookAdvisory = true;
-  if (enableHook) {
+  if (enableHook && !quick) {
     const { select: selectMode } = await import("@inquirer/prompts");
     hookAdvisory = await selectMode({
       message: "Hook mode?",
@@ -1472,7 +1789,7 @@ program.command("init").description("Initialize memory-core in the current proje
       ]
     });
   }
-  const config2 = {
+  const config = {
     projectName,
     projectType,
     backendArchitecture,
@@ -1495,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() }
       );
@@ -1506,16 +1823,16 @@ 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) ? readFileSync5(gitignorePath, "utf-8") : "";
+    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";
@@ -1531,17 +1848,17 @@ program.command("init").description("Initialize memory-core in the current proje
     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) => ({
@@ -1558,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"]
@@ -1588,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({
@@ -1602,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()) : [],
@@ -1619,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();
@@ -1648,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;
@@ -1660,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,
@@ -1669,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++;
@@ -1725,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 {};
     }
@@ -1755,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
@@ -1767,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 {
@@ -1796,10 +2341,14 @@ hook.command("install").description("Install pre-commit hook (advisory mode by d
 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);