@shahmilsaari/memory-core 1.0.25 → 1.0.27

package/dist/{chunk-35ZWQFTO.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,409 +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();
-  const inputTokens = data.prompt_eval_count ?? 0;
-  const outputTokens = data.eval_count ?? 0;
-  return {
-    content: data.message.content.trim(),
-    usage: inputTokens || outputTokens ? { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens } : void 0
-  };
-}
-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();
-  const u = data.usage;
-  return {
-    content: data.choices[0].message.content.trim(),
-    usage: u ? { inputTokens: u.prompt_tokens, outputTokens: u.completion_tokens, totalTokens: u.total_tokens } : void 0
-  };
-}
-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();
-  const u = data.usage;
-  return {
-    content: data.content[0].text.trim(),
-    usage: u ? { inputTokens: u.input_tokens, outputTokens: u.output_tokens, totalTokens: u.input_tokens + u.output_tokens } : void 0
-  };
-}
-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();
-  const u = data.usage;
-  return {
-    content: data.choices[0].message.content.trim(),
-    usage: u ? { inputTokens: u.prompt_tokens, outputTokens: u.completion_tokens, totalTokens: u.total_tokens } : void 0
-  };
-}
-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) {
@@ -1026,8 +619,8 @@ var seeds = [
 ];
 
 // src/memory-file.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { join as join3 } from "path";
+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 {
@@ -1061,13 +654,13 @@ function parseContext(value) {
   return Object.keys(context).length ? context : void 0;
 }
 function writeMemoryFile(memories, cwd = process.cwd()) {
-  const path = join3(cwd, MEMORY_FILE);
+  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 = join3(cwd, MEMORY_FILE);
-  if (!existsSync3(path)) {
+  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"));
@@ -1105,8 +698,8 @@ function parseMemoryFile(raw) {
 }
 
 // src/modules/rule-engine/infrastructure/schema-violations.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 function parseSchemaRule(content) {
   try {
     const parsed = JSON.parse(content);
@@ -1157,9 +750,9 @@ async function findSchemaViolations(opts) {
   for (const memory of schemaMemories) {
     const rule = parseSchemaRule(memory.content);
     if (!rule) continue;
-    const tsPath = join4(opts.cwd, rule.tsFile);
-    const goPath = join4(opts.cwd, rule.goFile);
-    if (!existsSync4(tsPath) || !existsSync4(goPath)) 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));
@@ -1192,13 +785,13 @@ async function findSchemaViolations(opts) {
 
 // src/hook.ts
 import { execSync, spawnSync as spawnSync2 } from "child_process";
-import { writeFileSync as writeFileSync5, existsSync as existsSync9, unlinkSync, readFileSync as readFileSync8, chmodSync, statSync as statSync3 } from "fs";
-import { join as join10 } from "path";
+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 readFileSync7, readdirSync as readdirSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync8 } from "fs";
-import { join as join9, dirname as dirname4, 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";
@@ -1307,9 +900,9 @@ var PostgresMemoryRepository = class {
 };
 
 // src/infrastructure/persistence/filesystem/file-graph-repository.ts
-import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { dirname, join as join5 } from "path";
-var DEFAULT_FILE = join5(".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, "/");
 }
@@ -1348,7 +941,7 @@ var FileGraphRepository = class {
   }
   readData() {
     const filePath = this.absolutePath();
-    if (!existsSync5(filePath)) {
+    if (!existsSync4(filePath)) {
       return { version: 1, snapshots: [] };
     }
     try {
@@ -1373,7 +966,7 @@ var FileGraphRepository = class {
 `, "utf-8");
   }
   absolutePath() {
-    return join5(this.rootPath, this.relativeFilePath);
+    return join4(this.rootPath, this.relativeFilePath);
   }
 };
 
@@ -1421,214 +1014,39 @@ var ResilientGraphRepository = class {
 // src/watcher.ts
 import { watch } from "chokidar";
 import { spawnSync } from "child_process";
-import { existsSync as existsSync7, readdirSync, readFileSync as readFileSync6, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, join as join7, relative, resolve as resolve3, sep } from "path";
+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/rule-engine/infrastructure/ast-deterministic-violations.ts
-import { resolve as resolve2 } from "path";
-
-// src/infrastructure/ast/import-analysis.ts
-import { builtinModules } from "module";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname2, extname, isAbsolute, join as join6, 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 (existsSync6(candidate)) return normalize(candidate);
-  if (!extname(candidate)) {
-    for (const ext of SOURCE_EXTENSIONS) {
-      const withExt = `${candidate}${ext}`;
-      if (existsSync6(withExt)) return normalize(withExt);
-    }
-    for (const ext of SOURCE_EXTENSIONS) {
-      const indexFile = join6(candidate, `index${ext}`);
-      if (existsSync6(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 (!existsSync6(filePath)) return [];
-  const source = readFileSync5(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)
-    };
-  });
-}
+import { resolve } from "path";
 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/rule-engine/infrastructure/ast-deterministic-violations.ts
-function asPosix4(value) {
-  return value.replace(/\\/g, "/");
-}
 function hasPath(value, pathSegment) {
-  const normalized = asPosix4(value);
+  const normalized = asPosix3(value);
   const trimmed = pathSegment.startsWith("/") ? pathSegment.slice(1) : pathSegment;
   return normalized.includes(pathSegment) || normalized.includes(trimmed);
 }
 function isLegacyOrCompatibilitySpecifier(specifier) {
-  const normalized = asPosix4(specifier);
+  const normalized = asPosix3(specifier);
   return normalized.includes("/compatibility/") || normalized.includes("compatibility/") || normalized.includes("legacy-");
 }
 function isLegacyOrCompatibilityPath(pathValue) {
   if (!pathValue) return false;
-  const normalized = asPosix4(pathValue);
+  const normalized = asPosix3(pathValue);
   return normalized.includes("/src/compatibility/") || normalized.includes("/legacy-");
 }
-function moduleNameFromPath2(pathValue) {
-  const match = asPosix4(pathValue).match(/src\/modules\/([^/]+)\//);
+function moduleNameFromPath(pathValue) {
+  const match = asPosix3(pathValue).match(/src\/modules\/([^/]+)\//);
   return match?.[1];
 }
 function isModulePublicPath(pathValue) {
-  const normalized = asPosix4(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 = asPosix4(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";
@@ -1636,17 +1054,17 @@ function detectCleanLayer(pathValue) {
   return "unknown";
 }
 function detectHexLayer(pathValue) {
-  const normalized = asPosix4(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(config2, rules = []) {
+function activeArchitectures(config, rules = []) {
   const names = /* @__PURE__ */ new Set();
-  if (config2?.backendArchitecture) names.add(config2.backendArchitecture);
-  if (config2?.frontendFramework) names.add(config2.frontendFramework);
+  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");
@@ -1667,13 +1085,13 @@ function evaluateFile(file, options) {
   const architectures = activeArchitectures(options.config, rules);
   const reasonLookup = options.reasonLookup ?? /* @__PURE__ */ new Map();
   const violations = [];
-  const absFile = resolve2(cwd, file);
-  const normalizedFile = asPosix4(file);
+  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 ? asPosix4(imp.resolvedPath) : void 0;
+    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, {
@@ -1686,8 +1104,8 @@ function evaluateFile(file, options) {
       });
     }
     if (architectures.has("modular-monolith")) {
-      const fromModule = moduleNameFromPath2(normalizedFile);
-      const toModule = target ? moduleNameFromPath2(target) : void 0;
+      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, {
@@ -1811,7 +1229,7 @@ function findAstDeterministicViolationsForDiff(diff, options = {}) {
 // src/watcher.ts
 function getFileLines(filePath) {
   try {
-    return readFileSync6(filePath, "utf-8").split("\n");
+    return readFileSync5(filePath, "utf-8").split("\n");
   } catch {
     return [];
   }
@@ -1845,36 +1263,36 @@ function formatCodeContext(filePath, line, contextLines = 2) {
     return `${lineNum} ${marker} ${lines[current]}`;
   }).join("\n");
 }
-var SOURCE_EXTENSIONS2 = /\.(ts|tsx|js|jsx|py|php|rb|go|java|cs|swift|kt|rs|vue|svelte)$/;
+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 = resolve3(startPath);
+  let current = resolve2(startPath);
   while (true) {
-    if (existsSync7(join7(current, ".memory-core.json"))) return current;
-    const parent = dirname3(current);
+    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 = resolve3(projectRootOption);
+    const projectRoot2 = resolve2(projectRootOption);
     return {
       projectRoot: projectRoot2,
-      watchPath: resolve3(projectRoot2, pathOption ?? ".")
+      watchPath: resolve2(projectRoot2, pathOption ?? ".")
     };
   }
-  const cwdRoot = resolve3(process.cwd());
-  const watchPath = resolve3(cwdRoot, 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 (!existsSync7(statsPath)) return { rules: {}, files: {} };
+  if (!existsSync5(statsPath)) return { rules: {}, files: {} };
   try {
-    return JSON.parse(readFileSync6(statsPath, "utf-8"));
+    return JSON.parse(readFileSync5(statsPath, "utf-8"));
   } catch {
     return { rules: {}, files: {} };
   }
@@ -1892,7 +1310,7 @@ function rebuildLiveCounters(byFile) {
   return { rules, files };
 }
 function resetLiveStats(cwd) {
-  const statsPath = join7(cwd, ".memory-core-stats.json");
+  const statsPath = join5(cwd, ".memory-core-stats.json");
   const stats = readStatsFile(statsPath);
   stats.rules ??= {};
   stats.files ??= {};
@@ -1904,7 +1322,7 @@ function resetLiveStats(cwd) {
   writeFileSync3(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
 }
 function recordWatchResult(cwd, file, violations) {
-  const statsPath = join7(cwd, ".memory-core-stats.json");
+  const statsPath = join5(cwd, ".memory-core-stats.json");
   const stats = readStatsFile(statsPath);
   stats.rules ??= {};
   stats.files ??= {};
@@ -1930,26 +1348,26 @@ function recordWatchResult(cwd, file, violations) {
   writeFileSync3(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
 }
 function loadConfig(cwd) {
-  const configPath = join7(cwd, ".memory-core.json");
-  if (!existsSync7(configPath)) return null;
+  const configPath = join5(cwd, ".memory-core.json");
+  if (!existsSync5(configPath)) return null;
   try {
-    return JSON.parse(readFileSync6(configPath, "utf-8"));
+    return JSON.parse(readFileSync5(configPath, "utf-8"));
   } catch {
     return null;
   }
 }
-function getProfileRules(config2) {
+function getProfileRules(config) {
   const rules = [];
   const avoids = [];
-  if (config2.backendArchitecture) {
-    const profile = listProfiles("backend").find((p) => p.name === config2.backendArchitecture);
+  if (config.backendArchitecture) {
+    const profile = listProfiles("backend").find((p) => p.name === config.backendArchitecture);
     if (profile) {
       rules.push(...profile.rules);
       avoids.push(...profile.avoid);
     }
   }
-  if (config2.frontendFramework) {
-    const profile = listProfiles("frontend").find((p) => p.name === config2.frontendFramework);
+  if (config.frontendFramework) {
+    const profile = listProfiles("frontend").find((p) => p.name === config.frontendFramework);
     if (profile) {
       rules.push(...profile.rules);
       avoids.push(...profile.avoid);
@@ -1957,19 +1375,19 @@ function getProfileRules(config2) {
   }
   return { rules, avoids };
 }
-async function loadRelevantRules(cwd, config2, rel, diff, fallbackRules) {
+async function loadRelevantRules(cwd, config, rel, diff, fallbackRules) {
   try {
     const query = buildContextQuery([
       rel,
       diff.slice(0, 1200),
-      config2.backendArchitecture,
-      config2.frontendFramework,
-      config2.language
+      config.backendArchitecture,
+      config.frontendFramework,
+      config.language
     ]);
     const memories = await retrieveContextualMemories({
       query,
       cwd,
-      config: config2,
+      config,
       limit: 15
     });
     const selected = memories.filter((memory) => ["rule", "pattern", "decision"].includes(memory.type)).map((memory) => memory.content);
@@ -2037,7 +1455,7 @@ function normalizeForGit(pathLike) {
   return pathLike.split(sep).join("/");
 }
 function listSourceFilesFromFilesystem(dir) {
-  if (!existsSync7(dir)) return [];
+  if (!existsSync5(dir)) return [];
   const files = [];
   const stack = [dir];
   while (stack.length > 0) {
@@ -2049,7 +1467,7 @@ function listSourceFilesFromFilesystem(dir) {
       continue;
     }
     for (const entry of entries) {
-      const absolute = join7(current, entry);
+      const absolute = join5(current, entry);
       let isDirectory = false;
       let isFile = false;
       try {
@@ -2066,7 +1484,7 @@ function listSourceFilesFromFilesystem(dir) {
         stack.push(absolute);
         continue;
       }
-      if (isFile && SOURCE_EXTENSIONS2.test(absolute)) files.push(absolute);
+      if (isFile && SOURCE_EXTENSIONS.test(absolute)) files.push(absolute);
     }
   }
   return files;
@@ -2079,10 +1497,10 @@ function listTrackedSourceFiles(projectRoot, watchPath) {
   if (listed.status !== 0) {
     return listSourceFilesFromFilesystem(watchPath).sort();
   }
-  const files = (listed.stdout ?? "").split("\n").filter((file) => file.length > 0).filter((file) => SOURCE_EXTENSIONS2.test(file)).filter((file) => inRoot || file.startsWith(prefixWithSlash)).map((file) => join7(projectRoot, file)).filter((file) => existsSync7(file));
+  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, config2, verbose, debug, onEvent) {
+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"));
@@ -2104,7 +1522,7 @@ async function runSnapshotScan(projectRoot, watchPath, config2, verbose, debug,
     const rel = normalizeForGit(relative(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);
+    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 });
@@ -2125,8 +1543,8 @@ async function runSnapshotScan(projectRoot, watchPath, config2, verbose, debug,
   return summary;
 }
 async function autoFixFile(filePath, projectRoot, violations, rules, avoids, debug) {
-  if (!existsSync7(filePath)) return false;
-  const content = readFileSync6(filePath, "utf-8");
+  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}"
@@ -2182,13 +1600,13 @@ ${content}`;
     return false;
   }
 }
-async function checkFile(filePath, projectRoot, config2, verbose, debug, mode = "diff", onEvent) {
+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 (!existsSync7(filePath)) return { type: "skipped", reason: "File no longer exists" };
-    inputText = readFileSync6(filePath, "utf-8");
+    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 });
@@ -2203,8 +1621,8 @@ async function checkFile(filePath, projectRoot, config2, verbose, debug, mode =
     }
     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);
+  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;
@@ -2219,10 +1637,10 @@ async function checkFile(filePath, projectRoot, config2, verbose, debug, mode =
     return why ? `${i + 1}. ${r}
    WHY: ${why}` : `${i + 1}. ${r}`;
   }).join("\n");
-  const allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config2), ...await loadIgnorePatterns()])];
+  const allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config), ...await loadIgnorePatterns()])];
   const astViolations = findAstDeterministicViolationsForFile(rel, {
     cwd: projectRoot,
-    config: config2,
+    config,
     rules,
     reasonLookup: reasonMap
   }).map((violation) => ({
@@ -2309,7 +1727,7 @@ ${inputToSend}`;
       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 && existsSync7(filePath)) {
+      if (v.line && existsSync5(filePath)) {
         printCodeContext(filePath, v.line, 1);
       }
       if (v.issue) console.log(chalk.red("      Issue:  ") + v.issue);
@@ -2345,7 +1763,7 @@ ${inputToSend}`;
       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 && existsSync7(filePath)) {
+      if (v.line && existsSync5(filePath)) {
         printCodeContext(filePath, v.line, 1);
       }
       if (v.issue) console.log(chalk.red("      Issue:  ") + v.issue);
@@ -2360,11 +1778,11 @@ ${inputToSend}`;
 }
 async function scanFiles(options = {}) {
   const { projectRoot, watchPath } = resolveWatchPaths(options.path, options.projectRoot);
-  const config2 = loadConfig(projectRoot);
-  if (!config2) {
+  const config = loadConfig(projectRoot);
+  if (!config) {
     throw new Error("No .memory-core.json found. Run: memory-core init");
   }
-  const { rules } = getProfileRules(config2);
+  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 {
@@ -2383,7 +1801,7 @@ async function scanFiles(options = {}) {
   const summary = await runSnapshotScan(
     projectRoot,
     watchPath,
-    config2,
+    config,
     options.verbose ?? false,
     options.debug ?? false,
     options.onEvent
@@ -2399,9 +1817,9 @@ async function scanFiles(options = {}) {
 }
 async function startWatch(options = {}) {
   const { projectRoot, watchPath } = resolveWatchPaths(options.path, options.projectRoot);
-  const config2 = loadConfig(projectRoot);
+  const config = loadConfig(projectRoot);
   const exitOnSetupFailure = options.exitOnSetupFailure ?? true;
-  if (!config2) {
+  if (!config) {
     const message = "No .memory-core.json found. Run: memory-core init";
     console.error(chalk.red(`
   ${message}
@@ -2410,7 +1828,7 @@ async function startWatch(options = {}) {
     if (exitOnSetupFailure) process.exit(1);
     return;
   }
-  const { rules, avoids } = getProfileRules(config2);
+  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(`
@@ -2440,7 +1858,7 @@ async function startWatch(options = {}) {
     await runSnapshotScan(
       projectRoot,
       watchPath,
-      config2,
+      config,
       options.verbose ?? false,
       options.debug ?? false,
       options.onEvent
@@ -2464,7 +1882,7 @@ async function startWatch(options = {}) {
   const keepAlive = setInterval(() => {
   }, 1 << 30);
   const handle = (filePath) => {
-    if (!SOURCE_EXTENSIONS2.test(filePath)) return;
+    if (!SOURCE_EXTENSIONS.test(filePath)) return;
     if (pending.has(filePath)) clearTimeout(pending.get(filePath));
     const timer = setTimeout(async () => {
       pending.delete(filePath);
@@ -2477,7 +1895,7 @@ async function startWatch(options = {}) {
       const result = await checkFile(
         filePath,
         projectRoot,
-        config2,
+        config,
         options.verbose ?? false,
         options.debug ?? false,
         "diff",
@@ -2699,18 +2117,18 @@ var RuleEngineService = class {
 
 // src/modules/graph-engine/application/graph-engine-service.ts
 import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join8, relative as relative2, resolve as resolve4 } from "path";
-var SOURCE_EXTENSIONS3 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+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) {
   const extension = pathValue.slice(pathValue.lastIndexOf("."));
-  return SOURCE_EXTENSIONS3.has(extension);
+  return SOURCE_EXTENSIONS2.has(extension);
 }
-function asPosix5(value) {
+function asPosix4(value) {
   return value.replace(/\\/g, "/");
 }
 function normalizeNode(pathValue) {
-  return asPosix5(pathValue);
+  return asPosix4(pathValue);
 }
 function edgeKey(edge) {
   return `${edge.from}\0${edge.to}\0${edge.kind}`;
@@ -2734,19 +2152,19 @@ var GraphEngineService = class {
   }
   graphRepository;
   async buildGraph(options = {}) {
-    const cwd = resolve4(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 = resolve4(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(asPosix5(relative2(cwd, imp.resolvedPath)));
+          toNode = normalizeNode(asPosix4(relative2(cwd, imp.resolvedPath)));
         } else if (imp.isExternal) {
           toNode = `pkg:${imp.specifier}`;
         }
@@ -2817,13 +2235,13 @@ var GraphEngineService = class {
     const walk = (dir) => {
       for (const entry of readdirSync2(dir)) {
         if (IGNORED_DIRS.has(entry)) continue;
-        const absolutePath = join8(dir, entry);
+        const absolutePath = join6(dir, entry);
         const stat = statSync2(absolutePath);
         if (stat.isDirectory()) {
           walk(absolutePath);
           continue;
         }
-        const rel = asPosix5(relative2(cwd, absolutePath));
+        const rel = asPosix4(relative2(cwd, absolutePath));
         if (isSourceFile(rel)) files.push(rel);
       }
     };
@@ -2965,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 && config2.backendArchitecture !== "custom") inferred.add(config2.backendArchitecture);
-  if (config2?.frontendFramework && config2.frontendFramework !== "custom") 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);
@@ -2978,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 = [];
@@ -3061,8 +2479,8 @@ async function retrieveMemorySelection(options) {
 
 // src/generator.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname4(__filename);
-var PKG_ROOT = join9(__dirname, "..");
+var __dirname = dirname3(__filename);
+var PKG_ROOT = join7(__dirname, "..");
 function stringifyProfileScalar(value) {
   if (typeof value === "string") {
     const trimmed = value.trim();
@@ -3153,15 +2571,15 @@ function loadProfile(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 = join9(PKG_ROOT, "profiles", `${name}.yml`);
-  if (!existsSync8(profilePath)) throw new Error(`Profile not found: ${name}`);
-  return normalizeArchitectureProfile(yaml.load(readFileSync7(profilePath, "utf-8")), name);
+  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 = readdirSync3(join9(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(readFileSync7(join9(PKG_ROOT, "profiles", f), "utf-8")),
+      yaml.load(readFileSync6(join7(PKG_ROOT, "profiles", f), "utf-8")),
       basename(f, ".yml")
     )
   );
@@ -3231,15 +2649,15 @@ function buildTemplateData(options, cwd = process.cwd()) {
   };
 }
 function renderTemplate(templateName, data) {
-  const templatePath = join9(PKG_ROOT, "templates", templateName);
-  if (!existsSync8(templatePath)) throw new Error(`Template not found: ${templateName}`);
-  return Handlebars.compile(readFileSync7(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 = dirname4(filePath);
-  if (!existsSync8(dir)) mkdirSync2(dir, { recursive: true });
-  if (existsSync8(filePath)) {
-    const existing = readFileSync7(filePath, "utf-8");
+  const dir = dirname3(filePath);
+  if (!existsSync6(dir)) mkdirSync2(dir, { recursive: true });
+  if (existsSync6(filePath)) {
+    const existing = readFileSync6(filePath, "utf-8");
     if (existing === content) return "skipped";
   }
   writeFileSync4(filePath, content, "utf-8");
@@ -3251,8 +2669,8 @@ 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 = join9(cwd, output.path);
-    if (output.skipIfExists && existsSync8(targetPath)) {
+    const targetPath = join7(cwd, output.path);
+    if (output.skipIfExists && existsSync6(targetPath)) {
       skipped.push(output.path);
       continue;
     }
@@ -3272,9 +2690,9 @@ async function generate(options, cwd = process.cwd(), onlyAgents) {
 var reasonMap2 = new Map(
   seeds.filter((s) => s.reason).map((s) => [s.content, s.reason])
 );
-var HOOK_PATH = join10(".git", "hooks", "pre-commit");
+var HOOK_PATH = join8(".git", "hooks", "pre-commit");
 var HOOK_MARKER = "# archmind-memory-core";
-var COMMIT_MSG_HOOK_PATH = join10(".git", "hooks", "commit-msg");
+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";
@@ -3334,7 +2752,7 @@ function toRuleStatEntry(raw) {
   if (typeof raw === "number") return { count: raw, falsePositives: 0 };
   return raw;
 }
-function readPositiveIntEnv2(name, fallback) {
+function readPositiveIntEnv(name, fallback) {
   const raw = Number(process.env[name]);
   return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : fallback;
 }
@@ -3346,8 +2764,8 @@ async function withTimeout(promise, timeoutMs, fallback) {
   try {
     return await Promise.race([
       promise,
-      new Promise((resolve5) => {
-        timer = setTimeout(() => resolve5(fallback), timeoutMs);
+      new Promise((resolve4) => {
+        timer = setTimeout(() => resolve4(fallback), timeoutMs);
       })
     ]);
   } finally {
@@ -3355,11 +2773,11 @@ async function withTimeout(promise, timeoutMs, fallback) {
   }
 }
 function recordViolations(violations, source = "hook") {
-  const statsPath = join10(process.cwd(), ".memory-core-stats.json");
+  const statsPath = join8(process.cwd(), ".memory-core-stats.json");
   let stats = { rules: {}, files: {} };
-  if (existsSync9(statsPath)) {
+  if (existsSync7(statsPath)) {
     try {
-      stats = JSON.parse(readFileSync8(statsPath, "utf-8"));
+      stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
     } catch {
       stats = { rules: {}, files: {} };
     }
@@ -3377,11 +2795,11 @@ function recordViolations(violations, source = "hook") {
   writeFileSync5(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
 }
 function resetViolationStats(cwd = process.cwd()) {
-  const statsPath = join10(cwd, ".memory-core-stats.json");
-  if (!existsSync9(statsPath)) return;
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  if (!existsSync7(statsPath)) return;
   let stats = {};
   try {
-    const parsed = JSON.parse(readFileSync8(statsPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(statsPath, "utf-8"));
     if (parsed && typeof parsed === "object") {
       stats = parsed;
     }
@@ -3394,11 +2812,11 @@ function resetViolationStats(cwd = process.cwd()) {
   writeFileSync5(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
 }
 function recordBypass(hadReason, cwd = process.cwd()) {
-  const statsPath = join10(cwd, ".memory-core-stats.json");
+  const statsPath = join8(cwd, ".memory-core-stats.json");
   let stats = { rules: {}, files: {} };
-  if (existsSync9(statsPath)) {
+  if (existsSync7(statsPath)) {
     try {
-      stats = JSON.parse(readFileSync8(statsPath, "utf-8"));
+      stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
     } catch {
     }
   }
@@ -3412,10 +2830,10 @@ function recordBypass(hadReason, cwd = process.cwd()) {
   return stats.bypasses;
 }
 function readBypassStats(cwd = process.cwd()) {
-  const statsPath = join10(cwd, ".memory-core-stats.json");
-  if (!existsSync9(statsPath)) return { total: 0, withReason: 0, withoutReason: 0 };
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  if (!existsSync7(statsPath)) return { total: 0, withReason: 0, withoutReason: 0 };
   try {
-    const stats = JSON.parse(readFileSync8(statsPath, "utf-8"));
+    const stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
     return stats.bypasses ?? { total: 0, withReason: 0, withoutReason: 0 };
   } catch {
     return { total: 0, withReason: 0, withoutReason: 0 };
@@ -3423,11 +2841,11 @@ function readBypassStats(cwd = process.cwd()) {
 }
 function accumulateTokenUsage(usage, cwd = process.cwd()) {
   if (!usage) return;
-  const statsPath = join10(cwd, ".memory-core-stats.json");
+  const statsPath = join8(cwd, ".memory-core-stats.json");
   let stats = { rules: {}, files: {} };
-  if (existsSync9(statsPath)) {
+  if (existsSync7(statsPath)) {
     try {
-      stats = JSON.parse(readFileSync8(statsPath, "utf-8"));
+      stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
     } catch {
     }
   }
@@ -3471,17 +2889,17 @@ async function promptToSaveViolations(violations) {
   }
 }
 function readRuleCache(cwd) {
-  const cachePath = join10(cwd, RULE_CACHE_FILE);
-  const configPath = join10(cwd, ".memory-core.json");
-  if (!existsSync9(cachePath) || !existsSync9(configPath)) return null;
+  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(readFileSync8(cachePath, "utf-8"));
+    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 = join10(cwd, DB_VERSION_FILE);
-    const dbVersionMtime = existsSync9(dbVersionPath) ? statSync3(dbVersionPath).mtimeMs : 0;
+    const dbVersionPath = join8(cwd, DB_VERSION_FILE);
+    const dbVersionMtime = existsSync7(dbVersionPath) ? statSync3(dbVersionPath).mtimeMs : 0;
     if (dbVersionMtime !== entry.dbVersionMtime) return null;
     return entry;
   } catch {
@@ -3489,18 +2907,18 @@ function readRuleCache(cwd) {
   }
 }
 function saveRuleCache(cwd, data) {
-  const configPath = join10(cwd, ".memory-core.json");
+  const configPath = join8(cwd, ".memory-core.json");
   try {
     const configMtime = statSync3(configPath).mtimeMs;
-    const dbVersionPath = join10(cwd, DB_VERSION_FILE);
-    const dbVersionMtime = existsSync9(dbVersionPath) ? statSync3(dbVersionPath).mtimeMs : 0;
+    const dbVersionPath = join8(cwd, DB_VERSION_FILE);
+    const dbVersionMtime = existsSync7(dbVersionPath) ? statSync3(dbVersionPath).mtimeMs : 0;
     const entry = {
       timestamp: Date.now(),
       configMtime,
       dbVersionMtime,
       ...data
     };
-    writeFileSync5(join10(cwd, RULE_CACHE_FILE), JSON.stringify(entry, null, 2) + "\n", "utf-8");
+    writeFileSync5(join8(cwd, RULE_CACHE_FILE), JSON.stringify(entry, null, 2) + "\n", "utf-8");
   } catch {
   }
 }
@@ -3513,18 +2931,18 @@ async function loadIgnorePatterns2() {
     return [];
   }
 }
-function getProfileRules2(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);
@@ -3532,19 +2950,19 @@ function getProfileRules2(config2) {
   }
   return { rules, avoids };
 }
-async function loadRelevantRules2(config2, diff, stagedFiles, fallbackRules) {
+async function loadRelevantRules2(config, diff, stagedFiles, fallbackRules) {
   try {
     const query = buildContextQuery([
       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: process.cwd(),
-      config: config2,
+      config,
       limit: 15
     });
     const selected = memories.filter((memory) => ["rule", "pattern", "decision"].includes(memory.type)).map((memory) => memory.content);
@@ -3725,10 +3143,10 @@ function parseFalsePositiveDecisions(raw) {
   return { valid: false, decisions: [] };
 }
 function loadRecentViolationsFromStats(cwd = process.cwd()) {
-  const statsPath = join10(cwd, ".memory-core-stats.json");
-  if (!existsSync9(statsPath)) return [];
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  if (!existsSync7(statsPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync8(statsPath, "utf-8"));
+    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"
@@ -3739,11 +3157,11 @@ function loadRecentViolationsFromStats(cwd = process.cwd()) {
 }
 function incrementFalsePositivesForPatterns(learnedPatterns, violations, cwd = process.cwd()) {
   if (learnedPatterns.length === 0 || violations.length === 0) return;
-  const statsPath = join10(cwd, ".memory-core-stats.json");
-  if (!existsSync9(statsPath)) return;
+  const statsPath = join8(cwd, ".memory-core-stats.json");
+  if (!existsSync7(statsPath)) return;
   let stats;
   try {
-    stats = JSON.parse(readFileSync8(statsPath, "utf-8"));
+    stats = JSON.parse(readFileSync7(statsPath, "utf-8"));
   } catch {
     return;
   }
@@ -3787,7 +3205,7 @@ ${JSON.stringify(options.allowPatterns, null, 2)}`;
     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 recheckTimeoutMs = readPositiveIntEnv2("MEMORY_CORE_FALSE_POSITIVE_TIMEOUT_MS", 6e3);
+    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 }
@@ -3963,14 +3381,14 @@ function filterModelViolationsByStagedDiff(violations, stagedFiles, diff) {
   return filtered;
 }
 function installHook(advisory = true, fast = false) {
-  if (!existsSync9(".git")) {
+  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 (existsSync9(HOOK_PATH)) {
-    const existing = readFileSync8(HOOK_PATH, "utf-8");
+  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) : "";
@@ -4002,11 +3420,11 @@ ${body}
   console.log(chalk2.gray("    To uninstall: memory-core hook uninstall\n"));
 }
 function uninstallHook() {
-  if (!existsSync9(HOOK_PATH)) {
+  if (!existsSync7(HOOK_PATH)) {
     console.log(chalk2.yellow("\n  No pre-commit hook found.\n"));
     return;
   }
-  const content = readFileSync8(HOOK_PATH, "utf-8");
+  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;
@@ -4051,8 +3469,8 @@ function installCommitMsgHook(advisory = true) {
 
 ${body}
 `;
-  if (existsSync9(COMMIT_MSG_HOOK_PATH)) {
-    const existing = readFileSync8(COMMIT_MSG_HOOK_PATH, "utf-8");
+  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) : "";
@@ -4073,8 +3491,8 @@ ${body}
   chmodSync(COMMIT_MSG_HOOK_PATH, 493);
 }
 function uninstallCommitMsgHook() {
-  if (!existsSync9(COMMIT_MSG_HOOK_PATH)) return;
-  const content = readFileSync8(COMMIT_MSG_HOOK_PATH, "utf-8");
+  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)) : "";
@@ -4086,20 +3504,20 @@ function uninstallCommitMsgHook() {
   }
 }
 async function checkCommitMsg(msgFile, options = {}) {
-  if (!existsSync9(msgFile)) {
+  if (!existsSync7(msgFile)) {
     if (options.verbose) console.log(chalk2.gray("  No commit message file \u2014 skipping."));
     return;
   }
-  const raw = readFileSync8(msgFile, "utf-8");
+  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 = join10(process.cwd(), ".memory-core.json");
-  if (!existsSync9(configPath)) return;
-  const config2 = JSON.parse(readFileSync8(configPath, "utf-8"));
-  const rules = (config2.commitRules ?? []).filter(Boolean);
+  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 = [];
@@ -4132,11 +3550,11 @@ async function checkCommitMsg(msgFile, options = {}) {
   process.exit(1);
 }
 async function checkStaged(options = {}) {
-  const SOURCE_EXTENSIONS4 = /\.(ts|tsx|js|jsx|py|php|rb|go|java|cs|swift|kt|rs|vue|svelte)$/;
+  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_EXTENSIONS4.test(f)).map((f) => normalizePath(f));
+    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;
@@ -4155,20 +3573,20 @@ async function checkStaged(options = {}) {
     if (options.verbose) console.log(chalk2.gray("  No staged changes to check."));
     return;
   }
-  const configPath = join10(process.cwd(), ".memory-core.json");
-  if (!existsSync9(configPath)) return;
-  const config2 = JSON.parse(readFileSync8(configPath, "utf-8"));
-  const { rules: fallbackRules, avoids } = getProfileRules2(config2);
+  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 = readPositiveIntEnv2("MEMORY_CORE_RULE_LOAD_TIMEOUT_MS", 2e3);
-  const ignoreLoadTimeoutMs = readPositiveIntEnv2("MEMORY_CORE_IGNORE_LOAD_TIMEOUT_MS", 1500);
+  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(config2))];
+    allowPatterns = [...new Set(getAllowPatterns(config))];
   } else {
     const cwd = process.cwd();
     const cached = readRuleCache(cwd);
@@ -4181,17 +3599,17 @@ async function checkStaged(options = {}) {
       }
     } else {
       const [loadedRules, loadedIgnores] = await Promise.all([
-        withTimeout(loadRelevantRules2(config2, diff, stagedFiles, fallbackRules), ruleLoadTimeoutMs, fallbackRules),
+        withTimeout(loadRelevantRules2(config, diff, stagedFiles, fallbackRules), ruleLoadTimeoutMs, fallbackRules),
         withTimeout(loadIgnorePatterns2(), ignoreLoadTimeoutMs, [])
       ]);
       rules = loadedRules;
       ignores = loadedIgnores;
-      allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config2), ...loadedIgnores])];
+      allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config), ...loadedIgnores])];
       saveRuleCache(cwd, { rules, ignores, allowPatterns });
     }
   }
   if (rules.length === 0) return;
-  const modelInputMaxChars = readPositiveIntEnv2("MEMORY_CORE_MODEL_INPUT_MAX_CHARS", 8e3);
+  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) {
@@ -4235,7 +3653,7 @@ Do not include any text outside the JSON object.`;
   const deterministicViolations = findDeterministicViolations(diff, rules, avoids, allowPatterns);
   const astViolations = findAstDeterministicViolationsForDiff(diff, {
     cwd: process.cwd(),
-    config: config2,
+    config,
     rules,
     reasonLookup: reasonMap2
   });
@@ -4251,7 +3669,7 @@ Do not include any text outside the JSON object.`;
       console.log(chalk2.gray("  AI check skipped; running deterministic checks only."));
     }
   } else try {
-    const checkTimeoutMs = readPositiveIntEnv2("MEMORY_CORE_CHECK_TIMEOUT_MS", readPositiveIntEnv2("CHAT_TIMEOUT_MS", 2e4));
+    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: `Review these staged changes:
@@ -4350,10 +3768,10 @@ ${modelInput.text}` }
   }
   let ruleStatsSnapshot = {};
   {
-    const statsPath = join10(process.cwd(), ".memory-core-stats.json");
-    if (existsSync9(statsPath)) {
+    const statsPath = join8(process.cwd(), ".memory-core-stats.json");
+    if (existsSync7(statsPath)) {
       try {
-        const parsed = JSON.parse(readFileSync8(statsPath, "utf-8"));
+        const parsed = JSON.parse(readFileSync7(statsPath, "utf-8"));
         ruleStatsSnapshot = parsed.rules ?? {};
       } catch {
       }
@@ -4467,7 +3885,7 @@ function getCiDiff() {
 }
 async function checkFile2(filePath, options = {}) {
   const { readFileSync: readFile, existsSync: fileExists } = await import("fs");
-  const resolvedPath = filePath.startsWith("/") ? filePath : join10(process.cwd(), filePath);
+  const resolvedPath = filePath.startsWith("/") ? filePath : join8(process.cwd(), filePath);
   if (!fileExists(resolvedPath)) {
     console.error(chalk2.red(`
   File not found: ${filePath}
@@ -4482,14 +3900,14 @@ async function checkFile2(filePath, options = {}) {
     `@@ -0,0 +1,${lines.length} @@`,
     ...lines.map((l) => `+${l}`)
   ].join("\n");
-  const configPath = join10(process.cwd(), ".memory-core.json");
-  if (!existsSync9(configPath)) {
+  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 config2 = JSON.parse(readFileSync8(configPath, "utf-8"));
-  const { rules: fallbackRules, avoids } = getProfileRules2(config2);
-  const allowPatterns = [...new Set(getAllowPatterns(config2))];
+  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) {
@@ -4499,9 +3917,9 @@ async function checkFile2(filePath, options = {}) {
     if (cached) {
       rules = cached.rules;
     } else {
-      const ruleLoadTimeoutMs = readPositiveIntEnv2("MEMORY_CORE_RULE_LOAD_TIMEOUT_MS", 2e3);
+      const ruleLoadTimeoutMs = readPositiveIntEnv("MEMORY_CORE_RULE_LOAD_TIMEOUT_MS", 2e3);
       rules = await withTimeout(
-        loadRelevantRules2(config2, pseudoDiff, [filePath], fallbackRules),
+        loadRelevantRules2(config, pseudoDiff, [filePath], fallbackRules),
         ruleLoadTimeoutMs,
         fallbackRules
       );
@@ -4516,7 +3934,7 @@ async function checkFile2(filePath, options = {}) {
   const deterministicViolations = findDeterministicViolations(pseudoDiff, rules, avoids, allowPatterns);
   const astViolations = findAstDeterministicViolationsForDiff(pseudoDiff, {
     cwd: process.cwd(),
-    config: config2,
+    config,
     rules,
     reasonLookup: reasonMap2
   });
@@ -4606,22 +4024,13 @@ 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 .env"));
+  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,
-  getChatProviderLabel,
-  getPool,
-  runMigrations,
-  saveMemory,
-  listMemories,
-  deleteMemory,
-  updateMemory,
-  closePool,
   migrateGraphSnapshots,
   probeGraphSnapshotStore,
   seeds,