synapse-kit 0.0.0-stage → 0.3.1

package/dist/memory/index.js

@@ -0,0 +1,4451 @@
+// @bun
+// memory/causal-config.ts
+import { homedir } from "os";
+import { resolve } from "path";
+var CAUSAL_MEMORY_CONFIG = {
+  SCHEMA_VERSION: process.env.SYNAPSE_MEMORY_VERSION || "2.1.0",
+  GLOBAL_DB_PATH: process.env.SYNAPSE_MEMORY_PATH || resolve(homedir(), ".gemini", "antigravity", "causal_memory.json"),
+  LEGACY_BACKUP_PATH: process.env.SYNAPSE_MEMORY_BACKUP_PATH || resolve(homedir(), ".gemini", "antigravity", "memory_backup_20261101.json"),
+  LOCAL_DB_PATH: resolve(import.meta.dir, "causal-memory.json"),
+  DEFAULT_HOST: process.env.SYNAPSE_MEMORY_HOST || "127.0.0.1",
+  DEFAULT_PORT: parseInt(process.env.SYNAPSE_MEMORY_PORT || "4242", 10),
+  REMOTE_URL: process.env.SYNAPSE_MEMORY_REMOTE_URL || "",
+  REMOTE_TIMEOUT_MS: parseInt(process.env.SYNAPSE_MEMORY_REMOTE_TIMEOUT || "3000", 10),
+  MCP_PROTOCOL_VERSION: process.env.SYNAPSE_MCP_VERSION || "2024-11-05",
+  MCP_SERVER_NAME: "synapse-causal-memory",
+  MAX_CONTEXT_PREVIEW_LINES: parseInt(process.env.SYNAPSE_MEMORY_MAX_PREVIEW || "5", 10),
+  CONTEXT_DB_PATH: process.env.SYNAPSE_CONTEXT_PATH || resolve(homedir(), ".gemini", "antigravity", "causal_contexts.json"),
+  LOCAL_CONTEXT_DB_PATH: resolve(import.meta.dir, "causal-contexts.json"),
+  MAX_CHECKPOINTS_RETAINED: parseInt(process.env.SYNAPSE_MAX_CHECKPOINTS || "50", 10),
+  DEFAULT_OBSIDIAN_VAULT_PATH: process.env.SYNAPSE_OBSIDIAN_VAULT || resolve(homedir(), "Documents", "Min", "Min"),
+  OBSIDIAN_LENS_SUBDIR: process.env.SYNAPSE_LENS_SUBDIR || "Synapse-Mental"
+};
+// memory/causal-store.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
+import { dirname } from "path";
+class CausalMemoryStore {
+  dbPath;
+  database;
+  lastMtimeMs = 0;
+  alwaysActiveRules = [];
+  domainIndex = new Map;
+  commandIndex = new Map;
+  exactKeywordIndex = new Map;
+  exactFileIndex = new Map;
+  prefixFileRules = [];
+  compiledSearchRules = [];
+  titleToRuleMap = new Map;
+  idToRuleMap = new Map;
+  relationAdjacency = new Map;
+  constructor(customPath, initialDatabase) {
+    this.dbPath = customPath || (existsSync(CAUSAL_MEMORY_CONFIG.GLOBAL_DB_PATH) ? CAUSAL_MEMORY_CONFIG.GLOBAL_DB_PATH : CAUSAL_MEMORY_CONFIG.LOCAL_DB_PATH);
+    if (initialDatabase) {
+      this.database = initialDatabase;
+      this.rebuildIndices();
+    } else {
+      this.database = this.loadDatabase();
+      this.rebuildIndices();
+    }
+  }
+  reloadIfNeeded() {
+    try {
+      if (!existsSync(this.dbPath))
+        return false;
+      const stat = statSync(this.dbPath);
+      if (stat.mtimeMs > this.lastMtimeMs) {
+        this.database = this.loadDatabase();
+        this.rebuildIndices();
+        return true;
+      }
+    } catch {}
+    return false;
+  }
+  reload() {
+    this.database = this.loadDatabase();
+    this.rebuildIndices();
+  }
+  loadFromMemory(db) {
+    this.database = db;
+    this.rebuildIndices();
+  }
+  rebuildIndices() {
+    this.alwaysActiveRules = [];
+    this.domainIndex.clear();
+    this.commandIndex.clear();
+    this.exactKeywordIndex.clear();
+    this.exactFileIndex.clear();
+    this.prefixFileRules = [];
+    this.compiledSearchRules = [];
+    this.titleToRuleMap.clear();
+    this.idToRuleMap.clear();
+    this.relationAdjacency.clear();
+    const addTokenToKeywordIndex = (token, rule) => {
+      if (!token)
+        return;
+      let list = this.exactKeywordIndex.get(token);
+      if (!list) {
+        list = [];
+        this.exactKeywordIndex.set(token, list);
+      }
+      if (list[list.length - 1] !== rule) {
+        list.push(rule);
+      }
+    };
+    for (const rule of this.database.rules) {
+      const domainLower = rule.domain.toLowerCase();
+      const titleLower = rule.title.toLowerCase();
+      const idLower = rule.id.toLowerCase();
+      this.titleToRuleMap.set(titleLower, rule);
+      this.idToRuleMap.set(idLower, rule);
+      let domList = this.domainIndex.get(domainLower);
+      if (!domList) {
+        domList = [];
+        this.domainIndex.set(domainLower, domList);
+      }
+      domList.push(rule);
+      if (rule.triggers.alwaysActive) {
+        this.alwaysActiveRules.push(rule);
+      }
+      if (rule.triggers.commands) {
+        for (const cmd of rule.triggers.commands) {
+          const cmdLower = cmd.toLowerCase();
+          let cmdList = this.commandIndex.get(cmdLower);
+          if (!cmdList) {
+            cmdList = [];
+            this.commandIndex.set(cmdLower, cmdList);
+          }
+          cmdList.push(rule);
+        }
+      }
+      addTokenToKeywordIndex(titleLower, rule);
+      addTokenToKeywordIndex(domainLower, rule);
+      for (const part of titleLower.split(/[\s_-]+/)) {
+        addTokenToKeywordIndex(part, rule);
+      }
+      if (rule.triggers.keywords) {
+        for (const kw of rule.triggers.keywords) {
+          const kwLower = kw.toLowerCase();
+          addTokenToKeywordIndex(kwLower, rule);
+          for (const sub of kwLower.split(/[\s_-]+/)) {
+            addTokenToKeywordIndex(sub, rule);
+          }
+        }
+      }
+      if (rule.triggers.files && rule.triggers.files.length > 0) {
+        const prefixPatterns = [];
+        for (const pattern of rule.triggers.files) {
+          const cleaned = (pattern.includes("\\") ? pattern.replaceAll("\\", "/") : pattern).replace(/^\*\*\/|\*\*$|\*$/g, "").replace(/\/+$/, "").toLowerCase();
+          if (!cleaned)
+            continue;
+          let fList = this.exactFileIndex.get(cleaned);
+          if (!fList) {
+            fList = [];
+            this.exactFileIndex.set(cleaned, fList);
+          }
+          fList.push(rule);
+          if (cleaned.endsWith("-") || cleaned.endsWith("_") || cleaned.includes(":")) {
+            prefixPatterns.push(cleaned);
+          }
+        }
+        if (prefixPatterns.length > 0) {
+          this.prefixFileRules.push({ rule, domainLower, cleanPatterns: prefixPatterns });
+        }
+      }
+    }
+    for (const rel of this.database.relations) {
+      const fromLower = rel.from.toLowerCase();
+      const toLower = rel.to.toLowerCase();
+      let fromAdj = this.relationAdjacency.get(fromLower);
+      if (!fromAdj) {
+        fromAdj = [];
+        this.relationAdjacency.set(fromLower, fromAdj);
+      }
+      fromAdj.push(rel);
+      if (toLower !== fromLower) {
+        let toAdj = this.relationAdjacency.get(toLower);
+        if (!toAdj) {
+          toAdj = [];
+          this.relationAdjacency.set(toLower, toAdj);
+        }
+        toAdj.push(rel);
+      }
+    }
+  }
+  static getRuleDomainPriority(rule) {
+    const titleLower = rule.title.toLowerCase();
+    const dom = rule.domain;
+    if (titleLower.includes("biophys") && dom === "User_Preferences_And_Rules") {
+      return 0;
+    }
+    if (dom === "Knowledge_Base") {
+      return 1;
+    }
+    return 2;
+  }
+  static deduplicateRulesByTitle(rules) {
+    const byTitle = new Map;
+    for (const rule of rules) {
+      if (!rule.title)
+        continue;
+      const key = rule.title.toLowerCase();
+      const existing = byTitle.get(key);
+      if (!existing) {
+        byTitle.set(key, rule);
+      } else {
+        const existingPrio = CausalMemoryStore.getRuleDomainPriority(existing);
+        const incomingPrio = CausalMemoryStore.getRuleDomainPriority(rule);
+        if (incomingPrio > existingPrio) {
+          byTitle.set(key, rule);
+        } else if (incomingPrio === existingPrio) {
+          const existingDate = existing.lastVerified || "";
+          const incomingDate = rule.lastVerified || "";
+          if (incomingDate >= existingDate) {
+            byTitle.set(key, rule);
+          }
+        }
+      }
+    }
+    return Array.from(byTitle.values());
+  }
+  loadDatabase() {
+    try {
+      if (existsSync(this.dbPath)) {
+        const stat = statSync(this.dbPath);
+        this.lastMtimeMs = stat.mtimeMs;
+        const raw = readFileSync(this.dbPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const rawRules = Array.isArray(parsed.rules) ? parsed.rules : [];
+        const rules = CausalMemoryStore.deduplicateRulesByTitle(rawRules);
+        const relations = Array.isArray(parsed.relations) ? parsed.relations : [];
+        return {
+          version: parsed.version || CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
+          updatedAt: parsed.updatedAt || new Date().toISOString(),
+          totalRules: rules.length,
+          totalRelations: relations.length,
+          rules,
+          relations
+        };
+      }
+    } catch {}
+    return {
+      version: CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
+      updatedAt: new Date().toISOString(),
+      totalRules: 0,
+      totalRelations: 0,
+      rules: [],
+      relations: []
+    };
+  }
+  saveDatabase() {
+    try {
+      const dir = dirname(this.dbPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      const serialized = JSON.stringify(this.database, null, 2);
+      writeFileSync(this.dbPath, serialized, "utf-8");
+      this.lastMtimeMs = statSync(this.dbPath).mtimeMs;
+      if (this.dbPath === CAUSAL_MEMORY_CONFIG.GLOBAL_DB_PATH && existsSync(dirname(CAUSAL_MEMORY_CONFIG.LOCAL_DB_PATH))) {
+        writeFileSync(CAUSAL_MEMORY_CONFIG.LOCAL_DB_PATH, serialized, "utf-8");
+      }
+    } catch (error) {
+      throw new Error(`\uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uB514\uC2A4\uD06C \uC800\uC7A5 \uC2E4\uD328: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getAllRules() {
+    return this.database.rules;
+  }
+  getAllRelations() {
+    return this.database.relations;
+  }
+  getStatus() {
+    const domainCounts = {};
+    for (const [dom, list] of this.domainIndex.entries()) {
+      const originalDomainName = list[0]?.domain || dom;
+      domainCounts[originalDomainName] = list.length;
+    }
+    return {
+      version: this.database.version,
+      updatedAt: this.database.updatedAt,
+      totalRules: this.database.rules.length,
+      totalRelations: this.database.relations.length,
+      dbPath: this.dbPath,
+      domains: Object.keys(domainCounts),
+      domainCounts
+    };
+  }
+  getCompiledSearchRules() {
+    if (this.compiledSearchRules.length === 0 && this.database.rules.length > 0) {
+      for (const rule of this.database.rules) {
+        const domainLower = rule.domain.toLowerCase();
+        const searchableText = [
+          rule.title,
+          rule.domain,
+          ...rule.triggers.keywords || [],
+          ...rule.invariants,
+          ...rule.actions,
+          ...rule.context
+        ].join(" ").toLowerCase();
+        this.compiledSearchRules.push({ rule, domainLower, searchableText });
+      }
+    }
+    return this.compiledSearchRules;
+  }
+  queryResonance(options) {
+    const startTime = performance.now();
+    const targetDomain = options.domain ? options.domain.toLowerCase() : undefined;
+    const queryCommand = options.command ? options.command.toLowerCase() : undefined;
+    const propagate = options.propagateRelations ?? true;
+    const maxHops = options.maxHops ?? 1;
+    const matchedRulesMap = new Map;
+    const nonAlwaysMatchedTitles = new Set;
+    for (const rule of this.alwaysActiveRules) {
+      if (targetDomain && rule.domain.toLowerCase() !== targetDomain)
+        continue;
+      matchedRulesMap.set(rule.id, rule);
+    }
+    if (queryCommand) {
+      const cmdRules = this.commandIndex.get(queryCommand);
+      if (cmdRules) {
+        for (const rule of cmdRules) {
+          if (targetDomain && rule.domain.toLowerCase() !== targetDomain)
+            continue;
+          matchedRulesMap.set(rule.id, rule);
+          nonAlwaysMatchedTitles.add(rule.title.toLowerCase());
+        }
+      }
+    }
+    if (options.files && options.files.length > 0 && this.exactFileIndex.size > 0) {
+      const hasPrefixRules = this.prefixFileRules.length > 0;
+      const checkedDirs = new Set;
+      const registerHits = (hits) => {
+        if (!hits)
+          return;
+        for (let i = 0;i < hits.length; i++) {
+          const rule = hits[i];
+          if (targetDomain && rule.domain.toLowerCase() !== targetDomain)
+            continue;
+          matchedRulesMap.set(rule.id, rule);
+          nonAlwaysMatchedTitles.add(rule.title.toLowerCase());
+        }
+      };
+      let lastTwoSeg = "";
+      for (let i = 0;i < options.files.length; i++) {
+        const rawFile = options.files[i];
+        const nf = (rawFile.includes("\\") ? rawFile.replaceAll("\\", "/") : rawFile).toLowerCase();
+        registerHits(this.exactFileIndex.get(nf));
+        const firstSlash = nf.indexOf("/");
+        if (firstSlash > 0) {
+          const secondSlash = nf.indexOf("/", firstSlash + 1);
+          const twoSeg = secondSlash > 0 ? nf.slice(0, secondSlash) : nf.slice(0, firstSlash);
+          if (twoSeg !== lastTwoSeg) {
+            lastTwoSeg = twoSeg;
+            if (!checkedDirs.has(twoSeg)) {
+              checkedDirs.add(twoSeg);
+              registerHits(this.exactFileIndex.get(twoSeg));
+              const oneSeg = nf.slice(0, firstSlash);
+              const isDriveLetter = oneSeg.length === 2 && oneSeg.endsWith(":");
+              if (!isDriveLetter && oneSeg !== twoSeg && !checkedDirs.has(oneSeg)) {
+                checkedDirs.add(oneSeg);
+                registerHits(this.exactFileIndex.get(oneSeg));
+              }
+            }
+          }
+          const lastSlash = nf.lastIndexOf("/");
+          registerHits(this.exactFileIndex.get(nf.slice(lastSlash + 1)));
+        } else {
+          checkedDirs.add(nf);
+        }
+      }
+      if (hasPrefixRules && checkedDirs.size > 0) {
+        const prefixArr = Array.from(checkedDirs);
+        for (const entry of this.prefixFileRules) {
+          if (targetDomain && entry.domainLower !== targetDomain)
+            continue;
+          if (matchedRulesMap.has(entry.rule.id))
+            continue;
+          for (const pattern of entry.cleanPatterns) {
+            if (prefixArr.some((p) => p.includes(pattern) || p.length >= 4 && pattern.includes(p))) {
+              matchedRulesMap.set(entry.rule.id, entry.rule);
+              nonAlwaysMatchedTitles.add(entry.rule.title.toLowerCase());
+              break;
+            }
+          }
+        }
+      }
+    }
+    const queryKeywords = (options.keywords || []).flatMap((k) => k.toLowerCase().split(/\s+/)).filter((k) => k.length > 0);
+    if (queryKeywords.length > 0) {
+      const unindexedKeywords = [];
+      for (const qk of queryKeywords) {
+        const exactHits = this.exactKeywordIndex.get(qk);
+        if (exactHits && exactHits.length > 0) {
+          for (const rule of exactHits) {
+            if (targetDomain && rule.domain.toLowerCase() !== targetDomain)
+              continue;
+            matchedRulesMap.set(rule.id, rule);
+            nonAlwaysMatchedTitles.add(rule.title.toLowerCase());
+          }
+        } else {
+          unindexedKeywords.push(qk);
+        }
+      }
+      if (unindexedKeywords.length > 0) {
+        const searchPool = this.getCompiledSearchRules();
+        for (const entry of searchPool) {
+          if (targetDomain && entry.domainLower !== targetDomain)
+            continue;
+          if (matchedRulesMap.has(entry.rule.id))
+            continue;
+          for (const qk of unindexedKeywords) {
+            if (entry.searchableText.includes(qk)) {
+              matchedRulesMap.set(entry.rule.id, entry.rule);
+              nonAlwaysMatchedTitles.add(entry.rule.title.toLowerCase());
+              break;
+            }
+          }
+        }
+      }
+    }
+    const activeRelationsSet = new Set;
+    const visitedTitles = new Set(Array.from(matchedRulesMap.values()).map((r) => r.title.toLowerCase()));
+    let currentFrontier = new Set(nonAlwaysMatchedTitles.size > 0 ? nonAlwaysMatchedTitles : visitedTitles);
+    const effectiveHops = propagate ? Math.max(1, maxHops) : 1;
+    for (let hop = 0;hop < effectiveHops; hop++) {
+      const nextFrontier = new Set;
+      for (const titleLower of currentFrontier) {
+        const adjRelations = this.relationAdjacency.get(titleLower);
+        if (!adjRelations)
+          continue;
+        for (const rel of adjRelations) {
+          activeRelationsSet.add(rel);
+          if (propagate && nonAlwaysMatchedTitles.size > 0) {
+            const neighborLower = rel.from.toLowerCase() === titleLower ? rel.to.toLowerCase() : rel.from.toLowerCase();
+            if (!visitedTitles.has(neighborLower)) {
+              visitedTitles.add(neighborLower);
+              nextFrontier.add(neighborLower);
+              const neighborRule = this.titleToRuleMap.get(neighborLower);
+              if (neighborRule && (!targetDomain || neighborRule.domain.toLowerCase() === targetDomain)) {
+                matchedRulesMap.set(neighborRule.id, neighborRule);
+              }
+            }
+          }
+        }
+      }
+      if (nextFrontier.size === 0)
+        break;
+      currentFrontier = nextFrontier;
+    }
+    const matchedRules = Array.from(matchedRulesMap.values());
+    const activeRelations = Array.from(activeRelationsSet);
+    const duration = performance.now() - startTime;
+    const totalCount = this.database.rules.length;
+    const savings = totalCount > 0 ? ((totalCount - matchedRules.length) / totalCount * 100).toFixed(1) + "%" : "0.0%";
+    return {
+      queryDurationMs: Math.round(duration * 100) / 100,
+      matchedCount: matchedRules.length,
+      totalDatabaseRules: totalCount,
+      resonanceRules: matchedRules,
+      activeRelations,
+      tokenDietSavingsRatio: savings
+    };
+  }
+  assertRule(rule, persistToDisk = true) {
+    const targetTitle = (rule.title || rule.name || "").toLowerCase();
+    const existingIndex = this.database.rules.findIndex((r) => r.id === rule.id || targetTitle.length > 0 && (r.title || r.name || "").toLowerCase() === targetTitle);
+    const updatedRules = [...this.database.rules];
+    const today = new Date().toISOString().split("T")[0];
+    if (existingIndex >= 0) {
+      updatedRules[existingIndex] = {
+        ...rule,
+        id: rule.id || updatedRules[existingIndex].id,
+        lastVerified: today
+      };
+    } else {
+      updatedRules.push({
+        ...rule,
+        lastVerified: today
+      });
+    }
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      totalRules: updatedRules.length,
+      rules: updatedRules
+    };
+    this.rebuildIndices();
+    if (persistToDisk) {
+      this.saveDatabase();
+    }
+  }
+  readSmartGraph(files = []) {
+    const resonance = this.queryResonance({ files });
+    const status = this.getStatus();
+    const entities = resonance.resonanceRules.map((r) => ({
+      name: r.title,
+      entityType: r.entityType || r.domain,
+      domain: r.domain,
+      invariants: r.invariants,
+      actions: r.actions,
+      observations: [
+        ...r.invariants.map((i) => `[\uBD88\uBCC0\uADDC\uCE59] ${i}`),
+        ...r.actions.map((a) => `[\uC2E4\uD589\uC9C0\uCE68] ${a}`),
+        ...r.context
+      ]
+    }));
+    return {
+      causalMemoryEngine: `v${status.version} (Active Resonance Mode)`,
+      tokenDietSavings: resonance.tokenDietSavingsRatio,
+      queryDurationMs: resonance.queryDurationMs,
+      activeEntitiesCount: entities.length,
+      totalIndexedRules: status.totalRules,
+      totalIndexedRelations: status.totalRelations,
+      availableDomains: status.domainCounts,
+      hint: "\uBB34\uAD00\uD55C \uB3C4\uBA54\uC778 \uC9C0\uC2DD\uC740 \uD1A0\uD070 \uC808\uAC10\uC744 \uC704\uD574 0ms \uC2A4\uD0B5\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uD2B9\uC815 \uB3C4\uBA54\uC778 \uC0C1\uC138 \uC870\uD68C\uB294 search_nodes \uB610\uB294 query_causal_memory\uB97C \uC0AC\uC6A9\uD558\uC138\uC694.",
+      entities,
+      relations: resonance.activeRelations
+    };
+  }
+  searchNodes(query) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+      return this.readSmartGraph();
+    }
+    const tokens = trimmed.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+    const matchedRules = [];
+    const matchedTitles = new Set;
+    const searchPool = this.getCompiledSearchRules();
+    for (const entry of searchPool) {
+      const ruleIdLower = entry.rule.id.toLowerCase();
+      if (tokens.some((tok) => entry.searchableText.includes(tok) || ruleIdLower.includes(tok))) {
+        matchedRules.push(entry.rule);
+        matchedTitles.add(entry.rule.title.toLowerCase());
+      }
+    }
+    const relationsSet = new Set;
+    for (const titleLower of matchedTitles) {
+      const adj = this.relationAdjacency.get(titleLower);
+      if (adj) {
+        for (const r of adj)
+          relationsSet.add(r);
+      }
+    }
+    return {
+      entities: matchedRules.map((r) => ({
+        name: r.title,
+        entityType: r.entityType || r.domain,
+        observations: [...r.invariants, ...r.actions, ...r.context]
+      })),
+      relations: Array.from(relationsSet)
+    };
+  }
+  openNodes(names) {
+    const matchedRules = [];
+    const matchedTitles = new Set;
+    for (const name of names) {
+      const lower = name.toLowerCase();
+      const rule = this.titleToRuleMap.get(lower) || this.idToRuleMap.get(lower);
+      if (rule && !matchedTitles.has(rule.title.toLowerCase())) {
+        matchedRules.push(rule);
+        matchedTitles.add(rule.title.toLowerCase());
+      }
+    }
+    const relationsSet = new Set;
+    for (const titleLower of matchedTitles) {
+      const adj = this.relationAdjacency.get(titleLower);
+      if (adj) {
+        for (const r of adj)
+          relationsSet.add(r);
+      }
+    }
+    return {
+      entities: matchedRules.map((r) => ({
+        name: r.title,
+        entityType: r.entityType || r.domain,
+        observations: [...r.invariants, ...r.actions, ...r.context]
+      })),
+      relations: Array.from(relationsSet)
+    };
+  }
+  createEntities(entities, persistToDisk = true) {
+    const created = [];
+    const updatedRules = [...this.database.rules];
+    const today = new Date().toISOString().split("T")[0];
+    for (const ent of entities) {
+      if (this.titleToRuleMap.has(ent.name.toLowerCase()))
+        continue;
+      const inferred = CausalMemoryStore.inferRuleFromEntity(ent, today);
+      updatedRules.push(inferred);
+      created.push(ent);
+    }
+    if (created.length > 0) {
+      this.database = {
+        ...this.database,
+        updatedAt: new Date().toISOString(),
+        totalRules: updatedRules.length,
+        rules: updatedRules
+      };
+      this.rebuildIndices();
+      if (persistToDisk) {
+        this.saveDatabase();
+      }
+    }
+    return created;
+  }
+  addObservations(observations, persistToDisk = true) {
+    const updatedRules = [...this.database.rules];
+    const results = [];
+    let changed = false;
+    for (const item of observations) {
+      const idx = updatedRules.findIndex((r) => r.title.toLowerCase() === item.entityName.toLowerCase());
+      if (idx < 0)
+        continue;
+      const rule = updatedRules[idx];
+      const existingObs = new Set([...rule.invariants, ...rule.actions, ...rule.context]);
+      const added = [];
+      const newInvariants = [...rule.invariants];
+      const newActions = [...rule.actions];
+      const newContext = [...rule.context];
+      for (const content of item.contents) {
+        if (existingObs.has(content))
+          continue;
+        added.push(content);
+        existingObs.add(content);
+        changed = true;
+        if (content.includes("\uAE08\uC9C0") || content.includes("\uC808\uB300") || content.includes("\uD544\uC218") || content.includes("\uC8FC\uC758")) {
+          newInvariants.push(content);
+        } else if (/^\d+\.|\uB2E8\uACC4|Step/i.test(content)) {
+          newActions.push(content);
+        } else {
+          newContext.push(content);
+        }
+      }
+      updatedRules[idx] = {
+        ...rule,
+        invariants: newInvariants,
+        actions: newActions,
+        context: newContext,
+        lastVerified: new Date().toISOString().split("T")[0]
+      };
+      results.push({ entityName: item.entityName, addedObservations: added });
+    }
+    if (changed) {
+      this.database = {
+        ...this.database,
+        updatedAt: new Date().toISOString(),
+        rules: updatedRules
+      };
+      this.rebuildIndices();
+      if (persistToDisk) {
+        this.saveDatabase();
+      }
+    }
+    return results;
+  }
+  createRelations(relations, persistToDisk = true) {
+    const updatedRelations = [...this.database.relations];
+    const created = [];
+    for (const rel of relations) {
+      const exists = updatedRelations.some((r) => r.from === rel.from && r.to === rel.to && r.relationType === rel.relationType);
+      if (!exists) {
+        updatedRelations.push(rel);
+        created.push(rel);
+      }
+    }
+    if (created.length > 0) {
+      this.database = {
+        ...this.database,
+        updatedAt: new Date().toISOString(),
+        totalRelations: updatedRelations.length,
+        relations: updatedRelations
+      };
+      this.rebuildIndices();
+      if (persistToDisk) {
+        this.saveDatabase();
+      }
+    }
+    return created;
+  }
+  deleteRule(ruleId, persistToDisk = true) {
+    const targetId = ruleId.toLowerCase();
+    const removedTitles = new Set;
+    const filteredRules = this.database.rules.filter((r) => {
+      if (r.id.toLowerCase() === targetId) {
+        removedTitles.add(r.title.toLowerCase());
+        return false;
+      }
+      return true;
+    });
+    if (removedTitles.size === 0) {
+      return false;
+    }
+    const filteredRelations = this.database.relations.filter((rel) => !removedTitles.has(rel.from.toLowerCase()) && !removedTitles.has(rel.to.toLowerCase()) && rel.from.toLowerCase() !== targetId && rel.to.toLowerCase() !== targetId);
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      totalRules: filteredRules.length,
+      totalRelations: filteredRelations.length,
+      rules: filteredRules,
+      relations: filteredRelations
+    };
+    this.rebuildIndices();
+    if (persistToDisk) {
+      this.saveDatabase();
+    }
+    return true;
+  }
+  deleteEntities(entityNames, persistToDisk = true) {
+    const nameSet = new Set(entityNames.map((n) => n.toLowerCase()));
+    const filteredRules = this.database.rules.filter((r) => !nameSet.has(r.title.toLowerCase()) && !nameSet.has(r.id.toLowerCase()));
+    const filteredRelations = this.database.relations.filter((rel) => !nameSet.has(rel.from.toLowerCase()) && !nameSet.has(rel.to.toLowerCase()));
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      totalRules: filteredRules.length,
+      totalRelations: filteredRelations.length,
+      rules: filteredRules,
+      relations: filteredRelations
+    };
+    this.rebuildIndices();
+    if (persistToDisk) {
+      this.saveDatabase();
+    }
+  }
+  deleteObservations(deletions, persistToDisk = true) {
+    const updatedRules = [...this.database.rules];
+    for (const del of deletions) {
+      const idx = updatedRules.findIndex((r) => r.title.toLowerCase() === del.entityName.toLowerCase());
+      if (idx < 0)
+        continue;
+      const toDelete = new Set(del.observations);
+      const rule = updatedRules[idx];
+      updatedRules[idx] = {
+        ...rule,
+        invariants: rule.invariants.filter((x) => !toDelete.has(x)),
+        actions: rule.actions.filter((x) => !toDelete.has(x)),
+        context: rule.context.filter((x) => !toDelete.has(x))
+      };
+    }
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      rules: updatedRules
+    };
+    this.rebuildIndices();
+    if (persistToDisk) {
+      this.saveDatabase();
+    }
+  }
+  deleteRelations(relations, persistToDisk = true) {
+    const filtered = this.database.relations.filter((existing) => !relations.some((del) => del.from === existing.from && del.to === existing.to && del.relationType === existing.relationType));
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      totalRelations: filtered.length,
+      relations: filtered
+    };
+    this.rebuildIndices();
+    if (persistToDisk) {
+      this.saveDatabase();
+    }
+  }
+  static inferRuleFromEntity(ent, today) {
+    const nameLower = ent.name.toLowerCase();
+    const typeLower = ent.entityType.toLowerCase();
+    const obsJoined = ent.observations.join(" ").toLowerCase();
+    let domain = "Knowledge_Base";
+    const triggers = {};
+    const invariants = [];
+    const actions = [];
+    const context = [];
+    const isTrueUserPreference = !nameLower.includes("biophys") && (typeLower === "preference" || typeLower === "user_constraint" || typeLower === "forbidden_rules" || nameLower === "userpreferences" || nameLower === "user_web_navigation_preference" || nameLower === "python_strictly_forbidden" || nameLower === "forbidden_topics_until_mentioned");
+    if (isTrueUserPreference) {
+      domain = "User_Preferences_And_Rules";
+      triggers.alwaysActive = true;
+      triggers.keywords = ["\uD658\uACBD\uC124\uC815", "\uADDC\uCE59", "\uD130\uBBF8\uB110", "\uCD9C\uB825", "\uBCF4\uC548", "\uC120\uD638\uB3C4"];
+    } else if (nameLower.includes("poe2") || nameLower.includes("noble-babbage") || nameLower.includes("release_workflow") || obsJoined.includes("poe2filter-releases") || obsJoined.includes("noble-babbage")) {
+      domain = "Project_POE2_AutoFilter";
+      triggers.files = [
+        "noble-babbage",
+        "poe2filter-releases",
+        "updater.json",
+        "post_download_button.js"
+      ];
+      triggers.keywords = ["poe2", "autofilter", "\uD544\uD130", "\uC624\uD1A0\uD544\uD130", "updater", "discord", "\uB9B4\uB9AC\uC988", "\uBC30\uD3EC"];
+      triggers.commands = ["release", "updater", "build", "sign"];
+    } else if (nameLower.includes("vesper") || nameLower.includes("dsp") || nameLower.includes("neurospatial audio") || typeLower.includes("audio_architecture")) {
+      domain = "Project_Vesper_DSP";
+      triggers.files = ["vesper", "crates/vesper-", "vesper-apo"];
+      triggers.keywords = ["vesper", "dsp", "\uC624\uB514\uC624", "audio", "mmcss", "virtuallock", "apo", "eq", "\uC0AC\uC6B4\uB4DC"];
+      triggers.commands = ["check", "build", "test"];
+    } else if (nameLower.includes("synapse") && !nameLower.includes("biophys")) {
+      domain = "Project_Synapse_Kit";
+      triggers.files = ["synapse", "synapse.config.ts"];
+      triggers.keywords = ["synapse", "synapse-kit", "\uC2DC\uB0C5\uC2A4", "\uC778\uACFC\uC728", "causal", "\uCEF4\uD30C\uC77C\uB7EC", "\uCCB4\uCEE4"];
+      triggers.commands = ["check", "build", "package", "sign", "init", "memory"];
+    } else if (nameLower.includes("hardware") || nameLower.includes("pcb") || nameLower.includes("jlcpcb") || nameLower.includes("m2_2230") || nameLower.includes("pocket_orange") || typeLower.includes("hardware")) {
+      domain = "Hardware_And_PCB";
+      triggers.files = ["hardware", "pcb", "kicad"];
+      triggers.keywords = ["pcb", "hardware", "\uD558\uB4DC\uC6E8\uC5B4", "\uD68C\uB85C", "jlcpcb", "kicad", "m2"];
+    } else if (nameLower.includes("biophys") || nameLower.includes("connectome") || nameLower.includes("drosophila") || nameLower.includes("cortex") || typeLower.includes("whitepaper")) {
+      domain = "BioPhys_Research_And_Architecture";
+      triggers.files = ["biophys", "whitepaper"];
+      triggers.keywords = ["biophys", "connectome", "\uC2DC\uB0C5\uC2A4\uC2E0\uACBD\uB9DD", "\uD000\uD0C0\uC774\uC81C\uC774\uC158", "\uBC31\uC11C", "\uC544\uD0A4\uD14D\uCC98"];
+    } else {
+      domain = "Knowledge_Base";
+      triggers.keywords = [ent.name.toLowerCase().replace(/_/g, " ")];
+    }
+    for (const obs of ent.observations) {
+      if (obs.includes("\uAE08\uC9C0") || obs.includes("\uC808\uB300") || obs.includes("\uD544\uC218") || obs.includes("\uC8FC\uC758") || obs.includes("VirtualLock") || obs.includes("MMCSS")) {
+        invariants.push(obs);
+      } else if (/^\d+\.|\uB2E8\uACC4|Step/i.test(obs)) {
+        actions.push(obs);
+      } else {
+        context.push(obs);
+      }
+    }
+    const baseSlug = ent.name.trim().toLowerCase().replace(/[^\w\uAC00-\uD7A30-9-]+/g, "-").replace(/^-+|-+$/g, "") || "item";
+    return {
+      id: `rule-${domain.toLowerCase()}-${baseSlug}`,
+      domain,
+      title: ent.name,
+      entityType: ent.entityType,
+      triggers,
+      invariants,
+      actions,
+      context,
+      lastVerified: today
+    };
+  }
+  audit() {
+    const issues = [];
+    const seenIds = new Set;
+    const seenTitles = new Set;
+    let alwaysActiveCount = 0;
+    for (const rule of this.database.rules) {
+      if (rule.triggers.alwaysActive) {
+        alwaysActiveCount++;
+      }
+      if (!rule.id || rule.id.trim().length === 0) {
+        issues.push(`ID \uB204\uB77D \uADDC\uCE59 \uBC1C\uACAC: ${rule.title}`);
+      } else if (seenIds.has(rule.id)) {
+        issues.push(`\uC911\uBCF5 ID \uBC1C\uACAC: ${rule.id}`);
+      } else {
+        seenIds.add(rule.id);
+      }
+      const titleLower = (rule.title || "").toLowerCase();
+      if (titleLower) {
+        if (seenTitles.has(titleLower)) {
+          issues.push(`\uC911\uBCF5 \uC81C\uBAA9(Title) \uBC1C\uACAC: ${rule.title}`);
+        } else {
+          seenTitles.add(titleLower);
+        }
+      }
+      if (!rule.domain) {
+        issues.push(`\uB3C4\uBA54\uC778 \uB204\uB77D \uADDC\uCE59: ${rule.id}`);
+      }
+    }
+    if (alwaysActiveCount > 10) {
+      issues.push(`\uC0C1\uC2DC \uD65C\uC131(alwaysActive) \uADDC\uCE59 \uACFC\uB2E4 (${alwaysActiveCount}\uAC1C): \uD1A0\uD070 \uC808\uAC10 \uD6A8\uC728\uC774 \uC800\uD558\uB420 \uC218 \uC788\uC2B5\uB2C8\uB2E4.`);
+    }
+    return {
+      ok: issues.length === 0,
+      totalRules: this.database.rules.length,
+      totalRelations: this.database.relations.length,
+      alwaysActiveCount,
+      issues
+    };
+  }
+  getRawDatabase() {
+    this.reloadIfNeeded();
+    return this.database;
+  }
+  mergeDatabase(incomingRules, incomingRelations = []) {
+    this.reloadIfNeeded();
+    let addedRules = 0;
+    let updatedRules = 0;
+    let addedRelations = 0;
+    const byTitle = new Map;
+    for (const r of this.database.rules) {
+      byTitle.set(r.title.toLowerCase(), r);
+    }
+    for (const incoming of incomingRules) {
+      if (!incoming.id || !incoming.title)
+        continue;
+      const titleKey = incoming.title.toLowerCase();
+      const existing = byTitle.get(titleKey);
+      if (!existing) {
+        byTitle.set(titleKey, incoming);
+        addedRules++;
+      } else {
+        const existingPrio = CausalMemoryStore.getRuleDomainPriority(existing);
+        const incomingPrio = CausalMemoryStore.getRuleDomainPriority(incoming);
+        const existingDate = existing.lastVerified || "";
+        const incomingDate = incoming.lastVerified || "";
+        if (incomingPrio > existingPrio) {
+          byTitle.set(titleKey, incoming);
+          updatedRules++;
+        } else if (incomingPrio === existingPrio && incoming.id !== existing.id && incomingDate > existingDate) {
+          byTitle.set(titleKey, incoming);
+          updatedRules++;
+        } else if (incomingPrio === existingPrio && incoming.id === existing.id && incomingDate > existingDate) {
+          byTitle.set(titleKey, incoming);
+          updatedRules++;
+        }
+      }
+    }
+    const relationKey = (rel) => `${rel.from.toLowerCase()}::${rel.relationType.toLowerCase()}::${rel.to.toLowerCase()}`;
+    const relMap = new Map;
+    for (const rel of this.database.relations) {
+      relMap.set(relationKey(rel), rel);
+    }
+    for (const incomingRel of incomingRelations) {
+      const key = relationKey(incomingRel);
+      if (!relMap.has(key)) {
+        relMap.set(key, incomingRel);
+        addedRelations++;
+      }
+    }
+    const mergedRules = Array.from(byTitle.values());
+    const mergedRelations = Array.from(relMap.values());
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      totalRules: mergedRules.length,
+      totalRelations: mergedRelations.length,
+      rules: mergedRules,
+      relations: mergedRelations
+    };
+    this.rebuildIndices();
+    this.saveDatabase();
+    return {
+      addedRules,
+      updatedRules,
+      addedRelations,
+      totalRules: mergedRules.length,
+      totalRelations: mergedRelations.length
+    };
+  }
+}
+// memory/causal-query.ts
+var {spawn } = globalThis.Bun;
+async function detectModifiedFiles(cwd = process.cwd()) {
+  try {
+    const gitProc = spawn(["git", "status", "--porcelain", "-uall"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const output = await new Response(gitProc.stdout).text();
+    await gitProc.exited;
+    return output.split(`
+`).map((line) => line.slice(3).trim().replaceAll("\\", "/")).filter((line) => line.length > 0 && !line.startsWith(".synapse/") && !line.includes("/.synapse/"));
+  } catch {
+    return [];
+  }
+}
+async function runCausalQuery(rawOptions, storeCustomPath) {
+  const store = new CausalMemoryStore(storeCustomPath);
+  let targetFiles = rawOptions.files ? [...rawOptions.files] : [];
+  if (rawOptions.autoGit || targetFiles.length === 0) {
+    const gitFiles = await detectModifiedFiles(rawOptions.cwd || process.cwd());
+    if (gitFiles.length > 0) {
+      targetFiles = Array.from(new Set([...targetFiles, ...gitFiles]));
+    }
+  }
+  const queryOptions = {
+    files: targetFiles,
+    keywords: rawOptions.keywords,
+    command: rawOptions.command,
+    domain: rawOptions.domain,
+    propagateRelations: rawOptions.propagateRelations
+  };
+  return store.queryResonance(queryOptions);
+}
+function formatResonanceForAgent(result, compact = false) {
+  if (result.matchedCount === 0) {
+    return `[Causal-Memory] \uACF5\uBA85 \uADDC\uCE59 0\uAC74 (\uD1A0\uD070 \uC808\uAC10\uB960: ${result.tokenDietSavingsRatio}, \uC18C\uC694: ${result.queryDurationMs}ms)`;
+  }
+  if (compact) {
+    return JSON.stringify({
+      ok: true,
+      durationMs: result.queryDurationMs,
+      matchedCount: result.matchedCount,
+      totalDatabaseRules: result.totalDatabaseRules,
+      savings: result.tokenDietSavingsRatio,
+      rules: result.resonanceRules.map((r) => ({
+        id: r.id,
+        domain: r.domain,
+        title: r.title,
+        invariants: r.invariants,
+        actions: r.actions
+      })),
+      relations: result.activeRelations
+    });
+  }
+  const lines = [
+    `### \uD83E\uDDE0 \uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uACF5\uBA85 \uC8FC\uC785 (${result.matchedCount}/${result.totalDatabaseRules}\uAC1C \uADDC\uCE59 \uD65C\uC131\uD654, \uC808\uAC10\uB960: ${result.tokenDietSavingsRatio}, ${result.queryDurationMs}ms)`
+  ];
+  for (const rule of result.resonanceRules) {
+    lines.push(`
+**[${rule.domain}] ${rule.title}**`);
+    if (rule.invariants.length > 0) {
+      lines.push("  - **\uBD88\uBCC0 \uADDC\uCE59(Invariants)**:");
+      for (const inv of rule.invariants) {
+        lines.push(`    \u2022 ${inv}`);
+      }
+    }
+    if (rule.actions.length > 0) {
+      lines.push("  - **\uC2E4\uD589 \uC808\uCC28(Actions)**:");
+      for (const act of rule.actions) {
+        lines.push(`    \u2022 ${act}`);
+      }
+    }
+    if (rule.context.length > 0) {
+      lines.push("  - **\uD575\uC2EC \uB9E5\uB77D(Context)**:");
+      for (const ctx of rule.context.slice(0, CAUSAL_MEMORY_CONFIG.MAX_CONTEXT_PREVIEW_LINES)) {
+        lines.push(`    \u2022 ${ctx}`);
+      }
+    }
+  }
+  if (result.activeRelations.length > 0) {
+    lines.push(`
+### \uD83D\uDD17 \uD65C\uC131 \uC778\uACFC \uAC04\uC120 (Active Causal Relations)`);
+    for (const rel of result.activeRelations) {
+      lines.push(`  \u2022 \`${rel.from}\` \u2500\u2500[${rel.relationType}]\u2500\u2500\u25B6 \`${rel.to}\``);
+    }
+  }
+  return lines.join(`
+`);
+}
+// memory/causal-server.ts
+import { createInterface } from "readline";
+
+// memory/causal-context.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, renameSync, statSync as statSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var {spawn: spawn2 } = globalThis.Bun;
+async function detectGitHeadInfo(cwd = process.cwd()) {
+  try {
+    const branchProc = spawn2(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const branchOut = (await new Response(branchProc.stdout).text()).trim();
+    const branchExit = await branchProc.exited;
+    const commitProc = spawn2(["git", "rev-parse", "--short", "HEAD"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const commitOut = (await new Response(commitProc.stdout).text()).trim();
+    const commitExit = await commitProc.exited;
+    return {
+      branch: branchExit === 0 && branchOut.length > 0 ? branchOut : undefined,
+      commit: commitExit === 0 && commitOut.length > 0 ? commitOut : undefined
+    };
+  } catch {
+    return {};
+  }
+}
+
+class ContextCheckpointStore {
+  dbPath;
+  memoryDbPath;
+  database;
+  lastMtimeMs = 0;
+  constructor(customPath, memoryDbPath) {
+    this.dbPath = customPath || CAUSAL_MEMORY_CONFIG.CONTEXT_DB_PATH;
+    this.memoryDbPath = memoryDbPath;
+    this.database = this.loadDatabase();
+  }
+  loadDatabase() {
+    try {
+      if (existsSync2(this.dbPath)) {
+        const stat = statSync2(this.dbPath);
+        this.lastMtimeMs = stat.mtimeMs;
+        const raw = readFileSync2(this.dbPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && Array.isArray(parsed.checkpoints)) {
+          return parsed;
+        }
+      }
+    } catch {}
+    return {
+      version: CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
+      updatedAt: new Date().toISOString(),
+      latestCheckpointId: null,
+      totalCheckpoints: 0,
+      checkpoints: []
+    };
+  }
+  reloadIfNeeded() {
+    try {
+      if (existsSync2(this.dbPath)) {
+        const stat = statSync2(this.dbPath);
+        if (stat.mtimeMs > this.lastMtimeMs) {
+          this.database = this.loadDatabase();
+        }
+      }
+    } catch {}
+  }
+  saveDatabase() {
+    try {
+      const dir = dirname2(this.dbPath);
+      if (!existsSync2(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+      const serialized = JSON.stringify(this.database, null, 2);
+      const tempPath = `${this.dbPath}.tmp.${process.pid}.${Date.now()}`;
+      writeFileSync2(tempPath, serialized, "utf-8");
+      renameSync(tempPath, this.dbPath);
+      try {
+        const stat = statSync2(this.dbPath);
+        this.lastMtimeMs = stat.mtimeMs;
+      } catch {}
+      if (this.dbPath === CAUSAL_MEMORY_CONFIG.CONTEXT_DB_PATH) {
+        try {
+          const localDir = dirname2(CAUSAL_MEMORY_CONFIG.LOCAL_CONTEXT_DB_PATH);
+          if (existsSync2(localDir)) {
+            writeFileSync2(CAUSAL_MEMORY_CONFIG.LOCAL_CONTEXT_DB_PATH, serialized, "utf-8");
+          }
+        } catch {}
+      }
+    } catch (error) {
+      throw new Error(`\uCEE8\uD14D\uC2A4\uD2B8 \uCCB4\uD06C\uD3EC\uC778\uD2B8 \uC800\uC7A5 \uC2E4\uD328: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  static generateCheckpointId() {
+    const now = new Date;
+    const pad = (n) => String(n).padStart(2, "0");
+    const datePart = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+    const timePart = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const randPart = Math.random().toString(36).slice(2, 6);
+    return `ctx_${datePart}_${timePart}_${randPart}`;
+  }
+  async saveCheckpoint(input) {
+    this.reloadIfNeeded();
+    if (!input.title || input.title.trim().length === 0) {
+      throw new Error("\uCCB4\uD06C\uD3EC\uC778\uD2B8 \uC81C\uBAA9(title)\uC740 \uBE44\uC5B4 \uC788\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    }
+    const cwd = input.cwd || process.cwd();
+    const sessionId = (input.sessionId || "default-session").trim();
+    const autoGit = input.autoGit !== false;
+    const autoResonance = input.autoResonance !== false;
+    let modifiedFiles = input.modifiedFiles ? [...input.modifiedFiles] : [];
+    let gitBranch;
+    let gitCommit;
+    if (autoGit) {
+      const [detectedFiles, gitHead] = await Promise.all([
+        modifiedFiles.length === 0 ? detectModifiedFiles(cwd) : Promise.resolve(modifiedFiles),
+        detectGitHeadInfo(cwd)
+      ]);
+      modifiedFiles = detectedFiles;
+      gitBranch = gitHead.branch;
+      gitCommit = gitHead.commit;
+    }
+    const activeFiles = input.activeFiles ? Array.from(new Set(input.activeFiles)) : modifiedFiles.slice(0, 15);
+    const invariantsSet = new Set(input.activeInvariants || []);
+    if (autoResonance) {
+      try {
+        const memoryStore = new CausalMemoryStore(this.memoryDbPath);
+        const resonance = memoryStore.queryResonance({
+          files: activeFiles.length > 0 ? activeFiles : modifiedFiles,
+          keywords: input.keywords,
+          domain: input.domain,
+          propagateRelations: false
+        });
+        for (const rule of resonance.resonanceRules) {
+          for (const inv of rule.invariants) {
+            invariantsSet.add(inv);
+          }
+        }
+      } catch {}
+    }
+    const checkpointId = input.id?.trim() || ContextCheckpointStore.generateCheckpointId();
+    const nowIso = new Date().toISOString();
+    const checkpoint = {
+      id: checkpointId,
+      sessionId,
+      title: input.title.trim(),
+      createdAt: nowIso,
+      cwd: cwd.replaceAll("\\", "/"),
+      gitBranch,
+      gitCommit,
+      modifiedFiles,
+      activeFiles,
+      goal: (input.goal || input.title).trim(),
+      completedSteps: input.completedSteps ? [...input.completedSteps] : [],
+      pendingTasks: input.pendingTasks ? [...input.pendingTasks] : [],
+      keyDecisions: input.keyDecisions ? [...input.keyDecisions] : [],
+      activeInvariants: Array.from(invariantsSet),
+      artifacts: input.artifacts ? [...input.artifacts] : [],
+      customMeta: input.customMeta
+    };
+    const filtered = this.database.checkpoints.filter((c) => c.id !== checkpoint.id);
+    const maxRetained = Math.max(1, CAUSAL_MEMORY_CONFIG.MAX_CHECKPOINTS_RETAINED);
+    const updatedList = [checkpoint, ...filtered].slice(0, maxRetained);
+    this.database = {
+      version: CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
+      updatedAt: nowIso,
+      latestCheckpointId: checkpoint.id,
+      totalCheckpoints: updatedList.length,
+      checkpoints: updatedList
+    };
+    this.saveDatabase();
+    if (autoResonance) {
+      try {
+        const memoryStore = new CausalMemoryStore(this.memoryDbPath);
+        memoryStore.assertRule({
+          id: "ctx-active-session-snapshot",
+          domain: "User_Preferences_And_Rules",
+          title: "Active_Session_Context_Snapshot",
+          entityType: "ContextCheckpoint",
+          triggers: {
+            alwaysActive: true,
+            keywords: ["context", "checkpoint", "resume", "\uCEE8\uD14D\uC2A4\uD2B8", "\uC774\uC5B4\uC11C", checkpoint.sessionId]
+          },
+          invariants: [
+            `[\uCD5C\uADFC \uC791\uC5C5 \uBAA9\uD45C] ${checkpoint.goal}`,
+            ...checkpoint.pendingTasks.length > 0 ? [`[\uB2E4\uC74C \uCD5C\uC6B0\uC120 \uC9C4\uD589 \uACFC\uC81C] ${checkpoint.pendingTasks[0]}`] : []
+          ],
+          actions: checkpoint.pendingTasks.slice(0, 6),
+          context: [
+            `\uCCB4\uD06C\uD3EC\uC778\uD2B8 ID: ${checkpoint.id} (\uC138\uC158: ${checkpoint.sessionId}, \uC2DC\uAC01: ${checkpoint.createdAt})`,
+            `\uC81C\uBAA9: ${checkpoint.title}`,
+            ...checkpoint.completedSteps.length > 0 ? [`\uC644\uB8CC \uB0B4\uC5ED: ${checkpoint.completedSteps.join(" | ")}`] : [],
+            ...checkpoint.keyDecisions.length > 0 ? [`\uD575\uC2EC \uACB0\uC815: ${checkpoint.keyDecisions.join(" | ")}`] : [],
+            ...checkpoint.artifacts.length > 0 ? [`\uC124\uACC4 \uC544\uD2F0\uD329\uD2B8: ${checkpoint.artifacts.join(", ")}`] : []
+          ]
+        });
+      } catch {}
+    }
+    return checkpoint;
+  }
+  getLatestCheckpoint(sessionId) {
+    this.reloadIfNeeded();
+    if (this.database.checkpoints.length === 0) {
+      return null;
+    }
+    if (sessionId && sessionId.trim().length > 0) {
+      const targetSession = sessionId.trim().toLowerCase();
+      return this.database.checkpoints.find((c) => c.sessionId.toLowerCase() === targetSession) || null;
+    }
+    return this.database.checkpoints[0] || null;
+  }
+  getCheckpoint(idOrTag, sessionId) {
+    this.reloadIfNeeded();
+    if (!idOrTag || idOrTag === "latest") {
+      return this.getLatestCheckpoint(sessionId);
+    }
+    const cleanId = idOrTag.trim();
+    const exact = this.database.checkpoints.find((c) => c.id === cleanId);
+    if (exact)
+      return exact;
+    const cleanLower = cleanId.toLowerCase();
+    return this.database.checkpoints.find((c) => c.id.toLowerCase().includes(cleanLower) || c.title.toLowerCase().includes(cleanLower) || c.sessionId.toLowerCase() === cleanLower) || null;
+  }
+  listCheckpoints(options) {
+    this.reloadIfNeeded();
+    let list = [...this.database.checkpoints];
+    if (options?.sessionId && options.sessionId.trim().length > 0) {
+      const target = options.sessionId.trim().toLowerCase();
+      list = list.filter((c) => c.sessionId.toLowerCase() === target);
+    }
+    const limit = options?.limit && options.limit > 0 ? options.limit : list.length;
+    return list.slice(0, limit);
+  }
+  deleteCheckpoint(id) {
+    this.reloadIfNeeded();
+    const beforeLen = this.database.checkpoints.length;
+    const remaining = this.database.checkpoints.filter((c) => c.id !== id);
+    if (remaining.length === beforeLen) {
+      return false;
+    }
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      latestCheckpointId: remaining[0]?.id || null,
+      totalCheckpoints: remaining.length,
+      checkpoints: remaining
+    };
+    this.saveDatabase();
+    return true;
+  }
+  static formatForAgentResume(checkpoint, compact = false) {
+    if (compact) {
+      return JSON.stringify({
+        ok: true,
+        id: checkpoint.id,
+        sessionId: checkpoint.sessionId,
+        title: checkpoint.title,
+        createdAt: checkpoint.createdAt,
+        cwd: checkpoint.cwd,
+        git: checkpoint.gitBranch ? `${checkpoint.gitBranch}@${checkpoint.gitCommit || "HEAD"}` : undefined,
+        goal: checkpoint.goal,
+        completedSteps: checkpoint.completedSteps,
+        pendingTasks: checkpoint.pendingTasks,
+        keyDecisions: checkpoint.keyDecisions,
+        activeFiles: checkpoint.activeFiles,
+        artifacts: checkpoint.artifacts,
+        activeInvariants: checkpoint.activeInvariants
+      });
+    }
+    const lines = [
+      `### \uD83D\uDCCC [Synapse Context Snapshot \uBCF5\uC6D0] ${checkpoint.title}`,
+      `- **\uCCB4\uD06C\uD3EC\uC778\uD2B8 ID**: \`${checkpoint.id}\` (\uC138\uC158: \`${checkpoint.sessionId}\`, \uC2DC\uAC01: ${checkpoint.createdAt})`,
+      `- **\uC791\uC5C5 \uACBD\uB85C**: \`${checkpoint.cwd}\`${checkpoint.gitBranch ? ` (Git: \`${checkpoint.gitBranch}\` @ \`${checkpoint.gitCommit || "HEAD"}\`)` : ""}`,
+      `- **\uD575\uC2EC \uBAA9\uD45C(Goal)**: ${checkpoint.goal}`
+    ];
+    if (checkpoint.completedSteps.length > 0) {
+      lines.push(`
+#### \u2705 \uC644\uB8CC\uB41C \uC791\uC5C5 (Completed Steps)`);
+      for (const step of checkpoint.completedSteps) {
+        lines.push(`  - ${step}`);
+      }
+    }
+    if (checkpoint.pendingTasks.length > 0) {
+      lines.push(`
+#### \u23F3 \uBC14\uB85C \uC774\uC5B4\uC11C \uC9C4\uD589\uD560 \uC791\uC5C5 (Next Pending Tasks)`);
+      for (let i = 0;i < checkpoint.pendingTasks.length; i++) {
+        lines.push(`  ${i + 1}. **${checkpoint.pendingTasks[i]}**`);
+      }
+    }
+    if (checkpoint.keyDecisions.length > 0) {
+      lines.push(`
+#### \uD83D\uDCA1 \uD575\uC2EC \uC124\uACC4 \uACB0\uC815 \uBC0F \uB9E5\uB77D (Key Decisions)`);
+      for (const dec of checkpoint.keyDecisions) {
+        lines.push(`  - ${dec}`);
+      }
+    }
+    if (checkpoint.artifacts.length > 0) {
+      lines.push(`
+#### \uD83D\uDCC4 \uCC38\uC870 \uC544\uD2F0\uD329\uD2B8 \uBC0F \uC124\uACC4 \uBB38\uC11C (Artifacts)`);
+      for (const art of checkpoint.artifacts) {
+        lines.push(`  - \`${art}\``);
+      }
+    }
+    if (checkpoint.activeFiles.length > 0) {
+      lines.push(`
+#### \uD83D\uDCC2 \uD575\uC2EC \uC791\uC5C5 \uD30C\uC77C (Active Files)`);
+      lines.push(`  - ${checkpoint.activeFiles.map((f) => `\`${f}\``).join(", ")}`);
+    }
+    if (checkpoint.activeInvariants.length > 0) {
+      lines.push(`
+#### \uD83D\uDEE1\uFE0F \uD65C\uC131 \uBD88\uBCC0 \uADDC\uCE59 (Active Invariants)`);
+      for (const inv of checkpoint.activeInvariants) {
+        lines.push(`  - ${inv}`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+}
+
+// memory/causal-timeseries.ts
+class CausalTimeSeriesEngine {
+  contextStore;
+  constructor(contextStore, _memoryStore) {
+    this.contextStore = contextStore || new ContextCheckpointStore;
+  }
+  static calculateTemporalDecayScore(options) {
+    const baseScore = options.baseScore ?? 1;
+    const nowMs = options.nowMs ?? Date.now();
+    const deltaHours = Math.max(0, (nowMs - options.lastActiveMs) / (1000 * 60 * 60));
+    const halfLifeHours = Math.max(0.1, options.halfLifeHours ?? 24);
+    const lambda = Math.LN2 / halfLifeHours;
+    const hitCount = Math.max(0, options.hitCount ?? 0);
+    const decayFactor = Math.exp(-lambda * deltaHours);
+    const frequencyBoost = 0.25 * Math.log(1 + hitCount);
+    return Number((baseScore * decayFactor + frequencyBoost).toFixed(4));
+  }
+  computeDecayedResonance(rules) {
+    return rules.map((r) => {
+      const lastActiveMs = r.updatedAt ? new Date(r.updatedAt).getTime() : Date.now();
+      const decayScore = CausalTimeSeriesEngine.calculateTemporalDecayScore({
+        baseScore: (r.confidence ?? 1) * (r.weight ?? 1),
+        lastActiveMs
+      });
+      return { ...r, decayScore };
+    });
+  }
+  generateTimeline(options) {
+    const opt = typeof options === "number" ? { limit: options } : options;
+    const checkpoints = this.contextStore.listCheckpoints({
+      sessionId: opt?.sessionId
+    });
+    const nowMs = Date.now();
+    const sinceMs = opt?.sinceMs ?? nowMs - 7 * 24 * 60 * 60 * 1000;
+    const events = [];
+    for (const cp of checkpoints) {
+      const tsMs = new Date(cp.createdAt).getTime();
+      if (tsMs < sinceMs)
+        continue;
+      events.push({
+        id: `tl_${cp.id}`,
+        timestamp: cp.createdAt,
+        timestampMs: tsMs,
+        type: "checkpoint",
+        sessionId: cp.sessionId,
+        title: cp.title,
+        summary: `\uBAA9\uD45C: ${cp.goal} | \uC644\uB8CC: ${cp.completedSteps.length}\uAC74 | \uC794\uC5EC: ${cp.pendingTasks.length}\uAC74`,
+        tags: [cp.sessionId, cp.gitBranch || "main"],
+        checkpointId: cp.id
+      });
+    }
+    events.sort((a, b) => b.timestampMs - a.timestampMs);
+    const limit = opt?.limit && opt.limit > 0 ? opt.limit : events.length;
+    return events.slice(0, limit);
+  }
+  diffCheckpoints(fromId, toId) {
+    const fromCp = this.contextStore.getCheckpoint(fromId);
+    const toCp = this.contextStore.getCheckpoint(toId);
+    if (!fromCp) {
+      throw new Error(`\uC2DC\uC791 \uCCB4\uD06C\uD3EC\uC778\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${fromId}`);
+    }
+    if (!toCp) {
+      throw new Error(`\uBE44\uAD50 \uB300\uC0C1 \uCCB4\uD06C\uD3EC\uC778\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${toId}`);
+    }
+    const fromMs = new Date(fromCp.createdAt).getTime();
+    const toMs = new Date(toCp.createdAt).getTime();
+    const deltaHours = Number(Math.abs(toMs - fromMs) / (1000 * 60 * 60)).toFixed(2);
+    const fromPendingSet = new Set(fromCp.pendingTasks);
+    const toPendingSet = new Set(toCp.pendingTasks);
+    const addedPendingTasks = toCp.pendingTasks.filter((t) => !fromPendingSet.has(t));
+    const resolvedTasks = fromCp.pendingTasks.filter((t) => !toPendingSet.has(t));
+    const fromCompletedSet = new Set(fromCp.completedSteps);
+    const newCompletedSteps = toCp.completedSteps.filter((s) => !fromCompletedSet.has(s));
+    const fromDecisionsSet = new Set(fromCp.keyDecisions);
+    const newDecisions = toCp.keyDecisions.filter((d) => !fromDecisionsSet.has(d));
+    const fromFilesSet = new Set(fromCp.modifiedFiles);
+    const toFilesSet = new Set(toCp.modifiedFiles);
+    const addedFiles = toCp.modifiedFiles.filter((f) => !fromFilesSet.has(f));
+    const removedFiles = fromCp.modifiedFiles.filter((f) => !toFilesSet.has(f));
+    const retainedFiles = toCp.modifiedFiles.filter((f) => fromFilesSet.has(f));
+    const fromInvSet = new Set(fromCp.activeInvariants);
+    const toInvSet = new Set(toCp.activeInvariants);
+    const addedInvariants = toCp.activeInvariants.filter((i) => !fromInvSet.has(i));
+    const removedInvariants = fromCp.activeInvariants.filter((i) => !toInvSet.has(i));
+    return {
+      fromId: fromCp.id,
+      toId: toCp.id,
+      fromCheckpointId: fromCp.id,
+      toCheckpointId: toCp.id,
+      fromTimestamp: fromCp.createdAt,
+      toTimestamp: toCp.createdAt,
+      timeDeltaHours: parseFloat(deltaHours),
+      newlyCompletedSteps: newCompletedSteps,
+      resolvedPendingTasks: resolvedTasks,
+      addedModifiedFiles: addedFiles,
+      addedPendingTasks,
+      resolvedTasks,
+      newCompletedSteps,
+      newDecisions,
+      modifiedFilesDelta: {
+        added: addedFiles,
+        removed: removedFiles,
+        retained: retainedFiles
+      },
+      activeInvariantsDelta: {
+        added: addedInvariants,
+        removed: removedInvariants
+      }
+    };
+  }
+  async rewindToCheckpoint(targetIdOrTag) {
+    const targetCp = this.contextStore.getCheckpoint(targetIdOrTag);
+    if (!targetCp) {
+      throw new Error(`\uB418\uAC10\uAE30 \uB300\uC0C1 \uCCB4\uD06C\uD3EC\uC778\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${targetIdOrTag}`);
+    }
+    const rolledBack = await this.contextStore.saveCheckpoint({
+      sessionId: targetCp.sessionId,
+      title: `[Rewind \uB864\uBC31] ${targetCp.title}`,
+      goal: targetCp.goal,
+      cwd: targetCp.cwd,
+      activeFiles: targetCp.activeFiles,
+      modifiedFiles: targetCp.modifiedFiles,
+      completedSteps: targetCp.completedSteps,
+      pendingTasks: targetCp.pendingTasks,
+      keyDecisions: [
+        `\uACFC\uAC70 \uCCB4\uD06C\uD3EC\uC778\uD2B8(${targetCp.id}, ${targetCp.createdAt})\uB85C \uC2DC\uACC4\uC5F4 \uB418\uAC10\uAE30 \uC218\uD589\uB428`,
+        ...targetCp.keyDecisions
+      ],
+      activeInvariants: targetCp.activeInvariants,
+      artifacts: targetCp.artifacts,
+      autoGit: false,
+      autoResonance: false
+    });
+    return rolledBack;
+  }
+  static formatDiffReport(diff) {
+    const lines = [
+      `### \u23F3 [Synapse \uC2DC\uACC4\uC5F4 \uCC28\uBD84 \uBD84\uC11D] \`${diff.fromCheckpointId}\` \u2794 \`${diff.toCheckpointId}\``,
+      `- **\uACBD\uACFC \uC2DC\uAC04**: \uC57D ${diff.timeDeltaHours}\uC2DC\uAC04 (${diff.fromTimestamp} \u2794 ${diff.toTimestamp})`
+    ];
+    if (diff.resolvedTasks.length > 0) {
+      lines.push(`
+#### \uD83C\uDFAF \uD574\uACB0/\uC644\uB8CC\uB41C \uACFC\uC81C (Resolved Tasks)`);
+      for (const t of diff.resolvedTasks)
+        lines.push(`  - \u2714 ~~${t}~~`);
+    }
+    if (diff.newCompletedSteps.length > 0) {
+      lines.push(`
+#### \u2728 \uC0C8\uB85C \uC644\uB8CC\uB41C \uB2E8\uACC4 (New Completed Steps)`);
+      for (const s of diff.newCompletedSteps)
+        lines.push(`  - \u2705 ${s}`);
+    }
+    if (diff.addedPendingTasks.length > 0) {
+      lines.push(`
+#### \u23F3 \uC0C8\uB85C \uBD80\uC5EC\uB41C \uB2E4\uC74C \uACFC\uC81C (Added Pending Tasks)`);
+      for (const t of diff.addedPendingTasks)
+        lines.push(`  - \uD83D\uDCCC **${t}**`);
+    }
+    if (diff.newDecisions.length > 0) {
+      lines.push(`
+#### \uD83D\uDCA1 \uC0C8\uB85C\uC6B4 \uC124\uACC4 \uACB0\uC815 (New Key Decisions)`);
+      for (const d of diff.newDecisions)
+        lines.push(`  - ${d}`);
+    }
+    if (diff.modifiedFilesDelta.added.length > 0 || diff.modifiedFilesDelta.removed.length > 0) {
+      lines.push(`
+#### \uD83D\uDCC2 \uD30C\uC77C \uBCC0\uACBD\uC810 (Files Delta)`);
+      if (diff.modifiedFilesDelta.added.length > 0) {
+        lines.push(`  - \uD83D\uDFE2 **\uCD94\uAC00**: ${diff.modifiedFilesDelta.added.map((f) => `\`${f}\``).join(", ")}`);
+      }
+      if (diff.modifiedFilesDelta.removed.length > 0) {
+        lines.push(`  - \uD83D\uDD34 **\uC81C\uAC70**: ${diff.modifiedFilesDelta.removed.map((f) => `\`${f}\``).join(", ")}`);
+      }
+    }
+    if (diff.activeInvariantsDelta.added.length > 0) {
+      lines.push(`
+#### \uD83D\uDEE1\uFE0F \uC0C8\uB85C \uBC1C\uB3D9\uB41C \uBD88\uBCC0 \uADDC\uCE59 (New Invariants)`);
+      for (const i of diff.activeInvariantsDelta.added)
+        lines.push(`  - ${i}`);
+    }
+    return lines.join(`
+`);
+  }
+}
+
+// memory/causal-graveyard.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, renameSync as renameSync2, statSync as statSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
+class CausalGraveyardStore {
+  dbPath;
+  database;
+  lastMtimeMs = 0;
+  constructor(customPathOrMemoryStore) {
+    const customPath = typeof customPathOrMemoryStore === "string" ? customPathOrMemoryStore : undefined;
+    this.dbPath = customPath || process.env.SYNAPSE_GRAVEYARD_PATH || resolve2(homedir2(), ".gemini", "antigravity", "causal_graveyard.json");
+    this.database = this.loadDatabase();
+  }
+  loadDatabase() {
+    try {
+      if (existsSync3(this.dbPath)) {
+        const stat = statSync3(this.dbPath);
+        this.lastMtimeMs = stat.mtimeMs;
+        const raw = readFileSync3(this.dbPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && Array.isArray(parsed.traps)) {
+          return parsed;
+        }
+      }
+    } catch {}
+    return {
+      version: CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
+      updatedAt: new Date().toISOString(),
+      totalTraps: 0,
+      traps: []
+    };
+  }
+  reloadIfNeeded() {
+    try {
+      if (existsSync3(this.dbPath)) {
+        const stat = statSync3(this.dbPath);
+        if (stat.mtimeMs > this.lastMtimeMs) {
+          this.database = this.loadDatabase();
+        }
+      }
+    } catch {}
+  }
+  saveDatabase() {
+    try {
+      const dir = dirname3(this.dbPath);
+      if (!existsSync3(dir)) {
+        mkdirSync3(dir, { recursive: true });
+      }
+      const serialized = JSON.stringify(this.database, null, 2);
+      const tempPath = `${this.dbPath}.tmp.${process.pid}.${Date.now()}`;
+      writeFileSync3(tempPath, serialized, "utf-8");
+      renameSync2(tempPath, this.dbPath);
+      try {
+        this.lastMtimeMs = statSync3(this.dbPath).mtimeMs;
+      } catch {}
+    } catch (error) {
+      throw new Error(`\uC2E4\uD328 \uAC00\uC124 \uBB18\uC9C0 \uC800\uC7A5 \uC2E4\uD328: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  assertTrap(input) {
+    this.reloadIfNeeded();
+    const nowIso = new Date().toISOString();
+    const id = input.id || `trap_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+    const title = input.title || input.trapPattern || "\uC54C \uC218 \uC5C6\uB294 \uD568\uC815 \uD328\uD134";
+    const failedApproach = input.failedApproach || input.trapPattern || title;
+    const rootCause = input.rootCause || input.reason || "\uC0AC\uC720 \uBBF8\uAE30\uC7AC";
+    const counterMeasure = input.counterMeasure || input.safeAlternative || "\uC548\uC804\uD55C \uB300\uC548 \uBBF8\uAE30\uC7AC";
+    const triggerKeywords = Array.isArray(input.triggerKeywords) ? input.triggerKeywords : Array.isArray(input.keywords) ? input.keywords : title.split(/\s+/).filter(Boolean);
+    const triggerFiles = Array.isArray(input.triggerFiles) ? input.triggerFiles : Array.isArray(input.avoidFiles) ? input.avoidFiles : Array.isArray(input.files) ? input.files : undefined;
+    const trap = {
+      id,
+      title,
+      failedApproach,
+      rootCause,
+      counterMeasure,
+      triggerKeywords,
+      triggerFiles,
+      errorSignature: input.errorSignature,
+      environment: input.environment || input.domain || "general",
+      hitCount: (input.hitCount ?? 0) + 1,
+      createdAt: input.createdAt || nowIso,
+      lastEncounteredAt: nowIso,
+      trapPattern: failedApproach,
+      domain: input.domain || input.environment || "general",
+      severity: input.severity || (input.errorSignature ? "CRITICAL" : "WARNING"),
+      reason: rootCause,
+      safeAlternative: counterMeasure,
+      avoidFiles: triggerFiles
+    };
+    const filtered = this.database.traps.filter((t) => t.id !== trap.id);
+    const updated = [trap, ...filtered];
+    this.database = {
+      version: CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
+      updatedAt: nowIso,
+      totalTraps: updated.length,
+      traps: updated
+    };
+    this.saveDatabase();
+    return trap;
+  }
+  scanTraps(query) {
+    this.reloadIfNeeded();
+    const warnings = [];
+    const fullText = [
+      query.text || "",
+      query.code || "",
+      ...query.keywords || []
+    ].join(" ").toLowerCase();
+    const files = (query.files || []).map((f) => f.replaceAll("\\", "/").toLowerCase());
+    for (const trap of this.database.traps) {
+      let matched = false;
+      let matchedBy = "keyword";
+      let matchedPattern = "";
+      if (trap.errorSignature && trap.errorSignature.length >= 3) {
+        const sigLower = trap.errorSignature.toLowerCase();
+        if (fullText.includes(sigLower)) {
+          matched = true;
+          matchedBy = "error_signature";
+          matchedPattern = trap.errorSignature;
+        }
+      }
+      const targetFiles = trap.triggerFiles || trap.avoidFiles || [];
+      if (!matched && targetFiles.length > 0) {
+        for (const tf of targetFiles) {
+          const tfLower = tf.replaceAll("\\", "/").toLowerCase();
+          if (files.some((f) => f.includes(tfLower) || tfLower.includes(f))) {
+            matched = true;
+            matchedBy = "file";
+            matchedPattern = tf;
+            break;
+          }
+        }
+      }
+      const targetKeywords = trap.triggerKeywords || [];
+      if (!matched && targetKeywords.length > 0) {
+        for (const kw of targetKeywords) {
+          const kwLower = kw.toLowerCase();
+          if (kwLower.length >= 2 && fullText.includes(kwLower)) {
+            matched = true;
+            matchedBy = "keyword";
+            matchedPattern = kw;
+            break;
+          }
+        }
+      }
+      if (matched) {
+        warnings.push({
+          trapId: trap.id,
+          title: trap.title,
+          riskLevel: trap.severity === "CRITICAL" || trap.errorSignature ? "CRITICAL" : "WARNING",
+          matchedBy,
+          matchedPattern,
+          whyItFails: trap.rootCause,
+          recommendedFix: trap.counterMeasure
+        });
+      }
+    }
+    const hasCritical = warnings.some((w) => w.riskLevel === "CRITICAL");
+    const highestSeverity = warnings.length === 0 ? "NONE" : hasCritical ? "CRITICAL" : "WARNING";
+    const result = warnings;
+    Object.assign(result, {
+      trapped: warnings.length > 0,
+      triggeredTraps: warnings,
+      highestSeverity
+    });
+    return result;
+  }
+  listTraps() {
+    this.reloadIfNeeded();
+    return [...this.database.traps];
+  }
+  getAllTraps() {
+    return this.listTraps();
+  }
+  deleteTrap(id) {
+    this.reloadIfNeeded();
+    const before = this.database.traps.length;
+    const remaining = this.database.traps.filter((t) => t.id !== id);
+    if (remaining.length === before)
+      return false;
+    this.database = {
+      version: CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
+      updatedAt: new Date().toISOString(),
+      totalTraps: remaining.length,
+      traps: remaining
+    };
+    this.saveDatabase();
+    return true;
+  }
+  static formatWarningsForAgent(warnings) {
+    if (!warnings || warnings.length === 0)
+      return "";
+    const lines = [
+      `### \uD83D\uDC80 [\uC2E4\uD328 \uAC00\uC124 \uBB18\uC9C0 \uACBD\uACE0 (Graveyard Trap Detected)] \uC774\uBBF8 \uC2E4\uD328\uD588\uB358 \uC548\uD2F0\uD328\uD134 ${warnings.length}\uAC74 \uAC10\uC9C0!`
+    ];
+    for (const w of warnings) {
+      lines.push(`
+\uD83D\uDEA8 **[${w.riskLevel}] ${w.title}** (\uAC10\uC9C0: \`${w.matchedPattern}\` by ${w.matchedBy})`);
+      lines.push(`  - \u274C **\uC2E4\uD328 \uC6D0\uC778**: ${w.whyItFails}`);
+      lines.push(`  - \uD83D\uDCA1 **\uAC80\uC99D\uB41C \uB300\uC548**: ${w.recommendedFix}`);
+    }
+    return lines.join(`
+`);
+  }
+  static formatTrapWarnings(warnings) {
+    if (!warnings)
+      return "";
+    if (Array.isArray(warnings))
+      return CausalGraveyardStore.formatWarningsForAgent(warnings);
+    if (warnings && Array.isArray(warnings.triggeredTraps)) {
+      return CausalGraveyardStore.formatWarningsForAgent(warnings.triggeredTraps);
+    }
+    return "";
+  }
+}
+
+// memory/causal-branch.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, renameSync as renameSync3, statSync as statSync4 } from "fs";
+import { dirname as dirname4, resolve as resolve3 } from "path";
+import { homedir as homedir3 } from "os";
+class CausalBranchStore {
+  dbPath;
+  contextStore;
+  graveyardStore;
+  database;
+  lastMtimeMs = 0;
+  constructor(customPathOrContextStore, contextStoreOrGraveyard, graveyardStore) {
+    if (typeof customPathOrContextStore === "string") {
+      this.dbPath = customPathOrContextStore;
+      this.contextStore = contextStoreOrGraveyard instanceof ContextCheckpointStore ? contextStoreOrGraveyard : new ContextCheckpointStore;
+      this.graveyardStore = graveyardStore || (contextStoreOrGraveyard instanceof CausalGraveyardStore ? contextStoreOrGraveyard : new CausalGraveyardStore);
+    } else if (customPathOrContextStore instanceof ContextCheckpointStore) {
+      this.dbPath = process.env.SYNAPSE_BRANCH_PATH || resolve3(homedir3(), ".gemini", "antigravity", "causal_branches.json");
+      this.contextStore = customPathOrContextStore;
+      this.graveyardStore = contextStoreOrGraveyard instanceof CausalGraveyardStore ? contextStoreOrGraveyard : new CausalGraveyardStore;
+    } else {
+      this.dbPath = process.env.SYNAPSE_BRANCH_PATH || resolve3(homedir3(), ".gemini", "antigravity", "causal_branches.json");
+      this.contextStore = new ContextCheckpointStore;
+      this.graveyardStore = new CausalGraveyardStore;
+    }
+    this.database = this.loadDatabase();
+  }
+  loadDatabase() {
+    try {
+      if (existsSync4(this.dbPath)) {
+        const stat = statSync4(this.dbPath);
+        this.lastMtimeMs = stat.mtimeMs;
+        const raw = readFileSync4(this.dbPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && Array.isArray(parsed.branches)) {
+          return parsed;
+        }
+      }
+    } catch {}
+    return {
+      version: CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
+      updatedAt: new Date().toISOString(),
+      currentBranch: "main",
+      branches: [
+        {
+          name: "main",
+          baseCheckpointId: "root",
+          headCheckpointId: "root",
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+          status: "active",
+          description: "\uAE30\uBCF8 \uBA54\uC778 \uB450\uB1CC \uBE0C\uB79C\uCE58"
+        }
+      ]
+    };
+  }
+  reloadIfNeeded() {
+    try {
+      if (existsSync4(this.dbPath)) {
+        const stat = statSync4(this.dbPath);
+        if (stat.mtimeMs > this.lastMtimeMs) {
+          this.database = this.loadDatabase();
+        }
+      }
+    } catch {}
+  }
+  saveDatabase() {
+    try {
+      const dir = dirname4(this.dbPath);
+      if (!existsSync4(dir)) {
+        mkdirSync4(dir, { recursive: true });
+      }
+      const serialized = JSON.stringify(this.database, null, 2);
+      const tempPath = `${this.dbPath}.tmp.${process.pid}.${Date.now()}`;
+      writeFileSync4(tempPath, serialized, "utf-8");
+      renameSync3(tempPath, this.dbPath);
+      try {
+        this.lastMtimeMs = statSync4(this.dbPath).mtimeMs;
+      } catch {}
+    } catch (error) {
+      throw new Error(`\uCEE8\uD14D\uC2A4\uD2B8 \uBE0C\uB79C\uCE58 \uB370\uC774\uD130\uBCA0\uC774\uC2A4 \uC800\uC7A5 \uC2E4\uD328: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async createBranch(name, options) {
+    this.reloadIfNeeded();
+    const cleanName = name.trim();
+    if (!cleanName)
+      throw new Error("\uBE0C\uB79C\uCE58 \uC774\uB984\uC740 \uBE44\uC5B4 \uC788\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    const existing = this.database.branches.find((b) => b.name === cleanName);
+    if (existing && existing.status === "active") {
+      throw new Error(`\uC774\uBBF8 \uC874\uC7AC\uD558\uB294 \uD65C\uC131 \uBE0C\uB79C\uCE58\uC785\uB2C8\uB2E4: ${cleanName}`);
+    }
+    let baseCp = null;
+    if (options?.baseId) {
+      baseCp = this.contextStore.getCheckpoint(options.baseId);
+    } else {
+      baseCp = this.contextStore.getLatestCheckpoint();
+    }
+    const baseId = baseCp?.id || "root";
+    const nowIso = new Date().toISOString();
+    const forkedCp = await this.contextStore.saveCheckpoint({
+      sessionId: `branch-${cleanName}`,
+      title: `[Branch Start] ${cleanName}`,
+      goal: options?.description || `\uBE0C\uB79C\uCE58 ${cleanName} \uB3C5\uB9BD \uAC00\uC124 \uAC80\uC99D`,
+      completedSteps: baseCp?.completedSteps || [],
+      pendingTasks: baseCp?.pendingTasks || [],
+      keyDecisions: baseCp ? [`\uBE0C\uB79C\uCE58 ${cleanName}\uC774 \uCCB4\uD06C\uD3EC\uC778\uD2B8 ${baseId}\uC5D0\uC11C \uBD84\uAE30\uB428`] : [],
+      activeFiles: baseCp?.activeFiles || [],
+      artifacts: baseCp?.artifacts || [],
+      activeInvariants: baseCp?.activeInvariants || [],
+      autoGit: false,
+      autoResonance: false
+    });
+    const newBranch = {
+      name: cleanName,
+      baseCheckpointId: baseId,
+      headCheckpointId: forkedCp.id,
+      createdAt: nowIso,
+      updatedAt: nowIso,
+      status: "active",
+      description: options?.description
+    };
+    const remaining = this.database.branches.filter((b) => b.name !== cleanName);
+    this.database = {
+      ...this.database,
+      updatedAt: nowIso,
+      currentBranch: cleanName,
+      branches: [...remaining, newBranch]
+    };
+    this.saveDatabase();
+    return newBranch;
+  }
+  switchBranch(name) {
+    this.reloadIfNeeded();
+    const clean = name.trim();
+    const target = this.database.branches.find((b) => b.name === clean);
+    if (!target) {
+      throw new Error(`\uC874\uC7AC\uD558\uC9C0 \uC54A\uB294 \uBE0C\uB79C\uCE58\uC785\uB2C8\uB2E4: ${clean}`);
+    }
+    this.database = {
+      ...this.database,
+      updatedAt: new Date().toISOString(),
+      currentBranch: clean
+    };
+    this.saveDatabase();
+    return target;
+  }
+  async mergeBranch(sourceName, targetName = "main") {
+    this.reloadIfNeeded();
+    const src = this.database.branches.find((b) => b.name === sourceName.trim());
+    const tgt = this.database.branches.find((b) => b.name === targetName.trim());
+    if (!src)
+      throw new Error(`\uC18C\uC2A4 \uBE0C\uB79C\uCE58\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${sourceName}`);
+    if (!tgt)
+      throw new Error(`\uD0C0\uAE43 \uBE0C\uB79C\uCE58\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${targetName}`);
+    if (src.status !== "active")
+      throw new Error(`\uC18C\uC2A4 \uBE0C\uB79C\uCE58\uAC00 \uD65C\uC131 \uC0C1\uD0DC\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${src.status}`);
+    const srcCp = this.contextStore.getCheckpoint(src.headCheckpointId);
+    const tgtCp = this.contextStore.getCheckpoint(tgt.headCheckpointId);
+    const mergedTitle = `[Merge] ${src.name} \u2794 ${tgt.name}`;
+    const mergedDecisions = Array.from(new Set([
+      `\uBE0C\uB79C\uCE58 ${src.name}\uC774 ${tgt.name}\uC73C\uB85C \uBCD1\uD569 \uC644\uB8CC\uB428`,
+      ...tgtCp?.keyDecisions || [],
+      ...srcCp?.keyDecisions || []
+    ]));
+    const mergedCompleted = Array.from(new Set([...tgtCp?.completedSteps || [], ...srcCp?.completedSteps || []]));
+    const mergedPending = Array.from(new Set([...srcCp?.pendingTasks || [], ...tgtCp?.pendingTasks || []]));
+    const mergedFiles = Array.from(new Set([...tgtCp?.activeFiles || [], ...srcCp?.activeFiles || []]));
+    const mergedInvariants = Array.from(new Set([...tgtCp?.activeInvariants || [], ...srcCp?.activeInvariants || []]));
+    const resultingCp = await this.contextStore.saveCheckpoint({
+      sessionId: `branch-${tgt.name}`,
+      title: mergedTitle,
+      goal: tgtCp?.goal || srcCp?.goal || mergedTitle,
+      completedSteps: mergedCompleted,
+      pendingTasks: mergedPending,
+      keyDecisions: mergedDecisions,
+      activeFiles: mergedFiles,
+      activeInvariants: mergedInvariants,
+      artifacts: Array.from(new Set([...tgtCp?.artifacts || [], ...srcCp?.artifacts || []])),
+      autoGit: false,
+      autoResonance: false
+    });
+    const nowIso = new Date().toISOString();
+    const updatedSrc = {
+      ...src,
+      status: "merged",
+      mergedInto: tgt.name,
+      updatedAt: nowIso
+    };
+    const updatedTgt = {
+      ...tgt,
+      headCheckpointId: resultingCp.id,
+      updatedAt: nowIso
+    };
+    const remaining = this.database.branches.filter((b) => b.name !== src.name && b.name !== tgt.name);
+    this.database = {
+      ...this.database,
+      updatedAt: nowIso,
+      currentBranch: tgt.name,
+      branches: [...remaining, updatedTgt, updatedSrc]
+    };
+    this.saveDatabase();
+    return { mergedBranch: updatedSrc, resultingCheckpoint: resultingCp };
+  }
+  abandonBranch(name, failureInfo, safeAlternative) {
+    this.reloadIfNeeded();
+    const target = this.database.branches.find((b) => b.name === name.trim());
+    if (!target)
+      throw new Error(`\uD3D0\uAE30\uD560 \uBE0C\uB79C\uCE58\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${name}`);
+    const infoObj = typeof failureInfo === "string" ? { rootCause: failureInfo, counterMeasure: safeAlternative } : failureInfo || {};
+    const nowIso = new Date().toISOString();
+    const updated = {
+      ...target,
+      status: "abandoned",
+      abandonmentReason: infoObj.rootCause || "\uC2E4\uD5D8\uC801 \uAC00\uC124 \uC2E4\uD328\uB85C \uAE30\uAC01\uB428",
+      updatedAt: nowIso
+    };
+    let trapRecorded = false;
+    if (infoObj.rootCause || infoObj.failedApproach) {
+      this.graveyardStore.assertTrap({
+        id: `trap_branch_${target.name}_${Date.now().toString(36)}`,
+        title: `\uBE0C\uB79C\uCE58 ${target.name} \uAE30\uAC01 \uAC00\uC124`,
+        failedApproach: infoObj.failedApproach || target.description || target.name,
+        errorSignature: infoObj.errorSignature,
+        rootCause: infoObj.rootCause || "\uAC00\uC124 \uAC80\uC99D \uC2E4\uD328",
+        counterMeasure: infoObj.counterMeasure || "\uD574\uB2F9 \uBE0C\uB79C\uCE58 \uC811\uADFC\uBC95 \uD3D0\uAE30 \uBC0F \uB300\uC548 \uBE0C\uB79C\uCE58 \uC218\uB9BD \uD544\uC694",
+        triggerKeywords: [
+          target.name,
+          ...target.description ? target.description.split(/\s+/) : []
+        ]
+      });
+      trapRecorded = true;
+    }
+    const remaining = this.database.branches.filter((b) => b.name !== target.name);
+    this.database = {
+      ...this.database,
+      updatedAt: nowIso,
+      currentBranch: this.database.currentBranch === target.name ? "main" : this.database.currentBranch,
+      branches: [...remaining, updated]
+    };
+    this.saveDatabase();
+    return { branch: updated, trapRecorded, success: true };
+  }
+  listBranches() {
+    this.reloadIfNeeded();
+    return [...this.database.branches];
+  }
+  getCurrentBranch() {
+    this.reloadIfNeeded();
+    const curr = this.database.branches.find((b) => b.name === this.database.currentBranch);
+    return curr || {
+      name: "main",
+      baseCheckpointId: "root",
+      headCheckpointId: "root",
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      status: "active"
+    };
+  }
+}
+
+// memory/causal-predictor.ts
+class CausalPredictorEngine {
+  memoryStore;
+  contextStore;
+  constructor(memoryStore, contextStore) {
+    this.memoryStore = memoryStore || new CausalMemoryStore;
+    this.contextStore = contextStore || new ContextCheckpointStore;
+  }
+  analyzeBlastRadius(files, maxHops = 3) {
+    const startTime = performance.now();
+    this.memoryStore.reloadIfNeeded();
+    this.contextStore.reloadIfNeeded();
+    const normalizedFiles = files.map((f) => f.replaceAll("\\", "/").toLowerCase());
+    const resonance = this.memoryStore.queryResonance({
+      files: normalizedFiles,
+      propagateRelations: false
+    });
+    const directRules = resonance.resonanceRules;
+    const rawDb = this.memoryStore.getRawDatabase();
+    const outgoingMap = new Map;
+    const incomingMap = new Map;
+    for (const rel of rawDb.relations) {
+      const fromLower = rel.from.toLowerCase();
+      const toLower = rel.to.toLowerCase();
+      if (!outgoingMap.has(fromLower))
+        outgoingMap.set(fromLower, []);
+      outgoingMap.get(fromLower).push(rel);
+      if (!incomingMap.has(toLower))
+        incomingMap.set(toLower, []);
+      incomingMap.get(toLower).push(rel);
+    }
+    const titleToRule = new Map;
+    for (const rule of rawDb.rules) {
+      titleToRule.set(rule.title.toLowerCase(), rule);
+      titleToRule.set(rule.id.toLowerCase(), rule);
+    }
+    const visited = new Set;
+    const affectedNodes = [];
+    const prefetchedInvariantsSet = new Set;
+    const suggestedFilesSet = new Set;
+    for (const direct of directRules) {
+      if (direct.invariants && Array.isArray(direct.invariants)) {
+        for (const inv of direct.invariants) {
+          prefetchedInvariantsSet.add(inv);
+        }
+      }
+    }
+    let currentLevel = directRules.map((r) => r.title.toLowerCase());
+    for (const t of currentLevel)
+      visited.add(t);
+    for (let hop = 1;hop <= maxHops; hop++) {
+      const nextLevel = [];
+      const hopWeight = Math.pow(0.7, hop - 1);
+      for (const currentTitle of currentLevel) {
+        const outRels = outgoingMap.get(currentTitle) || [];
+        const inRels = incomingMap.get(currentTitle) || [];
+        const allRels = [...outRels, ...inRels];
+        for (const rel of allRels) {
+          const neighbor = rel.from.toLowerCase() === currentTitle ? rel.to.toLowerCase() : rel.from.toLowerCase();
+          if (visited.has(neighbor))
+            continue;
+          visited.add(neighbor);
+          nextLevel.push(neighbor);
+          const neighborRule = titleToRule.get(neighbor);
+          if (neighborRule) {
+            let baseScore = 60;
+            const relKind = rel.relation || rel.relationType || "requires";
+            const rType = relKind.toLowerCase();
+            if (rType.includes("trigger") || rType.includes("govern"))
+              baseScore = 90;
+            else if (rType.includes("verify") || rType.includes("produce"))
+              baseScore = 75;
+            const riskScore = Math.round(baseScore * hopWeight);
+            for (const inv of neighborRule.invariants || []) {
+              prefetchedInvariantsSet.add(inv);
+            }
+            if (neighborRule.triggers && Array.isArray(neighborRule.triggers.files)) {
+              for (const f of neighborRule.triggers.files) {
+                suggestedFilesSet.add(f);
+              }
+            }
+            affectedNodes.push({
+              name: neighborRule.title || neighborRule.name || neighborRule.id,
+              domain: neighborRule.domain,
+              hopLevel: hop,
+              relationType: relKind,
+              riskReason: `${hop}\uB2E8\uACC4 \uC778\uACFC \uC5F0\uACB0 (\`${rel.from}\` \u2500\u2500[${relKind}]\u2500\u2500\u25B6 \`${rel.to}\`)`,
+              riskScore,
+              requiredInvariants: neighborRule.invariants || []
+            });
+          }
+        }
+      }
+      if (nextLevel.length === 0)
+        break;
+      currentLevel = nextLevel;
+    }
+    const recentCheckpoints = this.contextStore.listCheckpoints({ limit: 15 });
+    for (const cp of recentCheckpoints) {
+      const hasInputFile = cp.modifiedFiles.some((mf) => normalizedFiles.some((nf) => mf.toLowerCase().includes(nf) || nf.includes(mf.toLowerCase())));
+      if (hasInputFile) {
+        for (const f of cp.modifiedFiles) {
+          if (!normalizedFiles.includes(f.toLowerCase())) {
+            suggestedFilesSet.add(f);
+          }
+        }
+      }
+    }
+    affectedNodes.sort((a, b) => b.riskScore - a.riskScore);
+    const maxRiskScore = affectedNodes.length > 0 ? affectedNodes[0].riskScore : 0;
+    let overallRisk = "LOW";
+    if (maxRiskScore >= 80)
+      overallRisk = "CRITICAL";
+    else if (maxRiskScore >= 60)
+      overallRisk = "HIGH";
+    else if (maxRiskScore >= 40)
+      overallRisk = "MEDIUM";
+    const durationMs = Number((performance.now() - startTime).toFixed(2));
+    return {
+      triggerFiles: files,
+      overallRisk,
+      maxRiskScore,
+      affectedNodes,
+      prefetchedInvariants: Array.from(prefetchedInvariantsSet),
+      suggestedTargetFiles: Array.from(suggestedFilesSet).slice(0, 10),
+      durationMs
+    };
+  }
+  static formatPredictReport(report) {
+    const lines = [
+      `### \uD83D\uDD2E [\uC778\uACFC \uC5F0\uC1C4 \uD30C\uAE09 \uC608\uCE21 \uBD84\uC11D] \uC704\uD5D8\uB3C4: **${report.overallRisk}** (\uCD5C\uACE0 \uC704\uD5D8 \uC810\uC218: ${report.maxRiskScore}/100, \uC18C\uC694: ${report.durationMs}ms)`,
+      `- **\uC218\uC815 \uB300\uC0C1 \uD30C\uC77C**: ${report.triggerFiles.map((f) => `\`${f}\``).join(", ")}`
+    ];
+    if (report.affectedNodes.length > 0) {
+      lines.push(`
+#### \uD83D\uDCA5 \uC5F0\uC1C4 \uD30C\uAE09 \uC601\uD5A5 \uB178\uB4DC (Blast Radius Nodes)`);
+      for (const node of report.affectedNodes) {
+        lines.push(`  - **[${node.riskScore}\uC810 | ${node.hopLevel}\uCC28]** \`${node.name}\` (${node.domain}) \u2794 ${node.riskReason}`);
+      }
+    }
+    if (report.suggestedTargetFiles.length > 0) {
+      lines.push(`
+#### \uD83C\uDFAF \uD568\uAED8 \uAC80\uC99D/\uC218\uC815\uD574\uC57C \uD560 \uCD94\uCC9C \uD0C0\uAE43 \uD30C\uC77C (Prefetched Targets)`);
+      for (const tf of report.suggestedTargetFiles) {
+        lines.push(`  - \`${tf}\``);
+      }
+    }
+    if (report.prefetchedInvariants.length > 0) {
+      lines.push(`
+#### \uD83D\uDEE1\uFE0F \uC0AC\uC804 \uB85C\uB4DC\uB41C \uD30C\uAE09 \uBD88\uBCC0 \uADDC\uCE59 (Prefetched Invariants)`);
+      for (const inv of report.prefetchedInvariants.slice(0, 8)) {
+        lines.push(`  - ${inv}`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+}
+
+// memory/causal-synthesizer.ts
+var {spawn: spawn3 } = globalThis.Bun;
+import { existsSync as existsSync5, readdirSync } from "fs";
+class CausalSynthesizerEngine {
+  contextStore;
+  memoryStore;
+  constructor(contextStore, memoryStore) {
+    this.contextStore = contextStore || new ContextCheckpointStore;
+    this.memoryStore = memoryStore || new CausalMemoryStore;
+  }
+  async inspectGitChanges(cwd = process.cwd()) {
+    try {
+      const gitHead = await detectGitHeadInfo(cwd);
+      const statusProc = spawn3(["git", "status", "--porcelain"], {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const statusOutput = (await new Response(statusProc.stdout).text()).trim();
+      await statusProc.exited;
+      const modifiedFiles = [];
+      const addedFiles = [];
+      const deletedFiles = [];
+      const untrackedFiles = [];
+      if (statusOutput.length > 0) {
+        for (const line of statusOutput.split(`
+`)) {
+          const trimmed = line.trimEnd();
+          if (trimmed.length < 3)
+            continue;
+          const statusCode = trimmed.slice(0, 2);
+          const rawFilePath = trimmed.slice(3).trim().replace(/^"|"$/g, "");
+          const normalizedPath = rawFilePath.replaceAll("\\", "/");
+          if (statusCode.includes("M")) {
+            modifiedFiles.push(normalizedPath);
+          } else if (statusCode.includes("A")) {
+            addedFiles.push(normalizedPath);
+          } else if (statusCode.includes("D")) {
+            deletedFiles.push(normalizedPath);
+          } else if (statusCode.includes("?")) {
+            untrackedFiles.push(normalizedPath);
+          }
+        }
+      }
+      const stats = await this.parseGitStats(cwd);
+      const extractedSymbols = await this.extractSymbolsFromDiff(cwd);
+      const allActiveFiles = Array.from(new Set([...modifiedFiles, ...addedFiles, ...untrackedFiles]));
+      const detectedDomains = this.detectDomainsFromFiles(allActiveFiles);
+      return {
+        cwd,
+        branch: gitHead.branch,
+        commit: gitHead.commit,
+        modifiedFiles,
+        addedFiles,
+        deletedFiles,
+        untrackedFiles,
+        allActiveFiles,
+        stats,
+        extractedSymbols,
+        detectedDomains
+      };
+    } catch {
+      return this.fallbackFilesystemScan(cwd);
+    }
+  }
+  async parseGitStats(cwd) {
+    try {
+      const proc = spawn3(["git", "diff", "HEAD", "--shortstat"], {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const out = (await new Response(proc.stdout).text()).trim();
+      await proc.exited;
+      let filesChanged = 0;
+      let insertions = 0;
+      let deletions = 0;
+      const filesMatch = out.match(/(\d+)\s+files?\s+changed/i);
+      const insertMatch = out.match(/(\d+)\s+insertions?\(\+\)/i);
+      const deleteMatch = out.match(/(\d+)\s+deletions?\(-\)/i);
+      if (filesMatch)
+        filesChanged = parseInt(filesMatch[1], 10);
+      if (insertMatch)
+        insertions = parseInt(insertMatch[1], 10);
+      if (deleteMatch)
+        deletions = parseInt(deleteMatch[1], 10);
+      return { filesChanged, insertions, deletions };
+    } catch {
+      return { filesChanged: 0, insertions: 0, deletions: 0 };
+    }
+  }
+  async extractSymbolsFromDiff(cwd) {
+    const functions = new Set;
+    const classes = new Set;
+    const interfaces = new Set;
+    const types = new Set;
+    try {
+      const proc = spawn3(["git", "diff", "HEAD", "-U1"], {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const diffText = await new Response(proc.stdout).text();
+      await proc.exited;
+      if (!diffText || diffText.length === 0) {
+        return { functions: [], classes: [], interfaces: [], types: [] };
+      }
+      for (const line of diffText.split(`
+`)) {
+        if (!line.startsWith("+") && !line.startsWith("@@"))
+          continue;
+        const content = line.startsWith("+") ? line.slice(1).trim() : line;
+        const fnMatch = content.match(/(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_$]+)/) || content.match(/(?:export\s+)?(?:const|let)\s+([A-Za-z0-9_$]+)\s*=\s*(?:async\s*)?\(/);
+        if (fnMatch && fnMatch[1]) {
+          functions.add(fnMatch[1]);
+        }
+        const clsMatch = content.match(/(?:export\s+)?(?:abstract\s+)?class\s+([A-Za-z0-9_$]+)/);
+        if (clsMatch && clsMatch[1]) {
+          classes.add(clsMatch[1]);
+        }
+        const ifaceMatch = content.match(/(?:export\s+)?interface\s+([A-Za-z0-9_$]+)/);
+        if (ifaceMatch && ifaceMatch[1]) {
+          interfaces.add(ifaceMatch[1]);
+        }
+        const typeMatch = content.match(/(?:export\s+)?type\s+([A-Za-z0-9_$]+)\s*=/);
+        if (typeMatch && typeMatch[1]) {
+          types.add(typeMatch[1]);
+        }
+      }
+      return {
+        functions: Array.from(functions).slice(0, 15),
+        classes: Array.from(classes).slice(0, 10),
+        interfaces: Array.from(interfaces).slice(0, 10),
+        types: Array.from(types).slice(0, 10)
+      };
+    } catch {
+      return { functions: [], classes: [], interfaces: [], types: [] };
+    }
+  }
+  detectDomainsFromFiles(files) {
+    const domains = new Set;
+    for (const file of files) {
+      const lower = file.toLowerCase();
+      if (lower.includes("test") || lower.endsWith(".test.ts") || lower.endsWith(".spec.ts")) {
+        domains.add("testing");
+      }
+      if (lower.includes("compiler") || lower.includes("ast")) {
+        domains.add("compiler");
+      }
+      if (lower.includes("memory") || lower.includes("causal")) {
+        domains.add("memory");
+      }
+      if (lower.includes("db") || lower.includes("database") || lower.includes("sqlite")) {
+        domains.add("database");
+      }
+      if (lower.includes("mesh") || lower.includes("distributed") || lower.includes("peer")) {
+        domains.add("mesh");
+      }
+      if (lower.includes("runner") || lower.includes("execution")) {
+        domains.add("runner");
+      }
+      if (lower.includes("bus") || lower.includes("event")) {
+        domains.add("bus");
+      }
+      if (lower.includes("guard") || lower.includes("security")) {
+        domains.add("security");
+      }
+      if (lower.includes("studio") || lower.includes("ui") || lower.includes("view")) {
+        domains.add("frontend");
+      }
+      if (lower.includes("lens") || lower.includes("obsidian")) {
+        domains.add("obsidian-lens");
+      }
+    }
+    if (domains.size === 0) {
+      domains.add("core");
+    }
+    return Array.from(domains);
+  }
+  fallbackFilesystemScan(cwd) {
+    try {
+      const modified = [];
+      if (existsSync5(cwd)) {
+        const entries = readdirSync(cwd, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isFile() && !entry.name.startsWith(".")) {
+            modified.push(entry.name);
+          }
+        }
+      }
+      return {
+        cwd,
+        modifiedFiles: modified,
+        addedFiles: [],
+        deletedFiles: [],
+        untrackedFiles: [],
+        allActiveFiles: modified,
+        stats: { insertions: 0, deletions: 0, filesChanged: modified.length },
+        extractedSymbols: { functions: [], classes: [], interfaces: [], types: [] },
+        detectedDomains: ["general"]
+      };
+    } catch {
+      return {
+        cwd,
+        modifiedFiles: [],
+        addedFiles: [],
+        deletedFiles: [],
+        untrackedFiles: [],
+        allActiveFiles: [],
+        stats: { insertions: 0, deletions: 0, filesChanged: 0 },
+        extractedSymbols: { functions: [], classes: [], interfaces: [], types: [] },
+        detectedDomains: ["unknown"]
+      };
+    }
+  }
+  synthesizeIntent(summary, customTitle) {
+    const completedSteps = [];
+    const pendingTasks = [];
+    const keyDecisions = [];
+    const activeInvariants = [];
+    const suggestedKeywords = [...summary.detectedDomains];
+    if (summary.extractedSymbols.classes.length > 0) {
+      completedSteps.push(`\uD575\uC2EC \uD074\uB798\uC2A4 \uBAA8\uB4C8\uD654 \uBC0F \uC120\uC5B8: ${summary.extractedSymbols.classes.join(", ")}`);
+    }
+    if (summary.extractedSymbols.interfaces.length > 0) {
+      completedSteps.push(`\uD0C0\uC785 \uACC4\uC57D \uBC0F \uC778\uD130\uD398\uC774\uC2A4 \uC815\uC758: ${summary.extractedSymbols.interfaces.join(", ")}`);
+    }
+    if (summary.extractedSymbols.functions.length > 0) {
+      completedSteps.push(`\uC8FC\uC694 \uD568\uC218 \uBC0F \uC54C\uACE0\uB9AC\uC998 \uAD6C\uD604: ${summary.extractedSymbols.functions.slice(0, 5).join(", ")}`);
+    }
+    if (summary.detectedDomains.includes("testing")) {
+      completedSteps.push("\uB2E8\uC704 \uBC0F \uD1B5\uD569 \uAC80\uC99D \uD14C\uC2A4\uD2B8 \uC2A4\uC704\uD2B8 \uC791\uC131 \uBC0F \uC815\uBC00 \uAC80\uC99D \uC900\uBE44");
+    }
+    if (summary.detectedDomains.includes("memory")) {
+      completedSteps.push("\uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uBC0F \uCEE8\uD14D\uC2A4\uD2B8 \uC2A4\uB0C5\uC0F7 \uC544\uD0A4\uD14D\uCC98 \uBC18\uC601");
+      activeInvariants.push("\uBA54\uBAA8\uB9AC \uCFFC\uB9AC \uC2DC 0ms \uC989\uAC01 \uC751\uB2F5 \uBC0F \uBB34\uC190\uC2E4 \uC778\uACFC\uC728 \uBCF4\uC874");
+    }
+    if (summary.detectedDomains.includes("obsidian-lens")) {
+      completedSteps.push("\uC635\uC2DC\uB514\uC5B8 \uB9C8\uD06C\uB2E4\uC6B4 \uBCFC\uD2B8 \uBC0F \uC2DC\uAC01\uC801 \uCE94\uBC84\uC2A4 \uC5F0\uB3D9 \uACC4\uCE35 \uAD6C\uCD95");
+    }
+    if (summary.addedFiles.length > 0) {
+      completedSteps.push(`\uC2E0\uADDC \uC544\uD0A4\uD14D\uCC98 \uD30C\uC77C \uC0DD\uC131 (${summary.addedFiles.length}\uAC1C \uD30C\uC77C: ${summary.addedFiles.slice(0, 3).join(", ")}${summary.addedFiles.length > 3 ? " \uC678" : ""})`);
+    }
+    if (summary.modifiedFiles.length > 0) {
+      completedSteps.push(`\uAE30\uC874 \uBAA8\uB4C8 \uB9AC\uD329\uD130\uB9C1 \uBC0F \uAE30\uB2A5 \uD655\uC7A5 (${summary.modifiedFiles.length}\uAC1C \uD30C\uC77C)`);
+    }
+    if (completedSteps.length === 0) {
+      completedSteps.push("\uC18C\uC2A4 \uCF54\uB4DC \uBCC0\uACBD \uBC0F \uBAA8\uB4C8 \uAD6C\uC870 \uC815\uBE44");
+    }
+    const hasTests = summary.allActiveFiles.some((f) => f.includes("test") || f.endsWith(".test.ts"));
+    if (!hasTests) {
+      pendingTasks.push("\uCD94\uAC00/\uC218\uC815\uB41C \uBAA8\uB4C8\uC5D0 \uB300\uD55C \uD3EC\uAD04\uC801 \uD1B5\uD569 \uD14C\uC2A4\uD2B8 \uC2A4\uC704\uD2B8 \uC791\uC131 \uBC0F \uD68C\uADC0 \uBC29\uC9C0");
+    }
+    pendingTasks.push("Bun \uB7F0\uD0C0\uC784 \uAE30\uBC18 \uBE4C\uB4DC \uAC80\uC99D (`bun run build`) \uBC0F \uBB34\uC624\uB958 \uD655\uC778");
+    pendingTasks.push("\uC804\uC5ED \uCEE8\uD14D\uC2A4\uD2B8 \uC2A4\uB0C5\uC0F7 \uB370\uC774\uD130\uBCA0\uC774\uC2A4 \uB3D9\uAE30\uD654 \uBC0F \uAE30\uC5B5 \uC601\uC18D\uD654");
+    keyDecisions.push("\uD558\uB4DC\uCF54\uB529 \uBC30\uC81C \uBC0F \uD658\uACBD \uBCC0\uC218/\uC124\uC815 \uBAA8\uB4C8 \uC911\uC2EC\uC758 \uC124\uC815 \uC544\uD0A4\uD14D\uCC98 \uC801\uC6A9");
+    keyDecisions.push("SOLID \uB2E8\uC77C \uCC45\uC784 \uC6D0\uCE59(SRP)\uC744 \uC900\uC218\uD55C \uB3C5\uB9BD \uC5D4\uC9C4 \uBD84\uB9AC");
+    if (summary.detectedDomains.includes("testing")) {
+      keyDecisions.push("\uBAA8\uC758(Mock)\uB97C \uC9C0\uC591\uD558\uACE0 \uC2E4\uC81C \uACA9\uB9AC \uD658\uACBD\uC5D0\uC11C\uC758 End-to-End \uB3D9\uC791 \uAC80\uC99D \uC218\uD589");
+    }
+    const primaryDomain = summary.detectedDomains[0] || "core";
+    const autoTitle = customTitle || `[\uC790\uB3D9 \uC5ED\uD569\uC131] ${primaryDomain.toUpperCase()} \uBAA8\uB4C8 \uC544\uD0A4\uD14D\uCC98 \uBCC0\uACBD (${summary.stats.filesChanged || summary.allActiveFiles.length}\uAC1C \uD30C\uC77C \uBC18\uC601)`;
+    const autoGoal = `${summary.detectedDomains.join(", ")} \uC601\uC5ED\uC758 \uAE30\uB2A5\uC744 \uD655\uC7A5\uD558\uACE0 \uBCC0\uACBD \uC0AC\uD56D\uC744 \uBB34\uACB0\uD558\uAC8C \uC815\uD569\uD558\uB294 \uC791\uC5C5`;
+    return {
+      title: autoTitle,
+      goal: autoGoal,
+      completedSteps,
+      pendingTasks,
+      keyDecisions,
+      activeInvariants,
+      suggestedKeywords
+    };
+  }
+  async autoCheckpoint(cwd = process.cwd(), options = {}) {
+    const summary = await this.inspectGitChanges(cwd);
+    const synthesized = this.synthesizeIntent(summary, options.title);
+    const mergedCompletedSteps = [
+      ...synthesized.completedSteps,
+      ...options.extraCompletedSteps || []
+    ];
+    const mergedPendingTasks = [
+      ...synthesized.pendingTasks,
+      ...options.extraPendingTasks || []
+    ];
+    const mergedKeyDecisions = [
+      ...synthesized.keyDecisions,
+      ...options.extraKeyDecisions || []
+    ];
+    const mergedInvariants = [
+      ...synthesized.activeInvariants,
+      ...options.extraInvariants || []
+    ];
+    const saveInput = {
+      title: options.title || synthesized.title,
+      goal: options.goal || synthesized.goal,
+      cwd,
+      activeFiles: summary.allActiveFiles,
+      modifiedFiles: [...summary.modifiedFiles, ...summary.addedFiles],
+      completedSteps: mergedCompletedSteps,
+      pendingTasks: mergedPendingTasks,
+      keyDecisions: mergedKeyDecisions,
+      activeInvariants: mergedInvariants,
+      keywords: synthesized.suggestedKeywords,
+      domain: summary.detectedDomains[0] || "core",
+      autoGit: true,
+      autoResonance: options.autoResonance ?? true,
+      customMeta: {
+        stats: summary.stats,
+        symbols: summary.extractedSymbols,
+        synthesizedAt: new Date().toISOString(),
+        ...options.customMeta
+      }
+    };
+    return this.contextStore.saveCheckpoint(saveInput);
+  }
+}
+
+// memory/causal-lens.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, renameSync as renameSync4 } from "fs";
+import { resolve as resolve4, basename } from "path";
+class CausalObsidianLensEngine {
+  memoryStore;
+  contextStore;
+  graveyardStore;
+  timeSeriesEngine;
+  constructor(memoryStore, contextStore, graveyardStore, timeSeriesEngine) {
+    this.memoryStore = memoryStore || new CausalMemoryStore;
+    this.contextStore = contextStore || new ContextCheckpointStore;
+    this.graveyardStore = graveyardStore || new CausalGraveyardStore;
+    this.timeSeriesEngine = timeSeriesEngine || new CausalTimeSeriesEngine(this.contextStore, this.memoryStore);
+  }
+  async exportToVault(vaultRoot = CAUSAL_MEMORY_CONFIG.DEFAULT_OBSIDIAN_VAULT_PATH) {
+    const startTime = performance.now();
+    try {
+      this.memoryStore.reloadIfNeeded();
+      this.contextStore.reloadIfNeeded();
+      this.graveyardStore.reloadIfNeeded();
+      const mentalRoot = resolve4(vaultRoot, CAUSAL_MEMORY_CONFIG.OBSIDIAN_LENS_SUBDIR);
+      const rulesDir = resolve4(mentalRoot, "Rules");
+      const graveyardDir = resolve4(mentalRoot, "Graveyard");
+      const checkpointsDir = resolve4(mentalRoot, "Checkpoints");
+      mkdirSync5(rulesDir, { recursive: true });
+      mkdirSync5(graveyardDir, { recursive: true });
+      mkdirSync5(checkpointsDir, { recursive: true });
+      const rawDb = this.memoryStore.getRawDatabase();
+      let exportedRules = 0;
+      for (const rule of rawDb.rules) {
+        const ruleTitle = rule.title || rule.name || rule.id;
+        const safeFileName = this.sanitizeFileName(ruleTitle);
+        const filePath = resolve4(rulesDir, `${safeFileName}.md`);
+        const content = this.renderRuleToMarkdown(rule);
+        this.atomicWriteFile(filePath, content);
+        exportedRules++;
+      }
+      const allTraps = this.graveyardStore.listTraps();
+      let exportedGraveyard = 0;
+      for (const trap of allTraps) {
+        const trapTitle = trap.title || trap.failedApproach || trap.id;
+        const safeFileName = this.sanitizeFileName(trapTitle);
+        const filePath = resolve4(graveyardDir, `${safeFileName}.md`);
+        const content = this.renderTrapToMarkdown(trap);
+        this.atomicWriteFile(filePath, content);
+        exportedGraveyard++;
+      }
+      const checkpoints = this.contextStore.listCheckpoints({ limit: 100 });
+      let exportedCheckpoints = 0;
+      for (const cp of checkpoints) {
+        const filePath = resolve4(checkpointsDir, `${cp.id}.md`);
+        const content = this.renderCheckpointToMarkdown(cp);
+        this.atomicWriteFile(filePath, content);
+        exportedCheckpoints++;
+      }
+      const timelinePath = resolve4(mentalRoot, "Timeline.md");
+      const timelineContent = this.renderTimelineMarkdown();
+      this.atomicWriteFile(timelinePath, timelineContent);
+      const canvasPath = resolve4(mentalRoot, "Causal-Architecture.canvas");
+      const canvasDoc = this.generateCanvasDocument(rawDb.rules, rawDb.relations);
+      this.atomicWriteFile(canvasPath, JSON.stringify(canvasDoc, null, 2));
+      const durationMs = Number((performance.now() - startTime).toFixed(2));
+      return {
+        success: true,
+        vaultPath: mentalRoot,
+        exportedRules,
+        exportedGraveyard,
+        exportedCheckpoints,
+        canvasGenerated: true,
+        timelineGenerated: true,
+        durationMs
+      };
+    } catch (err) {
+      const durationMs = Number((performance.now() - startTime).toFixed(2));
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        vaultPath: vaultRoot,
+        exportedRules: 0,
+        exportedGraveyard: 0,
+        exportedCheckpoints: 0,
+        canvasGenerated: false,
+        timelineGenerated: false,
+        durationMs,
+        error: `\uC635\uC2DC\uB514\uC5B8 \uBCFC\uD2B8 \uB0B4\uBCF4\uB0B4\uAE30 \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4: ${message}`
+      };
+    }
+  }
+  async importFromVault(vaultRoot = CAUSAL_MEMORY_CONFIG.DEFAULT_OBSIDIAN_VAULT_PATH) {
+    const startTime = performance.now();
+    try {
+      const mentalRoot = resolve4(vaultRoot, CAUSAL_MEMORY_CONFIG.OBSIDIAN_LENS_SUBDIR);
+      const rulesDir = resolve4(mentalRoot, "Rules");
+      const graveyardDir = resolve4(mentalRoot, "Graveyard");
+      let importedRules = 0;
+      let importedGraveyard = 0;
+      if (existsSync6(rulesDir)) {
+        const ruleFiles = readdirSync2(rulesDir).filter((f) => f.endsWith(".md"));
+        for (const file of ruleFiles) {
+          const filePath = resolve4(rulesDir, file);
+          const rawText = readFileSync5(filePath, "utf-8");
+          const parsed = this.parseRuleMarkdown(rawText, basename(file, ".md"));
+          if (parsed) {
+            this.memoryStore.assertRule(parsed);
+            importedRules++;
+          }
+        }
+      }
+      if (existsSync6(graveyardDir)) {
+        const trapFiles = readdirSync2(graveyardDir).filter((f) => f.endsWith(".md"));
+        for (const file of trapFiles) {
+          const filePath = resolve4(graveyardDir, file);
+          const rawText = readFileSync5(filePath, "utf-8");
+          const parsed = this.parseTrapMarkdown(rawText, basename(file, ".md"));
+          if (parsed) {
+            this.graveyardStore.assertTrap(parsed);
+            importedGraveyard++;
+          }
+        }
+      }
+      const durationMs = Number((performance.now() - startTime).toFixed(2));
+      return {
+        success: true,
+        vaultPath: mentalRoot,
+        importedRules,
+        importedGraveyard,
+        durationMs
+      };
+    } catch (err) {
+      const durationMs = Number((performance.now() - startTime).toFixed(2));
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        vaultPath: vaultRoot,
+        importedRules: 0,
+        importedGraveyard: 0,
+        durationMs,
+        error: `\uC635\uC2DC\uB514\uC5B8 \uBCFC\uD2B8 \uAC00\uC838\uC624\uAE30 \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4: ${message}`
+      };
+    }
+  }
+  async syncWithVault(vaultRoot = CAUSAL_MEMORY_CONFIG.DEFAULT_OBSIDIAN_VAULT_PATH) {
+    const importResult = await this.importFromVault(vaultRoot);
+    const exportResult = await this.exportToVault(vaultRoot);
+    return {
+      success: importResult.success && exportResult.success,
+      exportResult,
+      importResult,
+      syncedAt: new Date().toISOString()
+    };
+  }
+  renderRuleToMarkdown(rule) {
+    const title = rule.title || rule.name || rule.id;
+    const lines = [
+      "---",
+      `id: "${rule.id}"`,
+      `name: "${title.replaceAll('"', "\\\"")}"`,
+      `domain: "${rule.domain}"`,
+      `confidence: ${rule.confidence ?? 1}`,
+      `weight: ${rule.weight ?? 1}`,
+      `updatedAt: "${rule.updatedAt || new Date().toISOString()}"`,
+      "invariants:",
+      ...(rule.invariants || []).map((inv) => `  - "${inv.replaceAll('"', "\\\"")}"`),
+      "tags:",
+      '  - "synapse/causal-rule"',
+      `  - "domain/${rule.domain}"`,
+      "---",
+      "",
+      `# ${title}`,
+      "",
+      `> [!NOTE] \uC778\uACFC\uC728 \uADDC\uCE59 \uBA54\uD0C0\uB370\uC774\uD130`,
+      `> - **\uB3C4\uBA54\uC778**: \`${rule.domain}\``,
+      `> - **\uC2E0\uB8B0\uB3C4**: \`${rule.confidence ?? 1}\` | **\uAC00\uC911\uCE58**: \`${rule.weight ?? 1}\``,
+      `> - **\uCD5C\uC885 \uAC31\uC2E0**: \`${rule.updatedAt || "N/A"}\``,
+      "",
+      "## \uD83D\uDCA1 \uC694\uC57D \uC124\uBA85",
+      rule.description || "\uC0C1\uC138 \uC124\uBA85 \uC5C6\uC74C",
+      "",
+      "## \uD83D\uDEE1\uFE0F \uD544\uC218 \uBD88\uBCC0\uC2DD (Invariants)"
+    ];
+    if (!rule.invariants || rule.invariants.length === 0) {
+      lines.push("- *\uB4F1\uB85D\uB41C \uBD88\uBCC0 \uC870\uAC74 \uC5C6\uC74C*");
+    } else {
+      for (const inv of rule.invariants) {
+        lines.push(`- [x] ${inv}`);
+      }
+    }
+    if (rule.pattern) {
+      lines.push("", "## \uD83D\uDD0D \uB9E4\uCE6D \uD328\uD134", `\`\`\`regex
+${rule.pattern}
+\`\`\``);
+    }
+    return lines.join(`
+`);
+  }
+  renderTrapToMarkdown(trap) {
+    const title = trap.title || trap.failedApproach || trap.id;
+    const severity = trap.severity || "WARNING";
+    const rootCause = trap.rootCause || trap.reason || "\uC0AC\uC720 \uBBF8\uAE30\uC7AC";
+    const counterMeasure = trap.counterMeasure || trap.safeAlternative || "\uC548\uC804\uD55C \uB300\uC548 \uBBF8\uAE30\uC7AC";
+    const avoidFiles = trap.triggerFiles || trap.avoidFiles || [];
+    return [
+      "---",
+      `id: "${trap.id}"`,
+      `title: "${title.replaceAll('"', "\\\"")}"`,
+      `domain: "${trap.domain || trap.environment || "general"}"`,
+      `severity: "${severity}"`,
+      `createdAt: "${trap.createdAt}"`,
+      "tags:",
+      '  - "synapse/anti-pattern"',
+      `  - "severity/${severity.toLowerCase()}"`,
+      "---",
+      "",
+      `# \u26A0\uFE0F \uD568\uC815 \uACBD\uBCF4: ${title}`,
+      "",
+      `> [!WARNING] \uC704\uD5D8\uB3C4: **${severity}** (\uB3C4\uBA54\uC778: \`${trap.domain || "general"}\`)`,
+      `> \uC774 \uD328\uD134\uC740 \uC774\uC804\uC5D0 \uC2E4\uD328\uB97C \uC720\uBC1C\uD588\uB358 \uC548\uD2F0\uD328\uD134\uC785\uB2C8\uB2E4. \uB3D9\uC77C\uD55C \uC2DC\uB3C4\uB97C \uCC28\uB2E8\uD574\uC57C \uD569\uB2C8\uB2E4.`,
+      "",
+      "## \uD83D\uDCA5 \uC2E4\uD328 \uC6D0\uC778 (Root Cause)",
+      rootCause,
+      "",
+      "## \u2705 \uC548\uC804\uD55C \uB300\uC548 (Safe Solution)",
+      counterMeasure,
+      "",
+      "## \uD83E\uDEA4 \uAC10\uC9C0 \uD30C\uC77C \uD328\uD134",
+      ...avoidFiles.length > 0 ? avoidFiles.map((f) => `- \`${f}\``) : ["- *\uC804\uC5ED \uAC10\uC9C0*"]
+    ].join(`
+`);
+  }
+  renderCheckpointToMarkdown(cp) {
+    return [
+      "---",
+      `id: "${cp.id}"`,
+      `title: "${cp.title.replaceAll('"', "\\\"")}"`,
+      `createdAt: "${cp.createdAt}"`,
+      `cwd: "${cp.cwd.replaceAll("\\", "/")}"`,
+      `branch: "${cp.gitBranch || "unknown"}"`,
+      `commit: "${cp.gitCommit || "unknown"}"`,
+      "tags:",
+      '  - "synapse/checkpoint"',
+      "---",
+      "",
+      `# \uD83D\uDCCD \uCCB4\uD06C\uD3EC\uC778\uD2B8: ${cp.title}`,
+      "",
+      `> [!INFO] \uC2A4\uB0C5\uC0F7 \uC815\uBCF4`,
+      `> - **ID**: \`${cp.id}\``,
+      `> - **\uAE30\uB85D \uC2DC\uAC01**: \`${cp.createdAt}\``,
+      `> - **Git \uBE0C\uB79C\uCE58**: \`${cp.gitBranch || "N/A"}\` (\`${cp.gitCommit || "N/A"}\`)`,
+      `> - **\uC791\uC5C5 \uB514\uB809\uD130\uB9AC**: \`${cp.cwd}\``,
+      "",
+      "## \uD83C\uDFAF \uC138\uC158 \uBAA9\uD45C",
+      cp.goal,
+      "",
+      "## \u2705 \uC644\uB8CC\uB41C \uB2E8\uACC4 (Completed Steps)",
+      ...cp.completedSteps.map((s) => `- [x] ${s}`),
+      "",
+      "## \u23F3 \uB300\uAE30 \uACFC\uC81C (Pending Tasks)",
+      ...cp.pendingTasks.map((t) => `- [ ] ${t}`),
+      "",
+      "## \uD83E\uDDE0 \uD575\uC2EC \uACB0\uC815 \uC0AC\uD56D (Key Decisions)",
+      ...cp.keyDecisions.map((d) => `- ${d}`),
+      "",
+      "## \uD83D\uDEE1\uFE0F \uD65C\uC131 \uBD88\uBCC0\uC2DD (Active Invariants)",
+      ...cp.activeInvariants.map((inv) => `- \uD83D\uDD12 ${inv}`),
+      "",
+      "## \uD83D\uDCC1 \uC218\uC815\uB41C \uD30C\uC77C \uBAA9\uB85D",
+      ...cp.modifiedFiles.map((f) => `- \`${f}\``)
+    ].join(`
+`);
+  }
+  renderTimelineMarkdown() {
+    const events = this.timeSeriesEngine.generateTimeline(50);
+    const lines = [
+      "---",
+      'title: "Synapse Causal Memory Timeline"',
+      "tags:",
+      '  - "synapse/timeline"',
+      "---",
+      "",
+      "# \u23F3 \uC2DC\uB0C5\uC2A4 \uC778\uACFC\uC728 \uD0C0\uC784\uB77C\uC778",
+      "",
+      `> \uCD1D **${events.length}**\uAC1C\uC758 \uC774\uBCA4\uD2B8\uAC00 \uBCF4\uC874\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.`,
+      "",
+      "## \uD83D\uDCCA \uD0C0\uC784\uB77C\uC778 \uC2DC\uAC01\uD654 (Mermaid)",
+      "```mermaid",
+      "timeline",
+      "    title \uC138\uC158 \uC9C4\uD654 \uD0C0\uC784\uB77C\uC778"
+    ];
+    for (const ev of events.slice(-10)) {
+      const datePart = ev.timestamp ? ev.timestamp.slice(0, 10) : "2026-11-09";
+      const safeTitle = (ev.title || "\uC774\uBCA4\uD2B8").replaceAll('"', "").replaceAll(":", " -");
+      lines.push(`    ${datePart} : ${safeTitle}`);
+    }
+    lines.push("```", "", "## \uD83D\uDCCB \uC774\uBCA4\uD2B8 \uC774\uB825");
+    for (const ev of events) {
+      const targetLink = ev.checkpointId ? `./Checkpoints/${ev.checkpointId}.md` : "#";
+      lines.push(`### [${ev.title}](${targetLink})`);
+      lines.push(`- **\uBC1C\uC0DD \uC77C\uC2DC**: \`${ev.timestamp}\``);
+      lines.push(`- **\uC694\uC57D**: ${ev.summary}`);
+      lines.push("");
+    }
+    return lines.join(`
+`);
+  }
+  generateCanvasDocument(rules, relations) {
+    const nodes = [];
+    const edges = [];
+    const ruleIdToNodeId = new Map;
+    const nodeWidth = 320;
+    const nodeHeight = 160;
+    const spacingX = 400;
+    const spacingY = 220;
+    const cols = 4;
+    rules.forEach((rule, idx) => {
+      const title = rule.title || rule.name || rule.id;
+      const col = idx % cols;
+      const row = Math.floor(idx / cols);
+      const nodeId = `rule_node_${idx}`;
+      ruleIdToNodeId.set(title.toLowerCase(), nodeId);
+      ruleIdToNodeId.set(rule.id.toLowerCase(), nodeId);
+      const summaryInvariants = rule.invariants && rule.invariants.length > 0 ? rule.invariants.slice(0, 2).map((i) => `\u2022 ${i}`).join(`
+`) : "\u2022 \uBD88\uBCC0\uC2DD \uC5C6\uC74C";
+      const markdownText = [
+        `### \uD83D\uDCCC [[Rules/${this.sanitizeFileName(title)}|${title}]]`,
+        `**\uB3C4\uBA54\uC778**: \`${rule.domain}\` | **\uAC00\uC911\uCE58**: \`${rule.weight ?? 1}\``,
+        "",
+        summaryInvariants
+      ].join(`
+`);
+      nodes.push({
+        id: nodeId,
+        x: col * spacingX,
+        y: row * spacingY,
+        width: nodeWidth,
+        height: nodeHeight,
+        type: "text",
+        text: markdownText,
+        color: this.getColorForDomain(rule.domain)
+      });
+    });
+    let edgeCounter = 0;
+    for (const rel of relations) {
+      const fromNodeId = ruleIdToNodeId.get(rel.from.toLowerCase());
+      const toNodeId = ruleIdToNodeId.get(rel.to.toLowerCase());
+      if (fromNodeId && toNodeId) {
+        edges.push({
+          id: `edge_${edgeCounter++}`,
+          fromNode: fromNodeId,
+          fromSide: "right",
+          toNode: toNodeId,
+          toSide: "left",
+          label: rel.relation,
+          color: rel.relation === "blocks" ? "1" : "4"
+        });
+      }
+    }
+    return { nodes, edges };
+  }
+  getColorForDomain(domain) {
+    switch (domain.toLowerCase()) {
+      case "security":
+      case "guard":
+        return "1";
+      case "compiler":
+        return "2";
+      case "memory":
+      case "database":
+        return "4";
+      case "runner":
+      case "bus":
+        return "5";
+      case "studio":
+      case "frontend":
+        return "6";
+      default:
+        return "3";
+    }
+  }
+  parseRuleMarkdown(raw, defaultName) {
+    try {
+      const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+      if (!fmMatch)
+        return null;
+      const fmText = fmMatch[1];
+      const idMatch = fmText.match(/id:\s*"([^"]+)"/);
+      const nameMatch = fmText.match(/name:\s*"([^"]+)"/);
+      const domainMatch = fmText.match(/domain:\s*"([^"]+)"/);
+      const confMatch = fmText.match(/confidence:\s*([0-9.]+)/);
+      const weightMatch = fmText.match(/weight:\s*([0-9.]+)/);
+      const invariants = [];
+      const invSection = fmText.match(/invariants:\r?\n((?:\s*-\s*"[^"]+"\r?\n?)+)/);
+      if (invSection) {
+        const itemMatches = invSection[1].matchAll(/-\s*"([^"]+)"/g);
+        for (const m of itemMatches) {
+          invariants.push(m[1].replaceAll("\\\"", '"'));
+        }
+      }
+      const body = raw.slice(fmMatch[0].length).trim();
+      const descMatch = body.match(/## \uD83D\uDCA1 \uC694\uC57D \uC124\uBA85\r?\n([\s\S]*?)(?:\r?\n##|$)/);
+      const description = descMatch ? descMatch[1].trim() : "";
+      const ruleTitle = nameMatch ? nameMatch[1] : defaultName;
+      return {
+        id: idMatch ? idMatch[1] : `rule_${Date.now()}`,
+        title: ruleTitle,
+        name: ruleTitle,
+        domain: domainMatch ? domainMatch[1] : "general",
+        confidence: confMatch ? parseFloat(confMatch[1]) : 1,
+        weight: weightMatch ? parseFloat(weightMatch[1]) : 1,
+        triggers: {
+          files: [],
+          keywords: [ruleTitle.toLowerCase()]
+        },
+        invariants: invariants || [],
+        actions: [],
+        context: description ? [description] : [],
+        description,
+        updatedAt: new Date().toISOString()
+      };
+    } catch {
+      return null;
+    }
+  }
+  parseTrapMarkdown(raw, defaultPattern) {
+    try {
+      const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+      if (!fmMatch)
+        return null;
+      const fmText = fmMatch[1];
+      const idMatch = fmText.match(/id:\s*"([^"]+)"/);
+      const titleMatch = fmText.match(/(?:title|trapPattern):\s*"([^"]+)"/);
+      const domainMatch = fmText.match(/domain:\s*"([^"]+)"/);
+      const sevMatch = fmText.match(/severity:\s*"([^"]+)"/);
+      const body = raw.slice(fmMatch[0].length).trim();
+      const reasonMatch = body.match(/## \uD83D\uDCA5 \uC2E4\uD328 \uC6D0\uC778 \(Root Cause\)\r?\n([\s\S]*?)(?:\r?\n##|$)/);
+      const altMatch = body.match(/## \u2705 \uC548\uC804\uD55C \uB300\uC548 \(Safe Solution\)\r?\n([\s\S]*?)(?:\r?\n##|$)/);
+      const trapTitle = titleMatch ? titleMatch[1] : defaultPattern;
+      const rootCause = reasonMatch ? reasonMatch[1].trim() : "\uC0AC\uC720 \uBBF8\uAE30\uC7AC";
+      const counterMeasure = altMatch ? altMatch[1].trim() : "\uC548\uC804\uD55C \uB300\uC548 \uBBF8\uAE30\uC7AC";
+      return {
+        id: idMatch ? idMatch[1] : `trap_${Date.now()}`,
+        title: trapTitle,
+        failedApproach: trapTitle,
+        trapPattern: trapTitle,
+        domain: domainMatch ? domainMatch[1] : "general",
+        environment: domainMatch ? domainMatch[1] : "general",
+        severity: sevMatch ? sevMatch[1] : "MEDIUM",
+        rootCause,
+        reason: rootCause,
+        counterMeasure,
+        safeAlternative: counterMeasure,
+        triggerKeywords: [trapTitle],
+        createdAt: new Date().toISOString()
+      };
+    } catch {
+      return null;
+    }
+  }
+  atomicWriteFile(filePath, content) {
+    const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
+    writeFileSync5(tempPath, content, "utf-8");
+    renameSync4(tempPath, filePath);
+  }
+  sanitizeFileName(name) {
+    return name.replace(/\.\.+/g, "_").replace(/[\\/:*?"<>|\0]/g, "_").replace(/\s+/g, "_").replace(/^_+|_+$/g, "").slice(0, 80) || "unnamed";
+  }
+}
+
+// memory/causal-server.ts
+var CAUSAL_MCP_TOOLS = [
+  {
+    name: "query_causal_memory",
+    description: "\uC791\uC5C5 \uCEE8\uD14D\uC2A4\uD2B8(\uC218\uC815\uB41C \uD30C\uC77C, \uD0A4\uC6CC\uB4DC, \uBA85\uB839\uC5B4, \uB3C4\uBA54\uC778)\uC5D0 \uB9E4\uCE6D\uB418\uB294 \uC778\uACFC\uC728 \uC9C0\uC2DD\uACFC \uBD88\uBCC0 \uADDC\uCE59\uB9CC 0ms \uCD08\uACBD\uB7C9\uC73C\uB85C \uACF5\uBA85 \uCFFC\uB9AC\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "\uAC10\uC9C0\uD560 \uB300\uC0C1 \uD30C\uC77C \uACBD\uB85C \uBAA9\uB85D (\uC0DD\uB7B5 \uC2DC Git \uBCC0\uACBD \uD30C\uC77C \uC790\uB3D9 \uAC10\uC9C0)"
+        },
+        keywords: {
+          type: "array",
+          items: { type: "string" },
+          description: "\uAC80\uC0C9\uD560 \uB3C4\uBA54\uC778/\uC791\uC5C5 \uD0A4\uC6CC\uB4DC \uBAA9\uB85D"
+        },
+        command: {
+          type: "string",
+          description: "\uC5F0\uB3D9 \uBA85\uB839\uC5B4 (\uC608: check, build, release, sign)"
+        },
+        domain: {
+          type: "string",
+          description: "\uD2B9\uC815 \uB3C4\uBA54\uC778 \uD544\uD130"
+        },
+        compact: {
+          type: "boolean",
+          description: "\uCD08\uC18C\uD615 JSON \uD3EC\uB9F7 \uBC18\uD658 \uC5EC\uBD80"
+        }
+      }
+    }
+  },
+  {
+    name: "assert_causal_rule",
+    description: "\uC2E0\uADDC \uC778\uACFC\uC728 \uADDC\uCE59(\uC6D0\uC778 \uD2B8\uB9AC\uAC70 \u2794 \uBD88\uBCC0 \uACC4\uC57D \u2794 \uC2E4\uD589 \uC9C0\uCE68)\uC744 \uBA54\uBAA8\uB9AC\uC5D0 \uB4F1\uB85D\uD558\uAC70\uB098 \uAC31\uC2E0\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      required: ["id", "domain", "title", "triggers"],
+      properties: {
+        id: { type: "string" },
+        domain: { type: "string" },
+        title: { type: "string" },
+        triggers: { type: "object" },
+        invariants: { type: "array", items: { type: "string" } },
+        actions: { type: "array", items: { type: "string" } },
+        context: { type: "array", items: { type: "string" } }
+      }
+    }
+  },
+  {
+    name: "audit_causal_memory",
+    description: "\uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uB370\uC774\uD130\uBCA0\uC774\uC2A4\uC758 \uBB34\uACB0\uC131, \uB3C4\uBA54\uC778 \uBD84\uD3EC, \uD1A0\uD070 \uC808\uAC10 \uC0C1\uD0DC\uB97C \uAC10\uC0AC(Audit)\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "read_graph",
+    description: "Read the active causal resonance knowledge graph (automatically filters out unrelated noise for 90%+ token savings)",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "search_nodes",
+    description: "Search for causal rules and nodes in the knowledge graph based on a query and traverse causal relations",
+    inputSchema: {
+      type: "object",
+      required: ["query"],
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query to match against rule titles, domains, triggers, and invariants"
+        }
+      }
+    }
+  },
+  {
+    name: "open_nodes",
+    description: "Open specific causal rule nodes in the knowledge graph by their names or IDs",
+    inputSchema: {
+      type: "object",
+      required: ["names"],
+      properties: {
+        names: {
+          type: "array",
+          items: { type: "string" },
+          description: "An array of entity names or rule IDs to retrieve"
+        }
+      }
+    }
+  },
+  {
+    name: "create_entities",
+    description: "Create multiple new entities (automatically converted into structured Causal Rules)",
+    inputSchema: {
+      type: "object",
+      required: ["entities"],
+      properties: {
+        entities: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["name", "entityType", "observations"],
+            properties: {
+              name: { type: "string" },
+              entityType: { type: "string" },
+              observations: { type: "array", items: { type: "string" } }
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    name: "create_relations",
+    description: "Create multiple new causal relations between nodes in the knowledge graph",
+    inputSchema: {
+      type: "object",
+      required: ["relations"],
+      properties: {
+        relations: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["from", "to", "relationType"],
+            properties: {
+              from: { type: "string" },
+              to: { type: "string" },
+              relationType: { type: "string" }
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    name: "add_observations",
+    description: "Add new invariants, actions, or context observations to existing causal rules",
+    inputSchema: {
+      type: "object",
+      required: ["observations"],
+      properties: {
+        observations: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["entityName", "contents"],
+            properties: {
+              entityName: { type: "string" },
+              contents: { type: "array", items: { type: "string" } }
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    name: "delete_entities",
+    description: "Delete multiple entities/rules and their associated causal relations",
+    inputSchema: {
+      type: "object",
+      required: ["entityNames"],
+      properties: {
+        entityNames: {
+          type: "array",
+          items: { type: "string" }
+        }
+      }
+    }
+  },
+  {
+    name: "delete_observations",
+    description: "Delete specific observations from entities/rules in the causal memory",
+    inputSchema: {
+      type: "object",
+      required: ["deletions"],
+      properties: {
+        deletions: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["entityName", "observations"],
+            properties: {
+              entityName: { type: "string" },
+              observations: { type: "array", items: { type: "string" } }
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    name: "delete_relations",
+    description: "Delete multiple causal relations from the knowledge graph",
+    inputSchema: {
+      type: "object",
+      required: ["relations"],
+      properties: {
+        relations: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["from", "to", "relationType"],
+            properties: {
+              from: { type: "string" },
+              to: { type: "string" },
+              relationType: { type: "string" }
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    name: "save_context_checkpoint",
+    description: "\uD604\uC7AC \uC791\uC5C5 \uC138\uC158\uC758 \uD575\uC2EC \uCEE8\uD14D\uC2A4\uD2B8(\uBAA9\uD45C, \uC644\uB8CC \uB2E8\uACC4, \uB2E4\uC74C \uD560 \uC77C, \uD575\uC2EC \uC124\uACC4 \uACB0\uC815, \uD65C\uC131 \uD30C\uC77C, \uC544\uD2F0\uD329\uD2B8)\uB97C \uCD08\uACBD\uB7C9 \uC2A4\uB0C5\uC0F7\uC73C\uB85C \uC800\uC7A5\uD558\uC5EC \uC0C8 \uCC44\uD305\uCC3D\uC5D0\uC11C\uB3C4 \uAE30\uC5B5 \uC190\uC2E4 \uC5C6\uC774 0ms \uBCF5\uC6D0\uD560 \uC218 \uC788\uAC8C \uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      required: ["title"],
+      properties: {
+        id: { type: "string", description: "\uACE0\uC720 \uCCB4\uD06C\uD3EC\uC778\uD2B8 ID (\uC0DD\uB7B5 \uC2DC \uC790\uB3D9 \uC0DD\uC131)" },
+        sessionId: { type: "string", description: "\uD504\uB85C\uC81D\uD2B8 \uB610\uB294 \uC138\uC158 \uC2DD\uBCC4\uC790 (\uC608: synapse-kit)" },
+        title: { type: "string", description: "\uD604\uC7AC \uCEE8\uD14D\uC2A4\uD2B8 \uC2A4\uB0C5\uC0F7 \uC694\uC57D \uC81C\uBAA9" },
+        goal: { type: "string", description: "\uD604\uC7AC \uB2EC\uC131 \uC911\uC778 \uD575\uC2EC \uBAA9\uD45C" },
+        completedSteps: {
+          type: "array",
+          items: { type: "string" },
+          description: "\uC774\uBC88 \uC138\uC158\uAE4C\uC9C0 \uC644\uB8CC\uB41C \uD575\uC2EC \uC791\uC5C5 \uBAA9\uB85D"
+        },
+        pendingTasks: {
+          type: "array",
+          items: { type: "string" },
+          description: "\uB2E4\uC74C \uCC44\uD305/\uC138\uC158\uC5D0\uC11C \uBC14\uB85C \uC774\uC5B4\uC11C \uC9C4\uD589\uD560 \uD560 \uC77C \uBAA9\uB85D"
+        },
+        keyDecisions: {
+          type: "array",
+          items: { type: "string" },
+          description: "\uD575\uC2EC \uC124\uACC4 \uACB0\uC815 \uBC0F \uC544\uD0A4\uD14D\uCC98 \uC8FC\uC758\uC0AC\uD56D"
+        },
+        activeFiles: {
+          type: "array",
+          items: { type: "string" },
+          description: "\uC9D1\uC911 \uC791\uC5C5 \uC911\uC778 \uD30C\uC77C \uACBD\uB85C \uBAA9\uB85D"
+        },
+        artifacts: {
+          type: "array",
+          items: { type: "string" },
+          description: "\uAD00\uB828 \uC544\uD2F0\uD329\uD2B8 \uB610\uB294 \uB9C8\uC2A4\uD130 \uC124\uACC4 \uBB38\uC11C \uACBD\uB85C \uBAA9\uB85D"
+        },
+        cwd: { type: "string", description: "\uC791\uC5C5 \uB514\uB809\uD130\uB9AC \uACBD\uB85C" }
+      }
+    }
+  },
+  {
+    name: "load_context_checkpoint",
+    description: "\uC800\uC7A5\uB41C \uCEE8\uD14D\uC2A4\uD2B8 \uCCB4\uD06C\uD3EC\uC778\uD2B8 \uC2A4\uB0C5\uC0F7(\uCD5C\uC2E0 \uB610\uB294 \uD2B9\uC815 ID/\uC138\uC158)\uC744 0ms \uB9CC\uC5D0 \uBCF5\uC6D0\uD558\uC5EC \uC0C8 \uCC44\uD305\uCC3D\uC5D0\uC11C \uC774\uC804 \uC791\uC5C5\uC744 \uC989\uC2DC \uC774\uC5B4\uAC11\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "\uBCF5\uC6D0\uD560 \uCCB4\uD06C\uD3EC\uC778\uD2B8 ID, \uC81C\uBAA9 \uD0A4\uC6CC\uB4DC, \uB610\uB294 'latest' (\uAE30\uBCF8\uAC12: 'latest')"
+        },
+        sessionId: {
+          type: "string",
+          description: "\uD2B9\uC815 \uC138\uC158/\uD504\uB85C\uC81D\uD2B8\uC758 \uCD5C\uC2E0 \uC2A4\uB0C5\uC0F7\uB9CC \uD544\uD130\uB9C1\uD560 \uACBD\uC6B0 \uC9C0\uC815"
+        },
+        compact: {
+          type: "boolean",
+          description: "\uCD08\uC18C\uD615 JSON \uD3EC\uB9F7\uC73C\uB85C \uBC18\uD658\uD560\uC9C0 \uC5EC\uBD80"
+        }
+      }
+    }
+  },
+  {
+    name: "list_context_checkpoints",
+    description: "\uC800\uC7A5\uB41C \uBAA8\uB4E0 \uC791\uC5C5 \uCEE8\uD14D\uC2A4\uD2B8 \uC2A4\uB0C5\uC0F7(Checkpoint) \uBAA9\uB85D\uC744 \uCD5C\uC2E0\uC21C\uC73C\uB85C \uC870\uD68C\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "\uD2B9\uC815 \uC138\uC158/\uD504\uB85C\uC81D\uD2B8 \uD544\uD130" },
+        limit: { type: "number", description: "\uC870\uD68C\uD560 \uCD5C\uB300 \uAC1C\uC218 (\uAE30\uBCF8\uAC12: 20)" }
+      }
+    }
+  },
+  {
+    name: "time_travel_causal_memory",
+    description: "\uC778\uACFC\uC728 \uC2DC\uACC4\uC5F4(Time-Series) \uC5D4\uC9C4\uC744 \uD1B5\uD574 \uC2DC\uAC04 \uAC10\uC1E0 \uAC00\uC911\uCE58 \uACC4\uC0B0, \uCCB4\uD06C\uD3EC\uC778\uD2B8 \uAC04 \uBCC0\uACBD diff \uBD84\uC11D, \uD2B9\uC815 \uACFC\uAC70 \uC2DC\uC810\uC73C\uB85C\uC758 \uB9AC\uC640\uC778\uB4DC, \uC138\uC158 \uD0C0\uC784\uB77C\uC778\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: {
+          type: "string",
+          enum: ["diff", "rewind", "timeline", "decay"],
+          description: "\uC218\uD589\uD560 \uC2DC\uACC4\uC5F4 \uB3D9\uC791 (diff: \uBE44\uAD50, rewind: \uB418\uB3CC\uB9AC\uAE30, timeline: \uD0C0\uC784\uB77C\uC778, decay: \uAC10\uC1E0 \uACC4\uC0B0)"
+        },
+        fromId: { type: "string", description: "\uBE44\uAD50 \uAE30\uC900 \uC2DC\uC791 \uCCB4\uD06C\uD3EC\uC778\uD2B8 ID (diff \uC804\uC6A9)" },
+        toId: { type: "string", description: "\uBE44\uAD50 \uB300\uC0C1 \uBAA9\uD45C \uCCB4\uD06C\uD3EC\uC778\uD2B8 ID (diff \uC804\uC6A9)" },
+        targetId: { type: "string", description: "\uB9AC\uC640\uC778\uB4DC \uB300\uC0C1 \uCCB4\uD06C\uD3EC\uC778\uD2B8 ID (rewind \uC804\uC6A9)" },
+        limit: { type: "number", description: "\uD0C0\uC784\uB77C\uC778 \uC870\uD68C \uAC1C\uC218" }
+      }
+    }
+  },
+  {
+    name: "scan_causal_graveyard",
+    description: "\uBD80\uC815\uC801 \uAE30\uC5B5 / \uC548\uD2F0\uD328\uD134 \uD568\uC815(Graveyard)\uC744 \uC2E4\uC2DC\uAC04\uC73C\uB85C \uC2A4\uCE94\uD558\uC5EC \uC2E4\uD328\uB97C \uC720\uBC1C\uD588\uB358 \uC811\uADFC\uBC95\uC778\uC9C0 \uC120\uC81C \uAC80\uC99D\uD558\uAC70\uB098, \uC0C8\uB85C\uC6B4 \uC2E4\uD328 \uAC00\uC124\uC744 \uB4F1\uB85D\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: {
+          type: "string",
+          enum: ["scan", "assert", "list"],
+          description: "\uB3D9\uC791 (scan: \uD568\uC815 \uAC80\uC0AC, assert: \uC2E4\uD328 \uAC00\uC124 \uB4F1\uB85D, list: \uC804\uCCB4 \uBAA9\uB85D)"
+        },
+        files: { type: "array", items: { type: "string" }, description: "\uC218\uC815 \uC608\uC815 \uD30C\uC77C \uBAA9\uB85D (scan\uC6A9)" },
+        keywords: { type: "array", items: { type: "string" }, description: "\uC758\uB3C4/\uC811\uADFC\uBC95 \uD0A4\uC6CC\uB4DC (scan\uC6A9)" },
+        trapPattern: { type: "string", description: "\uC2E4\uD328 \uC720\uBC1C \uD328\uD134 \uC774\uB984 (assert\uC6A9)" },
+        domain: { type: "string", description: "\uB3C4\uBA54\uC778 (assert\uC6A9)" },
+        reason: { type: "string", description: "\uC2E4\uD328 \uC6D0\uC778 (assert\uC6A9)" },
+        safeAlternative: { type: "string", description: "\uC548\uC804\uD55C \uB300\uC548 (assert\uC6A9)" },
+        severity: { type: "string", enum: ["CRITICAL", "HIGH", "MEDIUM", "LOW"], description: "\uC704\uD5D8\uB3C4" },
+        avoidFiles: { type: "array", items: { type: "string" }, description: "\uAE08\uC9C0 \uD30C\uC77C \uD328\uD134" }
+      }
+    }
+  },
+  {
+    name: "branch_causal_context",
+    description: "\uC791\uC5C5 \uB9E5\uB77D\uC744 \uB3C5\uB9BD\uB41C \uBE0C\uB79C\uCE58(Mental Fork)\uB85C \uBD84\uAE30\uD558\uAC70\uB098, \uAC80\uC99D \uD6C4 \uBA54\uC778\uC5D0 \uBCD1\uD569(Merge)\uD558\uACE0, \uC2E4\uD328\uD55C \uC2E4\uD5D8\uC740 \uD3D0\uAE30(Abandon)\uD558\uC5EC Graveyard\uC5D0 \uC548\uD2F0\uD328\uD134\uC73C\uB85C \uC790\uB3D9 \uC774\uAD00\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "create", "switch", "merge", "abandon"],
+          description: "\uBE0C\uB79C\uCE58 \uB3D9\uC791 (list: \uBAA9\uB85D, create: \uC0DD\uC131, switch: \uC804\uD658, merge: \uBCD1\uD569, abandon: \uD3D0\uAE30 \uBC0F \uD568\uC815 \uB4F1\uB85D)"
+        },
+        name: { type: "string", description: "\uBE0C\uB79C\uCE58 \uC774\uB984" },
+        fromBranch: { type: "string", description: "\uBD84\uAE30 \uAE30\uC900 \uBD80\uBAA8 \uBE0C\uB79C\uCE58 (create\uC6A9)" },
+        targetBranch: { type: "string", description: "\uBCD1\uD569 \uB300\uC0C1 \uBE0C\uB79C\uCE58 (merge\uC6A9)" },
+        failureReason: { type: "string", description: "\uD3D0\uAE30 \uC0AC\uC720 (abandon\uC6A9)" },
+        safeAlternative: { type: "string", description: "\uC548\uC804\uD55C \uB300\uC548 (abandon\uC6A9)" }
+      }
+    }
+  },
+  {
+    name: "predict_blast_radius",
+    description: "\uC218\uC815 \uB300\uC0C1 \uD30C\uC77C\uB4E4\uC744 \uAE30\uBC18\uC73C\uB85C \uC778\uACFC \uADF8\uB798\uD504\uC758 2~3\uB2E8\uACC4 \uC5F0\uC1C4 \uD30C\uAE09 \uC601\uD5A5(Blast Radius)\uACFC \uC704\uD5D8\uB3C4(0~100)\uB97C \uC0B0\uCD9C\uD558\uACE0, \uC704\uBC18 \uBC29\uC9C0\uB97C \uC704\uD574 \uAD00\uB828 \uBD88\uBCC0\uC2DD\uB4E4\uC744 \uC0AC\uC804 \uD398\uCE58(prefetch)\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      required: ["files"],
+      properties: {
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "\uC218\uC815 \uB300\uC0C1 \uD30C\uC77C \uBAA9\uB85D"
+        },
+        maxHops: {
+          type: "number",
+          description: "\uCD5C\uB300 \uD30C\uAE09 \uC804\uD30C \uB2E8\uACC4 (\uAE30\uBCF8\uAC12: 3)"
+        }
+      }
+    }
+  },
+  {
+    name: "synthesize_git_checkpoint",
+    description: "Git \uC0C1\uD0DC \uBC0F diff\uB97C \uBD84\uC11D\uD558\uC5EC \uC791\uC5C5\uC790\uC758 \uC758\uB3C4(Goal, Completed Steps, Pending Tasks)\uB97C \uC790\uB3D9 \uC5ED\uD569\uC131(Reverse Synthesis)\uD558\uACE0 \uC6D0\uD074\uB9AD \uCCB4\uD06C\uD3EC\uC778\uD2B8\uB97C \uC800\uC7A5\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cwd: { type: "string", description: "\uC791\uC5C5 \uB514\uB809\uD130\uB9AC \uACBD\uB85C" },
+        title: { type: "string", description: "\uC0AC\uC6A9\uC790 \uC9C0\uC815 \uC81C\uBAA9 (\uC0DD\uB7B5 \uC2DC \uC790\uB3D9 \uC0DD\uC131)" },
+        autoCheckpoint: { type: "boolean", description: "\uBD84\uC11D \uD6C4 \uCCB4\uD06C\uD3EC\uC778\uD2B8 \uC989\uC2DC \uC800\uC7A5 \uC5EC\uBD80 (\uAE30\uBCF8: true)" }
+      }
+    }
+  },
+  {
+    name: "sync_obsidian_lens",
+    description: "\uC635\uC2DC\uB514\uC5B8(Obsidian) \uBCFC\uD2B8\uC640 \uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC(\uADDC\uCE59, \uD568\uC815, \uC2A4\uB0C5\uC0F7, \uD0C0\uC784\uB77C\uC778, \uCE94\uBC84\uC2A4 \uB2E4\uC774\uC5B4\uADF8\uB7A8)\uB97C \uC644\uBCBD\uD558\uAC8C \uC591\uBC29\uD5A5 \uB3D9\uAE30\uD654(Sync)\uD569\uB2C8\uB2E4.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["export", "import", "sync"],
+          description: "\uB3D9\uC791 (export: \uB9C8\uD06C\uB2E4\uC6B4/\uCE94\uBC84\uC2A4 \uB0B4\uBCF4\uB0B4\uAE30, import: \uB9C8\uD06C\uB2E4\uC6B4 \uC77D\uC5B4\uC624\uAE30, sync: \uC591\uBC29\uD5A5 \uB3D9\uAE30\uD654)"
+        },
+        vaultPath: {
+          type: "string",
+          description: "\uC635\uC2DC\uB514\uC5B8 \uBCFC\uD2B8 \uB8E8\uD2B8 \uACBD\uB85C (\uC0DD\uB7B5 \uC2DC \uAE30\uBCF8 \uD658\uACBD\uBCC0\uC218/OS \uACBD\uB85C \uC0AC\uC6A9)"
+        }
+      }
+    }
+  }
+];
+async function handleMcpJsonRpcRequest(rpc, store, dbPath, contextDbPath) {
+  const { id, method, params } = rpc;
+  const contextStore = new ContextCheckpointStore(contextDbPath, dbPath);
+  if (method.startsWith("notifications/")) {
+    return null;
+  }
+  if (method === "initialize") {
+    return {
+      jsonrpc: "2.0",
+      id: id ?? null,
+      result: {
+        protocolVersion: params?.protocolVersion || CAUSAL_MEMORY_CONFIG.MCP_PROTOCOL_VERSION,
+        capabilities: {
+          tools: {}
+        },
+        serverInfo: {
+          name: CAUSAL_MEMORY_CONFIG.MCP_SERVER_NAME,
+          version: CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION
+        }
+      }
+    };
+  }
+  if (method === "ping") {
+    return {
+      jsonrpc: "2.0",
+      id: id ?? null,
+      result: {}
+    };
+  }
+  if (method === "tools/list") {
+    return {
+      jsonrpc: "2.0",
+      id: id ?? null,
+      result: {
+        tools: CAUSAL_MCP_TOOLS
+      }
+    };
+  }
+  if (method === "tools/call") {
+    store.reloadIfNeeded();
+    contextStore.reloadIfNeeded();
+    const toolName = params?.name;
+    const args = params?.arguments || {};
+    try {
+      let payloadText = "";
+      switch (toolName) {
+        case "query_causal_memory": {
+          let files = Array.isArray(args.files) ? args.files : [];
+          if (files.length === 0 && args.autoGit !== false) {
+            files = await detectModifiedFiles();
+          }
+          const res = store.queryResonance({
+            files,
+            keywords: args.keywords,
+            command: args.command,
+            domain: args.domain,
+            propagateRelations: args.propagateRelations,
+            maxHops: args.maxHops
+          });
+          payloadText = formatResonanceForAgent(res, Boolean(args.compact));
+          const latestCtx = contextStore.getLatestCheckpoint(typeof args.sessionId === "string" ? args.sessionId : undefined);
+          if (latestCtx && !args.compact && args.includeContext !== false) {
+            payloadText += `
+
+` + ContextCheckpointStore.formatForAgentResume(latestCtx, false);
+          }
+          break;
+        }
+        case "assert_causal_rule": {
+          store.assertRule(args);
+          payloadText = JSON.stringify({
+            ok: true,
+            message: `\uC778\uACFC\uC728 \uADDC\uCE59 \uB4F1\uB85D/\uAC31\uC2E0 \uC644\uB8CC: ${args.id}`,
+            id: args.id
+          });
+          break;
+        }
+        case "audit_causal_memory": {
+          const audit = store.audit();
+          const status = store.getStatus();
+          const checkpointsCount = contextStore.listCheckpoints().length;
+          payloadText = JSON.stringify({ ...audit, status, checkpointsCount }, null, 2);
+          break;
+        }
+        case "read_graph": {
+          const gitFiles = await detectModifiedFiles();
+          const smartGraph = store.readSmartGraph(gitFiles);
+          const latestCheckpoint = contextStore.getLatestCheckpoint();
+          payloadText = JSON.stringify({
+            ...smartGraph,
+            latestContextCheckpoint: latestCheckpoint || null
+          }, null, 2);
+          break;
+        }
+        case "save_context_checkpoint": {
+          const saved = await contextStore.saveCheckpoint(args);
+          payloadText = JSON.stringify({
+            ok: true,
+            message: `\uCEE8\uD14D\uC2A4\uD2B8 \uCCB4\uD06C\uD3EC\uC778\uD2B8 \uC800\uC7A5 \uC644\uB8CC: ${saved.id}`,
+            checkpoint: saved
+          }, null, 2);
+          break;
+        }
+        case "load_context_checkpoint": {
+          const targetId = typeof args.id === "string" ? args.id : "latest";
+          const sessionId = typeof args.sessionId === "string" ? args.sessionId : undefined;
+          const found = contextStore.getCheckpoint(targetId, sessionId);
+          if (!found) {
+            payloadText = JSON.stringify({
+              ok: false,
+              message: "\uC800\uC7A5\uB41C \uCEE8\uD14D\uC2A4\uD2B8 \uCCB4\uD06C\uD3EC\uC778\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."
+            });
+          } else {
+            payloadText = ContextCheckpointStore.formatForAgentResume(found, Boolean(args.compact));
+          }
+          break;
+        }
+        case "list_context_checkpoints": {
+          const sessionId = typeof args.sessionId === "string" ? args.sessionId : undefined;
+          const limit = typeof args.limit === "number" ? args.limit : 20;
+          const list = contextStore.listCheckpoints({ sessionId, limit });
+          payloadText = JSON.stringify({
+            ok: true,
+            totalCount: list.length,
+            checkpoints: list.map((c) => ({
+              id: c.id,
+              sessionId: c.sessionId,
+              title: c.title,
+              createdAt: c.createdAt,
+              goal: c.goal,
+              pendingTasksCount: c.pendingTasks.length,
+              completedStepsCount: c.completedSteps.length
+            }))
+          }, null, 2);
+          break;
+        }
+        case "search_nodes": {
+          const searchResult = store.searchNodes(String(args.query || ""));
+          payloadText = JSON.stringify(searchResult, null, 2);
+          break;
+        }
+        case "open_nodes": {
+          const names = Array.isArray(args.names) ? args.names : [];
+          const openResult = store.openNodes(names);
+          payloadText = JSON.stringify(openResult, null, 2);
+          break;
+        }
+        case "create_entities": {
+          const entities = Array.isArray(args.entities) ? args.entities : [];
+          const created = store.createEntities(entities);
+          payloadText = JSON.stringify(created, null, 2);
+          break;
+        }
+        case "create_relations": {
+          const relations = Array.isArray(args.relations) ? args.relations : [];
+          const created = store.createRelations(relations);
+          payloadText = JSON.stringify(created, null, 2);
+          break;
+        }
+        case "add_observations": {
+          const observations = Array.isArray(args.observations) ? args.observations : [];
+          const added = store.addObservations(observations);
+          payloadText = JSON.stringify(added, null, 2);
+          break;
+        }
+        case "delete_entities": {
+          const entityNames = Array.isArray(args.entityNames) ? args.entityNames : [];
+          store.deleteEntities(entityNames);
+          payloadText = "Entities deleted successfully";
+          break;
+        }
+        case "delete_observations": {
+          const deletions = Array.isArray(args.deletions) ? args.deletions : [];
+          store.deleteObservations(deletions);
+          payloadText = "Observations deleted successfully";
+          break;
+        }
+        case "delete_relations": {
+          const relations = Array.isArray(args.relations) ? args.relations : [];
+          store.deleteRelations(relations);
+          payloadText = "Relations deleted successfully";
+          break;
+        }
+        case "time_travel_causal_memory": {
+          const timeSeries = new CausalTimeSeriesEngine(contextStore, store);
+          if (args.action === "diff") {
+            const diff = timeSeries.diffCheckpoints(String(args.fromId || ""), String(args.toId || ""));
+            payloadText = JSON.stringify(diff, null, 2);
+          } else if (args.action === "rewind") {
+            const res = await timeSeries.rewindToCheckpoint(String(args.targetId || ""));
+            payloadText = JSON.stringify(res, null, 2);
+          } else if (args.action === "timeline") {
+            const tl = timeSeries.generateTimeline(typeof args.limit === "number" ? args.limit : 20);
+            payloadText = JSON.stringify(tl, null, 2);
+          } else {
+            const resonance = store.queryResonance({
+              files: Array.isArray(args.files) ? args.files : []
+            });
+            const decayed = timeSeries.computeDecayedResonance(resonance.resonanceRules);
+            payloadText = JSON.stringify(decayed, null, 2);
+          }
+          break;
+        }
+        case "scan_causal_graveyard": {
+          const graveyard = new CausalGraveyardStore(store);
+          if (args.action === "assert") {
+            const trap = graveyard.assertTrap(args);
+            payloadText = JSON.stringify({ ok: true, trap }, null, 2);
+          } else if (args.action === "list") {
+            const list = graveyard.getAllTraps();
+            payloadText = JSON.stringify({ ok: true, traps: list }, null, 2);
+          } else {
+            const res = graveyard.scanTraps({
+              files: Array.isArray(args.files) ? args.files : undefined,
+              keywords: Array.isArray(args.keywords) ? args.keywords : undefined
+            });
+            payloadText = CausalGraveyardStore.formatTrapWarnings(res);
+          }
+          break;
+        }
+        case "branch_causal_context": {
+          const branchStore = new CausalBranchStore(contextStore);
+          if (args.action === "create") {
+            const b = await branchStore.createBranch(String(args.name || ""), {
+              description: args.fromBranch
+            });
+            payloadText = JSON.stringify({ ok: true, branch: b }, null, 2);
+          } else if (args.action === "switch") {
+            const b = branchStore.switchBranch(String(args.name || ""));
+            payloadText = JSON.stringify({ ok: true, branch: b }, null, 2);
+          } else if (args.action === "merge") {
+            const res = await branchStore.mergeBranch(String(args.name || ""), args.targetBranch);
+            payloadText = JSON.stringify(res, null, 2);
+          } else if (args.action === "abandon") {
+            const res = branchStore.abandonBranch(String(args.name || ""), String(args.failureReason || "\uD3D0\uAE30\uB428"), args.safeAlternative);
+            payloadText = JSON.stringify(res, null, 2);
+          } else {
+            const branches = branchStore.listBranches();
+            const current = branchStore.getCurrentBranch();
+            payloadText = JSON.stringify({ ok: true, currentBranch: current, branches }, null, 2);
+          }
+          break;
+        }
+        case "predict_blast_radius": {
+          const predictor = new CausalPredictorEngine(store, contextStore);
+          const files = Array.isArray(args.files) ? args.files : [];
+          const maxHops = typeof args.maxHops === "number" ? args.maxHops : 3;
+          const report = predictor.analyzeBlastRadius(files, maxHops);
+          payloadText = JSON.stringify(report, null, 2);
+          break;
+        }
+        case "synthesize_git_checkpoint": {
+          const synthesizer = new CausalSynthesizerEngine(contextStore, store);
+          const cwd = typeof args.cwd === "string" ? args.cwd : process.cwd();
+          if (args.autoCheckpoint === false) {
+            const summary = await synthesizer.inspectGitChanges(cwd);
+            const intent = synthesizer.synthesizeIntent(summary, args.title);
+            payloadText = JSON.stringify({ summary, intent }, null, 2);
+          } else {
+            const cp = await synthesizer.autoCheckpoint(cwd, { title: args.title });
+            payloadText = JSON.stringify({ ok: true, checkpoint: cp }, null, 2);
+          }
+          break;
+        }
+        case "sync_obsidian_lens": {
+          const lens = new CausalObsidianLensEngine(store, contextStore);
+          const vaultPath = typeof args.vaultPath === "string" ? args.vaultPath : undefined;
+          if (args.action === "export") {
+            const exp = await lens.exportToVault(vaultPath);
+            payloadText = JSON.stringify(exp, null, 2);
+          } else if (args.action === "import") {
+            const imp = await lens.importFromVault(vaultPath);
+            payloadText = JSON.stringify(imp, null, 2);
+          } else {
+            const syncRes = await lens.syncWithVault(vaultPath);
+            payloadText = JSON.stringify(syncRes, null, 2);
+          }
+          break;
+        }
+        default:
+          return {
+            jsonrpc: "2.0",
+            id: id ?? null,
+            error: {
+              code: -32601,
+              message: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uB3C4\uAD6C\uC785\uB2C8\uB2E4: ${toolName}`
+            }
+          };
+      }
+      return {
+        jsonrpc: "2.0",
+        id: id ?? null,
+        result: {
+          content: [{ type: "text", text: payloadText }]
+        }
+      };
+    } catch (error) {
+      return {
+        jsonrpc: "2.0",
+        id: id ?? null,
+        result: {
+          content: [
+            {
+              type: "text",
+              text: `\uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uB3C4\uAD6C \uC2E4\uD589 \uC624\uB958: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        }
+      };
+    }
+  }
+  return {
+    jsonrpc: "2.0",
+    id: id ?? null,
+    error: { code: -32601, message: `Method not found: ${method}` }
+  };
+}
+function startCausalServer(options = {}) {
+  const port = options.port || CAUSAL_MEMORY_CONFIG.DEFAULT_PORT;
+  const host = options.host || CAUSAL_MEMORY_CONFIG.DEFAULT_HOST;
+  const store = new CausalMemoryStore(options.dbPath);
+  const contextStore = new ContextCheckpointStore(options.contextDbPath, options.dbPath);
+  const server = Bun.serve({
+    port,
+    hostname: host,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const headers = {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type"
+      };
+      if (req.method === "OPTIONS") {
+        return new Response(null, { headers });
+      }
+      try {
+        if (url.pathname === "/health" || url.pathname === "/status") {
+          store.reloadIfNeeded();
+          return new Response(JSON.stringify({ ok: true, status: store.getStatus() }), { headers });
+        }
+        if (url.pathname === "/query" && req.method === "GET") {
+          store.reloadIfNeeded();
+          const files = url.searchParams.getAll("files");
+          const keywords = url.searchParams.getAll("keywords");
+          const command = url.searchParams.get("command") || undefined;
+          const domain = url.searchParams.get("domain") || undefined;
+          const result = store.queryResonance({ files, keywords, command, domain });
+          return new Response(JSON.stringify(result), { headers });
+        }
+        if (url.pathname === "/query" && req.method === "POST") {
+          store.reloadIfNeeded();
+          const body = await req.json();
+          let files = Array.isArray(body.files) ? body.files : [];
+          if (body.autoGit === true && files.length === 0) {
+            files = await detectModifiedFiles(body.cwd);
+          }
+          const result = store.queryResonance({
+            files,
+            keywords: body.keywords,
+            command: body.command,
+            domain: body.domain,
+            propagateRelations: body.propagateRelations,
+            maxHops: body.maxHops
+          });
+          const format = url.searchParams.get("format") || body.format;
+          if (format === "markdown" || format === "md") {
+            return new Response(formatResonanceForAgent(result, false), {
+              headers: { ...headers, "Content-Type": "text/markdown; charset=utf-8" }
+            });
+          }
+          if (format === "compact") {
+            return new Response(formatResonanceForAgent(result, true), { headers });
+          }
+          return new Response(JSON.stringify(result), { headers });
+        }
+        if (url.pathname === "/assert" && req.method === "POST") {
+          store.reloadIfNeeded();
+          const body = await req.json();
+          store.assertRule(body);
+          return new Response(JSON.stringify({ ok: true, id: body.id }), { headers });
+        }
+        if (url.pathname === "/audit") {
+          store.reloadIfNeeded();
+          const auditResult = store.audit();
+          return new Response(JSON.stringify(auditResult), { headers });
+        }
+        if (url.pathname === "/sync" && req.method === "GET") {
+          const rawDb = store.getRawDatabase();
+          return new Response(JSON.stringify(rawDb), { headers });
+        }
+        if (url.pathname === "/sync" && req.method === "POST") {
+          const body = await req.json();
+          const incomingRules = Array.isArray(body.rules) ? body.rules : [];
+          const incomingRelations = Array.isArray(body.relations) ? body.relations : [];
+          const mergeResult = store.mergeDatabase(incomingRules, incomingRelations);
+          return new Response(JSON.stringify({ ok: true, ...mergeResult }), { headers });
+        }
+        if (url.pathname === "/context" && req.method === "GET") {
+          contextStore.reloadIfNeeded();
+          const id = url.searchParams.get("id") || undefined;
+          const sessionId = url.searchParams.get("sessionId") || undefined;
+          const listMode = url.searchParams.get("list") === "true";
+          if (listMode) {
+            const list = contextStore.listCheckpoints({ sessionId });
+            return new Response(JSON.stringify({ ok: true, checkpoints: list }), { headers });
+          }
+          const found = contextStore.getCheckpoint(id || "latest", sessionId);
+          return new Response(JSON.stringify({ ok: Boolean(found), checkpoint: found }), { headers });
+        }
+        if (url.pathname === "/context" && req.method === "POST") {
+          const body = await req.json();
+          const saved = await contextStore.saveCheckpoint(body);
+          return new Response(JSON.stringify({ ok: true, checkpoint: saved }), { headers });
+        }
+        if (url.pathname === "/timeline" && req.method === "GET") {
+          const timeSeries = new CausalTimeSeriesEngine(contextStore, store);
+          const limit = parseInt(url.searchParams.get("limit") || "20", 10);
+          const tl = timeSeries.generateTimeline(limit);
+          return new Response(JSON.stringify({ ok: true, timeline: tl }), { headers });
+        }
+        if (url.pathname === "/graveyard") {
+          const graveyard = new CausalGraveyardStore(store);
+          if (req.method === "GET") {
+            const list = graveyard.getAllTraps();
+            return new Response(JSON.stringify({ ok: true, traps: list }), { headers });
+          }
+          if (req.method === "POST") {
+            const body = await req.json();
+            if (body.action === "scan") {
+              const scanRes = graveyard.scanTraps({
+                files: body.files,
+                keywords: body.keywords
+              });
+              return new Response(JSON.stringify({ ok: true, scan: scanRes }), { headers });
+            }
+            const trap = graveyard.assertTrap(body);
+            return new Response(JSON.stringify({ ok: true, trap }), { headers });
+          }
+        }
+        if (url.pathname === "/branch") {
+          const branchStore = new CausalBranchStore(contextStore);
+          if (req.method === "GET") {
+            return new Response(JSON.stringify({
+              ok: true,
+              current: branchStore.getCurrentBranch(),
+              branches: branchStore.listBranches()
+            }), { headers });
+          }
+          if (req.method === "POST") {
+            const body = await req.json();
+            if (body.action === "create") {
+              const b = await branchStore.createBranch(body.name, {
+                description: body.fromBranch
+              });
+              return new Response(JSON.stringify({ ok: true, branch: b }), { headers });
+            }
+            if (body.action === "switch") {
+              const b = branchStore.switchBranch(body.name);
+              return new Response(JSON.stringify({ ok: true, branch: b }), { headers });
+            }
+            if (body.action === "merge") {
+              const res = await branchStore.mergeBranch(body.name, body.targetBranch);
+              return new Response(JSON.stringify(res), { headers });
+            }
+            if (body.action === "abandon") {
+              const res = branchStore.abandonBranch(body.name, body.failureReason, body.safeAlternative);
+              return new Response(JSON.stringify(res), { headers });
+            }
+          }
+        }
+        if (url.pathname === "/predict" && req.method === "POST") {
+          const predictor = new CausalPredictorEngine(store, contextStore);
+          const body = await req.json();
+          const files = Array.isArray(body.files) ? body.files : [];
+          const maxHops = typeof body.maxHops === "number" ? body.maxHops : 3;
+          const report = predictor.analyzeBlastRadius(files, maxHops);
+          return new Response(JSON.stringify({ ok: true, report }), { headers });
+        }
+        if (url.pathname === "/synthesize" && req.method === "POST") {
+          const synthesizer = new CausalSynthesizerEngine(contextStore, store);
+          const body = await req.json();
+          const cwd = typeof body.cwd === "string" ? body.cwd : process.cwd();
+          if (body.autoCheckpoint === false) {
+            const summary = await synthesizer.inspectGitChanges(cwd);
+            const intent = synthesizer.synthesizeIntent(summary, body.title);
+            return new Response(JSON.stringify({ ok: true, summary, intent }), { headers });
+          }
+          const cp = await synthesizer.autoCheckpoint(cwd, { title: body.title });
+          return new Response(JSON.stringify({ ok: true, checkpoint: cp }), { headers });
+        }
+        if (url.pathname === "/lens" && req.method === "POST") {
+          const lens = new CausalObsidianLensEngine(store, contextStore);
+          const body = await req.json();
+          const vaultPath = typeof body.vaultPath === "string" ? body.vaultPath : undefined;
+          if (body.action === "export") {
+            const res = await lens.exportToVault(vaultPath);
+            return new Response(JSON.stringify(res), { headers });
+          }
+          if (body.action === "import") {
+            const res = await lens.importFromVault(vaultPath);
+            return new Response(JSON.stringify(res), { headers });
+          }
+          const syncRes = await lens.syncWithVault(vaultPath);
+          return new Response(JSON.stringify(syncRes), { headers });
+        }
+        if (url.pathname === "/mcp" && req.method === "POST") {
+          const rpc = await req.json();
+          const responseObj = await handleMcpJsonRpcRequest(rpc, store, options.dbPath, options.contextDbPath);
+          if (!responseObj) {
+            return new Response(null, { status: 204, headers });
+          }
+          return new Response(JSON.stringify(responseObj), { headers });
+        }
+        return new Response(JSON.stringify({ error: "Not Found" }), { status: 404, headers });
+      } catch (err) {
+        return new Response(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }), { status: 500, headers });
+      }
+    }
+  });
+  return server;
+}
+async function startCausalMcpStdioServer(dbPath, remoteUrl) {
+  const store = new CausalMemoryStore(dbPath);
+  const targetRemote = remoteUrl || CAUSAL_MEMORY_CONFIG.REMOTE_URL;
+  const isRemoteMode = Boolean(targetRemote && targetRemote.trim().length > 0);
+  const activeDaemonUrl = isRemoteMode ? targetRemote.endsWith("/mcp") ? targetRemote : `${targetRemote.replace(/\/+$/, "")}/mcp` : `http://${CAUSAL_MEMORY_CONFIG.DEFAULT_HOST}:${CAUSAL_MEMORY_CONFIG.DEFAULT_PORT}/mcp`;
+  const timeoutMs = isRemoteMode ? CAUSAL_MEMORY_CONFIG.REMOTE_TIMEOUT_MS : 150;
+  const rl = createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      const rpc = JSON.parse(trimmed);
+      let responseObj = null;
+      if (rpc.method === "tools/call") {
+        try {
+          const daemonRes = await fetch(activeDaemonUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: trimmed,
+            signal: AbortSignal.timeout(timeoutMs)
+          });
+          if (daemonRes.ok) {
+            responseObj = await daemonRes.json();
+          }
+        } catch {}
+      }
+      if (!responseObj) {
+        responseObj = await handleMcpJsonRpcRequest(rpc, store, dbPath);
+      }
+      if (responseObj) {
+        process.stdout.write(JSON.stringify(responseObj) + `
+`);
+      }
+    } catch (error) {
+      const errResp = {
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: -32700,
+          message: `JSON Parse error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      };
+      process.stdout.write(JSON.stringify(errResp) + `
+`);
+    }
+  }
+}
+// memory/causal-migrator.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname5 } from "path";
+function migrateLegacyMemoryGraph(sourceBackupPath = CAUSAL_MEMORY_CONFIG.LEGACY_BACKUP_PATH, targetGlobalPath = CAUSAL_MEMORY_CONFIG.GLOBAL_DB_PATH, targetLocalPath = CAUSAL_MEMORY_CONFIG.LOCAL_DB_PATH) {
+  if (!existsSync7(sourceBackupPath)) {
+    throw new Error(`\uAD6C\uD615 \uBA54\uBAA8\uB9AC \uBC31\uC5C5 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${sourceBackupPath}`);
+  }
+  const raw = readFileSync6(sourceBackupPath, "utf-8");
+  const legacy = JSON.parse(raw);
+  const entities = legacy.entities || [];
+  const legacyRelations = legacy.relations || [];
+  const today = new Date().toISOString().split("T")[0];
+  const seenIds = new Map;
+  const rules = [];
+  for (const ent of entities) {
+    const inferred = CausalMemoryStore.inferRuleFromEntity(ent, today);
+    const baseId = inferred.id;
+    const count = seenIds.get(baseId) || 0;
+    seenIds.set(baseId, count + 1);
+    const uniqueId = count === 0 ? baseId : `${baseId}-${count + 1}`;
+    rules.push({
+      ...inferred,
+      id: uniqueId
+    });
+  }
+  const hasVesperCore = rules.some((r) => r.id === "rule-project_vesper_dsp-vesper-dsp-master-invariants");
+  if (!hasVesperCore) {
+    rules.push({
+      id: "rule-project_vesper_dsp-vesper-dsp-master-invariants",
+      domain: "Project_Vesper_DSP",
+      title: "Vesper_DSP_Master_Invariants",
+      entityType: "Architecture_Invariant",
+      triggers: {
+        files: ["D:/Vesper", "crates/vesper-", "vesper-apo", "dsp-settings.json"],
+        keywords: ["vesper", "dsp", "mmcss", "virtuallock", "\uC624\uB514\uC624", "\uC0AC\uC6B4\uB4DC", "\uB04A\uAE40", "apo"],
+        commands: ["check", "build", "package", "sign"]
+      },
+      invariants: [
+        "\uC624\uB514\uC624 \uBC84\uD37C\uB294 \uBC18\uB4DC\uC2DC Win32 VirtualLock\uC73C\uB85C \uBB3C\uB9AC RAM\uC5D0 \uACE0\uC815\uD558\uC5EC \uB514\uC2A4\uD06C \uC2A4\uC651 \uC544\uC6C3(\uD558\uB4DC \uD398\uC774\uC9C0 \uD3F4\uD2B8)\uC744 \uC6D0\uCC9C \uCC28\uB2E8\uD560 \uAC83",
+        "\uC624\uB514\uC624 \uCC98\uB9AC \uC2A4\uB808\uB4DC\uB294 Windows MMCSS(Pro Audio) \uC2E4\uC2DC\uAC04 \uC2A4\uCF00\uC904\uB7EC\uC5D0 \uD544\uC218 \uB4F1\uB85D\uD560 \uAC83",
+        "\uC124\uC815 \uC800\uC7A5\uC740 \uBE0C\uB77C\uC6B0\uC800 localStorage \uB2E8\uB3C5 \uC758\uC874\uC744 \uAE08\uC9C0\uD558\uACE0 Crash-Safe \uC6D0\uC790\uC801(Atomic) \uD30C\uC77C \uC800\uC7A5(dsp-settings.json)\uC744 \uC0AC\uC6A9\uD560 \uAC83",
+        "Windows \uC167\uB2E4\uC6B4 \uC2DC WM_QUERYENDSESSION / SM_SHUTTINGDOWN \uAC10\uC9C0 \uD6C4 \uC815\uC0C1 \uC885\uB8CC\uB97C \uBCF4\uC7A5\uD560 \uAC83"
+      ],
+      actions: [
+        "1. Cargo Workspace 5\uB300 \uB9C8\uC774\uD06C\uB85C \uD06C\uB808\uC774\uD2B8(vesper-config, vesper-ipc, vesper-audio-core, vesper-system, vesper-tauri) \uACBD\uACC4 \uC900\uC218",
+        "2. \uC218\uC815\uB41C \uD06C\uB808\uC774\uD2B8 \uD2B8\uB799\uB9CC \uC778\uACFC\uC728 \uC99D\uBD84 \uBE4C\uB4DC \uC218\uD589"
+      ],
+      context: [
+        "\uC2E4\uC99D \uD0C0\uAE43 \uACBD\uB85C: D:\\Vesper\\dsp-boot-fix\\dsp",
+        "APO DLL \uBC0F Taskbar \uB124\uC774\uD2F0\uBE0C \uBC14\uC774\uB108\uB9AC \uC544\uD0A4\uD14D\uCC98 \uBB34\uACB0\uC131(x64 PE) \uAC80\uC99D \uD544\uC218"
+      ],
+      lastVerified: today
+    });
+  }
+  const hasSynapseCore = rules.some((r) => r.id === "rule-project_synapse_kit-synapse-kit-core-invariants");
+  if (!hasSynapseCore) {
+    rules.push({
+      id: "rule-project_synapse_kit-synapse-kit-core-invariants",
+      domain: "Project_Synapse_Kit",
+      title: "Synapse_Kit_Core_Invariants",
+      entityType: "Framework_Invariant",
+      triggers: {
+        files: ["D:/synapse", "D:/synapse-site", "synapse.config.ts"],
+        keywords: ["synapse", "synapse-kit", "\uC2DC\uB0C5\uC2A4", "\uC778\uACFC\uC728", "causal", "\uCEF4\uD30C\uC77C\uB7EC", "\uCCB4\uCEE4"],
+        commands: ["check", "build", "package", "sign", "init", "memory"]
+      },
+      invariants: [
+        "Git \uC0C1\uD0DC \uC2A4\uCE94 \uC2DC \uBC18\uB4DC\uC2DC git status --porcelain -uall \uD50C\uB798\uADF8\uB97C \uC0AC\uC6A9\uD558\uC5EC \uBBF8\uCD94\uC801 \uD558\uC704 \uB514\uB809\uD130\uB9AC \uD30C\uC77C \uB204\uB77D\uC744 \uBC29\uC9C0\uD560 \uAC83",
+        "AI \uC5D0\uC774\uC804\uD2B8 \uC5F0\uB3D9 \uC2DC --compact \uBAA8\uB4DC\uB97C \uD1B5\uD574 \uC131\uACF5 \uC2DC 11\uD1A0\uD070 \uB2E8\uC77C \uB77C\uC778 JSON\uC744 \uBC18\uD658\uD558\uC5EC \uD1A0\uD070\uC744 99.8% \uC808\uAC10\uD560 \uAC83",
+        "\uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800 \uBC0F \uB7F0\uD0C0\uC784\uC740 npm/npx\uB97C \uC808\uB300 \uC0AC\uC6A9\uD558\uC9C0 \uC54A\uACE0 \uBC18\uB4DC\uC2DC bun\uC744 \uC0AC\uC6A9\uD560 \uAC83"
+      ],
+      actions: [
+        "1. \uCF54\uB4DC \uBCC0\uACBD \uD6C4 bun D:/synapse/dist/cli.js check --compact\uB85C \uBB34\uACB0\uC131 \uAC80\uC99D",
+        "2. \uBA54\uBAA8\uB9AC \uC870\uD68C \uC2DC synapse memory query\uB85C \uACF5\uBA85 \uADDC\uCE59\uB9CC \uCD5C\uC18C \uD1A0\uD070 \uC8FC\uC785"
+      ],
+      context: [
+        "\uC5D4\uC9C4 \uCF54\uC5B4 \uACBD\uB85C: D:\\synapse",
+        "\uACF5\uC2DD \uBB38\uC11C \uBC0F \uC704\uD0A4 \uACBD\uB85C: D:\\synapse-site (KO/EN \uB2E4\uAD6D\uC5B4 \uB85C\uCF00\uC77C \uC790\uB3D9 \uBD84\uAE30)"
+      ],
+      lastVerified: today
+    });
+  }
+  const relations = [...legacyRelations];
+  const coreRelations = [
+    {
+      from: "POE2_AutoFilter_Project",
+      to: "POE2_AutoFilter_ReleaseProcess",
+      relationType: "governed_by_workflow"
+    },
+    {
+      from: "POE2_AutoFilter_ReleaseProcess",
+      to: "POE2_AutoFilter_Updater",
+      relationType: "triggers_update_of"
+    },
+    {
+      from: "POE2_AutoFilter_ReleaseProcess",
+      to: "POE2_AutoFilter_KnownBugs",
+      relationType: "verifies_and_notifies"
+    },
+    {
+      from: "Synapse_Kit_Core_Invariants",
+      to: "Vesper_DSP_Master_Invariants",
+      relationType: "verifies_and_builds"
+    }
+  ];
+  for (const cr of coreRelations) {
+    const exists = relations.some((r) => r.from === cr.from && r.to === cr.to && r.relationType === cr.relationType);
+    if (!exists) {
+      relations.push(cr);
+    }
+  }
+  const db = {
+    version: CAUSAL_MEMORY_CONFIG.SCHEMA_VERSION,
+    updatedAt: new Date().toISOString(),
+    totalRules: rules.length,
+    totalRelations: relations.length,
+    rules,
+    relations
+  };
+  const serialized = JSON.stringify(db, null, 2);
+  for (const outPath of [targetGlobalPath, targetLocalPath]) {
+    const dir = dirname5(outPath);
+    if (!existsSync7(dir)) {
+      mkdirSync6(dir, { recursive: true });
+    }
+    writeFileSync6(outPath, serialized, "utf-8");
+  }
+  const alwaysActiveCount = rules.filter((r) => r.triggers.alwaysActive).length;
+  const domains = Array.from(new Set(rules.map((r) => r.domain)));
+  return {
+    ok: true,
+    totalRules: rules.length,
+    totalRelations: relations.length,
+    alwaysActiveCount,
+    domains
+  };
+}
+// memory/causal-benchmark.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var GRAY = "\x1B[90m";
+function calcPercentile(sorted, p) {
+  if (sorted.length === 0)
+    return 0;
+  const idx = Math.min(sorted.length - 1, Math.floor(p / 100 * sorted.length));
+  return Math.round(sorted[idx] * 1000) / 1000;
+}
+function generateSyntheticDatabase(ruleCount, relationCount) {
+  const domains = [
+    "Project_POE2_AutoFilter",
+    "Project_Vesper_DSP",
+    "Project_Synapse_Kit",
+    "BioPhys_Research_And_Architecture",
+    "Hardware_And_PCB",
+    "Knowledge_Base"
+  ];
+  const rules = [
+    {
+      id: "rule-always-1",
+      domain: "User_Preferences_And_Rules",
+      title: "Global_Preference_1",
+      triggers: { alwaysActive: true },
+      invariants: ["\uD56D\uC0C1 \uD55C\uAD6D\uC5B4 \uC6B0\uC120 \uCD9C\uB825", "bun \uD544\uC218 \uC0AC\uC6A9"],
+      actions: [],
+      context: []
+    },
+    {
+      id: "rule-always-2",
+      domain: "User_Preferences_And_Rules",
+      title: "Global_Preference_2",
+      triggers: { alwaysActive: true },
+      invariants: ["console.log \uB514\uBC84\uADF8 \uCF54\uB4DC \uAE08\uC9C0", "\uD558\uB4DC\uCF54\uB529 \uAE08\uC9C0"],
+      actions: [],
+      context: []
+    },
+    {
+      id: "rule-always-3",
+      domain: "User_Preferences_And_Rules",
+      title: "Global_Preference_3",
+      triggers: { alwaysActive: true },
+      invariants: ["100% \uC21C\uC218 Rust \uBC31\uC5D4\uB4DC \uC6D0\uCE59"],
+      actions: [],
+      context: []
+    },
+    {
+      id: "rule-always-4",
+      domain: "User_Preferences_And_Rules",
+      title: "Global_Preference_4",
+      triggers: { alwaysActive: true },
+      invariants: ["\uAC80\uC99D \uCD5C\uC6B0\uC120 \uC6D0\uCE59 \uC900\uC218"],
+      actions: [],
+      context: []
+    }
+  ];
+  for (let i = 4;i < ruleCount; i++) {
+    const dom = domains[i % domains.length];
+    const moduleIdx = i % 500;
+    rules.push({
+      id: `rule-synth-${i}`,
+      domain: dom,
+      title: `Synth_Node_${i}`,
+      triggers: {
+        files: [`packages/mod_${moduleIdx}/src/file_${i}.rs`],
+        keywords: [`kw_${i}`, `topic_${i % 250}`],
+        commands: i % 20 === 0 ? ["build"] : i % 20 === 1 ? ["release"] : ["check"]
+      },
+      invariants: [`\uBD88\uBCC0 \uACC4\uC57D #${i}: \uBA54\uBAA8\uB9AC \uC548\uC804\uC131 \uBC0F \uD0C0\uC785 \uACBD\uACC4 \uBCF4\uC7A5`],
+      actions: [`1. \uBAA8\uB4C8 ${moduleIdx} \uC815\uC801 \uAC80\uC99D \uC218\uD589`],
+      context: [`\uD569\uC131 \uBCA4\uCE58\uB9C8\uD06C \uB178\uB4DC \uCEE8\uD14D\uC2A4\uD2B8 \uB370\uC774\uD130 #${i}`],
+      lastVerified: "2026-11-01"
+    });
+  }
+  const relations = [];
+  relations.push({ from: "Synth_Node_10", to: "Synth_Node_11", relationType: "triggers_hop_1" }, { from: "Synth_Node_11", to: "Synth_Node_12", relationType: "triggers_hop_2" }, { from: "Synth_Node_12", to: "Synth_Node_13", relationType: "triggers_hop_3" }, { from: "Synth_Node_13", to: "Synth_Node_14", relationType: "triggers_hop_4" }, { from: "Synth_Node_14", to: "Synth_Node_15", relationType: "triggers_hop_5" }, { from: "Synth_Node_15", to: "Synth_Node_10", relationType: "circular_feedback_edge" });
+  for (let j = relations.length;j < relationCount; j++) {
+    const fromIdx = 4 + j % (ruleCount - 10);
+    const toIdx = fromIdx + 1 + j % 5;
+    relations.push({
+      from: `Synth_Node_${fromIdx}`,
+      to: `Synth_Node_${toIdx}`,
+      relationType: "causal_impact_on"
+    });
+  }
+  return {
+    version: "2.1.0",
+    updatedAt: new Date().toISOString(),
+    totalRules: rules.length,
+    totalRelations: relations.length,
+    rules,
+    relations
+  };
+}
+async function executeOverloadBenchmark(customConfig, silent = false) {
+  const config = {
+    ruleScale: customConfig?.ruleScale ?? 1e4,
+    relationScale: customConfig?.relationScale ?? 20000,
+    concurrency: customConfig?.concurrency ?? 50,
+    totalRequests: customConfig?.totalRequests ?? 5000,
+    fileInputScale: customConfig?.fileInputScale ?? 1e4,
+    crudIterations: customConfig?.crudIterations ?? 5000
+  };
+  const log = (msg) => {
+    if (!silent)
+      process.stdout.write(msg);
+  };
+  const benchStart = performance.now();
+  const scenarios = [];
+  const isExtreme = config.ruleScale >= 1e5;
+  const modeTitle = isExtreme ? "\uC635\uC158 2 \uADF9\uD55C \uD55C\uACC4 \uB3CC\uD30C \uC2A4\uD2B8\uB808\uC2A4 \uBCA4\uCE58\uB9C8\uD06C (Stress Max)" : "\uC635\uC158 1 \uD45C\uC900 \uACFC\uBD80\uD558 \uC2A4\uD2B8\uB808\uC2A4 \uBCA4\uCE58\uB9C8\uD06C";
+  const sloP50Ms = isExtreme ? 2 : 0.8;
+  const sloP99Ms = isExtreme ? 5 : 1.5;
+  const sloRps = isExtreme ? 3000 : 5000;
+  const sloHopMs = isExtreme ? 100 : 30;
+  const sloHeapDeltaMB = isExtreme ? 8 : 3;
+  log(`
+${BOLD}${CYAN}\uD83D\uDD25 [Causal Memory 2.1] ${modeTitle} \uAC00\uB3D9${RESET}
+`);
+  log(`${GRAY}\u2022 \uC2A4\uD399: \uADDC\uCE59 ${config.ruleScale.toLocaleString()}\uAC1C | \uAC04\uC120 ${config.relationScale.toLocaleString()}\uAC1C | \uB3D9\uC2DC\uC131 ${config.concurrency} \uC6CC\uCEE4 | \uC694\uCCAD ${config.totalRequests.toLocaleString()}\uD68C | \uBCC0\uACBD\uD30C\uC77C ${config.fileInputScale.toLocaleString()}\uAC1C${RESET}
+`);
+  log(`${GRAY}${"\u2501".repeat(84)}${RESET}
+
+`);
+  log(`${BOLD}${YELLOW}\uD83D\uDCCC [\uC2DC\uB098\uB9AC\uC624 1] ${config.ruleScale.toLocaleString()}\uAC1C \uADDC\uCE59 & ${config.relationScale.toLocaleString()}\uAC1C \uAC04\uC120 \uC801\uC7AC \uBC0F O(1) \uC5ED\uC778\uB371\uC2A4 \uACF5\uBA85 \uD14C\uC2A4\uD2B8${RESET}
+`);
+  const genStart = performance.now();
+  const synthDb = generateSyntheticDatabase(config.ruleScale, config.relationScale);
+  const genDurationMs = Math.round((performance.now() - genStart) * 100) / 100;
+  const indexStart = performance.now();
+  const scaleStore = new CausalMemoryStore(undefined, synthDb);
+  const indexBuildMs = Math.round((performance.now() - indexStart) * 100) / 100;
+  const queryLatencies = [];
+  let lastResonance = scaleStore.queryResonance({ keywords: ["kw_10"] });
+  for (let i = 0;i < 1000; i++) {
+    const targetKw = `kw_${10 + i % 5000}`;
+    const qStart = performance.now();
+    lastResonance = scaleStore.queryResonance({ keywords: [targetKw] });
+    queryLatencies.push(performance.now() - qStart);
+  }
+  queryLatencies.sort((a, b) => a - b);
+  const s1P50 = calcPercentile(queryLatencies, 50);
+  const s1P95 = calcPercentile(queryLatencies, 95);
+  const s1P99 = calcPercentile(queryLatencies, 99);
+  const s1Passed = s1P50 <= sloP50Ms && s1P99 <= sloP99Ms && parseFloat(lastResonance.tokenDietSavingsRatio) >= 99;
+  scenarios.push({
+    name: "\uC2DC\uB098\uB9AC\uC624 1: \uB300\uADDC\uBAA8 \uBCFC\uB968 \uC801\uC7AC \uBC0F O(1) \uACF5\uBA85 \uCFFC\uB9AC",
+    passed: s1Passed,
+    details: {
+      totalRules: config.ruleScale,
+      totalRelations: config.relationScale,
+      syntheticGenMs: genDurationMs,
+      indexBuildMs,
+      p50Ms: s1P50,
+      p95Ms: s1P95,
+      p99Ms: s1P99,
+      tokenSavings: lastResonance.tokenDietSavingsRatio
+    }
+  });
+  log(`  \u2022 \uC5ED\uC778\uB371\uC2A4 \uAD6C\uCD95 \uC2DC\uAC04 : ${BOLD}${GREEN}${indexBuildMs}ms${RESET} (${config.ruleScale.toLocaleString()} Rules + ${config.relationScale.toLocaleString()} Relations)
+`);
+  log(`  \u2022 \uACF5\uBA85 \uCFFC\uB9AC \uB808\uC774\uD134\uC2DC : ${BOLD}p50=${s1P50}ms | p95=${s1P95}ms | p99=${s1P99}ms${RESET} (\uBAA9\uD45C: p50\u2264${sloP50Ms}ms, p99\u2264${sloP99Ms}ms)
+`);
+  log(`  \u2022 \uD1A0\uD070 \uC808\uAC10\uB960        : ${BOLD}${GREEN}${lastResonance.tokenDietSavingsRatio}${RESET} (${lastResonance.matchedCount}/${config.ruleScale}\uAC1C\uB9CC \uC815\uBC00 \uACF5\uBA85)
+`);
+  log(`  \u2022 \uD310\uC815               : ${s1Passed ? `${BOLD}${GREEN}\u2705 PASS${RESET}` : `${BOLD}${RED}\u274C FAIL${RESET}`}
+
+`);
+  log(`${BOLD}${YELLOW}\uD83D\uDCCC [\uC2DC\uB098\uB9AC\uC624 2] \uB3D9\uC2DC ${config.concurrency} \uD074\uB77C\uC774\uC5B8\uD2B8 \xD7 ${config.totalRequests.toLocaleString()}\uD68C HTTP/MCP \uB370\uBAAC \uD3ED\uACA9 \uD14C\uC2A4\uD2B8${RESET}
+`);
+  const benchPort = 4288;
+  const server = startCausalServer({ port: benchPort });
+  let successCount = 0;
+  let errorCount = 0;
+  const httpLatencies = [];
+  const requestsPerWorker = Math.floor(config.totalRequests / config.concurrency);
+  for (let w = 0;w < 10; w++) {
+    await fetch(`http://127.0.0.1:${benchPort}/query`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ keywords: ["poe2"], format: "compact" })
+    });
+  }
+  const concStart = performance.now();
+  try {
+    const workerPromises = Array.from({ length: config.concurrency }, async (_, workerId) => {
+      const sampleQueries = [
+        { keywords: ["poe2", "updater"], format: "compact" },
+        { files: ["crates/vesper-audio-core/src/lib.rs"], format: "compact" },
+        { keywords: ["synapse", "causal"], format: "compact" },
+        { keywords: ["pcb", "kicad"], format: "compact" }
+      ];
+      for (let r = 0;r < requestsPerWorker; r++) {
+        const qPayload = sampleQueries[(workerId + r) % sampleQueries.length];
+        const reqT0 = performance.now();
+        try {
+          const resp = await fetch(`http://127.0.0.1:${benchPort}/query`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(qPayload)
+          });
+          if (resp.ok) {
+            await resp.text();
+            successCount++;
+          } else {
+            errorCount++;
+          }
+        } catch {
+          errorCount++;
+        }
+        httpLatencies.push(performance.now() - reqT0);
+      }
+    });
+    await Promise.all(workerPromises);
+  } finally {
+    server.stop();
+  }
+  const concTotalSec = (performance.now() - concStart) / 1000;
+  const rps = Math.round(successCount / concTotalSec);
+  httpLatencies.sort((a, b) => a - b);
+  const s2P50 = calcPercentile(httpLatencies, 50);
+  const s2P95 = calcPercentile(httpLatencies, 95);
+  const s2P99 = calcPercentile(httpLatencies, 99);
+  const s2Passed = errorCount === 0 && successCount === config.totalRequests && rps >= sloRps;
+  scenarios.push({
+    name: "\uC2DC\uB098\uB9AC\uC624 2: \uACE0\uB3D9\uC2DC\uC131 \uB370\uBAAC \uCC98\uB9AC\uB7C9",
+    passed: s2Passed,
+    details: {
+      concurrency: config.concurrency,
+      totalRequests: config.totalRequests,
+      successCount,
+      errorCount,
+      durationSec: Math.round(concTotalSec * 100) / 100,
+      rps,
+      httpP50Ms: s2P50,
+      httpP95Ms: s2P95,
+      httpP99Ms: s2P99
+    }
+  });
+  log(`  \u2022 \uCD1D \uCC98\uB9AC \uC694\uCCAD       : ${BOLD}${GREEN}${successCount.toLocaleString()} / ${config.totalRequests.toLocaleString()} \uC131\uACF5${RESET} (\uC624\uB958\uC728: ${errorCount === 0 ? "0.00%" : errorCount})
+`);
+  log(`  \u2022 \uCD08\uB2F9 \uCC98\uB9AC\uB7C9 (RPS)  : ${BOLD}${CYAN}${rps.toLocaleString()} req/sec${RESET} (\uCD1D \uC18C\uC694: ${concTotalSec.toFixed(2)}s, \uBAA9\uD45C: \u2265${sloRps.toLocaleString()} req/s)
+`);
+  log(`  \u2022 HTTP \uC655\uBCF5 \uB808\uC774\uD134\uC2DC : ${BOLD}p50=${s2P50}ms | p95=${s2P95}ms | p99=${s2P99}ms${RESET}
+`);
+  log(`  \u2022 \uD310\uC815               : ${s2Passed ? `${BOLD}${GREEN}\u2705 PASS${RESET}` : `${BOLD}${RED}\u274C FAIL${RESET}`}
+
+`);
+  log(`${BOLD}${YELLOW}\uD83D\uDCCC [\uC2DC\uB098\uB9AC\uC624 3] ${config.fileInputScale.toLocaleString()}\uAC1C \uBCC0\uACBD \uD30C\uC77C \uB3D9\uC2DC \uC785\uB825 & 5-Hop \uB2E4\uC911 \uCCB4\uC778/\uC21C\uD658 \uCC38\uC870 \uC2A4\uD2B8\uB808\uC2A4${RESET}
+`);
+  const massiveFiles = [];
+  for (let f = 0;f < config.fileInputScale; f++) {
+    massiveFiles.push(`services/microservice_${f % 100}/src/handler_${f}.ts`);
+  }
+  massiveFiles[Math.floor(config.fileInputScale / 2)] = "packages/mod_10/src/file_10.rs";
+  const hopStart = performance.now();
+  const multiHopRes = scaleStore.queryResonance({
+    files: massiveFiles,
+    propagateRelations: true,
+    maxHops: 5
+  });
+  const hopDurationMs = Math.round((performance.now() - hopStart) * 100) / 100;
+  const matchedTitles = new Set(multiHopRes.resonanceRules.map((r) => r.title));
+  const all5HopsPropagated = matchedTitles.has("Synth_Node_10") && matchedTitles.has("Synth_Node_11") && matchedTitles.has("Synth_Node_12") && matchedTitles.has("Synth_Node_13") && matchedTitles.has("Synth_Node_14") && matchedTitles.has("Synth_Node_15");
+  const s3Passed = all5HopsPropagated && hopDurationMs <= sloHopMs;
+  scenarios.push({
+    name: "\uC2DC\uB098\uB9AC\uC624 3: \uB300\uADDC\uBAA8 \uD30C\uC77C & 5-Hop \uB2E4\uC911 \uC778\uACFC \uC804\uD30C",
+    passed: s3Passed,
+    details: {
+      inputFilesCount: config.fileInputScale,
+      maxHops: 5,
+      traversalDurationMs: hopDurationMs,
+      matchedRulesCount: multiHopRes.matchedCount,
+      activeRelationsCount: multiHopRes.activeRelations.length,
+      all5HopsResolved: all5HopsPropagated ? "YES (Circular Loop Safe)" : "NO",
+      tokenSavings: multiHopRes.tokenDietSavingsRatio
+    }
+  });
+  log(`  \u2022 \uB300\uB7C9 \uD30C\uC77C + 5-Hop \uC18C\uC694 : ${BOLD}${GREEN}${hopDurationMs}ms${RESET} (\uBAA9\uD45C: \u2264${sloHopMs}ms)
+`);
+  log(`  \u2022 5\uB2E8\uACC4 \uC5F0\uC1C4 \uC804\uD30C \uAC80\uC99D  : ${BOLD}${all5HopsPropagated ? `${GREEN}Node_10 \u2794 Node_15 (5-Hop) \uBC0F \uC21C\uD658 \uCC38\uC870 \uBC29\uC5B4 100% \uC131\uACF5` : `${RED}\uC2E4\uD328`}${RESET}
+`);
+  log(`  \u2022 \uC815\uBC00 \uACA9\uB9AC \uC808\uAC10\uB960      : ${BOLD}${GREEN}${multiHopRes.tokenDietSavingsRatio}${RESET} (${multiHopRes.matchedCount}/${config.ruleScale}\uAC1C\uB9CC \uD65C\uC131\uD654)
+`);
+  log(`  \u2022 \uD310\uC815                  : ${s3Passed ? `${BOLD}${GREEN}\u2705 PASS${RESET}` : `${BOLD}${RED}\u274C FAIL${RESET}`}
+
+`);
+  log(`${BOLD}${YELLOW}\uD83D\uDCCC [\uC2DC\uB098\uB9AC\uC624 4] ${config.crudIterations.toLocaleString()}\uD68C \uC5F0\uC18D CRUD \uD2B8\uB79C\uC7AD\uC158 & \uD799 \uBA54\uBAA8\uB9AC \uB204\uC218 \uAC10\uC0AC (Zero-Leak Audit)${RESET}
+`);
+  if (typeof Bun !== "undefined" && typeof Bun.gc === "function") {
+    Bun.gc(true);
+  }
+  const baseMem = process.memoryUsage();
+  const baseHeapMB = baseMem.heapUsed / (1024 * 1024);
+  const crudStore = new CausalMemoryStore(undefined, {
+    version: "2.1.0",
+    updatedAt: new Date().toISOString(),
+    totalRules: 0,
+    totalRelations: 0,
+    rules: [],
+    relations: []
+  });
+  const crudStart = performance.now();
+  for (let c = 0;c < config.crudIterations; c++) {
+    const tempName = `Ephemeral_Entity_${c % 50}`;
+    crudStore.createEntities([
+      {
+        name: tempName,
+        entityType: "StressTest",
+        observations: [`\uC808\uB300 \uADDC\uCE59 #${c}`, `1. \uC2E4\uD589 \uB2E8\uACC4 #${c}`]
+      }
+    ], false);
+    crudStore.addObservations([{ entityName: tempName, contents: [`\uCD94\uAC00 \uAD00\uCC30 #${c}`] }], false);
+    crudStore.queryResonance({ keywords: [tempName] });
+    crudStore.deleteEntities([tempName], false);
+  }
+  const crudDurationMs = Math.round((performance.now() - crudStart) * 100) / 100;
+  if (typeof Bun !== "undefined" && typeof Bun.gc === "function") {
+    Bun.gc(true);
+  }
+  const afterMem = process.memoryUsage();
+  const afterHeapMB = afterMem.heapUsed / (1024 * 1024);
+  const rssMB = Math.round(afterMem.rss / (1024 * 1024) * 100) / 100;
+  const heapDeltaMB = Math.round(Math.max(0, afterHeapMB - baseHeapMB) * 100) / 100;
+  const s4Passed = heapDeltaMB <= sloHeapDeltaMB && crudStore.getAllRules().length === 0;
+  scenarios.push({
+    name: "\uC2DC\uB098\uB9AC\uC624 4: \uC5F0\uC18D CRUD \uB0B4\uAD6C\uB3C4 \uBC0F \uD799 \uB204\uC218 \uAC10\uC0AC",
+    passed: s4Passed,
+    details: {
+      crudCycles: config.crudIterations,
+      totalOperations: config.crudIterations * 4,
+      durationMs: crudDurationMs,
+      baseHeapMB: Math.round(baseHeapMB * 100) / 100,
+      afterHeapMB: Math.round(afterHeapMB * 100) / 100,
+      heapDeltaMB,
+      rssMB,
+      residualRules: crudStore.getAllRules().length
+    }
+  });
+  log(`  \u2022 \uCD1D \uC218\uD589 \uC5F0\uC0B0 \uC218    : ${BOLD}${(config.crudIterations * 4).toLocaleString()}\uD68C CRUD \uC5F0\uC0B0${RESET} (\uC18C\uC694: ${crudDurationMs}ms)
+`);
+  log(`  \u2022 \uD799 \uBA54\uBAA8\uB9AC \uBCC0\uD654\uB7C9   : ${BOLD}${GREEN}\u0394 ${heapDeltaMB} MB${RESET} (\uC2DC\uC791: ${baseHeapMB.toFixed(2)}MB \u2794 \uC885\uB8CC: ${afterHeapMB.toFixed(2)}MB, \uBAA9\uD45C: \u2264${sloHeapDeltaMB.toFixed(1)}MB)
+`);
+  log(`  \u2022 \uD504\uB85C\uC138\uC2A4 RSS \uC810\uC720  : ${BOLD}${rssMB} MB${RESET}
+`);
+  log(`  \u2022 \uD310\uC815               : ${s4Passed ? `${BOLD}${GREEN}\u2705 PASS${RESET}` : `${BOLD}${RED}\u274C FAIL${RESET}`}
+
+`);
+  const totalDurationMs = Math.round((performance.now() - benchStart) * 100) / 100;
+  const allPassed = scenarios.every((s) => s.passed);
+  log(`${GRAY}${"\u2501".repeat(84)}${RESET}
+`);
+  log(`${BOLD}${allPassed ? GREEN : RED}\uD83C\uDFC6 [\uCD5C\uC885 \uBCA4\uCE58\uB9C8\uD06C \uACB0\uACFC] 4\uB300 \uACFC\uBD80\uD558 \uCC28\uC6D0 \uC804\uC218 ${allPassed ? "ALL PASS (100% \uD569\uACA9)" : "\uC77C\uBD80 \uBBF8\uB2EC"} (\uCD1D \uC18C\uC694 \uC2DC\uAC04: ${(totalDurationMs / 1000).toFixed(2)}s)${RESET}
+
+`);
+  return {
+    timestamp: new Date().toISOString(),
+    config,
+    allPassed,
+    totalDurationMs,
+    scenarios
+  };
+}
+export {
+  CAUSAL_MCP_TOOLS,
+  CAUSAL_MEMORY_CONFIG,
+  CausalBranchStore,
+  CausalGraveyardStore,
+  CausalMemoryStore,
+  CausalObsidianLensEngine,
+  CausalPredictorEngine,
+  CausalSynthesizerEngine,
+  CausalTimeSeriesEngine,
+  ContextCheckpointStore,
+  detectGitHeadInfo,
+  detectModifiedFiles,
+  executeOverloadBenchmark,
+  formatResonanceForAgent,
+  generateSyntheticDatabase,
+  handleMcpJsonRpcRequest,
+  migrateLegacyMemoryGraph,
+  runCausalQuery,
+  startCausalMcpStdioServer,
+  startCausalServer
+};