@shahmilsaari/memory-core 1.0.22 → 1.0.26

package/dist/{chunk-UZDALJVQ.js → chunk-3XTHE74V.js}

@@ -1,4 +1,27 @@
 #!/usr/bin/env node
+import {
+  callChatModel,
+  getChatProviderLabel
+} from "./chunk-PQBWHAZN.js";
+import {
+  Config,
+  deleteMemories,
+  deleteMemory,
+  getMemory,
+  getPool,
+  listMemories,
+  saveMemory,
+  searchMemories,
+  updateMemory,
+  upsertMemory
+} from "./chunk-M7NKSXFS.js";
+import {
+  buildModuleDependencyEdges,
+  collectResolvedImports,
+  detectModuleCycles,
+  isExternalFrameworkSpecifier,
+  parseChangedFilesFromDiff
+} from "./chunk-ZZBQEXEO.js";
 
 // src/project-detector.ts
 import { existsSync, readFileSync } from "fs";
@@ -62,33 +85,6 @@ function detectProject(cwd = process.cwd()) {
   return { language: "Unknown", framework: "Unknown" };
 }
 
-// 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.CHAT_MODEL ?? process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
-  },
-  get chatProvider() {
-    return process.env.CHAT_PROVIDER ?? "ollama";
-  },
-  get chatApiKey() {
-    return process.env.CHAT_API_KEY ?? "";
-  }
-};
-
 // src/embedding.ts
 function getEmbeddingTimeoutMs() {
   const raw = Number(process.env.EMBEDDING_TIMEOUT_MS ?? process.env.MEMORY_CORE_RETRIEVAL_TIMEOUT_MS ?? 5e3);
@@ -116,392 +112,6 @@ async function embed(text) {
   return data.embedding;
 }
 
-// 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 ?? "",
-    baseUrl: process.env.CHAT_BASE_URL ?? ""
-  };
-}
-function getDefaultTimeoutMs() {
-  const raw = Number(process.env.CHAT_TIMEOUT_MS ?? 6e4);
-  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 6e4;
-}
-function timeoutSignal(timeoutMs) {
-  return AbortSignal.timeout(timeoutMs ?? getDefaultTimeoutMs());
-}
-function normalizeChatError(err, timeoutMs) {
-  const ms = timeoutMs ?? getDefaultTimeoutMs();
-  if (err instanceof Error && err.name === "AbortError") {
-    return new Error(`TIMEOUT:${ms}`);
-  }
-  return err instanceof Error ? err : new Error(String(err));
-}
-async function callOllama(cfg, messages, options = {}) {
-  const res = await fetch(`${cfg.ollamaUrl}/api/chat`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    signal: timeoutSignal(options.timeoutMs),
-    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 callOpenAICompat(cfg, messages, options = {}) {
-  const base = (cfg.baseUrl ?? "").replace(/\/$/, "") || "https://api.openai.com/v1";
-  const res = await fetch(`${base}/chat/completions`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${cfg.apiKey}`
-    },
-    signal: timeoutSignal(options.timeoutMs),
-    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, options = {}) {
-  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"
-    },
-    signal: timeoutSignal(options.timeoutMs),
-    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, options = {}) {
-  const res = await fetch("https://api.minimax.io/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${cfg.apiKey}`
-    },
-    signal: timeoutSignal(options.timeoutMs),
-    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, options = {}) {
-  const cfg = getChatConfig();
-  try {
-    switch (cfg.provider) {
-      case "openai":
-      case "openai-compatible":
-        return await callOpenAICompat(cfg, messages, options);
-      case "anthropic":
-        return await callAnthropic(cfg, messages, options);
-      case "minimax":
-        return await callMiniMax(cfg, messages, options);
-      default:
-        return await callOllama(cfg, messages, options);
-    }
-  } catch (err) {
-    throw normalizeChatError(err, options.timeoutMs);
-  }
-}
-function getChatProviderLabel() {
-  const cfg = getChatConfig();
-  if (cfg.provider === "ollama") return `ollama (${cfg.model})`;
-  if (cfg.provider === "openai-compatible") {
-    const host = cfg.baseUrl ? new URL(cfg.baseUrl).hostname : "custom";
-    return `openai-compat/${host} (${cfg.model})`;
-  }
-  return `${cfg.provider} (${cfg.model})`;
-}
-
-// src/db.ts
-import pg from "pg";
-import { createHash } from "crypto";
-var { Pool } = pg;
-var pool = null;
-var migrationsRun = false;
-function readPositiveIntEnv(name, fallback) {
-  const raw = Number(process.env[name]);
-  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : fallback;
-}
-function hashMemoryContent(content) {
-  return createHash("md5").update(content.trim()).digest("hex");
-}
-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.");
-    }
-    const timeoutMs = readPositiveIntEnv("DATABASE_TIMEOUT_MS", 5e3);
-    pool = new Pool({
-      connectionString: Config.databaseUrl,
-      connectionTimeoutMillis: timeoutMs,
-      query_timeout: timeoutMs,
-      statement_timeout: timeoutMs
-    });
-  }
-  return pool;
-}
-async function runMigrations() {
-  if (migrationsRun) return;
-  const client = await getPool().connect();
-  try {
-    await client.query("BEGIN");
-    await client.query(`ALTER TABLE memories ALTER COLUMN scope SET DEFAULT 'project'`);
-    await client.query(`ALTER TABLE memories ADD COLUMN IF NOT EXISTS reason TEXT`);
-    await client.query(`ALTER TABLE memories ADD COLUMN IF NOT EXISTS content_hash TEXT`);
-    await client.query(`ALTER TABLE memories ADD COLUMN IF NOT EXISTS context JSONB NOT NULL DEFAULT '{}'::jsonb`);
-    await client.query(
-      `UPDATE memories
-       SET content_hash = md5(trim(content))
-       WHERE content_hash IS NULL`
-    );
-    await client.query(`CREATE INDEX IF NOT EXISTS memories_content_hash_idx ON memories (content_hash)`);
-    await client.query("COMMIT");
-    migrationsRun = true;
-  } catch (err) {
-    await client.query("ROLLBACK");
-    throw err;
-  } finally {
-    client.release();
-  }
-}
-async function saveMemory(memory) {
-  await runMigrations();
-  const { type, scope, architecture, projectName, title, content, reason, context, tags, embedding } = memory;
-  const contentHash = hashMemoryContent(content);
-  await getPool().query(
-    `INSERT INTO memories (type, scope, architecture, project_name, title, content, reason, context, tags, embedding, content_hash)
-     VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9, $10, $11)`,
-    [
-      type,
-      scope,
-      architecture ?? null,
-      projectName ?? null,
-      title ?? null,
-      content,
-      reason ?? null,
-      JSON.stringify(context ?? {}),
-      tags ?? [],
-      `[${embedding.join(",")}]`,
-      contentHash
-    ]
-  );
-}
-async function upsertMemory(memory) {
-  await runMigrations();
-  const contentHash = hashMemoryContent(memory.content);
-  const existing = await getPool().query(
-    `SELECT id FROM memories
-     WHERE content_hash = $1
-       AND COALESCE(architecture, '') = COALESCE($2, '')
-       AND scope = $3
-       AND type = $4
-     LIMIT 1`,
-    [contentHash, memory.architecture ?? null, memory.scope, memory.type]
-  );
-  if (existing.rowCount) return "skipped";
-  await saveMemory(memory);
-  return "inserted";
-}
-async function listMemories(filters = {}) {
-  await runMigrations();
-  const where = [];
-  const params = [];
-  if (filters.type) {
-    params.push(filters.type);
-    where.push(`type = $${params.length}`);
-  }
-  if (filters.scope) {
-    params.push(filters.scope);
-    where.push(`scope = $${params.length}`);
-  }
-  if (filters.architecture) {
-    if (Array.isArray(filters.architecture)) {
-      params.push(filters.architecture);
-      where.push(filters.includeGlobal ? `(architecture IS NULL OR architecture = ANY($${params.length}))` : `architecture = ANY($${params.length})`);
-    } else {
-      params.push(filters.architecture);
-      where.push(filters.includeGlobal ? `(architecture IS NULL OR architecture = $${params.length})` : `architecture = $${params.length}`);
-    }
-  }
-  if (filters.projectName) {
-    params.push(filters.projectName);
-    where.push(filters.includeGlobal ? `(project_name IS NULL OR project_name = $${params.length})` : `project_name = $${params.length}`);
-  }
-  if (filters.tags?.length) {
-    params.push(filters.tags);
-    where.push(`tags && $${params.length}::text[]`);
-  }
-  const limit = filters.limit ?? 200;
-  params.push(limit);
-  const result = await getPool().query(
-    `SELECT id, type, scope, architecture, project_name, title, content, reason, context, tags, content_hash
-     FROM memories
-     ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
-     ORDER BY id ASC
-     LIMIT $${params.length}`,
-    params
-  );
-  return result.rows;
-}
-async function getMemory(id) {
-  await runMigrations();
-  const result = await getPool().query(
-    `SELECT id, type, scope, architecture, project_name, title, content, reason, context, tags, content_hash
-     FROM memories
-     WHERE id = $1`,
-    [id]
-  );
-  return result.rows[0] ?? null;
-}
-async function deleteMemory(id) {
-  await runMigrations();
-  const result = await getPool().query(`DELETE FROM memories WHERE id = $1`, [id]);
-  return (result.rowCount ?? 0) > 0;
-}
-async function deleteMemories(filters) {
-  await runMigrations();
-  const where = [];
-  const params = [];
-  if (filters.type) {
-    params.push(filters.type);
-    where.push(`type = $${params.length}`);
-  }
-  if (filters.scope) {
-    params.push(filters.scope);
-    where.push(`scope = $${params.length}`);
-  }
-  if (filters.architecture) {
-    if (Array.isArray(filters.architecture)) {
-      params.push(filters.architecture);
-      where.push(`architecture = ANY($${params.length})`);
-    } else {
-      params.push(filters.architecture);
-      where.push(`architecture = $${params.length}`);
-    }
-  }
-  if (filters.tag) {
-    params.push(filters.tag);
-    where.push(`$${params.length} = ANY(tags)`);
-  }
-  if (where.length === 0) {
-    throw new Error("Refusing to bulk-delete without filters");
-  }
-  const result = await getPool().query(
-    `DELETE FROM memories WHERE ${where.join(" AND ")}`,
-    params
-  );
-  return result.rowCount ?? 0;
-}
-async function updateMemory(id, patch) {
-  await runMigrations();
-  const current = await getMemory(id);
-  if (!current) return null;
-  const content = patch.content ?? current.content;
-  const contentHash = hashMemoryContent(content);
-  const embedding = patch.embedding ? `[${patch.embedding.join(",")}]` : null;
-  const result = await getPool().query(
-    `UPDATE memories
-     SET type = $2,
-         scope = $3,
-         title = $4,
-         content = $5,
-         reason = $6,
-         context = $7::jsonb,
-         tags = $8,
-         content_hash = $9,
-         embedding = COALESCE($10::vector, embedding)
-     WHERE id = $1
-     RETURNING id, type, scope, architecture, project_name, title, content, reason, context, tags, content_hash`,
-    [
-      id,
-      patch.type ?? current.type,
-      patch.scope ?? current.scope,
-      patch.title ?? current.title ?? null,
-      content,
-      patch.reason ?? current.reason ?? null,
-      JSON.stringify(patch.context ?? current.context ?? {}),
-      patch.tags ?? current.tags ?? [],
-      contentHash,
-      embedding
-    ]
-  );
-  return result.rows[0] ?? null;
-}
-async function searchMemories(embedding, architectures, limit = 10) {
-  await runMigrations();
-  const vector = `[${embedding.join(",")}]`;
-  const params = [vector];
-  let whereClause = "";
-  const selectedArchitectures = architectures ? (Array.isArray(architectures) ? architectures : [architectures]).filter(Boolean) : [];
-  if (selectedArchitectures.length > 0) {
-    whereClause = `WHERE (
-      architecture = ANY($2)
-      OR architecture IS NULL
-      OR architecture = 'global'
-    )`;
-    params.push(selectedArchitectures);
-  }
-  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, context, 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;
-    migrationsRun = false;
-  }
-}
-
 // src/infrastructure/persistence/postgres/postgres-graph-repository.ts
 var graphMigrationsRun = false;
 function asPosix(value) {
@@ -1008,16 +618,180 @@ 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/watcher.ts
-import { watch } from "chokidar";
-import { spawnSync } from "child_process";
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4, join as join7, relative as relative2, resolve as resolve4, sep } from "path";
-import chalk from "chalk";
+// src/memory-file.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2 } 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,
+    context: memory.context,
+    tags: memory.tags ?? []
+  };
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const entries = value.filter((entry) => typeof entry === "string" && entry.trim() !== "");
+  return entries.length ? entries : void 0;
+}
+function parseContext(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const context = {};
+  const appliesTo = normalizeStringArray(record.appliesTo);
+  const avoidWhen = normalizeStringArray(record.avoidWhen);
+  const examples = normalizeStringArray(record.examples);
+  if (appliesTo) context.appliesTo = appliesTo;
+  if (avoidWhen) context.avoidWhen = avoidWhen;
+  if (examples) context.examples = examples;
+  if (typeof record.source === "string" && record.source.trim() !== "") context.source = record.source;
+  return Object.keys(context).length ? context : void 0;
+}
+function writeMemoryFile(memories, cwd = process.cwd()) {
+  const path = join2(cwd, MEMORY_FILE);
+  writeFileSync(path, JSON.stringify(memories, null, 2) + "\n", "utf-8");
+  return path;
+}
+function readMemoryFile(cwd = process.cwd()) {
+  const path = join2(cwd, MEMORY_FILE);
+  if (!existsSync2(path)) {
+    throw new Error(`${MEMORY_FILE} not found. Run: memory-core export`);
+  }
+  return parseMemoryFile(readFileSync2(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,
+      context: parseContext(record.context),
+      tags: Array.isArray(record.tags) ? record.tags.filter((tag) => typeof tag === "string") : []
+    };
+  });
+}
+
+// src/modules/rule-engine/infrastructure/schema-violations.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+function parseSchemaRule(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed !== null && typeof parsed === "object" && "tsFile" in parsed && "goFile" in parsed && typeof parsed.tsFile === "string" && typeof parsed.goFile === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function extractTsFields(source) {
+  const fields = [];
+  const bodyMatch = source.match(/(?:interface|type)\s+\w+(?:<[^>]*>)?\s*(?:=\s*)?\{([^}]+)\}/s);
+  if (!bodyMatch) return fields;
+  for (const line of bodyMatch[1].split("\n")) {
+    const match = line.match(/^\s*(\w+)\??:/);
+    if (match) fields.push(match[1]);
+  }
+  return fields;
+}
+function extractGoFields(source) {
+  const fields = [];
+  const bodyMatch = source.match(/type\s+\w+\s+struct\s*\{([^}]+)\}/s);
+  if (!bodyMatch) return fields;
+  for (const line of bodyMatch[1].split("\n")) {
+    const jsonTag = line.match(/json:"([^",\s]+)/);
+    if (jsonTag) {
+      if (jsonTag[1] !== "-") fields.push(jsonTag[1]);
+      continue;
+    }
+    const fieldMatch = line.match(/^\s+([A-Z]\w*)/);
+    if (fieldMatch) {
+      const name = fieldMatch[1];
+      fields.push(name.charAt(0).toLowerCase() + name.slice(1));
+    }
+  }
+  return fields;
+}
+async function findSchemaViolations(opts) {
+  if (!opts.memoryEngine) return [];
+  let schemaMemories;
+  try {
+    schemaMemories = await opts.memoryEngine.list({ type: "schema", limit: 100 });
+  } catch {
+    return [];
+  }
+  const violations = [];
+  for (const memory of schemaMemories) {
+    const rule = parseSchemaRule(memory.content);
+    if (!rule) continue;
+    const tsPath = join3(opts.cwd, rule.tsFile);
+    const goPath = join3(opts.cwd, rule.goFile);
+    if (!existsSync3(tsPath) || !existsSync3(goPath)) continue;
+    const tsSource = readFileSync3(tsPath, "utf-8");
+    const goSource = readFileSync3(goPath, "utf-8");
+    const tsFields = new Set(extractTsFields(tsSource));
+    const goFields = new Set(extractGoFields(goSource));
+    for (const field of goFields) {
+      if (!tsFields.has(field)) {
+        violations.push({
+          rule: `Schema alignment: ${rule.tsFile} must match ${rule.goFile}`,
+          file: rule.tsFile,
+          issue: `Go field "${field}" missing in TypeScript file`,
+          suggestion: `Add "${field}" to the TypeScript interface/type in ${rule.tsFile}`,
+          reason: "Schema drift between TypeScript and Go causes runtime mismatches"
+        });
+      }
+    }
+    for (const field of tsFields) {
+      if (!goFields.has(field)) {
+        violations.push({
+          rule: `Schema alignment: ${rule.tsFile} must match ${rule.goFile}`,
+          file: rule.goFile,
+          issue: `TypeScript field "${field}" missing in Go struct`,
+          suggestion: `Add "${field}" to the Go struct in ${rule.goFile}`,
+          reason: "Schema drift between TypeScript and Go causes runtime mismatches"
+        });
+      }
+    }
+  }
+  return violations;
+}
+
+// src/hook.ts
+import { execSync, spawnSync as spawnSync2 } from "child_process";
+import { writeFileSync as writeFileSync5, existsSync as existsSync7, unlinkSync, readFileSync as readFileSync7, chmodSync, statSync as statSync3 } from "fs";
+import { join as join8 } from "path";
+import chalk2 from "chalk";
 
 // src/generator.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync5 } from "fs";
-import { join as join6, dirname as dirname3, basename } from "path";
+import { readFileSync as readFileSync6, readdirSync as readdirSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync6 } from "fs";
+import { join as join7, dirname as dirname3, basename } from "path";
 import { fileURLToPath } from "url";
 import Handlebars from "handlebars";
 import yaml from "js-yaml";
@@ -1038,7 +812,8 @@ var ChatLlmProvider = class {
     return getChatProviderLabel();
   }
   async generateText(messages) {
-    return callChatModel(messages);
+    const result = await callChatModel(messages);
+    return result.content;
   }
 };
 
@@ -1125,9 +900,9 @@ var PostgresMemoryRepository = class {
 };
 
 // src/infrastructure/persistence/filesystem/file-graph-repository.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname, join as join3 } from "path";
-var DEFAULT_FILE = join3(".memory-core", "graph-snapshots.json");
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join4 } from "path";
+var DEFAULT_FILE = join4(".memory-core", "graph-snapshots.json");
 function asPosix2(value) {
   return value.replace(/\\/g, "/");
 }
@@ -1166,11 +941,11 @@ var FileGraphRepository = class {
   }
   readData() {
     const filePath = this.absolutePath();
-    if (!existsSync3(filePath)) {
+    if (!existsSync4(filePath)) {
       return { version: 1, snapshots: [] };
     }
     try {
-      const parsed = JSON.parse(readFileSync2(filePath, "utf-8"));
+      const parsed = JSON.parse(readFileSync4(filePath, "utf-8"));
       if (!Array.isArray(parsed.snapshots)) {
         return { version: 1, snapshots: [] };
       }
@@ -1187,11 +962,11 @@ var FileGraphRepository = class {
   writeData(data) {
     const filePath = this.absolutePath();
     mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, `${JSON.stringify(data, null, 2)}
+    writeFileSync2(filePath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
   }
   absolutePath() {
-    return join3(this.rootPath, this.relativeFilePath);
+    return join4(this.rootPath, this.relativeFilePath);
   }
 };
 
@@ -1236,77 +1011,1023 @@ var ResilientGraphRepository = class {
   }
 };
 
-// src/infrastructure/filesystem/chokidar-watch-service.ts
-var ChokidarWatchService = class {
-  async start(options = {}) {
-    await startWatch({
-      path: options.path,
-      verbose: options.verbose,
-      debug: options.debug,
-      scanOnStart: options.scanOnStart
-    });
-  }
-  async scan(options = {}) {
-    return scanFiles({
-      path: options.path,
-      verbose: options.verbose,
-      debug: options.debug
-    });
-  }
-};
-
-// src/infrastructure/events/in-memory-event-bus.ts
-var InMemoryEventBus = class {
-  handlers = /* @__PURE__ */ new Map();
-  async publish(event) {
-    const handlers = this.handlers.get(event.type);
-    if (!handlers || handlers.size === 0) return;
-    for (const handler of handlers) {
-      await handler(event);
-    }
-  }
-  subscribe(eventType, handler) {
-    const existing = this.handlers.get(eventType) ?? /* @__PURE__ */ new Set();
-    existing.add(handler);
-    this.handlers.set(eventType, existing);
-    return () => {
-      const current = this.handlers.get(eventType);
-      if (!current) return;
-      current.delete(handler);
-      if (current.size === 0) {
-        this.handlers.delete(eventType);
-      }
-    };
-  }
-};
+// src/watcher.ts
+import { watch } from "chokidar";
+import { spawnSync } from "child_process";
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join5, relative, resolve as resolve2, sep } from "path";
+import chalk from "chalk";
 
-// src/modules/memory-engine/application/memory-engine-service.ts
-var MemoryEngineService = class {
-  constructor(memoryRepository, embeddingProvider) {
-    this.memoryRepository = memoryRepository;
-    this.embeddingProvider = embeddingProvider;
-  }
-  memoryRepository;
-  embeddingProvider;
-  withReason(input) {
-    const reason = input.reason?.trim();
-    return {
-      ...input,
-      reason: reason || `Captured as a ${input.type} memory because it should be remembered: ${input.content}`
-    };
-  }
-  async remember(input) {
-    const normalized = this.withReason(input);
-    const embedding = await this.embeddingProvider.embed(normalized.content);
-    return this.memoryRepository.upsert({ ...normalized, embedding });
-  }
-  async rememberForce(input) {
-    const normalized = this.withReason(input);
-    const embedding = await this.embeddingProvider.embed(normalized.content);
-    await this.memoryRepository.save({ ...normalized, embedding });
-  }
-  async list(filters = {}) {
-    return this.memoryRepository.list(filters);
+// src/modules/rule-engine/infrastructure/ast-deterministic-violations.ts
+import { resolve } from "path";
+function asPosix3(value) {
+  return value.replace(/\\/g, "/");
+}
+function hasPath(value, pathSegment) {
+  const normalized = asPosix3(value);
+  const trimmed = pathSegment.startsWith("/") ? pathSegment.slice(1) : pathSegment;
+  return normalized.includes(pathSegment) || normalized.includes(trimmed);
+}
+function isLegacyOrCompatibilitySpecifier(specifier) {
+  const normalized = asPosix3(specifier);
+  return normalized.includes("/compatibility/") || normalized.includes("compatibility/") || normalized.includes("legacy-");
+}
+function isLegacyOrCompatibilityPath(pathValue) {
+  if (!pathValue) return false;
+  const normalized = asPosix3(pathValue);
+  return normalized.includes("/src/compatibility/") || normalized.includes("/legacy-");
+}
+function moduleNameFromPath(pathValue) {
+  const match = asPosix3(pathValue).match(/src\/modules\/([^/]+)\//);
+  return match?.[1];
+}
+function isModulePublicPath(pathValue) {
+  const normalized = asPosix3(pathValue);
+  return /src\/modules\/[^/]+\/(public|api)\//.test(normalized) || /src\/modules\/[^/]+\/index\.(ts|tsx|js|jsx|mjs|cjs)$/.test(normalized);
+}
+function detectCleanLayer(pathValue) {
+  const normalized = asPosix3(pathValue);
+  if (hasPath(normalized, "/src/domain/") || hasPath(normalized, "/src/core/domain/")) return "domain";
+  if (hasPath(normalized, "/src/application/") || hasPath(normalized, "/src/core/application/")) return "application";
+  if (hasPath(normalized, "/src/infrastructure/")) return "infrastructure";
+  if (hasPath(normalized, "/src/interfaces/")) return "interface";
+  return "unknown";
+}
+function detectHexLayer(pathValue) {
+  const normalized = asPosix3(pathValue);
+  if (hasPath(normalized, "/src/core/")) return "core";
+  if (hasPath(normalized, "/src/adapters/inbound/")) return "adapter-inbound";
+  if (hasPath(normalized, "/src/adapters/outbound/")) return "adapter-outbound";
+  if (hasPath(normalized, "/src/adapters/")) return "adapter-other";
+  return "unknown";
+}
+function activeArchitectures(config, rules = []) {
+  const names = /* @__PURE__ */ new Set();
+  if (config?.backendArchitecture) names.add(config.backendArchitecture);
+  if (config?.frontendFramework) names.add(config.frontendFramework);
+  const text = rules.join("\n").toLowerCase();
+  if (text.includes("modular monolith")) names.add("modular-monolith");
+  if (text.includes("clean architecture")) names.add("clean-architecture");
+  if (text.includes("hexagonal")) names.add("hexagonal");
+  return names;
+}
+function pushUnique(target, incoming) {
+  if (target.some(
+    (entry) => entry.rule === incoming.rule && entry.file === incoming.file && entry.line === incoming.line && entry.issue === incoming.issue
+  )) {
+    return;
+  }
+  target.push(incoming);
+}
+function evaluateFile(file, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const rules = options.rules ?? [];
+  const architectures = activeArchitectures(options.config, rules);
+  const reasonLookup = options.reasonLookup ?? /* @__PURE__ */ new Map();
+  const violations = [];
+  const absFile = resolve(cwd, file);
+  const normalizedFile = asPosix3(file);
+  const imports = collectResolvedImports(absFile, cwd);
+  const fromCleanLayer = detectCleanLayer(normalizedFile);
+  const fromHexLayer = detectHexLayer(normalizedFile);
+  for (const imp of imports) {
+    const target = imp.resolvedPath ? asPosix3(imp.resolvedPath) : void 0;
+    if (isLegacyOrCompatibilitySpecifier(imp.specifier) || isLegacyOrCompatibilityPath(target)) {
+      const rule = "Application code must not import compatibility or legacy adapter paths";
+      pushUnique(violations, {
+        rule,
+        file,
+        line: imp.line,
+        issue: `Import references a removed migration path: ${imp.specifier}`,
+        suggestion: "Import module services/ports from src/app, src/modules, src/shared/ports, or current infrastructure adapters.",
+        reason: reasonLookup.get(rule)
+      });
+    }
+    if (architectures.has("modular-monolith")) {
+      const fromModule = moduleNameFromPath(normalizedFile);
+      const toModule = target ? moduleNameFromPath(target) : void 0;
+      if (fromModule && toModule && target && fromModule !== toModule && !isModulePublicPath(target)) {
+        const rule = "Modules communicate only through public interfaces or events \u2014 never by importing internals";
+        pushUnique(violations, {
+          rule,
+          file,
+          line: imp.line,
+          issue: `Cross-module import from "${fromModule}" to private path in module "${toModule}"`,
+          suggestion: `Expose a public API from src/modules/${toModule}/index.ts (or public/) and import through it.`,
+          reason: reasonLookup.get(rule)
+        });
+      }
+    }
+    if (architectures.has("clean-architecture")) {
+      const toCleanLayer = target ? detectCleanLayer(target) : "unknown";
+      if (fromCleanLayer === "domain" && ["application", "infrastructure", "interface"].includes(toCleanLayer)) {
+        const rule = "Entities encapsulate core business logic and have no external dependencies";
+        pushUnique(violations, {
+          rule,
+          file,
+          line: imp.line,
+          issue: `Domain layer imports ${toCleanLayer} layer: ${imp.specifier}`,
+          suggestion: "Keep domain isolated and move orchestration concerns into application layer.",
+          reason: reasonLookup.get(rule)
+        });
+      }
+      if (fromCleanLayer === "application" && (toCleanLayer === "infrastructure" || toCleanLayer === "interface")) {
+        const rule = "Infrastructure layer (DB, HTTP, queues) depends on application \u2014 never the reverse";
+        pushUnique(violations, {
+          rule,
+          file,
+          line: imp.line,
+          issue: `Application layer imports ${toCleanLayer} layer: ${imp.specifier}`,
+          suggestion: "Invert dependency via repository/port interface in application layer.",
+          reason: reasonLookup.get(rule)
+        });
+      }
+      if (fromCleanLayer === "interface" && toCleanLayer === "infrastructure") {
+        const rule = "Controllers must only validate input and delegate to use cases";
+        pushUnique(violations, {
+          rule,
+          file,
+          line: imp.line,
+          issue: `Interface/controller layer imports infrastructure directly: ${imp.specifier}`,
+          suggestion: "Delegate to application use cases instead of calling infrastructure directly.",
+          reason: reasonLookup.get(rule)
+        });
+      }
+      if (fromCleanLayer === "domain" && imp.isExternal && isExternalFrameworkSpecifier(imp.specifier)) {
+        const rule = "Domain layer must not import any framework or library code";
+        pushUnique(violations, {
+          rule,
+          file,
+          line: imp.line,
+          issue: `Domain file imports framework package: ${imp.specifier}`,
+          suggestion: "Keep domain pure. Move framework-specific logic to infrastructure/adapters.",
+          reason: reasonLookup.get(rule)
+        });
+      }
+    }
+    if (architectures.has("hexagonal")) {
+      const toHexLayer = target ? detectHexLayer(target) : "unknown";
+      if (fromHexLayer === "core" && (toHexLayer === "adapter-inbound" || toHexLayer === "adapter-outbound" || toHexLayer === "adapter-other")) {
+        const rule = "Direct imports of adapter code inside the core";
+        pushUnique(violations, {
+          rule,
+          file,
+          line: imp.line,
+          issue: `Core imports adapter path directly: ${imp.specifier}`,
+          suggestion: "Define a core port and resolve adapter at composition root.",
+          reason: reasonLookup.get(rule)
+        });
+      }
+      const crossAdapterBoundary = fromHexLayer === "adapter-inbound" && (toHexLayer === "adapter-outbound" || toHexLayer === "adapter-other") || fromHexLayer === "adapter-outbound" && (toHexLayer === "adapter-inbound" || toHexLayer === "adapter-other");
+      if (crossAdapterBoundary) {
+        const rule = "Adapters implement ports \u2014 one adapter per external system (DB, HTTP, queue, etc.)";
+        pushUnique(violations, {
+          rule,
+          file,
+          line: imp.line,
+          issue: `Adapter imports another adapter layer directly: ${imp.specifier}`,
+          suggestion: "Route adapter collaboration through core ports/use-cases, not direct adapter imports.",
+          reason: reasonLookup.get(rule)
+        });
+      }
+    }
+  }
+  return violations;
+}
+function findAstDeterministicViolationsForFile(file, options = {}) {
+  return evaluateFile(file, options);
+}
+function findAstDeterministicViolationsForDiff(diff, options = {}) {
+  const files = parseChangedFilesFromDiff(diff).filter((file) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(file));
+  const violations = [];
+  for (const file of files) {
+    for (const violation of evaluateFile(file, options)) {
+      pushUnique(violations, violation);
+    }
+  }
+  const architectures = activeArchitectures(options.config, options.rules ?? []);
+  if (architectures.has("modular-monolith")) {
+    const edges = buildModuleDependencyEdges(files, options.cwd ?? process.cwd());
+    const cycles = detectModuleCycles(edges);
+    for (const cycle of cycles) {
+      const representative = edges.find((edge) => edge.fromModule === cycle[0] && edge.toModule === cycle[1]);
+      if (!representative) continue;
+      const rule = "No circular dependencies between modules";
+      pushUnique(violations, {
+        rule,
+        file: representative.file,
+        line: representative.line,
+        issue: `Module dependency cycle detected: ${cycle.join(" -> ")}`,
+        suggestion: "Break the cycle by introducing a public port/event or moving shared logic into src/shared.",
+        reason: options.reasonLookup?.get(rule)
+      });
+    }
+  }
+  return violations;
+}
+
+// src/watcher.ts
+function getFileLines(filePath) {
+  try {
+    return readFileSync5(filePath, "utf-8").split("\n");
+  } catch {
+    return [];
+  }
+}
+function printCodeContext(filePath, line, contextLines = 2) {
+  const lines = getFileLines(filePath);
+  if (lines.length === 0) return;
+  const start = Math.max(0, line - 1 - contextLines);
+  const end = Math.min(lines.length - 1, line - 1 + contextLines);
+  console.log(chalk.dim("      \u250C\u2500 code \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"));
+  for (let i = start; i <= end; i++) {
+    const lineNum = String(i + 1).padStart(4, " ");
+    const isViolation = i === line - 1;
+    if (isViolation) {
+      console.log(chalk.red(`      \u2502 ${lineNum}  \u25B6  ${lines[i]}`));
+    } else {
+      console.log(chalk.dim(`      \u2502 ${lineNum}     ${lines[i]}`));
+    }
+  }
+  console.log(chalk.dim("      \u2514\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"));
+}
+function formatCodeContext(filePath, line, contextLines = 2) {
+  const lines = getFileLines(filePath);
+  if (lines.length === 0) return void 0;
+  const start = Math.max(0, line - 1 - contextLines);
+  const end = Math.min(lines.length - 1, line - 1 + contextLines);
+  return Array.from({ length: end - start + 1 }, (_, index) => {
+    const current = start + index;
+    const lineNum = String(current + 1).padStart(4, " ");
+    const marker = current === line - 1 ? ">" : " ";
+    return `${lineNum} ${marker} ${lines[current]}`;
+  }).join("\n");
+}
+var SOURCE_EXTENSIONS = /\.(ts|tsx|js|jsx|py|php|rb|go|java|cs|swift|kt|rs|vue|svelte)$/;
+var reasonMap = new Map(
+  seeds.filter((s) => s.reason).map((s) => [s.content, s.reason])
+);
+function findProjectRoot(startPath) {
+  let current = resolve2(startPath);
+  while (true) {
+    if (existsSync5(join5(current, ".memory-core.json"))) return current;
+    const parent = dirname2(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function resolveWatchPaths(pathOption, projectRootOption) {
+  if (projectRootOption) {
+    const projectRoot2 = resolve2(projectRootOption);
+    return {
+      projectRoot: projectRoot2,
+      watchPath: resolve2(projectRoot2, pathOption ?? ".")
+    };
+  }
+  const cwdRoot = resolve2(process.cwd());
+  const watchPath = resolve2(cwdRoot, pathOption ?? ".");
+  const projectRoot = findProjectRoot(watchPath) ?? findProjectRoot(cwdRoot) ?? cwdRoot;
+  return { projectRoot, watchPath };
+}
+function readStatsFile(statsPath) {
+  if (!existsSync5(statsPath)) return { rules: {}, files: {} };
+  try {
+    return JSON.parse(readFileSync5(statsPath, "utf-8"));
+  } catch {
+    return { rules: {}, files: {} };
+  }
+}
+function rebuildLiveCounters(byFile) {
+  const rules = {};
+  const files = {};
+  for (const [file, violations] of Object.entries(byFile)) {
+    if (!Array.isArray(violations) || violations.length === 0) continue;
+    files[file] = violations.length;
+    for (const violation of violations) {
+      rules[violation.rule] = (rules[violation.rule] ?? 0) + 1;
+    }
+  }
+  return { rules, files };
+}
+function resetLiveStats(cwd) {
+  const statsPath = join5(cwd, ".memory-core-stats.json");
+  const stats = readStatsFile(statsPath);
+  stats.rules ??= {};
+  stats.files ??= {};
+  stats.live = {
+    rules: {},
+    files: {},
+    byFile: {}
+  };
+  writeFileSync3(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+}
+function recordWatchResult(cwd, file, violations) {
+  const statsPath = join5(cwd, ".memory-core-stats.json");
+  const stats = readStatsFile(statsPath);
+  stats.rules ??= {};
+  stats.files ??= {};
+  stats.live ??= { rules: {}, files: {}, byFile: {} };
+  stats.live.byFile ??= {};
+  if (violations.length === 0) {
+    delete stats.live.byFile[file];
+  } else {
+    stats.live.byFile[file] = violations;
+  }
+  const live = rebuildLiveCounters(stats.live.byFile);
+  stats.live.rules = live.rules;
+  stats.live.files = live.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;
+  }
+  if (violations.length > 0) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const recent = violations.map((violation) => ({ ...violation, timestamp, source: "watch" }));
+    stats.recentViolations = [...recent, ...stats.recentViolations ?? []].slice(0, 50);
+  }
+  writeFileSync3(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(readFileSync5(configPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function getProfileRules(config) {
+  const rules = [];
+  const avoids = [];
+  if (config.backendArchitecture) {
+    const profile = listProfiles("backend").find((p) => p.name === config.backendArchitecture);
+    if (profile) {
+      rules.push(...profile.rules);
+      avoids.push(...profile.avoid);
+    }
+  }
+  if (config.frontendFramework) {
+    const profile = listProfiles("frontend").find((p) => p.name === config.frontendFramework);
+    if (profile) {
+      rules.push(...profile.rules);
+      avoids.push(...profile.avoid);
+    }
+  }
+  return { rules, avoids };
+}
+async function loadRelevantRules(cwd, config, rel, diff, fallbackRules) {
+  try {
+    const query = buildContextQuery([
+      rel,
+      diff.slice(0, 1200),
+      config.backendArchitecture,
+      config.frontendFramework,
+      config.language
+    ]);
+    const memories = await retrieveContextualMemories({
+      query,
+      cwd,
+      config,
+      limit: 15
+    });
+    const selected = memories.filter((memory) => ["rule", "pattern", "decision"].includes(memory.type)).map((memory) => memory.content);
+    return selected.length > 0 ? selected : fallbackRules;
+  } catch {
+    return fallbackRules;
+  }
+}
+function applyAllowPatterns(violations, allowPatterns) {
+  if (allowPatterns.length === 0) return violations;
+  return violations.filter((violation) => {
+    const haystack = `${violation.rule}
+${violation.issue}
+${violation.file}`.toLowerCase();
+    return !allowPatterns.some((pattern) => haystack.includes(pattern.toLowerCase()));
+  });
+}
+async function verifyViolations(inputText, violations, allowPatterns, debug, mode = "diff") {
+  if (violations.length === 0) return violations;
+  const sourceLabel = mode === "snapshot" ? "file content" : "diff";
+  const systemPrompt = `You are verifying candidate architecture violations.
+Only keep violations that are directly supported by the ${sourceLabel}.
+Reject speculative or weak matches.
+Treat these allowlisted patterns as intentional and valid:
+${allowPatterns.length ? allowPatterns.map((pattern, index) => `${index + 1}. ${pattern}`).join("\n") : "(none)"}
+
+Return strict JSON:
+{"violations":[{"rule":"...","file":"...","line":1,"issue":"...","suggestion":"...","reason":"..."}]}
+Do not include any text outside the JSON.`;
+  const userPrompt = `${mode === "snapshot" ? "File content" : "Diff"}:
+${inputText.slice(0, 6e3)}
+
+Candidate violations:
+${JSON.stringify(violations, null, 2)}`;
+  if (debug) {
+    console.log(chalk.gray("\n  [debug] verifier prompt:"));
+    console.log(chalk.dim(systemPrompt));
+    console.log(chalk.dim(userPrompt));
+    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"));
+  }
+  try {
+    const { content: raw, usage: verifyUsage } = await callChatModel([
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt }
+    ]);
+    accumulateTokenUsage(verifyUsage);
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed?.violations)) return parsed.violations;
+    if (Array.isArray(parsed)) return parsed;
+    return violations;
+  } catch {
+    return violations;
+  }
+}
+async function loadIgnorePatterns() {
+  try {
+    const app = getDefaultApplicationContainer();
+    const ignores = await app.services.memoryEngine.list({ type: "ignore", limit: 1e3 });
+    return ignores.map((ignore) => ignore.content);
+  } catch {
+    return [];
+  }
+}
+function normalizeForGit(pathLike) {
+  return pathLike.split(sep).join("/");
+}
+function listSourceFilesFromFilesystem(dir) {
+  if (!existsSync5(dir)) return [];
+  const files = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = readdirSync(current);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const absolute = join5(current, entry);
+      let isDirectory = false;
+      let isFile = false;
+      try {
+        const stats = statSync(absolute);
+        isDirectory = stats.isDirectory();
+        isFile = stats.isFile();
+      } catch {
+        continue;
+      }
+      if (isDirectory) {
+        if (entry === "node_modules" || entry === ".git" || entry === "dist" || entry === "build" || entry === "coverage") {
+          continue;
+        }
+        stack.push(absolute);
+        continue;
+      }
+      if (isFile && SOURCE_EXTENSIONS.test(absolute)) files.push(absolute);
+    }
+  }
+  return files;
+}
+function listTrackedSourceFiles(projectRoot, watchPath) {
+  const relPrefix = normalizeForGit(relative(projectRoot, watchPath));
+  const inRoot = relPrefix === "" || relPrefix === ".";
+  const prefixWithSlash = inRoot ? "" : `${relPrefix}/`;
+  const listed = spawnSync("git", ["ls-files"], { encoding: "utf-8", cwd: projectRoot });
+  if (listed.status !== 0) {
+    return listSourceFilesFromFilesystem(watchPath).sort();
+  }
+  const files = (listed.stdout ?? "").split("\n").filter((file) => file.length > 0).filter((file) => SOURCE_EXTENSIONS.test(file)).filter((file) => inRoot || file.startsWith(prefixWithSlash)).map((file) => join5(projectRoot, file)).filter((file) => existsSync5(file));
+  return [...new Set(files)].sort();
+}
+async function runSnapshotScan(projectRoot, watchPath, config, verbose, debug, onEvent) {
+  const files = listTrackedSourceFiles(projectRoot, watchPath);
+  if (files.length === 0) {
+    console.log(chalk.yellow("\n  No tracked source files found for scan.\n"));
+    return {
+      filesChecked: 0,
+      filesWithViolations: 0,
+      violations: 0
+    };
+  }
+  console.log(chalk.dim(`
+  scanning ${files.length} tracked source files...
+`));
+  const summary = {
+    filesChecked: 0,
+    filesWithViolations: 0,
+    violations: 0
+  };
+  for (const filePath of files) {
+    const rel = normalizeForGit(relative(projectRoot, filePath));
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    onEvent?.({ type: "saved", timestamp, file: rel });
+    const result = await checkFile(filePath, projectRoot, config, verbose, debug, "snapshot", onEvent);
+    if (result.type !== "checked") {
+      if (result.type === "skipped") {
+        onEvent?.({ type: "skipped", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, reason: result.reason });
+      } else {
+        onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message: result.message });
+      }
+      continue;
+    }
+    summary.filesChecked += 1;
+    if (result.violations.length === 0) {
+      onEvent?.({ type: "clean", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel });
+      continue;
+    }
+    summary.filesWithViolations += 1;
+    summary.violations += result.violations.length;
+    onEvent?.({ type: "violations", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, violations: result.violations });
+  }
+  return summary;
+}
+async function autoFixFile(filePath, projectRoot, violations, rules, avoids, debug) {
+  if (!existsSync5(filePath)) return false;
+  const content = readFileSync5(filePath, "utf-8");
+  const rel = relative(projectRoot, filePath).split(sep).join("/");
+  const violationSummary = violations.map(
+    (v, i) => `${i + 1}. Rule: "${v.rule}"
+   Issue: ${v.issue}${v.suggestion ? `
+   Fix: ${v.suggestion}` : ""}${v.line ? `
+   Line: ${v.line}` : ""}`
+  ).join("\n\n");
+  const systemPrompt = `You are an expert code fixer. You will be given a file with architecture violations.
+Fix ONLY the violations listed below. Do not change anything else.
+Return ONLY the complete fixed file content \u2014 no markdown, no explanation, no code blocks.`;
+  const userPrompt = `File: ${rel}
+
+Violations to fix:
+${violationSummary}
+
+Rules being enforced:
+${rules.slice(0, 10).join("\n")}
+${avoids.length > 0 ? `
+Things that must never appear:
+${avoids.slice(0, 5).join("\n")}` : ""}
+
+Current file content:
+${content}`;
+  if (debug) {
+    console.log(chalk.gray("  [debug] auto-fix prompt:"));
+    console.log(chalk.dim(userPrompt.slice(0, 500) + "..."));
+  }
+  try {
+    console.log(chalk.cyan(`  \u26A1 Auto-fixing ${violations.length} violation${violations.length > 1 ? "s" : ""} in ${rel}\u2026`));
+    const { content: fixed, usage: fixUsage } = await callChatModel([
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt }
+    ]);
+    accumulateTokenUsage(fixUsage);
+    if (!fixed.trim()) return false;
+    writeFileSync3(filePath, fixed, "utf-8");
+    try {
+      const app = getDefaultApplicationContainer();
+      for (const v of violations) {
+        await app.services.memoryEngine.remember({
+          type: "rule",
+          scope: "project",
+          content: v.rule,
+          reason: `Auto-fixed by AI: ${v.issue}`,
+          tags: ["auto-fix"]
+        });
+      }
+    } catch {
+    }
+    return true;
+  } catch (err) {
+    if (debug) console.log(chalk.yellow(`  [debug] auto-fix failed: ${err.message}`));
+    return false;
+  }
+}
+async function checkFile(filePath, projectRoot, config, verbose, debug, mode = "diff", onEvent) {
+  const rel = relative(projectRoot, filePath).split(sep).join("/");
+  if (rel.startsWith("..")) return { type: "skipped", reason: "File is outside project root" };
+  let inputText;
+  if (mode === "snapshot") {
+    if (!existsSync5(filePath)) return { type: "skipped", reason: "File no longer exists" };
+    inputText = readFileSync5(filePath, "utf-8");
+    if (!inputText.trim()) return { type: "skipped", reason: "File is empty" };
+  } else {
+    const headResult = spawnSync("git", ["diff", "HEAD", "--", rel], { encoding: "utf-8", cwd: projectRoot });
+    if (headResult.stdout?.trim()) {
+      inputText = headResult.stdout;
+    } else {
+      const noIndexResult = spawnSync("git", ["diff", "--no-index", "/dev/null", rel], {
+        encoding: "utf-8",
+        cwd: projectRoot
+      });
+      inputText = noIndexResult.stdout ?? "";
+    }
+    if (!inputText.trim()) return { type: "skipped", reason: "No changes compared with HEAD" };
+  }
+  const { rules: fallbackRules, avoids } = getProfileRules(config);
+  const rules = await loadRelevantRules(projectRoot, config, rel, inputText, fallbackRules);
+  if (rules.length === 0) return { type: "skipped", reason: "No applicable architecture rules" };
+  const MAX_INPUT = 6e3;
+  const truncated = inputText.length > MAX_INPUT;
+  const inputToSend = truncated ? inputText.slice(0, MAX_INPUT) + "\n\n[input truncated]" : inputText;
+  if (verbose || debug) {
+    const label = mode === "snapshot" ? "snapshot" : `${inputText.length} chars`;
+    console.log(chalk.dim(`
+  [watch] checking ${rel} (${label})\u2026`));
+  }
+  const rulesWithReasons = rules.map((r, i) => {
+    const why = reasonMap.get(r);
+    return why ? `${i + 1}. ${r}
+   WHY: ${why}` : `${i + 1}. ${r}`;
+  }).join("\n");
+  const allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config), ...await loadIgnorePatterns()])];
+  const astViolations = findAstDeterministicViolationsForFile(rel, {
+    cwd: projectRoot,
+    config,
+    rules,
+    reasonLookup: reasonMap
+  }).map((violation) => ({
+    ...violation,
+    severity: "error"
+  }));
+  const analysisTarget = mode === "snapshot" ? "file content" : "file diff";
+  const systemPrompt = `You are a strict code reviewer enforcing architecture rules.
+Analyze the ${analysisTarget} and identify ONLY clear, definite rule violations.
+Use the WHY for each rule to understand intent and judge edge cases.
+
+Rules to enforce:
+${rulesWithReasons}
+
+Things that must never appear:
+${avoids.map((a, i) => `${i + 1}. ${a}`).join("\n")}
+
+Never flag these accepted project patterns:
+${allowPatterns.length ? allowPatterns.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(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] input length: ${inputText.length} chars`));
+    console.log(chalk.dim(inputToSend));
+    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"));
+  }
+  try {
+    const reviewPrompt = mode === "snapshot" ? `Review this file ${rel}:
+
+${inputToSend}` : `Review this diff for ${rel}:
+
+${inputToSend}`;
+    onEvent?.({ type: "log", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, message: `checking with ${getChatProviderLabel()} | ${rules.length} rule${rules.length === 1 ? "" : "s"}` });
+    const { content: raw, usage: reviewUsage } = await callChatModel([
+      { role: "system", content: systemPrompt },
+      { role: "user", content: reviewPrompt }
+    ]);
+    accumulateTokenUsage(reviewUsage);
+    if (debug) {
+      console.log(chalk.gray("  [debug] raw response:"));
+      console.log(chalk.dim(raw));
+      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 parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        violations = parsed;
+      } else if (Array.isArray(parsed?.violations)) {
+        violations = parsed.violations;
+      } else if (parsed?.rule) {
+        violations = [parsed];
+      }
+    } catch {
+      violations = [];
+    }
+    onEvent?.({ type: "log", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, message: `model returned ${violations.length} candidate violation${violations.length === 1 ? "" : "s"}` });
+    violations = await verifyViolations(inputText, violations, allowPatterns, debug, mode);
+    violations = [...astViolations, ...violations];
+    violations = applyAllowPatterns(violations, allowPatterns);
+    violations = violations.map((violation) => ({
+      ...violation,
+      code: violation.code ?? (violation.line ? formatCodeContext(filePath, violation.line, 1) : void 0)
+    }));
+    if (violations.length === 0) {
+      recordWatchResult(projectRoot, rel, []);
+      console.log(chalk.green(`  \u2713 ${rel}`) + chalk.dim(" \u2014 no violations"));
+      return { type: "checked", violations: [] };
+    }
+    console.log(
+      chalk.red.bold(`
+  \u2717 ${violations.length} violation${violations.length > 1 ? "s" : ""} in ${rel}
+`)
+    );
+    violations.forEach((v, i) => {
+      const loc = v.line ? `${v.file ?? rel}:${v.line}` : v.file ?? rel;
+      console.log(chalk.bold(`  [${i + 1}] ${loc}`));
+      console.log(chalk.yellow("      Rule:   ") + v.rule);
+      const why = v.reason ?? reasonMap.get(v.rule);
+      if (why) console.log(chalk.dim("      Why:    ") + chalk.dim(why));
+      if (v.line && existsSync5(filePath)) {
+        printCodeContext(filePath, v.line, 1);
+      }
+      if (v.issue) console.log(chalk.red("      Issue:  ") + v.issue);
+      if (v.suggestion) console.log(chalk.green("      Fix:    ") + v.suggestion);
+      console.log();
+    });
+    recordWatchResult(projectRoot, rel, violations);
+    console.log(chalk.dim('  Fix violations or run: memory-core remember "<lesson>"'));
+    console.log();
+    return { type: "checked", violations };
+  } catch (err) {
+    const aiUnavailable = err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED");
+    const message = aiUnavailable ? `Model unreachable for ${rel}; using deterministic checks only.` : `AI check failed for ${rel}; using deterministic checks only.`;
+    console.log(chalk.yellow(`  \u26A0  ${message}`));
+    let violations = applyAllowPatterns(astViolations, allowPatterns);
+    violations = violations.map((violation) => ({
+      ...violation,
+      code: violation.code ?? (violation.line ? formatCodeContext(filePath, violation.line, 1) : void 0)
+    }));
+    if (violations.length === 0) {
+      recordWatchResult(projectRoot, rel, []);
+      console.log(chalk.green(`  \u2713 ${rel}`) + chalk.dim(" \u2014 no deterministic violations"));
+      return { type: "checked", violations: [] };
+    }
+    console.log(
+      chalk.red.bold(`
+  \u2717 ${violations.length} deterministic violation${violations.length > 1 ? "s" : ""} in ${rel}
+`)
+    );
+    violations.forEach((v, i) => {
+      const loc = v.line ? `${v.file ?? rel}:${v.line}` : v.file ?? rel;
+      console.log(chalk.bold(`  [${i + 1}] ${loc}`));
+      console.log(chalk.yellow("      Rule:   ") + v.rule);
+      const why = v.reason ?? reasonMap.get(v.rule);
+      if (why) console.log(chalk.dim("      Why:    ") + chalk.dim(why));
+      if (v.line && existsSync5(filePath)) {
+        printCodeContext(filePath, v.line, 1);
+      }
+      if (v.issue) console.log(chalk.red("      Issue:  ") + v.issue);
+      if (v.suggestion) console.log(chalk.green("      Fix:    ") + v.suggestion);
+      console.log();
+    });
+    recordWatchResult(projectRoot, rel, violations);
+    console.log(chalk.dim('  Fix violations or run: memory-core remember "<lesson>"'));
+    console.log();
+    return { type: "checked", violations };
+  }
+}
+async function scanFiles(options = {}) {
+  const { projectRoot, watchPath } = resolveWatchPaths(options.path, options.projectRoot);
+  const config = loadConfig(projectRoot);
+  if (!config) {
+    throw new Error("No .memory-core.json found. Run: memory-core init");
+  }
+  const { rules } = getProfileRules(config);
+  if (rules.length === 0) {
+    console.log(chalk.yellow("\n  No architecture rules configured in .memory-core.json \u2014 nothing to scan.\n"));
+    return {
+      filesChecked: 0,
+      filesWithViolations: 0,
+      violations: 0
+    };
+  }
+  resetLiveStats(projectRoot);
+  console.log(chalk.cyan("\n  archmind scan \u2014 checking tracked source files\n"));
+  console.log(chalk.dim(`  project: ${projectRoot}`));
+  console.log(chalk.dim(`  path:    ${watchPath}`));
+  console.log(chalk.dim(`  model:   ${getChatProviderLabel()}`));
+  console.log(chalk.dim(`  rules:   ${rules.length}
+`));
+  const summary = await runSnapshotScan(
+    projectRoot,
+    watchPath,
+    config,
+    options.verbose ?? false,
+    options.debug ?? false,
+    options.onEvent
+  );
+  const cleanFiles = summary.filesChecked - summary.filesWithViolations;
+  console.log(chalk.bold("\n  scan summary\n"));
+  console.log(chalk.dim(`  files checked:         ${summary.filesChecked}`));
+  console.log(chalk.dim(`  files clean:           ${cleanFiles}`));
+  console.log(chalk.dim(`  files with violations: ${summary.filesWithViolations}`));
+  console.log(chalk.dim(`  total violations:      ${summary.violations}
+`));
+  return summary;
+}
+async function startWatch(options = {}) {
+  const { projectRoot, watchPath } = resolveWatchPaths(options.path, options.projectRoot);
+  const config = loadConfig(projectRoot);
+  const exitOnSetupFailure = options.exitOnSetupFailure ?? true;
+  if (!config) {
+    const message = "No .memory-core.json found. Run: memory-core init";
+    console.error(chalk.red(`
+  ${message}
+`));
+    options.onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message });
+    if (exitOnSetupFailure) process.exit(1);
+    return;
+  }
+  const { rules, avoids } = getProfileRules(config);
+  if (rules.length === 0) {
+    const message = "No architecture rules configured in .memory-core.json \u2014 nothing to watch.";
+    console.log(chalk.yellow(`
+  ${message}
+`));
+    options.onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message });
+    if (exitOnSetupFailure) process.exit(0);
+    return;
+  }
+  resetLiveStats(projectRoot);
+  console.log(chalk.cyan("\n  archmind watch \u2014 real-time rule enforcement\n"));
+  console.log(chalk.dim(`  project:  ${projectRoot}`));
+  console.log(chalk.dim(`  watching: ${watchPath}`));
+  console.log(chalk.dim(`  model:    ${getChatProviderLabel()}`));
+  console.log(chalk.dim(`  rules:    ${rules.length}`));
+  if (options.autoFix) console.log(chalk.yellow("  mode:     auto-fix enabled \u2014 violations will be rewritten by AI"));
+  console.log(chalk.dim("  ctrl+c to stop\n"));
+  options.onEvent?.({
+    type: "ready",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    path: watchPath,
+    model: getChatProviderLabel(),
+    rules: rules.length
+  });
+  if (options.scanOnStart) {
+    console.log(chalk.dim("  running initial snapshot scan before watch events..."));
+    await runSnapshotScan(
+      projectRoot,
+      watchPath,
+      config,
+      options.verbose ?? false,
+      options.debug ?? false,
+      options.onEvent
+    );
+    console.log(chalk.dim("  initial scan complete.\n"));
+  }
+  const pending = /* @__PURE__ */ new Map();
+  const watcher = watch(watchPath, {
+    ignored: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/coverage/**",
+      "**/.memory-core*"
+    ],
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 }
+  });
+  const keepAlive = setInterval(() => {
+  }, 1 << 30);
+  const handle = (filePath) => {
+    if (!SOURCE_EXTENSIONS.test(filePath)) return;
+    if (pending.has(filePath)) clearTimeout(pending.get(filePath));
+    const timer = setTimeout(async () => {
+      pending.delete(filePath);
+      const rel = normalizeForGit(relative(projectRoot, filePath));
+      if (rel.startsWith("..")) return;
+      const timestamp = /* @__PURE__ */ new Date();
+      console.log(chalk.dim(`
+  [${timestamp.toLocaleTimeString()}] saved: ${rel}`));
+      options.onEvent?.({ type: "saved", timestamp: timestamp.toISOString(), file: rel });
+      const result = await checkFile(
+        filePath,
+        projectRoot,
+        config,
+        options.verbose ?? false,
+        options.debug ?? false,
+        "diff",
+        options.onEvent
+      );
+      if (result.type === "skipped") {
+        if (result.reason === "No changes compared with HEAD") {
+          recordWatchResult(projectRoot, rel, []);
+          options.onEvent?.({ type: "clean", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel });
+          return;
+        }
+        options.onEvent?.({ type: "skipped", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, reason: result.reason });
+        return;
+      }
+      if (result.type === "error") {
+        options.onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message: result.message });
+        return;
+      }
+      const { violations } = result;
+      if (violations.length === 0) {
+        options.onEvent?.({ type: "clean", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel });
+        return;
+      }
+      options.onEvent?.({ type: "violations", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, violations });
+      if (options.autoFix) {
+        const fixed = await autoFixFile(filePath, projectRoot, violations, rules, avoids, options.debug ?? false);
+        if (fixed) {
+          console.log(chalk.green(`  \u2713 Auto-fixed: ${rel} \u2014 re-checking\u2026
+`));
+          options.onEvent?.({ type: "log", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, message: "auto-fixed by AI" });
+        } else {
+          console.log(chalk.yellow(`  \u26A0  Auto-fix failed for ${rel} \u2014 fix manually.
+`));
+        }
+      }
+    }, 300);
+    pending.set(filePath, timer);
+  };
+  watcher.on("add", handle);
+  watcher.on("change", handle);
+  watcher.on("unlink", (filePath) => {
+    const rel = normalizeForGit(relative(projectRoot, filePath));
+    if (rel.startsWith("..")) return;
+    recordWatchResult(projectRoot, rel, []);
+    options.onEvent?.({ type: "clean", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel });
+  });
+  watcher.on("error", (err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`  watcher error: ${message}`));
+    options.onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message });
+  });
+  process.on("SIGINT", () => {
+    console.log(chalk.dim("\n\n  archmind watch stopped.\n"));
+    options.onEvent?.({ type: "stopped", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    clearInterval(keepAlive);
+    watcher.close();
+    process.exit(0);
+  });
+}
+
+// src/infrastructure/filesystem/chokidar-watch-service.ts
+var ChokidarWatchService = class {
+  async start(options = {}) {
+    await startWatch({
+      path: options.path,
+      verbose: options.verbose,
+      debug: options.debug,
+      scanOnStart: options.scanOnStart,
+      autoFix: options.autoFix
+    });
+  }
+  async scan(options = {}) {
+    return scanFiles({
+      path: options.path,
+      verbose: options.verbose,
+      debug: options.debug
+    });
+  }
+};
+
+// src/infrastructure/events/in-memory-event-bus.ts
+var InMemoryEventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  async publish(event) {
+    const handlers = this.handlers.get(event.type);
+    if (!handlers || handlers.size === 0) return;
+    for (const handler of handlers) {
+      await handler(event);
+    }
+  }
+  subscribe(eventType, handler) {
+    const existing = this.handlers.get(eventType) ?? /* @__PURE__ */ new Set();
+    existing.add(handler);
+    this.handlers.set(eventType, existing);
+    return () => {
+      const current = this.handlers.get(eventType);
+      if (!current) return;
+      current.delete(handler);
+      if (current.size === 0) {
+        this.handlers.delete(eventType);
+      }
+    };
+  }
+};
+
+// src/modules/memory-engine/application/memory-engine-service.ts
+var MemoryEngineService = class {
+  constructor(memoryRepository, embeddingProvider) {
+    this.memoryRepository = memoryRepository;
+    this.embeddingProvider = embeddingProvider;
+  }
+  memoryRepository;
+  embeddingProvider;
+  withReason(input) {
+    const reason = input.reason?.trim();
+    return {
+      ...input,
+      reason: reason || `Captured as a ${input.type} memory because it should be remembered: ${input.content}`
+    };
+  }
+  async remember(input) {
+    const normalized = this.withReason(input);
+    const embedding = await this.embeddingProvider.embed(normalized.content);
+    return this.memoryRepository.upsert({ ...normalized, embedding });
+  }
+  async rememberForce(input) {
+    const normalized = this.withReason(input);
+    const embedding = await this.embeddingProvider.embed(normalized.content);
+    await this.memoryRepository.save({ ...normalized, embedding });
+  }
+  async list(filters = {}) {
+    return this.memoryRepository.list(filters);
   }
   async getById(id) {
     return this.memoryRepository.getById(id);
@@ -1395,183 +2116,8 @@ var RuleEngineService = class {
 };
 
 // src/modules/graph-engine/application/graph-engine-service.ts
-import { readdirSync, statSync } from "fs";
-import { join as join5, relative, resolve as resolve2 } from "path";
-
-// src/infrastructure/ast/import-analysis.ts
-import { builtinModules } from "module";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, extname, isAbsolute, join as join4, normalize, resolve } from "path";
-var SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-var NODE_BUILTINS = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((entry) => `node:${entry}`)]);
-function countNewlines(value) {
-  let count = 0;
-  for (const char of value) {
-    if (char === "\n") count += 1;
-  }
-  return count;
-}
-function parseImports(source) {
-  const imports = [];
-  const patterns = [
-    { kind: "import", regex: /(^|\n)\s*import\s+(?:type\s+)?(?:[^'"\n]+?\s+from\s+)?['"]([^'"\n]+)['"]/g },
-    { kind: "export-from", regex: /(^|\n)\s*export\s+(?:type\s+)?(?:[^'"\n]+?\s+from\s+)['"]([^'"\n]+)['"]/g },
-    { kind: "require", regex: /(^|\n)[^\n]*?\brequire\(\s*['"]([^'"\n]+)['"]\s*\)/g },
-    { kind: "dynamic-import", regex: /(^|\n)[^\n]*?\bimport\(\s*['"]([^'"\n]+)['"]\s*\)/g }
-  ];
-  for (const { kind, regex } of patterns) {
-    for (const match of source.matchAll(regex)) {
-      const prefix = source.slice(0, match.index ?? 0);
-      imports.push({
-        kind,
-        specifier: match[2],
-        line: countNewlines(prefix) + 1
-      });
-    }
-  }
-  return imports;
-}
-function tryResolveFilePath(candidate) {
-  if (existsSync4(candidate)) return normalize(candidate);
-  if (!extname(candidate)) {
-    for (const ext of SOURCE_EXTENSIONS) {
-      const withExt = `${candidate}${ext}`;
-      if (existsSync4(withExt)) return normalize(withExt);
-    }
-    for (const ext of SOURCE_EXTENSIONS) {
-      const indexFile = join4(candidate, `index${ext}`);
-      if (existsSync4(indexFile)) return normalize(indexFile);
-    }
-  }
-  return void 0;
-}
-function looksLikeExternal(specifier) {
-  return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("@/");
-}
-function resolveImportPath(fromFile, specifier, cwd = process.cwd()) {
-  if (specifier.startsWith(".")) {
-    return tryResolveFilePath(resolve(dirname2(fromFile), specifier));
-  }
-  if (specifier.startsWith("/")) {
-    return tryResolveFilePath(resolve(cwd, `.${specifier}`));
-  }
-  if (specifier.startsWith("@/")) {
-    return tryResolveFilePath(resolve(cwd, "src", specifier.slice(2)));
-  }
-  if (isAbsolute(specifier)) {
-    return tryResolveFilePath(specifier);
-  }
-  return void 0;
-}
-function collectResolvedImports(filePath, cwd = process.cwd()) {
-  if (!existsSync4(filePath)) return [];
-  const source = readFileSync3(filePath, "utf-8");
-  const imports = parseImports(source);
-  return imports.map((entry) => {
-    if (looksLikeExternal(entry.specifier) || NODE_BUILTINS.has(entry.specifier)) {
-      return { ...entry, isExternal: true };
-    }
-    return {
-      ...entry,
-      isExternal: false,
-      resolvedPath: resolveImportPath(filePath, entry.specifier, cwd)
-    };
-  });
-}
-function asPosix3(value) {
-  return value.replace(/\\/g, "/");
-}
-function moduleNameFromPath(absPath, cwd = process.cwd()) {
-  const rel = asPosix3(normalize(absPath)).replace(asPosix3(normalize(cwd)) + "/", "");
-  const match = rel.match(/^src\/modules\/([^/]+)\//);
-  return match?.[1];
-}
-function buildModuleDependencyEdges(files, cwd = process.cwd()) {
-  const edges = [];
-  for (const file of files) {
-    const absoluteFile = resolve(cwd, file);
-    const fromModule = moduleNameFromPath(absoluteFile, cwd);
-    if (!fromModule) continue;
-    const imports = collectResolvedImports(absoluteFile, cwd);
-    for (const imp of imports) {
-      if (!imp.resolvedPath) continue;
-      const toModule = moduleNameFromPath(imp.resolvedPath, cwd);
-      if (!toModule || toModule === fromModule) continue;
-      edges.push({
-        fromModule,
-        toModule,
-        file,
-        line: imp.line
-      });
-    }
-  }
-  return edges;
-}
-function parseChangedFilesFromDiff(diff) {
-  const files = /* @__PURE__ */ new Set();
-  for (const line of diff.split("\n")) {
-    if (!line.startsWith("+++ b/")) continue;
-    const file = line.slice("+++ b/".length).trim();
-    if (!file || file === "/dev/null") continue;
-    files.add(file);
-  }
-  return [...files];
-}
-function detectModuleCycles(edges) {
-  const graph = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    const next = graph.get(edge.fromModule) ?? /* @__PURE__ */ new Set();
-    next.add(edge.toModule);
-    graph.set(edge.fromModule, next);
-  }
-  const visited = /* @__PURE__ */ new Set();
-  const stack = /* @__PURE__ */ new Set();
-  const cycles = /* @__PURE__ */ new Set();
-  const visit = (node, path) => {
-    visited.add(node);
-    stack.add(node);
-    const next = graph.get(node) ?? /* @__PURE__ */ new Set();
-    for (const target of next) {
-      if (!visited.has(target)) {
-        visit(target, [...path, target]);
-        continue;
-      }
-      if (stack.has(target)) {
-        const start = path.indexOf(target);
-        const cycle = start >= 0 ? path.slice(start).concat(target) : [node, target, node];
-        cycles.add(cycle.join("->"));
-      }
-    }
-    stack.delete(node);
-  };
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      visit(node, [node]);
-    }
-  }
-  return [...cycles].map((value) => value.split("->"));
-}
-function isExternalFrameworkSpecifier(specifier) {
-  const frameworkPrefixes = [
-    "express",
-    "fastify",
-    "@nestjs/",
-    "react",
-    "vue",
-    "svelte",
-    "@angular/",
-    "next/",
-    "nuxt",
-    "typeorm",
-    "@prisma/",
-    "mongoose",
-    "sequelize",
-    "axios"
-  ];
-  return frameworkPrefixes.some((prefix) => specifier === prefix || specifier.startsWith(`${prefix}/`));
-}
-
-// src/modules/graph-engine/application/graph-engine-service.ts
+import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join6, relative as relative2, resolve as resolve3 } from "path";
 var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var IGNORED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", "coverage", ".memory-core"]);
 function isSourceFile(pathValue) {
@@ -1606,19 +2152,19 @@ var GraphEngineService = class {
   }
   graphRepository;
   async buildGraph(options = {}) {
-    const cwd = resolve2(options.cwd ?? process.cwd());
+    const cwd = resolve3(options.cwd ?? process.cwd());
     const files = this.collectSourceFiles(cwd);
     const nodes = /* @__PURE__ */ new Set();
     const edges = /* @__PURE__ */ new Map();
     for (const relativeFile of files) {
-      const absoluteFile = resolve2(cwd, relativeFile);
+      const absoluteFile = resolve3(cwd, relativeFile);
       const fromNode = normalizeNode(relativeFile);
       nodes.add(fromNode);
       const imports = collectResolvedImports(absoluteFile, cwd);
       for (const imp of imports) {
         let toNode;
         if (imp.resolvedPath) {
-          toNode = normalizeNode(asPosix4(relative(cwd, imp.resolvedPath)));
+          toNode = normalizeNode(asPosix4(relative2(cwd, imp.resolvedPath)));
         } else if (imp.isExternal) {
           toNode = `pkg:${imp.specifier}`;
         }
@@ -1687,15 +2233,15 @@ var GraphEngineService = class {
   collectSourceFiles(cwd) {
     const files = [];
     const walk = (dir) => {
-      for (const entry of readdirSync(dir)) {
+      for (const entry of readdirSync2(dir)) {
         if (IGNORED_DIRS.has(entry)) continue;
-        const absolutePath = join5(dir, entry);
-        const stat = statSync(absolutePath);
+        const absolutePath = join6(dir, entry);
+        const stat = statSync2(absolutePath);
         if (stat.isDirectory()) {
           walk(absolutePath);
           continue;
         }
-        const rel = asPosix4(relative(cwd, absolutePath));
+        const rel = asPosix4(relative2(cwd, absolutePath));
         if (isSourceFile(rel)) files.push(rel);
       }
     };
@@ -1837,11 +2383,11 @@ function getStackReason(memory, activeArchitectures2) {
     reason: `excluded: tagged for ${architectureKeys.join(", ")}; active stack is ${active}`
   };
 }
-function inferProjectArchitectures(cwd = process.cwd(), config2) {
+function inferProjectArchitectures(cwd = process.cwd(), config) {
   const inferred = /* @__PURE__ */ new Set();
-  if (config2?.backendArchitecture) inferred.add(config2.backendArchitecture);
-  if (config2?.frontendFramework) inferred.add(config2.frontendFramework);
-  if (config2?.projectType === "backend" && !config2.backendArchitecture) {
+  if (config?.backendArchitecture && config.backendArchitecture !== "custom") inferred.add(config.backendArchitecture);
+  if (config?.frontendFramework && config.frontendFramework !== "custom") inferred.add(config.frontendFramework);
+  if (config?.projectType === "backend" && !config.backendArchitecture) {
     inferred.add("clean-architecture");
   }
   const detected = detectProject(cwd);
@@ -1850,14 +2396,14 @@ function inferProjectArchitectures(cwd = process.cwd(), config2) {
   }
   return [...inferred];
 }
-function getAllowPatterns(config2) {
-  return [...new Set(config2?.allowPatterns?.filter(Boolean) ?? [])];
+function getAllowPatterns(config) {
+  return [...new Set(config?.allowPatterns?.filter(Boolean) ?? [])];
 }
-function filterRelevantMemories(memories, config2, cwd = process.cwd()) {
-  return explainMemorySelection(memories, config2, cwd).included;
+function filterRelevantMemories(memories, config, cwd = process.cwd()) {
+  return explainMemorySelection(memories, config, cwd).included;
 }
-function explainMemorySelection(memories, config2, cwd = process.cwd(), threshold = 0.8) {
-  const activeArchitectures2 = inferProjectArchitectures(cwd, config2);
+function explainMemorySelection(memories, config, cwd = process.cwd(), threshold = 0.8) {
+  const activeArchitectures2 = inferProjectArchitectures(cwd, config);
   const activeSet = new Set(activeArchitectures2);
   const included = [];
   const decisions = [];
@@ -1934,7 +2480,7 @@ async function retrieveMemorySelection(options) {
 // src/generator.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname3(__filename);
-var PKG_ROOT = join6(__dirname, "..");
+var PKG_ROOT = join7(__dirname, "..");
 function stringifyProfileScalar(value) {
   if (typeof value === "string") {
     const trimmed = value.trim();
@@ -2022,15 +2568,18 @@ Handlebars.registerHelper("memoryBlock", (memory) => {
   return new Handlebars.SafeString(lines.join("\n"));
 });
 function loadProfile(name) {
-  const profilePath = join6(PKG_ROOT, "profiles", `${name}.yml`);
-  if (!existsSync5(profilePath)) throw new Error(`Profile not found: ${name}`);
-  return normalizeArchitectureProfile(yaml.load(readFileSync4(profilePath, "utf-8")), name);
+  if (name === "custom") {
+    return { name: "custom", displayName: "Custom", layer: "backend", description: "Custom architecture \u2014 rules added via memory-core remember", rules: [], folders: [], avoid: [] };
+  }
+  const profilePath = join7(PKG_ROOT, "profiles", `${name}.yml`);
+  if (!existsSync6(profilePath)) throw new Error(`Profile not found: ${name}`);
+  return normalizeArchitectureProfile(yaml.load(readFileSync6(profilePath, "utf-8")), name);
 }
 function listProfiles(layer) {
-  const files = readdirSync2(join6(PKG_ROOT, "profiles")).filter((f) => f.endsWith(".yml"));
+  const files = readdirSync3(join7(PKG_ROOT, "profiles")).filter((f) => f.endsWith(".yml"));
   const all = files.map(
     (f) => normalizeArchitectureProfile(
-      yaml.load(readFileSync4(join6(PKG_ROOT, "profiles", f), "utf-8")),
+      yaml.load(readFileSync6(join7(PKG_ROOT, "profiles", f), "utf-8")),
       basename(f, ".yml")
     )
   );
@@ -2100,18 +2649,18 @@ function buildTemplateData(options, cwd = process.cwd()) {
   };
 }
 function renderTemplate(templateName, data) {
-  const templatePath = join6(PKG_ROOT, "templates", templateName);
-  if (!existsSync5(templatePath)) throw new Error(`Template not found: ${templateName}`);
-  return Handlebars.compile(readFileSync4(templatePath, "utf-8"))(data);
+  const templatePath = join7(PKG_ROOT, "templates", templateName);
+  if (!existsSync6(templatePath)) throw new Error(`Template not found: ${templateName}`);
+  return Handlebars.compile(readFileSync6(templatePath, "utf-8"))(data);
 }
 function writeFile(filePath, content) {
   const dir = dirname3(filePath);
-  if (!existsSync5(dir)) mkdirSync2(dir, { recursive: true });
-  if (existsSync5(filePath)) {
-    const existing = readFileSync4(filePath, "utf-8");
+  if (!existsSync6(dir)) mkdirSync2(dir, { recursive: true });
+  if (existsSync6(filePath)) {
+    const existing = readFileSync6(filePath, "utf-8");
     if (existing === content) return "skipped";
   }
-  writeFileSync2(filePath, content, "utf-8");
+  writeFileSync4(filePath, content, "utf-8");
   return "written";
 }
 async function generate(options, cwd = process.cwd(), onlyAgents) {
@@ -2120,373 +2669,280 @@ async function generate(options, cwd = process.cwd(), onlyAgents) {
   const skipped = [];
   const files = onlyAgents ? OUTPUT_FILES.filter((f) => onlyAgents.includes(f.agent)) : OUTPUT_FILES;
   for (const output of files) {
-    const targetPath = join6(cwd, output.path);
-    if (output.skipIfExists && existsSync5(targetPath)) {
+    const targetPath = join7(cwd, output.path);
+    if (output.skipIfExists && existsSync6(targetPath)) {
       skipped.push(output.path);
-      continue;
-    }
-    try {
-      const content = renderTemplate(output.template, data);
-      const result = writeFile(targetPath, content);
-      if (result === "written") written.push(output.path);
-      else skipped.push(output.path);
-    } catch (err) {
-      if (!(err instanceof Error && err.message.includes("Template not found"))) throw err;
-    }
-  }
-  return { written, skipped };
-}
-
-// src/modules/rule-engine/infrastructure/ast-deterministic-violations.ts
-import { resolve as resolve3 } from "path";
-function asPosix5(value) {
-  return value.replace(/\\/g, "/");
-}
-function hasPath(value, pathSegment) {
-  const normalized = asPosix5(value);
-  const trimmed = pathSegment.startsWith("/") ? pathSegment.slice(1) : pathSegment;
-  return normalized.includes(pathSegment) || normalized.includes(trimmed);
-}
-function isLegacyOrCompatibilitySpecifier(specifier) {
-  const normalized = asPosix5(specifier);
-  return normalized.includes("/compatibility/") || normalized.includes("compatibility/") || normalized.includes("legacy-");
-}
-function isLegacyOrCompatibilityPath(pathValue) {
-  if (!pathValue) return false;
-  const normalized = asPosix5(pathValue);
-  return normalized.includes("/src/compatibility/") || normalized.includes("/legacy-");
-}
-function moduleNameFromPath2(pathValue) {
-  const match = asPosix5(pathValue).match(/src\/modules\/([^/]+)\//);
-  return match?.[1];
-}
-function isModulePublicPath(pathValue) {
-  const normalized = asPosix5(pathValue);
-  return /src\/modules\/[^/]+\/(public|api)\//.test(normalized) || /src\/modules\/[^/]+\/index\.(ts|tsx|js|jsx|mjs|cjs)$/.test(normalized);
-}
-function detectCleanLayer(pathValue) {
-  const normalized = asPosix5(pathValue);
-  if (hasPath(normalized, "/src/domain/") || hasPath(normalized, "/src/core/domain/")) return "domain";
-  if (hasPath(normalized, "/src/application/") || hasPath(normalized, "/src/core/application/")) return "application";
-  if (hasPath(normalized, "/src/infrastructure/")) return "infrastructure";
-  if (hasPath(normalized, "/src/interfaces/")) return "interface";
-  return "unknown";
-}
-function detectHexLayer(pathValue) {
-  const normalized = asPosix5(pathValue);
-  if (hasPath(normalized, "/src/core/")) return "core";
-  if (hasPath(normalized, "/src/adapters/inbound/")) return "adapter-inbound";
-  if (hasPath(normalized, "/src/adapters/outbound/")) return "adapter-outbound";
-  if (hasPath(normalized, "/src/adapters/")) return "adapter-other";
-  return "unknown";
-}
-function activeArchitectures(config2, rules = []) {
-  const names = /* @__PURE__ */ new Set();
-  if (config2?.backendArchitecture) names.add(config2.backendArchitecture);
-  if (config2?.frontendFramework) names.add(config2.frontendFramework);
-  const text = rules.join("\n").toLowerCase();
-  if (text.includes("modular monolith")) names.add("modular-monolith");
-  if (text.includes("clean architecture")) names.add("clean-architecture");
-  if (text.includes("hexagonal")) names.add("hexagonal");
-  return names;
-}
-function pushUnique(target, incoming) {
-  if (target.some(
-    (entry) => entry.rule === incoming.rule && entry.file === incoming.file && entry.line === incoming.line && entry.issue === incoming.issue
-  )) {
-    return;
-  }
-  target.push(incoming);
-}
-function evaluateFile(file, options) {
-  const cwd = options.cwd ?? process.cwd();
-  const rules = options.rules ?? [];
-  const architectures = activeArchitectures(options.config, rules);
-  const reasonLookup = options.reasonLookup ?? /* @__PURE__ */ new Map();
-  const violations = [];
-  const absFile = resolve3(cwd, file);
-  const normalizedFile = asPosix5(file);
-  const imports = collectResolvedImports(absFile, cwd);
-  const fromCleanLayer = detectCleanLayer(normalizedFile);
-  const fromHexLayer = detectHexLayer(normalizedFile);
-  for (const imp of imports) {
-    const target = imp.resolvedPath ? asPosix5(imp.resolvedPath) : void 0;
-    if (isLegacyOrCompatibilitySpecifier(imp.specifier) || isLegacyOrCompatibilityPath(target)) {
-      const rule = "Application code must not import compatibility or legacy adapter paths";
-      pushUnique(violations, {
-        rule,
-        file,
-        line: imp.line,
-        issue: `Import references a removed migration path: ${imp.specifier}`,
-        suggestion: "Import module services/ports from src/app, src/modules, src/shared/ports, or current infrastructure adapters.",
-        reason: reasonLookup.get(rule)
-      });
-    }
-    if (architectures.has("modular-monolith")) {
-      const fromModule = moduleNameFromPath2(normalizedFile);
-      const toModule = target ? moduleNameFromPath2(target) : void 0;
-      if (fromModule && toModule && target && fromModule !== toModule && !isModulePublicPath(target)) {
-        const rule = "Modules communicate only through public interfaces or events \u2014 never by importing internals";
-        pushUnique(violations, {
-          rule,
-          file,
-          line: imp.line,
-          issue: `Cross-module import from "${fromModule}" to private path in module "${toModule}"`,
-          suggestion: `Expose a public API from src/modules/${toModule}/index.ts (or public/) and import through it.`,
-          reason: reasonLookup.get(rule)
-        });
-      }
-    }
-    if (architectures.has("clean-architecture")) {
-      const toCleanLayer = target ? detectCleanLayer(target) : "unknown";
-      if (fromCleanLayer === "domain" && ["application", "infrastructure", "interface"].includes(toCleanLayer)) {
-        const rule = "Entities encapsulate core business logic and have no external dependencies";
-        pushUnique(violations, {
-          rule,
-          file,
-          line: imp.line,
-          issue: `Domain layer imports ${toCleanLayer} layer: ${imp.specifier}`,
-          suggestion: "Keep domain isolated and move orchestration concerns into application layer.",
-          reason: reasonLookup.get(rule)
-        });
-      }
-      if (fromCleanLayer === "application" && (toCleanLayer === "infrastructure" || toCleanLayer === "interface")) {
-        const rule = "Infrastructure layer (DB, HTTP, queues) depends on application \u2014 never the reverse";
-        pushUnique(violations, {
-          rule,
-          file,
-          line: imp.line,
-          issue: `Application layer imports ${toCleanLayer} layer: ${imp.specifier}`,
-          suggestion: "Invert dependency via repository/port interface in application layer.",
-          reason: reasonLookup.get(rule)
-        });
-      }
-      if (fromCleanLayer === "interface" && toCleanLayer === "infrastructure") {
-        const rule = "Controllers must only validate input and delegate to use cases";
-        pushUnique(violations, {
-          rule,
-          file,
-          line: imp.line,
-          issue: `Interface/controller layer imports infrastructure directly: ${imp.specifier}`,
-          suggestion: "Delegate to application use cases instead of calling infrastructure directly.",
-          reason: reasonLookup.get(rule)
-        });
-      }
-      if (fromCleanLayer === "domain" && imp.isExternal && isExternalFrameworkSpecifier(imp.specifier)) {
-        const rule = "Domain layer must not import any framework or library code";
-        pushUnique(violations, {
-          rule,
-          file,
-          line: imp.line,
-          issue: `Domain file imports framework package: ${imp.specifier}`,
-          suggestion: "Keep domain pure. Move framework-specific logic to infrastructure/adapters.",
-          reason: reasonLookup.get(rule)
-        });
-      }
-    }
-    if (architectures.has("hexagonal")) {
-      const toHexLayer = target ? detectHexLayer(target) : "unknown";
-      if (fromHexLayer === "core" && (toHexLayer === "adapter-inbound" || toHexLayer === "adapter-outbound" || toHexLayer === "adapter-other")) {
-        const rule = "Direct imports of adapter code inside the core";
-        pushUnique(violations, {
-          rule,
-          file,
-          line: imp.line,
-          issue: `Core imports adapter path directly: ${imp.specifier}`,
-          suggestion: "Define a core port and resolve adapter at composition root.",
-          reason: reasonLookup.get(rule)
-        });
-      }
-      const crossAdapterBoundary = fromHexLayer === "adapter-inbound" && (toHexLayer === "adapter-outbound" || toHexLayer === "adapter-other") || fromHexLayer === "adapter-outbound" && (toHexLayer === "adapter-inbound" || toHexLayer === "adapter-other");
-      if (crossAdapterBoundary) {
-        const rule = "Adapters implement ports \u2014 one adapter per external system (DB, HTTP, queue, etc.)";
-        pushUnique(violations, {
-          rule,
-          file,
-          line: imp.line,
-          issue: `Adapter imports another adapter layer directly: ${imp.specifier}`,
-          suggestion: "Route adapter collaboration through core ports/use-cases, not direct adapter imports.",
-          reason: reasonLookup.get(rule)
-        });
-      }
+      continue;
     }
-  }
-  return violations;
-}
-function findAstDeterministicViolationsForFile(file, options = {}) {
-  return evaluateFile(file, options);
-}
-function findAstDeterministicViolationsForDiff(diff, options = {}) {
-  const files = parseChangedFilesFromDiff(diff).filter((file) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(file));
-  const violations = [];
-  for (const file of files) {
-    for (const violation of evaluateFile(file, options)) {
-      pushUnique(violations, violation);
+    try {
+      const content = renderTemplate(output.template, data);
+      const result = writeFile(targetPath, content);
+      if (result === "written") written.push(output.path);
+      else skipped.push(output.path);
+    } catch (err) {
+      if (!(err instanceof Error && err.message.includes("Template not found"))) throw err;
     }
   }
-  const architectures = activeArchitectures(options.config, options.rules ?? []);
-  if (architectures.has("modular-monolith")) {
-    const edges = buildModuleDependencyEdges(files, options.cwd ?? process.cwd());
-    const cycles = detectModuleCycles(edges);
-    for (const cycle of cycles) {
-      const representative = edges.find((edge) => edge.fromModule === cycle[0] && edge.toModule === cycle[1]);
-      if (!representative) continue;
-      const rule = "No circular dependencies between modules";
-      pushUnique(violations, {
-        rule,
-        file: representative.file,
-        line: representative.line,
-        issue: `Module dependency cycle detected: ${cycle.join(" -> ")}`,
-        suggestion: "Break the cycle by introducing a public port/event or moving shared logic into src/shared.",
-        reason: options.reasonLookup?.get(rule)
-      });
+  return { written, skipped };
+}
+
+// src/hook.ts
+var reasonMap2 = new Map(
+  seeds.filter((s) => s.reason).map((s) => [s.content, s.reason])
+);
+var HOOK_PATH = join8(".git", "hooks", "pre-commit");
+var HOOK_MARKER = "# archmind-memory-core";
+var COMMIT_MSG_HOOK_PATH = join8(".git", "hooks", "commit-msg");
+var COMMIT_MSG_HOOK_MARKER = "# archmind-memory-core commit-msg";
+var RULE_CACHE_FILE = ".memory-core-rules-cache.json";
+var DB_VERSION_FILE = ".memory-core-db-version";
+var RULE_CACHE_TTL_MS = 5 * 60 * 1e3;
+function buildHookBody(advisory, fast = false) {
+  const suffix = advisory ? " || true" : "";
+  const checkArgs = fast ? "check --staged --fast" : "check --staged";
+  return `${HOOK_MARKER}${advisory ? " advisory" : ""}
+if [ "\${MEMORY_CORE_SKIP_HOOK:-}" = "1" ] || [ "\${ARCHMIND_SKIP_HOOK:-}" = "1" ] || [ "\${HUSKY:-}" = "0" ] || [ "\${HUSKY_SKIP_HOOKS:-}" = "1" ]; then
+  if command -v memory-core >/dev/null 2>&1 && [ -t 1 ]; then
+    memory-core hook bypass-prompt
+  fi
+  exit 0
+fi
+if [ -n "\${SKIP:-}" ] && echo ",$SKIP," | grep -qiE ',(memory-core|archmind),'; then
+  if command -v memory-core >/dev/null 2>&1 && [ -t 1 ]; then
+    memory-core hook bypass-prompt
+  fi
+  exit 0
+fi
+if [ -n "\${SKIP_HOOKS:-}" ]; then
+  exit 0
+fi
+if command -v memory-core >/dev/null 2>&1; then
+  memory-core ${checkArgs}${suffix}
+elif [ -f "./node_modules/.bin/memory-core" ]; then
+  ./node_modules/.bin/memory-core ${checkArgs}${suffix}
+elif [ -f "./dist/cli.js" ]; then
+  node ./dist/cli.js ${checkArgs}${suffix}
+else
+  exit 0
+fi
+`;
+}
+function buildHookScript(advisory, fast = false) {
+  return `#!/bin/sh
+
+${buildHookBody(advisory, fast)}`;
+}
+function normalizeHookPreamble(content) {
+  const lines = content.split("\n");
+  const normalized = [];
+  let shebangSeen = false;
+  for (const line of lines) {
+    if (/^\s*#!\/bin\/sh\s*$/.test(line)) {
+      if (shebangSeen) continue;
+      shebangSeen = true;
+      normalized.push("#!/bin/sh");
+      continue;
     }
+    normalized.push(line);
   }
-  return violations;
+  return normalized.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
-
-// src/watcher.ts
-function getFileLines(filePath) {
+function toRuleStatEntry(raw) {
+  if (raw === void 0) return { count: 0, falsePositives: 0 };
+  if (typeof raw === "number") return { count: raw, falsePositives: 0 };
+  return raw;
+}
+function readPositiveIntEnv(name, fallback) {
+  const raw = Number(process.env[name]);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : fallback;
+}
+function isFastCheck(options) {
+  return options.fast === true || process.env.MEMORY_CORE_CHECK_FAST === "1";
+}
+async function withTimeout(promise, timeoutMs, fallback) {
+  let timer;
   try {
-    return readFileSync5(filePath, "utf-8").split("\n");
-  } catch {
-    return [];
+    return await Promise.race([
+      promise,
+      new Promise((resolve4) => {
+        timer = setTimeout(() => resolve4(fallback), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
   }
 }
-function printCodeContext(filePath, line, contextLines = 2) {
-  const lines = getFileLines(filePath);
-  if (lines.length === 0) return;
-  const start = Math.max(0, line - 1 - contextLines);
-  const end = Math.min(lines.length - 1, line - 1 + contextLines);
-  console.log(chalk.dim("      \u250C\u2500 code \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"));
-  for (let i = start; i <= end; i++) {
-    const lineNum = String(i + 1).padStart(4, " ");
-    const isViolation = i === line - 1;
-    if (isViolation) {
-      console.log(chalk.red(`      \u2502 ${lineNum}  \u25B6  ${lines[i]}`));
-    } else {
-      console.log(chalk.dim(`      \u2502 ${lineNum}     ${lines[i]}`));
+function recordViolations(violations, source = "hook") {
+  const statsPath = join8(process.cwd(), ".memory-core-stats.json");
+  let stats = { rules: {}, files: {} };
+  if (existsSync7(statsPath)) {
+    try {
+      stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
+    } catch {
+      stats = { rules: {}, files: {} };
     }
   }
-  console.log(chalk.dim("      \u2514\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"));
-}
-function formatCodeContext(filePath, line, contextLines = 2) {
-  const lines = getFileLines(filePath);
-  if (lines.length === 0) return void 0;
-  const start = Math.max(0, line - 1 - contextLines);
-  const end = Math.min(lines.length - 1, line - 1 + contextLines);
-  return Array.from({ length: end - start + 1 }, (_, index) => {
-    const current = start + index;
-    const lineNum = String(current + 1).padStart(4, " ");
-    const marker = current === line - 1 ? ">" : " ";
-    return `${lineNum} ${marker} ${lines[current]}`;
-  }).join("\n");
+  stats.rules ??= {};
+  stats.files ??= {};
+  for (const violation of violations) {
+    const existing = toRuleStatEntry(stats.rules[violation.rule]);
+    stats.rules[violation.rule] = { count: existing.count + 1, falsePositives: existing.falsePositives };
+    if (violation.file) stats.files[violation.file] = (stats.files[violation.file] ?? 0) + 1;
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const recent = violations.map((violation) => ({ ...violation, timestamp, source }));
+  stats.recentViolations = [...recent, ...stats.recentViolations ?? []].slice(0, 50);
+  writeFileSync5(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
 }
-var SOURCE_EXTENSIONS3 = /\.(ts|tsx|js|jsx|py|php|rb|go|java|cs|swift|kt|rs|vue|svelte)$/;
-var reasonMap = new Map(
-  seeds.filter((s) => s.reason).map((s) => [s.content, s.reason])
-);
-function findProjectRoot(startPath) {
-  let current = resolve4(startPath);
-  while (true) {
-    if (existsSync6(join7(current, ".memory-core.json"))) return current;
-    const parent = dirname4(current);
-    if (parent === current) return null;
-    current = parent;
+function resetViolationStats(cwd = process.cwd()) {
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  if (!existsSync7(statsPath)) return;
+  let stats = {};
+  try {
+    const parsed = JSON.parse(readFileSync7(statsPath, "utf-8"));
+    if (parsed && typeof parsed === "object") {
+      stats = parsed;
+    }
+  } catch {
+    stats = {};
   }
+  stats.rules = {};
+  stats.files = {};
+  stats.recentViolations = [];
+  writeFileSync5(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
 }
-function resolveWatchPaths(pathOption, projectRootOption) {
-  if (projectRootOption) {
-    const projectRoot2 = resolve4(projectRootOption);
-    return {
-      projectRoot: projectRoot2,
-      watchPath: resolve4(projectRoot2, pathOption ?? ".")
-    };
+function recordBypass(hadReason, cwd = process.cwd()) {
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  let stats = { rules: {}, files: {} };
+  if (existsSync7(statsPath)) {
+    try {
+      stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
+    } catch {
+    }
   }
-  const cwdRoot = resolve4(process.cwd());
-  const watchPath = resolve4(cwdRoot, pathOption ?? ".");
-  const projectRoot = findProjectRoot(watchPath) ?? findProjectRoot(cwdRoot) ?? cwdRoot;
-  return { projectRoot, watchPath };
+  const prev = stats.bypasses ?? { total: 0, withReason: 0, withoutReason: 0 };
+  stats.bypasses = {
+    total: prev.total + 1,
+    withReason: prev.withReason + (hadReason ? 1 : 0),
+    withoutReason: prev.withoutReason + (hadReason ? 0 : 1)
+  };
+  writeFileSync5(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+  return stats.bypasses;
 }
-function readStatsFile(statsPath) {
-  if (!existsSync6(statsPath)) return { rules: {}, files: {} };
+function readBypassStats(cwd = process.cwd()) {
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  if (!existsSync7(statsPath)) return { total: 0, withReason: 0, withoutReason: 0 };
   try {
-    return JSON.parse(readFileSync5(statsPath, "utf-8"));
+    const stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
+    return stats.bypasses ?? { total: 0, withReason: 0, withoutReason: 0 };
   } catch {
-    return { rules: {}, files: {} };
+    return { total: 0, withReason: 0, withoutReason: 0 };
   }
 }
-function rebuildLiveCounters(byFile) {
-  const rules = {};
-  const files = {};
-  for (const [file, violations] of Object.entries(byFile)) {
-    if (!Array.isArray(violations) || violations.length === 0) continue;
-    files[file] = violations.length;
-    for (const violation of violations) {
-      rules[violation.rule] = (rules[violation.rule] ?? 0) + 1;
+function accumulateTokenUsage(usage, cwd = process.cwd()) {
+  if (!usage) return;
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  let stats = { rules: {}, files: {} };
+  if (existsSync7(statsPath)) {
+    try {
+      stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
+    } catch {
     }
   }
-  return { rules, files };
-}
-function resetLiveStats(cwd) {
-  const statsPath = join7(cwd, ".memory-core-stats.json");
-  const stats = readStatsFile(statsPath);
-  stats.rules ??= {};
-  stats.files ??= {};
-  stats.live = {
-    rules: {},
-    files: {},
-    byFile: {}
+  const prev = stats.tokens ?? { calls: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  stats.tokens = {
+    calls: prev.calls + 1,
+    inputTokens: prev.inputTokens + usage.inputTokens,
+    outputTokens: prev.outputTokens + usage.outputTokens,
+    totalTokens: prev.totalTokens + usage.totalTokens
   };
-  writeFileSync3(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+  writeFileSync5(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
 }
-function recordWatchResult(cwd, file, violations) {
-  const statsPath = join7(cwd, ".memory-core-stats.json");
-  const stats = readStatsFile(statsPath);
-  stats.rules ??= {};
-  stats.files ??= {};
-  stats.live ??= { rules: {}, files: {}, byFile: {} };
-  stats.live.byFile ??= {};
-  if (violations.length === 0) {
-    delete stats.live.byFile[file];
-  } else {
-    stats.live.byFile[file] = violations;
+async function promptToSaveViolations(violations) {
+  if (!process.stdin.isTTY || violations.length === 0) return;
+  try {
+    const app = getDefaultApplicationContainer();
+    const { confirm, input } = await import("@inquirer/prompts");
+    const save = await confirm({
+      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 input({ message: `Which violation? ${choices.join(" | ")}`, default: "1" })) - 1] ?? violations[0];
+    const reason = await input({
+      message: "Why should this rule exist?",
+      default: selected.reason ?? selected.issue ?? ""
+    });
+    const storedReason = reason.trim() || selected.reason || selected.issue || `Captured from violation: ${selected.rule}`;
+    await app.services.memoryEngine.remember({
+      type: "rule",
+      scope: "project",
+      content: selected.rule,
+      reason: storedReason,
+      tags: ["violation"]
+    });
+    console.log(chalk2.green("  \u2713 Saved as project rule. Run memory-core sync to propagate it.\n"));
+  } catch (err) {
+    console.log(chalk2.yellow(`  Could not save violation: ${err.message}
+`));
   }
-  const live = rebuildLiveCounters(stats.live.byFile);
-  stats.live.rules = live.rules;
-  stats.live.files = live.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;
+}
+function readRuleCache(cwd) {
+  const cachePath = join8(cwd, RULE_CACHE_FILE);
+  const configPath = join8(cwd, ".memory-core.json");
+  if (!existsSync7(cachePath) || !existsSync7(configPath)) return null;
+  try {
+    const entry = JSON.parse(readFileSync7(cachePath, "utf-8"));
+    const now = Date.now();
+    if (now - entry.timestamp > RULE_CACHE_TTL_MS) return null;
+    const configMtime = statSync3(configPath).mtimeMs;
+    if (configMtime !== entry.configMtime) return null;
+    const dbVersionPath = join8(cwd, DB_VERSION_FILE);
+    const dbVersionMtime = existsSync7(dbVersionPath) ? statSync3(dbVersionPath).mtimeMs : 0;
+    if (dbVersionMtime !== entry.dbVersionMtime) return null;
+    return entry;
+  } catch {
+    return null;
   }
-  if (violations.length > 0) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const recent = violations.map((violation) => ({ ...violation, timestamp, source: "watch" }));
-    stats.recentViolations = [...recent, ...stats.recentViolations ?? []].slice(0, 50);
+}
+function saveRuleCache(cwd, data) {
+  const configPath = join8(cwd, ".memory-core.json");
+  try {
+    const configMtime = statSync3(configPath).mtimeMs;
+    const dbVersionPath = join8(cwd, DB_VERSION_FILE);
+    const dbVersionMtime = existsSync7(dbVersionPath) ? statSync3(dbVersionPath).mtimeMs : 0;
+    const entry = {
+      timestamp: Date.now(),
+      configMtime,
+      dbVersionMtime,
+      ...data
+    };
+    writeFileSync5(join8(cwd, RULE_CACHE_FILE), JSON.stringify(entry, null, 2) + "\n", "utf-8");
+  } catch {
   }
-  writeFileSync3(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
 }
-function loadConfig(cwd) {
-  const configPath = join7(cwd, ".memory-core.json");
-  if (!existsSync6(configPath)) return null;
+async function loadIgnorePatterns2() {
   try {
-    return JSON.parse(readFileSync5(configPath, "utf-8"));
+    const app = getDefaultApplicationContainer();
+    const ignores = await app.services.memoryEngine.list({ type: "ignore", limit: 1e3 });
+    return ignores.map((ignore) => ignore.content);
   } catch {
-    return null;
+    return [];
   }
 }
-function getProfileRules(config2) {
+function getProfileRules2(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);
@@ -2494,19 +2950,19 @@ function getProfileRules(config2) {
   }
   return { rules, avoids };
 }
-async function loadRelevantRules(cwd, config2, rel, diff, fallbackRules) {
+async function loadRelevantRules2(config, diff, stagedFiles, fallbackRules) {
   try {
     const query = buildContextQuery([
-      rel,
+      stagedFiles.join("\n"),
       diff.slice(0, 1200),
-      config2.backendArchitecture,
-      config2.frontendFramework,
-      config2.language
+      config.backendArchitecture,
+      config.frontendFramework,
+      config.language
     ]);
     const memories = await retrieveContextualMemories({
       query,
-      cwd,
-      config: config2,
+      cwd: process.cwd(),
+      config,
       limit: 15
     });
     const selected = memories.filter((memory) => ["rule", "pattern", "decision"].includes(memory.type)).map((memory) => memory.content);
@@ -2515,7 +2971,7 @@ async function loadRelevantRules(cwd, config2, rel, diff, fallbackRules) {
     return fallbackRules;
   }
 }
-function applyAllowPatterns(violations, allowPatterns) {
+function applyAllowPatterns2(violations, allowPatterns) {
   if (allowPatterns.length === 0) return violations;
   return violations.filter((violation) => {
     const haystack = `${violation.rule}
@@ -2524,193 +2980,651 @@ ${violation.file}`.toLowerCase();
     return !allowPatterns.some((pattern) => haystack.includes(pattern.toLowerCase()));
   });
 }
-async function verifyViolations(inputText, violations, allowPatterns, debug, mode = "diff") {
-  if (violations.length === 0) return violations;
-  const sourceLabel = mode === "snapshot" ? "file content" : "diff";
-  const systemPrompt = `You are verifying candidate architecture violations.
-Only keep violations that are directly supported by the ${sourceLabel}.
-Reject speculative or weak matches.
-Treat these allowlisted patterns as intentional and valid:
-${allowPatterns.length ? allowPatterns.map((pattern, index) => `${index + 1}. ${pattern}`).join("\n") : "(none)"}
-
-Return strict JSON:
-{"violations":[{"rule":"...","file":"...","line":1,"issue":"...","suggestion":"...","reason":"..."}]}
-Do not include any text outside the JSON.`;
-  const userPrompt = `${mode === "snapshot" ? "File content" : "Diff"}:
-${inputText.slice(0, 6e3)}
-
-Candidate violations:
-${JSON.stringify(violations, null, 2)}`;
-  if (debug) {
-    console.log(chalk.gray("\n  [debug] verifier prompt:"));
-    console.log(chalk.dim(systemPrompt));
-    console.log(chalk.dim(userPrompt));
-    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"));
+function normalizeViolation(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  if (typeof candidate.rule !== "string" || typeof candidate.issue !== "string") return null;
+  return {
+    rule: candidate.rule,
+    file: typeof candidate.file === "string" ? candidate.file : "diff",
+    line: typeof candidate.line === "number" ? candidate.line : void 0,
+    issue: candidate.issue,
+    suggestion: typeof candidate.suggestion === "string" ? candidate.suggestion : void 0,
+    reason: typeof candidate.reason === "string" ? candidate.reason : void 0
+  };
+}
+function parseModelViolations(raw) {
+  const candidates = [
+    raw,
+    raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "")
+  ];
+  const objectStart = raw.indexOf("{");
+  const objectEnd = raw.lastIndexOf("}");
+  if (objectStart !== -1 && objectEnd > objectStart) {
+    candidates.push(raw.slice(objectStart, objectEnd + 1));
+  }
+  const arrayStart = raw.indexOf("[");
+  const arrayEnd = raw.lastIndexOf("]");
+  if (arrayStart !== -1 && arrayEnd > arrayStart) {
+    candidates.push(raw.slice(arrayStart, arrayEnd + 1));
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      const items = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.violations) ? parsed.violations : parsed?.rule ? [parsed] : null;
+      if (!items) continue;
+      return {
+        valid: true,
+        violations: items.map(normalizeViolation).filter((violation) => violation !== null)
+      };
+    } catch {
+    }
+  }
+  return { valid: false, violations: [] };
+}
+function getAddedLines(diff) {
+  const lines = [];
+  let currentFile = "diff";
+  let newLineNumber = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ b/")) {
+      currentFile = line.slice("+++ b/".length);
+      continue;
+    }
+    const hunk = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunk) {
+      newLineNumber = Number(hunk[1]);
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      lines.push({
+        file: currentFile,
+        line: Number.isFinite(newLineNumber) ? newLineNumber : void 0,
+        content: line.slice(1)
+      });
+      newLineNumber += 1;
+      continue;
+    }
+    if (!line.startsWith("-") && newLineNumber > 0) {
+      newLineNumber += 1;
+    }
+  }
+  return lines;
+}
+function dedupeViolations(violations) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const violation of violations) {
+    const key = [
+      violation.rule,
+      violation.file,
+      violation.line ?? "",
+      violation.issue
+    ].join("\0");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(violation);
+  }
+  return deduped;
+}
+function normalizeKeyPath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\/+/, "").toLowerCase();
+}
+function violationRecurrenceKey(violation) {
+  return [
+    violation.rule.trim().toLowerCase(),
+    normalizeKeyPath(violation.file || "diff"),
+    violation.issue.trim().toLowerCase()
+  ].join("\0");
+}
+function findRecurringViolations(currentViolations, recentViolations, minCount = 2) {
+  if (currentViolations.length === 0 || recentViolations.length === 0) return [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const recent of recentViolations) {
+    const key = violationRecurrenceKey(recent);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return currentViolations.filter((violation) => (counts.get(violationRecurrenceKey(violation)) ?? 0) >= minCount);
+}
+function extractIssuePhrase(issue) {
+  const quoted = issue.match(/"([^"]{3,160})"/);
+  if (quoted?.[1]) return quoted[1].trim();
+  const afterColon = issue.split(":").slice(1).join(":").trim();
+  if (afterColon.length >= 3) return afterColon.slice(0, 180);
+  const fallback = issue.trim();
+  return fallback.length >= 3 ? fallback.slice(0, 180) : null;
+}
+function buildIgnorePatternFromDecision(decision) {
+  const explicit = decision.pattern?.trim();
+  if (explicit && explicit.length >= 3) return explicit;
+  return extractIssuePhrase(decision.issue);
+}
+function parseFalsePositiveDecision(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  if (typeof candidate.rule !== "string" || typeof candidate.issue !== "string") return null;
+  return {
+    rule: candidate.rule,
+    file: typeof candidate.file === "string" ? candidate.file : void 0,
+    line: typeof candidate.line === "number" ? candidate.line : void 0,
+    issue: candidate.issue,
+    falsePositive: candidate.falsePositive === true,
+    pattern: typeof candidate.pattern === "string" ? candidate.pattern : void 0,
+    reason: typeof candidate.reason === "string" ? candidate.reason : void 0
+  };
+}
+function parseFalsePositiveDecisions(raw) {
+  const candidates = [
+    raw,
+    raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "")
+  ];
+  const objectStart = raw.indexOf("{");
+  const objectEnd = raw.lastIndexOf("}");
+  if (objectStart !== -1 && objectEnd > objectStart) {
+    candidates.push(raw.slice(objectStart, objectEnd + 1));
+  }
+  const arrayStart = raw.indexOf("[");
+  const arrayEnd = raw.lastIndexOf("]");
+  if (arrayStart !== -1 && arrayEnd > arrayStart) {
+    candidates.push(raw.slice(arrayStart, arrayEnd + 1));
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      const items = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.decisions) ? parsed.decisions : parsed?.rule ? [parsed] : null;
+      if (!items) continue;
+      return {
+        valid: true,
+        decisions: items.map(parseFalsePositiveDecision).filter((decision) => decision !== null)
+      };
+    } catch {
+    }
+  }
+  return { valid: false, decisions: [] };
+}
+function loadRecentViolationsFromStats(cwd = process.cwd()) {
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  if (!existsSync7(statsPath)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync7(statsPath, "utf-8"));
+    if (!Array.isArray(parsed.recentViolations)) return [];
+    return parsed.recentViolations.filter(
+      (entry) => Boolean(entry) && typeof entry.rule === "string" && typeof entry.issue === "string" && typeof entry.file === "string" && typeof entry.timestamp === "string"
+    );
+  } catch {
+    return [];
+  }
+}
+function incrementFalsePositivesForPatterns(learnedPatterns, violations, cwd = process.cwd()) {
+  if (learnedPatterns.length === 0 || violations.length === 0) return;
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  if (!existsSync7(statsPath)) return;
+  let stats;
+  try {
+    stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
+  } catch {
+    return;
+  }
+  stats.rules ??= {};
+  for (const violation of violations) {
+    const haystack = `${violation.rule}
+${violation.issue}
+${violation.file}`.toLowerCase();
+    const matched = learnedPatterns.some((p) => haystack.includes(p.toLowerCase()));
+    if (!matched) continue;
+    const existing = toRuleStatEntry(stats.rules[violation.rule]);
+    stats.rules[violation.rule] = { count: existing.count, falsePositives: existing.falsePositives + 1 };
+  }
+  writeFileSync5(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+}
+async function learnGlobalIgnoresFromFalsePositives(options) {
+  if (options.currentViolations.length === 0) return [];
+  const recentViolations = loadRecentViolationsFromStats();
+  const recurring = findRecurringViolations(options.currentViolations, recentViolations, 2);
+  if (recurring.length === 0) return [];
+  const systemPrompt = `You are verifying repeated architecture-rule alerts.
+Mark falsePositive=true ONLY when the alert is clearly a false positive for this staged diff.
+For each false positive, return a concise ignore pattern that will suppress only this recurring false alert.
+Prefer exact snippets from the issue text.
+
+Return strict JSON:
+{"decisions":[{"rule":"...","file":"...","line":1,"issue":"...","falsePositive":true,"pattern":"...","reason":"..."}]}
+Do not include any text outside JSON.`;
+  const userPrompt = `Staged diff:
+${options.diff.slice(0, 6e3)}
+
+Recurring violations:
+${JSON.stringify(recurring, null, 2)}
+
+Existing allow patterns:
+${JSON.stringify(options.allowPatterns, null, 2)}`;
+  if (options.debug) {
+    console.log(chalk2.gray("\n  [debug] false-positive recheck prompt:"));
+    console.log(chalk2.dim(systemPrompt));
+    console.log(chalk2.dim(userPrompt));
+    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 raw = await callChatModel([
+    const recheckTimeoutMs = readPositiveIntEnv("MEMORY_CORE_FALSE_POSITIVE_TIMEOUT_MS", 6e3);
+    const { content: raw, usage: recheckUsage } = await callChatModel([
       { role: "system", content: systemPrompt },
       { role: "user", content: userPrompt }
-    ]);
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed?.violations)) return parsed.violations;
-    if (Array.isArray(parsed)) return parsed;
-    return violations;
-  } catch {
-    return violations;
-  }
-}
-async function loadIgnorePatterns() {
-  try {
+    ], { timeoutMs: recheckTimeoutMs });
+    accumulateTokenUsage(recheckUsage);
+    const parsed = parseFalsePositiveDecisions(raw);
+    if (!parsed.valid) return [];
+    const existing = new Set(options.allowPatterns.map((pattern) => pattern.toLowerCase()));
     const app = getDefaultApplicationContainer();
-    const ignores = await app.services.memoryEngine.list({ type: "ignore", limit: 1e3 });
-    return ignores.map((ignore) => ignore.content);
+    const inserted = [];
+    for (const decision of parsed.decisions) {
+      if (!decision.falsePositive) continue;
+      const pattern = buildIgnorePatternFromDecision(decision);
+      if (!pattern) continue;
+      const normalized = pattern.toLowerCase();
+      if (existing.has(normalized)) continue;
+      try {
+        await app.services.memoryEngine.remember({
+          type: "ignore",
+          scope: "global",
+          architecture: "global",
+          content: pattern,
+          reason: `Auto-added from repeated false-positive recheck for "${decision.rule}"${decision.reason ? `: ${decision.reason}` : ""}`,
+          tags: ["ignore", "auto-false-positive"]
+        });
+        existing.add(normalized);
+        inserted.push(pattern);
+      } catch {
+      }
+    }
+    if (inserted.length > 0) {
+      incrementFalsePositivesForPatterns(inserted, options.currentViolations);
+    }
+    return inserted;
   } catch {
     return [];
   }
 }
-function normalizeForGit(pathLike) {
-  return pathLike.split(sep).join("/");
+function normalizePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\/+/, "");
 }
-function listSourceFilesFromFilesystem(dir) {
-  if (!existsSync6(dir)) return [];
-  const files = [];
-  const stack = [dir];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    let entries = [];
-    try {
-      entries = readdirSync3(current);
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const absolute = join7(current, entry);
-      let isDirectory = false;
-      let isFile = false;
-      try {
-        const stats = statSync2(absolute);
-        isDirectory = stats.isDirectory();
-        isFile = stats.isFile();
-      } catch {
-        continue;
-      }
-      if (isDirectory) {
-        if (entry === "node_modules" || entry === ".git" || entry === "dist" || entry === "build" || entry === "coverage") {
-          continue;
-        }
-        stack.push(absolute);
-        continue;
+function resolveChangedFile(candidate, changedFiles) {
+  const normalizedCandidate = normalizePath(candidate);
+  const candidates = [normalizedCandidate];
+  if (/^(?:a|b)\//.test(normalizedCandidate)) {
+    candidates.push(normalizedCandidate.slice(2));
+  }
+  for (const current of candidates) {
+    if (changedFiles.has(current)) return current;
+    for (const changed of changedFiles) {
+      if (changed.endsWith(`/${current}`) || current.endsWith(`/${changed}`)) {
+        return changed;
       }
-      if (isFile && SOURCE_EXTENSIONS3.test(absolute)) files.push(absolute);
     }
   }
-  return files;
-}
-function listTrackedSourceFiles(projectRoot, watchPath) {
-  const relPrefix = normalizeForGit(relative2(projectRoot, watchPath));
-  const inRoot = relPrefix === "" || relPrefix === ".";
-  const prefixWithSlash = inRoot ? "" : `${relPrefix}/`;
-  const listed = spawnSync("git", ["ls-files"], { encoding: "utf-8", cwd: projectRoot });
-  if (listed.status !== 0) {
-    return listSourceFilesFromFilesystem(watchPath).sort();
-  }
-  const files = (listed.stdout ?? "").split("\n").filter((file) => file.length > 0).filter((file) => SOURCE_EXTENSIONS3.test(file)).filter((file) => inRoot || file.startsWith(prefixWithSlash)).map((file) => join7(projectRoot, file)).filter((file) => existsSync6(file));
-  return [...new Set(files)].sort();
+  return void 0;
 }
-async function runSnapshotScan(projectRoot, watchPath, config2, verbose, debug, onEvent) {
-  const files = listTrackedSourceFiles(projectRoot, watchPath);
-  if (files.length === 0) {
-    console.log(chalk.yellow("\n  No tracked source files found for scan.\n"));
+function buildModelInputFromDiff(diff, maxChars = 8e3) {
+  const addedLines = getAddedLines(diff);
+  if (addedLines.length === 0) {
+    const truncated2 = diff.length > maxChars;
     return {
-      filesChecked: 0,
-      filesWithViolations: 0,
-      violations: 0
+      text: truncated2 ? diff.slice(0, maxChars) + "\n\n[diff truncated]" : diff,
+      source: "diff",
+      truncated: truncated2
     };
   }
-  console.log(chalk.dim(`
-  scanning ${files.length} tracked source files...
-`));
-  const summary = {
-    filesChecked: 0,
-    filesWithViolations: 0,
-    violations: 0
+  const chunks = [];
+  let currentFile = "";
+  for (const addedLine of addedLines) {
+    if (addedLine.file !== currentFile) {
+      currentFile = addedLine.file;
+      chunks.push(`
+# ${currentFile}`);
+    }
+    const line = addedLine.line ?? "?";
+    chunks.push(`${line}: ${addedLine.content}`);
+  }
+  const summary = chunks.join("\n").trim();
+  const truncated = summary.length > maxChars;
+  return {
+    text: truncated ? summary.slice(0, maxChars) + "\n\n[added lines truncated]" : summary,
+    source: "added-lines",
+    truncated
   };
-  for (const filePath of files) {
-    const rel = normalizeForGit(relative2(projectRoot, filePath));
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    onEvent?.({ type: "saved", timestamp, file: rel });
-    const result = await checkFile(filePath, projectRoot, config2, verbose, debug, "snapshot", onEvent);
-    if (result.type !== "checked") {
-      if (result.type === "skipped") {
-        onEvent?.({ type: "skipped", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, reason: result.reason });
-      } else {
-        onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message: result.message });
-      }
+}
+function findDeterministicViolations(diff, rules, avoids, allowPatterns = []) {
+  const rulePhrases = rules.flatMap(
+    (rule) => extractForbiddenPhrases(rule).map((phrase) => ({ rule, phrase }))
+  );
+  const avoidPhrases = avoids.map((avoid) => ({
+    rule: `Avoid: ${avoid}`,
+    phrase: avoid.toLowerCase()
+  }));
+  const phrases = [...rulePhrases, ...avoidPhrases].filter((item) => item.phrase.length > 0);
+  if (phrases.length === 0) return [];
+  const violations = [];
+  for (const addedLine of getAddedLines(diff)) {
+    const normalizedLine = addedLine.content.toLowerCase();
+    if (allowPatterns.some((pattern) => normalizedLine.includes(pattern.toLowerCase()))) {
       continue;
     }
-    summary.filesChecked += 1;
-    if (result.violations.length === 0) {
-      onEvent?.({ type: "clean", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel });
+    for (const { rule, phrase } of phrases) {
+      if (normalizedLine.includes(phrase)) {
+        violations.push({
+          rule,
+          file: addedLine.file,
+          line: addedLine.line,
+          issue: `Added line contains forbidden phrase: "${phrase}"`,
+          suggestion: "Remove this pattern or add an explicit ignore memory if it is intentional.",
+          reason: reasonMap2.get(rule)
+        });
+      }
+    }
+  }
+  return dedupeViolations(violations);
+}
+function suppressBatchRepetitions(violations, threshold = 3) {
+  const pairCounts = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    const key = `${v.rule}\0${v.file}`;
+    pairCounts.set(key, (pairCounts.get(key) ?? 0) + 1);
+  }
+  const suppressedKeys = /* @__PURE__ */ new Set();
+  for (const [key, count] of pairCounts) {
+    if (count >= threshold) suppressedKeys.add(key);
+  }
+  if (suppressedKeys.size === 0) return { filtered: violations, suppressedCount: 0 };
+  const filtered = violations.filter((v) => !suppressedKeys.has(`${v.rule}\0${v.file}`));
+  return { filtered, suppressedCount: violations.length - filtered.length };
+}
+function groupViolationsByRule(violations) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    const existing = groups.get(v.rule);
+    if (existing) {
+      existing.push(v);
+    } else {
+      groups.set(v.rule, [v]);
+    }
+  }
+  return groups;
+}
+function filterModelViolationsByStagedDiff(violations, stagedFiles, diff) {
+  if (violations.length === 0) return violations;
+  const changedFiles = new Set(stagedFiles.map((file) => normalizePath(file)));
+  if (changedFiles.size === 0) return [];
+  const linesByFile = /* @__PURE__ */ new Map();
+  for (const addedLine of getAddedLines(diff)) {
+    const file = normalizePath(addedLine.file);
+    if (!changedFiles.has(file)) continue;
+    if (typeof addedLine.line !== "number") continue;
+    const list = linesByFile.get(file) ?? [];
+    list.push(addedLine.line);
+    linesByFile.set(file, list);
+  }
+  const LINE_TOLERANCE = 3;
+  const filtered = [];
+  for (const violation of violations) {
+    if (!violation.file || violation.file === "diff") {
+      filtered.push(violation);
       continue;
     }
-    summary.filesWithViolations += 1;
-    summary.violations += result.violations.length;
-    onEvent?.({ type: "violations", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, violations: result.violations });
+    const resolvedFile = resolveChangedFile(violation.file, changedFiles);
+    if (!resolvedFile) continue;
+    const candidateLines = linesByFile.get(resolvedFile) ?? [];
+    if (typeof violation.line === "number" && candidateLines.length > 0) {
+      const supported = candidateLines.some((line) => Math.abs(line - violation.line) <= LINE_TOLERANCE);
+      if (!supported) continue;
+    }
+    filtered.push({ ...violation, file: resolvedFile });
+  }
+  return filtered;
+}
+function installHook(advisory = true, fast = false) {
+  if (!existsSync7(".git")) {
+    console.error(chalk2.red("\n  Not a git repository. Run from project root.\n"));
+    process.exit(1);
+  }
+  const script = buildHookScript(advisory, fast);
+  const body = buildHookBody(advisory, fast).trimEnd();
+  if (existsSync7(HOOK_PATH)) {
+    const existing = readFileSync7(HOOK_PATH, "utf-8");
+    if (existing.includes(HOOK_MARKER)) {
+      const markerIndex = existing.indexOf(HOOK_MARKER);
+      const beforeRaw = markerIndex > 0 ? existing.slice(0, markerIndex) : "";
+      const normalizedBefore = normalizeHookPreamble(beforeRaw);
+      const preamble = normalizedBefore.length > 0 ? normalizedBefore : "#!/bin/sh";
+      const preambleWithShebang = preamble.startsWith("#!/bin/sh") ? preamble : `#!/bin/sh
+${preamble}`;
+      writeFileSync5(HOOK_PATH, `${preambleWithShebang}
+
+${body}
+`);
+      chmodSync(HOOK_PATH, 493);
+      installCommitMsgHook(advisory);
+      const modeLabel2 = advisory ? chalk2.cyan("advisory") : chalk2.yellow("strict");
+      console.log(chalk2.green("\n  \u2713 Pre-commit hook updated") + chalk2.dim(` (${modeLabel2} mode)`));
+      if (fast) console.log(chalk2.gray(`    Check mode: fast deterministic checks`));
+      return;
+    }
+    writeFileSync5(HOOK_PATH, existing.trimEnd() + "\n\n" + body + "\n");
+  } else {
+    writeFileSync5(HOOK_PATH, script);
+  }
+  chmodSync(HOOK_PATH, 493);
+  installCommitMsgHook(advisory);
+  const modeLabel = advisory ? "advisory (logs violations, never blocks)" : "strict (blocks commits on violations)";
+  console.log(chalk2.green("\n  \u2713 Pre-commit hook installed") + chalk2.dim(` \u2014 ${modeLabel}`));
+  console.log(chalk2.gray(fast ? "    Check mode: fast deterministic checks" : `    Chat model: ${process.env.OLLAMA_CHAT_MODEL ?? "llama3.2"}`));
+  console.log(chalk2.gray("    Commit message rules: memory-core commit-rules --list"));
+  console.log(chalk2.gray("    To uninstall: memory-core hook uninstall\n"));
+}
+function uninstallHook() {
+  if (!existsSync7(HOOK_PATH)) {
+    console.log(chalk2.yellow("\n  No pre-commit hook found.\n"));
+    return;
+  }
+  const content = readFileSync7(HOOK_PATH, "utf-8");
+  if (!content.includes(HOOK_MARKER)) {
+    console.log(chalk2.yellow("\n  ArchMind hook not found in pre-commit \u2014 nothing to remove.\n"));
+    return;
+  }
+  const markerIndex = content.indexOf(HOOK_MARKER);
+  const before = markerIndex > 1 ? normalizeHookPreamble(content.slice(0, markerIndex)) : "";
+  if (before && before !== "#!/bin/sh") {
+    writeFileSync5(HOOK_PATH, `${before}
+`);
+  } else {
+    unlinkSync(HOOK_PATH);
+  }
+  uninstallCommitMsgHook();
+  console.log(chalk2.green("\n  \u2713 Pre-commit hook removed\n"));
+}
+function buildCommitMsgHookBody(advisory) {
+  const suffix = advisory ? " || true" : "";
+  return `${COMMIT_MSG_HOOK_MARKER}${advisory ? " advisory" : ""}
+if [ "\${MEMORY_CORE_SKIP_HOOK:-}" = "1" ] || [ "\${ARCHMIND_SKIP_HOOK:-}" = "1" ] || [ "\${HUSKY:-}" = "0" ] || [ "\${HUSKY_SKIP_HOOKS:-}" = "1" ]; then
+  exit 0
+fi
+if [ -n "\${SKIP:-}" ] && echo ",$SKIP," | grep -qiE ',(memory-core|archmind),'; then
+  exit 0
+fi
+if [ -n "\${SKIP_HOOKS:-}" ]; then
+  exit 0
+fi
+if command -v memory-core >/dev/null 2>&1; then
+  memory-core check --commit-msg "$1"${suffix}
+elif [ -f "./node_modules/.bin/memory-core" ]; then
+  ./node_modules/.bin/memory-core check --commit-msg "$1"${suffix}
+elif [ -f "./dist/cli.js" ]; then
+  node ./dist/cli.js check --commit-msg "$1"${suffix}
+else
+  exit 0
+fi
+`;
+}
+function installCommitMsgHook(advisory = true) {
+  const body = buildCommitMsgHookBody(advisory).trimEnd();
+  const script = `#!/bin/sh
+
+${body}
+`;
+  if (existsSync7(COMMIT_MSG_HOOK_PATH)) {
+    const existing = readFileSync7(COMMIT_MSG_HOOK_PATH, "utf-8");
+    if (existing.includes(COMMIT_MSG_HOOK_MARKER)) {
+      const markerIndex = existing.indexOf(COMMIT_MSG_HOOK_MARKER);
+      const beforeRaw = markerIndex > 0 ? existing.slice(0, markerIndex) : "";
+      const normalizedBefore = normalizeHookPreamble(beforeRaw);
+      const preamble = normalizedBefore.length > 0 ? normalizedBefore : "#!/bin/sh";
+      const preambleWithShebang = preamble.startsWith("#!/bin/sh") ? preamble : `#!/bin/sh
+${preamble}`;
+      writeFileSync5(COMMIT_MSG_HOOK_PATH, `${preambleWithShebang}
+
+${body}
+`);
+    } else {
+      writeFileSync5(COMMIT_MSG_HOOK_PATH, existing.trimEnd() + "\n\n" + body + "\n");
+    }
+  } else {
+    writeFileSync5(COMMIT_MSG_HOOK_PATH, script);
+  }
+  chmodSync(COMMIT_MSG_HOOK_PATH, 493);
+}
+function uninstallCommitMsgHook() {
+  if (!existsSync7(COMMIT_MSG_HOOK_PATH)) return;
+  const content = readFileSync7(COMMIT_MSG_HOOK_PATH, "utf-8");
+  if (!content.includes(COMMIT_MSG_HOOK_MARKER)) return;
+  const markerIndex = content.indexOf(COMMIT_MSG_HOOK_MARKER);
+  const before = markerIndex > 1 ? normalizeHookPreamble(content.slice(0, markerIndex)) : "";
+  if (before && before !== "#!/bin/sh") {
+    writeFileSync5(COMMIT_MSG_HOOK_PATH, `${before}
+`);
+  } else {
+    unlinkSync(COMMIT_MSG_HOOK_PATH);
   }
-  return summary;
 }
-async function checkFile(filePath, projectRoot, config2, verbose, debug, mode = "diff", onEvent) {
-  const rel = relative2(projectRoot, filePath).split(sep).join("/");
-  if (rel.startsWith("..")) return { type: "skipped", reason: "File is outside project root" };
-  let inputText;
-  if (mode === "snapshot") {
-    if (!existsSync6(filePath)) return { type: "skipped", reason: "File no longer exists" };
-    inputText = readFileSync5(filePath, "utf-8");
-    if (!inputText.trim()) return { type: "skipped", reason: "File is empty" };
+async function checkCommitMsg(msgFile, options = {}) {
+  if (!existsSync7(msgFile)) {
+    if (options.verbose) console.log(chalk2.gray("  No commit message file \u2014 skipping."));
+    return;
+  }
+  const raw = readFileSync7(msgFile, "utf-8");
+  const cleanMsg = raw.split("\n").filter((l) => !l.startsWith("#")).join("\n").trim();
+  if (!cleanMsg) {
+    if (options.verbose) console.log(chalk2.gray("  Empty commit message \u2014 skipping."));
+    return;
+  }
+  const configPath = join8(process.cwd(), ".memory-core.json");
+  if (!existsSync7(configPath)) return;
+  const config = JSON.parse(readFileSync7(configPath, "utf-8"));
+  const rules = (config.commitRules ?? []).filter(Boolean);
+  if (rules.length === 0) return;
+  console.log(chalk2.cyan("\n  archmind \u2014 checking commit message\u2026"));
+  const violations = [];
+  for (const rule of rules) {
+    try {
+      const regex = new RegExp(rule.pattern, "im");
+      const matched = regex.test(cleanMsg);
+      const violated = rule.negate ? matched : !matched;
+      if (violated) violations.push({ rule });
+    } catch {
+      if (options.debug) console.log(chalk2.yellow(`  [debug] Invalid regex: "${rule.pattern}"`));
+    }
+  }
+  if (violations.length === 0) {
+    console.log(chalk2.green("  \u2713 Commit message OK.\n"));
+    return;
+  }
+  const blocking = violations.filter((v) => !v.rule.advisory);
+  violations.forEach(({ rule }) => {
+    const prefix = rule.advisory ? chalk2.yellow("  \u26A0  ") : chalk2.red("  \u2717  ");
+    console.log(prefix + rule.message);
+    const matchLabel = rule.negate ? "(must NOT match)" : "(must match)";
+    console.log(chalk2.dim(`       Pattern: ${rule.pattern} ${matchLabel}`));
+  });
+  console.log();
+  if (blocking.length === 0) return;
+  console.log(chalk2.dim("  Fix the commit message, then commit again."));
+  console.log(chalk2.dim("  To bypass: MEMORY_CORE_SKIP_HOOK=1 git commit"));
+  console.log(chalk2.dim("  Manage rules: memory-core commit-rules --list\n"));
+  process.exit(1);
+}
+async function checkStaged(options = {}) {
+  const SOURCE_EXTENSIONS3 = /\.(ts|tsx|js|jsx|py|php|rb|go|java|cs|swift|kt|rs|vue|svelte)$/;
+  let diff;
+  let stagedFiles = [];
+  try {
+    stagedFiles = execSync("git diff --cached --name-only --diff-filter=ACMRT", { encoding: "utf-8" }).split("\n").filter((f) => f && SOURCE_EXTENSIONS3.test(f)).map((f) => normalizePath(f));
+    if (stagedFiles.length === 0) {
+      if (options.verbose) console.log(chalk2.gray("  No source files staged \u2014 skipping rule check."));
+      return;
+    }
+    const result = spawnSync2(
+      "git",
+      ["diff", "--cached", "--unified=0", "--diff-filter=ACMRT", "--", ...stagedFiles],
+      { encoding: "utf-8" }
+    );
+    diff = result.stdout ?? "";
+  } catch {
+    console.error(chalk2.red("  Failed to read staged diff."));
+    process.exit(1);
+  }
+  if (!diff.trim()) {
+    if (options.verbose) console.log(chalk2.gray("  No staged changes to check."));
+    return;
+  }
+  const configPath = join8(process.cwd(), ".memory-core.json");
+  if (!existsSync7(configPath)) return;
+  const config = JSON.parse(readFileSync7(configPath, "utf-8"));
+  const { rules: fallbackRules, avoids } = getProfileRules2(config);
+  const fast = isFastCheck(options);
+  const ruleLoadTimeoutMs = readPositiveIntEnv("MEMORY_CORE_RULE_LOAD_TIMEOUT_MS", 2e3);
+  const ignoreLoadTimeoutMs = readPositiveIntEnv("MEMORY_CORE_IGNORE_LOAD_TIMEOUT_MS", 1500);
+  let rules;
+  let ignores;
+  let allowPatterns;
+  if (fast) {
+    rules = fallbackRules;
+    ignores = [];
+    allowPatterns = [...new Set(getAllowPatterns(config))];
   } else {
-    const headResult = spawnSync("git", ["diff", "HEAD", "--", rel], { encoding: "utf-8", cwd: projectRoot });
-    if (headResult.stdout?.trim()) {
-      inputText = headResult.stdout;
+    const cwd = process.cwd();
+    const cached = readRuleCache(cwd);
+    if (cached) {
+      rules = cached.rules;
+      ignores = cached.ignores;
+      allowPatterns = cached.allowPatterns;
+      if (options.debug) {
+        console.log(chalk2.gray("  [debug] using cached rules (TTL valid)"));
+      }
     } else {
-      const noIndexResult = spawnSync("git", ["diff", "--no-index", "/dev/null", rel], {
-        encoding: "utf-8",
-        cwd: projectRoot
-      });
-      inputText = noIndexResult.stdout ?? "";
+      const [loadedRules, loadedIgnores] = await Promise.all([
+        withTimeout(loadRelevantRules2(config, diff, stagedFiles, fallbackRules), ruleLoadTimeoutMs, fallbackRules),
+        withTimeout(loadIgnorePatterns2(), ignoreLoadTimeoutMs, [])
+      ]);
+      rules = loadedRules;
+      ignores = loadedIgnores;
+      allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config), ...loadedIgnores])];
+      saveRuleCache(cwd, { rules, ignores, allowPatterns });
     }
-    if (!inputText.trim()) return { type: "skipped", reason: "No changes compared with HEAD" };
   }
-  const { rules: fallbackRules, avoids } = getProfileRules(config2);
-  const rules = await loadRelevantRules(projectRoot, config2, rel, inputText, fallbackRules);
-  if (rules.length === 0) return { type: "skipped", reason: "No applicable architecture rules" };
-  const MAX_INPUT = 6e3;
-  const truncated = inputText.length > MAX_INPUT;
-  const inputToSend = truncated ? inputText.slice(0, MAX_INPUT) + "\n\n[input truncated]" : inputText;
-  if (verbose || debug) {
-    const label = mode === "snapshot" ? "snapshot" : `${inputText.length} chars`;
-    console.log(chalk.dim(`
-  [watch] checking ${rel} (${label})\u2026`));
+  if (rules.length === 0) return;
+  const modelInputMaxChars = readPositiveIntEnv("MEMORY_CORE_MODEL_INPUT_MAX_CHARS", 8e3);
+  const modelInput = buildModelInputFromDiff(diff, modelInputMaxChars);
+  console.log(chalk2.cyan("\n  archmind \u2014 checking staged changes against rules\u2026"));
+  if (options.verbose || options.debug) {
+    const sourceLabel = modelInput.source === "added-lines" ? "added lines" : "diff";
+    const modelLabel = fast ? "skipped (--fast)" : getChatProviderLabel();
+    console.log(chalk2.gray(`  model: ${modelLabel}  rules: ${rules.length}  diff: ${diff.length} chars  input: ${sourceLabel}${modelInput.truncated ? " (truncated)" : ""}`));
   }
   const rulesWithReasons = rules.map((r, i) => {
-    const why = reasonMap.get(r);
+    const why = reasonMap2.get(r);
     return why ? `${i + 1}. ${r}
    WHY: ${why}` : `${i + 1}. ${r}`;
   }).join("\n");
-  const allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config2), ...await loadIgnorePatterns()])];
-  const astViolations = findAstDeterministicViolationsForFile(rel, {
-    cwd: projectRoot,
-    config: config2,
-    rules,
-    reasonLookup: reasonMap
-  }).map((violation) => ({
-    ...violation,
-    severity: "error"
-  }));
-  const analysisTarget = mode === "snapshot" ? "file content" : "file diff";
-  const systemPrompt = `You are a strict code reviewer enforcing architecture rules.
-Analyze the ${analysisTarget} and identify ONLY clear, definite rule violations.
-Use the WHY for each rule to understand intent and judge edge cases.
+  const systemPrompt = `You are a strict code reviewer enforcing architecture and framework rules.
+Analyze the provided staged changes 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.
 
 Rules to enforce:
 ${rulesWithReasons}
@@ -2721,311 +3635,424 @@ ${avoids.map((a, i) => `${i + 1}. ${a}`).join("\n")}
 Never flag these accepted project patterns:
 ${allowPatterns.length ? allowPatterns.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(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"));
+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(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(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] input length: ${inputText.length} chars`));
-    console.log(chalk.dim(inputToSend));
-    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"));
-  }
-  try {
-    const reviewPrompt = mode === "snapshot" ? `Review this file ${rel}:
-
-${inputToSend}` : `Review this diff for ${rel}:
-
-${inputToSend}`;
-    onEvent?.({ type: "log", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, message: `checking with ${getChatProviderLabel()} | ${rules.length} rule${rules.length === 1 ? "" : "s"}` });
-    const raw = await callChatModel([
+    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.gray(`  [debug] model input source: ${modelInput.source}`));
+    console.log(chalk2.dim(modelInput.text));
+    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 deterministicViolations = findDeterministicViolations(diff, rules, avoids, allowPatterns);
+  const astViolations = findAstDeterministicViolationsForDiff(diff, {
+    cwd: process.cwd(),
+    config,
+    rules,
+    reasonLookup: reasonMap2
+  });
+  const app = getDefaultApplicationContainer();
+  const schemaViolations = await findSchemaViolations({
+    cwd: process.cwd(),
+    memoryEngine: app.services.memoryEngine
+  });
+  let modelViolations = [];
+  let aiFallback = fast;
+  if (fast) {
+    if (options.verbose || options.debug) {
+      console.log(chalk2.gray("  AI check skipped; running deterministic checks only."));
+    }
+  } else try {
+    const checkTimeoutMs = readPositiveIntEnv("MEMORY_CORE_CHECK_TIMEOUT_MS", readPositiveIntEnv("CHAT_TIMEOUT_MS", 2e4));
+    const { content: raw, usage: checkUsage } = await callChatModel([
       { role: "system", content: systemPrompt },
-      { role: "user", content: reviewPrompt }
-    ]);
-    if (debug) {
-      console.log(chalk.gray("  [debug] raw response:"));
-      console.log(chalk.dim(raw));
-      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"));
+      { role: "user", content: `Review these staged changes:
+
+${modelInput.text}` }
+    ], { timeoutMs: checkTimeoutMs });
+    accumulateTokenUsage(checkUsage);
+    if (options.verbose || options.debug) {
+      console.log(chalk2.gray(`  raw response: ${options.debug ? raw : raw.slice(0, 200)}`));
     }
-    let violations = [];
-    try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) {
-        violations = parsed;
-      } else if (Array.isArray(parsed?.violations)) {
-        violations = parsed.violations;
-      } else if (parsed?.rule) {
-        violations = [parsed];
+    const parsed = parseModelViolations(raw);
+    if (parsed.valid) {
+      modelViolations = parsed.violations;
+    } else {
+      console.log(chalk2.yellow("  \u26A0  AI returned invalid JSON \u2014 using deterministic checks only."));
+    }
+  } catch (err) {
+    if (err.message?.startsWith("MODEL_NOT_FOUND:")) {
+      printModelMissing(err.message.split(":")[1]);
+      aiFallback = true;
+      modelViolations = [];
+    } else if (err.message?.startsWith("TIMEOUT:")) {
+      const timeoutMs = err.message.split(":")[1];
+      console.log(chalk2.yellow(`
+  \u26A0  AI check timed out after ${timeoutMs}ms \u2014 switching to fast deterministic checks for this run.`));
+      console.log(chalk2.gray("     Set MEMORY_CORE_CHECK_TIMEOUT_MS to tune this.\n"));
+      aiFallback = true;
+      modelViolations = [];
+    } else if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
+      console.log(chalk2.yellow("\n  \u26A0  Ollama not running \u2014 using deterministic checks only."));
+      console.log(chalk2.gray("     Start it: ollama serve\n"));
+      aiFallback = true;
+      modelViolations = [];
+    } else {
+      console.log(chalk2.yellow(`
+  \u26A0  AI rule check failed: ${err.message}`));
+      console.log(chalk2.gray("     Using deterministic checks only.\n"));
+      aiFallback = true;
+      modelViolations = [];
+    }
+  }
+  modelViolations = filterModelViolationsByStagedDiff(modelViolations, stagedFiles, diff);
+  let violations = dedupeViolations([...deterministicViolations, ...astViolations, ...schemaViolations, ...modelViolations]);
+  violations = applyAllowPatterns2(violations, allowPatterns);
+  if (violations.length > 0) {
+    const { filtered, suppressedCount } = suppressBatchRepetitions(violations);
+    if (suppressedCount > 0) {
+      console.log(
+        chalk2.dim(
+          `  \u2139  Auto-suppressed ${suppressedCount} repetitive violation${suppressedCount > 1 ? "s" : ""} (same rule fired \u22653\xD7 on the same file \u2014 consider tuning the rule)`
+        )
+      );
+      violations = filtered;
+    }
+  }
+  if (!aiFallback && violations.length > 0) {
+    const learnedPatterns = await learnGlobalIgnoresFromFalsePositives({
+      diff,
+      currentViolations: violations,
+      allowPatterns,
+      debug: options.debug
+    });
+    if (learnedPatterns.length > 0) {
+      if (options.verbose || options.debug) {
+        console.log(chalk2.gray(`  learned ${learnedPatterns.length} global ignore pattern${learnedPatterns.length > 1 ? "s" : ""} from false-positive recheck`));
       }
-    } catch {
-      violations = [];
+      const refinedAllowPatterns = [.../* @__PURE__ */ new Set([...allowPatterns, ...learnedPatterns])];
+      violations = applyAllowPatterns2(violations, refinedAllowPatterns);
     }
-    onEvent?.({ type: "log", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, message: `model returned ${violations.length} candidate violation${violations.length === 1 ? "" : "s"}` });
-    violations = await verifyViolations(inputText, violations, allowPatterns, debug, mode);
-    violations = [...astViolations, ...violations];
-    violations = applyAllowPatterns(violations, allowPatterns);
-    violations = violations.map((violation) => ({
-      ...violation,
-      code: violation.code ?? (violation.line ? formatCodeContext(filePath, violation.line, 1) : void 0)
-    }));
-    if (violations.length === 0) {
-      recordWatchResult(projectRoot, rel, []);
-      console.log(chalk.green(`  \u2713 ${rel}`) + chalk.dim(" \u2014 no violations"));
-      return { type: "checked", violations: [] };
+  }
+  if (violations.length === 0) {
+    resetViolationStats();
+    if (options.dryRun) {
+      console.log(chalk2.green("  \u2713 [dry-run] No rule violations found.\n"));
+    } else {
+      console.log(chalk2.green("  \u2713 No rule violations \u2014 commit allowed.\n"));
     }
+    return;
+  }
+  if (options.dryRun) {
+    console.log(
+      chalk2.yellow.bold(
+        `
+  \u26A0  [dry-run] ${violations.length} rule violation${violations.length > 1 ? "s" : ""} would be flagged (commit not blocked)
+`
+      )
+    );
+  } else {
     console.log(
-      chalk.red.bold(`
-  \u2717 ${violations.length} violation${violations.length > 1 ? "s" : ""} in ${rel}
-`)
+      chalk2.red.bold(
+        `
+  \u2717 ${violations.length} rule violation${violations.length > 1 ? "s" : ""} found \u2014 commit blocked
+`
+      )
     );
-    violations.forEach((v, i) => {
-      const loc = v.line ? `${v.file ?? rel}:${v.line}` : v.file ?? rel;
-      console.log(chalk.bold(`  [${i + 1}] ${loc}`));
-      console.log(chalk.yellow("      Rule:   ") + v.rule);
-      const why = v.reason ?? reasonMap.get(v.rule);
-      if (why) console.log(chalk.dim("      Why:    ") + chalk.dim(why));
-      if (v.line && existsSync6(filePath)) {
-        printCodeContext(filePath, v.line, 1);
+  }
+  let ruleStatsSnapshot = {};
+  {
+    const statsPath = join8(process.cwd(), ".memory-core-stats.json");
+    if (existsSync7(statsPath)) {
+      try {
+        const parsed = JSON.parse(readFileSync7(statsPath, "utf-8"));
+        ruleStatsSnapshot = parsed.rules ?? {};
+      } catch {
       }
-      if (v.issue) console.log(chalk.red("      Issue:  ") + v.issue);
-      if (v.suggestion) console.log(chalk.green("      Fix:    ") + v.suggestion);
+    }
+  }
+  const MAX_LOCATIONS = 5;
+  const groups = groupViolationsByRule(violations);
+  let groupIndex = 0;
+  for (const [rule, group] of groups) {
+    groupIndex++;
+    const isCluster = group.length > 1;
+    const first = group[0];
+    if (isCluster) {
+      console.log(chalk2.bold.red(`
+  [${groupIndex}] ${rule}`) + chalk2.dim(`  \xD7${group.length}`));
+    } else {
+      const loc = first.file ? first.line ? `${first.file}:${first.line}` : first.file : "unknown location";
+      console.log(chalk2.bold(`
+  [${groupIndex}] ${loc}`));
+      console.log(chalk2.yellow("      Rule:   ") + rule);
+    }
+    const why = first.reason ?? reasonMap2.get(rule);
+    if (why) console.log(chalk2.dim("      Why:    ") + chalk2.dim(why));
+    if (first.suggestion) console.log(chalk2.green("      Fix:    ") + first.suggestion);
+    if (isCluster) {
       console.log();
-    });
-    recordWatchResult(projectRoot, rel, violations);
-    console.log(chalk.dim('  Fix violations or run: memory-core remember "<lesson>"'));
-    console.log();
-    return { type: "checked", violations };
-  } catch (err) {
-    const aiUnavailable = err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED");
-    const message = aiUnavailable ? `Model unreachable for ${rel}; using deterministic checks only.` : `AI check failed for ${rel}; using deterministic checks only.`;
-    console.log(chalk.yellow(`  \u26A0  ${message}`));
-    let violations = applyAllowPatterns(astViolations, allowPatterns);
-    violations = violations.map((violation) => ({
-      ...violation,
-      code: violation.code ?? (violation.line ? formatCodeContext(filePath, violation.line, 1) : void 0)
-    }));
-    if (violations.length === 0) {
-      recordWatchResult(projectRoot, rel, []);
-      console.log(chalk.green(`  \u2713 ${rel}`) + chalk.dim(" \u2014 no deterministic violations"));
-      return { type: "checked", violations: [] };
+      const shown = group.slice(0, MAX_LOCATIONS);
+      const overflow = group.length - MAX_LOCATIONS;
+      for (const v of shown) {
+        const loc = v.file ? v.line ? `${v.file}:${v.line}` : v.file : "unknown location";
+        const issue = v.issue ? chalk2.dim(`   ${v.issue}`) : "";
+        console.log(chalk2.dim(`      ${loc}`) + issue);
+      }
+      if (overflow > 0) {
+        console.log(chalk2.dim(`      ... and ${overflow} more`));
+      }
+    } else {
+      if (first.issue) console.log(chalk2.red("      Issue:  ") + first.issue);
     }
+    const ruleEntry = toRuleStatEntry(ruleStatsSnapshot[rule]);
+    if (ruleEntry.count > 5 && ruleEntry.falsePositives > 0) {
+      const rate = Math.round(ruleEntry.falsePositives / ruleEntry.count * 100);
+      if (rate > 40) {
+        console.log(chalk2.yellow(`
+      Noisy:  ${rate}% historical false-positive rate`));
+        console.log(chalk2.dim(`              Silence: memory-core allow "${rule}"`));
+        console.log(chalk2.dim(`              Review all: memory-core tune`));
+      } else if (rate > 25) {
+        console.log(chalk2.dim(`
+      Note:   ${rate}% false-positive rate \u2014 run: memory-core tune`));
+      }
+    }
+    console.log();
+  }
+  const noisyRules = Array.from(groups.keys()).filter((rule) => {
+    const entry = toRuleStatEntry(ruleStatsSnapshot[rule]);
+    return entry.count > 3 && entry.falsePositives / entry.count > 0.25;
+  });
+  if (noisyRules.length > 0) {
     console.log(
-      chalk.red.bold(`
-  \u2717 ${violations.length} deterministic violation${violations.length > 1 ? "s" : ""} in ${rel}
-`)
+      chalk2.yellow(`  \u26A0  ${noisyRules.length} of these rule${noisyRules.length > 1 ? "s have" : " has"} a high false-positive rate.`)
     );
-    violations.forEach((v, i) => {
-      const loc = v.line ? `${v.file ?? rel}:${v.line}` : v.file ?? rel;
-      console.log(chalk.bold(`  [${i + 1}] ${loc}`));
-      console.log(chalk.yellow("      Rule:   ") + v.rule);
-      const why = v.reason ?? reasonMap.get(v.rule);
-      if (why) console.log(chalk.dim("      Why:    ") + chalk.dim(why));
-      if (v.line && existsSync6(filePath)) {
-        printCodeContext(filePath, v.line, 1);
-      }
-      if (v.issue) console.log(chalk.red("      Issue:  ") + v.issue);
-      if (v.suggestion) console.log(chalk.green("      Fix:    ") + v.suggestion);
-      console.log();
-    });
-    recordWatchResult(projectRoot, rel, violations);
-    console.log(chalk.dim('  Fix violations or run: memory-core remember "<lesson>"'));
+    console.log(chalk2.dim("     Run: memory-core tune \u2014 to review and silence noisy rules\n"));
+  }
+  if (options.dryRun) {
+    console.log(chalk2.dim("  [dry-run] Commit not blocked. To enforce, run without --dry-run."));
+    console.log(chalk2.dim('  To save as memory: memory-core remember "<lesson>"'));
     console.log();
-    return { type: "checked", violations };
+    return;
   }
-}
-async function scanFiles(options = {}) {
-  const { projectRoot, watchPath } = resolveWatchPaths(options.path, options.projectRoot);
-  const config2 = loadConfig(projectRoot);
-  if (!config2) {
-    throw new Error("No .memory-core.json found. Run: memory-core init");
+  console.log(chalk2.dim("  Fix the violations above, then commit again."));
+  console.log(chalk2.dim("  To bypass (not recommended): git commit --no-verify"));
+  console.log(chalk2.dim("  Env bypass: MEMORY_CORE_SKIP_HOOK=1 git commit"));
+  console.log(chalk2.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());
+    }
   }
-  const { rules } = getProfileRules(config2);
-  if (rules.length === 0) {
-    console.log(chalk.yellow("\n  No architecture rules configured in .memory-core.json \u2014 nothing to scan.\n"));
-    return {
-      filesChecked: 0,
-      filesWithViolations: 0,
-      violations: 0
-    };
+  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 {
+    }
   }
-  resetLiveStats(projectRoot);
-  console.log(chalk.cyan("\n  archmind scan \u2014 checking tracked source files\n"));
-  console.log(chalk.dim(`  project: ${projectRoot}`));
-  console.log(chalk.dim(`  path:    ${watchPath}`));
-  console.log(chalk.dim(`  model:   ${getChatProviderLabel()}`));
-  console.log(chalk.dim(`  rules:   ${rules.length}
-`));
-  const summary = await runSnapshotScan(
-    projectRoot,
-    watchPath,
-    config2,
-    options.verbose ?? false,
-    options.debug ?? false,
-    options.onEvent
-  );
-  const cleanFiles = summary.filesChecked - summary.filesWithViolations;
-  console.log(chalk.bold("\n  scan summary\n"));
-  console.log(chalk.dim(`  files checked:         ${summary.filesChecked}`));
-  console.log(chalk.dim(`  files clean:           ${cleanFiles}`));
-  console.log(chalk.dim(`  files with violations: ${summary.filesWithViolations}`));
-  console.log(chalk.dim(`  total violations:      ${summary.violations}
-`));
-  return summary;
+  return "";
 }
-async function startWatch(options = {}) {
-  const { projectRoot, watchPath } = resolveWatchPaths(options.path, options.projectRoot);
-  const config2 = loadConfig(projectRoot);
-  const exitOnSetupFailure = options.exitOnSetupFailure ?? true;
-  if (!config2) {
-    const message = "No .memory-core.json found. Run: memory-core init";
-    console.error(chalk.red(`
-  ${message}
+async function checkFile2(filePath, options = {}) {
+  const { readFileSync: readFile, existsSync: fileExists } = await import("fs");
+  const resolvedPath = filePath.startsWith("/") ? filePath : join8(process.cwd(), filePath);
+  if (!fileExists(resolvedPath)) {
+    console.error(chalk2.red(`
+  File not found: ${filePath}
 `));
-    options.onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message });
-    if (exitOnSetupFailure) process.exit(1);
-    return;
+    process.exit(1);
+  }
+  const content = readFile(resolvedPath, "utf-8");
+  const lines = content.split("\n");
+  const pseudoDiff = [
+    `diff --git a/${filePath} b/${filePath}`,
+    `+++ b/${filePath}`,
+    `@@ -0,0 +1,${lines.length} @@`,
+    ...lines.map((l) => `+${l}`)
+  ].join("\n");
+  const configPath = join8(process.cwd(), ".memory-core.json");
+  if (!existsSync7(configPath)) {
+    console.error(chalk2.red("\n  No .memory-core.json found. Run: memory-core init\n"));
+    process.exit(1);
+  }
+  const config = JSON.parse(readFileSync7(configPath, "utf-8"));
+  const { rules: fallbackRules, avoids } = getProfileRules2(config);
+  const allowPatterns = [...new Set(getAllowPatterns(config))];
+  const fast = isFastCheck(options);
+  let rules;
+  if (fast) {
+    rules = fallbackRules;
+  } else {
+    const cached = readRuleCache(process.cwd());
+    if (cached) {
+      rules = cached.rules;
+    } else {
+      const ruleLoadTimeoutMs = readPositiveIntEnv("MEMORY_CORE_RULE_LOAD_TIMEOUT_MS", 2e3);
+      rules = await withTimeout(
+        loadRelevantRules2(config, pseudoDiff, [filePath], fallbackRules),
+        ruleLoadTimeoutMs,
+        fallbackRules
+      );
+    }
   }
-  const { rules } = getProfileRules(config2);
   if (rules.length === 0) {
-    const message = "No architecture rules configured in .memory-core.json \u2014 nothing to watch.";
-    console.log(chalk.yellow(`
-  ${message}
-`));
-    options.onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message });
-    if (exitOnSetupFailure) process.exit(0);
+    console.log(chalk2.dim("\n  No rules loaded \u2014 nothing to check.\n"));
     return;
   }
-  resetLiveStats(projectRoot);
-  console.log(chalk.cyan("\n  archmind watch \u2014 real-time rule enforcement\n"));
-  console.log(chalk.dim(`  project:  ${projectRoot}`));
-  console.log(chalk.dim(`  watching: ${watchPath}`));
-  console.log(chalk.dim(`  model:    ${getChatProviderLabel()}`));
-  console.log(chalk.dim(`  rules:    ${rules.length}`));
-  console.log(chalk.dim("  ctrl+c to stop\n"));
-  options.onEvent?.({
-    type: "ready",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    path: watchPath,
-    model: getChatProviderLabel(),
-    rules: rules.length
+  console.log(chalk2.cyan(`
+  archmind \u2014 checking ${filePath} against rules\u2026`));
+  const deterministicViolations = findDeterministicViolations(pseudoDiff, rules, avoids, allowPatterns);
+  const astViolations = findAstDeterministicViolationsForDiff(pseudoDiff, {
+    cwd: process.cwd(),
+    config,
+    rules,
+    reasonLookup: reasonMap2
   });
-  if (options.scanOnStart) {
-    console.log(chalk.dim("  running initial snapshot scan before watch events..."));
-    await runSnapshotScan(
-      projectRoot,
-      watchPath,
-      config2,
-      options.verbose ?? false,
-      options.debug ?? false,
-      options.onEvent
-    );
-    console.log(chalk.dim("  initial scan complete.\n"));
+  let violations = dedupeViolations([...deterministicViolations, ...astViolations]);
+  violations = applyAllowPatterns2(violations, allowPatterns);
+  if (violations.length === 0) {
+    console.log(chalk2.green("  \u2713 No rule violations found in this file.\n"));
+    return;
   }
-  const pending = /* @__PURE__ */ new Map();
-  const watcher = watch(watchPath, {
-    ignored: [
-      "**/node_modules/**",
-      "**/.git/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/coverage/**",
-      "**/.memory-core*"
-    ],
-    ignoreInitial: true,
-    persistent: true,
-    awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 }
-  });
-  const keepAlive = setInterval(() => {
-  }, 1 << 30);
-  const handle = (filePath) => {
-    if (!SOURCE_EXTENSIONS3.test(filePath)) return;
-    if (pending.has(filePath)) clearTimeout(pending.get(filePath));
-    const timer = setTimeout(async () => {
-      pending.delete(filePath);
-      const rel = normalizeForGit(relative2(projectRoot, filePath));
-      if (rel.startsWith("..")) return;
-      const timestamp = /* @__PURE__ */ new Date();
-      console.log(chalk.dim(`
-  [${timestamp.toLocaleTimeString()}] saved: ${rel}`));
-      options.onEvent?.({ type: "saved", timestamp: timestamp.toISOString(), file: rel });
-      const result = await checkFile(
-        filePath,
-        projectRoot,
-        config2,
-        options.verbose ?? false,
-        options.debug ?? false,
-        "diff",
-        options.onEvent
-      );
-      if (result.type === "skipped") {
-        if (result.reason === "No changes compared with HEAD") {
-          recordWatchResult(projectRoot, rel, []);
-          options.onEvent?.({ type: "clean", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel });
-          return;
-        }
-        options.onEvent?.({ type: "skipped", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, reason: result.reason });
-        return;
-      }
-      if (result.type === "error") {
-        options.onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message: result.message });
-        return;
-      }
-      const { violations } = result;
-      if (violations.length === 0) {
-        options.onEvent?.({ type: "clean", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel });
-        return;
+  const label = options.dryRun ? "[dry-run] " : "";
+  console.log(chalk2.yellow.bold(`
+  ${label}${violations.length} violation${violations.length > 1 ? "s" : ""} found in ${filePath}
+`));
+  const groups = groupViolationsByRule(violations);
+  let idx = 0;
+  for (const [rule, group] of groups) {
+    idx++;
+    const first = group[0];
+    const loc = first.line ? `${filePath}:${first.line}` : filePath;
+    console.log(chalk2.bold(`
+  [${idx}] ${loc}`));
+    console.log(chalk2.yellow("      Rule:   ") + rule);
+    if (first.reason) console.log(chalk2.dim("      Why:    ") + chalk2.dim(first.reason));
+    if (first.issue) console.log(chalk2.red("      Issue:  ") + first.issue);
+    if (first.suggestion) console.log(chalk2.green("      Fix:    ") + first.suggestion);
+    console.log();
+  }
+  if (!options.dryRun) process.exit(1);
+}
+async function checkCi(options = {}) {
+  let memories;
+  try {
+    memories = readMemoryFile();
+  } catch (err) {
+    console.error(chalk2.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(chalk2.gray(`
+  [debug] memories: ${memories.length}`));
+    console.log(chalk2.gray(`  [debug] text rules: ${phrases.length}`));
+    console.log(chalk2.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}"`
+        });
       }
-      options.onEvent?.({ type: "violations", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, violations });
-    }, 300);
-    pending.set(filePath, timer);
-  };
-  watcher.on("add", handle);
-  watcher.on("change", handle);
-  watcher.on("unlink", (filePath) => {
-    const rel = normalizeForGit(relative2(projectRoot, filePath));
-    if (rel.startsWith("..")) return;
-    recordWatchResult(projectRoot, rel, []);
-    options.onEvent?.({ type: "clean", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel });
-  });
-  watcher.on("error", (err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(chalk.red(`  watcher error: ${message}`));
-    options.onEvent?.({ type: "error", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message });
-  });
-  process.on("SIGINT", () => {
-    console.log(chalk.dim("\n\n  archmind watch stopped.\n"));
-    options.onEvent?.({ type: "stopped", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-    clearInterval(keepAlive);
-    watcher.close();
-    process.exit(0);
+    }
+  }
+  if (violations.length === 0) {
+    console.log(chalk2.green(`
+  \u2713 CI memory check passed (${rules.length} rules loaded from memories.json)
+`));
+    return;
+  }
+  console.log(chalk2.red.bold(`
+  \u2717 ${violations.length} CI violation${violations.length > 1 ? "s" : ""} found
+`));
+  violations.forEach((violation, index) => {
+    console.log(chalk2.bold(`  [${index + 1}] ${violation.file}`));
+    console.log(chalk2.yellow("      Rule:   ") + violation.rule);
+    console.log(chalk2.red("      Issue:  ") + violation.issue);
+    console.log();
   });
+  recordViolations(violations, "ci");
+  process.exit(1);
+}
+function printModelMissing(model) {
+  console.log(chalk2.yellow(`
+  \u26A0  Chat model "${model}" not found in Ollama.`));
+  console.log(chalk2.gray(`     Pull a model: ollama pull ${model}`));
+  console.log(chalk2.gray("     Or set OLLAMA_CHAT_MODEL=<model> in .memory-core.env"));
+  console.log(chalk2.gray("     Recommended: llama3.2  |  qwen2.5-coder:3b  |  mistral\n"));
 }
 
 export {
   detectProject,
-  Config,
   embed,
-  callChatModel,
-  getChatProviderLabel,
-  getPool,
-  runMigrations,
-  saveMemory,
-  listMemories,
-  deleteMemory,
-  updateMemory,
-  closePool,
   migrateGraphSnapshots,
   probeGraphSnapshotStore,
   seeds,
-  findAstDeterministicViolationsForDiff,
+  MEMORY_FILE,
+  toPortableMemory,
+  writeMemoryFile,
+  readMemoryFile,
+  readMemoryFileFromUrl,
+  parseMemoryFile,
+  findSchemaViolations,
+  recordBypass,
+  readBypassStats,
+  installHook,
+  uninstallHook,
+  checkCommitMsg,
+  checkStaged,
+  checkFile2 as checkFile,
+  checkCi,
   startWatch,
   getDefaultApplicationContainer,
   inferProjectArchitectures,
   getAllowPatterns,
-  buildContextQuery,
-  retrieveContextualMemories,
   retrieveMemorySelection,
   OUTPUT_FILES,
   AGENT_NAMES,