@shahmilsaari/memory-core 0.2.13 → 0.2.15

package/dist/cli.js

@@ -7,13 +7,14 @@ import {
   deleteMemories,
   deleteMemory,
   getMemory,
+  getPool,
   listMemories,
   runMigrations,
   saveMemory,
   searchMemories,
   updateMemory,
   upsertMemory
-} from "./chunk-25Y2KI7M.js";
+} from "./chunk-DUUQHRIB.js";
 import "./chunk-KSLFLWB4.js";
 
 // src/cli.ts
@@ -24,7 +25,6 @@ import ora from "ora";
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync2, appendFileSync, rmSync, unlinkSync as unlinkSync2 } from "fs";
 import { join as join6, dirname as dirname2 } from "path";
 import { homedir } from "os";
-import { execSync as execSync2 } from "child_process";
 
 // src/generator.ts
 import { readFileSync as readFileSync2, readdirSync, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
@@ -112,6 +112,17 @@ var FRAMEWORK_ARCHITECTURE_MAP = {
   "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();
 }
@@ -139,6 +150,33 @@ function mergeMemory(primary, secondary) {
     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, 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(", ")}`
+    };
+  }
+  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) {
@@ -160,6 +198,9 @@ 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);
@@ -169,13 +210,63 @@ function inferProjectArchitectures(cwd = process.cwd(), config) {
 function getAllowPatterns(config) {
   return [...new Set(config?.allowPatterns?.filter(Boolean) ?? [])];
 }
+function filterRelevantMemories(memories, config, cwd = process.cwd()) {
+  return explainMemorySelection(memories, config, cwd).included;
+}
+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;
+    }
+    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
+  };
+}
 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 memories = await retrieve(options.query, architectures, options.limit ?? 15);
-  return dedupeMemories(memories);
+  return explainMemorySelection(memories, options.config, options.cwd);
 }
 
 // src/generator.ts
@@ -229,10 +320,15 @@ function listProfiles(layer) {
   if (layer === "frontend") return all.filter((p) => p.layer === "frontend" || p.layer === "fullstack");
   return all;
 }
-function buildTemplateData(options) {
+function buildTemplateData(options, cwd = process.cwd()) {
   const backend = options.backendArchitecture ? loadProfile(options.backendArchitecture) : null;
   const frontend = options.frontendFramework ? loadProfile(options.frontendFramework) : null;
-  const dedupedMemories = dedupeMemories(options.memories);
+  const dedupedMemories = filterRelevantMemories(options.memories, {
+    projectType: options.projectType,
+    backendArchitecture: options.backendArchitecture,
+    frontendFramework: options.frontendFramework,
+    language: options.language
+  }, cwd);
   const allRules = [
     ...backend?.rules ?? [],
     ...frontend?.rules ?? []
@@ -300,7 +396,7 @@ function writeFile(filePath, content) {
   return "written";
 }
 async function generate(options, cwd = process.cwd(), onlyAgents) {
-  const data = buildTemplateData(options);
+  const data = buildTemplateData(options, cwd);
   const written = [];
   const skipped = [];
   const files = onlyAgents ? OUTPUT_FILES.filter((f) => onlyAgents.includes(f.agent)) : OUTPUT_FILES;
@@ -711,11 +807,11 @@ import chalk from "chalk";
 
 // 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";
+  const provider2 = process.env.CHAT_PROVIDER ?? "ollama";
+  const model2 = process.env.CHAT_MODEL ?? process.env.OLLAMA_CHAT_MODEL ?? "llama3.2";
   return {
-    provider,
-    model,
+    provider: provider2,
+    model: model2,
     ollamaUrl: process.env.OLLAMA_URL ?? "http://localhost:11434",
     apiKey: process.env.CHAT_API_KEY ?? ""
   };
@@ -922,7 +1018,7 @@ async function promptToSaveViolations(violations) {
       default: selected.reason ?? selected.issue ?? ""
     });
     const { embed: embed2 } = await import("./embedding-PAYD2JYW.js");
-    const { upsertMemory: upsertMemory2 } = await import("./db-5X5LTUCB.js");
+    const { upsertMemory: upsertMemory2 } = await import("./db-VLOR7L6Q.js");
     await upsertMemory2({
       type: "rule",
       scope: "project",
@@ -939,7 +1035,7 @@ async function promptToSaveViolations(violations) {
 }
 async function loadIgnorePatterns() {
   try {
-    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-5X5LTUCB.js");
+    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-VLOR7L6Q.js");
     const ignores = await listMemories2({ type: "ignore", limit: 1e3 });
     await closePool2();
     return ignores.map((ignore) => ignore.content);
@@ -996,6 +1092,124 @@ ${violation.file}`.toLowerCase();
     return !allowPatterns.some((pattern) => haystack.includes(pattern.toLowerCase()));
   });
 }
+function normalizeViolation(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  if (typeof candidate.rule !== "string" || typeof candidate.issue !== "string") return null;
+  return {
+    rule: candidate.rule,
+    file: typeof candidate.file === "string" ? candidate.file : "diff",
+    line: typeof candidate.line === "number" ? candidate.line : void 0,
+    issue: candidate.issue,
+    suggestion: typeof candidate.suggestion === "string" ? candidate.suggestion : void 0,
+    reason: typeof candidate.reason === "string" ? candidate.reason : void 0
+  };
+}
+function parseModelViolations(raw) {
+  const candidates = [
+    raw,
+    raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "")
+  ];
+  const objectStart = raw.indexOf("{");
+  const objectEnd = raw.lastIndexOf("}");
+  if (objectStart !== -1 && objectEnd > objectStart) {
+    candidates.push(raw.slice(objectStart, objectEnd + 1));
+  }
+  const arrayStart = raw.indexOf("[");
+  const arrayEnd = raw.lastIndexOf("]");
+  if (arrayStart !== -1 && arrayEnd > arrayStart) {
+    candidates.push(raw.slice(arrayStart, arrayEnd + 1));
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      const items = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.violations) ? parsed.violations : parsed?.rule ? [parsed] : null;
+      if (!items) continue;
+      return {
+        valid: true,
+        violations: items.map(normalizeViolation).filter((violation) => violation !== null)
+      };
+    } catch {
+    }
+  }
+  return { valid: false, violations: [] };
+}
+function getAddedLines(diff) {
+  const lines = [];
+  let currentFile = "diff";
+  let newLineNumber = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ b/")) {
+      currentFile = line.slice("+++ b/".length);
+      continue;
+    }
+    const hunk = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunk) {
+      newLineNumber = Number(hunk[1]);
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      lines.push({
+        file: currentFile,
+        line: Number.isFinite(newLineNumber) ? newLineNumber : void 0,
+        content: line.slice(1)
+      });
+      newLineNumber += 1;
+      continue;
+    }
+    if (!line.startsWith("-") && newLineNumber > 0) {
+      newLineNumber += 1;
+    }
+  }
+  return lines;
+}
+function dedupeViolations(violations) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const violation of violations) {
+    const key = [
+      violation.rule,
+      violation.file,
+      violation.line ?? "",
+      violation.issue
+    ].join("\0");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(violation);
+  }
+  return deduped;
+}
+function findDeterministicViolations(diff, rules, avoids, allowPatterns = []) {
+  const rulePhrases = rules.flatMap(
+    (rule) => extractForbiddenPhrases(rule).map((phrase) => ({ rule, phrase }))
+  );
+  const avoidPhrases = avoids.map((avoid) => ({
+    rule: `Avoid: ${avoid}`,
+    phrase: avoid.toLowerCase()
+  }));
+  const phrases = [...rulePhrases, ...avoidPhrases].filter((item) => item.phrase.length > 0);
+  if (phrases.length === 0) return [];
+  const violations = [];
+  for (const addedLine of getAddedLines(diff)) {
+    const normalizedLine = addedLine.content.toLowerCase();
+    if (allowPatterns.some((pattern) => normalizedLine.includes(pattern.toLowerCase()))) {
+      continue;
+    }
+    for (const { rule, phrase } of phrases) {
+      if (normalizedLine.includes(phrase)) {
+        violations.push({
+          rule,
+          file: addedLine.file,
+          line: addedLine.line,
+          issue: `Added line contains forbidden phrase: "${phrase}"`,
+          suggestion: "Remove this pattern or add an explicit ignore memory if it is intentional.",
+          reason: reasonMap.get(rule)
+        });
+      }
+    }
+  }
+  return dedupeViolations(violations);
+}
 async function verifyViolations(diff, violations, allowPatterns, debug) {
   if (violations.length === 0) return violations;
   const systemPrompt = `You are verifying candidate architecture violations.
@@ -1023,9 +1237,8 @@ ${JSON.stringify(violations, null, 2)}`;
       { role: "system", content: systemPrompt },
       { role: "user", content: userPrompt }
     ]);
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed?.violations)) return parsed.violations;
-    if (Array.isArray(parsed)) return parsed;
+    const parsed = parseModelViolations(raw);
+    if (parsed.valid) return parsed.violations;
     return violations;
   } catch {
     return violations;
@@ -1142,7 +1355,8 @@ Do not include any text outside the JSON object.`;
     console.log(chalk.dim(diffToSend));
     console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   }
-  let violations = [];
+  const deterministicViolations = findDeterministicViolations(diff, rules, avoids, allowPatterns);
+  let modelViolations = [];
   try {
     const raw = await callChatModel([
       { role: "system", content: systemPrompt },
@@ -1153,36 +1367,29 @@ ${diffToSend}` }
     if (options.verbose || options.debug) {
       console.log(chalk.gray(`  raw response: ${options.debug ? raw : raw.slice(0, 200)}`));
     }
-    try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) {
-        violations = parsed;
-      } else if (Array.isArray(parsed?.violations)) {
-        violations = parsed.violations;
-      } else if (parsed?.rule) {
-        violations = [parsed];
-      } else {
-        violations = [];
-      }
-    } catch {
-      violations = [];
+    const parsed = parseModelViolations(raw);
+    if (parsed.valid) {
+      modelViolations = parsed.violations;
+    } else {
+      console.log(chalk.yellow("  \u26A0  AI returned invalid JSON \u2014 using deterministic checks only."));
     }
   } catch (err) {
     if (err.message?.startsWith("MODEL_NOT_FOUND:")) {
       printModelMissing(err.message.split(":")[1]);
-      return;
-    }
-    if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
-      console.log(chalk.yellow("\n  \u26A0  Ollama not running \u2014 skipping rule check."));
+      modelViolations = [];
+    } else if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
+      console.log(chalk.yellow("\n  \u26A0  Ollama not running \u2014 using deterministic checks only."));
       console.log(chalk.gray("     Start it: ollama serve\n"));
-      return;
+      modelViolations = [];
+    } else {
+      console.log(chalk.yellow(`
+  \u26A0  AI rule check failed: ${err.message}`));
+      console.log(chalk.gray("     Using deterministic checks only.\n"));
+      modelViolations = [];
     }
-    console.log(chalk.yellow(`
-  \u26A0  Rule check failed: ${err.message}
-`));
-    return;
   }
-  violations = await verifyViolations(diff, violations, allowPatterns, options.debug ?? false);
+  modelViolations = await verifyViolations(diff, modelViolations, allowPatterns, options.debug ?? false);
+  let violations = dedupeViolations([...deterministicViolations, ...modelViolations]);
   violations = applyAllowPatterns(violations, allowPatterns);
   if (violations.length === 0) {
     console.log(chalk.green("  \u2713 No rule violations \u2014 commit allowed.\n"));
@@ -1301,10 +1508,10 @@ async function checkCi(options = {}) {
   recordViolations(violations);
   process.exit(1);
 }
-function printModelMissing(model) {
+function printModelMissing(model2) {
   console.log(chalk.yellow(`
-  \u26A0  Chat model "${model}" not found in Ollama.`));
-  console.log(chalk.gray(`     Pull a model: ollama pull ${model}`));
+  \u26A0  Chat model "${model2}" not found in Ollama.`));
+  console.log(chalk.gray(`     Pull a model: ollama pull ${model2}`));
   console.log(chalk.gray("     Or set OLLAMA_CHAT_MODEL=<model> in .env"));
   console.log(chalk.gray("     Recommended: llama3.2  |  qwen2.5-coder:3b  |  mistral\n"));
 }
@@ -1454,7 +1661,7 @@ ${JSON.stringify(violations, null, 2)}`;
 }
 async function loadIgnorePatterns2() {
   try {
-    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-5X5LTUCB.js");
+    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-VLOR7L6Q.js");
     const ignores = await listMemories2({ type: "ignore", limit: 1e3 });
     await closePool2();
     return ignores.map((ignore) => ignore.content);
@@ -1633,6 +1840,55 @@ async function startWatch(options = {}) {
   });
 }
 
+// src/remote-install.ts
+import { spawnSync as spawnSync3 } from "child_process";
+var CAVEMAN_INSTALL_URL = "https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh";
+var MAX_INSTALLER_BYTES = 2e5;
+var TRUSTED_INSTALL_HOSTS = /* @__PURE__ */ new Set(["raw.githubusercontent.com"]);
+function assertTrustedInstallerUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:") {
+    throw new Error("Remote installer URL must use HTTPS");
+  }
+  if (!TRUSTED_INSTALL_HOSTS.has(parsed.hostname)) {
+    throw new Error(`Remote installer host is not trusted: ${parsed.hostname}`);
+  }
+}
+function defaultRunScript(script) {
+  return spawnSync3("bash", ["-s"], {
+    input: script,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+async function fetchRemoteInstaller(url, fetchImpl = fetch) {
+  assertTrustedInstallerUrl(url);
+  const response = await fetchImpl(url, {
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download installer (${response.status})`);
+  }
+  const script = await response.text();
+  if (script.length > MAX_INSTALLER_BYTES) {
+    throw new Error(`Installer is too large (${script.length} bytes)`);
+  }
+  if (script.includes("\0")) {
+    throw new Error("Installer contains null bytes");
+  }
+  return script;
+}
+async function installCavemanTokenSaver(options = {}) {
+  const url = options.url ?? CAVEMAN_INSTALL_URL;
+  const script = await fetchRemoteInstaller(url, options.fetchImpl ?? fetch);
+  const result = (options.runScript ?? defaultRunScript)(script);
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const stderr = result.stderr ? String(result.stderr).trim() : "";
+    throw new Error(stderr || `Installer exited with status ${result.status}`);
+  }
+}
+
 // src/cli.ts
 function printBanner(projectName, agentCount, status) {
   const pg = status ? status.postgresOk ? chalk3.green("  \u2713 PostgreSQL ") + chalk3.bold("connected") : chalk3.red("  \u2717 PostgreSQL ") + chalk3.bold("not connected \u2014 check DATABASE_URL") : chalk3.green("  \u2713 Memory    ") + chalk3.bold("PostgreSQL + pgvector ready");
@@ -1697,6 +1953,156 @@ async function checkConnections(dbUrl, ollamaUrl, chatModel) {
 }
 var { version } = JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf-8"));
 var CONFIG_FILE = ".memory-core.json";
+var LOCAL_GENERATED_FILES = [".memory-core-stats.json"];
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
+var DEFAULT_CHAT_MODEL = "llama3.2";
+function getEnvPath() {
+  const memoryEnv = join6(process.cwd(), ".memory-core.env");
+  if (existsSync6(memoryEnv)) return memoryEnv;
+  const dotEnv = join6(process.cwd(), ".env");
+  return existsSync6(dotEnv) ? dotEnv : memoryEnv;
+}
+function parseEnvFile(raw) {
+  const lines = raw.split(/\r?\n/);
+  const values = {};
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const separatorIndex = trimmed.indexOf("=");
+    if (separatorIndex === -1) continue;
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const value = trimmed.slice(separatorIndex + 1).trim();
+    if (key) values[key] = value;
+  }
+  return values;
+}
+function readRuntimeEnv() {
+  const envPath = getEnvPath();
+  const fileValues = existsSync6(envPath) ? parseEnvFile(readFileSync6(envPath, "utf-8")) : {};
+  const values = {
+    ...fileValues
+  };
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string" && value !== "") values[key] = value;
+  }
+  return { envPath, values };
+}
+function writeRuntimeEnv(values, envPath = getEnvPath()) {
+  const orderedKeys = [
+    "DATABASE_URL",
+    "OLLAMA_URL",
+    "OLLAMA_MODEL",
+    "CHAT_PROVIDER",
+    "CHAT_MODEL",
+    "OLLAMA_CHAT_MODEL",
+    "CHAT_API_KEY"
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const key of orderedKeys) {
+    const value = values[key];
+    if (value) {
+      lines.push(`${key}=${value}`);
+      seen.add(key);
+    }
+  }
+  for (const key of Object.keys(values).sort()) {
+    if (seen.has(key)) continue;
+    const value = values[key];
+    if (value) lines.push(`${key}=${value}`);
+  }
+  writeFileSync5(envPath, `${lines.join("\n")}
+`, "utf-8");
+}
+function applyRuntimeEnv(values) {
+  for (const [key, value] of Object.entries(values)) {
+    process.env[key] = value;
+  }
+}
+function ensureEnvFileIgnored(envPath = getEnvPath()) {
+  const envFileName = envPath.split("/").pop() ?? ".memory-core.env";
+  const gitignorePath = join6(process.cwd(), ".gitignore");
+  const existing = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
+  if (!existing.includes(envFileName)) {
+    appendFileSync(gitignorePath, `${existing ? "\n" : ""}${envFileName}
+`);
+  }
+}
+function appendMissingGitignoreEntries(entries, heading) {
+  const gitignorePath = join6(process.cwd(), ".gitignore");
+  const existing = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
+  const existingEntries = new Set(
+    existing.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  );
+  const toAdd = entries.filter((entry) => !existingEntries.has(entry));
+  if (toAdd.length === 0) {
+    return 0;
+  }
+  const prefix = existing.trim().length > 0 ? "\n" : "";
+  appendFileSync(gitignorePath, `${prefix}${heading}
+${toAdd.join("\n")}
+`);
+  return toAdd.length;
+}
+function normalizeProvider(value) {
+  const provider2 = value.trim().toLowerCase();
+  if (provider2 === "ollama" || provider2 === "openai" || provider2 === "anthropic" || provider2 === "minimax") {
+    return provider2;
+  }
+  throw new Error(`Unsupported provider "${value}". Use: ollama, openai, anthropic, minimax`);
+}
+function providerLabel(provider2) {
+  switch (provider2) {
+    case "openai":
+      return "OpenAI";
+    case "anthropic":
+      return "Anthropic";
+    case "minimax":
+      return "MiniMax";
+    default:
+      return "Ollama";
+  }
+}
+function redactDatabaseUrl(url) {
+  if (!url) return "(not set)";
+  return url.replace(/:\/\/([^:@/]+)(?::[^@/]+)?@/, "://$1:***@");
+}
+function getConfiguredProvider(values) {
+  return normalizeProvider(values.CHAT_PROVIDER ?? "ollama");
+}
+function getConfiguredChatModel(values) {
+  return values.CHAT_MODEL ?? values.OLLAMA_CHAT_MODEL ?? DEFAULT_CHAT_MODEL;
+}
+async function resolveOllamaInstalledModel(ollamaUrl, model2) {
+  const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const data = await res.json();
+  const models = data.models ?? [];
+  const exact = models.find((entry) => entry.name === model2);
+  const prefixed = models.find((entry) => entry.name.startsWith(`${model2}:`));
+  return (exact ?? prefixed)?.name ?? null;
+}
+async function verifyDatabaseConnection(dbUrl) {
+  if (!dbUrl) return "DATABASE_URL is not set";
+  try {
+    const { Pool } = (await import("pg")).default;
+    const testPool = new Pool({ connectionString: dbUrl, connectionTimeoutMillis: 5e3 });
+    await testPool.query("SELECT 1");
+    await testPool.end();
+    return null;
+  } catch (err) {
+    return err.message;
+  }
+}
+async function verifyOllamaConnection(ollamaUrl) {
+  try {
+    const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+    return res.ok ? null : `HTTP ${res.status}`;
+  } catch (err) {
+    return err.message;
+  }
+}
 function readProjectConfig() {
   const path = join6(process.cwd(), CONFIG_FILE);
   if (!existsSync6(path)) return null;
@@ -1744,6 +2150,222 @@ function printMemoryTable(memories, title = "Rules in memory") {
   });
   console.log(chalk3.gray("\n  Use: memory-core remove <id>  |  memory-core edit <id>\n"));
 }
+function getCurrentListArchitectures(config) {
+  return inferProjectArchitectures(process.cwd(), config).filter((architecture) => architecture !== "global");
+}
+function printStatusLine(label, value) {
+  console.log(`  ${chalk3.dim(label.padEnd(18))} ${value}`);
+}
+async function runModelDoctor() {
+  const { envPath, values } = readRuntimeEnv();
+  const provider2 = getConfiguredProvider(values);
+  const model2 = getConfiguredChatModel(values);
+  const ollamaUrl = values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL;
+  const embeddingModel = values.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL;
+  const dbUrl = values.DATABASE_URL ?? "";
+  console.log(chalk3.bold("\n  memory-core model doctor\n"));
+  printStatusLine("Env file", existsSync6(envPath) ? envPath : `${envPath} ${chalk3.yellow("(will be created on first write)")}`);
+  printStatusLine("Provider", provider2);
+  printStatusLine("Chat model", model2);
+  printStatusLine("Embedding model", embeddingModel);
+  printStatusLine("Ollama URL", ollamaUrl);
+  console.log();
+  let ok = true;
+  const dbError = await verifyDatabaseConnection(dbUrl);
+  if (dbError) {
+    ok = false;
+    console.log(chalk3.red("  \u2717 PostgreSQL ") + chalk3.dim(dbError));
+  } else {
+    console.log(chalk3.green("  \u2713 PostgreSQL ") + chalk3.dim("connected"));
+  }
+  const ollamaError = await verifyOllamaConnection(ollamaUrl);
+  if (ollamaError) {
+    ok = false;
+    console.log(chalk3.red("  \u2717 Ollama     ") + chalk3.dim(ollamaError));
+  } else {
+    console.log(chalk3.green("  \u2713 Ollama     ") + chalk3.dim("reachable"));
+  }
+  if (!ollamaError) {
+    try {
+      const installedEmbeddingModel = await resolveOllamaInstalledModel(ollamaUrl, embeddingModel);
+      if (installedEmbeddingModel) {
+        console.log(chalk3.green("  \u2713 Embedding  ") + chalk3.dim(`${installedEmbeddingModel} installed`));
+      } else {
+        ok = false;
+        console.log(chalk3.red("  \u2717 Embedding  ") + chalk3.dim(`${embeddingModel} not installed in Ollama`));
+      }
+    } catch (err) {
+      ok = false;
+      console.log(chalk3.red("  \u2717 Embedding  ") + chalk3.dim(err.message));
+    }
+  }
+  if (provider2 === "ollama") {
+    if (ollamaError) {
+      ok = false;
+      console.log(chalk3.red("  \u2717 Chat model ") + chalk3.dim("cannot verify while Ollama is unreachable"));
+    } else {
+      try {
+        const installedChatModel = await resolveOllamaInstalledModel(ollamaUrl, model2);
+        if (installedChatModel) {
+          console.log(chalk3.green("  \u2713 Chat model ") + chalk3.dim(`${installedChatModel} installed`));
+        } else {
+          ok = false;
+          console.log(chalk3.red("  \u2717 Chat model ") + chalk3.dim(`${model2} not installed in Ollama`));
+        }
+      } catch (err) {
+        ok = false;
+        console.log(chalk3.red("  \u2717 Chat model ") + chalk3.dim(err.message));
+      }
+    }
+  } else {
+    if (!values.CHAT_API_KEY) {
+      ok = false;
+      console.log(chalk3.red(`  \u2717 ${providerLabel(provider2)} API`) + chalk3.dim(" CHAT_API_KEY is missing"));
+    } else {
+      console.log(chalk3.green(`  \u2713 ${providerLabel(provider2)} API`) + chalk3.dim(" key configured"));
+      console.log(chalk3.gray("    Remote provider connectivity is not verified live by doctor."));
+    }
+  }
+  console.log();
+  return { ok, provider: provider2, model: model2 };
+}
+async function printProjectStatus() {
+  const config = readProjectConfig();
+  const { envPath, values } = readRuntimeEnv();
+  const provider2 = getConfiguredProvider(values);
+  const model2 = getConfiguredChatModel(values);
+  const architectures = inferProjectArchitectures(process.cwd(), config);
+  const generatedFiles = OUTPUT_FILES.map((entry) => entry.path).filter((relativePath) => existsSync6(join6(process.cwd(), relativePath)));
+  const hookPath = join6(process.cwd(), ".git", "hooks", "pre-commit");
+  const memoryFilePath = join6(process.cwd(), MEMORY_FILE);
+  const statsPath = join6(process.cwd(), ".memory-core-stats.json");
+  const dbError = await verifyDatabaseConnection(values.DATABASE_URL ?? "");
+  const ollamaError = await verifyOllamaConnection(values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL);
+  console.log(chalk3.bold("\n  memory-core status\n"));
+  printStatusLine("Project", config?.projectName ?? process.cwd().split("/").pop() ?? "unknown");
+  printStatusLine("Project type", config?.projectType ?? chalk3.yellow("not initialized"));
+  printStatusLine("Language", config?.language ?? detectProject().language);
+  printStatusLine("Backend arch", config?.backendArchitecture ?? chalk3.gray("\u2014"));
+  printStatusLine("Frontend fw", config?.frontendFramework ?? chalk3.gray("\u2014"));
+  printStatusLine("Architectures", architectures.length ? architectures.join(", ") : chalk3.gray("none detected"));
+  printStatusLine("Agents", config?.agents?.length ? `${config.agents.length} selected` : chalk3.gray("none saved"));
+  printStatusLine("Caveman", config?.caveman?.enabled ? `enabled (${config.caveman.intensity})` : "disabled");
+  printStatusLine("Auto sync", config?.autoSync === false ? "disabled" : "enabled");
+  printStatusLine("Allow patterns", String(getAllowPatterns(config).length));
+  printStatusLine("Env file", `${existsSync6(envPath) ? "present" : "missing"} (${envPath.split("/").pop()})`);
+  printStatusLine("Memory file", existsSync6(memoryFilePath) ? MEMORY_FILE : chalk3.gray("not exported"));
+  printStatusLine("Project config", existsSync6(join6(process.cwd(), CONFIG_FILE)) ? CONFIG_FILE : chalk3.gray("missing"));
+  printStatusLine("Generated files", String(generatedFiles.length));
+  printStatusLine("Hook", existsSync6(hookPath) ? "installed" : "not installed");
+  printStatusLine("Stats file", existsSync6(statsPath) ? ".memory-core-stats.json" : chalk3.gray("none"));
+  console.log();
+  printStatusLine("Database URL", redactDatabaseUrl(values.DATABASE_URL ?? ""));
+  printStatusLine("Ollama URL", values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL);
+  printStatusLine("Embedding model", values.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL);
+  printStatusLine("Chat provider", provider2);
+  printStatusLine("Chat model", model2);
+  console.log();
+  console.log(
+    dbError ? chalk3.red("  \u2717 PostgreSQL ") + chalk3.dim(dbError) : chalk3.green("  \u2713 PostgreSQL ") + chalk3.dim("connected")
+  );
+  console.log(
+    ollamaError ? chalk3.red("  \u2717 Ollama     ") + chalk3.dim(ollamaError) : chalk3.green("  \u2713 Ollama     ") + chalk3.dim("reachable")
+  );
+  if (provider2 !== "ollama") {
+    console.log(
+      values.CHAT_API_KEY ? chalk3.green(`  \u2713 ${providerLabel(provider2)} API`) + chalk3.dim(" key configured") : chalk3.red(`  \u2717 ${providerLabel(provider2)} API`) + chalk3.dim(" CHAT_API_KEY is missing")
+    );
+  }
+  console.log();
+}
+function printMemorySelection(selection, limit = 4) {
+  const active = selection.activeArchitectures.join(", ") || "none detected";
+  console.log(chalk3.gray(`    Stack filter: ${active}`));
+  const included = selection.decisions.filter((decision) => decision.status === "included");
+  if (included.length > 0) {
+    console.log(chalk3.gray(`    Included ${included.length}:`));
+    for (const decision of included.slice(0, limit)) {
+      console.log(chalk3.gray(`      + ${decision.memory.content} (${decision.reason})`));
+    }
+    if (included.length > limit) {
+      console.log(chalk3.gray(`      \u2026 ${included.length - limit} more included`));
+    }
+  }
+  if (selection.excluded.length > 0) {
+    console.log(chalk3.gray(`    Excluded ${selection.excluded.length}:`));
+    for (const decision of selection.excluded.slice(0, limit)) {
+      console.log(chalk3.gray(`      - ${decision.memory.content} (${decision.reason})`));
+    }
+    if (selection.excluded.length > limit) {
+      console.log(chalk3.gray(`      \u2026 ${selection.excluded.length - limit} more excluded`));
+    }
+  }
+}
+function getConfiguredAgents(config) {
+  const agents = config.agents?.length ? config.agents : AGENT_NAMES.filter((agent) => agent !== "Shared");
+  return [.../* @__PURE__ */ new Set([...agents, "Shared"])];
+}
+async function syncGeneratedFiles(config, agents, options = {}) {
+  const memorySpinner = ora(options.label ?? "Syncing memories\u2026").start();
+  let memories = [];
+  try {
+    const archQuery = [config.backendArchitecture, config.frontendFramework, config.language].filter(Boolean).join(" ");
+    const selection = await retrieveMemorySelection({
+      query: archQuery,
+      cwd: process.cwd(),
+      config,
+      limit: 25
+    });
+    memories = selection.included;
+    memorySpinner.succeed(`Found ${memories.length} memories`);
+    if (options.showSelection) {
+      printMemorySelection(selection);
+    }
+  } catch (err) {
+    memorySpinner.warn(`Could not retrieve memories: ${err.message}`);
+  }
+  const spinner = ora("Regenerating agent files\u2026").start();
+  const result = await generate(
+    {
+      projectName: config.projectName,
+      projectType: config.projectType,
+      backendArchitecture: config.backendArchitecture,
+      frontendFramework: config.frontendFramework,
+      language: config.language,
+      memories,
+      caveman: config.caveman
+    },
+    process.cwd(),
+    agents
+  );
+  spinner.succeed(
+    `Synced \u2014 ${chalk3.green(`${result.written.length} updated`)}, ${chalk3.dim(`${result.skipped.length} already up to date`)}`
+  );
+  if (result.written.length > 0) {
+    result.written.forEach((file) => console.log(chalk3.gray(`    \u2713 ${file}`)));
+  }
+}
+async function autoSyncGeneratedFiles(config, action, enabled = true) {
+  if (!enabled) {
+    console.log(chalk3.gray("  Auto-sync skipped (--no-sync). Run memory-core sync when ready."));
+    return;
+  }
+  if (!config) {
+    return;
+  }
+  if (config.autoSync === false) {
+    console.log(chalk3.gray("  Auto-sync disabled for this project. Run memory-core sync when ready."));
+    return;
+  }
+  try {
+    await syncGeneratedFiles(config, getConfiguredAgents(config), {
+      label: `Auto-syncing agent files after ${action}\u2026`
+    });
+  } catch (err) {
+    console.log(chalk3.yellow(`  Auto-sync skipped: ${err.message}`));
+    console.log(chalk3.gray("  Run memory-core sync manually when ready."));
+  }
+}
 var program = new Command();
 program.name("memory-core").description("Universal AI memory core \u2014 generate AI context files for all coding agents").version(version);
 program.command("init").description("Initialize memory-core in the current project").option("--quick", "Use smart defaults and skip optional prompts").action(async (opts) => {
@@ -1755,25 +2377,19 @@ program.command("init").description("Initialize memory-core in the current proje
   if (!hasEnv && quick) {
     const dbUser = process.env.USER ?? process.env.USERNAME ?? "postgres";
     const dbUrl = `postgresql://${dbUser}@localhost:5432/memory_core`;
-    const ollamaUrl = "http://localhost:11434";
-    const chatModel = "llama3.2";
-    const envContent = [
-      `DATABASE_URL=${dbUrl}`,
-      `OLLAMA_URL=${ollamaUrl}`,
-      `OLLAMA_MODEL=nomic-embed-text`,
-      `OLLAMA_CHAT_MODEL=${chatModel}`
-    ].join("\n") + "\n";
-    writeFileSync5(envPath, envContent);
-    process.env.DATABASE_URL = dbUrl;
-    process.env.OLLAMA_URL = ollamaUrl;
-    process.env.OLLAMA_MODEL = "nomic-embed-text";
-    process.env.OLLAMA_CHAT_MODEL = chatModel;
-    const gitignorePath2 = join6(process.cwd(), ".gitignore");
-    const gitignore = existsSync6(gitignorePath2) ? readFileSync6(gitignorePath2, "utf-8") : "";
-    if (!gitignore.includes(".memory-core.env")) {
-      appendFileSync(gitignorePath2, `${gitignore ? "\n" : ""}.memory-core.env
-`);
-    }
+    const ollamaUrl = DEFAULT_OLLAMA_URL;
+    const chatModel = DEFAULT_CHAT_MODEL;
+    const envValues = {
+      DATABASE_URL: dbUrl,
+      OLLAMA_URL: ollamaUrl,
+      OLLAMA_MODEL: DEFAULT_EMBEDDING_MODEL,
+      CHAT_PROVIDER: "ollama",
+      CHAT_MODEL: chatModel,
+      OLLAMA_CHAT_MODEL: chatModel
+    };
+    writeRuntimeEnv(envValues, envPath);
+    applyRuntimeEnv(envValues);
+    ensureEnvFileIgnored(envPath);
     console.log(chalk3.green("  \u2713 .memory-core.env created with local defaults"));
   } else if (!hasEnv) {
     console.log(chalk3.dim("  No .memory-core.env found \u2014 let's set up your connection.\n"));
@@ -1889,33 +2505,18 @@ program.command("init").description("Initialize memory-core in the current proje
       });
       console.log(chalk3.green(`  \u2713 ${chatProvider} / ${chatModel} configured`));
     }
-    const envLines = [
-      `DATABASE_URL=${dbUrl}`,
-      `OLLAMA_URL=${ollamaUrl}`,
-      `OLLAMA_MODEL=nomic-embed-text`,
-      `CHAT_PROVIDER=${chatProvider}`,
-      `CHAT_MODEL=${chatModel}`
-    ];
-    if (chatProvider === "ollama") envLines.push(`OLLAMA_CHAT_MODEL=${chatModel}`);
-    if (chatApiKey) envLines.push(`CHAT_API_KEY=${chatApiKey}`);
-    const envContent = envLines.join("\n") + "\n";
-    writeFileSync5(envPath, envContent);
-    process.env.DATABASE_URL = dbUrl;
-    process.env.OLLAMA_URL = ollamaUrl;
-    process.env.OLLAMA_MODEL = "nomic-embed-text";
-    process.env.CHAT_PROVIDER = chatProvider;
-    process.env.CHAT_MODEL = chatModel;
-    if (chatProvider === "ollama") process.env.OLLAMA_CHAT_MODEL = chatModel;
-    if (chatApiKey) process.env.CHAT_API_KEY = chatApiKey;
-    const gitignorePath2 = join6(process.cwd(), ".gitignore");
-    if (existsSync6(gitignorePath2)) {
-      const gi = readFileSync6(gitignorePath2, "utf-8");
-      if (!gi.includes(".memory-core.env")) {
-        appendFileSync(gitignorePath2, "\n.memory-core.env\n");
-      }
-    } else {
-      writeFileSync5(gitignorePath2, ".memory-core.env\n");
-    }
+    const envValues = {
+      DATABASE_URL: dbUrl,
+      OLLAMA_URL: ollamaUrl,
+      OLLAMA_MODEL: DEFAULT_EMBEDDING_MODEL,
+      CHAT_PROVIDER: chatProvider,
+      CHAT_MODEL: chatModel
+    };
+    if (chatProvider === "ollama") envValues.OLLAMA_CHAT_MODEL = chatModel;
+    if (chatApiKey) envValues.CHAT_API_KEY = chatApiKey;
+    writeRuntimeEnv(envValues, envPath);
+    applyRuntimeEnv(envValues);
+    ensureEnvFileIgnored(envPath);
     console.log(chalk3.green("\n  \u2713 .memory-core.env created"));
     console.log(chalk3.gray("    Added to .gitignore \u2014 your DB credentials stay local.\n"));
   }
@@ -1976,11 +2577,20 @@ program.command("init").description("Initialize memory-core in the current proje
     message: "Pull relevant memories from previous projects?",
     default: true
   });
-  const installCaveman = quick ? false : await confirm({
-    message: "Install caveman token saver? (~65-75% fewer tokens)",
+  let installCaveman = quick ? false : await confirm({
+    message: "Install caveman token saver? Downloads and runs the upstream installer.",
     default: false
   });
   let cavemanIntensity = "full";
+  if (installCaveman) {
+    const allowRemoteInstaller = await confirm({
+      message: `Security check: download and execute installer from ${CAVEMAN_INSTALL_URL}?`,
+      default: false
+    });
+    if (!allowRemoteInstaller) {
+      installCaveman = false;
+    }
+  }
   if (installCaveman) {
     cavemanIntensity = await select({
       message: "Caveman intensity?",
@@ -2022,20 +2632,23 @@ program.command("init").description("Initialize memory-core in the current proje
     language,
     caveman: { enabled: installCaveman, intensity: cavemanIntensity },
     agents: selectedAgents,
-    allowPatterns: []
+    allowPatterns: [],
+    autoSync: true
   };
   let memories = [];
   if (pullMemories) {
     const spinner2 = ora("Retrieving relevant memories\u2026").start();
     try {
       const archQuery = [backendArchitecture, frontendFramework, language].filter(Boolean).join(" ");
-      memories = await retrieveContextualMemories({
+      const selection = await retrieveMemorySelection({
         query: archQuery,
         cwd: process.cwd(),
         config,
         limit: 20
       });
+      memories = selection.included;
       spinner2.succeed(`Found ${memories.length} relevant memories`);
+      printMemorySelection(selection);
     } catch (err) {
       spinner2.warn(`Could not retrieve memories: ${err.message}`);
     }
@@ -2043,10 +2656,7 @@ program.command("init").description("Initialize memory-core in the current proje
   if (installCaveman) {
     const spinner2 = ora("Installing caveman token saver\u2026").start();
     try {
-      execSync2(
-        "curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash",
-        { stdio: "pipe", cwd: process.cwd() }
-      );
+      await installCavemanTokenSaver();
       spinner2.succeed("Caveman installed");
     } catch (err) {
       spinner2.warn(`Caveman install failed: ${err.message}`);
@@ -2060,15 +2670,11 @@ program.command("init").description("Initialize memory-core in the current proje
   );
   writeProjectConfig(config);
   spinner.succeed(`Generated ${written.written.length} files`);
-  const gitignorePath = join6(process.cwd(), ".gitignore");
-  const generatedPaths = written.written;
-  if (generatedPaths.length > 0) {
-    const existing = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
-    const toAdd = generatedPaths.filter((p) => !existing.includes(p));
-    if (toAdd.length > 0) {
-      const block = "\n# memory-core generated files\n" + toAdd.join("\n") + "\n";
-      appendFileSync(gitignorePath, block);
-      console.log(chalk3.green(`  \u2713 Added ${toAdd.length} generated files to .gitignore`));
+  const gitignoreEntries = [...written.written, ...LOCAL_GENERATED_FILES];
+  if (gitignoreEntries.length > 0) {
+    const added = appendMissingGitignoreEntries(gitignoreEntries, "# memory-core generated files");
+    if (added > 0) {
+      console.log(chalk3.green(`  \u2713 Added ${added} generated files to .gitignore`));
     }
   }
   if (enableHook) {
@@ -2103,44 +2709,32 @@ program.command("sync").description("Re-pull memories and regenerate AI agent fi
     console.log(chalk3.yellow("  No agents selected \u2014 nothing to sync."));
     process.exit(0);
   }
-  const spinner = ora("Syncing memories\u2026").start();
-  let memories = [];
-  try {
-    const archQuery = [config.backendArchitecture, config.frontendFramework, config.language].filter(Boolean).join(" ");
-    memories = await retrieveContextualMemories({
-      query: archQuery,
-      cwd: process.cwd(),
-      config,
-      limit: 25
-    });
-    spinner.text = `Found ${memories.length} memories \u2014 regenerating files\u2026`;
-  } catch (err) {
-    spinner.warn(`Could not retrieve memories: ${err.message}`);
+  await syncGeneratedFiles(config, [...selectedAgents, "Shared"], { showSelection: true });
+  await closePool();
+});
+program.command("auto-sync [mode]").description("Show or change automatic agent file sync (on|off)").action((mode) => {
+  const config = readProjectConfig();
+  if (!config) {
+    console.error(chalk3.red("No .memory-core.json found. Run: memory-core init"));
+    process.exit(1);
   }
-  const result = await generate(
-    {
-      projectName: config.projectName,
-      projectType: config.projectType,
-      backendArchitecture: config.backendArchitecture,
-      frontendFramework: config.frontendFramework,
-      language: config.language,
-      memories,
-      caveman: config.caveman
-    },
-    process.cwd(),
-    [...selectedAgents, "Shared"]
-  );
-  const updatedCount = result.written.length;
-  const skippedCount = result.skipped.length;
-  spinner.succeed(
-    `Synced \u2014 ${chalk3.green(`${updatedCount} updated`)}, ${chalk3.dim(`${skippedCount} already up to date`)}`
-  );
-  if (result.written.length > 0) {
-    result.written.forEach((f) => console.log(chalk3.gray(`    \u2713 ${f}`)));
+  const normalized = mode?.trim().toLowerCase();
+  if (!normalized || normalized === "status") {
+    console.log(chalk3.bold("\n  Auto-sync\n"));
+    console.log(`  Status: ${config.autoSync === false ? chalk3.yellow("disabled") : chalk3.green("enabled")}`);
+    console.log(chalk3.gray("  Manual sync is always available: memory-core sync\n"));
+    return;
   }
-  await closePool();
+  if (normalized !== "on" && normalized !== "off") {
+    console.error(chalk3.red("Use: memory-core auto-sync [on|off|status]"));
+    process.exit(1);
+  }
+  const enabled = normalized === "on";
+  writeProjectConfig({ ...config, autoSync: enabled });
+  console.log(chalk3.green(`Auto-sync ${enabled ? "enabled" : "disabled"}`));
+  console.log(chalk3.gray("  Manual sync is always available: memory-core sync"));
 });
-program.command("remember <text>").description("Save a new memory to the central database").option("-t, --type <type>", "Memory type (decision|rule|pattern|note)", "decision").option("-s, --scope <scope>", "Scope (global|project)", "project").option("--tags <tags>", "Comma-separated tags").option("-r, --reason <reason>", "Why this rule exists \u2014 helps agents understand intent and debug violations").action(async (text, opts) => {
+program.command("remember <text>").description("Save a new memory to the central database").option("-t, --type <type>", "Memory type (decision|rule|pattern|note)", "decision").option("-s, --scope <scope>", "Scope (global|project)", "project").option("--tags <tags>", "Comma-separated tags").option("-r, --reason <reason>", "Why this rule exists \u2014 helps agents understand intent and debug violations").option("--no-sync", "Skip automatic agent file sync after saving").action(async (text, opts) => {
   const config = readProjectConfig();
   let reason = opts.reason;
   if (!reason) {
@@ -2165,6 +2759,7 @@ program.command("remember <text>").description("Save a new memory to the central
     const reasonLine = reason ? chalk3.gray(`
   Why: ${reason}`) : "";
     spinner.succeed(chalk3.green(`Memory saved: "${text}"`) + reasonLine);
+    await autoSyncGeneratedFiles(config, "remember", opts.sync);
   } catch (err) {
     spinner.fail(`Failed: ${err.message}`);
     process.exit(1);
@@ -2219,9 +2814,10 @@ program.command("export").description(`Export DB memories to ${MEMORY_FILE}`).op
     await closePool();
   }
 });
-program.command("import").description(`Import memories from ${MEMORY_FILE}`).option("--url <url>", "Import memories from a remote URL").option("-f, --file <file>", `Import file (default: ${MEMORY_FILE})`).action(async (opts) => {
+program.command("import").description(`Import memories from ${MEMORY_FILE}`).option("--url <url>", "Import memories from a remote URL").option("-f, --file <file>", `Import file (default: ${MEMORY_FILE})`).option("--no-sync", "Skip automatic agent file sync after import").action(async (opts) => {
   const spinner = ora("Reading memories\u2026").start();
   try {
+    const config = readProjectConfig();
     const memories = opts.url ? await readMemoryFileFromUrl(opts.url) : opts.file ? parseMemoryFile(readFileSync6(join6(process.cwd(), opts.file), "utf-8")) : readMemoryFile();
     let inserted = 0;
     let skipped = 0;
@@ -2243,6 +2839,9 @@ program.command("import").description(`Import memories from ${MEMORY_FILE}`).opt
       else skipped++;
     }
     spinner.succeed(`Imported ${inserted} memories, skipped ${skipped} duplicates`);
+    if (inserted > 0) {
+      await autoSyncGeneratedFiles(config, "import", opts.sync);
+    }
   } catch (err) {
     spinner.fail(`Import failed: ${err.message}`);
     process.exit(1);
@@ -2250,15 +2849,24 @@ program.command("import").description(`Import memories from ${MEMORY_FILE}`).opt
     await closePool();
   }
 });
-program.command("list").description("List memories from the local database").option("--type <type>", "Filter by type").option("--scope <scope>", "Filter by scope").option("--arch <architecture>", "Filter by architecture").option("-n, --limit <n>", "Maximum rows to show", "200").action(async (opts) => {
+program.command("list").description("List memories from the local database").option("--type <type>", "Filter by type").option("--scope <scope>", "Filter by scope").option("--arch <architecture>", "Filter by architecture").option("--project <name>", "Filter by project name").option("--current", "Only show memories relevant to the current project (default)").option("--all", "Show all memories in the database").option("-n, --limit <n>", "Maximum rows to show", "200").action(async (opts) => {
   try {
+    const config = readProjectConfig();
+    const architectures = opts.arch ? opts.arch : opts.all ? void 0 : getCurrentListArchitectures(config);
+    const projectName = opts.project ? opts.project : opts.all || opts.arch ? void 0 : config?.projectName;
     const memories = await listMemories({
       type: opts.type,
       scope: opts.scope,
-      architecture: opts.arch,
+      architecture: architectures,
+      projectName,
+      includeGlobal: !opts.all,
       limit: parseInt(opts.limit, 10)
     });
-    printMemoryTable(memories);
+    const title = opts.all ? "All memories" : `Current project memories${architectures ? ` (${Array.isArray(architectures) ? architectures.join(", ") : architectures})` : ""}`;
+    printMemoryTable(memories, title);
+    if (!opts.all) {
+      console.log(chalk3.gray("  Showing current project context plus shared/global memories. Use --all for the full database.\n"));
+    }
   } catch (err) {
     console.error(chalk3.red(`List failed: ${err.message}`));
     process.exit(1);
@@ -2266,14 +2874,16 @@ program.command("list").description("List memories from the local database").opt
     await closePool();
   }
 });
-program.command("remove <id>").description("Remove a memory by ID").action(async (id) => {
+program.command("remove <id>").description("Remove a memory by ID").option("--no-sync", "Skip automatic agent file sync after removal").action(async (id, opts) => {
   try {
+    const config = readProjectConfig();
     const deleted = await deleteMemory(parseInt(id, 10));
     if (!deleted) {
       console.log(chalk3.yellow(`No memory found with ID ${id}`));
       process.exit(1);
     }
     console.log(chalk3.green(`Removed memory ${id}`));
+    await autoSyncGeneratedFiles(config, "remove", opts.sync);
   } catch (err) {
     console.error(chalk3.red(`Remove failed: ${err.message}`));
     process.exit(1);
@@ -2281,8 +2891,9 @@ program.command("remove <id>").description("Remove a memory by ID").action(async
     await closePool();
   }
 });
-program.command("forget").description("Bulk-delete memories by tag, scope, type, or architecture").option("--tag <tag>", "Delete memories with this tag").option("--scope <scope>", "Filter by scope").option("--type <type>", "Filter by type").option("--arch <architecture>", "Filter by architecture").action(async (opts) => {
+program.command("forget").description("Bulk-delete memories by tag, scope, type, or architecture").option("--tag <tag>", "Delete memories with this tag").option("--scope <scope>", "Filter by scope").option("--type <type>", "Filter by type").option("--arch <architecture>", "Filter by architecture").option("--no-sync", "Skip automatic agent file sync after deletion").action(async (opts) => {
   try {
+    const config = readProjectConfig();
     const deleted = await deleteMemories({
       tag: opts.tag,
       scope: opts.scope,
@@ -2290,6 +2901,9 @@ program.command("forget").description("Bulk-delete memories by tag, scope, type,
       architecture: opts.arch
     });
     console.log(chalk3.green(`Deleted ${deleted} memories`));
+    if (deleted > 0) {
+      await autoSyncGeneratedFiles(config, "forget", opts.sync);
+    }
   } catch (err) {
     console.error(chalk3.red(`Forget failed: ${err.message}`));
     process.exit(1);
@@ -2297,9 +2911,10 @@ program.command("forget").description("Bulk-delete memories by tag, scope, type,
     await closePool();
   }
 });
-program.command("edit <id>").description("Edit a memory interactively").action(async (id) => {
+program.command("edit <id>").description("Edit a memory interactively").option("--no-sync", "Skip automatic agent file sync after editing").action(async (id, opts) => {
   const memoryId = parseInt(id, 10);
   try {
+    const config = readProjectConfig();
     const existing = await getMemory(memoryId);
     if (!existing) {
       console.log(chalk3.yellow(`No memory found with ID ${id}`));
@@ -2322,6 +2937,7 @@ program.command("edit <id>").description("Edit a memory interactively").action(a
       embedding
     });
     console.log(chalk3.green(`Updated memory ${id}`));
+    await autoSyncGeneratedFiles(config, "edit", opts.sync);
   } catch (err) {
     console.error(chalk3.red(`Edit failed: ${err.message}`));
     process.exit(1);
@@ -2329,8 +2945,9 @@ program.command("edit <id>").description("Edit a memory interactively").action(a
     await closePool();
   }
 });
-program.command("ignore [pattern]").description("Manage project-scoped false-positive ignore patterns").option("--list", "List ignored patterns").option("--remove <id>", "Remove an ignored pattern by ID").action(async (pattern, opts) => {
+program.command("ignore [pattern]").description("Manage project-scoped false-positive ignore patterns").option("--list", "List ignored patterns").option("--remove <id>", "Remove an ignored pattern by ID").option("--no-sync", "Skip automatic agent file sync after changing ignore patterns").action(async (pattern, opts) => {
   try {
+    const config = readProjectConfig();
     if (opts.list) {
       printMemoryTable(await listMemories({ type: "ignore", limit: 1e3 }), "Ignored patterns");
       return;
@@ -2342,13 +2959,13 @@ program.command("ignore [pattern]").description("Manage project-scoped false-pos
         process.exit(1);
       }
       console.log(chalk3.green(`Removed ignore pattern ${opts.remove}`));
+      await autoSyncGeneratedFiles(config, "ignore remove", opts.sync);
       return;
     }
     if (!pattern) {
       console.error(chalk3.red("Provide a pattern, --list, or --remove <id>"));
       process.exit(1);
     }
-    const config = readProjectConfig();
     const embedding = await embed(pattern);
     await upsertMemory({
       type: "ignore",
@@ -2360,6 +2977,7 @@ program.command("ignore [pattern]").description("Manage project-scoped false-pos
       embedding
     });
     console.log(chalk3.green(`Ignored pattern saved: "${pattern}"`));
+    await autoSyncGeneratedFiles(config, "ignore", opts.sync);
   } catch (err) {
     console.error(chalk3.red(`Ignore failed: ${err.message}`));
     process.exit(1);
@@ -2437,7 +3055,6 @@ program.command("reset").description("Remove memory-core generated files and loc
       default: false
     });
     if (ok) {
-      const { getPool } = await import("./db-5X5LTUCB.js");
       await getPool().query("DROP TABLE IF EXISTS memories");
       await closePool();
       console.log(chalk3.yellow("Dropped memories table"));
@@ -2617,6 +3234,82 @@ read:
   console.log(chalk3.bold("\n  Every AI agent now follows your memory globally.\n"));
   await closePool();
 });
+var provider = program.command("provider").description("Manage the code-checking provider configuration");
+provider.command("set <name>").description("Set the code-checking provider (ollama, openai, anthropic, minimax)").option("--model <model>", "Chat model to set alongside the provider").option("--api-key <key>", "API key for cloud providers").action(async (name, opts) => {
+  try {
+    const providerName = normalizeProvider(name);
+    const runtimeEnv = readRuntimeEnv();
+    const values = { ...runtimeEnv.values };
+    values.CHAT_PROVIDER = providerName;
+    values.OLLAMA_URL = values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL;
+    values.OLLAMA_MODEL = values.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL;
+    if (opts.model) {
+      values.CHAT_MODEL = opts.model;
+    } else if (!values.CHAT_MODEL && !values.OLLAMA_CHAT_MODEL) {
+      values.CHAT_MODEL = DEFAULT_CHAT_MODEL;
+    }
+    if (providerName === "ollama") {
+      const model2 = values.CHAT_MODEL ?? values.OLLAMA_CHAT_MODEL ?? DEFAULT_CHAT_MODEL;
+      values.CHAT_MODEL = model2;
+      values.OLLAMA_CHAT_MODEL = model2;
+      delete values.CHAT_API_KEY;
+    } else {
+      delete values.OLLAMA_CHAT_MODEL;
+      if (opts.apiKey) {
+        values.CHAT_API_KEY = opts.apiKey;
+      } else if (!values.CHAT_API_KEY) {
+        values.CHAT_API_KEY = await input({
+          message: `${providerLabel(providerName)} API key?`
+        });
+      }
+    }
+    writeRuntimeEnv(values, runtimeEnv.envPath);
+    applyRuntimeEnv(values);
+    ensureEnvFileIgnored(runtimeEnv.envPath);
+    console.log(chalk3.green(`Updated provider: ${providerName}`));
+    console.log(chalk3.gray(`  Chat model: ${getConfiguredChatModel(values)}`));
+  } catch (err) {
+    console.error(chalk3.red(`Provider update failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+var model = program.command("model").description("Manage code-checking and embedding models");
+model.command("set <name>").description("Set the chat model used for code checking").option("--provider <provider>", "Override provider while setting the model").option("--embedding", "Set the embedding model instead of the chat model").action(async (name, opts) => {
+  try {
+    const runtimeEnv = readRuntimeEnv();
+    const values = { ...runtimeEnv.values };
+    if (opts.provider) values.CHAT_PROVIDER = normalizeProvider(opts.provider);
+    const providerName = getConfiguredProvider(values);
+    if (opts.embedding) {
+      values.OLLAMA_MODEL = name;
+    } else {
+      values.CHAT_MODEL = name;
+      if (providerName === "ollama") values.OLLAMA_CHAT_MODEL = name;
+    }
+    values.OLLAMA_URL = values.OLLAMA_URL ?? DEFAULT_OLLAMA_URL;
+    values.OLLAMA_MODEL = values.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL;
+    writeRuntimeEnv(values, runtimeEnv.envPath);
+    applyRuntimeEnv(values);
+    ensureEnvFileIgnored(runtimeEnv.envPath);
+    console.log(chalk3.green(`Updated ${opts.embedding ? "embedding" : "chat"} model: ${name}`));
+    console.log(chalk3.gray(`  Provider: ${providerName}`));
+  } catch (err) {
+    console.error(chalk3.red(`Model update failed: ${err.message}`));
+    process.exit(1);
+  }
+});
+model.command("doctor").description("Verify provider, model, database, and Ollama setup").action(async () => {
+  const result = await runModelDoctor();
+  if (!result.ok) process.exit(1);
+});
+program.command("status").description("Show the current memory-core project and runtime setup").action(async () => {
+  try {
+    await printProjectStatus();
+  } catch (err) {
+    console.error(chalk3.red(`Status failed: ${err.message}`));
+    process.exit(1);
+  }
+});
 var hook = program.command("hook").description("Manage the pre-commit rule enforcement hook");
 hook.command("install").description("Install pre-commit hook (advisory mode by default \u2014 logs violations, never blocks)").option("--advisory", "Log violations but never block commits (default)").option("--strict", "Block commits that violate your rules").action((opts) => {
   const advisory = opts.strict ? false : true;