@shahmilsaari/memory-core 1.0.13 → 1.0.18

package/dist/cli.js

@@ -20,7 +20,7 @@ import {
   retrieveMemorySelection,
   runMigrations,
   seeds
-} from "./chunk-PRRVI3YM.js";
+} from "./chunk-UNGXRKD2.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -33,7 +33,7 @@ import { homedir } from "os";
 
 // src/hook.ts
 import { execSync, spawnSync } from "child_process";
-import { writeFileSync as writeFileSync2, existsSync as existsSync2, unlinkSync, readFileSync as readFileSync2, chmodSync } from "fs";
+import { writeFileSync as writeFileSync2, existsSync as existsSync2, unlinkSync, readFileSync as readFileSync2, chmodSync, statSync } from "fs";
 import { join as join2 } from "path";
 import chalk from "chalk";
 
@@ -122,8 +122,14 @@ var reasonMap = new Map(
 );
 var HOOK_PATH = join2(".git", "hooks", "pre-commit");
 var HOOK_MARKER = "# archmind-memory-core";
-function buildHookBody(advisory) {
+var COMMIT_MSG_HOOK_PATH = join2(".git", "hooks", "commit-msg");
+var COMMIT_MSG_HOOK_MARKER = "# archmind-memory-core commit-msg";
+var RULE_CACHE_FILE = ".memory-core-rules-cache.json";
+var DB_VERSION_FILE = ".memory-core-db-version";
+var RULE_CACHE_TTL_MS = 5 * 60 * 1e3;
+function buildHookBody(advisory, fast = false) {
   const suffix = advisory ? " || true" : "";
+  const checkArgs = fast ? "check --staged --fast" : "check --staged";
   return `${HOOK_MARKER}${advisory ? " advisory" : ""}
 if [ "\${MEMORY_CORE_SKIP_HOOK:-}" = "1" ] || [ "\${ARCHMIND_SKIP_HOOK:-}" = "1" ] || [ "\${HUSKY:-}" = "0" ] || [ "\${HUSKY_SKIP_HOOKS:-}" = "1" ]; then
   exit 0
@@ -135,20 +141,20 @@ if [ -n "\${SKIP_HOOKS:-}" ]; then
   exit 0
 fi
 if command -v memory-core >/dev/null 2>&1; then
-  memory-core check --staged${suffix}
+  memory-core ${checkArgs}${suffix}
 elif [ -f "./node_modules/.bin/memory-core" ]; then
-  ./node_modules/.bin/memory-core check --staged${suffix}
+  ./node_modules/.bin/memory-core ${checkArgs}${suffix}
 elif [ -f "./dist/cli.js" ]; then
-  node ./dist/cli.js check --staged${suffix}
+  node ./dist/cli.js ${checkArgs}${suffix}
 else
-  npx --no-install memory-core check --staged 2>/dev/null || exit 0
+  npx --no-install memory-core ${checkArgs} 2>/dev/null || exit 0
 fi
 `;
 }
-function buildHookScript(advisory) {
+function buildHookScript(advisory, fast = false) {
   return `#!/bin/sh
 
-${buildHookBody(advisory)}`;
+${buildHookBody(advisory, fast)}`;
 }
 function normalizeHookPreamble(content) {
   const lines = content.split("\n");
@@ -165,6 +171,31 @@ function normalizeHookPreamble(content) {
   }
   return normalized.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
+function toRuleStatEntry(raw) {
+  if (raw === void 0) return { count: 0, falsePositives: 0 };
+  if (typeof raw === "number") return { count: raw, falsePositives: 0 };
+  return raw;
+}
+function readPositiveIntEnv(name, fallback) {
+  const raw = Number(process.env[name]);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : fallback;
+}
+function isFastCheck(options) {
+  return options.fast === true || process.env.MEMORY_CORE_CHECK_FAST === "1";
+}
+async function withTimeout(promise, timeoutMs, fallback) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve2) => {
+        timer = setTimeout(() => resolve2(fallback), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 function recordViolations(violations, source = "hook") {
   const statsPath = join2(process.cwd(), ".memory-core-stats.json");
   let stats = { rules: {}, files: {} };
@@ -178,7 +209,8 @@ function recordViolations(violations, source = "hook") {
   stats.rules ??= {};
   stats.files ??= {};
   for (const violation of violations) {
-    stats.rules[violation.rule] = (stats.rules[violation.rule] ?? 0) + 1;
+    const existing = toRuleStatEntry(stats.rules[violation.rule]);
+    stats.rules[violation.rule] = { count: existing.count + 1, falsePositives: existing.falsePositives };
     if (violation.file) stats.files[violation.file] = (stats.files[violation.file] ?? 0) + 1;
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -219,11 +251,12 @@ async function promptToSaveViolations(violations) {
       message: "Why should this rule exist?",
       default: selected.reason ?? selected.issue ?? ""
     });
+    const storedReason = reason.trim() || selected.reason || selected.issue || `Captured from violation: ${selected.rule}`;
     await app.services.memoryEngine.remember({
       type: "rule",
       scope: "project",
       content: selected.rule,
-      reason: reason || void 0,
+      reason: storedReason,
       tags: ["violation"]
     });
     console.log(chalk.green("  \u2713 Saved as project rule. Run memory-core sync to propagate it.\n"));
@@ -232,6 +265,40 @@ async function promptToSaveViolations(violations) {
 `));
   }
 }
+function readRuleCache(cwd) {
+  const cachePath = join2(cwd, RULE_CACHE_FILE);
+  const configPath = join2(cwd, ".memory-core.json");
+  if (!existsSync2(cachePath) || !existsSync2(configPath)) return null;
+  try {
+    const entry = JSON.parse(readFileSync2(cachePath, "utf-8"));
+    const now = Date.now();
+    if (now - entry.timestamp > RULE_CACHE_TTL_MS) return null;
+    const configMtime = statSync(configPath).mtimeMs;
+    if (configMtime !== entry.configMtime) return null;
+    const dbVersionPath = join2(cwd, DB_VERSION_FILE);
+    const dbVersionMtime = existsSync2(dbVersionPath) ? statSync(dbVersionPath).mtimeMs : 0;
+    if (dbVersionMtime !== entry.dbVersionMtime) return null;
+    return entry;
+  } catch {
+    return null;
+  }
+}
+function saveRuleCache(cwd, data) {
+  const configPath = join2(cwd, ".memory-core.json");
+  try {
+    const configMtime = statSync(configPath).mtimeMs;
+    const dbVersionPath = join2(cwd, DB_VERSION_FILE);
+    const dbVersionMtime = existsSync2(dbVersionPath) ? statSync(dbVersionPath).mtimeMs : 0;
+    const entry = {
+      timestamp: Date.now(),
+      configMtime,
+      dbVersionMtime,
+      ...data
+    };
+    writeFileSync2(join2(cwd, RULE_CACHE_FILE), JSON.stringify(entry, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
 async function loadIgnorePatterns() {
   try {
     const app = getDefaultApplicationContainer();
@@ -465,6 +532,28 @@ function loadRecentViolationsFromStats(cwd = process.cwd()) {
     return [];
   }
 }
+function incrementFalsePositivesForPatterns(learnedPatterns, violations, cwd = process.cwd()) {
+  if (learnedPatterns.length === 0 || violations.length === 0) return;
+  const statsPath = join2(cwd, ".memory-core-stats.json");
+  if (!existsSync2(statsPath)) return;
+  let stats;
+  try {
+    stats = JSON.parse(readFileSync2(statsPath, "utf-8"));
+  } catch {
+    return;
+  }
+  stats.rules ??= {};
+  for (const violation of violations) {
+    const haystack = `${violation.rule}
+${violation.issue}
+${violation.file}`.toLowerCase();
+    const matched = learnedPatterns.some((p) => haystack.includes(p.toLowerCase()));
+    if (!matched) continue;
+    const existing = toRuleStatEntry(stats.rules[violation.rule]);
+    stats.rules[violation.rule] = { count: existing.count, falsePositives: existing.falsePositives + 1 };
+  }
+  writeFileSync2(statsPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+}
 async function learnGlobalIgnoresFromFalsePositives(options) {
   if (options.currentViolations.length === 0) return [];
   const recentViolations = loadRecentViolationsFromStats();
@@ -493,10 +582,11 @@ ${JSON.stringify(options.allowPatterns, null, 2)}`;
     console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   }
   try {
+    const recheckTimeoutMs = readPositiveIntEnv("MEMORY_CORE_FALSE_POSITIVE_TIMEOUT_MS", 6e3);
     const raw = await callChatModel([
       { role: "system", content: systemPrompt },
       { role: "user", content: userPrompt }
-    ]);
+    ], { timeoutMs: recheckTimeoutMs });
     const parsed = parseFalsePositiveDecisions(raw);
     if (!parsed.valid) return [];
     const existing = new Set(options.allowPatterns.map((pattern) => pattern.toLowerCase()));
@@ -522,6 +612,9 @@ ${JSON.stringify(options.allowPatterns, null, 2)}`;
       } catch {
       }
     }
+    if (inserted.length > 0) {
+      incrementFalsePositivesForPatterns(inserted, options.currentViolations);
+    }
     return inserted;
   } catch {
     return [];
@@ -606,6 +699,32 @@ function findDeterministicViolations(diff, rules, avoids, allowPatterns = []) {
   }
   return dedupeViolations(violations);
 }
+function suppressBatchRepetitions(violations, threshold = 3) {
+  const pairCounts = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    const key = `${v.rule}\0${v.file}`;
+    pairCounts.set(key, (pairCounts.get(key) ?? 0) + 1);
+  }
+  const suppressedKeys = /* @__PURE__ */ new Set();
+  for (const [key, count] of pairCounts) {
+    if (count >= threshold) suppressedKeys.add(key);
+  }
+  if (suppressedKeys.size === 0) return { filtered: violations, suppressedCount: 0 };
+  const filtered = violations.filter((v) => !suppressedKeys.has(`${v.rule}\0${v.file}`));
+  return { filtered, suppressedCount: violations.length - filtered.length };
+}
+function groupViolationsByRule(violations) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    const existing = groups.get(v.rule);
+    if (existing) {
+      existing.push(v);
+    } else {
+      groups.set(v.rule, [v]);
+    }
+  }
+  return groups;
+}
 function filterModelViolationsByStagedDiff(violations, stagedFiles, diff) {
   if (violations.length === 0) return violations;
   const changedFiles = new Set(stagedFiles.map((file) => normalizePath(file)));
@@ -637,13 +756,13 @@ function filterModelViolationsByStagedDiff(violations, stagedFiles, diff) {
   }
   return filtered;
 }
-function installHook(advisory = true) {
+function installHook(advisory = true, fast = false) {
   if (!existsSync2(".git")) {
     console.error(chalk.red("\n  Not a git repository. Run from project root.\n"));
     process.exit(1);
   }
-  const script = buildHookScript(advisory);
-  const body = buildHookBody(advisory).trimEnd();
+  const script = buildHookScript(advisory, fast);
+  const body = buildHookBody(advisory, fast).trimEnd();
   if (existsSync2(HOOK_PATH)) {
     const existing = readFileSync2(HOOK_PATH, "utf-8");
     if (existing.includes(HOOK_MARKER)) {
@@ -658,8 +777,10 @@ ${preamble}`;
 ${body}
 `);
       chmodSync(HOOK_PATH, 493);
+      installCommitMsgHook(advisory);
       const modeLabel2 = advisory ? chalk.cyan("advisory") : chalk.yellow("strict");
       console.log(chalk.green("\n  \u2713 Pre-commit hook updated") + chalk.dim(` (${modeLabel2} mode)`));
+      if (fast) console.log(chalk.gray(`    Check mode: fast deterministic checks`));
       return;
     }
     writeFileSync2(HOOK_PATH, existing.trimEnd() + "\n\n" + body + "\n");
@@ -667,9 +788,11 @@ ${body}
     writeFileSync2(HOOK_PATH, script);
   }
   chmodSync(HOOK_PATH, 493);
+  installCommitMsgHook(advisory);
   const modeLabel = advisory ? "advisory (logs violations, never blocks)" : "strict (blocks commits on violations)";
   console.log(chalk.green("\n  \u2713 Pre-commit hook installed") + chalk.dim(` \u2014 ${modeLabel}`));
-  console.log(chalk.gray(`    Chat model: ${process.env.OLLAMA_CHAT_MODEL ?? "llama3.2"}`));
+  console.log(chalk.gray(fast ? "    Check mode: fast deterministic checks" : `    Chat model: ${process.env.OLLAMA_CHAT_MODEL ?? "llama3.2"}`));
+  console.log(chalk.gray("    Commit message rules: memory-core commit-rules --list"));
   console.log(chalk.gray("    To uninstall: memory-core hook uninstall\n"));
 }
 function uninstallHook() {
@@ -690,8 +813,118 @@ function uninstallHook() {
   } else {
     unlinkSync(HOOK_PATH);
   }
+  uninstallCommitMsgHook();
   console.log(chalk.green("\n  \u2713 Pre-commit hook removed\n"));
 }
+function buildCommitMsgHookBody(advisory) {
+  const suffix = advisory ? " || true" : "";
+  return `${COMMIT_MSG_HOOK_MARKER}${advisory ? " advisory" : ""}
+if [ "\${MEMORY_CORE_SKIP_HOOK:-}" = "1" ] || [ "\${ARCHMIND_SKIP_HOOK:-}" = "1" ] || [ "\${HUSKY:-}" = "0" ] || [ "\${HUSKY_SKIP_HOOKS:-}" = "1" ]; then
+  exit 0
+fi
+if [ -n "\${SKIP:-}" ] && echo ",$SKIP," | grep -qiE ',(memory-core|archmind),'; then
+  exit 0
+fi
+if [ -n "\${SKIP_HOOKS:-}" ]; then
+  exit 0
+fi
+if command -v memory-core >/dev/null 2>&1; then
+  memory-core check --commit-msg "$1"${suffix}
+elif [ -f "./node_modules/.bin/memory-core" ]; then
+  ./node_modules/.bin/memory-core check --commit-msg "$1"${suffix}
+elif [ -f "./dist/cli.js" ]; then
+  node ./dist/cli.js check --commit-msg "$1"${suffix}
+else
+  npx --no-install memory-core check --commit-msg "$1" 2>/dev/null || exit 0
+fi
+`;
+}
+function installCommitMsgHook(advisory = true) {
+  const body = buildCommitMsgHookBody(advisory).trimEnd();
+  const script = `#!/bin/sh
+
+${body}
+`;
+  if (existsSync2(COMMIT_MSG_HOOK_PATH)) {
+    const existing = readFileSync2(COMMIT_MSG_HOOK_PATH, "utf-8");
+    if (existing.includes(COMMIT_MSG_HOOK_MARKER)) {
+      const markerIndex = existing.indexOf(COMMIT_MSG_HOOK_MARKER);
+      const beforeRaw = markerIndex > 0 ? existing.slice(0, markerIndex) : "";
+      const normalizedBefore = normalizeHookPreamble(beforeRaw);
+      const preamble = normalizedBefore.length > 0 ? normalizedBefore : "#!/bin/sh";
+      const preambleWithShebang = preamble.startsWith("#!/bin/sh") ? preamble : `#!/bin/sh
+${preamble}`;
+      writeFileSync2(COMMIT_MSG_HOOK_PATH, `${preambleWithShebang}
+
+${body}
+`);
+    } else {
+      writeFileSync2(COMMIT_MSG_HOOK_PATH, existing.trimEnd() + "\n\n" + body + "\n");
+    }
+  } else {
+    writeFileSync2(COMMIT_MSG_HOOK_PATH, script);
+  }
+  chmodSync(COMMIT_MSG_HOOK_PATH, 493);
+}
+function uninstallCommitMsgHook() {
+  if (!existsSync2(COMMIT_MSG_HOOK_PATH)) return;
+  const content = readFileSync2(COMMIT_MSG_HOOK_PATH, "utf-8");
+  if (!content.includes(COMMIT_MSG_HOOK_MARKER)) return;
+  const markerIndex = content.indexOf(COMMIT_MSG_HOOK_MARKER);
+  const before = markerIndex > 1 ? normalizeHookPreamble(content.slice(0, markerIndex)) : "";
+  if (before && before !== "#!/bin/sh") {
+    writeFileSync2(COMMIT_MSG_HOOK_PATH, `${before}
+`);
+  } else {
+    unlinkSync(COMMIT_MSG_HOOK_PATH);
+  }
+}
+async function checkCommitMsg(msgFile, options = {}) {
+  if (!existsSync2(msgFile)) {
+    if (options.verbose) console.log(chalk.gray("  No commit message file \u2014 skipping."));
+    return;
+  }
+  const raw = readFileSync2(msgFile, "utf-8");
+  const cleanMsg = raw.split("\n").filter((l) => !l.startsWith("#")).join("\n").trim();
+  if (!cleanMsg) {
+    if (options.verbose) console.log(chalk.gray("  Empty commit message \u2014 skipping."));
+    return;
+  }
+  const configPath = join2(process.cwd(), ".memory-core.json");
+  if (!existsSync2(configPath)) return;
+  const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+  const rules = (config.commitRules ?? []).filter(Boolean);
+  if (rules.length === 0) return;
+  console.log(chalk.cyan("\n  archmind \u2014 checking commit message\u2026"));
+  const violations = [];
+  for (const rule of rules) {
+    try {
+      const regex = new RegExp(rule.pattern, "im");
+      const matched = regex.test(cleanMsg);
+      const violated = rule.negate ? matched : !matched;
+      if (violated) violations.push({ rule });
+    } catch {
+      if (options.debug) console.log(chalk.yellow(`  [debug] Invalid regex: "${rule.pattern}"`));
+    }
+  }
+  if (violations.length === 0) {
+    console.log(chalk.green("  \u2713 Commit message OK.\n"));
+    return;
+  }
+  const blocking = violations.filter((v) => !v.rule.advisory);
+  violations.forEach(({ rule }) => {
+    const prefix = rule.advisory ? chalk.yellow("  \u26A0  ") : chalk.red("  \u2717  ");
+    console.log(prefix + rule.message);
+    const matchLabel = rule.negate ? "(must NOT match)" : "(must match)";
+    console.log(chalk.dim(`       Pattern: ${rule.pattern} ${matchLabel}`));
+  });
+  console.log();
+  if (blocking.length === 0) return;
+  console.log(chalk.dim("  Fix the commit message, then commit again."));
+  console.log(chalk.dim("  To bypass: MEMORY_CORE_SKIP_HOOK=1 git commit"));
+  console.log(chalk.dim("  Manage rules: memory-core commit-rules --list\n"));
+  process.exit(1);
+}
 async function checkStaged(options = {}) {
   const SOURCE_EXTENSIONS = /\.(ts|tsx|js|jsx|py|php|rb|go|java|cs|swift|kt|rs|vue|svelte)$/;
   let diff;
@@ -720,17 +953,45 @@ async function checkStaged(options = {}) {
   if (!existsSync2(configPath)) return;
   const config = JSON.parse(readFileSync2(configPath, "utf-8"));
   const { rules: fallbackRules, avoids } = getProfileRules(config);
-  const [rules, ignores] = await Promise.all([
-    loadRelevantRules(config, diff, stagedFiles, fallbackRules),
-    loadIgnorePatterns()
-  ]);
-  const allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config), ...ignores])];
+  const fast = isFastCheck(options);
+  const ruleLoadTimeoutMs = readPositiveIntEnv("MEMORY_CORE_RULE_LOAD_TIMEOUT_MS", 2e3);
+  const ignoreLoadTimeoutMs = readPositiveIntEnv("MEMORY_CORE_IGNORE_LOAD_TIMEOUT_MS", 1500);
+  let rules;
+  let ignores;
+  let allowPatterns;
+  if (fast) {
+    rules = fallbackRules;
+    ignores = [];
+    allowPatterns = [...new Set(getAllowPatterns(config))];
+  } else {
+    const cwd = process.cwd();
+    const cached = readRuleCache(cwd);
+    if (cached) {
+      rules = cached.rules;
+      ignores = cached.ignores;
+      allowPatterns = cached.allowPatterns;
+      if (options.debug) {
+        console.log(chalk.gray("  [debug] using cached rules (TTL valid)"));
+      }
+    } else {
+      const [loadedRules, loadedIgnores] = await Promise.all([
+        withTimeout(loadRelevantRules(config, diff, stagedFiles, fallbackRules), ruleLoadTimeoutMs, fallbackRules),
+        withTimeout(loadIgnorePatterns(), ignoreLoadTimeoutMs, [])
+      ]);
+      rules = loadedRules;
+      ignores = loadedIgnores;
+      allowPatterns = [.../* @__PURE__ */ new Set([...getAllowPatterns(config), ...loadedIgnores])];
+      saveRuleCache(cwd, { rules, ignores, allowPatterns });
+    }
+  }
   if (rules.length === 0) return;
-  const modelInput = buildModelInputFromDiff(diff, 8e3);
+  const modelInputMaxChars = readPositiveIntEnv("MEMORY_CORE_MODEL_INPUT_MAX_CHARS", 8e3);
+  const modelInput = buildModelInputFromDiff(diff, modelInputMaxChars);
   console.log(chalk.cyan("\n  archmind \u2014 checking staged changes against rules\u2026"));
   if (options.verbose || options.debug) {
     const sourceLabel = modelInput.source === "added-lines" ? "added lines" : "diff";
-    console.log(chalk.gray(`  model: ${getChatProviderLabel()}  rules: ${rules.length}  diff: ${diff.length} chars  input: ${sourceLabel}${modelInput.truncated ? " (truncated)" : ""}`));
+    const modelLabel = fast ? "skipped (--fast)" : getChatProviderLabel();
+    console.log(chalk.gray(`  model: ${modelLabel}  rules: ${rules.length}  diff: ${diff.length} chars  input: ${sourceLabel}${modelInput.truncated ? " (truncated)" : ""}`));
   }
   const rulesWithReasons = rules.map((r, i) => {
     const why = reasonMap.get(r);
@@ -773,13 +1034,19 @@ Do not include any text outside the JSON object.`;
     reasonLookup: reasonMap
   });
   let modelViolations = [];
-  try {
+  let aiFallback = fast;
+  if (fast) {
+    if (options.verbose || options.debug) {
+      console.log(chalk.gray("  AI check skipped; running deterministic checks only."));
+    }
+  } else try {
+    const checkTimeoutMs = readPositiveIntEnv("MEMORY_CORE_CHECK_TIMEOUT_MS", readPositiveIntEnv("CHAT_TIMEOUT_MS", 2e4));
     const raw = await callChatModel([
       { role: "system", content: systemPrompt },
       { role: "user", content: `Review these staged changes:
 
 ${modelInput.text}` }
-    ]);
+    ], { timeoutMs: checkTimeoutMs });
     if (options.verbose || options.debug) {
       console.log(chalk.gray(`  raw response: ${options.debug ? raw : raw.slice(0, 200)}`));
     }
@@ -792,15 +1059,25 @@ ${modelInput.text}` }
   } catch (err) {
     if (err.message?.startsWith("MODEL_NOT_FOUND:")) {
       printModelMissing(err.message.split(":")[1]);
+      aiFallback = true;
+      modelViolations = [];
+    } else if (err.message?.startsWith("TIMEOUT:")) {
+      const timeoutMs = err.message.split(":")[1];
+      console.log(chalk.yellow(`
+  \u26A0  AI check timed out after ${timeoutMs}ms \u2014 switching to fast deterministic checks for this run.`));
+      console.log(chalk.gray("     Set MEMORY_CORE_CHECK_TIMEOUT_MS to tune this.\n"));
+      aiFallback = true;
       modelViolations = [];
     } else if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
       console.log(chalk.yellow("\n  \u26A0  Ollama not running \u2014 using deterministic checks only."));
       console.log(chalk.gray("     Start it: ollama serve\n"));
+      aiFallback = true;
       modelViolations = [];
     } else {
       console.log(chalk.yellow(`
   \u26A0  AI rule check failed: ${err.message}`));
       console.log(chalk.gray("     Using deterministic checks only.\n"));
+      aiFallback = true;
       modelViolations = [];
     }
   }
@@ -808,6 +1085,17 @@ ${modelInput.text}` }
   let violations = dedupeViolations([...deterministicViolations, ...astViolations, ...modelViolations]);
   violations = applyAllowPatterns(violations, allowPatterns);
   if (violations.length > 0) {
+    const { filtered, suppressedCount } = suppressBatchRepetitions(violations);
+    if (suppressedCount > 0) {
+      console.log(
+        chalk.dim(
+          `  \u2139  Auto-suppressed ${suppressedCount} repetitive violation${suppressedCount > 1 ? "s" : ""} (same rule fired \u22653\xD7 on the same file \u2014 consider tuning the rule)`
+        )
+      );
+      violations = filtered;
+    }
+  }
+  if (!aiFallback && violations.length > 0) {
     const learnedPatterns = await learnGlobalIgnoresFromFalsePositives({
       diff,
       currentViolations: violations,
@@ -834,16 +1122,66 @@ ${modelInput.text}` }
 `
     )
   );
-  violations.forEach((v, i) => {
-    const loc = v.file ? v.line ? `${v.file}:${v.line}` : v.file : "unknown location";
-    console.log(chalk.bold(`  [${i + 1}] ${loc}`));
-    console.log(chalk.yellow("      Rule:   ") + v.rule);
-    const why = v.reason ?? reasonMap.get(v.rule);
+  let ruleStatsSnapshot = {};
+  {
+    const statsPath = join2(process.cwd(), ".memory-core-stats.json");
+    if (existsSync2(statsPath)) {
+      try {
+        const parsed = JSON.parse(readFileSync2(statsPath, "utf-8"));
+        ruleStatsSnapshot = parsed.rules ?? {};
+      } catch {
+      }
+    }
+  }
+  const MAX_LOCATIONS = 5;
+  const groups = groupViolationsByRule(violations);
+  let groupIndex = 0;
+  for (const [rule, group] of groups) {
+    groupIndex++;
+    const isCluster = group.length > 1;
+    const first = group[0];
+    if (isCluster) {
+      console.log(chalk.bold.red(`
+  [${groupIndex}] ${rule}`) + chalk.dim(`  \xD7${group.length}`));
+    } else {
+      const loc = first.file ? first.line ? `${first.file}:${first.line}` : first.file : "unknown location";
+      console.log(chalk.bold(`
+  [${groupIndex}] ${loc}`));
+      console.log(chalk.yellow("      Rule:   ") + rule);
+    }
+    const why = first.reason ?? reasonMap.get(rule);
     if (why) console.log(chalk.dim("      Why:    ") + chalk.dim(why));
-    if (v.issue) console.log(chalk.red("      Issue:  ") + v.issue);
-    if (v.suggestion) console.log(chalk.green("      Fix:    ") + v.suggestion);
+    if (first.suggestion) console.log(chalk.green("      Fix:    ") + first.suggestion);
+    if (isCluster) {
+      console.log();
+      const shown = group.slice(0, MAX_LOCATIONS);
+      const overflow = group.length - MAX_LOCATIONS;
+      for (const v of shown) {
+        const loc = v.file ? v.line ? `${v.file}:${v.line}` : v.file : "unknown location";
+        const issue = v.issue ? chalk.dim(`   ${v.issue}`) : "";
+        console.log(chalk.dim(`      ${loc}`) + issue);
+      }
+      if (overflow > 0) {
+        console.log(chalk.dim(`      ... and ${overflow} more`));
+      }
+    } else {
+      if (first.issue) console.log(chalk.red("      Issue:  ") + first.issue);
+    }
+    const ruleEntry = toRuleStatEntry(ruleStatsSnapshot[rule]);
+    if (ruleEntry.count > 5 && ruleEntry.falsePositives > 0) {
+      const rate = Math.round(ruleEntry.falsePositives / ruleEntry.count * 100);
+      if (rate > 40) {
+        console.log(chalk.yellow(`
+      Noisy:  ${rate}% historical false-positive rate`));
+        console.log(chalk.dim(`              Silence: memory-core allow "${rule}"`));
+        console.log(chalk.dim(`              Review all: memory-core tune`));
+      } else if (rate > 25) {
+        console.log(chalk.dim(`
+      Note:   ${rate}% false-positive rate \u2014 run: memory-core tune`));
+      }
+    }
     console.log();
-  });
+  }
   console.log(chalk.dim("  Fix the violations above, then commit again."));
   console.log(chalk.dim("  To bypass (not recommended): git commit --no-verify"));
   console.log(chalk.dim("  Env bypass: MEMORY_CORE_SKIP_HOOK=1 git commit"));
@@ -1031,35 +1369,6 @@ function printBanner(projectName, agentCount, status) {
   ];
   lines.forEach((l) => console.log(l));
 }
-async function checkConnections(dbUrl, ollamaUrl, chatModel) {
-  const spinner = ora("Checking connections\u2026").start();
-  let postgresOk = false;
-  let ollamaOk = false;
-  try {
-    const { Pool } = (await import("pg")).default;
-    const testPool = new Pool({ connectionString: dbUrl, connectionTimeoutMillis: 5e3 });
-    await testPool.query("SELECT 1");
-    await testPool.end();
-    postgresOk = true;
-  } catch {
-    postgresOk = false;
-  }
-  try {
-    const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
-    ollamaOk = res.ok;
-  } catch {
-    ollamaOk = false;
-  }
-  spinner.stop();
-  console.log(
-    postgresOk ? chalk2.green("  \u2713 PostgreSQL") + chalk2.dim(" \u2014 connected") : chalk2.red("  \u2717 PostgreSQL") + chalk2.dim(" \u2014 cannot connect. Check DATABASE_URL and that PostgreSQL is running.")
-  );
-  console.log(
-    ollamaOk ? chalk2.green("  \u2713 Ollama    ") + chalk2.dim(` \u2014 connected (${chatModel})`) : chalk2.red("  \u2717 Ollama    ") + chalk2.dim(" \u2014 not reachable. Run: ollama serve")
-  );
-  console.log();
-  return { postgresOk, ollamaOk, chatModel };
-}
 var { version } = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf-8"));
 var CONFIG_FILE = ".memory-core.json";
 var LOCAL_GENERATED_FILES = [".memory-core-stats.json"];
@@ -1108,6 +1417,7 @@ function writeRuntimeEnv(values, envPath = getEnvPath()) {
     "OLLAMA_MODEL",
     "CHAT_PROVIDER",
     "CHAT_MODEL",
+    "CHAT_BASE_URL",
     "OLLAMA_CHAT_MODEL",
     "CHAT_API_KEY"
   ];
@@ -1206,10 +1516,10 @@ function removeProjectFiles(relativePaths) {
 }
 function normalizeProvider(value) {
   const provider2 = value.trim().toLowerCase();
-  if (provider2 === "ollama" || provider2 === "openai" || provider2 === "anthropic" || provider2 === "minimax") {
+  if (provider2 === "ollama" || provider2 === "openai" || provider2 === "anthropic" || provider2 === "minimax" || provider2 === "openai-compatible") {
     return provider2;
   }
-  throw new Error(`Unsupported provider "${value}". Use: ollama, openai, anthropic, minimax`);
+  throw new Error(`Unsupported provider "${value}". Use: ollama, openai, anthropic, minimax, openai-compatible`);
 }
 function providerLabel(provider2) {
   switch (provider2) {
@@ -1219,6 +1529,8 @@ function providerLabel(provider2) {
       return "Anthropic";
     case "minimax":
       return "MiniMax";
+    case "openai-compatible":
+      return "OpenAI-compatible";
     default:
       return "Ollama";
   }
@@ -1305,6 +1617,11 @@ function buildMemoryContext(opts) {
   if (opts.source?.trim()) context.source = opts.source.trim();
   return Object.keys(context).length ? context : void 0;
 }
+function memoryReasonOrFallback(reason, content, type = "memory") {
+  const trimmed = reason?.trim();
+  if (trimmed) return trimmed;
+  return `Captured as a ${type} memory because it should be remembered: ${content}`;
+}
 function truncate(value, length) {
   if (!value) return "";
   return value.length > length ? `${value.slice(0, Math.max(0, length - 1))}\u2026` : value;
@@ -1596,16 +1913,56 @@ program.command("init").description("Initialize memory-core in the current proje
   console.log(chalk2.bold.cyan("\n  memory-core init\n"));
   const detected = detectProject();
   const quick = opts.quick ?? false;
+  let skipEnv = false;
+  let skipProject = false;
+  if (existsSync3(join3(process.cwd(), CONFIG_FILE)) && !quick) {
+    const existing = readProjectConfig();
+    const envVals = readRuntimeEnv().values;
+    console.log(chalk2.dim(`  Already initialized: ${existing?.projectName ?? "?"} (${existing?.projectType ?? "?"})`));
+    console.log(chalk2.dim(`  Provider: ${envVals.CHAT_PROVIDER ?? "ollama"}  Model: ${envVals.CHAT_MODEL ?? "llama3.2"}`));
+    console.log(chalk2.dim(`  Hook: ${existsSync3(join3(".git", "hooks", "pre-commit")) ? "installed" : "not installed"}  Agents: ${existing?.agents?.length ?? 0}
+`));
+    const reinitChoice = await select({
+      message: "Already initialized \u2014 what do you want to do?",
+      choices: [
+        { value: "full", name: "Full re-init     \u2014 update everything" },
+        { value: "connection", name: "Connection only  \u2014 update DB / provider / model" },
+        { value: "project", name: "Project only     \u2014 update arch, agents, hook" },
+        { value: "cancel", name: "Cancel" }
+      ]
+    });
+    if (reinitChoice === "cancel") {
+      await closePool();
+      process.exit(0);
+    }
+    skipEnv = reinitChoice === "project";
+    skipProject = reinitChoice === "connection";
+  }
+  let pgOk = false;
+  let ollamaOk = false;
   const envPath = join3(process.cwd(), ".memory-core.env");
   const hasEnv = existsSync3(envPath) || existsSync3(join3(process.cwd(), ".env")) || !!process.env.DATABASE_URL;
-  if (!hasEnv && quick) {
+  if (skipEnv) {
+    try {
+      const { Pool } = (await import("pg")).default;
+      const p = new Pool({ connectionString: process.env.DATABASE_URL, connectionTimeoutMillis: 3e3 });
+      await p.query("SELECT 1");
+      await p.end();
+      pgOk = true;
+    } catch {
+    }
+    try {
+      const r = await fetch(`${process.env.OLLAMA_URL ?? DEFAULT_OLLAMA_URL}/api/tags`, { signal: AbortSignal.timeout(3e3) });
+      ollamaOk = r.ok;
+    } catch {
+    }
+  } else if (!hasEnv && quick) {
     const dbUser = process.env.USER ?? process.env.USERNAME ?? "postgres";
     const dbUrl = `postgresql://${dbUser}@localhost:5432/memory_core`;
-    const ollamaUrl = DEFAULT_OLLAMA_URL;
     const chatModel = DEFAULT_CHAT_MODEL;
     const envValues = {
       DATABASE_URL: dbUrl,
-      OLLAMA_URL: ollamaUrl,
+      OLLAMA_URL: DEFAULT_OLLAMA_URL,
       OLLAMA_MODEL: DEFAULT_EMBEDDING_MODEL,
       CHAT_PROVIDER: "ollama",
       CHAT_MODEL: chatModel,
@@ -1631,6 +1988,7 @@ program.command("init").description("Initialize memory-core in the current proje
         await testPool.query("SELECT 1");
         await testPool.end();
         pgSpinner.succeed(chalk2.green("PostgreSQL connected"));
+        pgOk = true;
         break;
       } catch (err) {
         pgSpinner.fail(chalk2.red(`Cannot connect: ${err.message}`));
@@ -1640,14 +1998,15 @@ program.command("init").description("Initialize memory-core in the current proje
     let ollamaUrl = "";
     while (true) {
       ollamaUrl = await input({
-        message: "Ollama URL?",
-        default: ollamaUrl || "http://localhost:11434"
+        message: "Ollama URL (used for search embeddings)?",
+        default: ollamaUrl || DEFAULT_OLLAMA_URL
       });
       const ollamaSpinner = ora("  Testing Ollama connection\u2026").start();
       try {
         const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         ollamaSpinner.succeed(chalk2.green("Ollama connected"));
+        ollamaOk = true;
         break;
       } catch (err) {
         ollamaSpinner.fail(chalk2.red(`Cannot reach Ollama: ${err.message}`));
@@ -1660,11 +2019,16 @@ program.command("init").description("Initialize memory-core in the current proje
         { name: "Local \u2014 Ollama (no API key, free)", value: "ollama" },
         { name: "OpenAI \u2014 gpt-4o, gpt-4o-mini", value: "openai" },
         { name: "Anthropic \u2014 claude-sonnet, claude-haiku", value: "anthropic" },
-        { name: "MiniMax \u2014 MiniMax-Text-01, abab6.5s-chat", value: "minimax" }
+        { name: "MiniMax \u2014 MiniMax-Text-01, abab6.5s-chat", value: "minimax" },
+        { name: "OpenAI-compatible \u2014 Groq, DeepSeek, xAI, Mistral, Together\u2026", value: "openai-compatible" }
       ]
     });
+    if (chatProvider !== "ollama") {
+      console.log(chalk2.dim("  Note: Ollama is still used for search embeddings. Code checking uses the cloud provider above."));
+    }
     let chatModel = "";
     let chatApiKey = "";
+    let chatBaseUrl = "";
     if (chatProvider === "ollama") {
       while (true) {
         const chatModelChoice = await select({
@@ -1717,6 +2081,13 @@ program.command("init").description("Initialize memory-core in the current proje
           { name: "MiniMax-Text-01  (flagship)", value: "MiniMax-Text-01" },
           { name: "abab6.5s-chat    (fast, efficient)", value: "abab6.5s-chat" },
           { name: "Other (enter manually)", value: "__custom__" }
+        ],
+        "openai-compatible": [
+          { name: "llama-3.1-70b-versatile  (Groq)", value: "llama-3.1-70b-versatile" },
+          { name: "deepseek-coder           (DeepSeek)", value: "deepseek-coder" },
+          { name: "grok-beta                (xAI)", value: "grok-beta" },
+          { name: "mistral-large-latest     (Mistral)", value: "mistral-large-latest" },
+          { name: "Other (enter manually)", value: "__custom__" }
         ]
       };
       const modelChoice = await select({
@@ -1724,8 +2095,14 @@ program.command("init").description("Initialize memory-core in the current proje
         choices: modelChoices[chatProvider]
       });
       chatModel = modelChoice === "__custom__" ? await input({ message: "Model name?" }) : modelChoice;
+      if (chatProvider === "openai-compatible") {
+        chatBaseUrl = await input({
+          message: "API base URL?",
+          default: "https://api.groq.com/openai/v1"
+        });
+      }
       chatApiKey = await input({
-        message: `${chatProvider.charAt(0).toUpperCase() + chatProvider.slice(1)} API key?`
+        message: `${providerLabel(chatProvider)} API key?`
       });
       console.log(chalk2.green(`  \u2713 ${chatProvider} / ${chatModel} configured`));
     }
@@ -1737,19 +2114,34 @@ program.command("init").description("Initialize memory-core in the current proje
       CHAT_MODEL: chatModel
     };
     if (chatProvider === "ollama") envValues.OLLAMA_CHAT_MODEL = chatModel;
+    if (chatBaseUrl) envValues.CHAT_BASE_URL = chatBaseUrl;
     if (chatApiKey) envValues.CHAT_API_KEY = chatApiKey;
     writeRuntimeEnv(envValues, envPath);
     applyRuntimeEnv(envValues);
     ensureEnvFileIgnored(envPath);
     console.log(chalk2.green("\n  \u2713 .memory-core.env created"));
     console.log(chalk2.gray("    Added to .gitignore \u2014 your DB credentials stay local.\n"));
+  } else {
+    try {
+      const { Pool } = (await import("pg")).default;
+      const p = new Pool({ connectionString: process.env.DATABASE_URL, connectionTimeoutMillis: 3e3 });
+      await p.query("SELECT 1");
+      await p.end();
+      pgOk = true;
+    } catch {
+    }
+    try {
+      const r = await fetch(`${process.env.OLLAMA_URL ?? DEFAULT_OLLAMA_URL}/api/tags`, { signal: AbortSignal.timeout(3e3) });
+      ollamaOk = r.ok;
+    } catch {
+    }
   }
-  const projectName = quick ? process.cwd().split("/").pop() ?? "my-project" : await input({
+  const projectName = quick || skipProject ? readProjectConfig()?.projectName ?? process.cwd().split("/").pop() ?? "my-project" : await input({
     message: "Project name?",
     default: process.cwd().split("/").pop() ?? "my-project"
   });
   const inferredProjectType = ["Nuxt.js"].includes(detected.framework) ? "fullstack" : ["React", "Vue.js", "Svelte"].includes(detected.framework) ? "frontend" : "backend";
-  const projectType = quick ? inferredProjectType : await select({
+  const projectType = quick || skipProject ? readProjectConfig()?.projectType ?? inferredProjectType : await select({
     message: "Project type?",
     choices: [
       { value: "backend", name: "Backend    \u2014 API, server, microservice" },
@@ -1759,8 +2151,8 @@ program.command("init").description("Initialize memory-core in the current proje
   });
   let backendArchitecture;
   if (projectType === "backend" || projectType === "fullstack") {
-    if (quick) {
-      backendArchitecture = detected.framework === "NestJS" ? "nestjs" : detected.framework === "Laravel" ? "laravel-service-repository" : detected.framework === "Go" ? "go-api" : "clean-architecture";
+    if (quick || skipProject) {
+      backendArchitecture = readProjectConfig()?.backendArchitecture ?? (detected.framework === "NestJS" ? "nestjs" : detected.framework === "Laravel" ? "laravel-service-repository" : detected.framework === "Go" ? "go-api" : "clean-architecture");
     } else {
       const backendProfiles = listProfiles("backend");
       backendArchitecture = await select({
@@ -1774,14 +2166,14 @@ program.command("init").description("Initialize memory-core in the current proje
   }
   let frontendFramework;
   if (projectType === "frontend" || projectType === "fullstack") {
-    if (quick) {
+    if (quick || skipProject) {
       const frameworkMap = {
         "Nuxt.js": "nuxt",
         React: "react",
         "Vue.js": "vue",
         Svelte: "svelte"
       };
-      frontendFramework = frameworkMap[detected.framework] ?? "react";
+      frontendFramework = readProjectConfig()?.frontendFramework ?? (frameworkMap[detected.framework] ?? "react");
     } else {
       const frontendProfiles = listProfiles("frontend");
       frontendFramework = await select({
@@ -1793,43 +2185,20 @@ program.command("init").description("Initialize memory-core in the current proje
       });
     }
   }
-  const language = quick ? detected.language : await input({
+  const language = quick || skipProject ? readProjectConfig()?.language ?? detected.language : await input({
     message: "Language?",
     default: detected.language
   });
-  const pullMemories = quick ? true : await confirm({
-    message: "Pull relevant memories from previous projects?",
-    default: true
-  });
-  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?",
-      choices: [
-        { value: "full", name: "Full    \u2014 caveman mode (default)" },
-        { value: "lite", name: "Lite    \u2014 professional terseness" },
-        { value: "ultra", name: "Ultra   \u2014 telegraphic, minimum words" }
-      ]
-    });
-  }
   const selectedAgents = quick ? AGENT_NAMES.filter((a) => a !== "Shared") : await (async () => {
     const { checkbox } = await import("@inquirer/prompts");
+    const saved = new Set(readProjectConfig()?.agents ?? []);
     return checkbox({
       message: "Which AI agents do you want to generate files for?",
-      choices: AGENT_NAMES.filter((a) => a !== "Shared").map((name) => ({ name, value: name, checked: true })),
+      choices: AGENT_NAMES.filter((a) => a !== "Shared").map((name) => ({
+        name,
+        value: name,
+        checked: saved.size === 0 || saved.has(name)
+      })),
       instructions: "  (Space to toggle, A to select all, Enter to confirm)"
     });
   })();
@@ -1848,6 +2217,42 @@ program.command("init").description("Initialize memory-core in the current proje
       ]
     });
   }
+  let installCaveman = false;
+  let cavemanIntensity = "full";
+  if (!quick) {
+    installCaveman = await confirm({
+      message: "Enable caveman token saver? (compresses AI responses ~70%)",
+      default: false
+    });
+    if (installCaveman) {
+      cavemanIntensity = await select({
+        message: "Intensity?",
+        choices: [
+          { value: "full", name: "Full  \u2014 caveman mode (default)" },
+          { value: "lite", name: "Lite  \u2014 professional terseness" },
+          { value: "ultra", name: "Ultra \u2014 telegraphic, minimum words" }
+        ]
+      });
+    }
+  }
+  if (!quick) {
+    const envVals = readRuntimeEnv().values;
+    console.log(chalk2.bold("\n  Ready to initialize\n"));
+    console.log(`  Project   ${chalk2.white(projectName)} (${projectType})`);
+    if (backendArchitecture) console.log(`  Backend   ${chalk2.white(backendArchitecture)}`);
+    if (frontendFramework) console.log(`  Frontend  ${chalk2.white(frontendFramework)}`);
+    console.log(`  Language  ${chalk2.white(language)}`);
+    console.log(`  Provider  ${chalk2.white(envVals.CHAT_PROVIDER ?? "ollama")} / ${chalk2.white(envVals.CHAT_MODEL ?? DEFAULT_CHAT_MODEL)}`);
+    console.log(`  Agents    ${chalk2.white(String(selectedAgents.length))} selected`);
+    console.log(`  Hook      ${chalk2.white(enableHook ? hookAdvisory ? "advisory" : "strict" : "skip")}`);
+    console.log();
+    const proceed = await confirm({ message: "Generate files?", default: true });
+    if (!proceed) {
+      console.log(chalk2.yellow("  Cancelled.\n"));
+      await closePool();
+      process.exit(0);
+    }
+  }
   const config = {
     projectName,
     projectType,
@@ -1856,34 +2261,33 @@ program.command("init").description("Initialize memory-core in the current proje
     language,
     caveman: { enabled: installCaveman, intensity: cavemanIntensity },
     agents: selectedAgents,
-    allowPatterns: [],
+    allowPatterns: readProjectConfig()?.allowPatterns ?? [],
+    commitRules: readProjectConfig()?.commitRules,
     autoSync: true
   };
   let memories = [];
-  if (pullMemories) {
-    const spinner2 = ora("Retrieving relevant memories\u2026").start();
-    try {
-      const archQuery = [backendArchitecture, frontendFramework, language].filter(Boolean).join(" ");
-      const selection = await retrieveMemorySelection({
-        query: archQuery,
-        cwd: process.cwd(),
-        config,
-        limit: 20
-      });
-      memories = selection.included;
-      spinner2.succeed(`Found ${memories.length} relevant memories`);
+  try {
+    const archQuery = [backendArchitecture, frontendFramework, language].filter(Boolean).join(" ");
+    const selection = await retrieveMemorySelection({
+      query: archQuery,
+      cwd: process.cwd(),
+      config,
+      limit: 20
+    });
+    memories = selection.included;
+    if (memories.length > 0) {
+      console.log(chalk2.dim(`  Found ${memories.length} relevant memories`));
       printMemorySelection(selection);
-    } catch (err) {
-      spinner2.warn(`Could not retrieve memories: ${err.message}`);
     }
+  } catch {
   }
   if (installCaveman) {
-    const spinner2 = ora("Installing caveman token saver\u2026").start();
+    const cavemanSpinner = ora("Installing caveman token saver\u2026").start();
     try {
       await installCavemanTokenSaver();
-      spinner2.succeed("Caveman installed");
+      cavemanSpinner.succeed("Caveman installed");
     } catch (err) {
-      spinner2.warn(`Caveman install failed: ${err.message}`);
+      cavemanSpinner.warn(`Caveman install failed: ${err.message}`);
     }
   }
   const spinner = ora("Generating AI agent context files\u2026").start();
@@ -1904,12 +2308,8 @@ program.command("init").description("Initialize memory-core in the current proje
   if (enableHook) {
     installHook(hookAdvisory);
   }
-  const status = await checkConnections(
-    process.env.DATABASE_URL ?? "",
-    process.env.OLLAMA_URL ?? "http://localhost:11434",
-    process.env.OLLAMA_CHAT_MODEL ?? "llama3.2"
-  );
-  printBanner(config.projectName, written.written.length, status);
+  const chatModelForBanner = process.env.CHAT_MODEL ?? DEFAULT_CHAT_MODEL;
+  printBanner(config.projectName, written.written.length, { postgresOk: pgOk, ollamaOk, chatModel: chatModelForBanner });
   await closePool();
 });
 program.command("sync").description("Re-pull memories and regenerate AI agent files").action(async () => {
@@ -1960,27 +2360,31 @@ program.command("auto-sync [mode]").description("Show or change automatic agent
 });
 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("--applies-to <items>", "Comma-separated situations where this memory applies").option("--avoid-when <items>", "Comma-separated situations where this memory should not be used").option("--example <items>", "Comma-separated examples that teach agents how to apply this memory").option("--source <source>", "Human-readable source for this memory").option("--no-sync", "Skip automatic agent file sync after saving").action(async (text, opts) => {
   const config = readProjectConfig();
+  const scope = opts.scope?.trim() || "project";
   let reason = opts.reason;
   if (!reason) {
     reason = await input({
-      message: chalk2.dim("Why does this rule exist? (optional \u2014 helps agents debug violations)"),
+      message: chalk2.dim("Why should this memory exist?"),
       default: ""
     });
   }
+  const storedReason = memoryReasonOrFallback(reason, text, opts.type);
   const spinner = ora("Saving memory\u2026").start();
   try {
     await phase1.services.memoryEngine.remember({
       type: opts.type,
-      scope: opts.scope,
+      scope,
       architecture: config?.backendArchitecture ?? config?.frontendFramework,
-      projectName: config?.projectName,
+      projectName: scope === "project" ? config?.projectName : void 0,
       content: text,
-      reason: reason || void 0,
+      reason: storedReason,
       context: buildMemoryContext(opts),
       tags: parseTags(opts.tags)
     });
-    const reasonLine = reason ? chalk2.gray(`
-  Why: ${reason}`) : "";
+    const dbVersionPath = join3(process.cwd(), ".memory-core-db-version");
+    writeFileSync3(dbVersionPath, (/* @__PURE__ */ new Date()).toISOString() + "\n", "utf-8");
+    const reasonLine = chalk2.gray(`
+  Why: ${storedReason}`);
     spinner.succeed(chalk2.green(`Memory saved: "${text}"`) + reasonLine);
     await autoSyncGeneratedFiles(config, "remember", opts.sync);
   } catch (err) {
@@ -2067,6 +2471,8 @@ program.command("import").description(`Import memories from ${MEMORY_FILE}`).opt
     }
     spinner.succeed(`Imported ${inserted} memories, skipped ${skipped} duplicates`);
     if (inserted > 0) {
+      const dbVersionPath = join3(process.cwd(), ".memory-core-db-version");
+      writeFileSync3(dbVersionPath, (/* @__PURE__ */ new Date()).toISOString() + "\n", "utf-8");
       await autoSyncGeneratedFiles(config, "import", opts.sync);
     }
   } catch (err) {
@@ -2162,7 +2568,7 @@ program.command("edit <id>").description("Edit a memory interactively").option("
       scope,
       title: title || void 0,
       content,
-      reason: reason || void 0,
+      reason: memoryReasonOrFallback(reason, content, type),
       context: buildMemoryContext({ appliesTo, avoidWhen, example: examples, source }),
       tags: parseTags(tags)
     });
@@ -2205,6 +2611,8 @@ program.command("ignore [pattern]").description("Manage project-scoped false-pos
       content: pattern,
       tags: ["ignore"]
     });
+    const dbVersionPath = join3(process.cwd(), ".memory-core-db-version");
+    writeFileSync3(dbVersionPath, (/* @__PURE__ */ new Date()).toISOString() + "\n", "utf-8");
     console.log(chalk2.green(`Ignored pattern saved: "${pattern}"`));
     await autoSyncGeneratedFiles(config, "ignore", opts.sync);
   } catch (err) {
@@ -2244,6 +2652,61 @@ program.command("allow [pattern]").description("Manage project allow patterns in
   }));
   console.log(chalk2.green(`Allow pattern saved: "${pattern}"`));
 });
+program.command("commit-rules [pattern]").description("Manage commit message rules in .memory-core.json").option("--message <msg>", "Error message shown when rule is violated (required when adding)").option("--negate", "Pattern must NOT match (default: must match)").option("--advisory", "Warn only \u2014 do not block commit").option("--list", "List current commit rules").option("--remove <pattern>", "Remove a commit rule by pattern").action((pattern, opts) => {
+  if (opts.list) {
+    const rules = readProjectConfig()?.commitRules ?? [];
+    if (rules.length === 0) {
+      console.log(chalk2.yellow("\n  No commit rules configured.\n"));
+      return;
+    }
+    console.log(chalk2.bold("\n  Commit message rules\n"));
+    rules.forEach((rule, i) => {
+      const flags = [
+        rule.negate ? "must NOT match" : "must match",
+        rule.advisory ? "advisory" : "blocking"
+      ].join(", ");
+      console.log(`  ${i + 1}. ${rule.pattern}`);
+      console.log(chalk2.dim(`       Message: ${rule.message}`));
+      console.log(chalk2.dim(`       Flags:   ${flags}`));
+      console.log();
+    });
+    return;
+  }
+  if (opts.remove) {
+    updateProjectConfig((config) => ({
+      ...config,
+      commitRules: (config.commitRules ?? []).filter((r) => r.pattern !== opts.remove)
+    }));
+    console.log(chalk2.green(`Commit rule removed: "${opts.remove}"`));
+    return;
+  }
+  if (!pattern) {
+    console.error(chalk2.red("Provide a pattern, --list, or --remove <pattern>"));
+    process.exit(1);
+  }
+  if (!opts.message) {
+    console.error(chalk2.red("--message is required when adding a commit rule"));
+    process.exit(1);
+  }
+  try {
+    new RegExp(pattern);
+  } catch {
+    console.error(chalk2.red(`Invalid regex pattern: "${pattern}"`));
+    process.exit(1);
+  }
+  const newRule = {
+    pattern,
+    message: opts.message,
+    ...opts.negate && { negate: true },
+    ...opts.advisory && { advisory: true }
+  };
+  updateProjectConfig((config) => ({
+    ...config,
+    commitRules: [...(config.commitRules ?? []).filter((r) => r.pattern !== pattern), newRule]
+  }));
+  console.log(chalk2.green(`Commit rule saved: "${pattern}"`));
+  console.log(chalk2.dim("  Run: memory-core commit-rules --list to see all rules"));
+});
 program.command("ci-setup").description("Generate GitHub Actions workflow for memory-core").action(() => {
   const workflowPath = join3(process.cwd(), ".github", "workflows", "memory-core.yml");
   mkdirSync(dirname(workflowPath), { recursive: true });
@@ -2308,7 +2771,7 @@ program.command("uninstall").description("Remove memory-core from the current pr
     console.log(chalk2.gray("    \u2713 cleaned .gitignore memory-core block"));
   }
 });
-program.command("stats").description("Show violation counters recorded by check and watch").option("--reset", "Reset violation counters and recent history").action((opts) => {
+program.command("stats").description("Show violation counters recorded by check and watch").option("--reset", "Reset violation counters and recent history").option("--tune", "Show only noisy rules (>40% false-positive rate) with disable commands").action((opts) => {
   const statsPath = join3(process.cwd(), ".memory-core-stats.json");
   if (opts.reset) {
     const emptyStats = {
@@ -2330,14 +2793,46 @@ program.command("stats").description("Show violation counters recorded by check
     return;
   }
   const stats = JSON.parse(readFileSync3(statsPath, "utf-8"));
+  const toEntry = (raw) => {
+    if (raw === void 0) return { count: 0, falsePositives: 0 };
+    if (typeof raw === "number") return { count: raw, falsePositives: 0 };
+    return raw;
+  };
   const printTop = (label, values = {}) => {
     console.log(chalk2.bold(`
   ${label}
 `));
-    Object.entries(values).sort((a, b) => b[1] - a[1]).slice(0, 10).forEach(([name, count], index) => {
-      console.log(`  ${index + 1}. ${truncate(name, 44).padEnd(46)} ${count}`);
+    Object.entries(values).map(([name, raw]) => ({ name, entry: toEntry(raw) })).sort((a, b) => b.entry.count - a.entry.count).slice(0, 10).forEach(({ name, entry }, index) => {
+      const rate = entry.count > 0 ? Math.round(entry.falsePositives / entry.count * 100) : 0;
+      const fpHint = rate > 0 ? chalk2.dim(` \u2014 ${rate}% false-positive rate`) + (rate > 25 ? " \u26A0\uFE0F" : "") : "";
+      console.log(`  ${index + 1}. ${truncate(name, 44).padEnd(46)} ${entry.count} hits${fpHint}`);
     });
   };
+  if (opts.tune) {
+    const tuneThreshold = 40;
+    const tuneMinCount = 5;
+    const noisy = Object.entries(stats.rules ?? {}).map(([name, raw]) => ({ name, entry: toEntry(raw) })).map(({ name, entry }) => ({
+      name,
+      count: entry.count,
+      rate: entry.count > 0 ? Math.round(entry.falsePositives / entry.count * 100) : 0
+    })).filter((r) => r.rate > tuneThreshold && r.count >= tuneMinCount).sort((a, b) => b.rate - a.rate);
+    if (noisy.length === 0) {
+      console.log(chalk2.green(`
+  \u2713 No noisy rules found (threshold: ${tuneThreshold}%, min hits: ${tuneMinCount})
+`));
+      return;
+    }
+    console.log(chalk2.bold(`
+  Noisy rules (>${tuneThreshold}% false-positive rate, \u2265${tuneMinCount} hits)
+`));
+    noisy.forEach(({ name, count, rate }, i) => {
+      console.log(`  ${i + 1}. ${truncate(name, 50).padEnd(52)} ${count} hits \u2014 ${rate}% \u26A0\uFE0F`);
+      console.log(chalk2.dim(`     To disable:  memory-core allow "${name}"`));
+      console.log(chalk2.dim(`     Interactive: memory-core tune`));
+      console.log();
+    });
+    return;
+  }
   const liveRules = stats.live?.rules ?? {};
   const liveFiles = stats.live?.files ?? {};
   const hasLiveState = !!stats.live;
@@ -2361,6 +2856,87 @@ program.command("stats").description("Show violation counters recorded by check
     }
   }
 });
+program.command("tune").description("Review and disable noisy rules with high false-positive rates").option("--threshold <percent>", "False-positive rate % above which a rule is noisy (default: 40)", "40").option("--min-count <n>", "Minimum hit count required to consider a rule (default: 5)", "5").option("--yes", "Disable all noisy rules without prompting").action(async (opts) => {
+  const statsPath = join3(process.cwd(), ".memory-core-stats.json");
+  if (!existsSync3(statsPath)) {
+    console.log(chalk2.yellow("\n  No violation stats yet. Run some commits first.\n"));
+    return;
+  }
+  const threshold = Math.max(0, Math.min(100, parseInt(opts.threshold, 10) || 40));
+  const minCount = Math.max(1, parseInt(opts.minCount, 10) || 5);
+  const toEntry = (raw) => {
+    if (raw === void 0) return { count: 0, falsePositives: 0 };
+    if (typeof raw === "number") return { count: raw, falsePositives: 0 };
+    return raw;
+  };
+  const stats = JSON.parse(readFileSync3(statsPath, "utf-8"));
+  const noisy = Object.entries(stats.rules ?? {}).map(([rule, raw]) => {
+    const entry = toEntry(raw);
+    const rate = entry.count > 0 ? Math.round(entry.falsePositives / entry.count * 100) : 0;
+    return { rule, count: entry.count, rate };
+  }).filter((r) => r.rate > threshold && r.count >= minCount).sort((a, b) => b.rate - a.rate);
+  if (noisy.length === 0) {
+    console.log(chalk2.green(`
+  \u2713 All rules within acceptable noise (threshold: ${threshold}%, min hits: ${minCount})
+`));
+    return;
+  }
+  console.log(chalk2.bold(`
+  Found ${noisy.length} noisy rule${noisy.length > 1 ? "s" : ""} (>${threshold}% false-positive rate, \u2265${minCount} hits)
+`));
+  const existingAllows = new Set(
+    (readProjectConfig()?.allowPatterns ?? []).map((p) => p.toLowerCase())
+  );
+  const toAdd = /* @__PURE__ */ new Set();
+  if (opts.yes) {
+    for (const { rule, count, rate } of noisy) {
+      const key = rule.toLowerCase();
+      if (existingAllows.has(key)) {
+        console.log(chalk2.dim(`  \u2022 "${truncate(rule, 56)}" \u2014 already disabled`));
+        continue;
+      }
+      toAdd.add(key);
+      console.log(chalk2.green(`  \u2713 "${truncate(rule, 56)}"`) + chalk2.dim(` \u2014 ${count} hits, ${rate}% FP rate`));
+    }
+  } else {
+    const { select: select2 } = await import("@inquirer/prompts");
+    for (let i = 0; i < noisy.length; i++) {
+      const { rule, count, rate } = noisy[i];
+      const key = rule.toLowerCase();
+      console.log(chalk2.bold(`
+  [${i + 1}/${noisy.length}] "${truncate(rule, 60)}"`));
+      console.log(chalk2.dim(`        ${count} hits \u2014 ${rate}% false-positive rate \u26A0\uFE0F`));
+      if (existingAllows.has(key)) {
+        console.log(chalk2.dim("        Already in allow patterns \u2014 skipping"));
+        continue;
+      }
+      const choice = await select2({
+        message: "What would you like to do?",
+        choices: [
+          { name: "Disable this rule (add to allow patterns)", value: "disable" },
+          { name: "Keep it (skip for now)", value: "keep" },
+          { name: "Quit tuning", value: "quit" }
+        ]
+      });
+      if (choice === "quit") break;
+      if (choice === "disable") {
+        toAdd.add(key);
+        console.log(chalk2.green("        \u2713 Marked for disable"));
+      }
+    }
+  }
+  if (toAdd.size > 0) {
+    updateProjectConfig((config) => ({
+      ...config,
+      allowPatterns: [.../* @__PURE__ */ new Set([...config.allowPatterns ?? [], ...toAdd])]
+    }));
+    console.log(chalk2.green(`
+  \u2713 Saved ${toAdd.size} allow pattern${toAdd.size > 1 ? "s" : ""} to .memory-core.json`));
+    console.log(chalk2.dim("  These rules will no longer block commits.\n"));
+  } else {
+    console.log(chalk2.dim("\n  No changes made.\n"));
+  }
+});
 program.command("dashboard").description("Start the live Svelte dashboard with WebSocket watch events").option("-p, --port <port>", "Dashboard port", "5178").option("--path <dir>", "Directory to watch (default: current directory)").option("--no-watch", "Serve the dashboard without starting file watch").action(async (opts) => {
   const resolveDashboardPath = () => {
     if (typeof opts.path === "string" && opts.path.trim().length > 0) return opts.path;
@@ -2378,7 +2954,7 @@ program.command("dashboard").description("Start the live Svelte dashboard with W
     }
     return void 0;
   };
-  const { startDashboard } = await import("./dashboard-server-53HVL7LF.js");
+  const { startDashboard } = await import("./dashboard-server-ZBGR4CO7.js");
   await startDashboard({
     port: parseInt(opts.port, 10),
     path: resolveDashboardPath(),
@@ -2424,6 +3000,10 @@ program.command("seed").description("Load all predefined memories into the datab
       skipped++;
     }
   }
+  if (saved > 0) {
+    const dbVersionPath = join3(process.cwd(), ".memory-core-db-version");
+    writeFileSync3(dbVersionPath, (/* @__PURE__ */ new Date()).toISOString() + "\n", "utf-8");
+  }
   console.log(chalk2.bold.green(`
   Done. ${saved} memories seeded, ${skipped} skipped.
 `));
@@ -2541,7 +3121,7 @@ read:
   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) => {
+provider.command("set <name>").description("Set the code-checking provider (ollama, openai, anthropic, minimax, openai-compatible)").option("--model <model>", "Chat model to set alongside the provider").option("--api-key <key>", "API key for cloud providers").option("--base-url <url>", "API base URL for openai-compatible providers").action(async (name, opts) => {
   try {
     const providerName = normalizeProvider(name);
     const runtimeEnv = readRuntimeEnv();
@@ -2559,6 +3139,7 @@ provider.command("set <name>").description("Set the code-checking provider (olla
       values.CHAT_MODEL = model2;
       values.OLLAMA_CHAT_MODEL = model2;
       delete values.CHAT_API_KEY;
+      delete values.CHAT_BASE_URL;
     } else {
       delete values.OLLAMA_CHAT_MODEL;
       if (opts.apiKey) {
@@ -2568,6 +3149,16 @@ provider.command("set <name>").description("Set the code-checking provider (olla
           message: `${providerLabel(providerName)} API key?`
         });
       }
+      if (providerName === "openai-compatible") {
+        if (opts.baseUrl) {
+          values.CHAT_BASE_URL = opts.baseUrl;
+        } else if (!values.CHAT_BASE_URL) {
+          values.CHAT_BASE_URL = await input({
+            message: "API base URL?",
+            default: "https://api.groq.com/openai/v1"
+          });
+        }
+      }
     }
     writeRuntimeEnv(values, runtimeEnv.envPath);
     applyRuntimeEnv(values);
@@ -2775,14 +3366,20 @@ graph.command("diff <leftSnapshotId> [rightSnapshotId]").description("Diff two s
   }
 });
 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) => {
+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").option("--fast", "Use deterministic checks only in the hook").action((opts) => {
   const advisory = opts.strict ? false : true;
-  installHook(advisory);
+  installHook(advisory, opts.fast ?? false);
 });
 hook.command("uninstall").description("Remove the pre-commit hook").action(() => {
   uninstallHook();
 });
-program.command("check").description("Check staged changes against architecture rules (used by pre-commit hook)").option("--staged", "Check git staged diff (default behaviour)").option("--ci", `Check CI diff using ${MEMORY_FILE}`).option("--all", "Check all tracked source files, including already-committed files").option("--path <dir>", "Directory to check for --all mode (default: current directory)").option("--verbose", "Show model and diff details").option("--debug", "Show prompt, diff, and raw model response").action(async (opts) => {
+program.command("check").description("Check staged changes against architecture rules (used by pre-commit hook)").option("--staged", "Check git staged diff (default behaviour)").option("--ci", `Check CI diff using ${MEMORY_FILE}`).option("--all", "Check all tracked source files, including already-committed files").option("--path <dir>", "Directory to check for --all mode (default: current directory)").option("--commit-msg [file]", "Check commit message (defaults to .git/COMMIT_EDITMSG)").option("--verbose", "Show model and diff details").option("--debug", "Show prompt, diff, and raw model response").option("--fast", "Skip AI and memory retrieval; run deterministic checks only").action(async (opts) => {
+  if (opts.commitMsg !== void 0) {
+    const msgFile = typeof opts.commitMsg === "string" ? opts.commitMsg : join3(process.cwd(), ".git", "COMMIT_EDITMSG");
+    await checkCommitMsg(msgFile, { verbose: opts.verbose ?? false, debug: opts.debug ?? false });
+    await closePool();
+    return;
+  }
   if (opts.ci && opts.all) {
     console.error(chalk2.red("\n  Choose one mode: --ci or --all.\n"));
     process.exit(1);
@@ -2800,7 +3397,7 @@ program.command("check").description("Check staged changes against architecture
     if (summary.violations > 0) process.exit(1);
     return;
   }
-  await checkStaged({ verbose: opts.verbose ?? false, debug: opts.debug ?? false });
+  await checkStaged({ verbose: opts.verbose ?? false, debug: opts.debug ?? false, fast: opts.fast ?? false });
 });
 program.command("watch").description("Watch source files and check violations in real-time on every save").option("--path <dir>", "Directory to watch (default: current directory)").option("--scan-on-start", "Run an initial full snapshot scan before watching file changes").option("--verbose", "Show diff size and model details per file").option("--debug", "Show prompt, diff, and raw model response").action(async (opts) => {
   await phase1.providers.watchService.start({