synapse-kit 0.0.0-stage → 0.3.1

package/dist/cli.js

@@ -0,0 +1,3474 @@
+#!/usr/bin/env bun
+// @bun
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// src/memory/causal-config.ts
+import { homedir } from "os";
+import { resolve as resolve4 } from "path";
+var CAUSAL_MEMORY_CONFIG;
+var init_causal_config = __esm(() => {
+  CAUSAL_MEMORY_CONFIG = {
+    SCHEMA_VERSION: process.env.SYNAPSE_MEMORY_VERSION || "2.1.0",
+    GLOBAL_DB_PATH: process.env.SYNAPSE_MEMORY_PATH || resolve4(homedir(), ".gemini", "antigravity", "causal_memory.json"),
+    LEGACY_BACKUP_PATH: process.env.SYNAPSE_MEMORY_BACKUP_PATH || resolve4(homedir(), ".gemini", "antigravity", "memory_backup_20261101.json"),
+    LOCAL_DB_PATH: resolve4(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),
+    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)
+  };
+});
+
+// src/memory/causal-store.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, statSync as statSync2 } 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 || (existsSync4(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 (!existsSync4(this.dbPath))
+        return false;
+      const stat = statSync2(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);
+      }
+    }
+  }
+  loadDatabase() {
+    try {
+      if (existsSync4(this.dbPath)) {
+        const stat = statSync2(this.dbPath);
+        this.lastMtimeMs = stat.mtimeMs;
+        const raw = readFileSync2(this.dbPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const rules = Array.isArray(parsed.rules) ? parsed.rules : [];
+        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 (!existsSync4(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+      const serialized = JSON.stringify(this.database, null, 2);
+      writeFileSync2(this.dbPath, serialized, "utf-8");
+      this.lastMtimeMs = statSync2(this.dbPath).mtimeMs;
+      if (this.dbPath === CAUSAL_MEMORY_CONFIG.GLOBAL_DB_PATH && existsSync4(dirname(CAUSAL_MEMORY_CONFIG.LOCAL_DB_PATH))) {
+        writeFileSync2(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);
+              if (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) || 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 existingIndex = this.database.rules.findIndex((r) => r.id === rule.id || r.title.toLowerCase() === rule.title.toLowerCase());
+    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;
+  }
+  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 = 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;
+    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);
+      }
+      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
+    };
+  }
+}
+var init_causal_store = __esm(() => {
+  init_causal_config();
+});
+
+// src/memory/causal-query.ts
+var {spawn: spawn3 } = globalThis.Bun;
+async function detectModifiedFiles(cwd = process.cwd()) {
+  try {
+    const gitProc = spawn3(["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(`
+`);
+}
+var init_causal_query = __esm(() => {
+  init_causal_config();
+  init_causal_store();
+});
+
+// src/memory/causal-server.ts
+import { createInterface } from "readline";
+async function handleMcpJsonRpcRequest(rpc, store, dbPath) {
+  const { id, method, params } = rpc;
+  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();
+    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));
+          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();
+          payloadText = JSON.stringify({ ...audit, status }, null, 2);
+          break;
+        }
+        case "read_graph": {
+          const gitFiles = await detectModifiedFiles();
+          const smartGraph = store.readSmartGraph(gitFiles);
+          payloadText = JSON.stringify(smartGraph, 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;
+        }
+        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 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 === "/mcp" && req.method === "POST") {
+          const rpc = await req.json();
+          const responseObj = await handleMcpJsonRpcRequest(rpc, store, options.dbPath);
+          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) {
+  const store = new CausalMemoryStore(dbPath);
+  const daemonUrl = `http://${CAUSAL_MEMORY_CONFIG.DEFAULT_HOST}:${CAUSAL_MEMORY_CONFIG.DEFAULT_PORT}/mcp`;
+  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(daemonUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: trimmed,
+            signal: AbortSignal.timeout(150)
+          });
+          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) + `
+`);
+    }
+  }
+}
+var CAUSAL_MCP_TOOLS;
+var init_causal_server = __esm(() => {
+  init_causal_config();
+  init_causal_store();
+  init_causal_query();
+  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" }
+              }
+            }
+          }
+        }
+      }
+    }
+  ];
+});
+
+// src/memory/causal-benchmark.ts
+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(`
+${BOLD3}${CYAN3}\uD83D\uDD25 [Causal Memory 2.1] ${modeTitle} \uAC00\uB3D9${RESET3}
+`);
+  log(`${GRAY3}\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${RESET3}
+`);
+  log(`${GRAY3}${"\u2501".repeat(84)}${RESET3}
+
+`);
+  log(`${BOLD3}${YELLOW3}\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${RESET3}
+`);
+  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 : ${BOLD3}${GREEN3}${indexBuildMs}ms${RESET3} (${config.ruleScale.toLocaleString()} Rules + ${config.relationScale.toLocaleString()} Relations)
+`);
+  log(`  \u2022 \uACF5\uBA85 \uCFFC\uB9AC \uB808\uC774\uD134\uC2DC : ${BOLD3}p50=${s1P50}ms | p95=${s1P95}ms | p99=${s1P99}ms${RESET3} (\uBAA9\uD45C: p50\u2264${sloP50Ms}ms, p99\u2264${sloP99Ms}ms)
+`);
+  log(`  \u2022 \uD1A0\uD070 \uC808\uAC10\uB960        : ${BOLD3}${GREEN3}${lastResonance.tokenDietSavingsRatio}${RESET3} (${lastResonance.matchedCount}/${config.ruleScale}\uAC1C\uB9CC \uC815\uBC00 \uACF5\uBA85)
+`);
+  log(`  \u2022 \uD310\uC815               : ${s1Passed ? `${BOLD3}${GREEN3}\u2705 PASS${RESET3}` : `${BOLD3}${RED3}\u274C FAIL${RESET3}`}
+
+`);
+  log(`${BOLD3}${YELLOW3}\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${RESET3}
+`);
+  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       : ${BOLD3}${GREEN3}${successCount.toLocaleString()} / ${config.totalRequests.toLocaleString()} \uC131\uACF5${RESET3} (\uC624\uB958\uC728: ${errorCount === 0 ? "0.00%" : errorCount})
+`);
+  log(`  \u2022 \uCD08\uB2F9 \uCC98\uB9AC\uB7C9 (RPS)  : ${BOLD3}${CYAN3}${rps.toLocaleString()} req/sec${RESET3} (\uCD1D \uC18C\uC694: ${concTotalSec.toFixed(2)}s, \uBAA9\uD45C: \u2265${sloRps.toLocaleString()} req/s)
+`);
+  log(`  \u2022 HTTP \uC655\uBCF5 \uB808\uC774\uD134\uC2DC : ${BOLD3}p50=${s2P50}ms | p95=${s2P95}ms | p99=${s2P99}ms${RESET3}
+`);
+  log(`  \u2022 \uD310\uC815               : ${s2Passed ? `${BOLD3}${GREEN3}\u2705 PASS${RESET3}` : `${BOLD3}${RED3}\u274C FAIL${RESET3}`}
+
+`);
+  log(`${BOLD3}${YELLOW3}\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${RESET3}
+`);
+  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 : ${BOLD3}${GREEN3}${hopDurationMs}ms${RESET3} (\uBAA9\uD45C: \u2264${sloHopMs}ms)
+`);
+  log(`  \u2022 5\uB2E8\uACC4 \uC5F0\uC1C4 \uC804\uD30C \uAC80\uC99D  : ${BOLD3}${all5HopsPropagated ? `${GREEN3}Node_10 \u2794 Node_15 (5-Hop) \uBC0F \uC21C\uD658 \uCC38\uC870 \uBC29\uC5B4 100% \uC131\uACF5` : `${RED3}\uC2E4\uD328`}${RESET3}
+`);
+  log(`  \u2022 \uC815\uBC00 \uACA9\uB9AC \uC808\uAC10\uB960      : ${BOLD3}${GREEN3}${multiHopRes.tokenDietSavingsRatio}${RESET3} (${multiHopRes.matchedCount}/${config.ruleScale}\uAC1C\uB9CC \uD65C\uC131\uD654)
+`);
+  log(`  \u2022 \uD310\uC815                  : ${s3Passed ? `${BOLD3}${GREEN3}\u2705 PASS${RESET3}` : `${BOLD3}${RED3}\u274C FAIL${RESET3}`}
+
+`);
+  log(`${BOLD3}${YELLOW3}\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)${RESET3}
+`);
+  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    : ${BOLD3}${(config.crudIterations * 4).toLocaleString()}\uD68C CRUD \uC5F0\uC0B0${RESET3} (\uC18C\uC694: ${crudDurationMs}ms)
+`);
+  log(`  \u2022 \uD799 \uBA54\uBAA8\uB9AC \uBCC0\uD654\uB7C9   : ${BOLD3}${GREEN3}\u0394 ${heapDeltaMB} MB${RESET3} (\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  : ${BOLD3}${rssMB} MB${RESET3}
+`);
+  log(`  \u2022 \uD310\uC815               : ${s4Passed ? `${BOLD3}${GREEN3}\u2705 PASS${RESET3}` : `${BOLD3}${RED3}\u274C FAIL${RESET3}`}
+
+`);
+  const totalDurationMs = Math.round((performance.now() - benchStart) * 100) / 100;
+  const allPassed = scenarios.every((s) => s.passed);
+  log(`${GRAY3}${"\u2501".repeat(84)}${RESET3}
+`);
+  log(`${BOLD3}${allPassed ? GREEN3 : RED3}\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)${RESET3}
+
+`);
+  return {
+    timestamp: new Date().toISOString(),
+    config,
+    allPassed,
+    totalDurationMs,
+    scenarios
+  };
+}
+var RESET3 = "\x1B[0m", BOLD3 = "\x1B[1m", CYAN3 = "\x1B[36m", GREEN3 = "\x1B[32m", YELLOW3 = "\x1B[33m", RED3 = "\x1B[31m", GRAY3 = "\x1B[90m";
+var init_causal_benchmark = __esm(() => {
+  init_causal_store();
+  init_causal_server();
+});
+
+// src/cli.ts
+import { resolve as resolve5 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { writeFile } from "fs/promises";
+// package.json
+var package_default = {
+  name: "synapse-kit",
+  version: "0.2.2",
+  private: false,
+  publishConfig: {
+    access: "public"
+  },
+  description: "AI-Native Unified Compiler, Linter & Verification Framework for Tauri and Full-Stack Apps",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    synapse: "./dist/cli.js",
+    "synapse-kit": "./dist/cli.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "README.ko.md",
+    "LICENSE"
+  ],
+  scripts: {
+    "build:bundle": "bun build src/cli.ts --outfile dist/cli.js --target bun && bun build src/index.ts --outfile dist/index.js --target bun",
+    "build:types": "tsc -p tsconfig.build.json",
+    build: "bun run build:bundle && bun run build:types",
+    prepublishOnly: "bun run build",
+    start: "bun run src/cli.ts",
+    check: "bun run src/cli.ts check",
+    test: "bun test"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/minseokk77/synapse-kit.git"
+  },
+  homepage: "https://github.com/minseokk77/synapse-kit#readme",
+  bugs: {
+    url: "https://github.com/minseokk77/synapse-kit/issues"
+  },
+  keywords: [
+    "tauri",
+    "compiler",
+    "verification",
+    "rust",
+    "svelte",
+    "typescript",
+    "ai-native",
+    "bun"
+  ],
+  author: "Vesper",
+  license: "MIT",
+  devDependencies: {
+    "@types/bun": "^1.4.4",
+    typescript: "^5.6.3"
+  }
+};
+
+// src/core/config.ts
+import { resolve } from "path";
+import { existsSync } from "fs";
+var CONFIG_FILENAMES = [
+  "synapse.config.ts",
+  "synapse.config.js",
+  "synapse.config.mjs"
+];
+async function loadSynapseConfig(targetDir = process.cwd()) {
+  for (const filename of CONFIG_FILENAMES) {
+    const candidate = resolve(targetDir, filename);
+    if (existsSync(candidate)) {
+      try {
+        const imported = await import(candidate);
+        const config = imported.default || imported;
+        return {
+          config: {
+            ...config,
+            rootDir: config.rootDir ? resolve(targetDir, config.rootDir) : targetDir
+          },
+          configPath: candidate
+        };
+      } catch (error) {
+        throw new Error(`\uC124\uC815 \uD30C\uC77C(${candidate}) \uB85C\uB529 \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  throw new Error(`\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8(${targetDir})\uC5D0\uC11C synapse.config.ts \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.
+` + `'synapse init' \uBA85\uB839\uC5B4\uB97C \uC2E4\uD589\uD558\uC5EC \uAE30\uBCF8 \uC124\uC815 \uD30C\uC77C\uC744 \uC0DD\uC131\uD574 \uC8FC\uC138\uC694.`);
+}
+
+// src/core/engine.ts
+var {spawn: spawn2 } = globalThis.Bun;
+import { existsSync as existsSync3, readdirSync, watch } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/memory/causal-build.ts
+var {spawn } = globalThis.Bun;
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync, statSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { createHash } from "crypto";
+function loadBuildCache(rootDir) {
+  const cacheFile = resolve2(rootDir, ".synapse/build-cache.json");
+  try {
+    if (existsSync2(cacheFile)) {
+      const content = readFileSync(cacheFile, "utf-8");
+      const parsed = JSON.parse(content);
+      return {
+        lastVerifiedHead: parsed.lastVerifiedHead,
+        tracks: parsed.tracks || {},
+        sign: parsed.sign
+      };
+    }
+  } catch {}
+  return { tracks: {} };
+}
+function saveBuildCache(rootDir, cache) {
+  const cacheDir = resolve2(rootDir, ".synapse");
+  const cacheFile = resolve2(cacheDir, "build-cache.json");
+  try {
+    if (!existsSync2(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
+    }
+    writeFileSync(cacheFile, JSON.stringify(cache, null, 2), "utf-8");
+  } catch {}
+}
+async function getGitState(rootDir) {
+  try {
+    const rootProc = spawn(["git", "rev-parse", "--show-toplevel"], { cwd: rootDir, stdout: "pipe" });
+    const repoRoot = (await new Response(rootProc.stdout).text()).trim().replaceAll("\\", "/");
+    await rootProc.exited;
+    const headProc = spawn(["git", "rev-parse", "HEAD"], { cwd: rootDir, stdout: "pipe" });
+    const head = (await new Response(headProc.stdout).text()).trim();
+    await headProc.exited;
+    const statusProc = spawn(["git", "status", "--porcelain", "-uall"], { cwd: rootDir, stdout: "pipe" });
+    const statusText = await new Response(statusProc.stdout).text();
+    await statusProc.exited;
+    const modifiedFiles = statusText.split(`
+`).map((line) => line.slice(3).trim().replaceAll("\\", "/")).filter((line) => line.length > 0 && !line.startsWith(".synapse/") && !line.includes("/.synapse/"));
+    return { head, modifiedFiles, repoRoot: repoRoot || rootDir };
+  } catch {
+    return { head: "unknown", modifiedFiles: [], repoRoot: rootDir };
+  }
+}
+function shouldSkipBuildTrack(track, rootDir, repoRoot, cache, modifiedFiles, isForce) {
+  if (isForce) {
+    return { skip: false, reason: "\uAC15\uC81C \uBE4C\uB4DC \uBAA8\uB4DC(--force)" };
+  }
+  const artifacts = track.artifacts || [];
+  if (artifacts.length > 0) {
+    for (const art of artifacts) {
+      const fullPath = resolve2(track.cwd || rootDir, art);
+      if (!existsSync2(fullPath)) {
+        return { skip: false, reason: `\uC0B0\uCD9C\uBB3C \uB204\uB77D: ${art}` };
+      }
+    }
+  }
+  const record = cache.tracks[track.name];
+  if (!record) {
+    return { skip: false, reason: "\uCD08\uAE30 \uBE4C\uB4DC \uAE30\uB85D \uC5C6\uC74C" };
+  }
+  const sources = track.sources || [];
+  if (sources.length > 0) {
+    const lastBuildEpoch = new Date(record.lastBuildTime).getTime();
+    const hasModifiedSource = modifiedFiles.some((file) => {
+      const isMatch = sources.some((src) => file.includes(src.replaceAll("\\", "/")));
+      if (!isMatch)
+        return false;
+      const fullPath = resolve2(repoRoot, file);
+      if (existsSync2(fullPath)) {
+        try {
+          const stat = statSync(fullPath);
+          return stat.mtimeMs > lastBuildEpoch;
+        } catch {
+          return true;
+        }
+      }
+      return true;
+    });
+    if (hasModifiedSource) {
+      return { skip: false, reason: "\uB9C8\uC9C0\uB9C9 \uBE4C\uB4DC \uC774\uD6C4 \uC18C\uC2A4 \uCF54\uB4DC \uBCC0\uACBD \uAC10\uC9C0" };
+    }
+  }
+  return { skip: true, reason: "\uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uC77C\uCE58 (\uC18C\uC2A4 \uBCC0\uACBD \uC5C6\uC74C)" };
+}
+function computeFileHash(filePath) {
+  try {
+    const buffer = readFileSync(filePath);
+    return createHash("sha256").update(buffer).digest("hex");
+  } catch {
+    return "";
+  }
+}
+function shouldSkipSign(installerPath, signaturePath, cache, isForce) {
+  if (isForce) {
+    return { skip: false, reason: "\uAC15\uC81C \uC11C\uBA85 \uBAA8\uB4DC(--force)", currentHash: "" };
+  }
+  if (!existsSync2(installerPath)) {
+    return { skip: false, reason: "\uC11C\uBA85 \uB300\uC0C1 \uC778\uC2A4\uD1A8\uB7EC \uBBF8\uC874\uC7AC", currentHash: "" };
+  }
+  if (!existsSync2(signaturePath)) {
+    return { skip: false, reason: "\uAE30\uC874 \uC11C\uBA85(.sig) \uD30C\uC77C \uBBF8\uC874\uC7AC", currentHash: "" };
+  }
+  const currentHash = computeFileHash(installerPath);
+  if (!currentHash) {
+    return { skip: false, reason: "\uC778\uC2A4\uD1A8\uB7EC \uD574\uC2DC \uACC4\uC0B0 \uBD88\uAC00", currentHash: "" };
+  }
+  const record = cache.sign;
+  if (record && record.installerHash === currentHash && record.signaturePath === signaturePath) {
+    return { skip: true, reason: "\uC778\uC2A4\uD1A8\uB7EC \uBC14\uC774\uB108\uB9AC \uBD88\uBCC0 (\uC11C\uBA85 \uCE90\uC2DC \uC801\uC911)", currentHash };
+  }
+  return { skip: false, reason: "\uC778\uC2A4\uD1A8\uB7EC \uBC14\uC774\uB108\uB9AC \uBCC0\uACBD \uAC10\uC9C0", currentHash };
+}
+
+// src/i18n.ts
+var currentLocale = "en";
+var MESSAGES = {
+  ko: {
+    cliTitle: "\uD83E\uDDE0 Synapse Kit - AI-Native \uD1B5\uD569 \uCEF4\uD30C\uC77C, \uBE4C\uB4DC & \uD328\uD0A4\uC9D5 \uD504\uB808\uC784\uC6CC\uD06C",
+    cliUsage: "\uC0AC\uC6A9\uBC95:",
+    cliCommands: "\uD575\uC2EC \uBA85\uB839\uC5B4:",
+    cmdCheck: "\uB4F1\uB85D\uB41C \uD50C\uB7EC\uADF8\uC778 \uBB34\uACB0\uC131 \uAC80\uC99D (\uAE30\uBCF8: AI \uC778\uACFC\uC728 \uC2A4\uB9C8\uD2B8 \uAC80\uC0AC)",
+    cmdBuild: "\uB4F1\uB85D\uB41C buildTracks \uCD08\uACE0\uC18D \uC778\uACFC\uC728 \uBCD1\uB82C \uC99D\uBD84 \uBE4C\uB4DC (0\uCD08\uB300 \uCE90\uC2DC)",
+    cmdPackage: "\uB2E8\uC77C NSIS + zlib \uACE0\uC18D \uC778\uC2A4\uD1A8\uB7EC \uD328\uD0A4\uC9D5 \uBC88\uB4E4\uB7EC",
+    cmdSign: "\uC778\uACFC\uC728 \uC554\uD638\uD654 \uC11C\uBA85 \uC5D4\uC9C4 (Minisign / Ed25519)",
+    cmdInit: "\uD604\uC7AC \uB514\uB809\uD130\uB9AC\uC5D0 \uCD5C\uC801\uD654\uB41C synapse.config.ts \uC0DD\uC131",
+    cmdMemory: "\uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC(Causal Memory) \uCD08\uACBD\uB7C9 \uACF5\uBA85 \uC870\uD68C, \uAD00\uB9AC \uBC0F \uB85C\uCEEC \uB370\uBAAC \uAD6C\uB3D9",
+    cliOptions: "\uC635\uC158:",
+    optAll: "\uC778\uACFC\uC728 \uC2A4\uD0B5\uC744 \uB044\uACE0 \uC804\uBC29\uC704 \uAC15\uC81C \uAC80\uC0AC",
+    optForce: "\uBE4C\uB4DC/\uC11C\uBA85 \uC2DC \uC778\uACFC\uC728 \uCE90\uC2DC\uB97C \uBB34\uC2DC\uD558\uACE0 \uAC15\uC81C \uC7AC\uC2E4\uD589",
+    optAgent: "AI \uC5D0\uC774\uC804\uD2B8(Claude Code, Antigravity \uB4F1) \uC5F0\uB3D9\uC6A9 \uAD6C\uC870\uD654\uB41C JSON \uCD9C\uB825",
+    optCompact: "AI \uD1A0\uD070 \uADF9\uB2E8\uC801 \uCD5C\uC18C\uD654 \uBAA8\uB4DC (\uC131\uACF5 \uC2DC \uB2E8 11 \uD1A0\uD070)",
+    optInteractive: "\uC624\uB958 \uBC1C\uC0DD \uC2DC \uD504\uB85C\uC138\uC2A4\uB97C \uC77C\uC2DC\uC815\uC9C0\uD558\uACE0 \uC2E4\uC2DC\uAC04 \uCF54\uB4DC \uC218\uC815 \uB300\uAE30 (\uC778\uACFC \uD56B\uD53D\uC2A4)",
+    optWatch: "\uD30C\uC77C \uBCC0\uACBD \uAC10\uC9C0 \uBC31\uADF8\uB77C\uC6B4\uB4DC \uBAA8\uB4DC",
+    optLang: "\uCD9C\uB825 \uC5B8\uC5B4 \uAC15\uC81C \uC9C0\uC815 (ko | en)",
+    optHelp: "\uB3C4\uC6C0\uB9D0 \uD45C\uC2DC",
+    optVersion: "\uBC84\uC804 \uC815\uBCF4 \uD45C\uC2DC",
+    unknownCmd: "\uC54C \uC218 \uC5C6\uB294 \uBA85\uB839\uC5B4:",
+    errPrefix: "\uD83D\uDEA8 \uC624\uB958:",
+    configExists: "\uC774\uBBF8 \uC124\uC815 \uD30C\uC77C\uC774 \uC874\uC7AC\uD569\uB2C8\uB2E4:",
+    configCreated: "synapse.config.ts \uD15C\uD50C\uB9BF\uC774 \uC131\uACF5\uC801\uC73C\uB85C \uC0DD\uC131\uB418\uC5C8\uC2B5\uB2C8\uB2E4.",
+    checkHeader: "\uD83E\uDDE0 [Synapse Kit] AI-Native \uD1B5\uD569 \uCEF4\uD30C\uC77C & \uAC80\uC0AC \uD504\uB808\uC784\uC6CC\uD06C",
+    causalAll: "\uC804\uCCB4 \uAC80\uC0AC \uBAA8\uB4DC(--all) \uC694\uCCAD: \uBAA8\uB4E0 \uD50C\uB7EC\uADF8\uC778 \uAC80\uC0AC\uAE30\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4.",
+    causalDirty: (count, plugins) => `\uBCC0\uACBD\uB41C ${count}\uAC1C \uD30C\uC77C \uC778\uACFC \uBD84\uC11D \uC644\uB8CC: [${plugins}] \uD50C\uB7EC\uADF8\uC778\uB9CC \uC120\uBCC4 \uC2E4\uD589\uD569\uB2C8\uB2E4.`,
+    causalClean: "\uBCC0\uACBD\uB41C \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBAA8\uB4E0 \uAC80\uC99D \uD50C\uB7EC\uADF8\uC778\uC744 0.00\uCD08 \uC2A4\uD0B5\uD569\uB2C8\uB2E4.",
+    causalCleanCacheHit: "\uC791\uC5C5 \uD2B8\uB9AC\uC5D0 \uBCC0\uACBD \uD30C\uC77C\uC774 \uC5C6\uC73C\uBA70 \uC774\uC804 \uAC80\uC99D \uD1B5\uACFC \uCEE4\uBC0B\uACFC \uC77C\uCE58\uD558\uC5EC 0.00\uCD08 \uC2A4\uD0B5\uD569\uB2C8\uB2E4.",
+    causalBaseline: "\uC791\uC5C5 \uD2B8\uB9AC\uC5D0 \uBCC0\uACBD\uB41C \uD30C\uC77C\uC774 \uC5C6\uC5B4 \uC804\uCCB4 \uBCA0\uC774\uC2A4\uB77C\uC778 \uAC80\uC99D\uC744 \uC218\uD589\uD569\uB2C8\uB2E4.",
+    causalUnrelated: (count) => `\uBCC0\uACBD\uB41C ${count}\uAC1C \uD30C\uC77C\uC774 \uB4F1\uB85D\uB41C \uAC80\uC0AC \uD50C\uB7EC\uADF8\uC778\uC758 \uC601\uD5A5 \uBC94\uC704\uC5D0 \uC18D\uD558\uC9C0 \uC54A\uC544 \uC804\uCCB4 \uAC80\uC0AC\uB97C \uC2A4\uD0B5\uD569\uB2C8\uB2E4.`,
+    causalGitFail: "Git \uBCC0\uACBD \uCD94\uC801 \uBD88\uAC00\uB85C \uC548\uC804 \uBAA8\uB4DC(\uC804\uCCB4 \uAC80\uC0AC)\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4.",
+    checkPassed: "\uD1B5\uACFC",
+    checkSkipped: "\uC0DD\uB7B5 (\uC778\uACFC\uC728 0\uCD08 \uC2A4\uD0B5)",
+    checkFailed: "\uC2E4\uD328",
+    checkSuccessSummary: (errs, warns, skips, sec) => `\u2728 \uC2DC\uB0C5\uC2A4 \uAC80\uC99D \uC131\uACF5: ${errs} Errors, ${warns} Warnings, ${skips} Skipped (\uCD1D \uC18C\uC694 \uC2DC\uAC04: ${sec}\uCD08)`,
+    checkFailureSummary: (errs, warns, sec) => `\u274C \uC2DC\uB0C5\uC2A4 \uAC80\uC99D \uC2E4\uD328: ${errs}\uAC1C \uAC80\uC0AC\uAE30 \uC624\uB958 \uBC1C\uC0DD (\uCD1D \uC18C\uC694 \uC2DC\uAC04: ${sec}\uCD08)`,
+    interactivePause: "\u23F8\uFE0F  \uC5D0\uB7EC \uBC1C\uC0DD\uC73C\uB85C \uC77C\uC2DC\uC815\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uD30C\uC77C\uC744 \uC218\uC815\uD55C \uB4A4 \uC800\uC7A5\uD558\uBA74 0.05\uCD08 \uB9CC\uC5D0 \uD56B \uC7AC\uAC80\uC99D\uD569\uB2C8\uB2E4. (\uC885\uB8CC: Ctrl+C)",
+    interactiveReload: "\u26A1 \uD30C\uC77C \uBCC0\uACBD \uAC10\uC9C0! \uC778\uBA54\uBAA8\uB9AC \uD56B \uC7AC\uAC80\uC99D\uC744 \uC989\uC2DC \uAC00\uB3D9\uD569\uB2C8\uB2E4...",
+    interactiveTitle: "\u23F8\uFE0F  [\uB300\uD654\uD615 \uC778\uACFC \uD56B\uD53D\uC2A4 \uBAA8\uB4DC] \uC624\uB958 \uBC1C\uC0DD\uC73C\uB85C \uD504\uB85C\uC138\uC2A4\uB97C \uC77C\uC2DC\uC815\uC9C0\uD588\uC2B5\uB2C8\uB2E4.",
+    interactiveTarget: "\uB300\uC0C1 \uD50C\uB7EC\uADF8\uC778",
+    interactiveWatching: "\uAC10\uC2DC \uC0C1\uD0DC     : \uD83D\uDC40 \uC18C\uC2A4 \uCF54\uB4DC \uC218\uC815 \uB300\uAE30 \uC911... (\uC800\uC7A5 \uC2DC 0.05\uCD08 \uB9CC\uC5D0 \uD56B \uC7AC\uCEF4\uD30C\uC77C)",
+    interactiveExit: "\uC138\uC158 \uC885\uB8CC     : \uD130\uBBF8\uB110\uC5D0\uC11C Ctrl+C \uC785\uB825",
+    interactiveDetected: (time, file) => `\u26A1 [\uC800\uC7A5 \uAC10\uC9C0 ${time}] ${file} \uC218\uC815 \uAC10\uC9C0 \u279C \uD56B \uC7AC\uCEF4\uD30C\uC77C \uC2E4\uD589 \uC911...`,
+    interactivePassed: (sec) => `\u2728 [\uD56B \uC7AC\uCEF4\uD30C\uC77C \uD1B5\uACFC] (${sec}s) \uACB0\uD568\uC774 \uC644\uC804\uD788 \uD574\uACB0\uB418\uC5C8\uC2B5\uB2C8\uB2E4!`,
+    interactiveResumed: "\u25B6\uFE0F  [\uD30C\uC774\uD504\uB77C\uC778 \uC7AC\uAC1C] \uBAA8\uB4E0 \uAC80\uC99D \uD1B5\uACFC \uC644\uB8CC. \uD504\uB85C\uC138\uC2A4\uB97C \uC815\uC0C1 \uC885\uB8CC\uD569\uB2C8\uB2E4.",
+    interactiveFailed: "\u274C [\uC7AC\uAC80\uC99D \uC2E4\uD328] \uC5EC\uC804\uD788 \uC624\uB958\uAC00 \uB0A8\uC544\uC788\uC2B5\uB2C8\uB2E4. \uCF54\uB4DC\uB97C \uB2E4\uC2DC \uC218\uC815\uD558\uACE0 \uC800\uC7A5\uD574 \uC8FC\uC138\uC694.",
+    buildHeader: "\u26A1 [Synapse Build] \uC778\uACFC\uC728 \uBA40\uD2F0\uD2B8\uB799 \uBCD1\uB82C \uC99D\uBD84 \uBE4C\uB354",
+    buildSkipped: "\u23ED\uFE0F \uC18C\uC2A4 \uBBF8\uBCC0\uACBD \uAC10\uC9C0: 0.00\uCD08 \uC2A4\uD0B5",
+    buildSuccess: "\u2705 \uBE4C\uB4DC \uC644\uACB0",
+    buildFailed: "\u274C \uBE4C\uB4DC \uC2E4\uD328",
+    buildAllUpToDate: "\u2728 \uBAA8\uB4E0 \uBE4C\uB4DC \uD2B8\uB799\uC774 \uCD5C\uC2E0 \uC0C1\uD0DC\uC785\uB2C8\uB2E4. (\uC804\uCCB4 \uBE4C\uB4DC \uC0DD\uB7B5: 0.00\uCD08)",
+    buildComplete: (sec) => `\u2728 \uC804\uCCB4 \uC778\uACFC\uC728 \uC99D\uBD84 \uBE4C\uB4DC \uC644\uACB0 (\uCD1D \uC18C\uC694 \uC2DC\uAC04: ${sec}\uCD08)`,
+    packageHeader: "\uD83D\uDCE6 [Synapse Package] \uCD08\uACE0\uC18D \uC778\uC2A4\uD1A8\uB7EC \uBC88\uB4E4\uB7EC",
+    packageSuccess: (sec) => `\u2728 \uC778\uC2A4\uD1A8\uB7EC \uD328\uD0A4\uC9D5 \uC131\uACF5 (\uC18C\uC694 \uC2DC\uAC04: ${sec}\uCD08)`,
+    packageFailed: (sec) => `\u274C \uC778\uC2A4\uD1A8\uB7EC \uD328\uD0A4\uC9D5 \uC2E4\uD328 (\uC18C\uC694 \uC2DC\uAC04: ${sec}\uCD08)`,
+    signHeader: "\uD83D\uDD10 [Synapse Sign] \uC778\uACFC\uC728 \uC554\uD638\uD654 \uC11C\uBA85 \uD30C\uC774\uD504\uB77C\uC778",
+    signSkipped: "\u23ED\uFE0F \uC778\uC2A4\uD1A8\uB7EC \uBC14\uC774\uB108\uB9AC \uD574\uC2DC \uBD88\uBCC0: \uC11C\uBA85 0.00\uCD08 \uC2A4\uD0B5",
+    signSuccess: (sec) => `\u2728 \uC778\uC2A4\uD1A8\uB7EC Ed25519 \uB514\uC9C0\uD138 \uC11C\uBA85 \uBC1C\uD589 \uC644\uB8CC (\uC18C\uC694 \uC2DC\uAC04: ${sec}\uCD08)`,
+    signFailed: (sec) => `\u274C \uC11C\uBA85 \uC0DD\uC131 \uC2E4\uD328 (\uC18C\uC694 \uC2DC\uAC04: ${sec}\uCD08)`,
+    signNoConfig: "\u274C \uC11C\uBA85 \uC124\uC815(sign.privateKeyPath)\uC774 synapse.config.ts\uC5D0 \uC9C0\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.",
+    signNoKey: (p) => `\u274C \uC11C\uBA85 \uAC1C\uC778\uD0A4 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${p}`,
+    signNoInstaller: "\u274C \uC11C\uBA85 \uB300\uC0C1 \uC778\uC2A4\uD1A8\uB7EC(.exe) \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
+    signTarget: "\uB300\uC0C1 \uC778\uC2A4\uD1A8\uB7EC",
+    signStatus: "\uC11C\uBA85 \uC0C1\uD0DC",
+    signFile: "\uC11C\uBA85 \uD30C\uC77C",
+    signReasonLabel: "\uC11C\uBA85 \uC0AC\uC720",
+    signEngineLabel: "\uC11C\uBA85 \uC5D4\uC9C4",
+    signCacheHit: "\uC2A4\uD0B5 [\uC778\uACFC\uC728 \uCE90\uC2DC \uC801\uC911: \uBC14\uC774\uB108\uB9AC \uD574\uC2DC \uBD88\uBCC0]",
+    signExistingKeep: (p) => `\uAE30\uC874 \uC11C\uBA85 \uD30C\uC77C \uC720\uC9C0 (${p})`,
+    signIntegrityPass: "\u2728 \uC11C\uBA85 \uBB34\uACB0\uC131 \uD655\uC778 \uC644\uB8CC (0.00\uCD08)",
+    statusSuccess: "\uD1B5\uACFC",
+    statusSkipped: "\uC2A4\uD0B5 (\uC778\uACFC\uC728 \uC0DD\uB7B5)",
+    statusWarning: "\uACBD\uACE0",
+    statusError: "\uC2E4\uD328",
+    causalAnalysis: "\uC778\uACFC \uBA54\uBAA8\uB9AC \uBD84\uC11D",
+    trackSkipped: "\uC2A4\uD0B5 [\uC778\uACFC\uC728 \uCE90\uC2DC \uC801\uC911]",
+    trackComplete: "\uBE4C\uB4DC \uC644\uB8CC",
+    trackFailed: "\uBE4C\uB4DC \uC2E4\uD328",
+    noBuildTracks: "\u274C \uB4F1\uB85D\uB41C \uBE4C\uB4DC \uD2B8\uB799(buildTracks)\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. synapse.config.ts\uB97C \uD655\uC778\uD574 \uC8FC\uC138\uC694.",
+    buildSuccessSummary: (tracks, sec) => `\u2728 \uC778\uACFC\uC728 \uBCD1\uB82C \uBE4C\uB4DC \uC131\uACF5: \uC804\uCCB4 ${tracks}\uAC1C \uD2B8\uB799 \uC644\uB8CC (\uCD1D \uC18C\uC694 \uC2DC\uAC04: ${sec}\uCD08)`,
+    buildFailureSummary: "\uD83D\uDEA8 \uBCD1\uB82C \uBE4C\uB4DC \uC2E4\uD328: \uD558\uB098 \uC774\uC0C1\uC758 \uD2B8\uB799\uC5D0\uC11C \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.",
+    packagingPreBuild: "\u2139\uFE0F  \uC0AC\uC804 \uC544\uD2F0\uD329\uD2B8 \uC778\uACFC\uC728 \uBE4C\uB4DC \uD655\uC778 \uC911...",
+    packagingStart: "\uD83D\uDE80 Tauri \uC778\uC2A4\uD1A8\uB7EC \uBC88\uB4E4\uB9C1 \uC2DC\uC791...",
+    packagingGuide: `\u26A0\uFE0F  [\uD328\uD0A4\uC9D5 \uAC00\uC774\uB4DC] tauri.conf.json\uC758 targets\uAC00 "all"\uB85C \uC124\uC815\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.
+   \u21B3 WiX MSI \uC911\uBCF5 \uBE4C\uB4DC\uB85C \uC2DC\uAC04\uC774 \uC18C\uC694\uB429\uB2C8\uB2E4. targets: ["nsis"] \uC124\uC815\uC744 \uAD8C\uC7A5\uD569\uB2C8\uB2E4.`,
+    pluginRustTitle: "Rust \uBC31\uC5D4\uB4DC \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 (Check & Clippy)",
+    pluginRustSuccess: "Rust \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uCEF4\uD30C\uC77C \uBC0F Clippy \uBB34\uACB0\uC131 \uD655\uC778 \uC644\uB8CC (0 Warnings, 0 Errors)",
+    pluginRustClippyWarn: (count) => `\uCEF4\uD30C\uC77C \uD1B5\uACFC \uC644\uB8CC (${count}\uAC1C Clippy \uAD8C\uC7A5\uC0AC\uD56D \uAC10\uC9C0\uB428)`,
+    pluginRustCompileFail: "Rust \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uCEF4\uD30C\uC77C\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4.",
+    pluginRustExecFail: (msg) => `Rust \uAC80\uC0AC \uB3C4\uAD6C \uC2E4\uD589 \uC2E4\uD328: ${msg}`,
+    pluginSvelteTitle: "Svelte 5 & TypeScript (svelte-check)",
+    pluginSvelteSuccess: "Svelte 5 Runes \uBC0F TS \uD0C0\uC785 \uBB34\uACB0\uC131 \uAC80\uC99D \uC644\uB8CC (0 Errors, 0 Warnings)",
+    pluginSvelteError: "Svelte \uD15C\uD50C\uB9BF \uB610\uB294 TypeScript \uD0C0\uC785 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.",
+    pluginSvelteExecFail: (msg) => `Svelte \uAC80\uC0AC \uB3C4\uAD6C \uC2E4\uD589 \uC2E4\uD328: ${msg}`,
+    pluginJavaTitle: "Java \uC5D4\uD130\uD504\uB77C\uC774\uC988 \uCEF4\uD30C\uC77C\uB7EC (javac)",
+    pluginJavaSuccess: (count) => `Java ${count}\uAC1C \uC18C\uC2A4 \uD30C\uC77C \uBC14\uC774\uD2B8\uCF54\uB4DC \uCEF4\uD30C\uC77C \uBB34\uACB0\uC131 \uAC80\uC99D \uC644\uB8CC`,
+    pluginJavaNoFiles: "\uAC80\uC99D\uD560 Java \uC18C\uC2A4 \uD30C\uC77C(.java)\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+    pluginJavaError: "javac \uCEF4\uD30C\uC77C \uC2E4\uD328",
+    pluginCppTitle: "C/C++ \uB124\uC774\uD2F0\uBE0C \uCEE4\uB110 \uAC80\uC99D\uAE30 (g++/clang++)",
+    pluginCppSuccess: (count) => `C/C++ ${count}\uAC1C \uC18C\uC2A4 \uD30C\uC77C \uAD6C\uBB38 \uBC0F \uD5E4\uB354 \uBB34\uACB0\uC131 \uAC80\uC99D \uC644\uB8CC`,
+    pluginCppNoFiles: "\uAC80\uC99D\uD560 C/C++ \uC18C\uC2A4 \uD30C\uC77C\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+    pluginCppError: "C/C++ \uAD6C\uBB38 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.",
+    pluginCsharpTitle: "C# .NET \uC194\uB8E8\uC158 \uAC80\uC99D\uAE30 (dotnet build)",
+    pluginCsharpSuccess: "C# .NET \uD504\uB85C\uC81D\uD2B8 \uBE4C\uB4DC \uBC0F \uD0C0\uC785 \uBB34\uACB0\uC131 \uAC80\uC99D \uC644\uB8CC",
+    pluginCsharpError: "C# .NET \uBE4C\uB4DC \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.",
+    pluginGoTitle: "Go \uBC31\uC5D4\uB4DC \uD328\uD0A4\uC9C0 \uAC80\uC99D\uAE30 (go vet)",
+    pluginGoSuccess: "Go \uB3D9\uC2DC\uC131 \uB8E8\uD2F4 \uBC0F \uD328\uD0A4\uC9C0 \uC815\uC801 \uBD84\uC11D \uD1B5\uACFC",
+    pluginGoError: "Go \uC815\uC801 \uBD84\uC11D \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.",
+    pluginPythonTitle: "Python \uBC14\uC774\uD2B8\uCF54\uB4DC \uAC80\uC99D\uAE30 (py_compile)",
+    pluginPythonSuccess: (count) => `Python ${count}\uAC1C \uBAA8\uB4C8 \uBC14\uC774\uD2B8\uCF54\uB4DC \uBB34\uACB0\uC131 \uAC80\uC99D \uC644\uB8CC`,
+    pluginPythonNoFiles: "\uAC80\uC99D\uD560 Python \uC18C\uC2A4 \uD30C\uC77C\uC774 \uC874\uC7AC\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+    pluginPythonError: "Python \uAD6C\uBB38 \uBD84\uC11D \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.",
+    pluginTypescriptTitlePure: "\uC21C\uC218 TypeScript \uACF5\uC2DD \uCEF4\uD30C\uC77C\uB7EC (tsc)",
+    pluginTypescriptTitleNative: "TypeScript \uB124\uC774\uD2F0\uBE0C Rust Oxc (tsrs)",
+    pluginTypescriptSuccess: (mode) => `TypeScript \uD0C0\uC785 \uBB34\uACB0\uC131 \uAC80\uC99D \uC644\uB8CC (${mode})`,
+    pluginTypescriptError: "TypeScript \uD0C0\uC785 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.",
+    pluginSchemaTitle: "\uB370\uC774\uD130 \uBC0F \uC124\uC815 \uC2A4\uD0A4\uB9C8 \uBB34\uACB0\uC131 \uAC80\uC0AC",
+    pluginSchemaSuccess: (count) => `${count}\uAC1C \uC2A4\uD0A4\uB9C8/\uB370\uC774\uD130 \uD30C\uC77C \uC815\uC0C1 \uD655\uC778 \uC644\uB8CC`,
+    pluginSchemaParseFail: (path, err) => `${path} \uD30C\uC2F1 \uC2E4\uD328: ${err}`,
+    pluginNativeTitle: "\uB124\uC774\uD2F0\uBE0C \uBC14\uC774\uB108\uB9AC & \uC5D0\uC14B \uAC80\uC0AC",
+    pluginNativeSuccess: (count) => `${count}\uAC1C \uBC14\uC774\uB108\uB9AC \uBC0F \uB9AC\uC18C\uC2A4 \uBB34\uACB0\uC131 \uD655\uC778 \uC644\uB8CC`,
+    pluginNativeMissing: (path) => `\uD544\uC218 \uBC14\uC774\uB108\uB9AC\uAC00 \uB204\uB77D\uB418\uC5C8\uC2B5\uB2C8\uB2E4: ${path}`,
+    pluginNativeNotPe: (path) => `${path}: \uC62C\uBC14\uB978 PE \uD3EC\uB9F7(MZ \uC2DC\uADF8\uB2C8\uCC98 \uB204\uB77D)\uC774 \uC544\uB2D9\uB2C8\uB2E4.`,
+    pluginNativeInvalidPe: (path) => `${path}: \uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 PE \uC2DC\uADF8\uB2C8\uCC98\uC785\uB2C8\uB2E4.`,
+    pluginNativeInvalidArch: (path, code) => `${path}: 64\uBE44\uD2B8(x64) \uBC14\uC774\uB108\uB9AC\uAC00 \uC544\uB2D9\uB2C8\uB2E4 (\uBA38\uC2E0 \uCF54\uB4DC: 0x${code}).`,
+    pluginNsisTitle: "NSIS \uC778\uC2A4\uD1A8\uB7EC \uD15C\uD50C\uB9BF \uAD6C\uBB38 \uAC80\uC0AC",
+    pluginNsisSuccess: (path) => `${path} \uAD6C\uBB38 \uBC0F \uD544\uC218 \uC9C0\uC2DC\uBB38 \uD655\uC778 \uC644\uB8CC`,
+    pluginNsisMissing: (path) => `NSIS \uD15C\uD50C\uB9BF \uD30C\uC77C\uC774 \uB204\uB77D\uB418\uC5C8\uC2B5\uB2C8\uB2E4: ${path}`,
+    pluginNsisCorrupt: "NSIS \uD15C\uD50C\uB9BF \uD30C\uC77C \uB0B4\uC6A9\uC774 \uBE44\uC5B4 \uC788\uAC70\uB098 \uC190\uC0C1\uB418\uC5C8\uC2B5\uB2C8\uB2E4.",
+    pluginNsisDirectiveMissing: (dir) => `NSIS \uD544\uC218 \uC9C0\uC2DC\uBB38 \uB204\uB77D: '${dir}' \uAD6C\uBB38\uC774 \uBC1C\uACAC\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`
+  },
+  en: {
+    cliTitle: "\uD83E\uDDE0 Synapse Kit - AI-Native Unified Compiler, Build & Packaging Framework",
+    cliUsage: "Usage:",
+    cliCommands: "Core Commands:",
+    cmdCheck: "Run multi-track verification with AI causal smart skipping",
+    cmdBuild: "Fast incremental multi-track build (0.00s skip on unchanged sources)",
+    cmdPackage: "Single NSIS + zlib high-speed installer packager",
+    cmdSign: "Causal cryptographic signing engine (Minisign / Ed25519)",
+    cmdInit: "Generate optimized synapse.config.ts template in current directory",
+    cmdMemory: "Query, manage and serve zero-cost Causal Memory & Local Daemon",
+    cliOptions: "Options:",
+    optAll: "Disable causal skipping and force full verification",
+    optForce: "Ignore cache and force re-execution of build and signing",
+    optAgent: "Structured JSON output for AI coding agents (Claude, Cursor, Antigravity)",
+    optCompact: "Extreme token-diet mode for AI agents (only 11 tokens on pass)",
+    optInteractive: "Pause on error and wait for live code modification (0.05s live-fix)",
+    optWatch: "Background file-watcher mode",
+    optLang: "Force display language (ko | en)",
+    optHelp: "Display help information",
+    optVersion: "Display version information",
+    unknownCmd: "Unknown command:",
+    errPrefix: "\uD83D\uDEA8 Error:",
+    configExists: "Configuration file already exists:",
+    configCreated: "synapse.config.ts template created successfully.",
+    checkHeader: "\uD83E\uDDE0 [Synapse Kit] AI-Native Unified Compiler & Verification Framework",
+    causalAll: "Full check requested (--all): Executing all registered checkers.",
+    causalDirty: (count, plugins) => `${count} modified files detected: Running [${plugins}] plugins only.`,
+    causalClean: "No source changes detected. All checkers skipped in 0.00s.",
+    causalCleanCacheHit: "No file changes and matches last verified commit. Skipped in 0.00s.",
+    causalBaseline: "No changes detected; performing baseline verification for initial state.",
+    causalUnrelated: (count) => `${count} modified files do not affect registered plugins. Skipping all checkers.`,
+    causalGitFail: "Cannot track Git changes; running full verification in safe mode.",
+    checkPassed: "PASSED",
+    checkSkipped: "SKIPPED (Causal 0.00s)",
+    checkFailed: "FAILED",
+    checkSuccessSummary: (errs, warns, skips, sec) => `\u2728 Verification Passed: ${errs} Errors, ${warns} Warnings, ${skips} Skipped (Total: ${sec}s)`,
+    checkFailureSummary: (errs, warns, sec) => `\u274C Verification Failed: ${errs} check failures (Total: ${sec}s)`,
+    interactivePause: "\u23F8\uFE0F  Paused due to errors. Save modified files to hot-recheck in 0.05s. (Exit: Ctrl+C)",
+    interactiveReload: "\u26A1 File changes detected! Launching in-memory hot-recheck...",
+    interactiveTitle: "\u23F8\uFE0F  [Interactive Causal Hotfix] Process paused due to verification errors.",
+    interactiveTarget: "Target Plugins",
+    interactiveWatching: "Watch Status  : \uD83D\uDC40 Waiting for code changes... (hot-rechecks in 0.05s on save)",
+    interactiveExit: "Exit Session  : Press Ctrl+C in terminal",
+    interactiveDetected: (time, file) => `\u26A1 [Save Detected ${time}] ${file} changed \u279C Running hot-recheck...`,
+    interactivePassed: (sec) => `\u2728 [Hot-recheck Passed] (${sec}s) All issues resolved!`,
+    interactiveResumed: "\u25B6\uFE0F  [Pipeline Resumed] All verifications passed. Exiting cleanly.",
+    interactiveFailed: "\u274C [Hot-recheck Failed] Errors remain. Please edit and save again.",
+    buildHeader: "\u26A1 [Synapse Build] Causal Multi-Track Parallel Incremental Builder",
+    buildSkipped: "\u23ED\uFE0F Unchanged source detected: 0.00s skipped",
+    buildSuccess: "\u2705 Build completed",
+    buildFailed: "\u274C Build failed",
+    buildAllUpToDate: "\u2728 All build tracks are up-to-date. (Skipped all tracks: 0.00s)",
+    buildComplete: (sec) => `\u2728 Causal incremental build completed (Total: ${sec}s)`,
+    packageHeader: "\uD83D\uDCE6 [Synapse Package] High-Speed Installer Bundler",
+    packageSuccess: (sec) => `\u2728 Installer package bundled successfully (Elapsed: ${sec}s)`,
+    packageFailed: (sec) => `\u274C Installer packaging failed (Elapsed: ${sec}s)`,
+    signHeader: "\uD83D\uDD10 [Synapse Sign] Causal Cryptographic Signing Pipeline",
+    signSkipped: "\u23ED\uFE0F Binary SHA-256 unchanged: Signature skipped in 0.00s",
+    signSuccess: (sec) => `\u2728 Ed25519 digital signature generated (Elapsed: ${sec}s)`,
+    signFailed: (sec) => `\u274C Signature generation failed (Elapsed: ${sec}s)`,
+    signNoConfig: "\u274C Signing configuration (sign.privateKeyPath) is missing in synapse.config.ts.",
+    signNoKey: (p) => `\u274C Signing private key not found: ${p}`,
+    signNoInstaller: "\u274C Target installer (.exe) not found for signing.",
+    signTarget: "Target Installer",
+    signStatus: "Signing Status",
+    signFile: "Signature File",
+    signReasonLabel: "Reason",
+    signEngineLabel: "Signing Engine",
+    signCacheHit: "SKIPPED [Causal Cache Hit: Binary hash identical]",
+    signExistingKeep: (p) => `Keeping existing signature file (${p})`,
+    signIntegrityPass: "\u2728 Signature integrity verified (0.00s)",
+    statusSuccess: "PASSED",
+    statusSkipped: "SKIPPED (Causal skip)",
+    statusWarning: "WARNING",
+    statusError: "FAILED",
+    causalAnalysis: "Causal Analysis",
+    trackSkipped: "SKIPPED [Causal Cache Hit]",
+    trackComplete: "Build Passed",
+    trackFailed: "Build Failed",
+    noBuildTracks: "\u274C No buildTracks found in synapse.config.ts.",
+    buildSuccessSummary: (tracks, sec) => `\u2728 Causal Parallel Build Passed: All ${tracks} tracks completed (Total: ${sec}s)`,
+    buildFailureSummary: "\uD83D\uDEA8 Parallel Build Failed: Errors occurred in one or more tracks.",
+    packagingPreBuild: "\u2139\uFE0F  Verifying prerequisite artifact causal builds...",
+    packagingStart: "\uD83D\uDE80 Starting Tauri installer bundling...",
+    packagingGuide: `\u26A0\uFE0F  [Packaging Notice] tauri.conf.json has targets set to "all".
+   \u21B3 WiX MSI adds redundant delay. Recommended setting: targets: ["nsis"].`,
+    pluginRustTitle: "Rust Backend Workspace (Check & Clippy)",
+    pluginRustSuccess: "Rust workspace compilation & Clippy integrity verified (0 Warnings, 0 Errors)",
+    pluginRustClippyWarn: (count) => `Compilation passed (${count} Clippy recommendations detected)`,
+    pluginRustCompileFail: "Rust workspace compilation failed.",
+    pluginRustExecFail: (msg) => `Failed to execute Rust checker tool: ${msg}`,
+    pluginSvelteTitle: "Svelte 5 & TypeScript (svelte-check)",
+    pluginSvelteSuccess: "Svelte 5 Runes & TS type integrity verified (0 Errors, 0 Warnings)",
+    pluginSvelteError: "Errors detected in Svelte template or TypeScript types.",
+    pluginSvelteExecFail: (msg) => `Failed to execute Svelte checker tool: ${msg}`,
+    pluginJavaTitle: "Java Enterprise Compiler (javac)",
+    pluginJavaSuccess: (count) => `Java bytecode compilation verified for ${count} source files`,
+    pluginJavaNoFiles: "No Java source files (*.java) found to verify.",
+    pluginJavaError: "javac compilation failed",
+    pluginCppTitle: "C/C++ Native Kernel Checker (g++/clang++)",
+    pluginCppSuccess: (count) => `C/C++ syntax & header integrity verified for ${count} files`,
+    pluginCppNoFiles: "No C/C++ source files found to verify.",
+    pluginCppError: "C/C++ compilation syntax errors detected.",
+    pluginCsharpTitle: "C# .NET Solution Checker (dotnet build)",
+    pluginCsharpSuccess: "C# .NET project build and type integrity verified",
+    pluginCsharpError: "Errors detected during C# .NET build.",
+    pluginGoTitle: "Go Backend Package Checker (go vet)",
+    pluginGoSuccess: "Go concurrency routines and packages passed static analysis",
+    pluginGoError: "Errors detected during Go static analysis.",
+    pluginPythonTitle: "Python Bytecode Checker (py_compile)",
+    pluginPythonSuccess: (count) => `Python bytecode integrity verified for ${count} modules`,
+    pluginPythonNoFiles: "No Python source files found to verify.",
+    pluginPythonError: "Syntax errors detected in Python source.",
+    pluginTypescriptTitlePure: "Pure TypeScript Official Compiler (tsc)",
+    pluginTypescriptTitleNative: "TypeScript Native Rust Oxc (tsrs)",
+    pluginTypescriptSuccess: (mode) => `TypeScript type integrity verified (${mode})`,
+    pluginTypescriptError: "TypeScript type errors detected.",
+    pluginSchemaTitle: "Data & Config Schema Integrity Checker",
+    pluginSchemaSuccess: (count) => `Verified ${count} schema/data files successfully`,
+    pluginSchemaParseFail: (path, err) => `${path} parse failure: ${err}`,
+    pluginNativeTitle: "Native Binary & Asset Checker",
+    pluginNativeSuccess: (count) => `Verified ${count} binaries & resources successfully`,
+    pluginNativeMissing: (path) => `Required binary is missing: ${path}`,
+    pluginNativeNotPe: (path) => `${path}: Not a valid PE format (MZ signature missing).`,
+    pluginNativeInvalidPe: (path) => `${path}: Invalid PE signature.`,
+    pluginNativeInvalidArch: (path, code) => `${path}: Not a 64-bit (x64) binary (Machine code: 0x${code}).`,
+    pluginNsisTitle: "NSIS Installer Template Checker",
+    pluginNsisSuccess: (path) => `${path} syntax & required directives verified`,
+    pluginNsisMissing: (path) => `NSIS template file is missing: ${path}`,
+    pluginNsisCorrupt: "NSIS template content is empty or corrupted.",
+    pluginNsisDirectiveMissing: (dir) => `Required NSIS directive missing: '${dir}'.`
+  }
+};
+function detectLocale(explicitLang) {
+  if (explicitLang === "ko" || explicitLang === "en") {
+    currentLocale = explicitLang;
+    return currentLocale;
+  }
+  const envLang = process.env.SYNAPSE_LANG || process.env.LANG || process.env.LC_ALL || process.env.LC_MESSAGES || "";
+  if (envLang.toLowerCase().includes("ko")) {
+    currentLocale = "ko";
+    return "ko";
+  }
+  try {
+    const sysLocale = Intl.DateTimeFormat().resolvedOptions().locale.toLowerCase();
+    if (sysLocale.startsWith("ko")) {
+      currentLocale = "ko";
+      return "ko";
+    }
+  } catch {}
+  currentLocale = "en";
+  return "en";
+}
+function t(key, ...args) {
+  const dict = MESSAGES[currentLocale] || MESSAGES.en;
+  const val = dict[key] ?? MESSAGES.en[key] ?? key;
+  if (typeof val === "function") {
+    return val(...args);
+  }
+  return val;
+}
+
+// src/memory/causal-graph.ts
+async function analyzeCausalGraph(rootDir, plugins, options) {
+  const allPluginNames = new Set(plugins.map((p) => p.name));
+  if (options.mode === "all") {
+    return {
+      runAll: true,
+      activePluginNames: allPluginNames,
+      reason: t("causalAll"),
+      modifiedFiles: []
+    };
+  }
+  try {
+    const { head, modifiedFiles } = await getGitState(rootDir);
+    if (modifiedFiles.length === 0) {
+      const cache = loadBuildCache(rootDir);
+      if (cache.lastVerifiedHead && cache.lastVerifiedHead === head && head !== "unknown") {
+        return {
+          runAll: false,
+          activePluginNames: new Set,
+          reason: t("causalCleanCacheHit"),
+          modifiedFiles: []
+        };
+      }
+      return {
+        runAll: true,
+        activePluginNames: allPluginNames,
+        reason: t("causalBaseline"),
+        modifiedFiles: []
+      };
+    }
+    const activePluginNames = new Set;
+    for (const plugin of plugins) {
+      const isTriggered = plugin.triggers.some((pattern) => {
+        const cleanPattern = pattern.replaceAll("\\", "/").replace(/^\.\//, "");
+        const isExtension = cleanPattern.startsWith(".");
+        return modifiedFiles.some((file) => {
+          if (isExtension) {
+            return file.endsWith(cleanPattern);
+          }
+          return file.includes(cleanPattern);
+        });
+      });
+      if (isTriggered) {
+        activePluginNames.add(plugin.name);
+      }
+    }
+    if (activePluginNames.size === 0) {
+      return {
+        runAll: false,
+        activePluginNames: new Set,
+        reason: t("causalUnrelated", modifiedFiles.length),
+        modifiedFiles
+      };
+    }
+    return {
+      runAll: false,
+      activePluginNames,
+      reason: t("causalDirty", modifiedFiles.length, Array.from(activePluginNames).join(", ")),
+      modifiedFiles
+    };
+  } catch {
+    return {
+      runAll: true,
+      activePluginNames: allPluginNames,
+      reason: t("causalGitFail"),
+      modifiedFiles: []
+    };
+  }
+}
+
+// src/core/reporter.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var CYAN = "\x1B[36m";
+var GRAY = "\x1B[90m";
+function reportResults(decision, results, totalDurationMs, options) {
+  const totalSeconds = (totalDurationMs / 1000).toFixed(2);
+  const errorResults = results.filter((r) => r.status === "error");
+  const warningResults = results.filter((r) => r.status === "warning");
+  const skippedResults = results.filter((r) => r.status === "skipped");
+  const successResults = results.filter((r) => r.status === "success");
+  if (options.agentMode || options.compactMode) {
+    const isCleanPass = errorResults.length === 0 && warningResults.length === 0;
+    if (isCleanPass && options.compactMode) {
+      const minimalPayload = {
+        ok: true,
+        duration: `${totalSeconds}s`,
+        skipped: skippedResults.map((r) => r.name)
+      };
+      process.stdout.write(`${JSON.stringify(minimalPayload)}
+`);
+      return;
+    }
+    const payload = {
+      ok: errorResults.length === 0,
+      duration: `${totalSeconds}s`,
+      summary: {
+        pass: successResults.length,
+        warn: warningResults.length,
+        err: errorResults.length,
+        skip: skippedResults.length
+      }
+    };
+    if (errorResults.length > 0) {
+      payload.errors = errorResults.map((r) => ({
+        plugin: r.name,
+        details: r.details,
+        diagnostics: r.diagnostics
+      }));
+    }
+    if (warningResults.length > 0) {
+      payload.warnings = warningResults.map((r) => ({
+        plugin: r.name,
+        details: r.details,
+        diagnostics: r.diagnostics
+      }));
+    }
+    if (skippedResults.length > 0) {
+      payload.skipped = skippedResults.map((r) => r.name);
+    }
+    const outputString = options.compactMode ? JSON.stringify(payload) : JSON.stringify(payload, null, 2);
+    process.stdout.write(`${outputString}
+`);
+    return;
+  }
+  const line = "\u2501".repeat(68);
+  process.stdout.write(`
+${BOLD}${CYAN}${t("checkHeader")}${RESET}
+`);
+  process.stdout.write(`${GRAY}${line}${RESET}
+`);
+  process.stdout.write(`${GRAY}\uD83D\uDCA1 ${t("causalAnalysis")}: ${decision.reason}${RESET}
+`);
+  process.stdout.write(`${GRAY}${line}${RESET}
+`);
+  for (const result of results) {
+    const duration = (result.durationMs / 1000).toFixed(2);
+    let statusBadge = "";
+    switch (result.status) {
+      case "success":
+        statusBadge = `${GREEN}\u2705 ${t("statusSuccess")} (${duration}s)${RESET}`;
+        break;
+      case "skipped":
+        statusBadge = `${GRAY}\u23ED\uFE0F  ${t("statusSkipped")}${RESET}`;
+        break;
+      case "warning":
+        statusBadge = `${YELLOW}\u26A0\uFE0F  ${t("statusWarning")} (${duration}s)${RESET}`;
+        break;
+      case "error":
+        statusBadge = `${RED}\u274C ${t("statusError")} (${duration}s)${RESET}`;
+        break;
+    }
+    const titlePadded = result.title.padEnd(36, " ");
+    process.stdout.write(` \u2022 ${BOLD}${titlePadded}${RESET} : ${statusBadge}
+`);
+    if (result.status !== "skipped" && result.details) {
+      process.stdout.write(`   ${GRAY}\u2514\u2500 ${result.details}${RESET}
+`);
+    }
+    if (result.diagnostics && result.diagnostics.length > 0) {
+      for (const diag of result.diagnostics) {
+        process.stdout.write(`   ${RED}\u25B6 ${diag.message}${RESET}
+`);
+      }
+    }
+  }
+  process.stdout.write(`${GRAY}${line}${RESET}
+`);
+  if (errorResults.length === 0) {
+    process.stdout.write(`${BOLD}${GREEN}${t("checkSuccessSummary", 0, warningResults.length, skippedResults.length, totalSeconds)}${RESET}
+
+`);
+  } else {
+    process.stdout.write(`${BOLD}${RED}${t("checkFailureSummary", errorResults.length, warningResults.length, totalSeconds)}${RESET}
+
+`);
+  }
+}
+
+// src/core/engine.ts
+var RESET2 = "\x1B[0m";
+var BOLD2 = "\x1B[1m";
+var GREEN2 = "\x1B[32m";
+var RED2 = "\x1B[31m";
+var YELLOW2 = "\x1B[33m";
+var CYAN2 = "\x1B[36m";
+var GRAY2 = "\x1B[90m";
+async function runPluginChecker(plugin, isActive, rootDir, options) {
+  if (!isActive) {
+    return {
+      name: plugin.name,
+      title: plugin.title,
+      status: "skipped",
+      durationMs: 0,
+      details: t("checkSkipped")
+    };
+  }
+  try {
+    return await plugin.check({ rootDir, options });
+  } catch (error) {
+    return {
+      name: plugin.name,
+      title: plugin.title,
+      status: "error",
+      durationMs: 0,
+      details: `Critical plugin execution failure: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function executeChecks(config, options) {
+  const rootDir = config.rootDir || process.cwd();
+  const startTime = performance.now();
+  const decision = await analyzeCausalGraph(rootDir, config.plugins, options);
+  const results = await Promise.all(config.plugins.map((plugin) => runPluginChecker(plugin, decision.activePluginNames.has(plugin.name), rootDir, options)));
+  const totalDurationMs = performance.now() - startTime;
+  reportResults(decision, results, totalDurationMs, options);
+  const hasError = results.some((r) => r.status === "error");
+  if (!hasError) {
+    const cache = loadBuildCache(rootDir);
+    const { head } = await getGitState(rootDir);
+    if (head && head !== "unknown") {
+      cache.lastVerifiedHead = head;
+      saveBuildCache(rootDir, cache);
+    }
+  }
+  if (hasError && options.interactive) {
+    const failedNames = new Set(results.filter((r) => r.status === "error").map((r) => r.name));
+    const failedPlugins = config.plugins.filter((p) => failedNames.has(p.name));
+    return await runInteractiveLoop(failedPlugins, rootDir, options);
+  }
+  return hasError ? 1 : 0;
+}
+async function runInteractiveLoop(failedPlugins, rootDir, options) {
+  const line = "\u2501".repeat(68);
+  process.stdout.write(`
+${BOLD2}${CYAN2}${t("interactiveTitle")}${RESET2}
+`);
+  process.stdout.write(`${GRAY2}${line}${RESET2}
+`);
+  process.stdout.write(` \u2022 ${t("interactiveTarget")} : ${BOLD2}${failedPlugins.map((p) => p.name).join(", ")}${RESET2}
+`);
+  process.stdout.write(` \u2022 ${t("interactiveWatching")}
+`);
+  process.stdout.write(` \u2022 ${t("interactiveExit")}
+`);
+  process.stdout.write(`${GRAY2}${line}${RESET2}
+
+`);
+  return new Promise((resolve) => {
+    let isChecking = false;
+    let debounceTimer = null;
+    const watcher = watch(rootDir, { recursive: true }, async (_eventType, filename) => {
+      if (!filename)
+        return;
+      const normalized = filename.replace(/\\/g, "/");
+      if (normalized.includes("target/") || normalized.includes("node_modules/") || normalized.includes(".git/") || normalized.includes(".svelte-kit/") || normalized.includes("dist/") || normalized.includes(".synapse/")) {
+        return;
+      }
+      if (debounceTimer)
+        clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(async () => {
+        if (isChecking)
+          return;
+        isChecking = true;
+        const timeStr = new Date().toLocaleTimeString("ko-KR", { hour12: false });
+        process.stdout.write(`
+${CYAN2}${t("interactiveDetected", timeStr, normalized)}${RESET2}
+`);
+        const retryStart = performance.now();
+        const retryResults = await Promise.all(failedPlugins.map((p) => p.check({ rootDir, options })));
+        const retryDuration = ((performance.now() - retryStart) / 1000).toFixed(2);
+        const stillFailed = retryResults.some((r) => r.status === "error");
+        if (!stillFailed) {
+          process.stdout.write(`${BOLD2}${GREEN2}${t("interactivePassed", retryDuration)}${RESET2}
+`);
+          process.stdout.write(`${BOLD2}${CYAN2}${t("interactiveResumed")}${RESET2}
+
+`);
+          watcher.close();
+          const cache = loadBuildCache(rootDir);
+          const { head } = await getGitState(rootDir);
+          if (head && head !== "unknown") {
+            cache.lastVerifiedHead = head;
+            saveBuildCache(rootDir, cache);
+          }
+          resolve(0);
+        } else {
+          process.stdout.write(`${BOLD2}${RED2}${t("interactiveFailed")}${RESET2}
+`);
+          for (const res of retryResults) {
+            if (res.status === "error" && res.details) {
+              process.stdout.write(`   \u2514\u2500 ${GRAY2}${res.details}${RESET2}
+`);
+            }
+          }
+          isChecking = false;
+        }
+      }, 60);
+    });
+  });
+}
+async function executeBuild(config, options = { mode: "smart", agentMode: false, compactMode: false, watch: false }) {
+  const rootDir = config.rootDir || process.cwd();
+  const tracks = config.buildTracks || [];
+  if (tracks.length === 0) {
+    process.stderr.write(`${RED2}${t("noBuildTracks")}${RESET2}
+`);
+    return 1;
+  }
+  const startTime = performance.now();
+  const line = "\u2501".repeat(68);
+  process.stdout.write(`
+${BOLD2}${CYAN2}${t("buildHeader")} (${tracks.length})${RESET2}
+`);
+  process.stdout.write(`${GRAY2}${line}${RESET2}
+`);
+  const cache = loadBuildCache(rootDir);
+  const { head: currentHead, modifiedFiles, repoRoot } = await getGitState(rootDir);
+  const isForce = options.force || options.mode === "all";
+  const taskPromises = tracks.map(async (track) => {
+    const { skip, reason } = shouldSkipBuildTrack(track, rootDir, repoRoot, cache, modifiedFiles, isForce);
+    if (skip) {
+      return {
+        name: track.name,
+        durationMs: 0,
+        exitCode: 0,
+        skipped: true,
+        reason
+      };
+    }
+    const trackStart = performance.now();
+    const proc = spawn2([...track.command], {
+      cwd: track.cwd || rootDir,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const exitCode = await proc.exited;
+    const durationMs = performance.now() - trackStart;
+    return {
+      name: track.name,
+      durationMs,
+      exitCode,
+      skipped: false,
+      reason
+    };
+  });
+  const taskResults = await Promise.all(taskPromises);
+  const totalDuration = ((performance.now() - startTime) / 1000).toFixed(2);
+  const hasFailed = taskResults.some((t) => t.exitCode !== 0);
+  process.stdout.write(`${GRAY2}${line}${RESET2}
+`);
+  for (const res of taskResults) {
+    if (res.skipped) {
+      process.stdout.write(` \u2022 ${BOLD2}${res.name.padEnd(38, " ")}${RESET2} : ${YELLOW2}\u26A1 ${t("trackSkipped")}${RESET2} ${GRAY2}(0.00s)${RESET2}
+`);
+    } else {
+      const sec = (res.durationMs / 1000).toFixed(2);
+      const badge = res.exitCode === 0 ? `${GREEN2}\u2705 ${t("trackComplete")} (${sec}s)${RESET2}` : `${RED2}\u274C ${t("trackFailed")} (${sec}s)${RESET2}`;
+      process.stdout.write(` \u2022 ${BOLD2}${res.name.padEnd(38, " ")}${RESET2} : ${badge}
+`);
+    }
+  }
+  process.stdout.write(`${GRAY2}${line}${RESET2}
+`);
+  if (!hasFailed) {
+    const now = new Date().toISOString();
+    for (const res of taskResults) {
+      if (!res.skipped && res.exitCode === 0) {
+        cache.tracks[res.name] = {
+          lastBuildTime: now,
+          gitCommit: currentHead,
+          artifactExists: true
+        };
+      }
+    }
+    saveBuildCache(rootDir, cache);
+    process.stdout.write(`${BOLD2}${GREEN2}${t("buildSuccessSummary", tracks.length, totalDuration)}${RESET2}
+
+`);
+    return 0;
+  } else {
+    process.stdout.write(`${BOLD2}${RED2}${t("buildFailureSummary")}${RESET2}
+
+`);
+    return 1;
+  }
+}
+async function executePackage(config, options = { mode: "smart", agentMode: false, compactMode: false, watch: false }) {
+  const rootDir = config.rootDir || process.cwd();
+  const startTime = performance.now();
+  const line = "\u2501".repeat(68);
+  process.stdout.write(`
+${BOLD2}${CYAN2}${t("packageHeader")}${RESET2}
+`);
+  process.stdout.write(`${GRAY2}${line}${RESET2}
+`);
+  if (config.buildTracks && config.buildTracks.length > 0) {
+    process.stdout.write(`${CYAN2}${t("packagingPreBuild")}${RESET2}
+`);
+    const buildExit = await executeBuild(config, options);
+    if (buildExit !== 0)
+      return buildExit;
+  }
+  const tauriConfCandidates = [
+    resolve3(rootDir, "src-tauri/tauri.conf.json"),
+    resolve3(rootDir, "tauri.conf.json")
+  ];
+  const tauriConfPath = tauriConfCandidates.find((p) => existsSync3(p));
+  if (tauriConfPath) {
+    try {
+      const content = await Bun.file(tauriConfPath).json();
+      const targets = content?.bundle?.targets;
+      if (targets === "all") {
+        process.stdout.write(`${YELLOW2}${t("packagingGuide")}${RESET2}
+`);
+      }
+    } catch {}
+  }
+  process.stdout.write(`${BOLD2}${t("packagingStart")}${RESET2}
+`);
+  const pkgProc = spawn2(["bun", "x", "tauri", "build", "--bundles", "nsis"], {
+    cwd: rootDir,
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await pkgProc.exited;
+  const duration = ((performance.now() - startTime) / 1000).toFixed(2);
+  process.stdout.write(`${GRAY2}${line}${RESET2}
+`);
+  if (exitCode === 0) {
+    process.stdout.write(`${BOLD2}${GREEN2}${t("packageSuccess", duration)}${RESET2}
+
+`);
+    return 0;
+  } else {
+    process.stdout.write(`${BOLD2}${RED2}${t("packageFailed", duration)}${RESET2}
+
+`);
+    return exitCode;
+  }
+}
+async function executeSign(config, options = { mode: "smart", agentMode: false, compactMode: false, watch: false }) {
+  const rootDir = config.rootDir || process.cwd();
+  const startTime = performance.now();
+  const line = "\u2501".repeat(68);
+  process.stdout.write(`
+${BOLD2}${CYAN2}${t("signHeader")}${RESET2}
+`);
+  process.stdout.write(`${GRAY2}${line}${RESET2}
+`);
+  const signConfig = config.sign;
+  if (!signConfig || !signConfig.privateKeyPath) {
+    process.stderr.write(`${RED2}${t("signNoConfig")}${RESET2}
+`);
+    return 1;
+  }
+  const keyPath = resolve3(rootDir, signConfig.privateKeyPath);
+  if (!existsSync3(keyPath)) {
+    process.stderr.write(`${RED2}${t("signNoKey", keyPath)}${RESET2}
+`);
+    return 1;
+  }
+  let installerPath = signConfig.targetInstaller ? resolve3(rootDir, signConfig.targetInstaller) : "";
+  if (!installerPath || !existsSync3(installerPath)) {
+    const candidates = [
+      resolve3(rootDir, "target/release/bundle/nsis"),
+      resolve3(rootDir, "src-tauri/target/release/bundle/nsis"),
+      resolve3(rootDir, "../target/release/bundle/nsis")
+    ];
+    for (const dir of candidates) {
+      if (existsSync3(dir)) {
+        const files = readdirSync(dir).filter((f) => f.endsWith(".exe") && !f.endsWith(".sig"));
+        if (files.length > 0) {
+          installerPath = resolve3(dir, files[0]);
+          break;
+        }
+      }
+    }
+  }
+  if (!installerPath || !existsSync3(installerPath)) {
+    process.stderr.write(`${RED2}${t("signNoInstaller")}${RESET2}
+`);
+    return 1;
+  }
+  const signaturePath = `${installerPath}.sig`;
+  const cache = loadBuildCache(rootDir);
+  const isForce = options.force || options.mode === "all";
+  const { skip, reason, currentHash } = shouldSkipSign(installerPath, signaturePath, cache, isForce);
+  if (skip) {
+    process.stdout.write(` \u2022 ${t("signTarget")} : ${BOLD2}${installerPath}${RESET2}
+` + ` \u2022 ${t("signStatus")} : ${YELLOW2}\u26A1 ${t("signCacheHit")}${RESET2} ${GRAY2}(0.00s)${RESET2}
+` + ` \u2022 ${t("signFile")}   : ${GREEN2}\u2705 ${t("signExistingKeep", signaturePath)}${RESET2}
+`);
+    process.stdout.write(`${GRAY2}${line}${RESET2}
+`);
+    process.stdout.write(`${BOLD2}${GREEN2}${t("signIntegrityPass")}${RESET2}
+
+`);
+    return 0;
+  }
+  process.stdout.write(` \u2022 ${t("signTarget")} : ${BOLD2}${installerPath}${RESET2}
+`);
+  process.stdout.write(` \u2022 ${t("signReasonLabel")} : ${CYAN2}${reason}${RESET2}
+`);
+  process.stdout.write(` \u2022 ${t("signEngineLabel")} : ${BOLD2}Bun Native Tauri Signer (Ed25519)${RESET2}
+`);
+  const passwordEnvName = signConfig.passwordEnv || "TAURI_KEY_PASSWORD";
+  const passwordVal = process.env[passwordEnvName] || process.env.TAURI_PRIVATE_KEY_PASSWORD || process.env.TAURI_KEY_PASSWORD || "";
+  const signArgs = [
+    "bun",
+    "x",
+    "tauri",
+    "signer",
+    "sign",
+    "--private-key-path",
+    keyPath
+  ];
+  if (passwordVal) {
+    signArgs.push("--password", passwordVal);
+  }
+  signArgs.push(installerPath);
+  const proc = spawn2(signArgs, {
+    cwd: rootDir,
+    env: {
+      ...process.env,
+      TAURI_PRIVATE_KEY_PASSWORD: passwordVal,
+      TAURI_KEY_PASSWORD: passwordVal
+    },
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  const duration = ((performance.now() - startTime) / 1000).toFixed(2);
+  process.stdout.write(`${GRAY2}${line}${RESET2}
+`);
+  if (exitCode === 0) {
+    cache.sign = {
+      lastSignTime: new Date().toISOString(),
+      installerHash: currentHash || computeFileHash(installerPath),
+      signaturePath
+    };
+    saveBuildCache(rootDir, cache);
+    process.stdout.write(`${BOLD2}${GREEN2}${t("signSuccess", duration)}${RESET2}
+` + ` \u2022 ${t("signFile")}: ${BOLD2}${signaturePath}${RESET2}
+
+`);
+    return 0;
+  } else {
+    process.stdout.write(`${BOLD2}${RED2}${t("signFailed", duration)}${RESET2}
+
+`);
+    return exitCode;
+  }
+}
+
+// src/cli-memory.ts
+init_causal_config();
+init_causal_store();
+init_causal_query();
+init_causal_server();
+
+// src/memory/causal-migrator.ts
+init_causal_config();
+init_causal_store();
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } 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 (!existsSync5(sourceBackupPath)) {
+    throw new Error(`\uAD6C\uD615 \uBA54\uBAA8\uB9AC \uBC31\uC5C5 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${sourceBackupPath}`);
+  }
+  const raw = readFileSync3(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 = dirname2(outPath);
+    if (!existsSync5(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync3(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
+  };
+}
+
+// src/cli-memory.ts
+var RESET4 = "\x1B[0m";
+var BOLD4 = "\x1B[1m";
+var CYAN4 = "\x1B[36m";
+var GREEN4 = "\x1B[32m";
+var RED4 = "\x1B[31m";
+var GRAY4 = "\x1B[90m";
+var YELLOW4 = "\x1B[33m";
+function printMemoryHelp() {
+  process.stdout.write(`
+${BOLD4}${CYAN4}\uD83E\uDDE0 Synapse Kit - Causal Memory Engine (\uC778\uACFC\uC728 \uC9C0\uB2A5\uD615 \uBA54\uBAA8\uB9AC CLI)${RESET4}
+
+${BOLD4}\uC0AC\uC6A9\uBC95:${RESET4}
+  synapse memory <subcommand> [options]
+
+${BOLD4}\uC11C\uBE0C \uBA85\uB839\uC5B4:${RESET4}
+  query       \uC791\uC5C5 \uD30C\uC77C/\uD0A4\uC6CC\uB4DC\uC5D0 \uB9E4\uCE6D\uB418\uB294 \uC778\uACFC \uADDC\uCE59 \uBC0F \uAC04\uC120(Relations) \uCD08\uACBD\uB7C9 \uACF5\uBA85 \uC870\uD68C (\uAE30\uBCF8\uAC12)
+  list        \uB4F1\uB85D\uB41C \uB3C4\uBA54\uC778, \uC778\uACFC \uADDC\uCE59 \uBC0F \uC778\uACFC \uAC04\uC120(Relations) \uD1B5\uACC4 \uD655\uC778
+  audit       \uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uB370\uC774\uD130\uBCA0\uC774\uC2A4 \uBB34\uACB0\uC131 \uBC0F \uD1A0\uD070 \uC808\uAC10 \uC0C1\uD0DC \uAC10\uC0AC
+  assert      \uC2E0\uADDC \uC778\uACFC\uC728 \uADDC\uCE59 \uB4F1\uB85D \uB610\uB294 \uAC31\uC2E0 (--json '<json>')
+  migrate     \uAD6C\uD615 \uC9C0\uC2DD \uADF8\uB798\uD504 \uBC31\uC5C5\uBCF8\uC744 \uC778\uACFC\uC728 \uBA54\uBAA8\uB9AC \uB370\uC774\uD130\uBCA0\uC774\uC2A4\uB85C \uBB34\uC190\uC2E4 \uBCC0\uD658
+  benchmark   4\uB300 \uCC28\uC6D0 \uACFC\uBD80\uD558 \uC2A4\uD2B8\uB808\uC2A4 \uBCA4\uCE58\uB9C8\uD06C \uC2E4\uD589 (--scale 10000 --concurrency 50)
+  serve       \uB3C5\uB9BD \uB85C\uCEEC \uBC31\uADF8\uB77C\uC6B4\uB4DC \uC11C\uBC84/\uB370\uBAAC \uAD6C\uB3D9 (0ms \uC778\uBA54\uBAA8\uB9AC HTTP & MCP API)
+  mcp-stdio   MCP \uD45C\uC900 \uC785\uCD9C\uB825(stdio) JSON-RPC 2.0 \uC11C\uBC84 \uAD6C\uB3D9 (mcp_config.json \uC5F0\uB3D9\uC6A9)
+
+${BOLD4}query \uC635\uC158:${RESET4}
+  --files <paths...>       \uD2B8\uB9AC\uAC70 \uB300\uC0C1 \uD30C\uC77C \uACBD\uB85C (\uBBF8\uC9C0\uC815 \uC2DC Git \uBCC0\uACBD \uC790\uB3D9 \uC2A4\uCE94)
+  --keywords <words...>    \uD2B8\uB9AC\uAC70 \uAC80\uC0C9 \uD0A4\uC6CC\uB4DC
+  --command <cmd>          \uD2B8\uB9AC\uAC70 \uC5F0\uB3D9 \uBA85\uB839\uC5B4 (\uC608: release, build, sign)
+  --domain <domain>        \uD2B9\uC815 \uB3C4\uBA54\uC778\uC73C\uB85C \uAC80\uC0C9 \uC81C\uD55C
+  --format <json|md|compact> \uCD9C\uB825 \uD3EC\uB9F7 \uC9C0\uC815
+
+${BOLD4}serve \uC635\uC158:${RESET4}
+  --port <number>          \uC11C\uBC84 \uD3EC\uD2B8 \uBC88\uD638 (\uAE30\uBCF8: ${CAUSAL_MEMORY_CONFIG.DEFAULT_PORT})
+  --host <string>          \uBC14\uC778\uB529 \uD638\uC2A4\uD2B8 (\uAE30\uBCF8: ${CAUSAL_MEMORY_CONFIG.DEFAULT_HOST})
+
+${BOLD4}\uACF5\uD1B5 \uD50C\uB798\uADF8:${RESET4}
+  --agent, --compact       AI \uC5D0\uC774\uC804\uD2B8 \uC804\uC6A9 \uCD08\uACBD\uB7C9 JSON \uBAA8\uB4DC
+
+`);
+}
+async function handleMemoryCommand(args, options) {
+  const subArgs = args.filter((a) => a !== "memory");
+  const subCommand = subArgs.find((a) => !a.startsWith("-")) || "query";
+  if (subArgs.includes("--help") || subArgs.includes("-h") || subCommand === "help") {
+    printMemoryHelp();
+    return 0;
+  }
+  if (subCommand === "mcp-stdio") {
+    await startCausalMcpStdioServer();
+    return 0;
+  }
+  if (subCommand === "benchmark") {
+    let ruleScale = 1e4;
+    let concurrency = 50;
+    let totalRequests = 5000;
+    for (let i = 0;i < subArgs.length; i++) {
+      if (subArgs[i] === "--scale" && subArgs[i + 1]) {
+        ruleScale = parseInt(subArgs[i + 1], 10);
+      } else if (subArgs[i] === "--concurrency" && subArgs[i + 1]) {
+        concurrency = parseInt(subArgs[i + 1], 10);
+      } else if (subArgs[i] === "--requests" && subArgs[i + 1]) {
+        totalRequests = parseInt(subArgs[i + 1], 10);
+      }
+    }
+    await Promise.resolve().then(() => init_causal_benchmark());
+    const report = await executeOverloadBenchmark({
+      ruleScale,
+      relationScale: ruleScale * 2,
+      concurrency,
+      totalRequests,
+      fileInputScale: ruleScale,
+      crudIterations: totalRequests
+    }, options.agentMode);
+    if (options.agentMode) {
+      process.stdout.write(JSON.stringify(report, null, 2) + `
+`);
+    }
+    return report.allPassed ? 0 : 1;
+  }
+  if (subCommand === "migrate") {
+    const result = migrateLegacyMemoryGraph();
+    if (options.agentMode) {
+      process.stdout.write(JSON.stringify(result) + `
+`);
+    } else {
+      process.stdout.write(`
+${BOLD4}${GREEN4}\u2728 [Causal Memory \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC644\uB8CC]${RESET4}
+` + `  \u2022 \uBCC0\uD658\uB41C \uC778\uACFC \uADDC\uCE59(Rules)     : ${BOLD4}${result.totalRules}\uAC1C${RESET4}
+` + `  \u2022 \uBCF4\uC874\uB41C \uC778\uACFC \uAC04\uC120(Relations) : ${BOLD4}${result.totalRelations}\uAC1C${RESET4}
+` + `  \u2022 \uC0C1\uC2DC \uD65C\uC131 \uADDC\uCE59(AlwaysActive): ${BOLD4}${result.alwaysActiveCount}\uAC1C${RESET4}
+` + `  \u2022 \uBD84\uB958 \uB3C4\uBA54\uC778                 : ${result.domains.join(", ")}
+
+`);
+    }
+    return 0;
+  }
+  if (subCommand === "assert") {
+    const jsonIdx = subArgs.indexOf("--json");
+    if (jsonIdx < 0 || !subArgs[jsonIdx + 1]) {
+      process.stderr.write(`${RED4}\u274C --json '<\uADDC\uCE59 JSON>' \uC778\uC790\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.${RESET4}
+`);
+      return 1;
+    }
+    const rule = JSON.parse(subArgs[jsonIdx + 1]);
+    const store = new CausalMemoryStore;
+    store.assertRule(rule);
+    if (options.agentMode) {
+      process.stdout.write(JSON.stringify({ ok: true, id: rule.id }) + `
+`);
+    } else {
+      process.stdout.write(`${BOLD4}${GREEN4}\u2705 \uC778\uACFC \uADDC\uCE59 \uB4F1\uB85D \uC644\uB8CC: ${rule.id}${RESET4}
+`);
+    }
+    return 0;
+  }
+  if (subCommand === "query") {
+    const files = [];
+    const keywords = [];
+    let command;
+    let domain;
+    let format = options.compactMode ? "compact" : options.agentMode ? "json" : "text";
+    for (let i = 0;i < subArgs.length; i++) {
+      const arg = subArgs[i];
+      if (arg === "--files" || arg === "-f") {
+        let j = i + 1;
+        while (j < subArgs.length && !subArgs[j].startsWith("-")) {
+          files.push(subArgs[j]);
+          j++;
+        }
+        i = j - 1;
+      } else if (arg === "--keywords" || arg === "-k") {
+        let j = i + 1;
+        while (j < subArgs.length && !subArgs[j].startsWith("-")) {
+          keywords.push(subArgs[j]);
+          j++;
+        }
+        i = j - 1;
+      } else if (arg === "--command" || arg === "-c") {
+        command = subArgs[++i];
+      } else if (arg === "--domain" || arg === "-d") {
+        domain = subArgs[++i];
+      } else if (arg === "--format") {
+        format = subArgs[++i];
+      }
+    }
+    const result = await runCausalQuery({
+      files,
+      keywords,
+      command,
+      domain,
+      autoGit: files.length === 0
+    });
+    if (options.compactMode || format === "compact") {
+      process.stdout.write(formatResonanceForAgent(result, true) + `
+`);
+    } else if (options.agentMode || format === "json") {
+      process.stdout.write(JSON.stringify(result, null, 2) + `
+`);
+    } else if (format === "md" || format === "markdown") {
+      process.stdout.write(formatResonanceForAgent(result, false) + `
+`);
+    } else {
+      process.stdout.write(`
+${BOLD4}${CYAN4}\uD83E\uDDE0 [Causal Memory] \uACF5\uBA85 \uCFFC\uB9AC \uC644\uACB0 (${result.matchedCount}/${result.totalDatabaseRules}\uAC1C \uADDC\uCE59 \uD65C\uC131\uD654, \uAC04\uC120 ${result.activeRelations.length}\uAC1C, \uC808\uAC10\uB960: ${result.tokenDietSavingsRatio}, ${result.queryDurationMs}ms)${RESET4}
+`);
+      for (const rule of result.resonanceRules) {
+        process.stdout.write(`
+  ${BOLD4}${GREEN4}\u2714 [${rule.domain}]${RESET4} ${BOLD4}${rule.title}${RESET4} ${GRAY4}(${rule.id})${RESET4}
+`);
+        if (rule.invariants.length > 0) {
+          process.stdout.write(`    ${YELLOW4}\uD83D\uDEE1\uFE0F \uBD88\uBCC0 \uADDC\uCE59:${RESET4}
+`);
+          for (const inv of rule.invariants) {
+            process.stdout.write(`      \u2022 ${inv}
+`);
+          }
+        }
+        if (rule.actions.length > 0) {
+          process.stdout.write(`    ${CYAN4}\u26A1 \uC2E4\uD589 \uC9C0\uCE68:${RESET4}
+`);
+          for (const act of rule.actions) {
+            process.stdout.write(`      \u2022 ${act}
+`);
+          }
+        }
+      }
+      if (result.activeRelations.length > 0) {
+        process.stdout.write(`
+  ${BOLD4}${CYAN4}\uD83D\uDD17 \uD65C\uC131 \uC778\uACFC \uAC04\uC120 (Relations):${RESET4}
+`);
+        for (const rel of result.activeRelations) {
+          process.stdout.write(`    \u2022 ${rel.from} \u2500\u2500[${rel.relationType}]\u2500\u2500\u25B6 ${rel.to}
+`);
+        }
+      }
+      process.stdout.write(`
+`);
+    }
+    return 0;
+  }
+  if (subCommand === "list") {
+    const store = new CausalMemoryStore;
+    const status = store.getStatus();
+    const rules = store.getAllRules();
+    if (options.agentMode) {
+      process.stdout.write(JSON.stringify({ ok: true, status, rulesCount: rules.length, relationsCount: status.totalRelations }) + `
+`);
+      return 0;
+    }
+    process.stdout.write(`
+${BOLD4}${CYAN4}\uD83E\uDDE0 [Causal Memory] \uC778\uACFC\uC728 \uB370\uC774\uD130\uBCA0\uC774\uC2A4 \uC0C1\uD0DC${RESET4}
+`);
+    process.stdout.write(`  \u2022 \uC800\uC7A5\uC18C \uACBD\uB85C : ${GRAY4}${status.dbPath}${RESET4}
+`);
+    process.stdout.write(`  \u2022 \uC5D4\uC9C4 \uBC84\uC804   : ${GREEN4}v${status.version}${RESET4}
+`);
+    process.stdout.write(`  \u2022 \uCD1D \uADDC\uCE59 \uC218  : ${BOLD4}${status.totalRules}\uAC1C${RESET4}
+`);
+    process.stdout.write(`  \u2022 \uCD1D \uC778\uACFC \uAC04\uC120: ${BOLD4}${status.totalRelations}\uAC1C${RESET4}
+`);
+    process.stdout.write(`  \u2022 \uAD00\uB9AC \uB3C4\uBA54\uC778 : ${status.domains.join(", ")}
+
+`);
+    for (const domain of status.domains) {
+      const domainRules = rules.filter((r) => r.domain === domain);
+      process.stdout.write(`  ${BOLD4}${YELLOW4}[${domain}]${RESET4} (${domainRules.length}\uAC1C \uADDC\uCE59)
+`);
+      for (const r of domainRules) {
+        process.stdout.write(`    \u2022 ${r.title} ${GRAY4}(${r.id})${RESET4}
+`);
+      }
+    }
+    process.stdout.write(`
+`);
+    return 0;
+  }
+  if (subCommand === "audit") {
+    const store = new CausalMemoryStore;
+    const audit = store.audit();
+    if (options.agentMode) {
+      process.stdout.write(JSON.stringify(audit) + `
+`);
+      return audit.ok ? 0 : 1;
+    }
+    if (audit.ok) {
+      process.stdout.write(`
+${BOLD4}${GREEN4}\u2728 [Causal Memory Audit \uD1B5\uACFC] \uCD1D ${audit.totalRules}\uAC1C \uADDC\uCE59, ${audit.totalRelations}\uAC1C \uC778\uACFC \uAC04\uC120 (\uC0C1\uC2DC \uD65C\uC131: ${audit.alwaysActiveCount}\uAC1C) \uBB34\uACB0\uC131 100% \uC815\uC0C1${RESET4}
+
+`);
+      return 0;
+    } else {
+      process.stderr.write(`
+${BOLD4}${RED4}\uD83D\uDEA8 [Causal Memory Audit \uACB0\uD568 \uBC1C\uACAC] \uCD1D ${audit.issues.length}\uAC1C \uD56D\uBAA9 \uC774\uC0C1 \uBC1C\uC0DD:${RESET4}
+`);
+      for (const issue of audit.issues) {
+        process.stderr.write(`  \u2022 ${issue}
+`);
+      }
+      process.stderr.write(`
+`);
+      return 1;
+    }
+  }
+  if (subCommand === "serve") {
+    let port = CAUSAL_MEMORY_CONFIG.DEFAULT_PORT;
+    let host = CAUSAL_MEMORY_CONFIG.DEFAULT_HOST;
+    for (let i = 0;i < subArgs.length; i++) {
+      if (subArgs[i] === "--port" && subArgs[i + 1]) {
+        port = parseInt(subArgs[i + 1], 10);
+      } else if (subArgs[i] === "--host" && subArgs[i + 1]) {
+        host = subArgs[i + 1];
+      }
+    }
+    const server = startCausalServer({ port, host });
+    if (options.agentMode) {
+      process.stdout.write(JSON.stringify({ ok: true, port: server.port, host, url: `http://${host}:${server.port}` }) + `
+`);
+    } else {
+      process.stdout.write(`
+${BOLD4}${GREEN4}\uD83D\uDE80 [Causal Memory Daemon \uAC00\uB3D9 \uC644\uB8CC]${RESET4}
+  \u2022 \uC8FC\uC18C: ${CYAN4}http://${host}:${server.port}${RESET4}
+  \u2022 MCP API: ${GRAY4}http://${host}:${server.port}/mcp${RESET4}
+  \u2022 0ms \uC778\uBA54\uBAA8\uB9AC \uACF5\uBA85 \uB300\uAE30 \uC911... (\uC885\uB8CC: Ctrl+C)
+
+`);
+    }
+    await new Promise(() => {});
+    return 0;
+  }
+  process.stderr.write(`${RED4}\u274C \uC54C \uC218 \uC5C6\uB294 memory \uC11C\uBE0C \uBA85\uB839\uC5B4: '${subCommand}'${RESET4}
+`);
+  printMemoryHelp();
+  return 1;
+}
+
+// src/cli.ts
+var RESET5 = "\x1B[0m";
+var BOLD5 = "\x1B[1m";
+var CYAN5 = "\x1B[36m";
+var GREEN5 = "\x1B[32m";
+var RED5 = "\x1B[31m";
+async function handleInit(targetDir = process.cwd()) {
+  const configPath = resolve5(targetDir, "synapse.config.ts");
+  if (existsSync6(configPath)) {
+    process.stderr.write(`${RED5}\u274C ${t("configExists")} ${configPath}${RESET5}
+`);
+    return 1;
+  }
+  const template = `import { defineConfig, rustChecker, svelteChecker, schemaChecker, nativeChecker, nsisChecker } from 'synapse-kit';
+
+export default defineConfig({
+  aiMemory: {
+    enabled: true,
+    smartSkipping: true,
+  },
+  plugins: [
+    rustChecker({ workspaceDir: './src-tauri' }),
+    svelteChecker({ tsconfig: './tsconfig.json' }),
+    schemaChecker({
+      targets: [
+        { path: './src-tauri/tauri.conf.json' },
+      ],
+    }),
+    nativeChecker({
+      targets: [
+        { path: './src-tauri/resources/vesper_apo.dll', expectedArchitecture: 'x64' },
+      ],
+    }),
+    nsisChecker({
+      templatePath: './installer-template.nsi',
+    }),
+  ],
+  buildTracks: [
+    {
+      name: 'APO DLL \uBE4C\uB4DC',
+      command: ['bun', 'tooling/build-apo.mjs'],
+      sources: ['vesper-apo/'],
+      artifacts: ['src-tauri/resources/vesper_apo.dll'],
+    },
+    {
+      name: 'Taskbar \uC704\uC82F \uBE4C\uB4DC',
+      command: ['bun', 'tooling/build-taskbar.mjs'],
+      sources: ['windhawk/', 'standalone/'],
+      artifacts: ['src-tauri/resources/taskbar/VesperTaskbar.dll'],
+    },
+    {
+      name: 'Svelte UI \uBE4C\uB4DC',
+      command: ['bun', 'run', 'build'],
+      sources: ['src/', 'static/'],
+      artifacts: ['build/index.html'],
+    },
+  ],
+  package: {
+    framework: 'tauri',
+    targets: ['nsis'],
+    compression: 'zlib',
+  },
+  sign: {
+    privateKeyPath: 'src-tauri/keys/updater',
+    passwordEnv: 'TAURI_KEY_PASSWORD',
+  },
+});
+`;
+  await writeFile(configPath, template, "utf8");
+  process.stdout.write(`${BOLD5}${GREEN5}\u2705 ${t("configCreated")}${RESET5}
+`);
+  return 0;
+}
+function printHelp() {
+  process.stdout.write(`
+${BOLD5}${CYAN5}${t("cliTitle")}${RESET5}
+
+${BOLD5}${t("cliUsage")}${RESET5}
+  synapse <command> [options]
+
+${BOLD5}${t("cliCommands")}${RESET5}
+  check          ${t("cmdCheck")}
+  build          ${t("cmdBuild")}
+  package        ${t("cmdPackage")}
+  sign           ${t("cmdSign")}
+  init           ${t("cmdInit")}
+  memory         ${t("cmdMemory")}
+
+${BOLD5}${t("cliOptions")}${RESET5}
+  --all              ${t("optAll")}
+  -f, --force        ${t("optForce")}
+  --agent            ${t("optAgent")}
+  --compact          ${t("optCompact")}
+  -i, --interactive  ${t("optInteractive")}
+  --watch            ${t("optWatch")}
+  --lang <ko|en>     ${t("optLang")}
+  --help, -h         ${t("optHelp")}
+  --version, -v      ${t("optVersion")}
+
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  let explicitLang;
+  for (let i = 0;i < args.length; i++) {
+    if (args[i].startsWith("--lang=")) {
+      explicitLang = args[i].split("=")[1];
+    } else if (args[i] === "--lang" && args[i + 1]) {
+      explicitLang = args[i + 1];
+    }
+  }
+  detectLocale(explicitLang);
+  if (args.includes("--help") || args.includes("-h") || args[0] === "help") {
+    printHelp();
+    process.exit(0);
+  }
+  if (args.includes("--version") || args.includes("-v") || args[0] === "version") {
+    process.stdout.write(`synapse-kit v${package_default.version}
+`);
+    process.exit(0);
+  }
+  const command = args.find((a) => !a.startsWith("-")) || "check";
+  if (command === "init") {
+    const code = await handleInit();
+    process.exit(code);
+  }
+  const isInteractive = args.includes("--interactive") || args.includes("-i");
+  const isForce = args.includes("--force") || args.includes("-f");
+  const options = {
+    mode: args.includes("--all") ? "all" : "smart",
+    agentMode: args.includes("--agent") || args.includes("--compact"),
+    compactMode: args.includes("--compact"),
+    watch: args.includes("--watch"),
+    interactive: isInteractive,
+    force: isForce
+  };
+  if (command === "memory") {
+    const code = await handleMemoryCommand(args, options);
+    process.exit(code);
+  }
+  try {
+    const { config } = await loadSynapseConfig();
+    if (command === "check") {
+      const code = await executeChecks(config, options);
+      process.exit(code);
+    } else if (command === "build") {
+      const code = await executeBuild(config, options);
+      process.exit(code);
+    } else if (command === "package") {
+      const code = await executePackage(config, options);
+      process.exit(code);
+    } else if (command === "sign") {
+      const code = await executeSign(config, options);
+      process.exit(code);
+    } else {
+      process.stderr.write(`${RED5}\u274C ${t("unknownCmd")} '${command}'${RESET5}
+`);
+      printHelp();
+      process.exit(1);
+    }
+  } catch (error) {
+    if (options.agentMode) {
+      process.stdout.write(JSON.stringify({
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      }) + `
+`);
+    } else {
+      process.stderr.write(`${RED5}${t("errPrefix")}${RESET5} ${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    process.exit(1);
+  }
+}
+main();