@shahmilsaari/memory-core 1.0.0 → 1.0.2

package/dist/{chunk-J7SPACA3.js → chunk-PDQXIKL7.js}

@@ -1,10 +1,4 @@
 #!/usr/bin/env node
-import {
-  embed
-} from "./chunk-HAGRPKR3.js";
-import {
-  searchMemories
-} from "./chunk-WUL7HLAA.js";
 
 // src/project-detector.ts
 import { existsSync, readFileSync } from "fs";
@@ -68,350 +62,525 @@ function detectProject(cwd = process.cwd()) {
   return { language: "Unknown", framework: "Unknown" };
 }
 
-// src/retriever.ts
-async function retrieve(query, architecture, limit = 10) {
-  const embedding = await embed(query);
-  return searchMemories(embedding, architecture, limit);
-}
-
-// src/memory-selection.ts
-var FRAMEWORK_ARCHITECTURE_MAP = {
-  Laravel: ["laravel-service-repository"],
-  "Next.js": ["nextjs"],
-  "Nuxt.js": ["nuxt"],
-  Go: ["go-api"],
-  NestJS: ["nestjs"],
-  React: ["react"],
-  "Vue.js": ["vue"],
-  Svelte: ["svelte"]
+// 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 ?? "";
+  }
 };
-var KNOWN_ARCHITECTURE_KEYS = /* @__PURE__ */ new Set([
-  ...Object.values(FRAMEWORK_ARCHITECTURE_MAP).flat(),
-  "angular",
-  "clean-architecture",
-  "express",
-  "fastify",
-  "hexagonal",
-  "modular-monolith",
-  "mvc",
-  "react-native"
-]);
-function normalizeText(value) {
-  return value.toLowerCase().replace(/[`"'()[\]{}.,:;!?/\\<>|=*+-]/g, " ").replace(/\s+/g, " ").trim();
-}
-function tokenSet(value) {
-  return new Set(
-    normalizeText(value).split(" ").filter((token) => token.length > 2)
-  );
-}
-function similarityScore(a, b) {
-  const left = tokenSet(a);
-  const right = tokenSet(b);
-  if (left.size === 0 || right.size === 0) return 0;
-  let intersection = 0;
-  for (const token of left) {
-    if (right.has(token)) intersection++;
+
+// src/embedding.ts
+async function embed(text) {
+  let response;
+  try {
+    response = await fetch(`${Config.ollamaUrl}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: Config.ollamaModel, prompt: text })
+    });
+  } catch {
+    throw new Error(
+      `Cannot reach Ollama at ${Config.ollamaUrl}. Run: ollama serve`
+    );
   }
-  return 2 * intersection / (left.size + right.size);
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Ollama embedding failed (${response.status}): ${body}`);
+  }
+  const data = await response.json();
+  return data.embedding;
 }
-function mergeMemory(primary, secondary) {
-  const mergedTags = [.../* @__PURE__ */ new Set([...primary.tags ?? [], ...secondary.tags ?? []])];
-  const reason = [primary.reason, secondary.reason].filter(Boolean).join(" | ") || void 0;
+
+// 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 {
-    ...primary,
-    tags: mergedTags,
-    reason
+    provider,
+    model,
+    ollamaUrl: process.env.OLLAMA_URL ?? "http://localhost:11434",
+    apiKey: process.env.CHAT_API_KEY ?? ""
   };
 }
-function memoryArchitectureKeys(memory) {
-  if (memory.architecture && memory.architecture !== "global") {
-    return [memory.architecture];
+async function callOllama(cfg, messages) {
+  const res = await fetch(`${cfg.ollamaUrl}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model: cfg.model, messages, stream: false, format: "json" })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    if (body.includes("not found") || body.includes("model")) {
+      throw new Error(`MODEL_NOT_FOUND:${cfg.model}`);
+    }
+    throw new Error(body);
   }
-  return (memory.tags ?? []).filter((tag) => KNOWN_ARCHITECTURE_KEYS.has(tag));
+  const data = await res.json();
+  return data.message.content.trim();
 }
-function getStackReason(memory, activeArchitectures) {
-  const architectureKeys = memoryArchitectureKeys(memory);
-  if (architectureKeys.length === 0) {
-    return {
-      included: true,
-      reason: "global memory: no architecture-specific tag"
-    };
-  }
-  const matched = architectureKeys.filter((architecture) => activeArchitectures.has(architecture));
-  if (matched.length > 0) {
-    return {
-      included: true,
-      reason: `matched active architecture: ${matched.join(", ")}`
-    };
+async function callOpenAI(cfg, messages) {
+  const res = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${cfg.apiKey}`
+    },
+    body: JSON.stringify({
+      model: cfg.model,
+      messages,
+      response_format: { type: "json_object" }
+    })
+  });
+  if (!res.ok) throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.choices[0].message.content.trim();
+}
+async function callAnthropic(cfg, messages) {
+  const system = messages.find((m) => m.role === "system")?.content ?? "";
+  const userMessages = messages.filter((m) => m.role !== "system");
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": cfg.apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: cfg.model,
+      max_tokens: 4096,
+      system,
+      messages: userMessages
+    })
+  });
+  if (!res.ok) throw new Error(`Anthropic API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.content[0].text.trim();
+}
+async function callMiniMax(cfg, messages) {
+  const res = await fetch("https://api.minimax.io/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${cfg.apiKey}`
+    },
+    body: JSON.stringify({
+      model: cfg.model,
+      messages,
+      response_format: { type: "json_object" }
+    })
+  });
+  if (!res.ok) throw new Error(`MiniMax API error ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.choices[0].message.content.trim();
+}
+async function callChatModel(messages) {
+  const cfg = getChatConfig();
+  switch (cfg.provider) {
+    case "openai":
+      return callOpenAI(cfg, messages);
+    case "anthropic":
+      return callAnthropic(cfg, messages);
+    case "minimax":
+      return callMiniMax(cfg, messages);
+    default:
+      return callOllama(cfg, messages);
   }
-  const active = [...activeArchitectures].join(", ") || "none detected";
-  return {
-    included: false,
-    reason: `excluded: tagged for ${architectureKeys.join(", ")}; active stack is ${active}`
-  };
 }
-function dedupeMemories(memories, threshold = 0.8) {
-  const deduped = [];
-  for (const memory of memories) {
-    const existingIndex = deduped.findIndex((candidate) => {
-      if (candidate.content_hash && memory.content_hash && candidate.content_hash === memory.content_hash) {
-        return true;
-      }
-      return similarityScore(candidate.content, memory.content) >= threshold;
-    });
-    if (existingIndex === -1) {
-      deduped.push(memory);
-      continue;
+function getChatProviderLabel() {
+  const cfg = getChatConfig();
+  if (cfg.provider === "ollama") return `ollama (${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 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.");
     }
-    deduped[existingIndex] = mergeMemory(deduped[existingIndex], memory);
+    pool = new Pool({ connectionString: Config.databaseUrl });
   }
-  return deduped;
+  return pool;
 }
-function inferProjectArchitectures(cwd = process.cwd(), config) {
-  const inferred = /* @__PURE__ */ new Set();
-  if (config?.backendArchitecture) inferred.add(config.backendArchitecture);
-  if (config?.frontendFramework) inferred.add(config.frontendFramework);
-  if (config?.projectType === "backend" && !config.backendArchitecture) {
-    inferred.add("clean-architecture");
-  }
-  const detected = detectProject(cwd);
-  for (const architecture of FRAMEWORK_ARCHITECTURE_MAP[detected.framework] ?? []) {
-    inferred.add(architecture);
+async function runMigrations() {
+  if (migrationsRun) return;
+  const client = await getPool().connect();
+  try {
+    await client.query("BEGIN");
+    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();
   }
-  return [...inferred];
 }
-function getAllowPatterns(config) {
-  return [...new Set(config?.allowPatterns?.filter(Boolean) ?? [])];
+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
+    ]
+  );
 }
-function filterRelevantMemories(memories, config, cwd = process.cwd()) {
-  return explainMemorySelection(memories, config, cwd).included;
+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";
 }
-function explainMemorySelection(memories, config, cwd = process.cwd(), threshold = 0.8) {
-  const activeArchitectures = inferProjectArchitectures(cwd, config);
-  const activeSet = new Set(activeArchitectures);
-  const included = [];
-  const decisions = [];
-  for (const memory of memories) {
-    const stackDecision = getStackReason(memory, activeSet);
-    if (!stackDecision.included) {
-      decisions.push({
-        memory,
-        status: "excluded",
-        reason: stackDecision.reason
-      });
-      continue;
+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}`);
     }
-    const existingIndex = included.findIndex((candidate) => {
-      if (candidate.content_hash && memory.content_hash && candidate.content_hash === memory.content_hash) {
-        return true;
-      }
-      return similarityScore(candidate.content, memory.content) >= threshold;
-    });
-    if (existingIndex === -1) {
-      included.push(memory);
-      decisions.push({
-        memory,
-        status: "included",
-        reason: stackDecision.reason
-      });
-      continue;
+  }
+  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}`);
     }
-    included[existingIndex] = mergeMemory(included[existingIndex], memory);
-    decisions.push({
-      memory,
-      status: "excluded",
-      reason: `duplicate or near-duplicate of memory #${included[existingIndex].id}`
-    });
   }
-  return {
-    included,
-    excluded: decisions.filter((decision) => decision.status === "excluded"),
-    decisions,
-    activeArchitectures
-  };
+  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;
 }
-function buildContextQuery(parts, maxLength = 1200) {
-  return parts.filter(Boolean).join("\n").slice(0, maxLength);
+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 retrieveContextualMemories(options) {
-  return (await retrieveMemorySelection(options)).included;
+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 retrieveMemorySelection(options) {
-  const architectures = inferProjectArchitectures(options.cwd, options.config);
-  const memories = await retrieve(options.query, architectures, options.limit ?? 15);
-  return explainMemorySelection(memories, options.config, options.cwd);
+async function closePool() {
+  if (pool) {
+    await pool.end();
+    pool = null;
+    migrationsRun = false;
+  }
 }
 
-// src/generator.ts
-import { readFileSync as readFileSync2, readdirSync, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
-import { join as join2, dirname } from "path";
-import { fileURLToPath } from "url";
-import Handlebars from "handlebars";
-import yaml from "js-yaml";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var PKG_ROOT = join2(__dirname, "..");
-var OUTPUT_FILES = [
-  { template: "CLAUDE.md.hbs", path: "CLAUDE.md", agent: "Claude Code" },
-  { template: "copilot-instructions.md.hbs", path: ".github/copilot-instructions.md", agent: "GitHub Copilot" },
-  { template: "cursorrules.hbs", path: ".cursorrules", agent: "Cursor" },
-  { template: "cursor-rule.mdc.hbs", path: ".cursor/rules/memory-core.mdc", agent: "Cursor" },
-  { template: "windsurfrules.hbs", path: ".windsurfrules", agent: "Windsurf" },
-  { template: "clinerules.hbs", path: ".clinerules", agent: "Cline" },
-  { template: "roo-rule.md.hbs", path: ".roo/rules/memory-core.md", agent: "Roo Code" },
-  { template: "aider.conf.yml.hbs", path: ".aider.conf.yml", agent: "Aider" },
-  { template: "continue-config.json.hbs", path: ".continue/config.json", agent: "Continue.dev", skipIfExists: true },
-  { template: "DEVIN.md.hbs", path: "DEVIN.md", agent: "Devin" },
-  { template: "amazonq-guidelines.md.hbs", path: ".amazonq/dev/guidelines.md", agent: "Amazon Q" },
-  { template: "gemini-styleguide.md.hbs", path: ".gemini/styleguide.md", agent: "Gemini Code Assist" },
-  { template: "zed-settings.json.hbs", path: ".zed/settings.json", agent: "Zed AI", skipIfExists: true },
-  { template: "jetbrains-ai.md.hbs", path: ".idea/ai-instructions.md", agent: "JetBrains AI" },
-  { template: "AGENTS.md.hbs", path: "AGENTS.md", agent: "OpenHands" },
-  { template: "AI_RULES.md.hbs", path: "AI_RULES.md", agent: "Shared" },
-  { template: "ARCHITECTURE.md.hbs", path: "ARCHITECTURE.md", agent: "Shared" },
-  { template: "PROJECT_MEMORY.md.hbs", path: "PROJECT_MEMORY.md", agent: "Shared" }
-];
-var AGENT_NAMES = [...new Set(OUTPUT_FILES.map((f) => f.agent))];
-Handlebars.registerHelper(
-  "join",
-  (arr, sep) => Array.isArray(arr) ? arr.join(sep) : ""
-);
-Handlebars.registerHelper(
-  "bullet",
-  (arr) => Array.isArray(arr) ? arr.map((i) => `- ${i}`).join("\n") : ""
-);
-Handlebars.registerHelper(
-  "numbered",
-  (arr) => Array.isArray(arr) ? arr.map((i, idx) => `${idx + 1}. ${i}`).join("\n") : ""
-);
-Handlebars.registerHelper("json", (val) => JSON.stringify(val, null, 2));
-Handlebars.registerHelper("memoryBlock", (memory) => {
-  const meta = [memory.type, memory.architecture].filter(Boolean).join(" \xB7 ");
-  const label = memory.title ? `${memory.title}: ${memory.content}` : memory.content;
-  const lines = [`- [${meta || "memory"}] ${label}`];
-  if (memory.reason) lines.push(`  Why: ${memory.reason}`);
-  if (memory.context?.appliesTo?.length) lines.push(`  Use when: ${memory.context.appliesTo.join("; ")}`);
-  if (memory.context?.avoidWhen?.length) lines.push(`  Avoid when: ${memory.context.avoidWhen.join("; ")}`);
-  if (memory.context?.examples?.length) {
-    lines.push("  Examples:");
-    for (const example of memory.context.examples) lines.push(`    - ${example}`);
-  }
-  if (memory.tags?.length) lines.push(`  Tags: ${memory.tags.join(", ")}`);
-  if (memory.project_name || memory.context?.source) {
-    lines.push(`  Source: ${memory.context?.source ?? memory.project_name}`);
-  }
-  return new Handlebars.SafeString(lines.join("\n"));
-});
-function loadProfile(name) {
-  const profilePath = join2(PKG_ROOT, "profiles", `${name}.yml`);
-  if (!existsSync2(profilePath)) throw new Error(`Profile not found: ${name}`);
-  return yaml.load(readFileSync2(profilePath, "utf-8"));
+// src/infrastructure/persistence/postgres/postgres-graph-repository.ts
+var graphMigrationsRun = false;
+function asPosix(value) {
+  return value.replace(/\\/g, "/");
 }
-function listProfiles(layer) {
-  const files = readdirSync(join2(PKG_ROOT, "profiles")).filter((f) => f.endsWith(".yml"));
-  const all = files.map((f) => yaml.load(readFileSync2(join2(PKG_ROOT, "profiles", f), "utf-8")));
-  if (!layer) return all;
-  if (layer === "backend") return all.filter((p) => p.layer === "backend" || p.layer === "fullstack");
-  if (layer === "frontend") return all.filter((p) => p.layer === "frontend" || p.layer === "fullstack");
-  return all;
+function isEdge(value) {
+  if (!value || typeof value !== "object") return false;
+  const edge = value;
+  return typeof edge.from === "string" && typeof edge.to === "string" && (edge.kind === "import" || edge.kind === "dynamic-import" || edge.kind === "require");
 }
-function buildTemplateData(options, cwd = process.cwd()) {
-  const backend = options.backendArchitecture ? loadProfile(options.backendArchitecture) : null;
-  const frontend = options.frontendFramework ? loadProfile(options.frontendFramework) : null;
-  const dedupedMemories = filterRelevantMemories(options.memories, {
-    projectType: options.projectType,
-    backendArchitecture: options.backendArchitecture,
-    frontendFramework: options.frontendFramework,
-    language: options.language
-  }, cwd);
-  const allRules = [
-    ...backend?.rules ?? [],
-    ...frontend?.rules ?? []
-  ];
-  const allFolders = [
-    ...backend?.folders ?? [],
-    ...frontend?.folders ?? []
-  ];
-  const allAvoid = [
-    ...backend?.avoid ?? [],
-    ...frontend?.avoid ?? []
-  ];
-  const archLabel = [
-    backend ? `Backend: ${backend.displayName}` : null,
-    frontend ? `Frontend: ${frontend.displayName}` : null
-  ].filter(Boolean).join(" \xB7 ");
+function parseStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function parseEdgeArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isEdge);
+}
+function toSnapshot(row) {
   return {
-    projectName: options.projectName,
-    projectType: options.projectType,
-    isBackend: options.projectType === "backend" || options.projectType === "fullstack",
-    isFrontend: options.projectType === "frontend" || options.projectType === "fullstack",
-    isFullstack: options.projectType === "fullstack",
-    // backend
-    hasBackend: !!backend,
-    backendArchitecture: backend?.displayName,
-    backendDescription: backend?.description,
-    backendRules: backend?.rules ?? [],
-    backendFolders: backend?.folders ?? [],
-    backendAvoid: backend?.avoid ?? [],
-    // frontend
-    hasFrontend: !!frontend,
-    frontendFramework: frontend?.displayName,
-    frontendDescription: frontend?.description,
-    frontendRules: frontend?.rules ?? [],
-    frontendFolders: frontend?.folders ?? [],
-    frontendAvoid: frontend?.avoid ?? [],
-    // combined — used by simple templates
-    architecture: archLabel,
-    rules: allRules,
-    folders: allFolders,
-    avoid: allAvoid,
-    description: [backend?.description, frontend?.description].filter(Boolean).join(" | "),
-    // memories
-    memories: dedupedMemories,
-    hasMemories: dedupedMemories.length > 0,
-    // misc
-    language: options.language,
-    caveman: options.caveman,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+    id: row.id,
+    rootPath: asPosix(row.root_path),
+    createdAt: new Date(row.created_at).toISOString(),
+    nodes: parseStringArray(row.nodes),
+    edges: parseEdgeArray(row.edges)
   };
 }
-function renderTemplate(templateName, data) {
-  const templatePath = join2(PKG_ROOT, "templates", templateName);
-  if (!existsSync2(templatePath)) throw new Error(`Template not found: ${templateName}`);
-  return Handlebars.compile(readFileSync2(templatePath, "utf-8"))(data);
-}
-function writeFile(filePath, content) {
-  const dir = dirname(filePath);
-  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
-  if (existsSync2(filePath)) {
-    const existing = readFileSync2(filePath, "utf-8");
-    if (existing === content) return "skipped";
+async function ensureGraphMigrations() {
+  if (graphMigrationsRun) return;
+  const client = await getPool().connect();
+  try {
+    await client.query("BEGIN");
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS graph_snapshots (
+        id TEXT PRIMARY KEY,
+        root_path TEXT NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        nodes JSONB NOT NULL DEFAULT '[]'::jsonb,
+        edges JSONB NOT NULL DEFAULT '[]'::jsonb
+      )
+    `);
+    await client.query("CREATE INDEX IF NOT EXISTS graph_snapshots_root_path_idx ON graph_snapshots (root_path)");
+    await client.query("CREATE INDEX IF NOT EXISTS graph_snapshots_created_at_idx ON graph_snapshots (created_at DESC)");
+    await client.query("COMMIT");
+    graphMigrationsRun = true;
+  } catch (err) {
+    await client.query("ROLLBACK");
+    throw err;
+  } finally {
+    client.release();
   }
-  writeFileSync(filePath, content, "utf-8");
-  return "written";
 }
-async function generate(options, cwd = process.cwd(), onlyAgents) {
-  const data = buildTemplateData(options, cwd);
-  const written = [];
-  const skipped = [];
-  const files = onlyAgents ? OUTPUT_FILES.filter((f) => onlyAgents.includes(f.agent)) : OUTPUT_FILES;
-  for (const output of files) {
-    const targetPath = join2(cwd, output.path);
-    if (output.skipIfExists && existsSync2(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 };
+async function migrateGraphSnapshots() {
+  await ensureGraphMigrations();
+}
+async function probeGraphSnapshotStore(rootPath) {
+  await ensureGraphMigrations();
+  const result = await getPool().query(
+    `SELECT COUNT(*)::text AS count
+     FROM graph_snapshots
+     WHERE root_path = $1`,
+    [asPosix(rootPath)]
+  );
+  return { snapshotCount: Number(result.rows[0]?.count ?? 0) };
 }
+var PostgresGraphRepository = class {
+  async saveSnapshot(snapshot) {
+    await ensureGraphMigrations();
+    await getPool().query(
+      `INSERT INTO graph_snapshots (id, root_path, created_at, nodes, edges)
+       VALUES ($1, $2, $3::timestamptz, $4::jsonb, $5::jsonb)
+       ON CONFLICT (id)
+       DO UPDATE SET
+         root_path = EXCLUDED.root_path,
+         created_at = EXCLUDED.created_at,
+         nodes = EXCLUDED.nodes,
+         edges = EXCLUDED.edges`,
+      [
+        snapshot.id,
+        asPosix(snapshot.rootPath),
+        snapshot.createdAt,
+        JSON.stringify(snapshot.nodes),
+        JSON.stringify(snapshot.edges)
+      ]
+    );
+  }
+  async latestSnapshot(rootPath) {
+    await ensureGraphMigrations();
+    const result = await getPool().query(
+      `SELECT id, root_path, created_at, nodes, edges
+       FROM graph_snapshots
+       WHERE root_path = $1
+       ORDER BY created_at DESC
+       LIMIT 1`,
+      [asPosix(rootPath)]
+    );
+    const row = result.rows[0];
+    return row ? toSnapshot(row) : null;
+  }
+  async getSnapshot(rootPath, snapshotId) {
+    await ensureGraphMigrations();
+    const result = await getPool().query(
+      `SELECT id, root_path, created_at, nodes, edges
+       FROM graph_snapshots
+       WHERE root_path = $1 AND id = $2
+       LIMIT 1`,
+      [asPosix(rootPath), snapshotId]
+    );
+    const row = result.rows[0];
+    return row ? toSnapshot(row) : null;
+  }
+  async listSnapshots(rootPath, limit = 20) {
+    await ensureGraphMigrations();
+    const result = await getPool().query(
+      `SELECT id, root_path, created_at, nodes, edges
+       FROM graph_snapshots
+       WHERE root_path = $1
+       ORDER BY created_at DESC
+       LIMIT $2`,
+      [asPosix(rootPath), Math.max(1, limit)]
+    );
+    return result.rows.map(toSnapshot);
+  }
+};
 
 // src/seeds.ts
 var seeds = [
@@ -794,116 +963,1290 @@ 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/chat.ts
-function getChatConfig() {
-  const provider = process.env.CHAT_PROVIDER ?? "ollama";
-  const model = process.env.CHAT_MODEL ?? process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
+// src/watcher.ts
+import { watch } from "chokidar";
+import { spawnSync } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7, relative as relative2 } from "path";
+import chalk 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 } from "path";
+import { fileURLToPath } from "url";
+import Handlebars from "handlebars";
+import yaml from "js-yaml";
+
+// src/infrastructure/providers/embedding/ollama-embedding-provider.ts
+var OllamaEmbeddingProvider = class {
+  providerName() {
+    return "ollama";
+  }
+  async embed(text) {
+    return embed(text);
+  }
+};
+
+// src/infrastructure/providers/llm/chat-llm-provider.ts
+var ChatLlmProvider = class {
+  providerName() {
+    return getChatProviderLabel();
+  }
+  async generateText(messages) {
+    return callChatModel(messages);
+  }
+};
+
+// src/infrastructure/persistence/postgres/postgres-memory-repository.ts
+function toRecord(memory) {
+  return {
+    id: memory.id,
+    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,
+    contentHash: memory.content_hash,
+    similarity: memory.similarity
+  };
+}
+function toDbContext(context) {
+  return context;
+}
+function toDbInput(input) {
+  return {
+    type: input.type,
+    scope: input.scope,
+    architecture: input.architecture,
+    projectName: input.projectName,
+    title: input.title,
+    content: input.content,
+    reason: input.reason,
+    context: toDbContext(input.context),
+    tags: input.tags,
+    embedding: input.embedding
+  };
+}
+var PostgresMemoryRepository = class {
+  async save(input) {
+    await saveMemory(toDbInput(input));
+  }
+  async upsert(input) {
+    return upsertMemory(toDbInput(input));
+  }
+  async list(filters = {}) {
+    const rows = await listMemories({
+      type: filters.type,
+      scope: filters.scope,
+      architecture: filters.architecture,
+      projectName: filters.projectName,
+      includeGlobal: filters.includeGlobal,
+      limit: filters.limit,
+      tags: filters.tags
+    });
+    return rows.map(toRecord);
+  }
+  async getById(id) {
+    const row = await getMemory(id);
+    return row ? toRecord(row) : null;
+  }
+  async update(id, patch) {
+    const row = await updateMemory(id, {
+      type: patch.type,
+      scope: patch.scope,
+      title: patch.title,
+      content: patch.content,
+      reason: patch.reason,
+      context: patch.context,
+      tags: patch.tags,
+      embedding: patch.embedding
+    });
+    return row ? toRecord(row) : null;
+  }
+  async removeById(id) {
+    return deleteMemory(id);
+  }
+  async removeMany(filters) {
+    return deleteMemories(filters);
+  }
+  async searchByEmbedding(input) {
+    const rows = await searchMemories(input.embedding, input.architectures, input.limit ?? 10);
+    return rows.map(toRecord);
+  }
+};
+
+// 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");
+function asPosix2(value) {
+  return value.replace(/\\/g, "/");
+}
+var FileGraphRepository = class {
+  constructor(rootPath = process.cwd(), relativeFilePath = DEFAULT_FILE) {
+    this.rootPath = rootPath;
+    this.relativeFilePath = relativeFilePath;
+  }
+  rootPath;
+  relativeFilePath;
+  async saveSnapshot(snapshot) {
+    const data = this.readData();
+    data.snapshots.push({
+      ...snapshot,
+      rootPath: asPosix2(snapshot.rootPath),
+      nodes: [...new Set(snapshot.nodes.map(asPosix2))],
+      edges: snapshot.edges.map((edge) => ({ ...edge, from: asPosix2(edge.from), to: asPosix2(edge.to) }))
+    });
+    this.writeData(data);
+  }
+  async latestSnapshot(rootPath) {
+    const snapshots = this.snapshotsForRoot(rootPath);
+    return snapshots.length ? snapshots[snapshots.length - 1] : null;
+  }
+  async getSnapshot(rootPath, snapshotId) {
+    const snapshots = this.snapshotsForRoot(rootPath);
+    return snapshots.find((snapshot) => snapshot.id === snapshotId) ?? null;
+  }
+  async listSnapshots(rootPath, limit = 20) {
+    const snapshots = this.snapshotsForRoot(rootPath);
+    return [...snapshots].slice(-Math.max(1, limit)).reverse();
+  }
+  snapshotsForRoot(rootPath) {
+    const normalized = asPosix2(rootPath);
+    return this.readData().snapshots.filter((snapshot) => asPosix2(snapshot.rootPath) === normalized);
+  }
+  readData() {
+    const filePath = this.absolutePath();
+    if (!existsSync3(filePath)) {
+      return { version: 1, snapshots: [] };
+    }
+    try {
+      const parsed = JSON.parse(readFileSync2(filePath, "utf-8"));
+      if (!Array.isArray(parsed.snapshots)) {
+        return { version: 1, snapshots: [] };
+      }
+      return {
+        version: 1,
+        snapshots: parsed.snapshots.filter(
+          (snapshot) => typeof snapshot?.id === "string" && typeof snapshot?.createdAt === "string" && typeof snapshot?.rootPath === "string" && Array.isArray(snapshot?.nodes) && Array.isArray(snapshot?.edges)
+        )
+      };
+    } catch {
+      return { version: 1, snapshots: [] };
+    }
+  }
+  writeData(data) {
+    const filePath = this.absolutePath();
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(data, null, 2)}
+`, "utf-8");
+  }
+  absolutePath() {
+    return join3(this.rootPath, this.relativeFilePath);
+  }
+};
+
+// src/infrastructure/persistence/postgres/resilient-graph-repository.ts
+var ResilientGraphRepository = class {
+  constructor(primary, fallback) {
+    this.primary = primary;
+    this.fallback = fallback;
+  }
+  primary;
+  fallback;
+  async saveSnapshot(snapshot) {
+    try {
+      await this.primary.saveSnapshot(snapshot);
+    } catch {
+      await this.fallback.saveSnapshot(snapshot);
+    }
+  }
+  async latestSnapshot(rootPath) {
+    try {
+      const value = await this.primary.latestSnapshot(rootPath);
+      if (value) return value;
+    } catch {
+    }
+    return this.fallback.latestSnapshot(rootPath);
+  }
+  async getSnapshot(rootPath, snapshotId) {
+    try {
+      const value = await this.primary.getSnapshot(rootPath, snapshotId);
+      if (value) return value;
+    } catch {
+    }
+    return this.fallback.getSnapshot(rootPath, snapshotId);
+  }
+  async listSnapshots(rootPath, limit = 20) {
+    try {
+      const value = await this.primary.listSnapshots(rootPath, limit);
+      if (value.length > 0) return value;
+    } catch {
+    }
+    return this.fallback.listSnapshots(rootPath, limit);
+  }
+};
+
+// src/infrastructure/filesystem/chokidar-watch-service.ts
+var ChokidarWatchService = class {
+  async start(options = {}) {
+    await startWatch({
+      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;
+  async remember(input) {
+    const embedding = await this.embeddingProvider.embed(input.content);
+    return this.memoryRepository.upsert({ ...input, embedding });
+  }
+  async rememberForce(input) {
+    const embedding = await this.embeddingProvider.embed(input.content);
+    await this.memoryRepository.save({ ...input, embedding });
+  }
+  async list(filters = {}) {
+    return this.memoryRepository.list(filters);
+  }
+  async getById(id) {
+    return this.memoryRepository.getById(id);
+  }
+  async removeById(id) {
+    return this.memoryRepository.removeById(id);
+  }
+  async removeMany(filters) {
+    return this.memoryRepository.removeMany(filters);
+  }
+  async update(id, patch) {
+    const current = await this.memoryRepository.getById(id);
+    if (!current) return null;
+    const content = patch.content ?? current.content;
+    const embedding = content !== current.content ? await this.embeddingProvider.embed(content) : void 0;
+    return this.memoryRepository.update(id, { ...patch, embedding });
+  }
+  async search(query, architectures, limit = 10) {
+    const embedding = await this.embeddingProvider.embed(query);
+    return this.memoryRepository.searchByEmbedding({ embedding, architectures, limit });
+  }
+};
+
+// src/modules/retrieval-engine/application/retrieval-engine-service.ts
+var RetrievalEngineService = class {
+  constructor(embeddingProvider, memoryRepository) {
+    this.embeddingProvider = embeddingProvider;
+    this.memoryRepository = memoryRepository;
+  }
+  embeddingProvider;
+  memoryRepository;
+  async retrieve(query) {
+    const limit = query.limit ?? 10;
+    const embedding = await this.embeddingProvider.embed(query.text);
+    const vectorMatches = await this.memoryRepository.searchByEmbedding({
+      embedding,
+      architectures: query.architectures,
+      limit
+    });
+    const lexicalMatches = (await this.memoryRepository.list({
+      architecture: query.architectures,
+      includeGlobal: true,
+      limit: Math.max(limit * 2, 20)
+    })).filter((memory) => {
+      const haystack = `${memory.content} ${memory.title ?? ""} ${(memory.tags ?? []).join(" ")}`.toLowerCase();
+      return haystack.includes(query.text.toLowerCase());
+    });
+    const merged = [...vectorMatches];
+    for (const memory of lexicalMatches) {
+      if (!merged.some((candidate) => candidate.id === memory.id)) {
+        merged.push(memory);
+      }
+    }
+    return { items: merged.slice(0, limit) };
+  }
+};
+
+// src/modules/rule-engine/application/rule-engine-service.ts
+var RuleEngineService = class {
+  constructor(rules, llmProvider) {
+    this.rules = rules;
+    this.llmProvider = llmProvider;
+  }
+  rules;
+  llmProvider;
+  async evaluate(input, includeExplanation = false) {
+    const allViolations = [];
+    for (const rule of this.rules) {
+      allViolations.push(...await rule.evaluate(input));
+    }
+    if (!includeExplanation || allViolations.length === 0 || !this.llmProvider) {
+      return { violations: allViolations };
+    }
+    const explanation = await this.llmProvider.generateText([
+      {
+        role: "system",
+        content: "Summarize architecture violations and provide practical fixes in concise bullet points."
+      },
+      {
+        role: "user",
+        content: JSON.stringify(allViolations, null, 2)
+      }
+    ]);
+    return { violations: allViolations, explanation };
+  }
+};
+
+// 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
+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_EXTENSIONS2.has(extension);
+}
+function asPosix4(value) {
+  return value.replace(/\\/g, "/");
+}
+function normalizeNode(pathValue) {
+  return asPosix4(pathValue);
+}
+function edgeKey(edge) {
+  return `${edge.from}\0${edge.to}\0${edge.kind}`;
+}
+function generateSnapshotId() {
+  const suffix = Math.random().toString(36).slice(2, 8);
+  return `snapshot-${Date.now()}-${suffix}`;
+}
+function toGraph(snapshot) {
+  return {
+    id: snapshot.id,
+    createdAt: snapshot.createdAt,
+    rootPath: snapshot.rootPath,
+    nodes: snapshot.nodes,
+    edges: snapshot.edges
+  };
+}
+var GraphEngineService = class {
+  constructor(graphRepository) {
+    this.graphRepository = graphRepository;
+  }
+  graphRepository;
+  async buildGraph(options = {}) {
+    const cwd = resolve2(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 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)));
+        } else if (imp.isExternal) {
+          toNode = `pkg:${imp.specifier}`;
+        }
+        if (!toNode) continue;
+        nodes.add(toNode);
+        const edge = {
+          from: fromNode,
+          to: toNode,
+          kind: imp.kind === "export-from" ? "import" : imp.kind
+        };
+        edges.set(edgeKey(edge), edge);
+      }
+    }
+    return {
+      rootPath: cwd,
+      nodes: [...nodes].sort(),
+      edges: [...edges.values()].sort(
+        (a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.kind.localeCompare(b.kind)
+      )
+    };
+  }
+  async buildAndStoreSnapshot(options = {}) {
+    const graph = await this.buildGraph(options);
+    const snapshot = {
+      ...graph,
+      id: generateSnapshotId(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.storeSnapshot(snapshot);
+    return { snapshot };
+  }
+  async storeSnapshot(graph) {
+    const snapshotId = graph.id ?? generateSnapshotId();
+    const createdAt = graph.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    await this.graphRepository.saveSnapshot({
+      id: snapshotId,
+      createdAt,
+      rootPath: graph.rootPath,
+      nodes: graph.nodes,
+      edges: graph.edges
+    });
+  }
+  async latest(rootPath) {
+    const snapshot = await this.graphRepository.latestSnapshot(rootPath);
+    return snapshot ? toGraph(snapshot) : null;
+  }
+  async getSnapshot(rootPath, snapshotId) {
+    const snapshot = await this.graphRepository.getSnapshot(rootPath, snapshotId);
+    return snapshot ? toGraph(snapshot) : null;
+  }
+  async listSnapshots(rootPath, limit = 20) {
+    const snapshots = await this.graphRepository.listSnapshots(rootPath, limit);
+    return snapshots.map(toGraph);
+  }
+  diffGraphs(left, right) {
+    const leftNodes = new Set(left.nodes);
+    const rightNodes = new Set(right.nodes);
+    const leftEdges = new Map(left.edges.map((edge) => [edgeKey(edge), edge]));
+    const rightEdges = new Map(right.edges.map((edge) => [edgeKey(edge), edge]));
+    const addedNodes = right.nodes.filter((node) => !leftNodes.has(node));
+    const removedNodes = left.nodes.filter((node) => !rightNodes.has(node));
+    const addedEdges = right.edges.filter((edge) => !leftEdges.has(edgeKey(edge)));
+    const removedEdges = left.edges.filter((edge) => !rightEdges.has(edgeKey(edge)));
+    return { addedNodes, removedNodes, addedEdges, removedEdges };
+  }
+  collectSourceFiles(cwd) {
+    const files = [];
+    const walk = (dir) => {
+      for (const entry of readdirSync(dir)) {
+        if (IGNORED_DIRS.has(entry)) continue;
+        const absolutePath = join5(dir, entry);
+        const stat = statSync(absolutePath);
+        if (stat.isDirectory()) {
+          walk(absolutePath);
+          continue;
+        }
+        const rel = asPosix4(relative(cwd, absolutePath));
+        if (isSourceFile(rel)) files.push(rel);
+      }
+    };
+    walk(cwd);
+    return files;
+  }
+};
+
+// src/modules/agent-engine/application/agent-engine-service.ts
+var AgentEngineService = class {
+  constructor(eventBus) {
+    this.eventBus = eventBus;
+  }
+  eventBus;
+  async dispatch(task) {
+    await this.eventBus.publish({
+      type: "agent.task.dispatched",
+      occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: task
+    });
+  }
+};
+
+// src/app/build-application-container.ts
+function buildApplicationContainer(cwd = process.cwd()) {
+  const embeddingProvider = new OllamaEmbeddingProvider();
+  const llmProvider = new ChatLlmProvider();
+  const memoryRepository = new PostgresMemoryRepository();
+  const fileGraphRepository = new FileGraphRepository(cwd);
+  const graphRepository = Config.databaseUrl ? new ResilientGraphRepository(new PostgresGraphRepository(), fileGraphRepository) : fileGraphRepository;
+  const eventBus = new InMemoryEventBus();
+  const watchService = new ChokidarWatchService();
+  const memoryEngine = new MemoryEngineService(memoryRepository, embeddingProvider);
+  const retrievalEngine = new RetrievalEngineService(embeddingProvider, memoryRepository);
+  const ruleEngine = new RuleEngineService([], llmProvider);
+  const graphEngine = new GraphEngineService(graphRepository);
+  const agentEngine = new AgentEngineService(eventBus);
+  return {
+    providers: {
+      embeddingProvider,
+      llmProvider,
+      memoryRepository,
+      graphRepository,
+      eventBus,
+      watchService
+    },
+    services: {
+      memoryEngine,
+      retrievalEngine,
+      ruleEngine,
+      graphEngine,
+      agentEngine
+    }
+  };
+}
+
+// src/app/index.ts
+var defaultContainer;
+function getDefaultApplicationContainer() {
+  if (!defaultContainer) {
+    defaultContainer = buildApplicationContainer(process.cwd());
+  }
+  return defaultContainer;
+}
+
+// src/memory-selection.ts
+var FRAMEWORK_ARCHITECTURE_MAP = {
+  Laravel: ["laravel-service-repository"],
+  "Next.js": ["nextjs"],
+  "Nuxt.js": ["nuxt"],
+  Go: ["go-api"],
+  NestJS: ["nestjs"],
+  React: ["react"],
+  "Vue.js": ["vue"],
+  Svelte: ["svelte"]
+};
+var KNOWN_ARCHITECTURE_KEYS = /* @__PURE__ */ new Set([
+  ...Object.values(FRAMEWORK_ARCHITECTURE_MAP).flat(),
+  "angular",
+  "clean-architecture",
+  "express",
+  "fastify",
+  "hexagonal",
+  "modular-monolith",
+  "mvc",
+  "react-native"
+]);
+function normalizeText(value) {
+  return value.toLowerCase().replace(/[`"'()[\]{}.,:;!?/\\<>|=*+-]/g, " ").replace(/\s+/g, " ").trim();
+}
+function tokenSet(value) {
+  return new Set(
+    normalizeText(value).split(" ").filter((token) => token.length > 2)
+  );
+}
+function similarityScore(a, b) {
+  const left = tokenSet(a);
+  const right = tokenSet(b);
+  if (left.size === 0 || right.size === 0) return 0;
+  let intersection = 0;
+  for (const token of left) {
+    if (right.has(token)) intersection++;
+  }
+  return 2 * intersection / (left.size + right.size);
+}
+function mergeMemory(primary, secondary) {
+  const mergedTags = [.../* @__PURE__ */ new Set([...primary.tags ?? [], ...secondary.tags ?? []])];
+  const reason = [primary.reason, secondary.reason].filter(Boolean).join(" | ") || void 0;
+  return {
+    ...primary,
+    tags: mergedTags,
+    reason
+  };
+}
+function memoryArchitectureKeys(memory) {
+  if (memory.architecture && memory.architecture !== "global") {
+    return [memory.architecture];
+  }
+  return (memory.tags ?? []).filter((tag) => KNOWN_ARCHITECTURE_KEYS.has(tag));
+}
+function getStackReason(memory, activeArchitectures2) {
+  const architectureKeys = memoryArchitectureKeys(memory);
+  if (architectureKeys.length === 0) {
+    return {
+      included: true,
+      reason: "global memory: no architecture-specific tag"
+    };
+  }
+  const matched = architectureKeys.filter((architecture) => activeArchitectures2.has(architecture));
+  if (matched.length > 0) {
+    return {
+      included: true,
+      reason: `matched active architecture: ${matched.join(", ")}`
+    };
+  }
+  const active = [...activeArchitectures2].join(", ") || "none detected";
+  return {
+    included: false,
+    reason: `excluded: tagged for ${architectureKeys.join(", ")}; active stack is ${active}`
+  };
+}
+function inferProjectArchitectures(cwd = process.cwd(), config2) {
+  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) {
+    inferred.add("clean-architecture");
+  }
+  const detected = detectProject(cwd);
+  for (const architecture of FRAMEWORK_ARCHITECTURE_MAP[detected.framework] ?? []) {
+    inferred.add(architecture);
+  }
+  return [...inferred];
+}
+function getAllowPatterns(config2) {
+  return [...new Set(config2?.allowPatterns?.filter(Boolean) ?? [])];
+}
+function filterRelevantMemories(memories, config2, cwd = process.cwd()) {
+  return explainMemorySelection(memories, config2, cwd).included;
+}
+function explainMemorySelection(memories, config2, cwd = process.cwd(), threshold = 0.8) {
+  const activeArchitectures2 = inferProjectArchitectures(cwd, config2);
+  const activeSet = new Set(activeArchitectures2);
+  const included = [];
+  const decisions = [];
+  for (const memory of memories) {
+    const stackDecision = getStackReason(memory, activeSet);
+    if (!stackDecision.included) {
+      decisions.push({
+        memory,
+        status: "excluded",
+        reason: stackDecision.reason
+      });
+      continue;
+    }
+    const existingIndex = included.findIndex((candidate) => {
+      if (candidate.content_hash && memory.content_hash && candidate.content_hash === memory.content_hash) {
+        return true;
+      }
+      return similarityScore(candidate.content, memory.content) >= threshold;
+    });
+    if (existingIndex === -1) {
+      included.push(memory);
+      decisions.push({
+        memory,
+        status: "included",
+        reason: stackDecision.reason
+      });
+      continue;
+    }
+    included[existingIndex] = mergeMemory(included[existingIndex], memory);
+    decisions.push({
+      memory,
+      status: "excluded",
+      reason: `duplicate or near-duplicate of memory #${included[existingIndex].id}`
+    });
+  }
+  return {
+    included,
+    excluded: decisions.filter((decision) => decision.status === "excluded"),
+    decisions,
+    activeArchitectures: activeArchitectures2
+  };
+}
+function buildContextQuery(parts, maxLength = 1200) {
+  return parts.filter(Boolean).join("\n").slice(0, maxLength);
+}
+async function retrieveContextualMemories(options) {
+  return (await retrieveMemorySelection(options)).included;
+}
+async function retrieveMemorySelection(options) {
+  const architectures = inferProjectArchitectures(options.cwd, options.config);
+  const retrievalEngine = options.retrievalEngine ?? getDefaultApplicationContainer().services.retrievalEngine;
+  const result = await retrievalEngine.retrieve({
+    text: options.query,
+    architectures,
+    limit: options.limit ?? 15
+  });
+  const memories = result.items.map((memory) => ({
+    id: memory.id,
+    type: memory.type,
+    scope: memory.scope,
+    architecture: memory.architecture,
+    project_name: memory.projectName,
+    title: memory.title,
+    content: memory.content,
+    reason: memory.reason,
+    context: memory.context,
+    tags: memory.tags ?? [],
+    content_hash: memory.contentHash,
+    similarity: memory.similarity
+  }));
+  return explainMemorySelection(memories, options.config, options.cwd);
+}
+
+// src/generator.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname3(__filename);
+var PKG_ROOT = join6(__dirname, "..");
+var OUTPUT_FILES = [
+  { template: "CLAUDE.md.hbs", path: "CLAUDE.md", agent: "Claude Code" },
+  { template: "copilot-instructions.md.hbs", path: ".github/copilot-instructions.md", agent: "GitHub Copilot" },
+  { template: "cursorrules.hbs", path: ".cursorrules", agent: "Cursor" },
+  { template: "cursor-rule.mdc.hbs", path: ".cursor/rules/memory-core.mdc", agent: "Cursor" },
+  { template: "windsurfrules.hbs", path: ".windsurfrules", agent: "Windsurf" },
+  { template: "clinerules.hbs", path: ".clinerules", agent: "Cline" },
+  { template: "roo-rule.md.hbs", path: ".roo/rules/memory-core.md", agent: "Roo Code" },
+  { template: "aider.conf.yml.hbs", path: ".aider.conf.yml", agent: "Aider" },
+  { template: "continue-config.json.hbs", path: ".continue/config.json", agent: "Continue.dev", skipIfExists: true },
+  { template: "DEVIN.md.hbs", path: "DEVIN.md", agent: "Devin" },
+  { template: "amazonq-guidelines.md.hbs", path: ".amazonq/dev/guidelines.md", agent: "Amazon Q" },
+  { template: "gemini-styleguide.md.hbs", path: ".gemini/styleguide.md", agent: "Gemini Code Assist" },
+  { template: "zed-settings.json.hbs", path: ".zed/settings.json", agent: "Zed AI", skipIfExists: true },
+  { template: "jetbrains-ai.md.hbs", path: ".idea/ai-instructions.md", agent: "JetBrains AI" },
+  { template: "AGENTS.md.hbs", path: "AGENTS.md", agent: "OpenHands" },
+  { template: "AI_RULES.md.hbs", path: "AI_RULES.md", agent: "Shared" },
+  { template: "ARCHITECTURE.md.hbs", path: "ARCHITECTURE.md", agent: "Shared" },
+  { template: "PROJECT_MEMORY.md.hbs", path: "PROJECT_MEMORY.md", agent: "Shared" }
+];
+var AGENT_NAMES = [...new Set(OUTPUT_FILES.map((f) => f.agent))];
+Handlebars.registerHelper(
+  "join",
+  (arr, sep) => Array.isArray(arr) ? arr.join(sep) : ""
+);
+Handlebars.registerHelper(
+  "bullet",
+  (arr) => Array.isArray(arr) ? arr.map((i) => `- ${i}`).join("\n") : ""
+);
+Handlebars.registerHelper(
+  "numbered",
+  (arr) => Array.isArray(arr) ? arr.map((i, idx) => `${idx + 1}. ${i}`).join("\n") : ""
+);
+Handlebars.registerHelper("json", (val) => JSON.stringify(val, null, 2));
+Handlebars.registerHelper("memoryBlock", (memory) => {
+  const meta = [memory.type, memory.architecture].filter(Boolean).join(" \xB7 ");
+  const label = memory.title ? `${memory.title}: ${memory.content}` : memory.content;
+  const lines = [`- [${meta || "memory"}] ${label}`];
+  if (memory.reason) lines.push(`  Why: ${memory.reason}`);
+  if (memory.context?.appliesTo?.length) lines.push(`  Use when: ${memory.context.appliesTo.join("; ")}`);
+  if (memory.context?.avoidWhen?.length) lines.push(`  Avoid when: ${memory.context.avoidWhen.join("; ")}`);
+  if (memory.context?.examples?.length) {
+    lines.push("  Examples:");
+    for (const example of memory.context.examples) lines.push(`    - ${example}`);
+  }
+  if (memory.tags?.length) lines.push(`  Tags: ${memory.tags.join(", ")}`);
+  if (memory.project_name || memory.context?.source) {
+    lines.push(`  Source: ${memory.context?.source ?? memory.project_name}`);
+  }
+  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 yaml.load(readFileSync4(profilePath, "utf-8"));
+}
+function listProfiles(layer) {
+  const files = readdirSync2(join6(PKG_ROOT, "profiles")).filter((f) => f.endsWith(".yml"));
+  const all = files.map((f) => yaml.load(readFileSync4(join6(PKG_ROOT, "profiles", f), "utf-8")));
+  if (!layer) return all;
+  if (layer === "backend") return all.filter((p) => p.layer === "backend" || p.layer === "fullstack");
+  if (layer === "frontend") return all.filter((p) => p.layer === "frontend" || p.layer === "fullstack");
+  return all;
+}
+function buildTemplateData(options, cwd = process.cwd()) {
+  const backend = options.backendArchitecture ? loadProfile(options.backendArchitecture) : null;
+  const frontend = options.frontendFramework ? loadProfile(options.frontendFramework) : null;
+  const dedupedMemories = filterRelevantMemories(options.memories, {
+    projectType: options.projectType,
+    backendArchitecture: options.backendArchitecture,
+    frontendFramework: options.frontendFramework,
+    language: options.language
+  }, cwd);
+  const allRules = [
+    ...backend?.rules ?? [],
+    ...frontend?.rules ?? []
+  ];
+  const allFolders = [
+    ...backend?.folders ?? [],
+    ...frontend?.folders ?? []
+  ];
+  const allAvoid = [
+    ...backend?.avoid ?? [],
+    ...frontend?.avoid ?? []
+  ];
+  const archLabel = [
+    backend ? `Backend: ${backend.displayName}` : null,
+    frontend ? `Frontend: ${frontend.displayName}` : null
+  ].filter(Boolean).join(" \xB7 ");
   return {
-    provider,
-    model,
-    ollamaUrl: process.env.OLLAMA_URL ?? "http://localhost:11434",
-    apiKey: process.env.CHAT_API_KEY ?? ""
+    projectName: options.projectName,
+    projectType: options.projectType,
+    isBackend: options.projectType === "backend" || options.projectType === "fullstack",
+    isFrontend: options.projectType === "frontend" || options.projectType === "fullstack",
+    isFullstack: options.projectType === "fullstack",
+    // backend
+    hasBackend: !!backend,
+    backendArchitecture: backend?.displayName,
+    backendDescription: backend?.description,
+    backendRules: backend?.rules ?? [],
+    backendFolders: backend?.folders ?? [],
+    backendAvoid: backend?.avoid ?? [],
+    // frontend
+    hasFrontend: !!frontend,
+    frontendFramework: frontend?.displayName,
+    frontendDescription: frontend?.description,
+    frontendRules: frontend?.rules ?? [],
+    frontendFolders: frontend?.folders ?? [],
+    frontendAvoid: frontend?.avoid ?? [],
+    // combined — used by simple templates
+    architecture: archLabel,
+    rules: allRules,
+    folders: allFolders,
+    avoid: allAvoid,
+    description: [backend?.description, frontend?.description].filter(Boolean).join(" | "),
+    // memories
+    memories: dedupedMemories,
+    hasMemories: dedupedMemories.length > 0,
+    // misc
+    language: options.language,
+    caveman: options.caveman,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
   };
 }
-async function callOllama(cfg, messages) {
-  const res = await fetch(`${cfg.ollamaUrl}/api/chat`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ model: cfg.model, messages, stream: false, format: "json" })
-  });
-  if (!res.ok) {
-    const body = await res.text();
-    if (body.includes("not found") || body.includes("model")) {
-      throw new Error(`MODEL_NOT_FOUND:${cfg.model}`);
+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);
+}
+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 (existing === content) return "skipped";
+  }
+  writeFileSync2(filePath, content, "utf-8");
+  return "written";
+}
+async function generate(options, cwd = process.cwd(), onlyAgents) {
+  const data = buildTemplateData(options, cwd);
+  const written = [];
+  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)) {
+      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;
     }
-    throw new Error(body);
   }
-  const data = await res.json();
-  return data.message.content.trim();
+  return { written, skipped };
 }
-async function callOpenAI(cfg, messages) {
-  const res = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${cfg.apiKey}`
-    },
-    body: JSON.stringify({
-      model: cfg.model,
-      messages,
-      response_format: { type: "json_object" }
-    })
-  });
-  if (!res.ok) throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
-  const data = await res.json();
-  return data.choices[0].message.content.trim();
+
+// src/modules/rule-engine/infrastructure/ast-deterministic-violations.ts
+import { resolve as resolve3 } from "path";
+function asPosix5(value) {
+  return value.replace(/\\/g, "/");
 }
-async function callAnthropic(cfg, messages) {
-  const system = messages.find((m) => m.role === "system")?.content ?? "";
-  const userMessages = messages.filter((m) => m.role !== "system");
-  const res = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": cfg.apiKey,
-      "anthropic-version": "2023-06-01"
-    },
-    body: JSON.stringify({
-      model: cfg.model,
-      max_tokens: 4096,
-      system,
-      messages: userMessages
-    })
-  });
-  if (!res.ok) throw new Error(`Anthropic API error ${res.status}: ${await res.text()}`);
-  const data = await res.json();
-  return data.content[0].text.trim();
+function hasPath(value, pathSegment) {
+  const normalized = asPosix5(value);
+  const trimmed = pathSegment.startsWith("/") ? pathSegment.slice(1) : pathSegment;
+  return normalized.includes(pathSegment) || normalized.includes(trimmed);
 }
-async function callMiniMax(cfg, messages) {
-  const res = await fetch("https://api.minimax.io/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${cfg.apiKey}`
-    },
-    body: JSON.stringify({
-      model: cfg.model,
-      messages,
-      response_format: { type: "json_object" }
-    })
-  });
-  if (!res.ok) throw new Error(`MiniMax API error ${res.status}: ${await res.text()}`);
-  const data = await res.json();
-  return data.choices[0].message.content.trim();
+function isLegacyOrCompatibilitySpecifier(specifier) {
+  const normalized = asPosix5(specifier);
+  return normalized.includes("/compatibility/") || normalized.includes("compatibility/") || normalized.includes("legacy-");
 }
-async function callChatModel(messages) {
-  const cfg = getChatConfig();
-  switch (cfg.provider) {
-    case "openai":
-      return callOpenAI(cfg, messages);
-    case "anthropic":
-      return callAnthropic(cfg, messages);
-    case "minimax":
-      return callMiniMax(cfg, messages);
-    default:
-      return callOllama(cfg, messages);
+function 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 getChatProviderLabel() {
-  const cfg = getChatConfig();
-  if (cfg.provider === "ollama") return `ollama (${cfg.model})`;
-  return `${cfg.provider} (${cfg.model})`;
+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)
+        });
+      }
+    }
+  }
+  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
-import { watch } from "chokidar";
-import { spawnSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3, relative } from "path";
-import chalk from "chalk";
 function getFileLines(filePath) {
   try {
-    return readFileSync3(filePath, "utf-8").split("\n");
+    return readFileSync5(filePath, "utf-8").split("\n");
   } catch {
     return [];
   }
@@ -937,16 +2280,16 @@ function formatCodeContext(filePath, line, contextLines = 2) {
     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 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 recordViolations(violations) {
-  const statsPath = join3(process.cwd(), ".memory-core-stats.json");
+  const statsPath = join7(process.cwd(), ".memory-core-stats.json");
   let stats = { rules: {}, files: {} };
-  if (existsSync3(statsPath)) {
+  if (existsSync6(statsPath)) {
     try {
-      stats = JSON.parse(readFileSync3(statsPath, "utf-8"));
+      stats = JSON.parse(readFileSync5(statsPath, "utf-8"));
     } catch {
       stats = { rules: {}, files: {} };
     }
@@ -960,29 +2303,29 @@ function recordViolations(violations) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const recent = violations.map((violation) => ({ ...violation, timestamp, source: "watch" }));
   stats.recentViolations = [...recent, ...stats.recentViolations ?? []].slice(0, 50);
-  writeFileSync2(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+  writeFileSync3(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
 }
 function loadConfig(cwd) {
-  const configPath = join3(cwd, ".memory-core.json");
-  if (!existsSync3(configPath)) return null;
+  const configPath = join7(cwd, ".memory-core.json");
+  if (!existsSync6(configPath)) return null;
   try {
-    return JSON.parse(readFileSync3(configPath, "utf-8"));
+    return JSON.parse(readFileSync5(configPath, "utf-8"));
   } catch {
     return null;
   }
 }
-function getProfileRules(config) {
+function getProfileRules(config2) {
   const rules = [];
   const avoids = [];
-  if (config.backendArchitecture) {
-    const profile = listProfiles("backend").find((p) => p.name === config.backendArchitecture);
+  if (config2.backendArchitecture) {
+    const profile = listProfiles("backend").find((p) => p.name === config2.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 (config2.frontendFramework) {
+    const profile = listProfiles("frontend").find((p) => p.name === config2.frontendFramework);
     if (profile) {
       rules.push(...profile.rules);
       avoids.push(...profile.avoid);
@@ -990,19 +2333,19 @@ function getProfileRules(config) {
   }
   return { rules, avoids };
 }
-async function loadRelevantRules(config, rel, diff, fallbackRules) {
+async function loadRelevantRules(config2, rel, diff, fallbackRules) {
   try {
     const query = buildContextQuery([
       rel,
       diff.slice(0, 1200),
-      config.backendArchitecture,
-      config.frontendFramework,
-      config.language
+      config2.backendArchitecture,
+      config2.frontendFramework,
+      config2.language
     ]);
     const memories = await retrieveContextualMemories({
       query,
       cwd: process.cwd(),
-      config,
+      config: config2,
       limit: 15
     });
     const selected = memories.filter((memory) => ["rule", "pattern", "decision"].includes(memory.type)).map((memory) => memory.content);
@@ -1057,16 +2400,15 @@ ${JSON.stringify(violations, null, 2)}`;
 }
 async function loadIgnorePatterns() {
   try {
-    const { listMemories, closePool } = await import("./db-MF3VKVKH.js");
-    const ignores = await listMemories({ type: "ignore", limit: 1e3 });
-    await closePool();
+    const app = getDefaultApplicationContainer();
+    const ignores = await app.services.memoryEngine.list({ type: "ignore", limit: 1e3 });
     return ignores.map((ignore) => ignore.content);
   } catch {
     return [];
   }
 }
-async function checkFile(filePath, cwd, config, verbose, debug) {
-  const rel = relative(cwd, filePath);
+async function checkFile(filePath, cwd, config2, verbose, debug) {
+  const rel = relative2(cwd, filePath);
   let diff;
   const headResult = spawnSync("git", ["diff", "HEAD", "--", rel], { encoding: "utf-8", cwd });
   if (headResult.stdout?.trim()) {
@@ -1076,8 +2418,8 @@ async function checkFile(filePath, cwd, config, verbose, debug) {
     diff = noIndexResult.stdout ?? "";
   }
   if (!diff.trim()) return { type: "skipped", reason: "No changes compared with HEAD" };
-  const { rules: fallbackRules, avoids } = getProfileRules(config);
-  const rules = await loadRelevantRules(config, rel, diff, fallbackRules);
+  const { rules: fallbackRules, avoids } = getProfileRules(config2);
+  const rules = await loadRelevantRules(config2, rel, diff, fallbackRules);
   if (rules.length === 0) return { type: "skipped", reason: "No applicable architecture rules" };
   const MAX_DIFF = 6e3;
   const truncated = diff.length > MAX_DIFF;
@@ -1091,7 +2433,16 @@ async function checkFile(filePath, cwd, config, verbose, debug) {
     return why ? `${i + 1}. ${r}
    WHY: ${why}` : `${i + 1}. ${r}`;
   }).join("\n");
-  const allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config), ...await loadIgnorePatterns()])];
+  const allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config2), ...await loadIgnorePatterns()])];
+  const astViolations = findAstDeterministicViolationsForFile(rel, {
+    cwd,
+    config: config2,
+    rules,
+    reasonLookup: reasonMap
+  }).map((violation) => ({
+    ...violation,
+    severity: "error"
+  }));
   const systemPrompt = `You are a strict code reviewer enforcing architecture rules.
 Analyze the file diff and identify ONLY clear, definite rule violations.
 Use the WHY for each rule to understand intent and judge edge cases.
@@ -1143,6 +2494,7 @@ ${diffToSend}` }
       violations = [];
     }
     violations = await verifyViolations(diff, violations, allowPatterns, debug);
+    violations = [...astViolations, ...violations];
     violations = applyAllowPatterns(violations, allowPatterns);
     violations = violations.map((violation) => ({
       ...violation,
@@ -1163,7 +2515,7 @@ ${diffToSend}` }
       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 && existsSync3(filePath)) {
+      if (v.line && existsSync6(filePath)) {
         printCodeContext(filePath, v.line, 1);
       }
       if (v.issue) console.log(chalk.red("      Issue:  ") + v.issue);
@@ -1175,20 +2527,47 @@ ${diffToSend}` }
     console.log();
     return { type: "checked", violations };
   } catch (err) {
-    if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
-      return { type: "error", message: `Check model unreachable for ${rel}: ${err.message}` };
-    }
-    if (verbose) {
-      console.log(chalk.yellow(`  \u26A0  Check failed for ${rel}: ${err.message}`));
+    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) {
+      console.log(chalk.green(`  \u2713 ${rel}`) + chalk.dim(" \u2014 no deterministic violations"));
+      return { type: "checked", violations: [] };
     }
-    return { type: "error", message: `Check failed for ${rel}: ${err.message}` };
+    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 && 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();
+    });
+    recordViolations(violations);
+    console.log(chalk.dim('  Fix violations or run: memory-core remember "<lesson>"'));
+    console.log();
+    return { type: "checked", violations };
   }
 }
 async function startWatch(options = {}) {
   const cwd = process.cwd();
-  const config = loadConfig(cwd);
+  const config2 = loadConfig(cwd);
   const exitOnSetupFailure = options.exitOnSetupFailure ?? true;
-  if (!config) {
+  if (!config2) {
     const message = "No .memory-core.json found. Run: memory-core init";
     console.error(chalk.red(`
   ${message}
@@ -1197,7 +2576,7 @@ async function startWatch(options = {}) {
     if (exitOnSetupFailure) process.exit(1);
     return;
   }
-  const { rules } = getProfileRules(config);
+  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(`
@@ -1237,16 +2616,16 @@ async function startWatch(options = {}) {
   const keepAlive = setInterval(() => {
   }, 1 << 30);
   const handle = (filePath) => {
-    if (!SOURCE_EXTENSIONS.test(filePath)) return;
+    if (!SOURCE_EXTENSIONS3.test(filePath)) return;
     if (pending.has(filePath)) clearTimeout(pending.get(filePath));
     const timer = setTimeout(async () => {
       pending.delete(filePath);
-      const rel = relative(cwd, filePath);
+      const rel = relative2(cwd, filePath);
       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, cwd, config, options.verbose ?? false, options.debug ?? false);
+      const result = await checkFile(filePath, cwd, config2, options.verbose ?? false, options.debug ?? false);
       if (result.type === "skipped") {
         options.onEvent?.({ type: "skipped", timestamp: (/* @__PURE__ */ new Date()).toISOString(), file: rel, reason: result.reason });
         return;
@@ -1282,8 +2661,23 @@ async function startWatch(options = {}) {
 
 export {
   detectProject,
-  retrieve,
-  dedupeMemories,
+  Config,
+  embed,
+  callChatModel,
+  getChatProviderLabel,
+  getPool,
+  runMigrations,
+  saveMemory,
+  listMemories,
+  deleteMemory,
+  updateMemory,
+  closePool,
+  migrateGraphSnapshots,
+  probeGraphSnapshotStore,
+  seeds,
+  findAstDeterministicViolationsForDiff,
+  startWatch,
+  getDefaultApplicationContainer,
   inferProjectArchitectures,
   getAllowPatterns,
   buildContextQuery,
@@ -1292,9 +2686,5 @@ export {
   OUTPUT_FILES,
   AGENT_NAMES,
   listProfiles,
-  generate,
-  seeds,
-  callChatModel,
-  getChatProviderLabel,
-  startWatch
+  generate
 };