memorix 1.0.2 → 1.0.4

package/dist/index.js

@@ -3,6 +3,12 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -470,7 +476,8 @@ var init_types = __esm({
       "discovery": "\u{1F7E3}",
       "why-it-exists": "\u{1F7E0}",
       "decision": "\u{1F7E4}",
-      "trade-off": "\u2696\uFE0F"
+      "trade-off": "\u2696\uFE0F",
+      "reasoning": "\u{1F9E0}"
     };
     TOPIC_KEY_FAMILIES = {
       "architecture": ["architecture", "design", "adr", "structure", "pattern"],
@@ -483,6 +490,146 @@ var init_types = __esm({
   }
 });
 
+// src/config/yaml-loader.ts
+var yaml_loader_exports = {};
+__export(yaml_loader_exports, {
+  initProjectRoot: () => initProjectRoot,
+  loadYamlConfig: () => loadYamlConfig,
+  resetYamlConfigCache: () => resetYamlConfigCache
+});
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function initProjectRoot(root) {
+  globalProjectRoot = root;
+  cachedYamlConfig = null;
+  cachedProjectRoot = null;
+}
+function loadYamlConfig(projectRoot) {
+  const resolvedRoot = projectRoot ?? globalProjectRoot ?? null;
+  if (cachedYamlConfig !== null && cachedProjectRoot === resolvedRoot) {
+    return cachedYamlConfig;
+  }
+  const userYaml = join(homedir(), ".memorix", "memorix.yml");
+  const projectYaml = resolvedRoot ? join(resolvedRoot, "memorix.yml") : null;
+  let userConfig = {};
+  let projectConfig = {};
+  if (existsSync(userYaml)) {
+    try {
+      userConfig = parseYaml(readFileSync(userYaml, "utf-8"));
+    } catch (err) {
+      console.error(`[memorix] Warning: Failed to parse ${userYaml}: ${err}`);
+    }
+  }
+  if (projectYaml && existsSync(projectYaml)) {
+    try {
+      projectConfig = parseYaml(readFileSync(projectYaml, "utf-8"));
+    } catch (err) {
+      console.error(`[memorix] Warning: Failed to parse ${projectYaml}: ${err}`);
+    }
+  }
+  cachedYamlConfig = {
+    ...userConfig,
+    ...projectConfig,
+    // Deep merge for nested objects where both exist
+    llm: { ...userConfig.llm, ...projectConfig.llm },
+    embedding: { ...userConfig.embedding, ...projectConfig.embedding },
+    git: { ...userConfig.git, ...projectConfig.git },
+    behavior: { ...userConfig.behavior, ...projectConfig.behavior },
+    server: { ...userConfig.server, ...projectConfig.server },
+    team: { ...userConfig.team, ...projectConfig.team }
+  };
+  cachedProjectRoot = resolvedRoot;
+  return cachedYamlConfig;
+}
+function resetYamlConfigCache() {
+  cachedYamlConfig = null;
+  cachedProjectRoot = null;
+}
+function parseYaml(content) {
+  try {
+    const yaml = __require("js-yaml");
+    return yaml.load(content) ?? {};
+  } catch {
+    try {
+      const matter9 = __require("gray-matter");
+      const parsed = matter9(`---
+${content}
+---`);
+      return parsed.data ?? {};
+    } catch {
+      console.error("[memorix] YAML parse failed \u2014 check memorix.yml syntax");
+      return {};
+    }
+  }
+}
+var cachedYamlConfig, cachedProjectRoot, globalProjectRoot;
+var init_yaml_loader = __esm({
+  "src/config/yaml-loader.ts"() {
+    "use strict";
+    init_esm_shims();
+    cachedYamlConfig = null;
+    cachedProjectRoot = null;
+    globalProjectRoot = null;
+  }
+});
+
+// src/config/dotenv-loader.ts
+var dotenv_loader_exports = {};
+__export(dotenv_loader_exports, {
+  getLoadedEnvFiles: () => getLoadedEnvFiles,
+  loadDotenv: () => loadDotenv,
+  resetDotenv: () => resetDotenv
+});
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { parse } from "dotenv";
+function loadEnvFile(filePath) {
+  if (!existsSync2(filePath)) return;
+  const parsed = parse(readFileSync2(filePath, "utf-8"));
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!(key in process.env)) {
+      process.env[key] = value;
+      injectedKeys.add(key);
+    }
+  }
+  loadedEnvFiles.push(filePath);
+}
+function loadDotenv(projectRoot) {
+  if (dotenvLoaded && dotenvProjectRoot === (projectRoot ?? null)) return;
+  loadedEnvFiles.length = 0;
+  if (projectRoot) {
+    loadEnvFile(join2(projectRoot, ".env"));
+  }
+  loadEnvFile(join2(homedir2(), ".memorix", ".env"));
+  dotenvLoaded = true;
+  dotenvProjectRoot = projectRoot ?? null;
+}
+function resetDotenv() {
+  for (const key of injectedKeys) {
+    delete process.env[key];
+  }
+  injectedKeys.clear();
+  dotenvLoaded = false;
+  dotenvProjectRoot = null;
+  loadedEnvFiles.length = 0;
+}
+function getLoadedEnvFiles() {
+  return loadedEnvFiles;
+}
+var dotenvLoaded, dotenvProjectRoot, loadedEnvFiles, injectedKeys;
+var init_dotenv_loader = __esm({
+  "src/config/dotenv-loader.ts"() {
+    "use strict";
+    init_esm_shims();
+    dotenvLoaded = false;
+    dotenvProjectRoot = null;
+    loadedEnvFiles = [];
+    injectedKeys = /* @__PURE__ */ new Set();
+  }
+});
+
 // src/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -491,22 +638,29 @@ __export(config_exports, {
   getEmbeddingDimensions: () => getEmbeddingDimensions,
   getEmbeddingMode: () => getEmbeddingMode,
   getEmbeddingModel: () => getEmbeddingModel,
+  getGitConfig: () => getGitConfig,
   getLLMApiKey: () => getLLMApiKey,
   getLLMBaseUrl: () => getLLMBaseUrl,
   getLLMModel: () => getLLMModel,
   getLLMProvider: () => getLLMProvider,
+  getLoadedEnvFiles: () => getLoadedEnvFiles,
+  getServerConfig: () => getServerConfig,
+  getTeamConfig: () => getTeamConfig,
+  loadDotenv: () => loadDotenv,
   loadFileConfig: () => loadFileConfig,
-  resetConfigCache: () => resetConfigCache
+  loadYamlConfig: () => loadYamlConfig,
+  resetConfigCache: () => resetConfigCache,
+  resetDotenv: () => resetDotenv
 });
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 function loadFileConfig() {
   if (cachedConfig !== null) return cachedConfig;
-  const configPath = join(homedir(), ".memorix", "config.json");
+  const configPath = join3(homedir3(), ".memorix", "config.json");
   try {
-    if (existsSync(configPath)) {
-      cachedConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (existsSync3(configPath)) {
+      cachedConfig = JSON.parse(readFileSync3(configPath, "utf-8"));
       return cachedConfig;
     }
   } catch {
@@ -518,10 +672,14 @@ function resetConfigCache() {
   cachedConfig = null;
 }
 function getLLMApiKey() {
-  return process.env.MEMORIX_LLM_API_KEY || loadFileConfig().llm?.apiKey || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.OPENROUTER_API_KEY || void 0;
+  return process.env.MEMORIX_LLM_API_KEY || // LLM-specific (优先级最高)
+  process.env.MEMORIX_API_KEY || // Unified API key (fallback)
+  loadYamlConfig().llm?.apiKey || loadFileConfig().llm?.apiKey || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.OPENROUTER_API_KEY || void 0;
 }
 function getLLMProvider() {
   if (process.env.MEMORIX_LLM_PROVIDER) return process.env.MEMORIX_LLM_PROVIDER;
+  const yml = loadYamlConfig();
+  if (yml.llm?.provider) return yml.llm.provider;
   const cfg = loadFileConfig();
   if (cfg.llm?.provider) return cfg.llm.provider;
   if (process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) return "anthropic";
@@ -529,14 +687,17 @@ function getLLMProvider() {
   return "openai";
 }
 function getLLMModel(providerDefault) {
-  return process.env.MEMORIX_LLM_MODEL || loadFileConfig().llm?.model || providerDefault;
+  return process.env.MEMORIX_LLM_MODEL || loadYamlConfig().llm?.model || loadFileConfig().llm?.model || providerDefault;
 }
 function getLLMBaseUrl(providerDefault) {
-  return process.env.MEMORIX_LLM_BASE_URL || loadFileConfig().llm?.baseUrl || providerDefault;
+  return process.env.MEMORIX_LLM_BASE_URL || loadYamlConfig().llm?.baseUrl || loadFileConfig().llm?.baseUrl || providerDefault;
 }
 function getEmbeddingMode() {
   const env = process.env.MEMORIX_EMBEDDING?.toLowerCase()?.trim();
   if (env === "fastembed" || env === "transformers" || env === "api" || env === "auto") return env;
+  const yml = loadYamlConfig();
+  const ymlEmb = yml.embedding?.provider;
+  if (ymlEmb === "fastembed" || ymlEmb === "transformers" || ymlEmb === "api" || ymlEmb === "auto") return ymlEmb;
   const cfg = loadFileConfig();
   if (cfg.embedding === "fastembed" || cfg.embedding === "transformers" || cfg.embedding === "api" || cfg.embedding === "auto") {
     return cfg.embedding;
@@ -544,26 +705,42 @@ function getEmbeddingMode() {
   return "off";
 }
 function getEmbeddingApiKey() {
-  return process.env.MEMORIX_EMBEDDING_API_KEY || loadFileConfig().embeddingApi?.apiKey || process.env.MEMORIX_LLM_API_KEY || loadFileConfig().llm?.apiKey || process.env.OPENAI_API_KEY || void 0;
+  return process.env.MEMORIX_EMBEDDING_API_KEY || // Embedding-specific (优先级最高)
+  process.env.MEMORIX_API_KEY || // Unified API key (fallback)
+  process.env.MEMORIX_LLM_API_KEY || loadYamlConfig().embedding?.apiKey || loadFileConfig().embeddingApi?.apiKey || loadYamlConfig().llm?.apiKey || loadFileConfig().llm?.apiKey || process.env.OPENAI_API_KEY || void 0;
 }
 function getEmbeddingBaseUrl() {
-  return process.env.MEMORIX_EMBEDDING_BASE_URL || loadFileConfig().embeddingApi?.baseUrl || process.env.MEMORIX_LLM_BASE_URL || loadFileConfig().llm?.baseUrl || "https://api.openai.com/v1";
+  return process.env.MEMORIX_EMBEDDING_BASE_URL || loadYamlConfig().embedding?.baseUrl || loadFileConfig().embeddingApi?.baseUrl || process.env.MEMORIX_LLM_BASE_URL || loadYamlConfig().llm?.baseUrl || loadFileConfig().llm?.baseUrl || "https://api.openai.com/v1";
 }
 function getEmbeddingModel() {
-  return process.env.MEMORIX_EMBEDDING_MODEL || loadFileConfig().embeddingApi?.model || "text-embedding-3-small";
+  return process.env.MEMORIX_EMBEDDING_MODEL || loadYamlConfig().embedding?.model || loadFileConfig().embeddingApi?.model || "text-embedding-3-small";
 }
 function getEmbeddingDimensions() {
   const envDim = process.env.MEMORIX_EMBEDDING_DIMENSIONS;
   if (envDim) return parseInt(envDim, 10);
+  const ymlDim = loadYamlConfig().embedding?.dimensions;
+  if (ymlDim) return ymlDim;
   const cfgDim = loadFileConfig().embeddingApi?.dimensions;
   if (cfgDim) return cfgDim;
   return null;
 }
+function getGitConfig() {
+  return loadYamlConfig().git ?? {};
+}
+function getServerConfig() {
+  return loadYamlConfig().server ?? {};
+}
+function getTeamConfig() {
+  return loadYamlConfig().team ?? {};
+}
 var cachedConfig;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_esm_shims();
+    init_yaml_loader();
+    init_dotenv_loader();
+    init_yaml_loader();
     cachedConfig = null;
   }
 });
@@ -575,8 +752,8 @@ __export(fastembed_provider_exports, {
 });
 import { createHash } from "crypto";
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
 function textHash(text) {
   return createHash("sha256").update(text).digest("hex").slice(0, 16);
 }
@@ -604,8 +781,8 @@ var init_fastembed_provider = __esm({
   "src/embedding/fastembed-provider.ts"() {
     "use strict";
     init_esm_shims();
-    CACHE_DIR = process.env.MEMORIX_DATA_DIR || join2(homedir2(), ".memorix", "data");
-    CACHE_FILE = join2(CACHE_DIR, ".embedding-cache.json");
+    CACHE_DIR = process.env.MEMORIX_DATA_DIR || join4(homedir4(), ".memorix", "data");
+    CACHE_FILE = join4(CACHE_DIR, ".embedding-cache.json");
     cache = /* @__PURE__ */ new Map();
     MAX_CACHE_SIZE = 5e3;
     diskCacheDirty = false;
@@ -631,8 +808,8 @@ var init_fastembed_provider = __esm({
       }
       async embed(text) {
         const hash = textHash(text);
-        const cached = cache.get(hash);
-        if (cached) return cached;
+        const cached2 = cache.get(hash);
+        if (cached2) return cached2;
         const raw = await this.model.queryEmbed(text);
         const result = Array.from(raw);
         if (result.length !== this.dimensions) {
@@ -647,9 +824,9 @@ var init_fastembed_provider = __esm({
         const uncachedTexts = [];
         for (let i = 0; i < texts.length; i++) {
           const hash = textHash(texts[i]);
-          const cached = cache.get(hash);
-          if (cached) {
-            results[i] = cached;
+          const cached2 = cache.get(hash);
+          if (cached2) {
+            results[i] = cached2;
           } else {
             uncachedIndices.push(i);
             uncachedTexts.push(texts[i]);
@@ -718,8 +895,8 @@ var init_transformers_provider = __esm({
         return new _TransformersProvider(extractor);
       }
       async embed(text) {
-        const cached = cache2.get(text);
-        if (cached) return cached;
+        const cached2 = cache2.get(text);
+        if (cached2) return cached2;
         const output = await this.extractor(text, {
           pooling: "mean",
           normalize: true
@@ -736,9 +913,9 @@ var init_transformers_provider = __esm({
         const uncachedIndices = [];
         const uncachedTexts = [];
         for (let i = 0; i < texts.length; i++) {
-          const cached = cache2.get(texts[i]);
-          if (cached) {
-            results[i] = cached;
+          const cached2 = cache2.get(texts[i]);
+          if (cached2) {
+            results[i] = cached2;
           } else {
             uncachedIndices.push(i);
             uncachedTexts.push(texts[i]);
@@ -777,8 +954,8 @@ __export(api_provider_exports, {
 });
 import { createHash as createHash2 } from "crypto";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
 function normalizeText(text) {
   return text.replace(/\s+/g, " ").trim().slice(0, MAX_INPUT_CHARS);
 }
@@ -861,8 +1038,8 @@ var init_api_provider = __esm({
   "src/embedding/api-provider.ts"() {
     "use strict";
     init_esm_shims();
-    CACHE_DIR2 = process.env.MEMORIX_DATA_DIR || join3(homedir3(), ".memorix", "data");
-    CACHE_FILE2 = join3(CACHE_DIR2, ".embedding-api-cache.json");
+    CACHE_DIR2 = process.env.MEMORIX_DATA_DIR || join5(homedir5(), ".memorix", "data");
+    CACHE_FILE2 = join5(CACHE_DIR2, ".embedding-api-cache.json");
     cache3 = /* @__PURE__ */ new Map();
     MAX_CACHE_SIZE3 = 1e4;
     diskCacheDirty2 = false;
@@ -914,7 +1091,8 @@ var init_api_provider = __esm({
           model = cfg.getEmbeddingModel();
           requestedDimensions = cfg.getEmbeddingDimensions();
         } catch {
-          apiKey = process.env.MEMORIX_EMBEDDING_API_KEY || process.env.MEMORIX_LLM_API_KEY || process.env.OPENAI_API_KEY;
+          apiKey = process.env.MEMORIX_EMBEDDING_API_KEY || process.env.MEMORIX_API_KEY || // Unified API key
+          process.env.MEMORIX_LLM_API_KEY || process.env.OPENAI_API_KEY;
           baseUrl = process.env.MEMORIX_EMBEDDING_BASE_URL || process.env.MEMORIX_LLM_BASE_URL || "https://api.openai.com/v1";
           model = process.env.MEMORIX_EMBEDDING_MODEL || "text-embedding-3-small";
           const dimStr = process.env.MEMORIX_EMBEDDING_DIMENSIONS;
@@ -952,8 +1130,8 @@ var init_api_provider = __esm({
       async embed(text) {
         const normalized = normalizeText(text);
         const hash = textHash2(normalized);
-        const cached = cache3.get(hash);
-        if (cached) return cached;
+        const cached2 = cache3.get(hash);
+        if (cached2) return cached2;
         const body = {
           model: this.config.model,
           input: normalized
@@ -982,9 +1160,9 @@ var init_api_provider = __esm({
         const uncachedTexts = [];
         for (let i = 0; i < normalizedTexts.length; i++) {
           const hash = textHash2(normalizedTexts[i]);
-          const cached = cache3.get(hash);
-          if (cached) {
-            results[i] = cached;
+          const cached2 = cache3.get(hash);
+          if (cached2) {
+            results[i] = cached2;
           } else {
             uncachedIndices.push(i);
             uncachedTexts.push(normalizedTexts[i]);
@@ -1248,6 +1426,7 @@ function detectQueryIntent(query) {
     confidence,
     typeBoosts: INTENT_TYPE_BOOSTS[bestIntent],
     fieldBoosts: INTENT_FIELD_BOOSTS[bestIntent],
+    sourceBoosts: INTENT_SOURCE_BOOSTS[bestIntent],
     preferChronological: bestIntent === "when"
   };
 }
@@ -1257,7 +1436,7 @@ function applyIntentBoost(score, type, intentResult) {
   const effectiveBoost = 1 + (boost - 1) * intentResult.confidence;
   return score * effectiveBoost;
 }
-var INTENT_PATTERNS, INTENT_TYPE_BOOSTS, INTENT_FIELD_BOOSTS;
+var INTENT_PATTERNS, INTENT_TYPE_BOOSTS, INTENT_SOURCE_BOOSTS, INTENT_FIELD_BOOSTS;
 var init_intent_detector = __esm({
   "src/search/intent-detector.ts"() {
     "use strict";
@@ -1390,6 +1569,35 @@ var init_intent_detector = __esm({
         // No special boosting
       }
     };
+    INTENT_SOURCE_BOOSTS = {
+      what_changed: {
+        git: 2,
+        // "what changed" → prefer commit-derived ground truth
+        agent: 0.8
+      },
+      when: {
+        git: 1.8,
+        // Temporal queries → git has precise timestamps
+        agent: 1
+      },
+      why: {
+        agent: 2,
+        // "why" → prefer reasoning/decision memories
+        git: 0.7
+        // commits rarely explain WHY
+      },
+      how: {
+        agent: 1.5,
+        // "how" → prefer explanations
+        git: 1
+      },
+      problem: {
+        git: 1.5,
+        // Bug fixes often in commit history
+        agent: 1.5
+        // But also in problem-solution memories
+      }
+    };
     INTENT_FIELD_BOOSTS = {
       why: {
         title: 2,
@@ -1436,7 +1644,7 @@ function normalizePath(p) {
   return normalized;
 }
 function idPriority(id) {
-  if (id.startsWith("placeholder/")) return 0;
+  if (id.startsWith("untracked/")) return 0;
   if (id.startsWith("local/")) return 1;
   return 2;
 }
@@ -1626,6 +1834,14 @@ var init_aliases = __esm({
 });
 
 // src/llm/provider.ts
+var provider_exports2 = {};
+__export(provider_exports2, {
+  callLLM: () => callLLM,
+  getLLMConfig: () => getLLMConfig,
+  initLLM: () => initLLM,
+  isLLMEnabled: () => isLLMEnabled,
+  setLLMConfig: () => setLLMConfig
+});
 function initLLM() {
   const { getLLMApiKey: getLLMApiKey2, getLLMProvider: getLLMProvider2, getLLMModel: getLLMModel2, getLLMBaseUrl: getLLMBaseUrl2 } = (init_config(), __toCommonJS(config_exports));
   const apiKey = getLLMApiKey2();
@@ -1649,6 +1865,9 @@ function isLLMEnabled() {
 function getLLMConfig() {
   return currentConfig;
 }
+function setLLMConfig(config) {
+  currentConfig = config;
+}
 async function callLLM(systemPrompt, userMessage) {
   if (!currentConfig) {
     throw new Error("LLM not configured. Set MEMORIX_LLM_API_KEY or OPENAI_API_KEY.");
@@ -1748,7 +1967,7 @@ __export(quality_exports, {
 });
 async function compressNarrative(narrative, facts, type) {
   const originalTokens = estimateTokens(narrative);
-  if (!isLLMEnabled() || narrative.length <= 80) {
+  if (!isLLMEnabled() || narrative.length <= 150) {
     return { compressed: narrative, saved: 0, usedLLM: false };
   }
   if (shouldSkipCompression(narrative, type)) {
@@ -1758,7 +1977,9 @@ async function compressNarrative(narrative, facts, type) {
     const factsContext = facts && facts.length > 0 ? `
 
 Separate facts (already stored, don't repeat): ${facts.join("; ")}` : "";
-    const response = await callLLM(COMPRESS_PROMPT, narrative + factsContext);
+    const HIGH_VALUE_TYPES = /* @__PURE__ */ new Set(["decision", "trade-off", "why-it-exists", "how-it-works"]);
+    const prompt = type && HIGH_VALUE_TYPES.has(type) ? COMPRESS_PROMPT_GENTLE : COMPRESS_PROMPT;
+    const response = await callLLM(prompt, narrative + factsContext);
     const compressed = response.content.trim();
     if (!compressed || compressed.length >= narrative.length) {
       return { compressed: narrative, saved: 0, usedLLM: true };
@@ -1830,7 +2051,7 @@ function estimateTokens(text) {
   const otherChars = text.length - cjkChars;
   return Math.ceil(cjkChars / 1.5 + otherChars / 4);
 }
-var COMPRESS_PROMPT, RERANK_PROMPT, SKIP_PATTERNS, LOW_COMPRESSION_TYPES;
+var COMPRESS_PROMPT, COMPRESS_PROMPT_GENTLE, RERANK_PROMPT, SKIP_PATTERNS, LOW_COMPRESSION_TYPES;
 var init_quality = __esm({
   "src/llm/quality.ts"() {
     "use strict";
@@ -1838,13 +2059,12 @@ var init_quality = __esm({
     init_provider2();
     COMPRESS_PROMPT = `You are a memory compression engine for a coding assistant.
 
-Compress the given narrative into the shortest possible form that preserves ALL technical facts.
+Compress the given narrative while preserving ALL technical facts and reasoning.
 
 Rules:
-- Aggressively remove: filler words, background context, debugging journey, repeated info
-- Compress to MINIMUM viable length \u2014 aim for 50% or less of original
-- Keep ONLY: specific values, file paths, error messages, version numbers, config keys, causal relationships
-- Merge related points into single dense sentences
+- Remove: filler words, debugging journey, repeated info already in facts
+- Keep: specific values, file paths, error messages, version numbers, config keys, causal relationships, design reasoning
+- Merge related points into dense sentences
 - If facts are provided separately, do NOT repeat them in the compressed narrative
 - Output the compressed text ONLY, no explanation or wrapper
 
@@ -1854,6 +2074,16 @@ Output: "JWT refresh\u65E0\u81EA\u52A8\u7EED\u7B7E\u219224h\u540E\u9759\u9ED8\u8
 
 Input: "Final deployment model for shadcn-blog is stable: GitHub Actions build locally, SCP artifacts to VPS, systemd manages the process. Docker was considered but rejected due to complexity overhead for a simple blog. The whole pipeline takes about 2 minutes from push to live."
 Output: "shadcn-blog\u90E8\u7F72: GH Actions\u6784\u5EFA\u2192SCP\u5230VPS\u2192systemd\u7BA1\u7406, \u5F03Docker(\u590D\u6742\u5EA6\u8FC7\u9AD8), push\u5230\u4E0A\u7EBF~2min"`;
+    COMPRESS_PROMPT_GENTLE = `You are a memory compression engine for a coding assistant.
+
+Lightly compress the given narrative \u2014 preserve reasoning, trade-offs, and "why" context.
+
+Rules:
+- Only remove: obvious filler, debugging detours, info already in the separate facts list
+- PRESERVE: design reasoning, rejected alternatives, trade-off analysis, causal chains
+- Aim for ~70-80% of original length, NOT aggressive compression
+- If facts are provided separately, do NOT repeat them in the compressed narrative
+- Output the compressed text ONLY, no explanation or wrapper`;
     RERANK_PROMPT = `You are a memory relevance ranker for a coding assistant.
 
 Given a QUERY (what the user/agent is looking for) and a list of CANDIDATE memories,
@@ -1867,7 +2097,7 @@ Rules:
 - Output ONLY a JSON array of IDs in order of relevance (most relevant first)
 - Include ALL candidate IDs, just reorder them
 
-Example output: [42, 15, 87, 3, 21]`;
+Example output: ["r1", "r3", "r2"]`;
     SKIP_PATTERNS = [
       /^(?:Command|Run|Execute):\s/i,
       // Shell commands
@@ -1899,11 +2129,18 @@ __export(orama_store_exports, {
   getTimeline: () => getTimeline,
   insertObservation: () => insertObservation,
   isEmbeddingEnabled: () => isEmbeddingEnabled,
+  makeOramaObservationId: () => makeOramaObservationId,
   removeObservation: () => removeObservation,
   resetDb: () => resetDb,
   searchObservations: () => searchObservations
 });
 import { create, insert, search, remove, update, count } from "@orama/orama";
+function makeOramaObservationId(projectId, observationId) {
+  return `obs-${encodeURIComponent(projectId)}-${observationId}`;
+}
+function makeEntryKey(projectId, observationId) {
+  return `${projectId ?? ""}::${observationId}`;
+}
 async function getDb() {
   if (db) return db;
   const provider2 = await getEmbeddingProvider();
@@ -1923,7 +2160,8 @@ async function getDb() {
     projectId: "string",
     accessCount: "number",
     lastAccessedAt: "string",
-    status: "string"
+    status: "string",
+    source: "string"
   };
   const dims = provider2?.dimensions ?? 384;
   const schema = embeddingEnabled ? { ...baseSchema, embedding: `vector[${dims}]` } : baseSchema;
@@ -1978,6 +2216,9 @@ async function searchObservations(options) {
   if (options.type) {
     filters["type"] = options.type;
   }
+  if (options.source) {
+    filters["source"] = options.source;
+  }
   const hasQuery = options.query && options.query.trim().length > 0;
   const intentResult = hasQuery ? detectQueryIntent(options.query) : null;
   const requestLimit = projectIds && projectIds.length > 1 ? (options.limit ?? 20) * 3 : options.limit ?? 20;
@@ -2006,7 +2247,12 @@ async function searchObservations(options) {
     try {
       const provider2 = await getEmbeddingProvider();
       if (provider2) {
-        queryVector = await provider2.embed(options.query);
+        const EMBEDDING_TIMEOUT_MS = 15e3;
+        const embedPromise = provider2.embed(options.query);
+        const timeoutPromise = new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`Embedding timeout after ${EMBEDDING_TIMEOUT_MS}ms`)), EMBEDDING_TIMEOUT_MS)
+        );
+        queryVector = await Promise.race([embedPromise, timeoutPromise]);
         const cjkRatio = (options.query.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g) || []).length / options.query.length;
         const isCJKHeavy = cjkRatio > 0.3;
         searchParams = {
@@ -2020,7 +2266,8 @@ async function searchObservations(options) {
           hybridWeights: isCJKHeavy ? { text: 0.2, vector: 0.8 } : { text: 0.6, vector: 0.4 }
         };
       }
-    } catch {
+    } catch (error) {
+      console.error("[memorix] Embedding failed or timed out, falling back to fulltext search");
     }
   }
   let results = await search(database, searchParams);
@@ -2068,7 +2315,9 @@ async function searchObservations(options) {
       icon: OBSERVATION_ICONS[obsType] ?? "\u2753",
       title: doc.title,
       tokens: doc.tokens,
-      score: (hit.score ?? 1) * recencyBoost
+      score: (hit.score ?? 1) * recencyBoost,
+      projectId: doc.projectId,
+      source: doc.source || "agent"
     };
   });
   if (intentResult && intentResult.confidence > 0.3) {
@@ -2077,6 +2326,14 @@ async function searchObservations(options) {
       score: applyIntentBoost(entry.score, entry.type, intentResult)
     }));
   }
+  if (intentResult && intentResult.confidence > 0.3 && intentResult.sourceBoosts) {
+    const srcBoosts = intentResult.sourceBoosts;
+    intermediate = intermediate.map((entry) => {
+      const boost = srcBoosts[entry.source] ?? 1;
+      const effectiveBoost = 1 + (boost - 1) * intentResult.confidence;
+      return { ...entry, score: entry.score * effectiveBoost };
+    });
+  }
   if (intentResult?.preferChronological) {
     intermediate.sort((a, b) => new Date(b.rawTime).getTime() - new Date(a.rawTime).getTime());
   } else {
@@ -2130,34 +2387,40 @@ async function searchObservations(options) {
       const narrativeMap = /* @__PURE__ */ new Map();
       for (const hit of results.hits) {
         const doc = hit.document;
-        narrativeMap.set(doc.observationId, doc.narrative);
+        narrativeMap.set(makeEntryKey(doc.projectId, doc.observationId), doc.narrative);
       }
-      const candidates = intermediate.map((e) => ({
-        id: e.id,
+      const candidates = intermediate.map((e, index) => ({
+        id: `r${index + 1}`,
         title: e.title,
         type: e.type,
         score: e.score,
-        narrative: narrativeMap.get(e.id)
+        narrative: narrativeMap.get(makeEntryKey(e.projectId, e.id))
       }));
-      const { reranked, usedLLM } = await rerankResults2(options.query, candidates);
+      const RERANK_TIMEOUT_MS = 1e4;
+      const rerankPromise = rerankResults2(options.query, candidates);
+      const timeoutPromise = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`LLM rerank timeout after ${RERANK_TIMEOUT_MS}ms`)), RERANK_TIMEOUT_MS)
+      );
+      const { reranked, usedLLM } = await Promise.race([rerankPromise, timeoutPromise]);
       if (usedLLM) {
-        const intermediateMap = new Map(intermediate.map((e) => [e.id, e]));
-        const rerankedIntermediate = reranked.map((r) => intermediateMap.get(r.id)).filter((e) => e != null);
+        const candidateMap = new Map(candidates.map((candidate, index) => [candidate.id, intermediate[index]]));
+        const rerankedIntermediate = reranked.map((r) => candidateMap.get(r.id)).filter((e) => e != null);
         if (rerankedIntermediate.length > 0) {
           intermediate = rerankedIntermediate;
         }
       }
-    } catch {
+    } catch (error) {
+      console.error("[memorix] LLM rerank failed or timed out, using original order");
     }
   }
   let entries = intermediate.map(({ rawTime: _, ...rest }) => rest);
   if (hasQuery && options.query) {
     const queryLower = options.query.toLowerCase();
     const queryTokens = queryLower.split(/\s+/).filter((t) => t.length > 1);
-    const entryMap = new Map(entries.map((e) => [e.id, e]));
+    const entryMap = new Map(entries.map((e) => [makeEntryKey(e.projectId, e.id), e]));
     for (const hit of results.hits) {
       const doc = hit.document;
-      const entry = entryMap.get(doc.observationId);
+      const entry = entryMap.get(makeEntryKey(doc.projectId, doc.observationId));
       if (!entry) continue;
       const reasons = [];
       const fields = [
@@ -2173,7 +2436,7 @@ async function searchObservations(options) {
         if (queryTokens.some((t) => valueLower.includes(t))) reasons.push(name);
       }
       if (reasons.length === 0) reasons.push("fuzzy");
-      entry["matchedFields"] = reasons;
+      entry.matchedFields = reasons;
     }
   }
   if (options.maxTokens && options.maxTokens > 0) {
@@ -2327,7 +2590,19 @@ function extractEntities(content) {
       seen.add(key);
       switch (kind) {
         case "file":
-          result.files.push(entity);
+          const isLikelyFilePath = (() => {
+            if (entity.includes("/") || entity.includes("\\")) return true;
+            if (entity.startsWith("./") || entity.startsWith("../")) return true;
+            if (/^(?:process\.env|config\.|options\.|params\.|props\.|this\.|self\.|module\.|exports\.|require\.|import\.)/i.test(entity)) return false;
+            const dotCount = (entity.match(/\./g) || []).length;
+            if (dotCount >= 2) return false;
+            const ext = entity.split(".").pop()?.toLowerCase() ?? "";
+            const FILE_EXTENSIONS = /* @__PURE__ */ new Set(["ts", "js", "tsx", "jsx", "mts", "mjs", "cjs", "json", "yaml", "yml", "toml", "xml", "csv", "py", "rb", "go", "rs", "java", "kt", "swift", "c", "cpp", "h", "html", "css", "scss", "less", "vue", "svelte", "sh", "bash", "zsh", "ps1", "cmd", "bat", "md", "txt", "rst", "log", "sql", "graphql", "prisma", "env", "gitignore", "dockerignore", "dockerfile", "lock", "config"]);
+            return FILE_EXTENSIONS.has(ext);
+          })();
+          if (isLikelyFilePath) {
+            result.files.push(entity);
+          }
           break;
         case "module":
           result.modules.push(entity);
@@ -2462,11 +2737,15 @@ async function storeObservation(input) {
     revisionCount: 1,
     sessionId: input.sessionId,
     status: "active",
-    progress: input.progress
+    progress: input.progress,
+    source: input.source,
+    commitHash: input.commitHash,
+    relatedCommits: input.relatedCommits,
+    relatedEntities: input.relatedEntities
   };
   observations.push(observation);
   const doc = {
-    id: `obs-${id}`,
+    id: makeOramaObservationId(input.projectId, id),
     observationId: id,
     entityName: input.entityName,
     type: input.type,
@@ -2480,7 +2759,8 @@ async function storeObservation(input) {
     projectId: input.projectId,
     accessCount: 0,
     lastAccessedAt: "",
-    status: "active"
+    status: "active",
+    source: input.source ?? "agent"
   };
   await insertObservation(doc);
   if (projectDir) {
@@ -2503,7 +2783,7 @@ async function storeObservation(input) {
     if (embedding) {
       try {
         const { removeObservation: removeObs } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
-        await removeObs(`obs-${id}`);
+        await removeObs(makeOramaObservationId(input.projectId, id));
         await insertObservation(Object.assign({}, doc, { embedding }));
       } catch {
       }
@@ -2539,7 +2819,7 @@ async function upsertObservation(existing, input, now) {
   if (input.sessionId) existing.sessionId = input.sessionId;
   if (input.progress) existing.progress = input.progress;
   const doc = {
-    id: `obs-${existing.id}`,
+    id: makeOramaObservationId(existing.projectId, existing.id),
     observationId: existing.id,
     entityName: existing.entityName,
     type: existing.type,
@@ -2553,11 +2833,12 @@ async function upsertObservation(existing, input, now) {
     projectId: existing.projectId,
     accessCount: 0,
     lastAccessedAt: "",
-    status: "active"
+    status: "active",
+    source: existing.source ?? "agent"
   };
   try {
     const { removeObservation: removeObservation3 } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
-    await removeObservation3(`obs-${existing.id}`);
+    await removeObservation3(makeOramaObservationId(existing.projectId, existing.id));
   } catch {
   }
   await insertObservation(doc);
@@ -2580,7 +2861,7 @@ async function upsertObservation(existing, input, now) {
     if (embedding) {
       try {
         const { removeObservation: removeObs } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
-        await removeObs(`obs-${obsId}`);
+        await removeObs(makeOramaObservationId(existing.projectId, obsId));
         await insertObservation(Object.assign({}, doc, { embedding }));
       } catch {
       }
@@ -2611,9 +2892,9 @@ async function resolveObservations(ids, status = "resolved") {
     resolved.push(id);
     try {
       const { removeObservation: removeObs } = await Promise.resolve().then(() => (init_orama_store(), orama_store_exports));
-      await removeObs(`obs-${id}`);
+      await removeObs(makeOramaObservationId(obs.projectId, id));
       const doc = {
-        id: `obs-${obs.id}`,
+        id: makeOramaObservationId(obs.projectId, obs.id),
         observationId: obs.id,
         entityName: obs.entityName,
         type: obs.type,
@@ -2627,7 +2908,8 @@ async function resolveObservations(ids, status = "resolved") {
         projectId: obs.projectId,
         accessCount: 0,
         lastAccessedAt: "",
-        status
+        status,
+        source: obs.source ?? "agent"
       };
       await insertObservation(doc);
       const obsId = obs.id;
@@ -2712,7 +2994,7 @@ async function reindexObservations() {
     const obs = observations[i];
     try {
       const embedding = embeddings[i] ?? null;
-      const docId = `obs-${obs.id}`;
+      const docId = makeOramaObservationId(obs.projectId, obs.id);
       const doc = {
         id: docId,
         observationId: obs.id,
@@ -2729,6 +3011,7 @@ async function reindexObservations() {
         accessCount: 0,
         lastAccessedAt: "",
         status: obs.status ?? "active",
+        source: obs.source ?? "agent",
         ...embedding ? { embedding } : {}
       };
       await insertObservation(doc);
@@ -2756,6 +3039,126 @@ var init_observations = __esm({
   }
 });
 
+// src/project/detector.ts
+var detector_exports = {};
+__export(detector_exports, {
+  detectProject: () => detectProject,
+  findGitInSubdirs: () => findGitInSubdirs,
+  isSystemDirectory: () => isSystemDirectory
+});
+import { execSync } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync, statSync } from "fs";
+import path5 from "path";
+function detectProject(cwd) {
+  const basePath = cwd ?? process.cwd();
+  const gitRoot = getGitRoot(basePath);
+  if (!gitRoot) {
+    return null;
+  }
+  const gitRemote = getGitRemote(gitRoot);
+  if (gitRemote) {
+    const id2 = normalizeGitRemote(gitRemote);
+    const name2 = id2.split("/").pop() ?? path5.basename(gitRoot);
+    return { id: id2, name: name2, gitRemote, rootPath: gitRoot };
+  }
+  const name = path5.basename(gitRoot);
+  const id = `local/${name}`;
+  return { id, name, rootPath: gitRoot };
+}
+function getGitRoot(cwd) {
+  let dir = path5.resolve(cwd);
+  const fsRoot = path5.parse(dir).root;
+  while (dir !== fsRoot) {
+    if (existsSync4(path5.join(dir, ".git"))) return dir;
+    dir = path5.dirname(dir);
+  }
+  try {
+    const root = execSync("git -c safe.directory=* rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim();
+    return root || null;
+  } catch {
+    return null;
+  }
+}
+function getGitRemote(cwd) {
+  const fsRemote = readGitConfigRemote(cwd);
+  if (fsRemote) return fsRemote;
+  try {
+    const remote = execSync("git -c safe.directory=* remote get-url origin", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim();
+    return remote || null;
+  } catch {
+    return null;
+  }
+}
+function readGitConfigRemote(cwd) {
+  try {
+    const configPath = path5.join(cwd, ".git", "config");
+    if (!existsSync4(configPath)) return null;
+    const content = readFileSync4(configPath, "utf-8");
+    const remoteMatch = content.match(/\[remote\s+"origin"\]([\s\S]*?)(?=\n\[|$)/);
+    if (!remoteMatch) return null;
+    const urlMatch = remoteMatch[1].match(/^\s*url\s*=\s*(.+)$/m);
+    return urlMatch ? urlMatch[1].trim() : null;
+  } catch {
+    return null;
+  }
+}
+function isSystemDirectory(dir) {
+  const lower = dir.toLowerCase().replace(/\\/g, "/");
+  return lower.includes("/windows/") || lower.endsWith("/windows") || lower.includes("/program files") || lower.includes("/appdata/") || // IDE installation directories
+  /\/(windsurf|cursor|code|vscode)\/\1/i.test(lower) || /\/windsurf\b/i.test(lower) && !lower.includes(".windsurf") || // Node / npm internal paths
+  lower.includes("/node_modules/") || lower.includes("/nvm") || // System root
+  /^[a-z]:\/$/i.test(lower);
+}
+function findGitInSubdirs(dir) {
+  try {
+    const resolved = path5.resolve(dir);
+    const entries = readdirSync(resolved);
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const fullPath = path5.join(resolved, entry);
+      try {
+        if (statSync(fullPath).isDirectory() && existsSync4(path5.join(fullPath, ".git"))) {
+          return fullPath;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function normalizeGitRemote(remote) {
+  let normalized = remote;
+  normalized = normalized.replace(/\.git$/, "");
+  const sshMatch = normalized.match(/^[\w-]+@[\w.-]+:(.+)$/);
+  if (sshMatch) {
+    return sshMatch[1];
+  }
+  try {
+    const url = new URL(normalized);
+    return url.pathname.replace(/^\//, "");
+  } catch {
+    const segments = normalized.split("/").filter(Boolean);
+    return segments.slice(-2).join("/");
+  }
+}
+var init_detector = __esm({
+  "src/project/detector.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/llm/memory-manager.ts
 var memory_manager_exports = {};
 __export(memory_manager_exports, {
@@ -2883,59 +3286,994 @@ function mergeFacts(oldFactsStr, newFactsStr) {
       merged.push(f);
     }
   }
-  return merged;
+  return merged;
+}
+async function deduplicateMemory(newMemory, existingMemories) {
+  if (!isLLMEnabled()) return null;
+  if (existingMemories.length === 0) return { action: "ADD", reason: "No existing memories", usedLLM: false };
+  const asExisting = existingMemories.map((m) => ({
+    ...m,
+    score: 0.8
+    // Batch dedup assumes high similarity (pre-filtered)
+  }));
+  return compactOnWrite(newMemory, asExisting);
+}
+var COMPACT_ON_WRITE_PROMPT, SIMILARITY_HIGH, SIMILARITY_MEDIUM;
+var init_memory_manager = __esm({
+  "src/llm/memory-manager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_provider2();
+    COMPACT_ON_WRITE_PROMPT = `You are a smart coding memory manager. You control the memory of a cross-IDE coding assistant.
+
+You receive a NEW MEMORY to store and a list of EXISTING similar memories. Your job:
+1. Extract the key facts from the new memory
+2. Compare with existing memories
+3. Decide the best action
+
+Actions:
+- ADD: New memory contains unique information. Store it as-is.
+- UPDATE: New memory supersedes or improves an existing one. Merge them into a single, comprehensive memory.
+- DELETE: An existing memory is outdated/contradicted by the new one. Remove it.
+- NONE: New memory is redundant. Existing memories already cover this. Skip storing.
+
+Decision rules:
+- Same topic updated (e.g., "MySQL \u2192 PostgreSQL"): UPDATE the old memory with merged content
+- Bug fixed that was reported as open: UPDATE the bug report to include the fix
+- Task completed that was tracked as in-progress: UPDATE to mark completed
+- Minor variation of existing memory: NONE (skip)
+- Completely new topic: ADD
+- Old info directly contradicted: DELETE the old one
+- Prefer UPDATE over ADD \u2014 keep memory count low, merge information
+
+For UPDATE: write a merged narrative that combines the best of both old and new, preserving all important details. Also merge the facts lists, removing duplicates.
+
+Respond in JSON only:
+{
+  "action": "ADD" | "UPDATE" | "DELETE" | "NONE",
+  "targetId": null or existing_memory_id_number,
+  "reason": "brief explanation of decision",
+  "mergedNarrative": "merged narrative text (required for UPDATE, null otherwise)",
+  "mergedFacts": ["merged fact 1", "merged fact 2"] or null,
+  "extractedFacts": ["fact extracted from new content 1", "fact 2"]
+}`;
+    SIMILARITY_HIGH = 0.75;
+    SIMILARITY_MEDIUM = 0.5;
+  }
+});
+
+// src/memory/formation/extract.ts
+function extractFacts(narrative, existingFacts) {
+  const existingLower = new Set(existingFacts.map((f) => f.toLowerCase().trim()));
+  const extracted = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { pattern, format } of FACT_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(narrative)) !== null) {
+      const fact = format(match);
+      const normalized = fact.toLowerCase().trim();
+      if (existingLower.has(normalized) || seen.has(normalized)) continue;
+      if (fact.length < 5 || fact.length > 120) continue;
+      seen.add(normalized);
+      extracted.push(fact);
+    }
+  }
+  return extracted.slice(0, 10);
+}
+function improveTitle(title, narrative) {
+  const isGeneric = GENERIC_TITLE_PATTERNS.some((p) => p.test(title));
+  if (!isGeneric) return { title, improved: false };
+  const sentences = narrative.replace(/```[\s\S]*?```/g, "").split(/[.。!！?\n]/).map((s) => s.trim()).filter((s) => s.length >= 15);
+  if (sentences.length > 0) {
+    return { title: sentences[0].slice(0, 60), improved: true };
+  }
+  return { title, improved: false };
+}
+function resolveEntity(entityName, existingEntities) {
+  if (existingEntities.length === 0) return { entityName, resolved: false };
+  const lower = entityName.toLowerCase().replace(/[-_]/g, "");
+  for (const existing of existingEntities) {
+    const existingLower = existing.toLowerCase().replace(/[-_]/g, "");
+    if (lower === existingLower) {
+      return { entityName: existing, resolved: existing !== entityName };
+    }
+    if (lower.length >= 3 && existingLower.length >= 3) {
+      if (existingLower.includes(lower) || lower.includes(existingLower)) {
+        const canonical = existing.length >= entityName.length ? existing : entityName;
+        return { entityName: canonical, resolved: canonical !== entityName };
+      }
+    }
+  }
+  return { entityName, resolved: false };
+}
+function verifyType(declaredType, narrative, title) {
+  const content = `${title} ${narrative}`;
+  const scores = [];
+  for (const { type, patterns } of TYPE_SIGNALS) {
+    let score = 0;
+    for (const p of patterns) {
+      const regex = new RegExp(p.source, p.flags.includes("g") ? p.flags : p.flags + "g");
+      const matches = [...content.matchAll(regex)];
+      score += matches.length;
+    }
+    if (score > 0) scores.push({ type, score });
+  }
+  if (scores.length === 0) return { type: declaredType, corrected: false };
+  scores.sort((a, b) => b.score - a.score);
+  const best = scores[0];
+  if (best.type !== declaredType && best.score >= 2) {
+    const declaredScore = scores.find((s) => s.type === declaredType)?.score ?? 0;
+    if (declaredScore === 0) {
+      return { type: best.type, corrected: true };
+    }
+  }
+  return { type: declaredType, corrected: false };
+}
+async function extractFactsWithLLM(narrative, title, existingFacts) {
+  try {
+    const { callLLM: callLLM2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
+    const input = `Title: ${title}
+Content: ${narrative}${existingFacts.length > 0 ? `
+Already known facts (don't repeat): ${existingFacts.join("; ")}` : ""}`;
+    const response = await callLLM2(LLM_EXTRACT_PROMPT, input);
+    const text = response.content.trim();
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return [];
+    const parsed = JSON.parse(jsonMatch[0]);
+    const facts = parsed.facts;
+    if (!Array.isArray(facts)) return [];
+    const existingLower = new Set(existingFacts.map((f) => f.toLowerCase().trim()));
+    return facts.filter((f) => typeof f === "string" && f.length >= 5).filter((f) => !existingLower.has(f.toLowerCase().trim())).slice(0, 10);
+  } catch {
+    return [];
+  }
+}
+async function runExtract(input, existingEntities, useLLM = false) {
+  const callerFacts = input.facts ?? [];
+  let extractedFacts;
+  if (useLLM) {
+    extractedFacts = await extractFactsWithLLM(input.narrative, input.title, callerFacts);
+    if (extractedFacts.length === 0) {
+      extractedFacts = extractFacts(input.narrative, callerFacts);
+    }
+  } else {
+    extractedFacts = extractFacts(input.narrative, callerFacts);
+  }
+  const allFacts = [...callerFacts, ...extractedFacts];
+  const { title, improved: titleImproved } = improveTitle(input.title, input.narrative);
+  const { entityName, resolved: entityResolved } = resolveEntity(
+    input.entityName,
+    existingEntities
+  );
+  const { type, corrected: typeCorrected } = verifyType(
+    input.type,
+    input.narrative,
+    input.title
+  );
+  return {
+    title,
+    titleImproved,
+    narrative: input.narrative,
+    facts: allFacts,
+    extractedFacts,
+    entityName,
+    entityResolved,
+    type,
+    typeCorrected
+  };
+}
+var FACT_PATTERNS, GENERIC_TITLE_PATTERNS, TYPE_SIGNALS, LLM_EXTRACT_PROMPT;
+var init_extract = __esm({
+  "src/memory/formation/extract.ts"() {
+    "use strict";
+    init_esm_shims();
+    FACT_PATTERNS = [
+      // Key: Value pairs (e.g., "Port: 3000", "Timeout = 60s")
+      {
+        pattern: /\b([A-Z][a-zA-Z_-]{2,30})\s*[:=]\s*([^\n,;]{2,60})/g,
+        format: (m) => `${m[1]}: ${m[2].trim()}`
+      },
+      // Arrow notation (e.g., "MySQL → PostgreSQL", "v1.0 → v2.0")
+      {
+        pattern: /\b(\S{2,30})\s*[→➜\->]+\s*(\S{2,30})/g,
+        format: (m) => `${m[1]} \u2192 ${m[2]}`
+      },
+      // Version numbers (e.g., "v1.2.3", "version 2.0")
+      {
+        pattern: /\b(?:v(?:ersion)?\s*)(\d+\.\d+(?:\.\d+)?(?:-[\w.]+)?)\b/gi,
+        format: (m) => `Version: ${m[1]}`
+      },
+      // Error messages (e.g., "Error: ...", "ERR_...")
+      {
+        pattern: /\b(?:Error|ERR|ENOENT|ECONNREFUSED|TypeError|RangeError|SyntaxError|ReferenceError)[:\s]+([^\n]{5,80})/gi,
+        format: (m) => `Error: ${m[1].trim()}`
+      },
+      // Port numbers in context
+      {
+        pattern: /\b(?:port|PORT)\s*[:=]?\s*(\d{2,5})\b/gi,
+        format: (m) => `Port: ${m[1]}`
+      },
+      // Environment variables
+      {
+        pattern: /\b([A-Z][A-Z0-9_]{3,30})\s*=\s*(\S{1,60})/g,
+        format: (m) => `${m[1]}=${m[2]}`
+      },
+      // npm/package versions (e.g., "react@18.2.0")
+      {
+        pattern: /\b([@a-z][\w./-]+)@(\d+\.\d+\.\d+(?:-[\w.]+)?)\b/g,
+        format: (m) => `${m[1]}@${m[2]}`
+      }
+    ];
+    GENERIC_TITLE_PATTERNS = [
+      /^Updated \S+\.\w+$/i,
+      /^Created \S+\.\w+$/i,
+      /^Deleted \S+\.\w+$/i,
+      /^Modified \S+\.\w+$/i,
+      /^Changed \S+\.\w+$/i,
+      /^Session activity/i,
+      /^Activity \(/i,
+      /^Used \w+$/i,
+      /^Ran: /i
+    ];
+    TYPE_SIGNALS = [
+      {
+        type: "problem-solution",
+        patterns: [
+          /\b(fix|fixed|bug|error|issue|crash|broken|resolved|workaround|patch)\b/i,
+          /\b(修复|修正|解决|报错|崩溃|异常)\b/
+        ]
+      },
+      {
+        type: "gotcha",
+        patterns: [
+          /\b(gotcha|pitfall|trap|careful|warning|caveat|footgun|unexpected|beware)\b/i,
+          /\b(坑|陷阱|注意|小心|踩坑)\b/
+        ]
+      },
+      {
+        type: "decision",
+        patterns: [
+          /\b(decided|chose|chosen|selected|adopted|rejected|evaluated|compared)\b/i,
+          /\b(决定|选择|采用|弃用|对比|评估)\b/
+        ]
+      },
+      {
+        type: "what-changed",
+        patterns: [
+          /\b(changed|migrated|upgraded|refactored|replaced|renamed|moved|removed|added)\b/i,
+          /\b(改|迁移|升级|重构|替换|重命名|删除|新增)\b/
+        ]
+      },
+      {
+        type: "how-it-works",
+        patterns: [
+          /\b(works by|architecture|mechanism|pipeline|flow|under the hood|internally)\b/i,
+          /\b(原理|机制|流程|架构|内部)\b/
+        ]
+      },
+      {
+        type: "trade-off",
+        patterns: [
+          /\b(trade.?off|compromise|downside|cost|benefit|pro|con|versus|vs)\b/i,
+          /\b(权衡|折中|代价|收益|优缺点)\b/
+        ]
+      }
+    ];
+    LLM_EXTRACT_PROMPT = `You are a Software Engineering Knowledge Extractor.
+Extract structured facts from the given development context.
+
+Focus on:
+1. Technical decisions and their reasoning
+2. Bug root causes and fixes
+3. Configuration values (ports, versions, env vars)
+4. Architecture patterns and constraints
+5. Gotchas, pitfalls, and workarounds
+6. File paths and their roles
+
+Rules:
+- Return ONLY a JSON object with a "facts" key containing an array of strings
+- Each fact should be a concise, self-contained statement
+- Include specific values (versions, ports, paths) when present
+- Detect the language of the input and record facts in the same language
+- If no meaningful facts exist, return {"facts": []}
+- Do NOT include trivial information (file read, directory listing)
+- Maximum 10 facts
+
+Example:
+Input: "Fixed Redis connection leak. The pool wasn't being closed on shutdown. Added defer pool.Close() in main.go. Port 6379."
+Output: {"facts": ["Redis connection leak caused by pool not closed on shutdown", "Fix: added defer pool.Close() in main.go", "Redis port: 6379"]}`;
+  }
+});
+
+// src/memory/formation/resolve.ts
+function wordOverlap(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  return intersection / Math.max(wordsA.size, wordsB.size);
+}
+function entitiesMatch(a, b) {
+  const na = a.toLowerCase().replace(/[-_]/g, "");
+  const nb = b.toLowerCase().replace(/[-_]/g, "");
+  if (na === nb) return true;
+  if (na.length >= 3 && nb.length >= 3) {
+    if (na.includes(nb) || nb.includes(na)) return true;
+  }
+  return false;
+}
+function hasContradiction(oldText, newText) {
+  const negationPatterns = [
+    /\bnot\s+(\w+)/gi,
+    /\bno longer\b/i,
+    /\binstead of\b/i,
+    /\breplaced\b.*\bwith\b/i,
+    /\bremoved\b/i,
+    /\bdeprecated\b/i,
+    /\bobsolete\b/i,
+    /不再/,
+    /已弃用/,
+    /替换为/,
+    /改为/
+  ];
+  return negationPatterns.some((p) => p.test(newText));
+}
+function mergeNarratives(oldNarrative, newNarrative) {
+  if (newNarrative.length > oldNarrative.length * 1.5) return newNarrative;
+  if (oldNarrative.length > newNarrative.length * 1.5) return oldNarrative;
+  return `${newNarrative}
+
+[Previous context]: ${oldNarrative}`;
+}
+function mergeFacts2(oldFacts, newFacts) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const f of newFacts) {
+    const norm = f.toLowerCase().trim();
+    if (!seen.has(norm) && f.trim().length > 0) {
+      seen.add(norm);
+      merged.push(f);
+    }
+  }
+  for (const f of oldFacts) {
+    const norm = f.toLowerCase().trim();
+    if (!seen.has(norm) && f.trim().length > 0) {
+      seen.add(norm);
+      merged.push(f);
+    }
+  }
+  return merged;
+}
+async function resolveWithLLM(extracted, hits, getObservation2) {
+  try {
+    const { callLLM: callLLM2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
+    const existingMemories = hits.slice(0, 5).map((h, i) => ({
+      id: h.observationId,
+      index: i,
+      title: h.title,
+      content: h.narrative.substring(0, 300),
+      facts: h.facts.substring(0, 200)
+    }));
+    const input = `NEW MEMORY:
+Title: ${extracted.title}
+Content: ${extracted.narrative.substring(0, 500)}
+Facts: ${extracted.facts.join("; ")}
+
+EXISTING MEMORIES:
+${existingMemories.map((m) => `[ID:${m.id}] ${m.title} | ${m.content} | Facts: ${m.facts}`).join("\n")}`;
+    const response = await callLLM2(LLM_RESOLVE_PROMPT, input);
+    const text = response.content.trim();
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return null;
+    const parsed = JSON.parse(jsonMatch[0]);
+    const action = parsed.action?.toUpperCase();
+    const targetId = parsed.targetId ? Number(parsed.targetId) : void 0;
+    const reason = parsed.reason || "LLM decision";
+    if (action === "NOOP") {
+      return { action: "discard", targetId, reason: `LLM: ${reason}` };
+    }
+    if (action === "ADD") {
+      return { action: "new", reason: `LLM: ${reason}` };
+    }
+    if (action === "UPDATE" && targetId) {
+      const existing = getObservation2(targetId);
+      const oldFacts = existing?.facts ?? [];
+      return {
+        action: "merge",
+        targetId,
+        reason: `LLM: ${reason}`,
+        mergedNarrative: parsed.mergedText || mergeNarratives(existing?.narrative ?? "", extracted.narrative),
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+    if (action === "DELETE" && targetId) {
+      const existing = getObservation2(targetId);
+      const oldFacts = existing?.facts ?? [];
+      return {
+        action: "evolve",
+        targetId,
+        reason: `LLM: ${reason}`,
+        mergedNarrative: extracted.narrative,
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function scoreCandidate(extracted, candidate) {
+  const entityMatch = entitiesMatch(extracted.entityName, candidate.entityName);
+  const contentOverlap = wordOverlap(
+    `${extracted.title} ${extracted.narrative}`,
+    `${candidate.title} ${candidate.narrative}`
+  );
+  const score = candidate.score * 0.6 + (entityMatch ? 0.2 : 0) + contentOverlap * 0.2;
+  const newLength = extracted.narrative.length + extracted.facts.join(" ").length;
+  const oldLength = candidate.narrative.length + candidate.facts.length;
+  const richer = newLength > oldLength * 1.15;
+  const contradiction = hasContradiction(candidate.narrative, extracted.narrative);
+  return { score, entityMatch, richer, contradiction };
+}
+async function runResolve(extracted, projectId, searchMemories, getObservation2, useLLM = false) {
+  const query = `${extracted.title} ${extracted.narrative.substring(0, 200)}`;
+  let hits;
+  try {
+    hits = await searchMemories(query, 5, projectId);
+  } catch {
+    return { action: "new", reason: "Search unavailable, defaulting to new" };
+  }
+  if (hits.length === 0) {
+    return { action: "new", reason: "No similar existing memories found" };
+  }
+  if (useLLM) {
+    const llmResult = await resolveWithLLM(extracted, hits, getObservation2);
+    if (llmResult) return llmResult;
+  }
+  const scored = hits.map((hit) => ({
+    hit,
+    ...scoreCandidate(extracted, hit)
+  }));
+  scored.sort((a, b) => b.score - a.score);
+  const best = scored[0];
+  if (best.hit.score >= SIMILARITY_DUPLICATE) {
+    if (best.richer) {
+      const existing = getObservation2(best.hit.observationId);
+      const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
+      return {
+        action: "evolve",
+        targetId: best.hit.observationId,
+        reason: `Near-duplicate of #${best.hit.observationId} but richer content (score: ${best.score.toFixed(2)})`,
+        mergedNarrative: mergeNarratives(best.hit.narrative, extracted.narrative),
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+    return {
+      action: "discard",
+      targetId: best.hit.observationId,
+      reason: `Duplicate of #${best.hit.observationId} (score: ${best.score.toFixed(2)})`
+    };
+  }
+  if (best.score >= SIMILARITY_HIGH2) {
+    if (best.contradiction) {
+      const existing = getObservation2(best.hit.observationId);
+      const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
+      return {
+        action: "evolve",
+        targetId: best.hit.observationId,
+        reason: `Supersedes #${best.hit.observationId}: contradiction detected (score: ${best.score.toFixed(2)})`,
+        mergedNarrative: extracted.narrative,
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+    if (best.richer) {
+      const existing = getObservation2(best.hit.observationId);
+      const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
+      return {
+        action: "merge",
+        targetId: best.hit.observationId,
+        reason: `Merging with #${best.hit.observationId}: same topic, new content is richer (score: ${best.score.toFixed(2)})`,
+        mergedNarrative: mergeNarratives(best.hit.narrative, extracted.narrative),
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+    return {
+      action: "discard",
+      targetId: best.hit.observationId,
+      reason: `Already covered by #${best.hit.observationId} (score: ${best.score.toFixed(2)})`
+    };
+  }
+  if (best.score >= SIMILARITY_MEDIUM2 && best.entityMatch) {
+    const existing = getObservation2(best.hit.observationId);
+    const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
+    const newFactCount = extracted.facts.length;
+    const oldFactCount = oldFacts.length;
+    if (newFactCount > oldFactCount) {
+      return {
+        action: "merge",
+        targetId: best.hit.observationId,
+        reason: `Same entity "${extracted.entityName}", new memory has more facts (${newFactCount} > ${oldFactCount})`,
+        mergedNarrative: mergeNarratives(best.hit.narrative, extracted.narrative),
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+  }
+  return { action: "new", reason: `Different from existing memories (best score: ${best.score.toFixed(2)})` };
+}
+var SIMILARITY_HIGH2, SIMILARITY_MEDIUM2, SIMILARITY_DUPLICATE, LLM_RESOLVE_PROMPT;
+var init_resolve = __esm({
+  "src/memory/formation/resolve.ts"() {
+    "use strict";
+    init_esm_shims();
+    SIMILARITY_HIGH2 = 0.75;
+    SIMILARITY_MEDIUM2 = 0.5;
+    SIMILARITY_DUPLICATE = 0.9;
+    LLM_RESOLVE_PROMPT = `You are a Memory Consolidation Manager for a software engineering knowledge base.
+
+You must decide what to do with a NEW memory given EXISTING memories that are similar.
+
+Operations:
+- ADD: The new memory contains genuinely new information not present in existing memories.
+- UPDATE: The new memory adds to or refines an existing memory. Specify which existing memory ID to update.
+- DELETE: The new memory contradicts an existing memory. Specify which existing memory ID to delete.
+- NOOP: The new memory is redundant (already covered by existing memories). Skip storage.
+
+Rules:
+- Return ONLY a JSON object
+- If UPDATE: merge the best information from both old and new
+- If DELETE: the new memory supersedes the old (contradiction detected)
+- Prefer UPDATE over ADD when the topic is the same but information differs
+- Prefer NOOP over ADD when the information is essentially the same
+
+Response format:
+{"action": "ADD|UPDATE|DELETE|NOOP", "targetId": <number or null>, "reason": "<brief explanation>", "mergedText": "<merged content for UPDATE, or null>"}`;
+  }
+});
+
+// src/memory/formation/evaluate.ts
+function factDensity(facts, narrativeLength) {
+  if (narrativeLength === 0) return 0;
+  const structuredChars = facts.reduce((sum, f) => sum + f.length, 0);
+  return Math.min(1, structuredChars / Math.max(narrativeLength, 100));
+}
+function specificityScore(content) {
+  let count2 = 0;
+  for (const p of SPECIFICITY_PATTERNS) {
+    p.lastIndex = 0;
+    if (p.test(content)) count2++;
+  }
+  return Math.min(1, count2 / 3);
+}
+function causalScore(content) {
+  let count2 = 0;
+  for (const p of CAUSAL_PATTERNS) {
+    p.lastIndex = 0;
+    if (p.test(content)) count2++;
+  }
+  return Math.min(1, count2 / 2);
+}
+function noiseScore(title, narrative) {
+  let noisiness = 0;
+  for (const p of NOISE_PATTERNS) {
+    if (p.test(title)) {
+      noisiness += 0.3;
+      break;
+    }
+  }
+  const lines = narrative.split("\n").filter((l) => l.trim().length > 0);
+  let toolOutputLines = 0;
+  for (const line of lines) {
+    for (const p of TOOL_OUTPUT_PATTERNS) {
+      if (p.test(line)) {
+        toolOutputLines++;
+        break;
+      }
+    }
+  }
+  if (lines.length > 0) {
+    noisiness += toolOutputLines / lines.length * 0.5;
+  }
+  if (narrative.length < 50) noisiness += 0.2;
+  return Math.min(1, noisiness);
+}
+function categorize(score) {
+  if (score >= 0.6) return "core";
+  if (score >= 0.35) return "contextual";
+  return "ephemeral";
+}
+function buildReason(typeWeight, factDens, specificity, causal, noise, category) {
+  const parts = [];
+  if (typeWeight >= 0.7) parts.push("high-value type");
+  else if (typeWeight <= 0.45) parts.push("low-value type");
+  if (factDens > 0.3) parts.push("fact-dense");
+  if (specificity > 0.3) parts.push("specific (versions/codes/paths)");
+  if (causal > 0.3) parts.push("causal reasoning");
+  if (noise > 0.3) parts.push("noisy content");
+  const detail = parts.length > 0 ? parts.join(", ") : "average content";
+  return `${category}: ${detail}`;
+}
+function runEvaluate(extracted) {
+  const content = `${extracted.title} ${extracted.narrative} ${extracted.facts.join(" ")}`;
+  const typeWeight = TYPE_WEIGHTS[extracted.type] ?? 0.5;
+  const factDens = factDensity(extracted.facts, extracted.narrative.length);
+  const specificity = specificityScore(content);
+  const causal = causalScore(content);
+  const noise = noiseScore(extracted.title, extracted.narrative);
+  const rawScore = typeWeight * 0.5 + factDens * 0.12 + specificity * 0.12 + causal * 0.12 - noise * 0.14;
+  const extractionBonus = extracted.extractedFacts.length > 0 ? 0.05 : 0;
+  const titlePenalty = extracted.titleImproved ? -0.03 : 0;
+  const correctionBonus = extracted.typeCorrected ? 0.03 : 0;
+  const score = Math.max(0, Math.min(1, rawScore + extractionBonus + titlePenalty + correctionBonus));
+  const category = categorize(score);
+  const reason = buildReason(typeWeight, factDens, specificity, causal, noise, category);
+  return { score, category, reason };
+}
+var TYPE_WEIGHTS, SPECIFICITY_PATTERNS, CAUSAL_PATTERNS, NOISE_PATTERNS, TOOL_OUTPUT_PATTERNS;
+var init_evaluate = __esm({
+  "src/memory/formation/evaluate.ts"() {
+    "use strict";
+    init_esm_shims();
+    TYPE_WEIGHTS = {
+      "gotcha": 0.85,
+      "decision": 0.8,
+      "problem-solution": 0.75,
+      "trade-off": 0.7,
+      "reasoning": 0.7,
+      "why-it-exists": 0.65,
+      "how-it-works": 0.6,
+      "discovery": 0.55,
+      "what-changed": 0.45,
+      "session-request": 0.4
+    };
+    SPECIFICITY_PATTERNS = [
+      /\b\d+\.\d+\.\d+\b/,
+      // Semantic version numbers
+      /\b(ERR_|ENOENT|ECONNREFUSED|E[A-Z]{3,})\b/,
+      // Error codes
+      /\b(port|PORT)\s*[:=]?\s*\d{2,5}\b/i,
+      // Port numbers
+      /\bhttps?:\/\/\S+/,
+      // URLs
+      /`[^`]{3,60}`/,
+      // Inline code references
+      /\b[A-Z][A-Z0-9_]{3,}\b/,
+      // Constants (e.g., MAX_RETRIES)
+      /\b\d+\s*(ms|s|sec|min|MB|GB|KB)\b/i
+      // Measurements with units
+    ];
+    CAUSAL_PATTERNS = [
+      /\b(because|therefore|due to|caused by|as a result|fixed by|resolved by)\b/i,
+      /\b(so that|in order to|leads to|results in|prevents)\b/i,
+      /(?:因为|所以|由于|导致|造成|因此|为了|解决)/
+    ];
+    NOISE_PATTERNS = [
+      /^Session activity/i,
+      /^Updated \S+\.\w+$/i,
+      /^Created \S+\.\w+$/i,
+      /^Deleted \S+\.\w+$/i,
+      /^File written successfully/i,
+      /^Command executed/i,
+      /^Tool: (read_file|list_dir|find_by_name)/i,
+      /^\s*$/
+    ];
+    TOOL_OUTPUT_PATTERNS = [
+      /^(file|directory|folder)\s+(created|deleted|moved|copied)/i,
+      /^Successfully\s+(installed|updated|removed)/i,
+      /^\d+ files? changed/i,
+      /^npm (WARN|notice)/i,
+      /^\s*at\s+\S+\s+\(/
+      // Stack trace lines
+    ];
+  }
+});
+
+// src/memory/formation/index.ts
+var formation_exports = {};
+__export(formation_exports, {
+  clearFormationMetrics: () => clearFormationMetrics,
+  getBeforeAfterMetrics: () => getBeforeAfterMetrics,
+  getFormationMetrics: () => getFormationMetrics,
+  getMetricsSummary: () => getMetricsSummary,
+  recordBeforeAfterMetrics: () => recordBeforeAfterMetrics,
+  runFormation: () => runFormation
+});
+function getFormationMetrics() {
+  return metricsBuffer;
+}
+function clearFormationMetrics() {
+  metricsBuffer.length = 0;
+}
+function recordBeforeAfterMetrics(data) {
+  if (beforeAfterBuffer.length >= MAX_BEFORE_AFTER_BUFFER) {
+    beforeAfterBuffer.shift();
+  }
+  beforeAfterBuffer.push(data);
+}
+function getBeforeAfterMetrics() {
+  const totalProcessed = beforeAfterBuffer.length;
+  if (totalProcessed === 0) {
+    return {
+      totalProcessed: 0,
+      agreements: 0,
+      disagreements: 0,
+      disagreementBreakdown: {
+        formationDiscardedCompactAdded: 0,
+        formationMergedCompactAdded: 0,
+        formationAddedCompactDiscarded: 0,
+        formationAddedCompactMerged: 0,
+        formationEvolvedCompactAdded: 0,
+        other: 0
+      },
+      quality: {
+        formationDiscardedLowValue: 0,
+        formationMergedDuplicates: 0,
+        formationEvolvedOutdated: 0,
+        compactMissedDuplicates: 0,
+        compactKeptLowValue: 0
+      },
+      duration: {
+        formationAvgMs: 0,
+        compactAvgMs: 0,
+        diffMs: 0
+      }
+    };
+  }
+  let agreements = 0;
+  let disagreements = 0;
+  const disagreementBreakdown = {
+    formationDiscardedCompactAdded: 0,
+    formationMergedCompactAdded: 0,
+    formationAddedCompactDiscarded: 0,
+    formationAddedCompactMerged: 0,
+    formationEvolvedCompactAdded: 0,
+    other: 0
+  };
+  const quality = {
+    formationDiscardedLowValue: 0,
+    formationMergedDuplicates: 0,
+    formationEvolvedOutdated: 0,
+    compactMissedDuplicates: 0,
+    compactKeptLowValue: 0
+  };
+  let formationTotalDuration = 0;
+  let compactTotalDuration = 0;
+  let compactDurationCount = 0;
+  for (const data of beforeAfterBuffer) {
+    formationTotalDuration += data.formationDurationMs;
+    if (data.compactDurationMs !== void 0) {
+      compactTotalDuration += data.compactDurationMs;
+      compactDurationCount++;
+    }
+    const formationAction = data.formationAction;
+    const oldCompactAction = data.oldCompactAction;
+    let formationMapped = "ADD";
+    if (formationAction === "merge" || formationAction === "evolve") {
+      formationMapped = "UPDATE";
+    } else if (formationAction === "discard") {
+      formationMapped = "NONE";
+    }
+    if (formationMapped === oldCompactAction) {
+      agreements++;
+    } else {
+      disagreements++;
+      if (formationAction === "discard" && oldCompactAction === "ADD") {
+        disagreementBreakdown.formationDiscardedCompactAdded++;
+        if (data.formationValueCategory === "ephemeral") {
+          quality.formationDiscardedLowValue++;
+        }
+      } else if (formationAction === "merge" && oldCompactAction === "ADD") {
+        disagreementBreakdown.formationMergedCompactAdded++;
+        quality.formationMergedDuplicates++;
+      } else if (formationAction === "new" && oldCompactAction === "NONE") {
+        disagreementBreakdown.formationAddedCompactDiscarded++;
+        quality.compactMissedDuplicates++;
+      } else if (formationAction === "new" && oldCompactAction === "UPDATE") {
+        disagreementBreakdown.formationAddedCompactMerged++;
+      } else if (formationAction === "evolve" && oldCompactAction === "ADD") {
+        disagreementBreakdown.formationEvolvedCompactAdded++;
+        quality.formationEvolvedOutdated++;
+      } else if (formationAction === "new" && oldCompactAction === "ADD") {
+        if (data.formationValueCategory === "ephemeral") {
+          quality.compactKeptLowValue++;
+        }
+      } else {
+        disagreementBreakdown.other++;
+      }
+    }
+  }
+  const compactAvgMs = compactDurationCount > 0 ? compactTotalDuration / compactDurationCount : 0;
+  const formationAvgMs = totalProcessed > 0 ? formationTotalDuration / totalProcessed : 0;
+  return {
+    totalProcessed,
+    agreements,
+    disagreements,
+    disagreementBreakdown,
+    quality,
+    duration: {
+      formationAvgMs,
+      compactAvgMs,
+      diffMs: compactAvgMs - formationAvgMs
+    }
+  };
+}
+function getMetricsSummary() {
+  const total = metricsBuffer.length;
+  if (total === 0) {
+    return {
+      total: 0,
+      avgValueScore: 0,
+      avgExtractedFacts: 0,
+      titleImprovedRate: 0,
+      entityResolvedRate: 0,
+      typeCorectedRate: 0,
+      resolutionBreakdown: {},
+      categoryBreakdown: {},
+      avgDurationMs: 0
+    };
+  }
+  const sum = (fn) => metricsBuffer.reduce((s, m) => s + fn(m), 0);
+  const resolutionBreakdown = {};
+  const categoryBreakdown = {};
+  for (const m of metricsBuffer) {
+    resolutionBreakdown[m.resolutionAction] = (resolutionBreakdown[m.resolutionAction] ?? 0) + 1;
+    categoryBreakdown[m.valueCategory] = (categoryBreakdown[m.valueCategory] ?? 0) + 1;
+  }
+  return {
+    total,
+    avgValueScore: sum((m) => m.valueScore) / total,
+    avgExtractedFacts: sum((m) => m.systemExtractedFacts) / total,
+    titleImprovedRate: sum((m) => m.titleImproved ? 1 : 0) / total,
+    entityResolvedRate: sum((m) => m.entityResolved ? 1 : 0) / total,
+    typeCorectedRate: sum((m) => m.typeCorrected ? 1 : 0) / total,
+    resolutionBreakdown,
+    categoryBreakdown,
+    avgDurationMs: sum((m) => m.durationMs) / total
+  };
+}
+async function runFormation(input, config) {
+  const startTime = Date.now();
+  let stagesCompleted = 0;
+  const existingEntities = config.getEntityNames();
+  const extraction = await runExtract(input, existingEntities, config.useLLM);
+  stagesCompleted = 1;
+  let resolution;
+  if (input.topicKey) {
+    resolution = {
+      action: "new",
+      reason: "TopicKey upsert \u2014 bypasses resolve stage"
+    };
+  } else {
+    resolution = await runResolve(
+      extraction,
+      input.projectId,
+      config.searchMemories,
+      config.getObservation,
+      config.useLLM
+    );
+  }
+  stagesCompleted = 2;
+  const evaluation = runEvaluate(extraction);
+  stagesCompleted = 3;
+  const durationMs = Date.now() - startTime;
+  const formed = {
+    // Final enriched data
+    entityName: extraction.entityName,
+    type: extraction.type,
+    title: extraction.title,
+    narrative: resolution.mergedNarrative ?? extraction.narrative,
+    facts: resolution.mergedFacts ?? extraction.facts,
+    // Stage results
+    extraction,
+    resolution,
+    evaluation,
+    // Pipeline metadata
+    pipeline: {
+      mode: config.useLLM ? "llm" : "rules",
+      durationMs,
+      stagesCompleted,
+      shadow: config.mode === "shadow"
+    },
+    // Governance fields
+    governance: {
+      provenance: {
+        creator: input.source === "explicit" ? "user" : "system",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        source: input.source
+      },
+      confidence: {
+        score: evaluation.score,
+        breakdown: {
+          extractionConfidence: extraction.extractedFacts.length > 0 ? 0.8 : 0.5,
+          resolutionConfidence: resolution.action === "new" ? 0.7 : 0.9,
+          evaluationConfidence: evaluation.score
+        },
+        reason: `Value score ${evaluation.score.toFixed(2)} in ${evaluation.category} category`
+      },
+      supersession: (resolution.action === "merge" || resolution.action === "evolve") && resolution.targetId ? {
+        replacedIds: [resolution.targetId],
+        reason: resolution.reason,
+        replacementType: resolution.action === "evolve" ? "hard" : "soft"
+      } : void 0
+    }
+  };
+  const metrics = {
+    systemExtractedFacts: extraction.extractedFacts.length,
+    titleImproved: extraction.titleImproved,
+    entityResolved: extraction.entityResolved,
+    typeCorrected: extraction.typeCorrected,
+    resolutionAction: resolution.action,
+    valueScore: evaluation.score,
+    valueCategory: evaluation.category,
+    durationMs,
+    mode: "rules"
+  };
+  if (metricsBuffer.length >= MAX_METRICS_BUFFER) {
+    metricsBuffer.shift();
+  }
+  metricsBuffer.push(metrics);
+  return formed;
+}
+var metricsBuffer, MAX_METRICS_BUFFER, beforeAfterBuffer, MAX_BEFORE_AFTER_BUFFER;
+var init_formation = __esm({
+  "src/memory/formation/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_extract();
+    init_resolve();
+    init_evaluate();
+    metricsBuffer = [];
+    MAX_METRICS_BUFFER = 500;
+    beforeAfterBuffer = [];
+    MAX_BEFORE_AFTER_BUFFER = 500;
+  }
+});
+
+// src/config/behavior.ts
+var behavior_exports = {};
+__export(behavior_exports, {
+  getBehaviorConfig: () => getBehaviorConfig,
+  resetBehaviorConfigCache: () => resetBehaviorConfigCache
+});
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join17 } from "path";
+import { homedir as homedir16 } from "os";
+function getBehaviorConfig() {
+  if (cached) return cached;
+  try {
+    const configPath = join17(homedir16(), ".memorix", "config.json");
+    const raw = readFileSync6(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    const behavior = config.behavior ?? {};
+    cached = {
+      sessionInject: behavior.sessionInject ?? DEFAULTS.sessionInject,
+      syncAdvisory: behavior.syncAdvisory ?? DEFAULTS.syncAdvisory,
+      autoCleanup: behavior.autoCleanup ?? DEFAULTS.autoCleanup,
+      formationMode: behavior.formationMode ?? DEFAULTS.formationMode
+    };
+  } catch {
+    cached = { ...DEFAULTS };
+  }
+  return cached;
 }
-async function deduplicateMemory(newMemory, existingMemories) {
-  if (!isLLMEnabled()) return null;
-  if (existingMemories.length === 0) return { action: "ADD", reason: "No existing memories", usedLLM: false };
-  const asExisting = existingMemories.map((m) => ({
-    ...m,
-    score: 0.8
-    // Batch dedup assumes high similarity (pre-filtered)
-  }));
-  return compactOnWrite(newMemory, asExisting);
+function resetBehaviorConfigCache() {
+  cached = null;
 }
-var COMPACT_ON_WRITE_PROMPT, SIMILARITY_HIGH, SIMILARITY_MEDIUM;
-var init_memory_manager = __esm({
-  "src/llm/memory-manager.ts"() {
+var DEFAULTS, cached;
+var init_behavior = __esm({
+  "src/config/behavior.ts"() {
     "use strict";
     init_esm_shims();
-    init_provider2();
-    COMPACT_ON_WRITE_PROMPT = `You are a smart coding memory manager. You control the memory of a cross-IDE coding assistant.
-
-You receive a NEW MEMORY to store and a list of EXISTING similar memories. Your job:
-1. Extract the key facts from the new memory
-2. Compare with existing memories
-3. Decide the best action
-
-Actions:
-- ADD: New memory contains unique information. Store it as-is.
-- UPDATE: New memory supersedes or improves an existing one. Merge them into a single, comprehensive memory.
-- DELETE: An existing memory is outdated/contradicted by the new one. Remove it.
-- NONE: New memory is redundant. Existing memories already cover this. Skip storing.
-
-Decision rules:
-- Same topic updated (e.g., "MySQL \u2192 PostgreSQL"): UPDATE the old memory with merged content
-- Bug fixed that was reported as open: UPDATE the bug report to include the fix
-- Task completed that was tracked as in-progress: UPDATE to mark completed
-- Minor variation of existing memory: NONE (skip)
-- Completely new topic: ADD
-- Old info directly contradicted: DELETE the old one
-- Prefer UPDATE over ADD \u2014 keep memory count low, merge information
-
-For UPDATE: write a merged narrative that combines the best of both old and new, preserving all important details. Also merge the facts lists, removing duplicates.
-
-Respond in JSON only:
-{
-  "action": "ADD" | "UPDATE" | "DELETE" | "NONE",
-  "targetId": null or existing_memory_id_number,
-  "reason": "brief explanation of decision",
-  "mergedNarrative": "merged narrative text (required for UPDATE, null otherwise)",
-  "mergedFacts": ["merged fact 1", "merged fact 2"] or null,
-  "extractedFacts": ["fact extracted from new content 1", "fact 2"]
-}`;
-    SIMILARITY_HIGH = 0.75;
-    SIMILARITY_MEDIUM = 0.5;
+    DEFAULTS = {
+      sessionInject: "minimal",
+      syncAdvisory: true,
+      autoCleanup: true,
+      formationMode: "active"
+    };
+    cached = null;
   }
 });
 
@@ -3187,7 +4525,8 @@ async function archiveExpired(projectDir2, referenceTime, accessMap) {
         projectId: obs.projectId,
         accessCount: access2?.accessCount ?? 0,
         lastAccessedAt: access2?.lastAccessedAt ?? "",
-        status: obs.status ?? "active"
+        status: obs.status ?? "active",
+        source: obs.source ?? "agent"
       };
     };
     const toArchive = [];
@@ -3232,6 +4571,7 @@ var init_retention = __esm({
       gotcha: "high",
       decision: "high",
       "trade-off": "high",
+      reasoning: "high",
       "problem-solution": "medium",
       "how-it-works": "medium",
       "what-changed": "low",
@@ -3249,10 +4589,10 @@ var engine_exports = {};
 __export(engine_exports, {
   SkillsEngine: () => SkillsEngine
 });
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "fs";
-import { join as join15 } from "path";
-import { homedir as homedir14 } from "os";
-var SKILLS_DIRS, SKILL_WORTHY_TYPES, MIN_OBS_FOR_SKILL, MIN_SCORE_FOR_SKILL, SkillsEngine;
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync3 } from "fs";
+import { join as join18 } from "path";
+import { homedir as homedir17 } from "os";
+var SKILLS_DIRS, SKILL_WORTHY_TYPES, MIN_OBS_FOR_SKILL, MIN_SCORE_FOR_SKILL, LOW_SIGNAL_TITLE_PATTERNS, LOW_SIGNAL_ENTITY_PATTERNS, COMMAND_TRACE_PATTERNS, SkillsEngine;
 var init_engine = __esm({
   "src/skills/engine.ts"() {
     "use strict";
@@ -3277,6 +4617,31 @@ var init_engine = __esm({
     ]);
     MIN_OBS_FOR_SKILL = 3;
     MIN_SCORE_FOR_SKILL = 5;
+    LOW_SIGNAL_TITLE_PATTERNS = [
+      /^ran:/i,
+      /^command:/i
+    ];
+    LOW_SIGNAL_ENTITY_PATTERNS = [
+      /^(?:bash|sh|cmd|powershell|pwsh|node|npm|npx|pnpm|yarn|gh|git)$/i,
+      /^mcp[_-]/i
+    ];
+    COMMAND_TRACE_PATTERNS = [
+      /\bcommand:\b/i,
+      /\b2>&1\b/i,
+      /\bselect-string\b/i,
+      /\bget-content\b/i,
+      /\bget-command\b/i,
+      /\bpowershell\b/i,
+      /\bcmd(?:\.exe)?\b/i,
+      /\bnpm\b/i,
+      /\bnpx\b/i,
+      /\bpnpm\b/i,
+      /\byarn\b/i,
+      /\bgit\b/i,
+      /\bgh\b/i,
+      /\|/,
+      /&&/
+    ];
     SkillsEngine = class {
       constructor(projectRoot, options) {
         this.projectRoot = projectRoot;
@@ -3292,30 +4657,30 @@ var init_engine = __esm({
       listSkills() {
         const skills = [];
         const seen = /* @__PURE__ */ new Set();
-        const home = homedir14();
+        const home = homedir17();
         for (const [agent, dirs] of Object.entries(SKILLS_DIRS)) {
           for (const dir of dirs) {
-            const paths = [join15(this.projectRoot, dir)];
+            const paths = [join18(this.projectRoot, dir)];
             if (!this.skipGlobal) {
-              paths.push(join15(home, dir));
+              paths.push(join18(home, dir));
             }
             for (const skillsRoot of paths) {
-              if (!existsSync5(skillsRoot)) continue;
+              if (!existsSync7(skillsRoot)) continue;
               try {
-                const entries = readdirSync2(skillsRoot, { withFileTypes: true });
+                const entries = readdirSync3(skillsRoot, { withFileTypes: true });
                 for (const entry of entries) {
                   if (!entry.isDirectory()) continue;
                   const name = entry.name;
                   if (seen.has(name)) continue;
-                  const skillMd = join15(skillsRoot, name, "SKILL.md");
-                  if (!existsSync5(skillMd)) continue;
+                  const skillMd = join18(skillsRoot, name, "SKILL.md");
+                  if (!existsSync7(skillMd)) continue;
                   try {
-                    const content = readFileSync4(skillMd, "utf-8");
+                    const content = readFileSync7(skillMd, "utf-8");
                     const description = this.parseDescription(content);
                     skills.push({
                       name,
                       description,
-                      sourcePath: join15(skillsRoot, name),
+                      sourcePath: join18(skillsRoot, name),
                       sourceAgent: agent,
                       content,
                       generated: false
@@ -3339,7 +4704,8 @@ var init_engine = __esm({
        * rich knowledge accumulation.
        */
       generateFromObservations(observations2) {
-        const clusters = this.clusterByEntity(observations2);
+        const candidates = observations2.filter((obs) => !this.isLowSignalObservation(obs));
+        const clusters = this.clusterByEntity(candidates);
         for (const cluster of clusters.values()) {
           cluster.score = this.scoreCluster(cluster);
         }
@@ -3357,11 +4723,11 @@ var init_engine = __esm({
       writeSkill(skill, target) {
         const dirs = SKILLS_DIRS[target];
         if (!dirs || dirs.length === 0) return null;
-        const targetDir = join15(this.projectRoot, dirs[0], skill.name);
+        const targetDir = join18(this.projectRoot, dirs[0], skill.name);
         try {
           mkdirSync3(targetDir, { recursive: true });
-          writeFileSync2(join15(targetDir, "SKILL.md"), skill.content, "utf-8");
-          return join15(dirs[0], skill.name, "SKILL.md");
+          writeFileSync2(join18(targetDir, "SKILL.md"), skill.content, "utf-8");
+          return join18(dirs[0], skill.name, "SKILL.md");
         } catch {
           return null;
         }
@@ -3383,6 +4749,24 @@ var init_engine = __esm({
         const match = content.match(/^---[\s\S]*?description:\s*["']?(.+?)["']?\s*$/m);
         return match ? match[1] : "";
       }
+      isLowSignalObservation(obs) {
+        if (obs.status === "archived") return true;
+        const title = obs.title.trim();
+        const narrative = obs.narrative.trim();
+        const entity = (obs.entityName || "").trim();
+        const haystack = `${title}
+${narrative}`;
+        if (LOW_SIGNAL_TITLE_PATTERNS.some((pattern) => pattern.test(title))) {
+          return true;
+        }
+        if (LOW_SIGNAL_ENTITY_PATTERNS.some((pattern) => pattern.test(entity))) {
+          return true;
+        }
+        if (obs.source !== "git" && COMMAND_TRACE_PATTERNS.filter((pattern) => pattern.test(haystack)).length >= 2) {
+          return true;
+        }
+        return false;
+      }
       clusterByEntity(observations2) {
         const clusters = /* @__PURE__ */ new Map();
         for (const obs of observations2) {
@@ -3577,7 +4961,7 @@ async function promoteToMiniSkill(projectDir2, projectId, observations2, options
     const title = generateTitle(observations2);
     const instruction = options?.instruction || generateInstruction(observations2);
     const trigger = options?.trigger || generateTrigger(observations2);
-    const facts = extractFacts(observations2);
+    const facts = extractFacts2(observations2);
     const tags = [
       ...options?.tags || [],
       ...extractTags(observations2)
@@ -3685,7 +5069,7 @@ function generateTrigger(observations2) {
   }
   return parts.length > 0 ? parts.join("; ") : `Related to ${obs.title}`;
 }
-function extractFacts(observations2) {
+function extractFacts2(observations2) {
   const facts = /* @__PURE__ */ new Set();
   for (const obs of observations2) {
     for (const f of obs.facts) {
@@ -4113,6 +5497,45 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir) {
           const t = obs.type || "unknown";
           typeCounts[t] = (typeCounts[t] || 0) + 1;
         }
+        const sourceCounts = { git: 0, agent: 0, manual: 0 };
+        const gitMemories = [];
+        const now = Date.now();
+        const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1e3;
+        let recentGitCount = 0;
+        for (const obs of observations2) {
+          const src = obs.source || "agent";
+          sourceCounts[src] = (sourceCounts[src] || 0) + 1;
+          if (src === "git") {
+            gitMemories.push(obs);
+            if (obs.createdAt && new Date(obs.createdAt).getTime() > sevenDaysAgo) {
+              recentGitCount++;
+            }
+          }
+        }
+        const gitSorted = [...gitMemories].sort((a, b) => (b.id || 0) - (a.id || 0));
+        const recentGitMemories = gitSorted.slice(0, 8).map((o) => ({
+          id: o.id,
+          title: o.title,
+          type: o.type,
+          commitHash: o.commitHash,
+          entityName: o.entityName,
+          createdAt: o.createdAt,
+          filesModified: o.filesModified
+        }));
+        let retentionSummary = { active: 0, stale: 0, archive: 0, immune: 0 };
+        for (const obs of observations2) {
+          const age = now - new Date(obs.createdAt || now).getTime();
+          const ageHours = age / (1e3 * 60 * 60);
+          const importance = obs.importance ?? 5;
+          const accessCount = obs.accessCount ?? 0;
+          const lambda = 0.01;
+          const score = Math.min(importance * Math.exp(-lambda * ageHours) + Math.min(accessCount * 0.5, 3), 10);
+          const isImmune2 = importance >= 8 || obs.type === "gotcha" || obs.type === "decision";
+          if (isImmune2) retentionSummary.immune++;
+          if (score >= 3) retentionSummary.active++;
+          else if (score >= 1) retentionSummary.stale++;
+          else retentionSummary.archive++;
+        }
         const sorted = [...observations2].sort((a, b) => (b.id || 0) - (a.id || 0)).slice(0, 10);
         let embeddingStatus = { enabled: false, provider: "", dimensions: 0 };
         try {
@@ -4131,8 +5554,15 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir) {
           observations: observations2.length,
           nextId: nextId2,
           typeCounts,
+          sourceCounts,
           recentObservations: sorted,
-          embedding: embeddingStatus
+          embedding: embeddingStatus,
+          gitSummary: {
+            total: gitMemories.length,
+            recentWeek: recentGitCount,
+            recentMemories: recentGitMemories
+          },
+          retentionSummary
         });
         break;
       }
@@ -4172,6 +5602,109 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir) {
         });
         break;
       }
+      case "/config": {
+        const os4 = await import("os");
+        const { existsSync: existsSync10 } = await import("fs");
+        const { join: join21 } = await import("path");
+        let yml = {};
+        try {
+          const { loadYamlConfig: loadYamlConfig2 } = await Promise.resolve().then(() => (init_yaml_loader(), yaml_loader_exports));
+          yml = loadYamlConfig2(effectiveProjectId.includes("/") ? void 0 : void 0);
+        } catch {
+        }
+        const projectRoot = process.cwd();
+        const files = {
+          "project memorix.yml": { exists: false, path: "" },
+          "user memorix.yml": { exists: false, path: "" },
+          "project .env": { exists: false, path: "" },
+          "user .env": { exists: false, path: "" },
+          "legacy config.json": { exists: false, path: "" }
+        };
+        try {
+          const home = os4.homedir();
+          const paths = {
+            "project memorix.yml": join21(projectRoot, "memorix.yml"),
+            "user memorix.yml": join21(home, ".memorix", "memorix.yml"),
+            "project .env": join21(projectRoot, ".env"),
+            "user .env": join21(home, ".memorix", ".env"),
+            "legacy config.json": join21(home, ".memorix", "config.json")
+          };
+          for (const [key, fpath] of Object.entries(paths)) {
+            files[key] = { exists: existsSync10(fpath), path: fpath };
+          }
+        } catch {
+        }
+        const values = [];
+        const llmProvider = process.env.MEMORIX_LLM_PROVIDER || yml.llm?.provider;
+        if (llmProvider) values.push({ key: "llm.provider", value: llmProvider, source: process.env.MEMORIX_LLM_PROVIDER ? "env" : "memorix.yml" });
+        const llmModel = process.env.MEMORIX_LLM_MODEL || yml.llm?.model;
+        if (llmModel) values.push({ key: "llm.model", value: llmModel, source: process.env.MEMORIX_LLM_MODEL ? "env" : "memorix.yml" });
+        const llmKey = process.env.MEMORIX_LLM_API_KEY || process.env.MEMORIX_API_KEY || yml.llm?.apiKey || process.env.OPENAI_API_KEY;
+        if (llmKey) {
+          let src = "unknown";
+          if (process.env.MEMORIX_LLM_API_KEY) src = "env:MEMORIX_LLM_API_KEY";
+          else if (process.env.MEMORIX_API_KEY) src = "env:MEMORIX_API_KEY";
+          else if (yml.llm?.apiKey) src = "memorix.yml (move to .env!)";
+          else if (process.env.OPENAI_API_KEY) src = "env:OPENAI_API_KEY";
+          values.push({ key: "llm.apiKey", value: "****" + llmKey.slice(-4), source: src, sensitive: true });
+        } else {
+          values.push({ key: "llm.apiKey", value: "not set", source: "none" });
+        }
+        const embProvider = process.env.MEMORIX_EMBEDDING || yml.embedding?.provider || "off";
+        values.push({ key: "embedding.provider", value: embProvider, source: process.env.MEMORIX_EMBEDDING ? "env" : yml.embedding?.provider ? "memorix.yml" : "default" });
+        values.push({ key: "git.autoHook", value: String(yml.git?.autoHook ?? false), source: yml.git?.autoHook !== void 0 ? "memorix.yml" : "default" });
+        values.push({ key: "git.skipMergeCommits", value: String(yml.git?.skipMergeCommits ?? true), source: yml.git?.skipMergeCommits !== void 0 ? "memorix.yml" : "default" });
+        if (yml.behavior?.formationMode) values.push({ key: "behavior.formationMode", value: yml.behavior.formationMode, source: "memorix.yml" });
+        if (yml.behavior?.sessionInject) values.push({ key: "behavior.sessionInject", value: yml.behavior.sessionInject, source: "memorix.yml" });
+        values.push({ key: "server.transport", value: yml.server?.transport || "stdio", source: yml.server?.transport ? "memorix.yml" : "default" });
+        values.push({ key: "server.dashboard", value: String(yml.server?.dashboard ?? true), source: yml.server?.dashboard !== void 0 ? "memorix.yml" : "default" });
+        sendJson(res, { files, values });
+        break;
+      }
+      case "/identity": {
+        const allObs = await loadObservationsJson(baseDir);
+        const allProjectIds = [...new Set(allObs.map((o) => o.projectId).filter(Boolean))];
+        const dirtyPatterns = [
+          /^placeholder\//,
+          /System32/i,
+          /Microsoft VS Code/i,
+          /node_modules/i,
+          /\.vscode/i,
+          /^local\/[A-Z]:\\/
+        ];
+        const dirtyIds = allProjectIds.filter((id) => dirtyPatterns.some((p) => p.test(id)));
+        let aliasGroups = [];
+        let canonicalId = effectiveProjectId;
+        try {
+          const aliasModule = await Promise.resolve().then(() => (init_aliases(), aliases_exports));
+          canonicalId = await aliasModule.getCanonicalId(effectiveProjectId);
+          const { promises: fsP } = await import("fs");
+          const registryPath = path7.join(baseDir, ".project-aliases.json");
+          const raw = await fsP.readFile(registryPath, "utf-8");
+          const registry = JSON.parse(raw);
+          aliasGroups = registry.groups || [];
+        } catch {
+        }
+        const currentGroup = aliasGroups.find((g) => g.aliases?.includes(effectiveProjectId) || g.canonical === effectiveProjectId);
+        const aliases = currentGroup?.aliases || [effectiveProjectId];
+        const hasDirtyIds = dirtyIds.length > 0;
+        const hasMultipleUnmerged = allProjectIds.length > aliasGroups.length + 1;
+        const isHealthy = !hasDirtyIds && !hasMultipleUnmerged;
+        sendJson(res, {
+          currentProjectId: effectiveProjectId,
+          canonicalId,
+          aliases,
+          allProjectIds,
+          dirtyIds,
+          aliasGroups: aliasGroups.length,
+          isHealthy,
+          healthIssues: [
+            ...hasDirtyIds ? [`${dirtyIds.length} dirty project ID(s) detected`] : [],
+            ...hasMultipleUnmerged ? ["Possible unmerged project identity splits"] : []
+          ]
+        });
+        break;
+      }
       default: {
         const deleteMatch = apiPath.match(/^\/observations\/(\d+)$/);
         if (deleteMatch && req.method === "DELETE") {
@@ -4294,7 +5827,11 @@ async function startDashboard(dataDir, port, staticDir, projectId, projectName,
       }
       return;
     }
-    if (url.startsWith("/api/team") && teamInstances) {
+    if (url.startsWith("/api/team")) {
+      if (!teamInstances) {
+        sendJson(res, { unavailable: true, reason: "http-transport-required" });
+        return;
+      }
       try {
         teamInstances.fileLocks.cleanExpired();
         const agents = teamInstances.registry.listAgents();
@@ -4945,7 +6482,7 @@ __export(persistence_exports2, {
   TeamPersistence: () => TeamPersistence
 });
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { statSync, renameSync as renameSync2, existsSync as existsSync6 } from "fs";
+import { statSync as statSync2, renameSync as renameSync2, existsSync as existsSync8 } from "fs";
 import { dirname as dirname2 } from "path";
 var TeamPersistence;
 var init_persistence2 = __esm({
@@ -4964,8 +6501,8 @@ var init_persistence2 = __esm({
       /** Reload state from disk if the file changed since last read */
       async sync() {
         try {
-          if (!existsSync6(this.filePath)) return;
-          const st = statSync(this.filePath);
+          if (!existsSync8(this.filePath)) return;
+          const st = statSync2(this.filePath);
           if (st.mtimeMs <= this.lastMtimeMs) return;
         } catch {
           return;
@@ -4979,7 +6516,7 @@ var init_persistence2 = __esm({
           this.taskManager.hydrate(snap.tasks);
           this.fileLocks.hydrate(snap.locks);
           try {
-            this.lastMtimeMs = statSync(this.filePath).mtimeMs;
+            this.lastMtimeMs = statSync2(this.filePath).mtimeMs;
           } catch {
           }
         } catch {
@@ -5009,7 +6546,7 @@ var init_persistence2 = __esm({
           }
         }
         try {
-          this.lastMtimeMs = statSync(this.filePath).mtimeMs;
+          this.lastMtimeMs = statSync2(this.filePath).mtimeMs;
         } catch {
         }
       }
@@ -5017,17 +6554,118 @@ var init_persistence2 = __esm({
   }
 });
 
+// src/audit/index.ts
+var audit_exports = {};
+__export(audit_exports, {
+  getAllAuditEntries: () => getAllAuditEntries,
+  getProjectFiles: () => getProjectFiles,
+  getProjectId: () => getProjectId,
+  loadAudit: () => loadAudit,
+  recordFile: () => recordFile,
+  removeFile: () => removeFile,
+  saveAudit: () => saveAudit
+});
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
+import { homedir as homedir18 } from "os";
+async function loadAudit() {
+  try {
+    const content = await fs6.readFile(AUDIT_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      version: "1.0.0",
+      projects: {}
+    };
+  }
+}
+async function saveAudit(data) {
+  const dir = path8.dirname(AUDIT_FILE);
+  await fs6.mkdir(dir, { recursive: true });
+  await fs6.writeFile(AUDIT_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+function getProjectId(projectRoot) {
+  try {
+    const { detectProject: detectProject2 } = (init_detector(), __toCommonJS(detector_exports));
+    const project = detectProject2(projectRoot);
+    if (project) return project.id;
+  } catch {
+  }
+  const normalized = projectRoot.replace(/\\/g, "/");
+  return `untracked/${normalized}`;
+}
+async function recordFile(projectRoot, type, filePath, agent) {
+  const data = await loadAudit();
+  const projectId = getProjectId(projectRoot);
+  if (!data.projects[projectId]) {
+    data.projects[projectId] = {
+      projectRoot,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      entries: []
+    };
+  }
+  const existingIndex = data.projects[projectId].entries.findIndex(
+    (e) => e.path === filePath
+  );
+  if (existingIndex === -1) {
+    data.projects[projectId].entries.push({
+      type,
+      agent,
+      path: filePath,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  await saveAudit(data);
+}
+async function getProjectFiles(projectRoot) {
+  const data = await loadAudit();
+  const projectId = getProjectId(projectRoot);
+  return data.projects[projectId]?.entries || [];
+}
+async function removeFile(projectRoot, filePath) {
+  const data = await loadAudit();
+  const projectId = getProjectId(projectRoot);
+  if (!data.projects[projectId]) return;
+  data.projects[projectId].entries = data.projects[projectId].entries.filter(
+    (e) => e.path !== filePath
+  );
+  if (data.projects[projectId].entries.length === 0) {
+    delete data.projects[projectId];
+  }
+  await saveAudit(data);
+}
+async function getAllAuditEntries() {
+  const data = await loadAudit();
+  const entries = [];
+  for (const [projectId, project] of Object.entries(data.projects)) {
+    for (const entry of project.entries) {
+      entries.push({ projectId, entry });
+    }
+  }
+  return entries;
+}
+var AUDIT_FILE;
+var init_audit = __esm({
+  "src/audit/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    AUDIT_FILE = path8.join(homedir18(), ".memorix", "audit.json");
+  }
+});
+
 // src/hooks/installers/index.ts
 var installers_exports = {};
 __export(installers_exports, {
   detectInstalledAgents: () => detectInstalledAgents,
+  getGlobalConfigPath: () => getGlobalConfigPath,
   getHookStatus: () => getHookStatus,
+  getProjectConfigPath: () => getProjectConfigPath,
   installHooks: () => installHooks,
   uninstallHooks: () => uninstallHooks
 });
-import * as fs6 from "fs/promises";
-import * as path8 from "path";
-import * as os4 from "os";
+import * as fs7 from "fs/promises";
+import * as path9 from "path";
+import * as os3 from "os";
 function resolveHookCommand() {
   if (process.platform === "win32") {
     return "memorix.cmd";
@@ -5261,101 +6899,101 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
 function getProjectConfigPath(agent, projectRoot) {
   switch (agent) {
     case "claude":
-      return path8.join(projectRoot, ".claude", "settings.local.json");
+      return path9.join(projectRoot, ".claude", "settings.local.json");
     case "copilot":
-      return path8.join(projectRoot, ".github", "hooks", "memorix.json");
+      return path9.join(projectRoot, ".github", "hooks", "memorix.json");
     case "windsurf":
-      return path8.join(projectRoot, ".windsurf", "hooks.json");
+      return path9.join(projectRoot, ".windsurf", "hooks.json");
     case "cursor":
-      return path8.join(projectRoot, ".cursor", "hooks.json");
+      return path9.join(projectRoot, ".cursor", "hooks.json");
     case "kiro":
-      return path8.join(projectRoot, ".kiro", "hooks", "memorix-agent-stop.kiro.hook");
+      return path9.join(projectRoot, ".kiro", "hooks", "memorix-agent-stop.kiro.hook");
     case "codex":
-      return path8.join(projectRoot, "AGENTS.md");
+      return path9.join(projectRoot, "AGENTS.md");
     case "trae":
-      return path8.join(projectRoot, ".trae", "rules", "project_rules.md");
+      return path9.join(projectRoot, ".trae", "rules", "project_rules.md");
     case "opencode":
-      return path8.join(projectRoot, ".opencode", "plugins", "memorix.js");
+      return path9.join(projectRoot, ".opencode", "plugins", "memorix.js");
     case "antigravity":
-      return path8.join(projectRoot, ".gemini", "settings.json");
+      return path9.join(projectRoot, ".gemini", "settings.json");
     default:
-      return path8.join(projectRoot, ".memorix", "hooks.json");
+      return path9.join(projectRoot, ".memorix", "hooks.json");
   }
 }
 function getGlobalConfigPath(agent) {
-  const home = os4.homedir();
+  const home = os3.homedir();
   switch (agent) {
     case "claude":
     case "copilot":
-      return path8.join(home, ".claude", "settings.json");
+      return path9.join(home, ".claude", "settings.json");
     case "windsurf":
-      return path8.join(home, ".codeium", "windsurf", "hooks.json");
+      return path9.join(home, ".codeium", "windsurf", "hooks.json");
     case "cursor":
-      return path8.join(home, ".cursor", "hooks.json");
+      return path9.join(home, ".cursor", "hooks.json");
     case "antigravity":
-      return path8.join(home, ".gemini", "settings.json");
+      return path9.join(home, ".gemini", "settings.json");
     case "opencode":
-      return path8.join(home, ".config", "opencode", "plugins", "memorix.js");
+      return path9.join(home, ".config", "opencode", "plugins", "memorix.js");
     case "trae":
-      return path8.join(home, ".trae", "rules", "project_rules.md");
+      return path9.join(home, ".trae", "rules", "project_rules.md");
     default:
-      return path8.join(home, ".memorix", "hooks.json");
+      return path9.join(home, ".memorix", "hooks.json");
   }
 }
 async function detectInstalledAgents() {
   const agents = [];
-  const home = os4.homedir();
-  const claudeDir = path8.join(home, ".claude");
+  const home = os3.homedir();
+  const claudeDir = path9.join(home, ".claude");
   try {
-    await fs6.access(claudeDir);
+    await fs7.access(claudeDir);
     agents.push("claude");
   } catch {
   }
-  const windsurfDir = path8.join(home, ".codeium", "windsurf");
+  const windsurfDir = path9.join(home, ".codeium", "windsurf");
   try {
-    await fs6.access(windsurfDir);
+    await fs7.access(windsurfDir);
     agents.push("windsurf");
   } catch {
   }
-  const cursorDir = path8.join(home, ".cursor");
+  const cursorDir = path9.join(home, ".cursor");
   try {
-    await fs6.access(cursorDir);
+    await fs7.access(cursorDir);
     agents.push("cursor");
   } catch {
   }
-  const vscodeDir = path8.join(home, ".vscode");
+  const vscodeDir = path9.join(home, ".vscode");
   try {
-    await fs6.access(vscodeDir);
+    await fs7.access(vscodeDir);
     agents.push("copilot");
   } catch {
   }
-  const kiroConfig = path8.join(home, ".kiro");
+  const kiroConfig = path9.join(home, ".kiro");
   try {
-    await fs6.access(kiroConfig);
+    await fs7.access(kiroConfig);
     agents.push("kiro");
   } catch {
   }
-  const codexDir = path8.join(home, ".codex");
+  const codexDir = path9.join(home, ".codex");
   try {
-    await fs6.access(codexDir);
+    await fs7.access(codexDir);
     agents.push("codex");
   } catch {
   }
-  const geminiDir = path8.join(home, ".gemini");
+  const geminiDir = path9.join(home, ".gemini");
   try {
-    await fs6.access(geminiDir);
+    await fs7.access(geminiDir);
     agents.push("antigravity");
   } catch {
   }
-  const opencodeDir = path8.join(home, ".config", "opencode");
+  const opencodeDir = path9.join(home, ".config", "opencode");
   try {
-    await fs6.access(opencodeDir);
+    await fs7.access(opencodeDir);
     agents.push("opencode");
   } catch {
   }
-  const traeDir = path8.join(home, ".trae");
+  const traeDir = path9.join(home, ".trae");
   try {
-    await fs6.access(traeDir);
+    await fs7.access(traeDir);
     agents.push("trae");
   } catch {
   }
@@ -5402,8 +7040,13 @@ async function installHooks(agent, projectRoot, global = false) {
     case "opencode": {
       const pluginContent = generateOpenCodePlugin();
       const pluginPath = global ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
-      await fs6.mkdir(path8.dirname(pluginPath), { recursive: true });
-      await fs6.writeFile(pluginPath, pluginContent, "utf-8");
+      await fs7.mkdir(path9.dirname(pluginPath), { recursive: true });
+      await fs7.writeFile(pluginPath, pluginContent, "utf-8");
+      try {
+        const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
+        await recordFile2(projectRoot, "hook", pluginPath, agent);
+      } catch {
+      }
       await installAgentRules(agent, projectRoot);
       return {
         agent,
@@ -5415,18 +7058,24 @@ async function installHooks(agent, projectRoot, global = false) {
     default:
       generated = generateClaudeConfig();
   }
-  await fs6.mkdir(path8.dirname(configPath), { recursive: true });
+  await fs7.mkdir(path9.dirname(configPath), { recursive: true });
   if (agent === "kiro") {
     const hookFiles = generateKiroHookFiles();
-    const hooksDir = path8.join(path8.dirname(configPath));
-    await fs6.mkdir(hooksDir, { recursive: true });
+    const hooksDir = path9.join(path9.dirname(configPath));
+    await fs7.mkdir(hooksDir, { recursive: true });
     for (const hf of hookFiles) {
-      await fs6.writeFile(path8.join(hooksDir, hf.filename), hf.content, "utf-8");
+      const hookPath = path9.join(hooksDir, hf.filename);
+      await fs7.writeFile(hookPath, hf.content, "utf-8");
+      try {
+        const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
+        await recordFile2(projectRoot, "hook", hookPath, agent);
+      } catch {
+      }
     }
   } else {
     let existing = {};
     try {
-      const content = await fs6.readFile(configPath, "utf-8");
+      const content = await fs7.readFile(configPath, "utf-8");
       existing = JSON.parse(content);
     } catch {
     }
@@ -5458,7 +7107,12 @@ async function installHooks(agent, projectRoot, global = false) {
       const h = merged.hooks;
       if (h) delete h.preToolUse;
     }
-    await fs6.writeFile(configPath, JSON.stringify(merged, null, 2), "utf-8");
+    await fs7.writeFile(configPath, JSON.stringify(merged, null, 2), "utf-8");
+    try {
+      const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
+      await recordFile2(projectRoot, "hook", configPath, agent);
+    } catch {
+    }
   }
   const events = [];
   switch (agent) {
@@ -5494,51 +7148,61 @@ async function installAgentRules(agent, projectRoot) {
   let rulesPath;
   switch (agent) {
     case "windsurf":
-      rulesPath = path8.join(projectRoot, ".windsurf", "rules", "memorix.md");
+      rulesPath = path9.join(projectRoot, ".windsurf", "rules", "memorix.md");
       break;
     case "cursor":
-      rulesPath = path8.join(projectRoot, ".cursor", "rules", "memorix.mdc");
+      rulesPath = path9.join(projectRoot, ".cursor", "rules", "memorix.mdc");
       break;
     case "claude":
     case "copilot":
-      rulesPath = path8.join(projectRoot, ".github", "copilot-instructions.md");
+      rulesPath = path9.join(projectRoot, ".github", "copilot-instructions.md");
       break;
     case "codex":
-      rulesPath = path8.join(projectRoot, "AGENTS.md");
+      rulesPath = path9.join(projectRoot, "AGENTS.md");
       break;
     case "kiro":
-      rulesPath = path8.join(projectRoot, ".kiro", "steering", "memorix.md");
+      rulesPath = path9.join(projectRoot, ".kiro", "steering", "memorix.md");
       break;
     case "opencode":
-      rulesPath = path8.join(projectRoot, "AGENTS.md");
+      rulesPath = path9.join(projectRoot, "AGENTS.md");
       break;
     case "antigravity":
-      rulesPath = path8.join(projectRoot, "GEMINI.md");
+      rulesPath = path9.join(projectRoot, "GEMINI.md");
       break;
     case "trae":
-      rulesPath = path8.join(projectRoot, ".trae", "rules", "project_rules.md");
+      rulesPath = path9.join(projectRoot, ".trae", "rules", "project_rules.md");
       break;
     default:
-      rulesPath = path8.join(projectRoot, ".agent", "rules", "memorix.md");
+      rulesPath = path9.join(projectRoot, ".agent", "rules", "memorix.md");
       break;
   }
   try {
-    await fs6.mkdir(path8.dirname(rulesPath), { recursive: true });
+    await fs7.mkdir(path9.dirname(rulesPath), { recursive: true });
     if (agent === "codex" || agent === "opencode" || agent === "antigravity") {
       try {
-        const existing = await fs6.readFile(rulesPath, "utf-8");
+        const existing = await fs7.readFile(rulesPath, "utf-8");
         if (existing.includes("Memorix")) {
           return;
         }
-        await fs6.writeFile(rulesPath, existing + "\n\n" + rulesContent, "utf-8");
+        await fs7.writeFile(rulesPath, existing + "\n\n" + rulesContent, "utf-8");
+        try {
+          const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
+          await recordFile2(projectRoot, "rule", rulesPath, agent);
+        } catch {
+        }
       } catch {
-        await fs6.writeFile(rulesPath, rulesContent, "utf-8");
+        await fs7.writeFile(rulesPath, rulesContent, "utf-8");
       }
     } else {
       try {
-        await fs6.access(rulesPath);
+        await fs7.access(rulesPath);
       } catch {
-        await fs6.writeFile(rulesPath, rulesContent, "utf-8");
+        await fs7.writeFile(rulesPath, rulesContent, "utf-8");
+        try {
+          const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
+          await recordFile2(projectRoot, "rule", rulesPath, agent);
+        } catch {
+        }
       }
     }
   } catch {
@@ -5670,15 +7334,15 @@ async function uninstallHooks(agent, projectRoot, global = false) {
   const configPath = global ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
   try {
     if (agent === "kiro") {
-      await fs6.unlink(configPath);
+      await fs7.unlink(configPath);
     } else {
-      const content = await fs6.readFile(configPath, "utf-8");
+      const content = await fs7.readFile(configPath, "utf-8");
       const config = JSON.parse(content);
       delete config.hooks;
       if (Object.keys(config).length === 0) {
-        await fs6.unlink(configPath);
+        await fs7.unlink(configPath);
       } else {
-        await fs6.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+        await fs7.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
       }
     }
     return true;
@@ -5695,11 +7359,11 @@ async function getHookStatus(projectRoot) {
     let installed = false;
     let usedPath = projectPath;
     try {
-      await fs6.access(projectPath);
+      await fs7.access(projectPath);
       installed = true;
     } catch {
       try {
-        await fs6.access(globalPath);
+        await fs7.access(globalPath);
         installed = true;
         usedPath = globalPath;
       } catch {
@@ -5716,6 +7380,60 @@ var init_installers = __esm({
   }
 });
 
+// src/git/hooks-path.ts
+var hooks_path_exports = {};
+__export(hooks_path_exports, {
+  ensureHooksDir: () => ensureHooksDir,
+  resolveGitDir: () => resolveGitDir,
+  resolveHooksDir: () => resolveHooksDir
+});
+import { existsSync as existsSync9, readFileSync as readFileSync8, statSync as statSync3, mkdirSync as mkdirSync4 } from "fs";
+import path10 from "path";
+function resolveGitDir(projectRoot) {
+  const dotGit = path10.join(projectRoot, ".git");
+  if (!existsSync9(dotGit)) return null;
+  const stat = statSync3(dotGit);
+  if (stat.isDirectory()) {
+    return dotGit;
+  }
+  if (stat.isFile()) {
+    try {
+      const content = readFileSync8(dotGit, "utf-8").trim();
+      const match = content.match(/^gitdir:\s*(.+)$/);
+      if (match) {
+        const gitdir = match[1].trim();
+        const resolved = path10.isAbsolute(gitdir) ? gitdir : path10.resolve(projectRoot, gitdir);
+        if (existsSync9(resolved)) {
+          return resolved;
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveHooksDir(projectRoot) {
+  const gitDir = resolveGitDir(projectRoot);
+  if (!gitDir) return null;
+  const hooksDir = path10.join(gitDir, "hooks");
+  return {
+    hooksDir,
+    hookPath: path10.join(hooksDir, "post-commit")
+  };
+}
+function ensureHooksDir(projectRoot) {
+  const resolved = resolveHooksDir(projectRoot);
+  if (!resolved) return null;
+  mkdirSync4(resolved.hooksDir, { recursive: true });
+  return resolved;
+}
+var init_hooks_path = __esm({
+  "src/git/hooks-path.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/index.ts
 init_esm_shims();
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -5841,6 +7559,10 @@ var KnowledgeGraphManager = class {
     );
     await this.save();
   }
+  /** Get all entity names (for Formation Pipeline entity resolution) */
+  getEntityNames() {
+    return this.entities.map((e) => e.name);
+  }
   /** Read the entire graph */
   async readGraph() {
     await this.init();
@@ -5946,38 +7668,38 @@ init_observations();
 
 // src/compact/index-format.ts
 init_esm_shims();
-function formatIndexTable(entries, query) {
+function formatIndexTable(entries, query, forceProjectColumn = false) {
   if (entries.length === 0) {
     return query ? `No observations found matching "${query}".` : "No observations found.";
   }
   const lines = [];
   if (query) {
-    lines.push(`Found ${entries.length} observation(s) matching "${query}":
-`);
+    lines.push(`Found ${entries.length} observation(s) matching "${query}":`);
+    lines.push("");
+  }
+  const distinctProjects = [...new Set(entries.map((entry) => entry.projectId).filter(Boolean))];
+  const hasProject = forceProjectColumn || distinctProjects.length > 1;
+  const hasExplanation = entries.some((entry) => (entry.matchedFields?.length ?? 0) > 0);
+  const header = ["ID", "Time", "T", "Title", "Tokens"];
+  const divider = ["----", "------", "---", "-------", "--------"];
+  if (hasProject) {
+    header.push("Project");
+    divider.push("---------");
   }
-  lines.push("| ID | Time | T | Title | Tokens |");
-  lines.push("|----|------|---|-------|--------|");
-  const hasExplanation = entries.some((e) => e["matchedFields"]);
   if (hasExplanation) {
-    lines.pop();
-    lines.pop();
-    lines.push("| ID | Time | T | Title | Tokens | Matched |");
-    lines.push("|----|------|---|-------|--------|---------|");
+    header.push("Matched");
+    divider.push("---------");
   }
+  lines.push(`| ${header.join(" | ")} |`);
+  lines.push(`|${divider.map((part) => ` ${part} `).join("|")}|`);
   for (const entry of entries) {
-    const matched = entry["matchedFields"];
-    if (hasExplanation && matched) {
-      lines.push(
-        `| #${entry.id} | ${entry.time} | ${entry.icon} | ${entry.title} | ~${entry.tokens} | ${matched.join(", ")} |`
-      );
-    } else {
-      lines.push(
-        `| #${entry.id} | ${entry.time} | ${entry.icon} | ${entry.title} | ~${entry.tokens} |`
-      );
-    }
+    const row = [`#${entry.id}`, entry.time, entry.icon, entry.title, `~${entry.tokens}`];
+    if (hasProject) row.push(entry.projectId ?? "-");
+    if (hasExplanation) row.push(entry.matchedFields?.join(", ") ?? "-");
+    lines.push(`| ${row.join(" | ")} |`);
   }
   lines.push("");
-  lines.push(PROGRESSIVE_DISCLOSURE_HINT);
+  lines.push(getProgressiveDisclosureHint(hasProject));
   return lines.join("\n");
 }
 function formatTimeline(timeline) {
@@ -5985,8 +7707,8 @@ function formatTimeline(timeline) {
     return `Observation #${timeline.anchorId} not found.`;
   }
   const lines = [];
-  lines.push(`Timeline around #${timeline.anchorId}:
-`);
+  lines.push(`Timeline around #${timeline.anchorId}:`);
+  lines.push("");
   if (timeline.before.length > 0) {
     lines.push("**Before:**");
     lines.push("| ID | Time | T | Title | Tokens |");
@@ -5996,11 +7718,11 @@ function formatTimeline(timeline) {
     }
     lines.push("");
   }
-  lines.push("**\u25BA Anchor:**");
+  lines.push("**Anchor:**");
   lines.push("| ID | Time | T | Title | Tokens |");
   lines.push("|----|------|---|-------|--------|");
-  const a = timeline.anchorEntry;
-  lines.push(`| #${a.id} | ${a.time} | ${a.icon} | ${a.title} | ~${a.tokens} |`);
+  const anchor = timeline.anchorEntry;
+  lines.push(`| #${anchor.id} | ${anchor.time} | ${anchor.icon} | ${anchor.title} | ~${anchor.tokens} |`);
   lines.push("");
   if (timeline.after.length > 0) {
     lines.push("**After:**");
@@ -6011,14 +7733,14 @@ function formatTimeline(timeline) {
     }
     lines.push("");
   }
-  lines.push(PROGRESSIVE_DISCLOSURE_HINT);
+  lines.push(getProgressiveDisclosureHint(false));
   return lines.join("\n");
 }
 function formatObservationDetail(doc) {
   const icon = getTypeIcon(doc.type);
   const lines = [];
   lines.push(`#${doc.observationId} ${icon} ${doc.title}`);
-  lines.push("\u2500".repeat(50));
+  lines.push("=".repeat(50));
   lines.push(`Date: ${new Date(doc.createdAt).toLocaleString()}`);
   lines.push(`Type: ${doc.type}`);
   lines.push(`Entity: ${doc.entityName}`);
@@ -6057,20 +7779,29 @@ function getTypeIcon(type) {
     "discovery": "\u{1F7E3}",
     "why-it-exists": "\u{1F7E0}",
     "decision": "\u{1F7E4}",
-    "trade-off": "\u2696\uFE0F"
+    "trade-off": "\u2696\uFE0F",
+    "reasoning": "\u{1F9E0}"
   };
   return icons[type] ?? "\u2753";
 }
-var PROGRESSIVE_DISCLOSURE_HINT = `\u{1F4A1} **Progressive Disclosure:** This index shows WHAT exists and retrieval COST.
-- Use \`memorix_detail\` to fetch full observation details by ID
-- Use \`memorix_timeline\` to see chronological context around an observation
-- Critical types (\u{1F534} gotcha, \u{1F7E4} decision, \u2696\uFE0F trade-off) are often worth fetching immediately`;
+function getProgressiveDisclosureHint(hasProject) {
+  const lines = [
+    "\u{1F4A1} **Progressive Disclosure:** This index shows WHAT exists and retrieval COST.",
+    "- Use `memorix_detail` to fetch full observation details by ID",
+    "- Use `memorix_timeline` to see chronological context around an observation",
+    "- Critical types (\u{1F534} gotcha, \u{1F7E4} decision, \u2696\uFE0F trade-off) are often worth fetching immediately"
+  ];
+  if (hasProject) {
+    lines.push("- For global results, prefer `memorix_detail refs=[{ id, projectId }]` to avoid cross-project ID ambiguity");
+  }
+  return lines.join("\n");
+}
 
 // src/compact/engine.ts
 init_token_budget();
 async function compactSearch(options) {
   const entries = await searchObservations(options);
-  const formatted = formatIndexTable(entries, options.query);
+  const formatted = formatIndexTable(entries, options.query, !options.projectId);
   const totalTokens = countTextTokens(formatted);
   return { entries, formatted, totalTokens };
 }
@@ -6086,13 +7817,18 @@ async function compactTimeline(anchorId, projectId, depthBefore = 3, depthAfter
   const totalTokens = countTextTokens(formatted);
   return { timeline, formatted, totalTokens };
 }
-async function compactDetail(ids) {
-  const documents = [];
-  for (const id of ids) {
-    const obs = getObservation(id);
-    if (obs) {
-      documents.push({
-        id: `obs-${obs.id}`,
+async function compactDetail(idsOrRefs) {
+  const refs = idsOrRefs.map(
+    (item) => typeof item === "number" ? { id: item } : item
+  );
+  const toRefKey = (ref) => `${ref.projectId ?? ""}::${ref.id}`;
+  const documentMap = /* @__PURE__ */ new Map();
+  const missingRefs = [];
+  for (const ref of refs) {
+    const obs = getObservation(ref.id);
+    if (obs && (!ref.projectId || obs.projectId === ref.projectId)) {
+      documentMap.set(toRefKey(ref), {
+        id: makeOramaObservationId(obs.projectId, obs.id),
         observationId: obs.id,
         entityName: obs.entityName,
         type: obs.type,
@@ -6106,166 +7842,90 @@ async function compactDetail(ids) {
         projectId: obs.projectId,
         accessCount: 0,
         lastAccessedAt: "",
-        status: obs.status ?? "active"
+        status: obs.status ?? "active",
+        source: obs.source ?? "agent"
       });
+    } else {
+      missingRefs.push(ref);
     }
   }
-  const formattedParts = documents.map(
-    (doc) => formatObservationDetail(doc)
-  );
-  const formatted = formattedParts.join("\n\n" + "\u2550".repeat(50) + "\n\n");
-  const totalTokens = countTextTokens(formatted);
-  return { documents, formatted, totalTokens };
-}
-
-// src/project/detector.ts
-init_esm_shims();
-import { execSync } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import os3 from "os";
-import path5 from "path";
-function detectProject(cwd) {
-  const basePath = cwd ?? process.cwd();
-  const rootPath = getGitRoot(basePath) ?? findPackageRoot(basePath) ?? basePath;
-  const gitRemote = getGitRemote(rootPath);
-  if (gitRemote) {
-    const id2 = normalizeGitRemote(gitRemote);
-    const name2 = id2.split("/").pop() ?? path5.basename(rootPath);
-    return { id: id2, name: name2, gitRemote, rootPath };
-  }
-  if (isDangerousRoot(rootPath)) {
-    const name2 = path5.basename(rootPath) || "unknown";
-    const id2 = `placeholder/${name2}`;
-    console.error(`[memorix] WARNING: cwd "${rootPath}" is not a project directory \u2014 using degraded mode (${id2})`);
-    console.error(`[memorix] For best results, set MEMORIX_PROJECT_ROOT or --cwd to your project path.`);
-    return { id: id2, name: name2, rootPath };
-  }
-  const name = path5.basename(rootPath);
-  const id = `local/${name}`;
-  return { id, name, rootPath };
-}
-function isDangerousRoot(dirPath) {
-  const resolved = path5.resolve(dirPath);
-  const home = path5.resolve(os3.homedir());
-  if (resolved === home) return true;
-  if (resolved === path5.parse(resolved).root) return true;
-  const basename2 = path5.basename(resolved).toLowerCase();
-  const knownNonProjectDirs = /* @__PURE__ */ new Set([
-    // IDE / editor config dirs
-    ".vscode",
-    ".cursor",
-    ".windsurf",
-    ".kiro",
-    ".codex",
-    ".gemini",
-    ".claude",
-    ".github",
-    ".git",
-    // OS / system dirs
-    "desktop",
-    "documents",
-    "downloads",
-    "pictures",
-    "videos",
-    "music",
-    "appdata",
-    "application data",
-    "library",
-    // Package manager / tool dirs
-    "node_modules",
-    ".npm",
-    ".yarn",
-    ".pnpm-store",
-    ".config",
-    ".local",
-    ".cache",
-    ".ssh",
-    ".memorix"
-  ]);
-  if (knownNonProjectDirs.has(basename2)) {
-    const parent = path5.resolve(path5.dirname(resolved));
-    if (parent === home || parent === path5.parse(parent).root) {
-      return true;
-    }
-  }
-  return false;
-}
-function findPackageRoot(cwd) {
-  let dir = path5.resolve(cwd);
-  const root = path5.parse(dir).root;
-  while (dir !== root) {
-    if (isDangerousRoot(dir)) return null;
-    if (existsSync2(path5.join(dir, "package.json"))) {
-      return dir;
-    }
-    dir = path5.dirname(dir);
-  }
-  return null;
-}
-function getGitRoot(cwd) {
-  let dir = path5.resolve(cwd);
-  const fsRoot = path5.parse(dir).root;
-  while (dir !== fsRoot) {
-    if (existsSync2(path5.join(dir, ".git"))) return dir;
-    dir = path5.dirname(dir);
-  }
-  try {
-    const root = execSync("git -c safe.directory=* rev-parse --show-toplevel", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5e3
-    }).trim();
-    return root || null;
-  } catch {
-    return null;
-  }
-}
-function getGitRemote(cwd) {
-  const fsRemote = readGitConfigRemote(cwd);
-  if (fsRemote) return fsRemote;
-  try {
-    const remote = execSync("git -c safe.directory=* remote get-url origin", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5e3
-    }).trim();
-    return remote || null;
-  } catch {
-    return null;
-  }
-}
-function readGitConfigRemote(cwd) {
-  try {
-    const configPath = path5.join(cwd, ".git", "config");
-    if (!existsSync2(configPath)) return null;
-    const content = readFileSync2(configPath, "utf-8");
-    const remoteMatch = content.match(/\[remote\s+"origin"\]([\s\S]*?)(?=\n\[|$)/);
-    if (!remoteMatch) return null;
-    const urlMatch = remoteMatch[1].match(/^\s*url\s*=\s*(.+)$/m);
-    return urlMatch ? urlMatch[1].trim() : null;
-  } catch {
-    return null;
-  }
-}
-function normalizeGitRemote(remote) {
-  let normalized = remote;
-  normalized = normalized.replace(/\.git$/, "");
-  const sshMatch = normalized.match(/^[\w-]+@[\w.-]+:(.+)$/);
-  if (sshMatch) {
-    return sshMatch[1];
+  if (missingRefs.length > 0) {
+    for (const ref of missingRefs) {
+      const fallbackDocs = await getObservationsByIds([ref.id], ref.projectId);
+      const doc = fallbackDocs[0];
+      if (doc) {
+        documentMap.set(toRefKey(ref), doc);
+      }
+    }
   }
-  try {
-    const url = new URL(normalized);
-    return url.pathname.replace(/^\//, "");
-  } catch {
-    const segments = normalized.split("/").filter(Boolean);
-    return segments.slice(-2).join("/");
+  const documents = refs.map((ref) => documentMap.get(toRefKey(ref))).filter((doc) => Boolean(doc));
+  const allObs = getAllObservations();
+  const crossRefMap = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const obs = getObservation(ref.id);
+    const doc = documentMap.get(toRefKey(ref));
+    if (!obs && !doc) continue;
+    const refs2 = [];
+    if (obs?.source === "git" && obs.commitHash) {
+      refs2.push(`Source: git commit ${obs.commitHash.substring(0, 7)}`);
+    } else if (obs?.source) {
+      refs2.push(`Source: ${obs.source}`);
+    } else if (doc?.source) {
+      refs2.push(`Source: ${doc.source}`);
+    }
+    if (!obs) {
+      if (refs2.length > 0 && doc) crossRefMap.set(doc.id, refs2);
+      continue;
+    }
+    if (obs.relatedCommits && obs.relatedCommits.length > 0) {
+      refs2.push(`Related commits: ${obs.relatedCommits.map((h) => h.substring(0, 7)).join(", ")}`);
+      const gitMems = allObs.filter((o) => o.source === "git" && o.commitHash && obs.relatedCommits.includes(o.commitHash));
+      for (const gm of gitMems) {
+        refs2.push(`  \u2192 #${gm.id} \u{1F7E2} ${gm.title}`);
+      }
+    }
+    if (obs.relatedEntities && obs.relatedEntities.length > 0) {
+      refs2.push(`Related entities: ${obs.relatedEntities.join(", ")}`);
+    }
+    if (obs.source === "git") {
+      const reasoning = allObs.filter(
+        (o) => o.type === "reasoning" && o.entityName === obs.entityName && o.id !== obs.id && o.status !== "archived"
+      ).slice(0, 3);
+      if (reasoning.length > 0) {
+        refs2.push("Related reasoning:");
+        for (const r of reasoning) {
+          refs2.push(`  \u2192 #${r.id} \u{1F9E0} ${r.title}`);
+        }
+      }
+    }
+    if (obs.type === "reasoning") {
+      const gitMems = allObs.filter(
+        (o) => o.source === "git" && o.entityName === obs.entityName && o.id !== obs.id && o.status !== "archived"
+      ).slice(0, 3);
+      if (gitMems.length > 0) {
+        refs2.push("Related commits:");
+        for (const g of gitMems) {
+          refs2.push(`  \u2192 #${g.id} \u{1F7E2} ${g.title}`);
+        }
+      }
+    }
+    if (refs2.length > 0) crossRefMap.set(makeOramaObservationId(obs.projectId, obs.id), refs2);
   }
+  const formattedParts = documents.map((doc) => {
+    let detail = formatObservationDetail(doc);
+    const refs2 = crossRefMap.get(doc.id);
+    if (refs2 && refs2.length > 0) {
+      detail += "\n\nCross-references:\n" + refs2.join("\n");
+    }
+    return detail;
+  });
+  const formatted = formattedParts.join("\n\n" + "\u2550".repeat(50) + "\n\n");
+  const totalTokens = countTextTokens(formatted);
+  return { documents, formatted, totalTokens };
 }
 
 // src/server.ts
+init_detector();
 init_aliases();
 init_persistence();
 
@@ -6998,14 +8658,14 @@ var RulesSyncer = class {
 
 // src/workspace/engine.ts
 init_esm_shims();
-import { readFileSync as readFileSync3, readdirSync, existsSync as existsSync4, cpSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir13 } from "os";
+import { readFileSync as readFileSync5, readdirSync as readdirSync2, existsSync as existsSync6, cpSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir15 } from "os";
 
 // src/workspace/mcp-adapters/windsurf.ts
 init_esm_shims();
-import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join6 } from "path";
 var WindsurfMCPAdapter = class {
   source = "windsurf";
   parse(content) {
@@ -7062,14 +8722,14 @@ var WindsurfMCPAdapter = class {
     return JSON.stringify({ mcpServers }, null, 2);
   }
   getConfigPath(_projectRoot) {
-    return join4(homedir4(), ".codeium", "windsurf", "mcp_config.json");
+    return join6(homedir6(), ".codeium", "windsurf", "mcp_config.json");
   }
 };
 
 // src/workspace/mcp-adapters/cursor.ts
 init_esm_shims();
-import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
 var CursorMCPAdapter = class {
   source = "cursor";
   parse(content) {
@@ -7106,16 +8766,16 @@ var CursorMCPAdapter = class {
   }
   getConfigPath(projectRoot) {
     if (projectRoot) {
-      return join5(projectRoot, ".cursor", "mcp.json");
+      return join7(projectRoot, ".cursor", "mcp.json");
     }
-    return join5(homedir5(), ".cursor", "mcp.json");
+    return join7(homedir7(), ".cursor", "mcp.json");
   }
 };
 
 // src/workspace/mcp-adapters/codex.ts
 init_esm_shims();
-import { homedir as homedir6 } from "os";
-import { join as join6 } from "path";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
 var CodexMCPAdapter = class {
   source = "codex";
   parse(content) {
@@ -7205,9 +8865,9 @@ var CodexMCPAdapter = class {
   }
   getConfigPath(projectRoot) {
     if (projectRoot) {
-      return join6(projectRoot, ".codex", "config.toml");
+      return join8(projectRoot, ".codex", "config.toml");
     }
-    return join6(homedir6(), ".codex", "config.toml");
+    return join8(homedir8(), ".codex", "config.toml");
   }
   // ---- TOML helpers ----
   parseTomlString(raw) {
@@ -7254,8 +8914,8 @@ var CodexMCPAdapter = class {
 
 // src/workspace/mcp-adapters/claude-code.ts
 init_esm_shims();
-import { homedir as homedir7 } from "os";
-import { join as join7 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join9 } from "path";
 var ClaudeCodeMCPAdapter = class {
   source = "claude-code";
   parse(content) {
@@ -7292,16 +8952,16 @@ var ClaudeCodeMCPAdapter = class {
   }
   getConfigPath(projectRoot) {
     if (projectRoot) {
-      return join7(projectRoot, ".claude", "settings.json");
+      return join9(projectRoot, ".claude", "settings.json");
     }
-    return join7(homedir7(), ".claude.json");
+    return join9(homedir9(), ".claude.json");
   }
 };
 
 // src/workspace/mcp-adapters/copilot.ts
 init_esm_shims();
-import { homedir as homedir8 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join10 } from "path";
 var CopilotMCPAdapter = class {
   source = "copilot";
   parse(content) {
@@ -7356,23 +9016,23 @@ var CopilotMCPAdapter = class {
   }
   getConfigPath(projectRoot) {
     if (projectRoot) {
-      return join8(projectRoot, ".vscode", "mcp.json");
+      return join10(projectRoot, ".vscode", "mcp.json");
     }
-    const home = homedir8();
+    const home = homedir10();
     if (process.platform === "win32") {
-      return join8(home, "AppData", "Roaming", "Code", "User", "settings.json");
+      return join10(home, "AppData", "Roaming", "Code", "User", "settings.json");
     } else if (process.platform === "darwin") {
-      return join8(home, "Library", "Application Support", "Code", "User", "settings.json");
+      return join10(home, "Library", "Application Support", "Code", "User", "settings.json");
     } else {
-      return join8(home, ".config", "Code", "User", "settings.json");
+      return join10(home, ".config", "Code", "User", "settings.json");
     }
   }
 };
 
 // src/workspace/mcp-adapters/antigravity.ts
 init_esm_shims();
-import { homedir as homedir9 } from "os";
-import { join as join9 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join11 } from "path";
 var AntigravityMCPAdapter = class {
   source = "antigravity";
   parse(content) {
@@ -7430,16 +9090,16 @@ var AntigravityMCPAdapter = class {
   }
   getConfigPath(projectRoot) {
     if (projectRoot) {
-      return join9(projectRoot, ".gemini", "settings.json");
+      return join11(projectRoot, ".gemini", "settings.json");
     }
-    return join9(homedir9(), ".gemini", "settings.json");
+    return join11(homedir11(), ".gemini", "settings.json");
   }
 };
 
 // src/workspace/mcp-adapters/kiro.ts
 init_esm_shims();
-import { homedir as homedir10 } from "os";
-import { join as join10 } from "path";
+import { homedir as homedir12 } from "os";
+import { join as join12 } from "path";
 var KiroMCPAdapter = class {
   source = "kiro";
   parse(content) {
@@ -7479,16 +9139,16 @@ var KiroMCPAdapter = class {
   }
   getConfigPath(projectRoot) {
     if (projectRoot) {
-      return join10(projectRoot, ".kiro", "settings", "mcp.json");
+      return join12(projectRoot, ".kiro", "settings", "mcp.json");
     }
-    return join10(homedir10(), ".kiro", "settings", "mcp.json");
+    return join12(homedir12(), ".kiro", "settings", "mcp.json");
   }
 };
 
 // src/workspace/mcp-adapters/opencode.ts
 init_esm_shims();
-import { homedir as homedir11 } from "os";
-import { join as join11 } from "path";
+import { homedir as homedir13 } from "os";
+import { join as join13 } from "path";
 var OpenCodeMCPAdapter = class {
   source = "opencode";
   parse(content) {
@@ -7553,16 +9213,16 @@ var OpenCodeMCPAdapter = class {
   }
   getConfigPath(projectRoot) {
     if (projectRoot) {
-      return join11(projectRoot, "opencode.json");
+      return join13(projectRoot, "opencode.json");
     }
-    return join11(homedir11(), ".config", "opencode", "opencode.json");
+    return join13(homedir13(), ".config", "opencode", "opencode.json");
   }
 };
 
 // src/workspace/mcp-adapters/trae.ts
 init_esm_shims();
-import { join as join12 } from "path";
-import { homedir as homedir12 } from "os";
+import { join as join14 } from "path";
+import { homedir as homedir14 } from "os";
 var TraeMCPAdapter = class {
   source = "trae";
   parse(content) {
@@ -7626,14 +9286,14 @@ var TraeMCPAdapter = class {
     return JSON.stringify({ mcpServers }, null, 2);
   }
   getConfigPath(_projectRoot) {
-    const home = homedir12();
+    const home = homedir14();
     if (process.platform === "win32") {
-      return join12(process.env.APPDATA || join12(home, "AppData", "Roaming"), "Trae", "User", "mcp.json");
+      return join14(process.env.APPDATA || join14(home, "AppData", "Roaming"), "Trae", "User", "mcp.json");
     }
     if (process.platform === "darwin") {
-      return join12(home, "Library", "Application Support", "Trae", "User", "mcp.json");
+      return join14(home, "Library", "Application Support", "Trae", "User", "mcp.json");
     }
-    return join12(home, ".config", "Trae", "User", "mcp.json");
+    return join14(home, ".config", "Trae", "User", "mcp.json");
   }
 };
 
@@ -7765,7 +9425,7 @@ function sanitize(input) {
 
 // src/workspace/applier.ts
 init_esm_shims();
-import { existsSync as existsSync3, mkdirSync, copyFileSync, writeFileSync, unlinkSync, renameSync } from "fs";
+import { existsSync as existsSync5, mkdirSync, copyFileSync, writeFileSync, unlinkSync, renameSync } from "fs";
 import { dirname } from "path";
 var WorkspaceSyncApplier = class {
   /**
@@ -7791,7 +9451,7 @@ var WorkspaceSyncApplier = class {
     for (const file of files) {
       try {
         const dir = dirname(file.filePath);
-        if (!existsSync3(dir)) {
+        if (!existsSync5(dir)) {
           mkdirSync(dir, { recursive: true });
         }
       } catch (err) {
@@ -7800,7 +9460,7 @@ var WorkspaceSyncApplier = class {
       }
     }
     for (const file of files) {
-      if (existsSync3(file.filePath)) {
+      if (existsSync5(file.filePath)) {
         try {
           const backupPath = file.filePath + `.backup-${Date.now()}`;
           copyFileSync(file.filePath, backupPath);
@@ -7851,7 +9511,7 @@ var WorkspaceSyncApplier = class {
   cleanBackups(backups) {
     for (const backup of backups) {
       try {
-        if (existsSync3(backup.backupPath)) {
+        if (existsSync5(backup.backupPath)) {
           unlinkSync(backup.backupPath);
         }
       } catch {
@@ -7901,13 +9561,13 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
       const globalPath = adapter.getConfigPath();
       const pathsToCheck = [configPath, globalPath];
       if (target === "antigravity") {
-        pathsToCheck.push(join14(homedir13(), ".gemini", "antigravity", "mcp_config.json"));
+        pathsToCheck.push(join16(homedir15(), ".gemini", "antigravity", "mcp_config.json"));
       }
       const merged = /* @__PURE__ */ new Map();
-      for (const path9 of pathsToCheck) {
-        if (existsSync4(path9)) {
+      for (const path11 of pathsToCheck) {
+        if (existsSync6(path11)) {
           try {
-            const content = readFileSync3(path9, "utf-8");
+            const content = readFileSync5(path11, "utf-8");
             const servers = adapter.parse(content);
             for (const s of servers) {
               if (!merged.has(s.name)) merged.set(s.name, s);
@@ -7959,9 +9619,9 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
       const adapter = this.adapters.get(target);
       const configPath = adapter.getConfigPath(this.projectRoot);
       let configContent;
-      if (target === "antigravity" && existsSync4(configPath)) {
+      if (target === "antigravity" && existsSync6(configPath)) {
         try {
-          const existing = JSON.parse(readFileSync3(configPath, "utf-8"));
+          const existing = JSON.parse(readFileSync5(configPath, "utf-8"));
           const generated = JSON.parse(adapter.generate(result.mcpServers.scanned));
           existing.mcpServers = { ...existing.mcpServers ?? {}, ...generated.mcpServers };
           configContent = JSON.stringify(existing, null, 2);
@@ -8014,7 +9674,7 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
   getTargetSkillsDir(target) {
     const dirs = _WorkspaceSyncEngine.SKILLS_DIRS[target];
     if (!dirs || dirs.length === 0) return null;
-    return join14(this.projectRoot, dirs[0]);
+    return join16(this.projectRoot, dirs[0]);
   }
   /**
    * Scan all agent skills directories and collect unique skills.
@@ -8023,24 +9683,24 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
     const skills = [];
     const conflicts = [];
     const seen = /* @__PURE__ */ new Map();
-    const home = homedir13();
+    const home = homedir15();
     for (const [agent, dirs] of Object.entries(_WorkspaceSyncEngine.SKILLS_DIRS)) {
       for (const dir of dirs) {
         const paths = [
-          join14(this.projectRoot, dir),
-          join14(home, dir)
+          join16(this.projectRoot, dir),
+          join16(home, dir)
         ];
         for (const skillsRoot of paths) {
-          if (!existsSync4(skillsRoot)) continue;
+          if (!existsSync6(skillsRoot)) continue;
           try {
-            const entries = readdirSync(skillsRoot, { withFileTypes: true });
+            const entries = readdirSync2(skillsRoot, { withFileTypes: true });
             for (const entry of entries) {
               if (!entry.isDirectory()) continue;
-              const skillMd = join14(skillsRoot, entry.name, "SKILL.md");
-              if (!existsSync4(skillMd)) continue;
+              const skillMd = join16(skillsRoot, entry.name, "SKILL.md");
+              if (!existsSync6(skillMd)) continue;
               let description = "";
               try {
-                const content = readFileSync3(skillMd, "utf-8");
+                const content = readFileSync5(skillMd, "utf-8");
                 const match = content.match(/^---[\s\S]*?description:\s*["']?(.+?)["']?\s*$/m);
                 if (match) description = match[1];
               } catch {
@@ -8048,7 +9708,7 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
               const newEntry = {
                 name: entry.name,
                 description,
-                sourcePath: join14(skillsRoot, entry.name),
+                sourcePath: join16(skillsRoot, entry.name),
                 sourceAgent: agent
               };
               const existing = seen.get(entry.name);
@@ -8085,8 +9745,8 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
     }
     for (const skill of skills) {
       if (skill.sourceAgent === target) continue;
-      const dest = join14(targetDir, skill.name);
-      if (existsSync4(dest)) {
+      const dest = join16(targetDir, skill.name);
+      if (existsSync6(dest)) {
         skipped.push(`${skill.name} (already exists in ${target})`);
         continue;
       }
@@ -8101,13 +9761,13 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
   }
   scanWorkflows() {
     const workflows = [];
-    const wfDir = join14(this.projectRoot, ".windsurf", "workflows");
-    if (!existsSync4(wfDir)) return workflows;
+    const wfDir = join16(this.projectRoot, ".windsurf", "workflows");
+    if (!existsSync6(wfDir)) return workflows;
     try {
-      const files = readdirSync(wfDir).filter((f) => f.endsWith(".md"));
+      const files = readdirSync2(wfDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
         try {
-          const content = readFileSync3(join14(wfDir, file), "utf-8");
+          const content = readFileSync5(join16(wfDir, file), "utf-8");
           workflows.push(this.workflowSyncer.parseWindsurfWorkflow(file, content));
         } catch {
         }
@@ -8207,6 +9867,7 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
 // src/server.ts
 init_provider2();
 init_memory_manager();
+init_formation();
 var lastInternalWriteMs = 0;
 var markInternalWrite = () => {
   lastInternalWriteMs = Date.now();
@@ -8215,6 +9876,7 @@ var OBSERVATION_TYPES = [
   "session-request",
   "gotcha",
   "problem-solution",
+  "reasoning",
   "how-it-works",
   "what-changed",
   "discovery",
@@ -8233,6 +9895,29 @@ function coerceNumberArray(val) {
   }
   return [];
 }
+function coerceObservationRefs(val) {
+  if (Array.isArray(val)) {
+    const refs = [];
+    for (const item of val) {
+      if (!item || typeof item !== "object") continue;
+      const record = item;
+      const id = Number(record["id"]);
+      if (!Number.isFinite(id) || id <= 0) continue;
+      const projectId = typeof record["projectId"] === "string" ? record["projectId"] : void 0;
+      refs.push(projectId ? { id, projectId } : { id });
+    }
+    return refs;
+  }
+  if (typeof val === "string") {
+    try {
+      const parsed = JSON.parse(val);
+      return coerceObservationRefs(parsed);
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
 function coerceNumber(val, fallback) {
   if (typeof val === "number") return val;
   if (typeof val === "string") {
@@ -8275,7 +9960,17 @@ function coerceObjectArray(val) {
   return [];
 }
 async function createMemorixServer(cwd, existingServer, sharedTeam) {
-  const rawProject = detectProject(cwd);
+  const detectedProject = detectProject(cwd);
+  let rawProject;
+  if (detectedProject) {
+    rawProject = detectedProject;
+  } else {
+    const basePath = cwd ?? process.cwd();
+    const name = (await import("path")).basename(basePath) || "unknown";
+    rawProject = { id: `untracked/${name}`, name, rootPath: basePath };
+    console.error(`[memorix] WARNING: No .git found in "${basePath}" \u2014 project isolation degraded`);
+    console.error(`[memorix] Run "git init" in your project for proper isolation.`);
+  }
   try {
     const { migrateSubdirsToFlat: migrateSubdirsToFlat2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
     const migrated = await migrateSubdirsToFlat2();
@@ -8284,14 +9979,21 @@ async function createMemorixServer(cwd, existingServer, sharedTeam) {
     }
   } catch {
   }
-  const projectDir2 = await getProjectDataDir(rawProject.id);
+  let projectDir2 = await getProjectDataDir(rawProject.id);
   initAliasRegistry(projectDir2);
   const canonicalId = await registerAlias(rawProject);
-  const project = { ...rawProject, id: canonicalId };
+  let project = { ...rawProject, id: canonicalId };
   if (canonicalId !== rawProject.id) {
     console.error(`[memorix] Alias resolved: ${rawProject.id} \u2192 ${canonicalId}`);
   }
-  const graphManager = new KnowledgeGraphManager(projectDir2);
+  try {
+    const { initProjectRoot: initProjectRoot2 } = await Promise.resolve().then(() => (init_yaml_loader(), yaml_loader_exports));
+    initProjectRoot2(project.rootPath);
+    const { loadDotenv: loadDotenv2 } = await Promise.resolve().then(() => (init_dotenv_loader(), dotenv_loader_exports));
+    loadDotenv2(project.rootPath);
+  } catch {
+  }
+  let graphManager = new KnowledgeGraphManager(projectDir2);
   await graphManager.init();
   await initObservations(projectDir2);
   try {
@@ -8338,7 +10040,7 @@ async function createMemorixServer(cwd, existingServer, sharedTeam) {
   let syncAdvisory = null;
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.0.2" : "1.0.1"
+    version: true ? "1.0.4" : "1.0.1"
   });
   server.registerTool(
     "memorix_store",
@@ -8360,16 +10062,148 @@ async function createMemorixServer(cwd, existingServer, sharedTeam) {
           feature: z.string().describe("Feature or task name"),
           status: z.enum(["in-progress", "completed", "blocked"]).describe("Current status"),
           completion: z.number().optional().describe("Completion percentage 0-100")
-        }).optional().describe("Progress tracking for task/feature observations")
+        }).optional().describe("Progress tracking for task/feature observations"),
+        relatedCommits: z.array(z.string()).optional().describe("Git commit hashes this memory relates to (links ground truth \u2194 reasoning)"),
+        relatedEntities: z.array(z.string()).optional().describe("Other entity names this memory cross-references")
       }
     },
-    async ({ entityName, type, title, narrative, facts, filesModified, concepts, topicKey, progress }) => {
-      const safeFacts = facts ? coerceStringArray(facts) : void 0;
+    async ({ entityName: rawEntityName, type: rawType, title: rawTitle, narrative, facts, filesModified, concepts, topicKey, progress, relatedCommits, relatedEntities }) => {
+      let entityName = rawEntityName;
+      let type = rawType;
+      let title = rawTitle;
+      let safeFacts = facts ? coerceStringArray(facts) : void 0;
       const safeFiles = filesModified ? coerceStringArray(filesModified) : void 0;
       const safeConcepts = concepts ? coerceStringArray(concepts) : void 0;
+      let formationMode = "active";
+      if (process.env.MEMORIX_FORMATION_MODE) {
+        formationMode = process.env.MEMORIX_FORMATION_MODE;
+      } else {
+        try {
+          const { getBehaviorConfig: getBehaviorConfig2 } = await Promise.resolve().then(() => (init_behavior(), behavior_exports));
+          formationMode = getBehaviorConfig2().formationMode;
+        } catch {
+        }
+      }
+      const useFormation = formationMode === "active";
+      let formationResult = null;
+      let formationNote = "";
+      if (useFormation && !topicKey && !progress) {
+        try {
+          const formationConfig = {
+            mode: "active",
+            useLLM: isLLMEnabled(),
+            minValueScore: 0.3,
+            searchMemories: async (q, limit, pid) => {
+              const result = await compactSearch({ query: q, limit, projectId: pid, status: "active" });
+              if (result.entries.length === 0) return [];
+              const details = await compactDetail(result.entries.map((e) => e.id));
+              return details.documents.map((d, i) => ({
+                id: Number(d.id.replace("obs-", "")),
+                observationId: d.observationId,
+                title: d.title,
+                narrative: d.narrative,
+                facts: d.facts,
+                entityName: d.entityName,
+                type: d.type,
+                score: result.entries[i]?.score ?? 0
+              }));
+            },
+            getObservation: (id) => {
+              const o = getObservation(id);
+              if (!o) return null;
+              return {
+                id: o.id,
+                entityName: o.entityName,
+                type: o.type,
+                title: o.title,
+                narrative: o.narrative,
+                facts: o.facts,
+                topicKey: o.topicKey
+              };
+            },
+            getEntityNames: () => graphManager.getEntityNames()
+          };
+          formationResult = await runFormation({
+            entityName,
+            type,
+            title,
+            narrative,
+            facts: safeFacts,
+            projectId: project.id,
+            source: "explicit"
+          }, formationConfig);
+          const modeIcon = "\u26A1";
+          formationNote = `
+${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formationResult.evaluation.score.toFixed(2)}) | ${formationResult.resolution.action} | ${formationResult.pipeline.durationMs}ms`;
+          if (formationResult.extraction.extractedFacts.length > 0) {
+            formationNote += ` | +${formationResult.extraction.extractedFacts.length} facts`;
+          }
+          if (formationResult.extraction.titleImproved) formationNote += " | title\u2191";
+          if (formationResult.extraction.entityResolved) formationNote += ` | entity\u2192${formationResult.entityName}`;
+          if (formationResult.extraction.typeCorrected) formationNote += ` | type\u2192${formationResult.type}`;
+        } catch {
+        }
+      }
+      if (useFormation && formationResult && formationResult.resolution.action !== "new") {
+        const { action: action2, targetId, reason } = formationResult.resolution;
+        if (action2 === "merge" && targetId) {
+          const targetObs = getObservation(targetId);
+          if (targetObs) {
+            markInternalWrite();
+            await storeObservation({
+              entityName: targetObs.entityName,
+              type: targetObs.type,
+              title: formationResult.title,
+              narrative: formationResult.narrative,
+              facts: formationResult.facts,
+              filesModified: safeFiles,
+              concepts: safeConcepts,
+              projectId: project.id,
+              topicKey: targetObs.topicKey,
+              progress
+            });
+            return {
+              content: [{
+                type: "text",
+                text: `\u{1F504} Formation MERGE: merged into #${targetId} (${reason})${formationNote}`
+              }]
+            };
+          }
+        } else if (action2 === "evolve" && targetId) {
+          const targetObs = getObservation(targetId);
+          if (targetObs) {
+            markInternalWrite();
+            await storeObservation({
+              entityName: targetObs.entityName,
+              type: targetObs.type,
+              title: formationResult.title,
+              narrative: formationResult.narrative,
+              facts: formationResult.facts,
+              filesModified: safeFiles,
+              concepts: safeConcepts,
+              projectId: project.id,
+              topicKey: targetObs.topicKey,
+              progress
+            });
+            return {
+              content: [{
+                type: "text",
+                text: `\u{1F504} Formation EVOLVE: evolved #${targetId} (${reason})${formationNote}`
+              }]
+            };
+          }
+        } else if (action2 === "discard") {
+          return {
+            content: [{
+              type: "text",
+              text: `\u23ED\uFE0F Formation DISCARD: ${reason}${formationNote}`
+            }]
+          };
+        }
+      }
       let compactAction = "";
       let compactMerged = false;
-      if (!topicKey && !progress) {
+      if (!useFormation && !topicKey && !progress) {
         try {
           const searchResult = await compactSearch({
             query: `${title} ${narrative.substring(0, 200)}`,
@@ -8443,6 +10277,26 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
         } catch {
         }
       }
+      if (formationResult && formationResult.resolution.action === "new") {
+        const llmFacts = formationResult.extraction.extractedFacts;
+        if (llmFacts.length > 0) {
+          const currentFacts = safeFacts ?? [];
+          const currentLower = new Set(currentFacts.map((f) => f.toLowerCase().trim()));
+          const newFacts = llmFacts.filter((f) => !currentLower.has(f.toLowerCase().trim()));
+          if (newFacts.length > 0) {
+            safeFacts = [...currentFacts, ...newFacts];
+          }
+        }
+        if (formationResult.extraction.titleImproved && formationResult.title) {
+          title = formationResult.title;
+        }
+        if (formationResult.extraction.typeCorrected && formationResult.type) {
+          type = formationResult.type;
+        }
+        if (formationResult.extraction.entityResolved && formationResult.entityName) {
+          entityName = formationResult.entityName;
+        }
+      }
       await graphManager.createEntities([
         { name: entityName, entityType: "auto", observations: [] }
       ]);
@@ -8476,7 +10330,9 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
         projectId: project.id,
         topicKey,
         sessionId,
-        progress
+        progress,
+        relatedCommits,
+        relatedEntities
       });
       await graphManager.addObservations([
         { entityName, contents: [`[#${obs.id}] ${title}`] }
@@ -8494,12 +10350,123 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
       const enrichment = enrichmentParts.length > 0 ? `
 Auto-enriched: ${enrichmentParts.join(", ")}` : "";
       const action = upserted ? "\u{1F504} Updated" : "\u2705 Stored";
+      if (!useFormation) {
+        try {
+          let oldCompactDecision = null;
+          if (!topicKey && !progress) {
+            try {
+              const compactStart = Date.now();
+              const searchResult = await compactSearch({
+                query: `${title} ${narrative.substring(0, 200)}`,
+                limit: 5,
+                projectId: project.id,
+                status: "active"
+              });
+              const similarEntries = searchResult.entries.map((e) => e);
+              if (similarEntries.length > 0) {
+                const similarIds = similarEntries.map((e) => e.id);
+                const details = await compactDetail(similarIds);
+                const existingMemories = details.documents.map((d, i) => ({
+                  id: d.observationId,
+                  title: d.title,
+                  narrative: d.narrative,
+                  facts: d.facts,
+                  score: similarEntries[i]?.score ?? 0
+                }));
+                const decision = await compactOnWrite(
+                  { title, narrative, facts: safeFacts ?? [] },
+                  existingMemories
+                );
+                const compactDuration = Date.now() - compactStart;
+                oldCompactDecision = {
+                  action: decision.action,
+                  targetId: decision.targetId,
+                  reason: decision.reason,
+                  durationMs: compactDuration
+                };
+              }
+            } catch {
+            }
+          }
+          const formationConfig = {
+            mode: formationMode,
+            useLLM: isLLMEnabled(),
+            minValueScore: 0.3,
+            searchMemories: async (q, limit, pid) => {
+              const result = await compactSearch({ query: q, limit, projectId: pid, status: "active" });
+              if (result.entries.length === 0) return [];
+              const details = await compactDetail(result.entries.map((e) => e.id));
+              return details.documents.map((d, i) => ({
+                id: Number(d.id.replace("obs-", "")),
+                observationId: d.observationId,
+                title: d.title,
+                narrative: d.narrative,
+                facts: d.facts,
+                entityName: d.entityName,
+                type: d.type,
+                score: result.entries[i]?.score ?? 0
+              }));
+            },
+            getObservation: (id) => {
+              const o = getObservation(id);
+              if (!o) return null;
+              return {
+                id: o.id,
+                entityName: o.entityName,
+                type: o.type,
+                title: o.title,
+                narrative: o.narrative,
+                facts: o.facts,
+                topicKey: o.topicKey
+              };
+            },
+            getEntityNames: () => graphManager.getEntityNames()
+          };
+          const formed = await runFormation({
+            entityName,
+            type,
+            title,
+            narrative,
+            facts: safeFacts,
+            projectId: project.id,
+            source: "explicit",
+            topicKey
+          }, formationConfig);
+          const { recordBeforeAfterMetrics: recordBeforeAfterMetrics2 } = await Promise.resolve().then(() => (init_formation(), formation_exports));
+          if (oldCompactDecision) {
+            recordBeforeAfterMetrics2({
+              formationAction: formed.resolution.action,
+              formationTargetId: formed.resolution.targetId,
+              oldCompactAction: oldCompactDecision.action,
+              oldCompactTargetId: oldCompactDecision.targetId,
+              oldCompactReason: oldCompactDecision.reason,
+              formationValueScore: formed.evaluation.score,
+              formationValueCategory: formed.evaluation.category,
+              formationDurationMs: formed.pipeline.durationMs,
+              compactDurationMs: oldCompactDecision.durationMs
+            });
+          }
+          const modeIcon = formationMode === "shadow" ? "\u{1F52C}" : "\u{1F6E1}\uFE0F";
+          formationNote = `
+${modeIcon} Formation[${formationMode}]: ${formed.evaluation.category} (${formed.evaluation.score.toFixed(2)}) | ${formed.resolution.action} | ${formed.pipeline.durationMs}ms`;
+          if (oldCompactDecision) {
+            formationNote += ` | Compact: ${oldCompactDecision.action}${oldCompactDecision.targetId ? ` #${oldCompactDecision.targetId}` : ""}${oldCompactDecision.durationMs ? ` (${oldCompactDecision.durationMs}ms)` : ""}`;
+          }
+          if (formed.extraction.extractedFacts.length > 0) {
+            formationNote += ` | +${formed.extraction.extractedFacts.length} facts`;
+          }
+          if (formed.extraction.titleImproved) formationNote += " | title\u2191";
+          if (formed.extraction.entityResolved) formationNote += ` | entity\u2192${formed.entityName}`;
+          if (formed.extraction.typeCorrected) formationNote += ` | type\u2192${formed.type}`;
+        } catch {
+        }
+      }
       return {
         content: [
           {
             type: "text",
             text: `${action} observation #${obs.id} "${title}" (~${obs.tokens} tokens)
-Entity: ${entityName} | Type: ${type} | Project: ${project.id}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ""}${compactAction}${compressionNote}${enrichment}`
+Entity: ${entityName} | Type: ${type} | Project: ${project.id}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ""}${compactAction}${compressionNote}${enrichment}${formationNote}`
           }
         ]
       };
@@ -8548,13 +10515,17 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
         until: z.string().optional().describe('Only return observations created before this date (ISO 8601 or natural like "2025-02-01")'),
         status: z.enum(["active", "resolved", "archived", "all"]).optional().default("active").describe(
           'Filter by memory status. "active" (default) shows current memories, "all" includes resolved/archived.'
+        ),
+        source: z.enum(["agent", "git", "manual"]).optional().describe(
+          'Filter by memory source. "git" returns only commit-derived ground truth memories. Omit for all sources.'
         )
       }
     },
-    async ({ query, limit, type, maxTokens, scope, since, until, status }) => {
+    async ({ query, limit, type, maxTokens, scope, since, until, status, source }) => {
       const safeLimit = limit != null ? coerceNumber(limit, 20) : void 0;
       const safeMaxTokens = maxTokens != null ? coerceNumber(maxTokens, 0) : void 0;
-      const result = await compactSearch({
+      const TIMEOUT_MS = 3e4;
+      const searchPromise = compactSearch({
         query,
         limit: safeLimit,
         type,
@@ -8564,8 +10535,29 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
         // Default to project-scoped search to prevent cross-project pollution.
         // Use scope: 'global' to explicitly search all projects.
         projectId: scope === "global" ? void 0 : project.id,
-        status: status ?? "active"
+        status: status ?? "active",
+        source
       });
+      const timeoutPromise = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Search timeout after ${TIMEOUT_MS}ms`)), TIMEOUT_MS)
+      );
+      let result;
+      try {
+        result = await Promise.race([searchPromise, timeoutPromise]);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("timeout")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Search timeout after ${TIMEOUT_MS}ms. Try a simpler query or check if the service is responsive.`
+              }
+            ],
+            isError: true
+          };
+        }
+        throw error;
+      }
       let text = result.formatted;
       if (!syncAdvisoryShown && syncAdvisory) {
         text += syncAdvisory;
@@ -8610,6 +10602,102 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
       };
     }
   );
+  server.registerTool(
+    "memorix_store_reasoning",
+    {
+      title: "Store Reasoning Trace",
+      description: "Store a reasoning trace \u2014 WHY you chose this approach, what alternatives you considered, and what outcome you expect. This creates a searchable record of your decision-making process. Use this when making non-trivial technical decisions, choosing between approaches, or solving complex problems. Unlike regular memories that record WHAT happened, reasoning memories record HOW you thought about it.",
+      inputSchema: {
+        entityName: z.string().describe('The entity this reasoning applies to (e.g., "auth-module", "database-schema")'),
+        decision: z.string().describe("What was decided or chosen"),
+        alternatives: z.array(z.string()).optional().describe("Other options that were considered"),
+        rationale: z.string().describe("Why this approach was chosen over alternatives"),
+        constraints: z.array(z.string()).optional().describe("Constraints that influenced the decision (time, perf, compat, etc.)"),
+        expectedOutcome: z.string().optional().describe("What outcome is expected from this decision"),
+        risks: z.array(z.string()).optional().describe("Known risks or potential downsides"),
+        concepts: z.array(z.string()).optional().describe("Related technical concepts"),
+        filesModified: z.array(z.string()).optional().describe("Files related to this reasoning"),
+        relatedCommits: z.array(z.string()).optional().describe("Git commit hashes this reasoning explains (links ground truth \u2194 reasoning)"),
+        relatedEntities: z.array(z.string()).optional().describe("Other entity names this reasoning relates to (cross-references)")
+      }
+    },
+    async ({ entityName, decision, alternatives, rationale, constraints, expectedOutcome, risks, concepts, filesModified, relatedCommits, relatedEntities }) => {
+      const narrativeParts = [rationale];
+      if (alternatives && alternatives.length > 0) {
+        narrativeParts.push(`Alternatives considered: ${alternatives.join("; ")}`);
+      }
+      if (constraints && constraints.length > 0) {
+        narrativeParts.push(`Constraints: ${constraints.join("; ")}`);
+      }
+      if (expectedOutcome) {
+        narrativeParts.push(`Expected outcome: ${expectedOutcome}`);
+      }
+      const narrative = narrativeParts.join(". ");
+      const facts = [`Decision: ${decision}`];
+      if (alternatives) alternatives.forEach((a) => facts.push(`Alternative considered: ${a}`));
+      if (constraints) constraints.forEach((c) => facts.push(`Constraint: ${c}`));
+      if (risks) risks.forEach((r) => facts.push(`Risk: ${r}`));
+      if (expectedOutcome) facts.push(`Expected outcome: ${expectedOutcome}`);
+      await graphManager.createEntities([
+        { name: entityName, entityType: "auto", observations: [] }
+      ]);
+      markInternalWrite();
+      const { observation: obs } = await storeObservation({
+        entityName,
+        type: "reasoning",
+        title: decision.length > 80 ? decision.substring(0, 77) + "..." : decision,
+        narrative,
+        facts,
+        concepts: concepts ?? [],
+        filesModified: filesModified ?? [],
+        projectId: project.id,
+        source: "agent",
+        relatedCommits,
+        relatedEntities
+      });
+      await graphManager.addObservations([
+        { entityName, contents: [`[#${obs.id}] \u{1F9E0} ${decision}`] }
+      ]);
+      return {
+        content: [{
+          type: "text",
+          text: `\u{1F9E0} Reasoning trace stored #${obs.id}: "${decision}"
+Entity: ${entityName} | ${facts.length} facts | ${obs.tokens} tokens`
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "memorix_search_reasoning",
+    {
+      title: "Search Reasoning Patterns",
+      description: "Search past reasoning traces to understand WHY decisions were made. Returns reasoning memories that explain the thought process behind technical choices. Use this when revisiting code, questioning a design decision, or looking for precedent on how similar problems were solved before.",
+      inputSchema: {
+        query: z.string().describe('Search query \u2014 describe what reasoning you want to find (e.g., "why did we choose PostgreSQL", "auth approach rationale")'),
+        limit: z.number().optional().describe("Max results (default: 10)"),
+        scope: z.enum(["project", "global"]).optional().default("project").describe("Search scope")
+      }
+    },
+    async ({ query, limit, scope }) => {
+      const safeLimit = limit != null ? coerceNumber(limit, 10) : 10;
+      const result = await compactSearch({
+        query,
+        limit: safeLimit,
+        type: "reasoning",
+        projectId: scope === "global" ? void 0 : project.id,
+        status: "active"
+      });
+      if (result.entries.length === 0) {
+        return {
+          content: [{ type: "text", text: "No reasoning traces found. Use memorix_store_reasoning to record decision rationale." }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `\u{1F9E0} Reasoning Traces:
+${result.formatted}` }]
+      };
+    }
+  );
   server.registerTool(
     "memorix_deduplicate",
     {
@@ -8742,19 +10830,27 @@ ${actions.join("\n")}`
     "memorix_detail",
     {
       title: "Memory Details",
-      description: "Fetch full observation details by IDs (~500-1000 tokens each). Always use memorix_search first to find relevant IDs, then fetch only what you need.",
+      description: "Fetch full observation details by IDs (~500-1000 tokens each). Always use memorix_search first to find relevant IDs, then fetch only what you need. For global search results, prefer refs with projectId to avoid cross-project ID ambiguity.",
       inputSchema: {
-        ids: z.array(z.number()).describe("Observation IDs to fetch (from memorix_search results)")
+        ids: z.array(z.number()).optional().describe("Observation IDs to fetch (from memorix_search results)"),
+        refs: z.array(
+          z.object({
+            id: z.number().describe("Observation ID"),
+            projectId: z.string().optional().describe("Project ID for global-search disambiguation")
+          })
+        ).optional().describe("Explicit observation refs. Prefer this for global search results.")
       }
     },
-    async ({ ids }) => {
+    async ({ ids, refs }) => {
       const safeIds = coerceNumberArray(ids);
-      const result = await compactDetail(safeIds);
+      const safeRefs = coerceObservationRefs(refs);
+      const detailInput = safeRefs.length > 0 ? safeRefs : safeIds;
+      const result = await compactDetail(detailInput);
       return {
         content: [
           {
             type: "text",
-            text: result.documents.length > 0 ? result.formatted : `No observations found for IDs: ${safeIds.join(", ")}`
+            text: result.documents.length > 0 ? result.formatted : safeRefs.length > 0 ? `No observations found for refs: ${safeRefs.map((ref) => `${ref.projectId ?? "current"}#${ref.id}`).join(", ")}` : `No observations found for IDs: ${safeIds.join(", ")}`
           }
         ]
       };
@@ -8804,7 +10900,8 @@ Archived memories can be restored manually if needed.` }]
         projectId: obs.projectId,
         accessCount: 0,
         lastAccessedAt: "",
-        status: obs.status ?? "active"
+        status: obs.status ?? "active",
+        source: obs.source ?? "agent"
       }));
       if (docs.length === 0) {
         return {
@@ -8854,12 +10951,89 @@ Archived memories can be restored manually if needed.` }]
       };
     }
   );
+  server.registerTool(
+    "memorix_formation_metrics",
+    {
+      title: "Formation Pipeline Metrics",
+      description: "Show aggregated metrics from recent Memory Formation Pipeline runs. Reports value scores, resolution actions, fact extraction rates, and processing times.",
+      inputSchema: {}
+    },
+    async () => {
+      const summary = getMetricsSummary();
+      const beforeAfter = getBeforeAfterMetrics();
+      if (summary.total === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "\u{1F4CA} Formation Pipeline: No metrics collected yet.\nStore some observations to start collecting runtime data."
+          }]
+        };
+      }
+      const lines = [
+        "\u{1F4CA} **Formation Pipeline Metrics**",
+        "",
+        `**Total observations processed:** ${summary.total}`,
+        `**Average value score:** ${summary.avgValueScore.toFixed(3)}`,
+        `**Average processing time:** ${summary.avgDurationMs.toFixed(1)}ms`,
+        "",
+        "### Quality Indicators",
+        `- **Avg system-extracted facts:** ${summary.avgExtractedFacts.toFixed(1)} per observation`,
+        `- **Title improved rate:** ${(summary.titleImprovedRate * 100).toFixed(1)}%`,
+        `- **Entity resolved rate:** ${(summary.entityResolvedRate * 100).toFixed(1)}%`,
+        `- **Type corrected rate:** ${(summary.typeCorectedRate * 100).toFixed(1)}%`,
+        "",
+        "### Value Categories"
+      ];
+      for (const [cat, count2] of Object.entries(summary.categoryBreakdown)) {
+        const pct = (count2 / summary.total * 100).toFixed(1);
+        const icon = cat === "core" ? "\u{1F7E2}" : cat === "contextual" ? "\u{1F7E1}" : "\u{1F534}";
+        lines.push(`- ${icon} **${cat}:** ${count2} (${pct}%)`);
+      }
+      lines.push("", "### Resolution Actions");
+      for (const [action, count2] of Object.entries(summary.resolutionBreakdown)) {
+        const pct = (count2 / summary.total * 100).toFixed(1);
+        lines.push(`- **${action}:** ${count2} (${pct}%)`);
+      }
+      if (beforeAfter.totalProcessed > 0) {
+        lines.push(
+          "",
+          "### Before/After Comparison (Formation vs Old Compact)",
+          `**Total comparisons:** ${beforeAfter.totalProcessed}`,
+          `**Agreements:** ${beforeAfter.agreements} (${(beforeAfter.agreements / beforeAfter.totalProcessed * 100).toFixed(1)}%)`,
+          `**Disagreements:** ${beforeAfter.disagreements} (${(beforeAfter.disagreements / beforeAfter.totalProcessed * 100).toFixed(1)}%)`,
+          "",
+          "### Disagreement Breakdown",
+          `- Formation discarded, Compact added: ${beforeAfter.disagreementBreakdown.formationDiscardedCompactAdded}`,
+          `- Formation merged, Compact added: ${beforeAfter.disagreementBreakdown.formationMergedCompactAdded}`,
+          `- Formation added, Compact discarded: ${beforeAfter.disagreementBreakdown.formationAddedCompactDiscarded}`,
+          "- Formation added, Compact merged: " + beforeAfter.disagreementBreakdown.formationAddedCompactMerged,
+          "- Formation evolved, Compact added: " + beforeAfter.disagreementBreakdown.formationEvolvedCompactAdded,
+          "- Other: " + beforeAfter.disagreementBreakdown.other,
+          "",
+          "### Quality Improvements",
+          `- Formation discarded low-value: ${beforeAfter.quality.formationDiscardedLowValue}`,
+          `- Formation merged duplicates: ${beforeAfter.quality.formationMergedDuplicates}`,
+          `- Formation evolved outdated: ${beforeAfter.quality.formationEvolvedOutdated}`,
+          `- Compact missed duplicates: ${beforeAfter.quality.compactMissedDuplicates}`,
+          `- Compact kept low-value: ${beforeAfter.quality.compactKeptLowValue}`,
+          "",
+          `### Duration Comparison`,
+          `- Formation avg: ${beforeAfter.duration.formationAvgMs.toFixed(1)}ms`,
+          `- Compact avg: ${beforeAfter.duration.compactAvgMs.toFixed(1)}ms`,
+          `- Diff: ${beforeAfter.duration.diffMs.toFixed(1)}ms`
+        );
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
   let enableKG = false;
   try {
-    const { homedir: homedir16 } = await import("os");
-    const { join: join17 } = await import("path");
-    const { readFile: readFile5 } = await import("fs/promises");
-    const raw = await readFile5(join17(homedir16(), ".memorix", "settings.json"), "utf-8");
+    const { homedir: homedir20 } = await import("os");
+    const { join: join21 } = await import("path");
+    const { readFile: readFile6 } = await import("fs/promises");
+    const raw = await readFile6(join21(homedir20(), ".memorix", "settings.json"), "utf-8");
     const s = JSON.parse(raw);
     if (s.knowledgeGraph === true) enableKG = true;
   } catch {
@@ -9257,7 +11431,9 @@ ${skill.content}` }]
         facts: o.facts,
         concepts: o.concepts,
         filesModified: o.filesModified,
-        createdAt: o.createdAt
+        createdAt: o.createdAt,
+        status: o.status,
+        source: o.source
       }));
       const generated = engine.generateFromObservations(obsData);
       if (generated.length === 0) {
@@ -9276,9 +11452,9 @@ ${skill.content}` }]
         lines.push(`- **Description**: ${sk.description}`);
         lines.push(`- **Observations**: ${sk.content.split("\n").length} lines of knowledge`);
         if (write && target) {
-          const path9 = engine.writeSkill(sk, target);
-          if (path9) {
-            lines.push(`- \u2705 **Written**: \`${path9}\``);
+          const path11 = engine.writeSkill(sk, target);
+          if (path11) {
+            lines.push(`- \u2705 **Written**: \`${path11}\``);
           } else {
             lines.push(`- \u274C Failed to write`);
           }
@@ -9734,9 +11910,9 @@ ${json}
   let teamPersist = null;
   if (!sharedTeam) {
     const { TeamPersistence: TeamPersistence2 } = await Promise.resolve().then(() => (init_persistence2(), persistence_exports2));
-    const { join: join17 } = await import("path");
+    const { join: join21 } = await import("path");
     teamPersist = new TeamPersistence2(
-      join17(projectDir2, "team-state.json"),
+      join21(projectDir2, "team-state.json"),
       teamRegistry,
       messageBus,
       taskManager,
@@ -9969,58 +12145,67 @@ ${lines.join("\n")}` }] };
   );
   const deferredInit = async () => {
     try {
-      let autoInstall = true;
-      try {
-        const { homedir: homedir16 } = await import("os");
-        const { join: join17 } = await import("path");
-        const { readFile: readFile5 } = await import("fs/promises");
-        const settingsPath = join17(homedir16(), ".memorix", "settings.json");
-        const raw = await readFile5(settingsPath, "utf-8");
-        const settings = JSON.parse(raw);
-        if (settings.autoInstallHooks === false) {
-          autoInstall = false;
-          console.error("[memorix] autoInstallHooks disabled in ~/.memorix/settings.json \u2014 skipping hook auto-install");
-        }
-      } catch {
+      const { getHookStatus: getHookStatus2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
+      const workDir = cwd ?? process.cwd();
+      const statuses = await getHookStatus2(workDir);
+      const installedAgents = statuses.filter((s) => s.installed).map((s) => s.agent);
+      if (installedAgents.length === 0) {
+        console.error('[memorix] No hooks installed. Run "memorix hooks install" to set up auto-capture.');
+      } else {
+        console.error(`[memorix] Hooks active: ${installedAgents.join(", ")}`);
       }
-      if (autoInstall) {
-        const { getHookStatus: getHookStatus2, installHooks: installHooks2, detectInstalledAgents: detectInstalledAgents2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
-        const { join: join17 } = await import("path");
-        const { access: access2 } = await import("fs/promises");
-        const workDir = cwd ?? process.cwd();
-        const statuses = await getHookStatus2(workDir);
-        const installedAgents = new Set(statuses.filter((s) => s.installed).map((s) => s.agent));
-        const detectedAgents = await detectInstalledAgents2();
-        const AGENT_MARKER_DIR = {
-          claude: ".claude",
-          windsurf: ".windsurf",
-          cursor: ".cursor",
-          copilot: ".vscode",
-          opencode: ".opencode",
-          kiro: ".kiro",
-          antigravity: ".gemini",
-          trae: ".trae"
-        };
-        for (const agent of detectedAgents) {
-          if (installedAgents.has(agent)) continue;
-          const markerDir = AGENT_MARKER_DIR[agent];
-          if (markerDir) {
+    } catch {
+    }
+    try {
+      const { getGitConfig: getGitConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      const gitCfg = getGitConfig2();
+      if (gitCfg.autoHook && project.rootPath) {
+        const { ensureHooksDir: ensureHooksDir2 } = await Promise.resolve().then(() => (init_hooks_path(), hooks_path_exports));
+        const resolved = ensureHooksDir2(project.rootPath);
+        if (resolved) {
+          const { existsSync: existsSync10, readFileSync: readFileSync9, writeFileSync: writeFileSync3, chmodSync } = await import("fs");
+          const { hookPath } = resolved;
+          const HOOK_MARKER = "# [memorix-git-hook]";
+          const needsInstall = !existsSync10(hookPath) || !readFileSync9(hookPath, "utf-8").includes(HOOK_MARKER);
+          if (needsInstall) {
+            const hookScript = `#!/bin/sh
+${HOOK_MARKER}
+# Memorix: Auto-ingest git commits as memories
+if command -v memorix >/dev/null 2>&1; then
+  memorix ingest commit --auto >/dev/null 2>&1 &
+fi
+`;
+            if (existsSync10(hookPath)) {
+              const existing = readFileSync9(hookPath, "utf-8");
+              writeFileSync3(hookPath, existing.trimEnd() + `
+
+${HOOK_MARKER}
+if command -v memorix >/dev/null 2>&1; then
+  memorix ingest commit --auto >/dev/null 2>&1 &
+fi
+`, "utf-8");
+            } else {
+              writeFileSync3(hookPath, hookScript, "utf-8");
+            }
             try {
-              await access2(join17(workDir, markerDir));
+              chmodSync(hookPath, 493);
             } catch {
-              continue;
             }
-          }
-          try {
-            const config = await installHooks2(agent, workDir);
-            console.error(`[memorix] Auto-installed hooks for ${agent} \u2192 ${config.configPath}`);
-          } catch {
+            console.error("[memorix] Auto-installed git post-commit hook (git.autoHook: true)");
           }
         }
       }
     } catch {
     }
+    let behaviorConfig = { syncAdvisory: true, autoCleanup: true };
     try {
+      const { getBehaviorConfig: getBehaviorConfig2 } = await Promise.resolve().then(() => (init_behavior(), behavior_exports));
+      behaviorConfig = getBehaviorConfig2();
+    } catch {
+    }
+    if (!behaviorConfig.syncAdvisory) {
+      console.error("[memorix] Sync advisory disabled via config.");
+    } else try {
       const engine = new WorkspaceSyncEngine(project.rootPath);
       const scan = await engine.scan();
       const lines = [];
@@ -10062,59 +12247,63 @@ ${lines.join("\n")}` }] };
       console.error(`[memorix] Sync advisory: ${syncAdvisory ? "available" : "nothing to sync"}`);
     } catch {
     }
-    try {
-      const { archiveExpired: archiveExpired2 } = await Promise.resolve().then(() => (init_retention(), retention_exports));
-      const archiveResult = await archiveExpired2(projectDir2);
-      if (archiveResult.archived > 0) {
-        console.error(`[memorix] Auto-archived ${archiveResult.archived} expired observation(s)`);
+    if (!behaviorConfig.autoCleanup) {
+      console.error("[memorix] Auto-cleanup disabled via config.");
+    } else {
+      try {
+        const { archiveExpired: archiveExpired2 } = await Promise.resolve().then(() => (init_retention(), retention_exports));
+        const archiveResult = await archiveExpired2(projectDir2);
+        if (archiveResult.archived > 0) {
+          console.error(`[memorix] Auto-archived ${archiveResult.archived} expired observation(s)`);
+        }
+      } catch {
       }
-    } catch {
-    }
-    try {
-      if (isLLMEnabled()) {
-        const { getAllObservations: getAllObservations2, resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-        const { deduplicateMemory: deduplicateMemory2 } = await Promise.resolve().then(() => (init_memory_manager(), memory_manager_exports));
-        const allObs = getAllObservations2().filter((o) => (o.status ?? "active") === "active" && o.projectId === project.id);
-        if (allObs.length > 10) {
-          const grouped = /* @__PURE__ */ new Map();
-          for (const obs of allObs) {
-            const key = `${obs.entityName}::${obs.type}`;
-            if (!grouped.has(key)) grouped.set(key, []);
-            grouped.get(key).push(obs);
-          }
-          const toResolve = [];
-          for (const [, group] of grouped) {
-            if (group.length < 2) continue;
-            group.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-            for (let i = 0; i < group.length - 1 && i < 5; i++) {
-              try {
-                const older = group[i], newer = group[i + 1];
-                const decision = await deduplicateMemory2(
-                  { title: newer.title, narrative: newer.narrative, facts: newer.facts },
-                  [{ id: older.id, title: older.title, narrative: older.narrative, facts: older.facts.join("\n") }]
-                );
-                if (decision && (decision.action === "UPDATE" || decision.action === "NONE")) {
-                  toResolve.push(decision.action === "UPDATE" ? older.id : newer.id);
-                } else if (decision?.action === "DELETE" && decision.targetId) {
-                  toResolve.push(decision.targetId);
+      try {
+        if (isLLMEnabled()) {
+          const { getAllObservations: getAllObservations2, resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+          const { deduplicateMemory: deduplicateMemory2 } = await Promise.resolve().then(() => (init_memory_manager(), memory_manager_exports));
+          const allObs = getAllObservations2().filter((o) => (o.status ?? "active") === "active" && o.projectId === project.id);
+          if (allObs.length > 10) {
+            const grouped = /* @__PURE__ */ new Map();
+            for (const obs of allObs) {
+              const key = `${obs.entityName}::${obs.type}`;
+              if (!grouped.has(key)) grouped.set(key, []);
+              grouped.get(key).push(obs);
+            }
+            const toResolve = [];
+            for (const [, group] of grouped) {
+              if (group.length < 2) continue;
+              group.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+              for (let i = 0; i < group.length - 1 && i < 5; i++) {
+                try {
+                  const older = group[i], newer = group[i + 1];
+                  const decision = await deduplicateMemory2(
+                    { title: newer.title, narrative: newer.narrative, facts: newer.facts },
+                    [{ id: older.id, title: older.title, narrative: older.narrative, facts: older.facts.join("\n") }]
+                  );
+                  if (decision && (decision.action === "UPDATE" || decision.action === "NONE")) {
+                    toResolve.push(decision.action === "UPDATE" ? older.id : newer.id);
+                  } else if (decision?.action === "DELETE" && decision.targetId) {
+                    toResolve.push(decision.targetId);
+                  }
+                } catch {
                 }
-              } catch {
               }
             }
+            if (toResolve.length > 0) {
+              await resolveObservations2([...new Set(toResolve)], "resolved");
+              console.error(`[memorix] Auto-dedup (LLM): resolved ${toResolve.length} redundant observation(s)`);
+            }
           }
-          if (toResolve.length > 0) {
-            await resolveObservations2([...new Set(toResolve)], "resolved");
-            console.error(`[memorix] Auto-dedup (LLM): resolved ${toResolve.length} redundant observation(s)`);
+        } else {
+          const { executeConsolidation: executeConsolidation2 } = await Promise.resolve().then(() => (init_consolidation(), consolidation_exports));
+          const result = await executeConsolidation2(projectDir2, project.id, { threshold: 0.55 });
+          if (result.observationsMerged > 0) {
+            console.error(`[memorix] Auto-consolidated: merged ${result.observationsMerged} duplicate(s) across ${result.clustersFound} cluster(s)`);
           }
         }
-      } else {
-        const { executeConsolidation: executeConsolidation2 } = await Promise.resolve().then(() => (init_consolidation(), consolidation_exports));
-        const result = await executeConsolidation2(projectDir2, project.id, { threshold: 0.55 });
-        if (result.observationsMerged > 0) {
-          console.error(`[memorix] Auto-consolidated: merged ${result.observationsMerged} duplicate(s) across ${result.clustersFound} cluster(s)`);
-        }
+      } catch {
       }
-    } catch {
     }
     const observationsFile = projectDir2 + "/observations.json";
     let reloadDebounce = null;
@@ -10145,7 +12334,32 @@ ${lines.join("\n")}` }] };
       console.error(`[memorix] Warning: could not watch observations file for hot-reload`);
     }
   };
-  return { server, graphManager, projectId: project.id, deferredInit };
+  const switchProject = async (newCwd) => {
+    const newDetected = detectProject(newCwd);
+    if (!newDetected) return false;
+    const newCanonicalId = await registerAlias(newDetected);
+    if (newCanonicalId === project.id) return false;
+    console.error(`[memorix] Switching project: ${project.id} \u2192 ${newCanonicalId}`);
+    const newProjectDir = await getProjectDataDir(newCanonicalId);
+    project = { ...newDetected, id: newCanonicalId };
+    projectDir2 = newProjectDir;
+    try {
+      const { initProjectRoot: initProjectRoot2 } = await Promise.resolve().then(() => (init_yaml_loader(), yaml_loader_exports));
+      initProjectRoot2(project.rootPath);
+      const { resetDotenv: resetDotenv2, loadDotenv: loadDotenv2 } = await Promise.resolve().then(() => (init_dotenv_loader(), dotenv_loader_exports));
+      resetDotenv2();
+      loadDotenv2(project.rootPath);
+    } catch {
+    }
+    graphManager = new KnowledgeGraphManager(projectDir2);
+    await graphManager.init();
+    await initObservations(projectDir2);
+    await reindexObservations();
+    console.error(`[memorix] Project switched to: ${project.id} (${project.name})`);
+    console.error(`[memorix] Data dir: ${projectDir2}`);
+    return true;
+  };
+  return { server, graphManager, projectId: project.id, deferredInit, switchProject };
 }
 
 // src/index.ts