trellis 1.0.8 → 2.0.6

package/dist/index-1j1anhmr.js

@@ -0,0 +1,4038 @@
+// @bun
+import {
+  EAVStore
+} from "./index-gkvhzm9f.js";
+import {
+  BlobStore,
+  addCriterion,
+  assignIssue,
+  blockIssue,
+  buildFileStateAtOp,
+  checkCompletionReadiness,
+  closeIssue,
+  createBranch,
+  createCheckpoint,
+  createIssue,
+  createMilestone,
+  decompose,
+  deleteBranch,
+  diffFileStates,
+  diffOpRange,
+  getActiveIssues,
+  getIssue,
+  listBranches,
+  listCheckpoints,
+  listIssues,
+  listMilestones,
+  loadBranchState,
+  pauseIssue,
+  reopenIssue,
+  resumeIssue,
+  runCriteria,
+  saveBranchState,
+  setCriterionStatus,
+  startIssue,
+  switchBranch,
+  threeWayMerge,
+  triageIssue,
+  unblockIssue,
+  updateIssue
+} from "./index-3s0eak0p.js";
+import {
+  getDecision,
+  getDecisionChain,
+  queryDecisions,
+  recordDecision
+} from "./index-8pce39mh.js";
+import {
+  DEFAULT_CONFIG,
+  createVcsOp
+} from "./index-fd4e26s4.js";
+
+// src/watcher/fs-watcher.ts
+import { watch } from "fs";
+import { readdir, stat, readFile } from "fs/promises";
+import { join, relative } from "path";
+async function hashFile(filePath) {
+  const content = await readFile(filePath);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", content);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function shouldIgnore(relPath, patterns) {
+  for (const pattern of patterns) {
+    if (pattern.startsWith("*.")) {
+      const ext = pattern.slice(1);
+      if (relPath.endsWith(ext))
+        return true;
+    } else if (relPath.includes(pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+class FileWatcher {
+  config;
+  watchers = [];
+  debounceTimers = new Map;
+  knownFiles = new Map;
+  running = false;
+  constructor(config) {
+    this.config = config;
+  }
+  async scan() {
+    const events = [];
+    const entries = await this.walkDir(this.config.rootPath);
+    for (const absPath of entries) {
+      const relPath = relative(this.config.rootPath, absPath);
+      if (shouldIgnore(relPath, this.config.ignorePatterns))
+        continue;
+      try {
+        const hash = await hashFile(absPath);
+        const stats = await stat(absPath);
+        this.knownFiles.set(relPath, hash);
+        events.push({
+          type: "add",
+          path: relPath,
+          contentHash: hash,
+          size: stats.size,
+          timestamp: new Date().toISOString()
+        });
+      } catch {}
+    }
+    return events;
+  }
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    try {
+      const watcher = watch(this.config.rootPath, { recursive: true }, (eventType, filename) => {
+        if (!filename)
+          return;
+        const relPath = filename.toString();
+        if (shouldIgnore(relPath, this.config.ignorePatterns))
+          return;
+        this.debouncedHandle(relPath);
+      });
+      this.watchers.push(watcher);
+    } catch {
+      console.warn("Recursive watch not supported; using scan-based polling.");
+    }
+  }
+  stop() {
+    this.running = false;
+    for (const w of this.watchers) {
+      w.close();
+    }
+    this.watchers = [];
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+  getKnownFiles() {
+    return new Map(this.knownFiles);
+  }
+  debouncedHandle(relPath) {
+    const existing = this.debounceTimers.get(relPath);
+    if (existing)
+      clearTimeout(existing);
+    const timer = setTimeout(async () => {
+      this.debounceTimers.delete(relPath);
+      await this.handleChange(relPath);
+    }, this.config.debounceMs);
+    this.debounceTimers.set(relPath, timer);
+  }
+  async handleChange(relPath) {
+    const absPath = join(this.config.rootPath, relPath);
+    const known = this.knownFiles.get(relPath);
+    try {
+      const stats = await stat(absPath);
+      if (!stats.isFile())
+        return;
+      const hash = await hashFile(absPath);
+      if (!known) {
+        this.knownFiles.set(relPath, hash);
+        await this.config.onEvent({
+          type: "add",
+          path: relPath,
+          contentHash: hash,
+          size: stats.size,
+          timestamp: new Date().toISOString()
+        });
+      } else if (known !== hash) {
+        const oldHash = known;
+        this.knownFiles.set(relPath, hash);
+        await this.config.onEvent({
+          type: "modify",
+          path: relPath,
+          contentHash: hash,
+          oldContentHash: oldHash,
+          size: stats.size,
+          timestamp: new Date().toISOString()
+        });
+      }
+    } catch {
+      if (known) {
+        this.knownFiles.delete(relPath);
+        await this.config.onEvent({
+          type: "delete",
+          path: relPath,
+          contentHash: known,
+          timestamp: new Date().toISOString()
+        });
+      }
+    }
+  }
+  async walkDir(dir) {
+    const results = [];
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        const relFromRoot = relative(this.config.rootPath, fullPath);
+        if (shouldIgnore(relFromRoot, this.config.ignorePatterns))
+          continue;
+        if (entry.isDirectory()) {
+          const sub = await this.walkDir(fullPath);
+          results.push(...sub);
+        } else if (entry.isFile()) {
+          results.push(fullPath);
+        }
+      }
+    } catch {}
+    return results;
+  }
+}
+
+// src/watcher/ingestion.ts
+import { extname } from "path";
+var EXT_LANGUAGE = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".rb": "ruby",
+  ".java": "java",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".cs": "csharp",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".md": "markdown",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".html": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".vue": "vue",
+  ".svelte": "svelte"
+};
+function detectLanguage(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return EXT_LANGUAGE[ext];
+}
+
+class Ingestion {
+  agentId;
+  lastOpHash;
+  onOp;
+  constructor(opts) {
+    this.agentId = opts.agentId;
+    this.lastOpHash = opts.lastOpHash;
+    this.onOp = opts.onOp;
+  }
+  async process(event) {
+    let kind;
+    switch (event.type) {
+      case "add":
+        kind = "vcs:fileAdd";
+        break;
+      case "modify":
+        kind = "vcs:fileModify";
+        break;
+      case "delete":
+        kind = "vcs:fileDelete";
+        break;
+      case "rename":
+        kind = "vcs:fileRename";
+        break;
+    }
+    const op = await createVcsOp(kind, {
+      agentId: this.agentId,
+      previousHash: this.lastOpHash,
+      vcs: {
+        filePath: event.path,
+        oldFilePath: event.oldPath,
+        contentHash: event.contentHash,
+        oldContentHash: event.oldContentHash,
+        size: event.size,
+        language: detectLanguage(event.path)
+      }
+    });
+    this.lastOpHash = op.hash;
+    await this.onOp(op);
+    return op;
+  }
+  async processBatch(events) {
+    const ops = [];
+    for (const event of events) {
+      ops.push(await this.process(event));
+    }
+    return ops;
+  }
+  getLastOpHash() {
+    return this.lastOpHash;
+  }
+}
+
+// src/engine.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync
+} from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2, dirname } from "path";
+
+// src/garden/cluster.ts
+var FILE_OP_KINDS = new Set([
+  "vcs:fileAdd",
+  "vcs:fileModify",
+  "vcs:fileDelete",
+  "vcs:fileRename"
+]);
+function isFileOp(op) {
+  return FILE_OP_KINDS.has(op.kind);
+}
+function extractFiles(ops) {
+  const files = new Set;
+  for (const op of ops) {
+    if (op.vcs?.filePath)
+      files.add(op.vcs.filePath);
+    if (op.vcs?.oldFilePath)
+      files.add(op.vcs.oldFilePath);
+  }
+  return [...files];
+}
+function generateClusterId(prefix, ops) {
+  const hash = ops[0]?.hash?.slice(0, 8) ?? "unknown";
+  return `cluster:${prefix}-${hash}`;
+}
+var contextSwitchDetector = {
+  name: "context-switch",
+  detect(ops, milestonedOpHashes) {
+    const fileOps = ops.filter((o) => isFileOp(o) && !milestonedOpHashes.has(o.hash));
+    if (fileOps.length < 2)
+      return [];
+    const groups = [];
+    let currentGroup = [];
+    let currentFiles = new Set;
+    for (const op of fileOps) {
+      const opFile = op.vcs?.filePath;
+      if (!opFile)
+        continue;
+      const opDir = opFile.split("/").slice(0, -1).join("/") || ".";
+      if (currentGroup.length === 0) {
+        currentGroup.push(op);
+        currentFiles.add(opDir);
+        continue;
+      }
+      const currentDirs = [...currentFiles];
+      const hasOverlap = currentDirs.some((d) => opDir.startsWith(d) || d.startsWith(opDir) || d === opDir);
+      if (hasOverlap) {
+        currentGroup.push(op);
+        currentFiles.add(opDir);
+      } else {
+        if (currentGroup.length > 0) {
+          groups.push(currentGroup);
+        }
+        currentGroup = [op];
+        currentFiles = new Set([opDir]);
+      }
+    }
+    if (currentGroup.length > 0) {
+      groups.push(currentGroup);
+    }
+    const clusters = [];
+    for (let i = 0;i < groups.length - 1; i++) {
+      const group = groups[i];
+      if (group.length < 2)
+        continue;
+      clusters.push({
+        id: generateClusterId("ctx", group),
+        ops: group,
+        firstOp: group[0].hash,
+        lastOp: group[group.length - 1].hash,
+        affectedFiles: extractFiles(group),
+        affectedSymbols: [],
+        estimatedIntent: "",
+        createdAt: group[0].timestamp,
+        abandonedAt: group[group.length - 1].timestamp,
+        status: "abandoned",
+        detectedBy: "context-switch"
+      });
+    }
+    return clusters;
+  }
+};
+var revertDetector = {
+  name: "revert",
+  detect(ops, milestonedOpHashes) {
+    const clusters = [];
+    const hashHistory = new Map;
+    for (let i = 0;i < ops.length; i++) {
+      const op = ops[i];
+      if (!isFileOp(op) || !op.vcs?.filePath || !op.vcs?.contentHash)
+        continue;
+      const filePath = op.vcs.filePath;
+      if (!hashHistory.has(filePath)) {
+        hashHistory.set(filePath, []);
+      }
+      const history = hashHistory.get(filePath);
+      const currentHash = op.vcs.contentHash;
+      const priorIdx = history.findIndex((h) => h.hash === currentHash);
+      if (priorIdx >= 0 && priorIdx < history.length - 1) {
+        const revertedStartIdx = history[priorIdx + 1].opIdx;
+        const revertedEndIdx = history[history.length - 1].opIdx;
+        const revertedOps = ops.slice(revertedStartIdx, revertedEndIdx + 1).filter((o) => isFileOp(o) && o.vcs?.filePath === filePath && !milestonedOpHashes.has(o.hash));
+        if (revertedOps.length >= 2) {
+          clusters.push({
+            id: generateClusterId("rev", revertedOps),
+            ops: revertedOps,
+            firstOp: revertedOps[0].hash,
+            lastOp: revertedOps[revertedOps.length - 1].hash,
+            affectedFiles: [filePath],
+            affectedSymbols: [],
+            estimatedIntent: "",
+            createdAt: revertedOps[0].timestamp,
+            abandonedAt: op.timestamp,
+            status: "abandoned",
+            detectedBy: "revert"
+          });
+        }
+      }
+      history.push({ hash: currentHash, opIdx: i });
+    }
+    return clusters;
+  }
+};
+var staleBranchDetector = {
+  name: "stale-branch",
+  detect(ops, milestonedOpHashes) {
+    const clusters = [];
+    const branchOps = new Map;
+    let currentBranch = "main";
+    for (const op of ops) {
+      if (op.kind === "vcs:branchCreate" && op.vcs?.branchName) {
+        currentBranch = op.vcs.branchName;
+        if (!branchOps.has(currentBranch)) {
+          branchOps.set(currentBranch, []);
+        }
+      }
+      if (isFileOp(op) && !milestonedOpHashes.has(op.hash)) {
+        if (!branchOps.has(currentBranch)) {
+          branchOps.set(currentBranch, []);
+        }
+        branchOps.get(currentBranch).push(op);
+      }
+    }
+    for (const [branchName, fileOps] of branchOps) {
+      if (branchName === "main")
+        continue;
+      if (fileOps.length < 2)
+        continue;
+      const lastOpTime = new Date(fileOps[fileOps.length - 1].timestamp).getTime();
+      const now = Date.now();
+      const daysSinceLastOp = (now - lastOpTime) / (1000 * 60 * 60 * 24);
+      if (daysSinceLastOp > 7) {
+        clusters.push({
+          id: generateClusterId("stale", fileOps),
+          ops: fileOps,
+          firstOp: fileOps[0].hash,
+          lastOp: fileOps[fileOps.length - 1].hash,
+          affectedFiles: extractFiles(fileOps),
+          affectedSymbols: [],
+          estimatedIntent: "",
+          createdAt: fileOps[0].timestamp,
+          abandonedAt: fileOps[fileOps.length - 1].timestamp,
+          status: "abandoned",
+          detectedBy: "stale-branch"
+        });
+      }
+    }
+    return clusters;
+  }
+};
+var defaultDetectors = [
+  contextSwitchDetector,
+  revertDetector,
+  staleBranchDetector
+];
+function detectClusters(ops, milestonedOpHashes, detectors = defaultDetectors) {
+  const seen = new Set;
+  const results = [];
+  for (const detector of detectors) {
+    const clusters = detector.detect(ops, milestonedOpHashes);
+    for (const cluster of clusters) {
+      if (!seen.has(cluster.id)) {
+        seen.add(cluster.id);
+        results.push(cluster);
+      }
+    }
+  }
+  results.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+  return results;
+}
+// src/garden/garden.ts
+class IdeaGarden {
+  ctx;
+  detectors;
+  _cache = null;
+  _revivedIds = new Set;
+  _embedder = null;
+  constructor(ctx, detectors) {
+    this.ctx = ctx;
+    this.detectors = detectors ?? defaultDetectors;
+  }
+  setEmbedder(embedder) {
+    this._embedder = embedder;
+  }
+  invalidate() {
+    this._cache = null;
+  }
+  listClusters() {
+    if (!this._cache) {
+      const ops = this.ctx.readAllOps();
+      const milestoned = this.ctx.getMilestonedOpHashes();
+      this._cache = detectClusters(ops, milestoned, this.detectors);
+      for (const cluster of this._cache) {
+        if (this._revivedIds.has(cluster.id)) {
+          cluster.status = "revived";
+        }
+      }
+    }
+    return this._cache;
+  }
+  getCluster(clusterId) {
+    return this.listClusters().find((c) => c.id === clusterId) ?? null;
+  }
+  search(opts = {}) {
+    let clusters = this.listClusters();
+    if (opts.status) {
+      clusters = clusters.filter((c) => c.status === opts.status);
+    }
+    if (opts.file) {
+      const fileTerm = opts.file.toLowerCase();
+      clusters = clusters.filter((c) => c.affectedFiles.some((f) => f.toLowerCase().includes(fileTerm)));
+    }
+    if (opts.keyword) {
+      const kw = opts.keyword.toLowerCase();
+      clusters = clusters.filter((c) => {
+        if (c.affectedFiles.some((f) => f.toLowerCase().includes(kw)))
+          return true;
+        if (c.estimatedIntent.toLowerCase().includes(kw))
+          return true;
+        if (c.ops.some((o) => o.kind.toLowerCase().includes(kw)))
+          return true;
+        return false;
+      });
+    }
+    if (opts.limit && opts.limit > 0) {
+      clusters = clusters.slice(0, opts.limit);
+    }
+    return clusters;
+  }
+  async semanticSearch(opts = {}) {
+    const keywordResults = this.search({ ...opts, limit: undefined });
+    if (!this._embedder || opts.semantic === false) {
+      const scored2 = keywordResults.map((c) => ({ cluster: c, score: 1 }));
+      if (opts.limit && opts.limit > 0)
+        return scored2.slice(0, opts.limit);
+      return scored2;
+    }
+    const query = opts.keyword ?? opts.file ?? "";
+    if (!query) {
+      const scored2 = keywordResults.map((c) => ({ cluster: c, score: 1 }));
+      if (opts.limit && opts.limit > 0)
+        return scored2.slice(0, opts.limit);
+      return scored2;
+    }
+    const allClusters = this.listClusters();
+    const embeddingResults = await this._embedder.search(query, { limit: 50 });
+    const fileScores = new Map;
+    for (const r of embeddingResults) {
+      if (r.chunk.filePath) {
+        const existing = fileScores.get(r.chunk.filePath) ?? 0;
+        fileScores.set(r.chunk.filePath, Math.max(existing, r.score));
+      }
+    }
+    const scored = [];
+    const keywordIds = new Set(keywordResults.map((c) => c.id));
+    for (const cluster of allClusters) {
+      if (opts.status && cluster.status !== opts.status)
+        continue;
+      if (opts.file) {
+        const fileTerm = opts.file.toLowerCase();
+        if (!cluster.affectedFiles.some((f) => f.toLowerCase().includes(fileTerm)))
+          continue;
+      }
+      let maxScore = 0;
+      for (const file of cluster.affectedFiles) {
+        const s = fileScores.get(file) ?? 0;
+        if (s > maxScore)
+          maxScore = s;
+      }
+      if (keywordIds.has(cluster.id)) {
+        maxScore = Math.max(maxScore, 0.5);
+      }
+      if (maxScore > 0) {
+        scored.push({ cluster, score: maxScore });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    if (opts.limit && opts.limit > 0)
+      return scored.slice(0, opts.limit);
+    return scored;
+  }
+  revive(clusterId) {
+    const cluster = this.getCluster(clusterId);
+    if (!cluster)
+      return null;
+    cluster.status = "revived";
+    this._revivedIds.add(clusterId);
+    this.invalidate();
+    return cluster.ops;
+  }
+  stats() {
+    const clusters = this.listClusters();
+    const allFiles = new Set;
+    let totalOps = 0;
+    for (const c of clusters) {
+      totalOps += c.ops.length;
+      for (const f of c.affectedFiles)
+        allFiles.add(f);
+    }
+    return {
+      total: clusters.length,
+      abandoned: clusters.filter((c) => c.status === "abandoned").length,
+      draft: clusters.filter((c) => c.status === "draft").length,
+      revived: clusters.filter((c) => c.status === "revived").length,
+      totalOps,
+      totalFiles: allFiles.size
+    };
+  }
+}
+function buildMilestonedOpHashes(ops) {
+  const milestoned = new Set;
+  const milestoneOps = ops.filter((o) => o.kind === "vcs:milestoneCreate");
+  for (const mOp of milestoneOps) {
+    const from = mOp.vcs?.fromOpHash;
+    const to = mOp.vcs?.toOpHash;
+    if (!from || !to)
+      continue;
+    const fromIdx = ops.findIndex((o) => o.hash === from);
+    const toIdx = ops.findIndex((o) => o.hash === to);
+    if (fromIdx >= 0 && toIdx >= 0) {
+      for (let i = fromIdx;i <= toIdx; i++) {
+        milestoned.add(ops[i].hash);
+      }
+    }
+    milestoned.add(mOp.hash);
+  }
+  return milestoned;
+}
+// src/semantic/ts-parser.ts
+var typescriptParser = {
+  languages: ["typescript", "javascript", "tsx", "jsx"],
+  parse(content, filePath) {
+    const fileEntityId = `file:${filePath}`;
+    const language = detectLanguage2(filePath);
+    return {
+      fileEntityId,
+      filePath,
+      language,
+      declarations: extractDeclarations(content, filePath),
+      imports: extractImports(content),
+      exports: extractExports(content)
+    };
+  },
+  diff(oldResult, newResult) {
+    return computeSemanticDiff(oldResult, newResult);
+  }
+};
+function detectLanguage2(filePath) {
+  if (filePath.endsWith(".tsx"))
+    return "tsx";
+  if (filePath.endsWith(".jsx"))
+    return "jsx";
+  if (filePath.endsWith(".ts"))
+    return "typescript";
+  if (filePath.endsWith(".js") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs"))
+    return "javascript";
+  return "unknown";
+}
+function extractDeclarations(content, filePath) {
+  const declarations = [];
+  const lines = content.split(`
+`);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("import ") || trimmed.startsWith("export default ") || trimmed.startsWith("export {") && !trimmed.includes("class") && !trimmed.includes("function")) {
+      i++;
+      continue;
+    }
+    const stripped = trimmed.replace(/^export\s+/, "").replace(/^declare\s+/, "").replace(/^abstract\s+/, "").replace(/^async\s+/, "");
+    const result = tryExtractDeclaration(stripped, trimmed, lines, i, filePath);
+    if (result) {
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+    } else {
+      i++;
+    }
+  }
+  return declarations;
+}
+function tryExtractDeclaration(stripped, originalLine, lines, startLine, filePath) {
+  let match = stripped.match(/^function\s+(\w+)/);
+  if (match) {
+    return extractBlock(match[1], "FunctionDef", lines, startLine, filePath);
+  }
+  match = stripped.match(/^class\s+(\w+)/);
+  if (match) {
+    return extractBlock(match[1], "ClassDef", lines, startLine, filePath);
+  }
+  match = stripped.match(/^interface\s+(\w+)/);
+  if (match) {
+    return extractBlock(match[1], "InterfaceDef", lines, startLine, filePath);
+  }
+  match = stripped.match(/^type\s+(\w+)/);
+  if (match) {
+    return extractTypeAlias(match[1], lines, startLine, filePath);
+  }
+  match = stripped.match(/^enum\s+(\w+)/);
+  if (match) {
+    return extractBlock(match[1], "EnumDef", lines, startLine, filePath);
+  }
+  match = stripped.match(/^(?:const|let|var)\s+(\w+)/);
+  if (match) {
+    return extractVariable(match[1], lines, startLine, filePath);
+  }
+  return null;
+}
+function extractBlock(name, kind, lines, startLine, filePath) {
+  let depth = 0;
+  let foundOpen = false;
+  let endLine = startLine;
+  for (let i = startLine;i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "{") {
+        depth++;
+        foundOpen = true;
+      } else if (ch === "}") {
+        depth--;
+      }
+    }
+    if (foundOpen && depth <= 0) {
+      endLine = i;
+      break;
+    }
+    if (i > startLine + 50) {
+      endLine = i;
+      break;
+    }
+    endLine = i;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  const endOffset = startOffset + rawText.length;
+  const children = kind === "ClassDef" || kind === "InterfaceDef" ? extractClassMembers(rawText, name, filePath) : [];
+  return {
+    entity: {
+      id: makeEntityId(filePath, kind, name),
+      kind,
+      name,
+      scopePath: name,
+      span: [startOffset, endOffset],
+      rawText,
+      signature: normalizeSignature(rawText),
+      children
+    },
+    endLine
+  };
+}
+function extractTypeAlias(name, lines, startLine, filePath) {
+  let endLine = startLine;
+  let depth = 0;
+  for (let i = startLine;i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "{" || ch === "(" || ch === "<")
+        depth++;
+      else if (ch === "}" || ch === ")" || ch === ">")
+        depth--;
+    }
+    if (line.includes(";") && depth <= 0) {
+      endLine = i;
+      break;
+    }
+    endLine = i;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId(filePath, "TypeAlias", name),
+      kind: "TypeAlias",
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature(rawText),
+      children: []
+    },
+    endLine
+  };
+}
+function extractVariable(name, lines, startLine, filePath) {
+  let endLine = startLine;
+  let depth = 0;
+  for (let i = startLine;i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "{" || ch === "(" || ch === "[")
+        depth++;
+      else if (ch === "}" || ch === ")" || ch === "]")
+        depth--;
+    }
+    if (depth <= 0 && (line.includes(";") || i > startLine && lines[i + 1]?.trim().match(/^(?:export|const|let|var|function|class|interface|type|enum|import)\s/))) {
+      endLine = i;
+      break;
+    }
+    endLine = i;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId(filePath, "VariableDecl", name),
+      kind: "VariableDecl",
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature(rawText),
+      children: []
+    },
+    endLine
+  };
+}
+function extractClassMembers(classText, className, filePath) {
+  const children = [];
+  const lines = classText.split(`
+`);
+  for (let i = 1;i < lines.length - 1; i++) {
+    const line = lines[i].trim();
+    if (!line || line.startsWith("//") || line.startsWith("/*") || line.startsWith("*"))
+      continue;
+    const methodMatch = line.match(/^(?:(?:public|private|protected|static|async|abstract|readonly)\s+)*(\w+)\s*\(/);
+    if (methodMatch && methodMatch[1] !== "if" && methodMatch[1] !== "for" && methodMatch[1] !== "while") {
+      const methodName = methodMatch[1];
+      const kind = methodName === "constructor" ? "Constructor" : "MethodDef";
+      children.push({
+        id: makeEntityId(filePath, kind, `${className}.${methodName}`),
+        kind,
+        name: methodName,
+        scopePath: `${className}.${methodName}`,
+        span: [0, 0],
+        rawText: line,
+        signature: normalizeSignature(line),
+        children: []
+      });
+      continue;
+    }
+    const propMatch = line.match(/^(?:(?:public|private|protected|static|readonly)\s+)*(\w+)\s*[?:]/);
+    if (propMatch) {
+      const propName = propMatch[1];
+      children.push({
+        id: makeEntityId(filePath, "PropertyDef", `${className}.${propName}`),
+        kind: "PropertyDef",
+        name: propName,
+        scopePath: `${className}.${propName}`,
+        span: [0, 0],
+        rawText: line,
+        signature: normalizeSignature(line),
+        children: []
+      });
+    }
+  }
+  return children;
+}
+function extractImports(content) {
+  const imports = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith("import "))
+      continue;
+    let full = line;
+    while (!full.includes(";") && !full.match(/from\s+['"]/) && i + 1 < lines.length) {
+      i++;
+      full += " " + lines[i].trim();
+    }
+    if (!full.includes(";") && i + 1 < lines.length) {
+      i++;
+      full += " " + lines[i].trim();
+    }
+    const rel = parseImport(full);
+    if (rel)
+      imports.push(rel);
+  }
+  return imports;
+}
+function parseImport(text) {
+  const namedMatch = text.match(/import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/);
+  if (namedMatch) {
+    const specifiers = namedMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+    return {
+      source: namedMatch[2],
+      specifiers,
+      isDefault: false,
+      isNamespace: false,
+      rawText: text,
+      span: [0, text.length]
+    };
+  }
+  const defaultMatch = text.match(/import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/);
+  if (defaultMatch) {
+    return {
+      source: defaultMatch[2],
+      specifiers: [defaultMatch[1]],
+      isDefault: true,
+      isNamespace: false,
+      rawText: text,
+      span: [0, text.length]
+    };
+  }
+  const nsMatch = text.match(/import\s+\*\s+as\s+(\w+)\s+from\s+['"]([^'"]+)['"]/);
+  if (nsMatch) {
+    return {
+      source: nsMatch[2],
+      specifiers: [nsMatch[1]],
+      isDefault: false,
+      isNamespace: true,
+      rawText: text,
+      span: [0, text.length]
+    };
+  }
+  const sideEffectMatch = text.match(/import\s+['"]([^'"]+)['"]/);
+  if (sideEffectMatch) {
+    return {
+      source: sideEffectMatch[1],
+      specifiers: [],
+      isDefault: false,
+      isNamespace: false,
+      rawText: text,
+      span: [0, text.length]
+    };
+  }
+  const typeMatch = text.match(/import\s+type\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/);
+  if (typeMatch) {
+    const specifiers = typeMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+    return {
+      source: typeMatch[2],
+      specifiers,
+      isDefault: false,
+      isNamespace: false,
+      rawText: text,
+      span: [0, text.length]
+    };
+  }
+  return null;
+}
+function extractExports(content) {
+  const exports = [];
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("export default ")) {
+      const nameMatch = trimmed.match(/export default (?:class|function)?\s*(\w+)?/);
+      exports.push({
+        name: nameMatch?.[1] ?? "default",
+        isDefault: true,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+      continue;
+    }
+    const reExportMatch = trimmed.match(/export\s+\{([^}]+)\}(?:\s+from\s+['"]([^'"]+)['"])?/);
+    if (reExportMatch && !trimmed.match(/export\s+(?:function|class|interface|type|enum|const|let|var)/)) {
+      const names = reExportMatch[1].split(",").map((s) => s.trim().split(/\s+as\s+/).pop()).filter(Boolean);
+      for (const name of names) {
+        exports.push({
+          name,
+          isDefault: false,
+          source: reExportMatch[2],
+          rawText: trimmed,
+          span: [0, trimmed.length]
+        });
+      }
+      continue;
+    }
+    const starMatch = trimmed.match(/export\s+\*\s+from\s+['"]([^'"]+)['"]/);
+    if (starMatch) {
+      exports.push({
+        name: "*",
+        isDefault: false,
+        source: starMatch[1],
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+    }
+  }
+  return exports;
+}
+function computeSemanticDiff(oldResult, newResult) {
+  const patches = [];
+  const fileId = newResult.fileEntityId;
+  const oldDecls = new Map(oldResult.declarations.map((d) => [d.id, d]));
+  const newDecls = new Map(newResult.declarations.map((d) => [d.id, d]));
+  const oldByName = new Map(oldResult.declarations.map((d) => [d.name, d]));
+  const newByName = new Map(newResult.declarations.map((d) => [d.name, d]));
+  for (const [id, entity] of newDecls) {
+    if (!oldDecls.has(id)) {
+      const oldEntity = findRenamedEntity(entity, oldResult.declarations, newDecls);
+      if (oldEntity) {
+        patches.push({
+          kind: "symbolRename",
+          entityId: oldEntity.id,
+          oldName: oldEntity.name,
+          newName: entity.name
+        });
+      } else {
+        patches.push({ kind: "symbolAdd", entity });
+      }
+    }
+  }
+  for (const [id, entity] of oldDecls) {
+    if (!newDecls.has(id)) {
+      const wasRenamed = findRenamedEntity(entity, newResult.declarations, oldDecls);
+      if (!wasRenamed) {
+        patches.push({ kind: "symbolRemove", entityId: id, entityName: entity.name });
+      }
+    }
+  }
+  for (const [id, newEntity] of newDecls) {
+    const oldEntity = oldDecls.get(id);
+    if (oldEntity && oldEntity.signature !== newEntity.signature) {
+      patches.push({
+        kind: "symbolModify",
+        entityId: id,
+        entityName: newEntity.name,
+        oldSignature: oldEntity.signature,
+        newSignature: newEntity.signature,
+        oldRawText: oldEntity.rawText,
+        newRawText: newEntity.rawText
+      });
+    }
+  }
+  const oldImports = new Map(oldResult.imports.map((imp) => [imp.source, imp]));
+  const newImports = new Map(newResult.imports.map((imp) => [imp.source, imp]));
+  for (const [source, imp] of newImports) {
+    const oldImp = oldImports.get(source);
+    if (!oldImp) {
+      patches.push({
+        kind: "importAdd",
+        fileId,
+        source,
+        specifiers: imp.specifiers,
+        rawText: imp.rawText
+      });
+    } else if (JSON.stringify(oldImp.specifiers.sort()) !== JSON.stringify(imp.specifiers.sort())) {
+      patches.push({
+        kind: "importModify",
+        fileId,
+        source,
+        oldSpecifiers: oldImp.specifiers,
+        newSpecifiers: imp.specifiers
+      });
+    }
+  }
+  for (const [source] of oldImports) {
+    if (!newImports.has(source)) {
+      patches.push({ kind: "importRemove", fileId, source });
+    }
+  }
+  const oldExports = new Map(oldResult.exports.map((exp) => [exp.name, exp]));
+  const newExports = new Map(newResult.exports.map((exp) => [exp.name, exp]));
+  for (const [name, exp] of newExports) {
+    if (!oldExports.has(name)) {
+      patches.push({ kind: "exportAdd", fileId, name, rawText: exp.rawText });
+    }
+  }
+  for (const [name] of oldExports) {
+    if (!newExports.has(name)) {
+      patches.push({ kind: "exportRemove", fileId, name });
+    }
+  }
+  return patches;
+}
+function findRenamedEntity(entity, candidates, existingIds) {
+  for (const candidate of candidates) {
+    if (candidate.kind !== entity.kind)
+      continue;
+    if (candidate.name === entity.name)
+      continue;
+    if (existingIds.has(candidate.id))
+      continue;
+    const normalizedOld = candidate.signature.replace(new RegExp(candidate.name, "g"), "___");
+    const normalizedNew = entity.signature.replace(new RegExp(entity.name, "g"), "___");
+    if (normalizedOld === normalizedNew) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function makeEntityId(filePath, kind, name) {
+  return `${kind}:${filePath}:${name}`;
+}
+function normalizeSignature(text) {
+  return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/;\s*$/, "").trim();
+}
+// src/semantic/python-parser.ts
+var pythonParser = {
+  languages: ["python"],
+  parse(content, filePath) {
+    const fileEntityId = `file:${filePath}`;
+    return {
+      fileEntityId,
+      filePath,
+      language: "python",
+      declarations: extractDeclarations2(content, filePath),
+      imports: extractImports2(content),
+      exports: extractExports2(content)
+    };
+  },
+  diff(oldResult, newResult) {
+    return computeSemanticDiff2(oldResult, newResult);
+  }
+};
+function extractDeclarations2(content, filePath) {
+  const declarations = [];
+  const lines = content.split(`
+`);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith('"""') || trimmed.startsWith("'''")) {
+      i++;
+      continue;
+    }
+    if (line.length > 0 && line[0] === " " || line[0] === "\t") {
+      i++;
+      continue;
+    }
+    const decorators = [];
+    const decoratorStart = i;
+    while (i < lines.length && lines[i].trim().startsWith("@")) {
+      decorators.push(lines[i].trim());
+      i++;
+    }
+    if (i >= lines.length)
+      break;
+    const declLine = lines[i].trim();
+    let match = declLine.match(/^class\s+(\w+)/);
+    if (match) {
+      const result = extractIndentedBlock(match[1], "ClassDef", lines, decorators.length > 0 ? decoratorStart : i, i, filePath, decorators);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = declLine.match(/^async\s+def\s+(\w+)/);
+    if (match) {
+      const result = extractIndentedBlock(match[1], "FunctionDef", lines, decorators.length > 0 ? decoratorStart : i, i, filePath, decorators);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = declLine.match(/^def\s+(\w+)/);
+    if (match) {
+      const result = extractIndentedBlock(match[1], "FunctionDef", lines, decorators.length > 0 ? decoratorStart : i, i, filePath, decorators);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = declLine.match(/^([A-Za-z_]\w*)\s*(?::\s*\w[^=]*)?\s*=/);
+    if (match && match[1] !== "__all__" && !declLine.startsWith("import ") && !declLine.startsWith("from ")) {
+      const result = extractAssignment(match[1], lines, i, filePath);
+      if (decorators.length === 0) {
+        declarations.push(result.entity);
+      }
+      i = result.endLine + 1;
+      continue;
+    }
+    if (decorators.length > 0) {
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return declarations;
+}
+function extractIndentedBlock(name, kind, lines, startLine, defLine, filePath, decorators) {
+  let headerEnd = defLine;
+  while (headerEnd < lines.length && !lines[headerEnd].includes(":")) {
+    headerEnd++;
+  }
+  let bodyIndent = -1;
+  let endLine = headerEnd;
+  for (let i = headerEnd + 1;i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      endLine = i;
+      continue;
+    }
+    const indent = line.length - line.trimStart().length;
+    if (bodyIndent < 0) {
+      bodyIndent = indent;
+      endLine = i;
+      continue;
+    }
+    if (indent >= bodyIndent) {
+      endLine = i;
+    } else {
+      break;
+    }
+  }
+  while (endLine > headerEnd && lines[endLine].trim() === "") {
+    endLine--;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  const children = kind === "ClassDef" ? extractClassMembers2(lines, headerEnd, endLine, bodyIndent, name, filePath) : [];
+  return {
+    entity: {
+      id: makeEntityId2(filePath, kind, name),
+      kind,
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature2(rawText),
+      children
+    },
+    endLine
+  };
+}
+function extractAssignment(name, lines, startLine, filePath) {
+  let endLine = startLine;
+  let depth = 0;
+  for (let i = startLine;i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "(" || ch === "[" || ch === "{")
+        depth++;
+      else if (ch === ")" || ch === "]" || ch === "}")
+        depth--;
+    }
+    endLine = i;
+    if (depth <= 0 && i > startLine)
+      break;
+    if (depth <= 0 && i === startLine) {
+      if (i + 1 < lines.length) {
+        const next = lines[i + 1];
+        if (!next.trim() || !next.startsWith(" ") && !next.startsWith("\t")) {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId2(filePath, "VariableDecl", name),
+      kind: "VariableDecl",
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature2(rawText),
+      children: []
+    },
+    endLine
+  };
+}
+function extractClassMembers2(lines, headerEnd, blockEnd, bodyIndent, className, filePath) {
+  const children = [];
+  if (bodyIndent < 0)
+    return children;
+  for (let i = headerEnd + 1;i <= blockEnd; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith('"""') || trimmed.startsWith("'''"))
+      continue;
+    const indent = line.length - line.trimStart().length;
+    if (indent !== bodyIndent)
+      continue;
+    if (trimmed.startsWith("@"))
+      continue;
+    let match = trimmed.match(/^(?:async\s+)?def\s+(\w+)/);
+    if (match) {
+      const methodName = match[1];
+      const kind = methodName === "__init__" ? "Constructor" : "MethodDef";
+      children.push({
+        id: makeEntityId2(filePath, kind, `${className}.${methodName}`),
+        kind,
+        name: methodName,
+        scopePath: `${className}.${methodName}`,
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature2(trimmed),
+        children: []
+      });
+      continue;
+    }
+    match = trimmed.match(/^(\w+)\s*(?::\s*\S[^=]*)?\s*=/);
+    if (match) {
+      children.push({
+        id: makeEntityId2(filePath, "PropertyDef", `${className}.${match[1]}`),
+        kind: "PropertyDef",
+        name: match[1],
+        scopePath: `${className}.${match[1]}`,
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature2(trimmed),
+        children: []
+      });
+    }
+  }
+  return children;
+}
+function extractImports2(content) {
+  const imports = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    let match = trimmed.match(/^from\s+([\w.]+)\s+import\s+(.+)/);
+    if (match) {
+      let specText = match[2];
+      if (specText.includes("(") && !specText.includes(")")) {
+        while (i + 1 < lines.length && !specText.includes(")")) {
+          i++;
+          specText += " " + lines[i].trim();
+        }
+      }
+      specText = specText.replace(/[()]/g, "").replace(/#.*$/, "");
+      const specifiers = specText.split(",").map((s) => s.trim().split(/\s+as\s+/).pop()).filter(Boolean);
+      const isWildcard = specifiers.includes("*");
+      imports.push({
+        source: match[1],
+        specifiers: isWildcard ? ["*"] : specifiers,
+        isDefault: false,
+        isNamespace: isWildcard,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+      continue;
+    }
+    match = trimmed.match(/^import\s+([\w.,\s]+)/);
+    if (match) {
+      const modules = match[1].split(",").map((m) => m.trim());
+      for (const mod of modules) {
+        const parts = mod.split(/\s+as\s+/);
+        const source = parts[0].trim();
+        const alias = parts.length > 1 ? parts[1].trim() : source;
+        imports.push({
+          source,
+          specifiers: [alias],
+          isDefault: true,
+          isNamespace: false,
+          rawText: trimmed,
+          span: [0, trimmed.length]
+        });
+      }
+    }
+  }
+  return imports;
+}
+function extractExports2(content) {
+  const exports = [];
+  const allMatch = content.match(/__all__\s*=\s*\[([^\]]*)\]/s);
+  if (allMatch) {
+    const names = allMatch[1].replace(/['"]/g, "").split(",").map((s) => s.trim()).filter(Boolean);
+    for (const name of names) {
+      exports.push({
+        name,
+        isDefault: false,
+        rawText: `__all__: ${name}`,
+        span: [0, 0]
+      });
+    }
+  }
+  return exports;
+}
+function computeSemanticDiff2(oldResult, newResult) {
+  const patches = [];
+  const fileId = newResult.fileEntityId;
+  const oldDecls = new Map(oldResult.declarations.map((d) => [d.id, d]));
+  const newDecls = new Map(newResult.declarations.map((d) => [d.id, d]));
+  for (const [id, entity] of newDecls) {
+    if (!oldDecls.has(id)) {
+      const oldEntity = findRenamedEntity2(entity, oldResult.declarations, newDecls);
+      if (oldEntity) {
+        patches.push({
+          kind: "symbolRename",
+          entityId: oldEntity.id,
+          oldName: oldEntity.name,
+          newName: entity.name
+        });
+      } else {
+        patches.push({ kind: "symbolAdd", entity });
+      }
+    }
+  }
+  for (const [id, entity] of oldDecls) {
+    if (!newDecls.has(id)) {
+      const wasRenamed = findRenamedEntity2(entity, newResult.declarations, oldDecls);
+      if (!wasRenamed) {
+        patches.push({
+          kind: "symbolRemove",
+          entityId: id,
+          entityName: entity.name
+        });
+      }
+    }
+  }
+  for (const [id, newEntity] of newDecls) {
+    const oldEntity = oldDecls.get(id);
+    if (oldEntity && oldEntity.signature !== newEntity.signature) {
+      patches.push({
+        kind: "symbolModify",
+        entityId: id,
+        entityName: newEntity.name,
+        oldSignature: oldEntity.signature,
+        newSignature: newEntity.signature,
+        oldRawText: oldEntity.rawText,
+        newRawText: newEntity.rawText
+      });
+    }
+  }
+  const oldImports = new Map(oldResult.imports.map((imp) => [imp.source, imp]));
+  const newImports = new Map(newResult.imports.map((imp) => [imp.source, imp]));
+  for (const [source, imp] of newImports) {
+    const oldImp = oldImports.get(source);
+    if (!oldImp) {
+      patches.push({
+        kind: "importAdd",
+        fileId,
+        source,
+        specifiers: imp.specifiers,
+        rawText: imp.rawText
+      });
+    } else if (JSON.stringify(oldImp.specifiers.sort()) !== JSON.stringify(imp.specifiers.sort())) {
+      patches.push({
+        kind: "importModify",
+        fileId,
+        source,
+        oldSpecifiers: oldImp.specifiers,
+        newSpecifiers: imp.specifiers
+      });
+    }
+  }
+  for (const [source] of oldImports) {
+    if (!newImports.has(source)) {
+      patches.push({ kind: "importRemove", fileId, source });
+    }
+  }
+  const oldExports = new Map(oldResult.exports.map((exp) => [exp.name, exp]));
+  const newExports = new Map(newResult.exports.map((exp) => [exp.name, exp]));
+  for (const [name, exp] of newExports) {
+    if (!oldExports.has(name)) {
+      patches.push({ kind: "exportAdd", fileId, name, rawText: exp.rawText });
+    }
+  }
+  for (const [name] of oldExports) {
+    if (!newExports.has(name)) {
+      patches.push({ kind: "exportRemove", fileId, name });
+    }
+  }
+  return patches;
+}
+function findRenamedEntity2(entity, candidates, existingIds) {
+  for (const candidate of candidates) {
+    if (candidate.kind !== entity.kind)
+      continue;
+    if (candidate.name === entity.name)
+      continue;
+    if (existingIds.has(candidate.id))
+      continue;
+    const normalizedOld = candidate.signature.replace(new RegExp(candidate.name, "g"), "___");
+    const normalizedNew = entity.signature.replace(new RegExp(entity.name, "g"), "___");
+    if (normalizedOld === normalizedNew) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function makeEntityId2(filePath, kind, name) {
+  return `${kind}:${filePath}:${name}`;
+}
+function normalizeSignature2(text) {
+  return text.replace(/#[^\n]*/g, "").replace(/"""[\s\S]*?"""/g, "").replace(/'''[\s\S]*?'''/g, "").replace(/\s+/g, " ").trim();
+}
+// src/semantic/go-parser.ts
+var goParser = {
+  languages: ["go"],
+  parse(content, filePath) {
+    const fileEntityId = `file:${filePath}`;
+    return {
+      fileEntityId,
+      filePath,
+      language: "go",
+      declarations: extractDeclarations3(content, filePath),
+      imports: extractImports3(content),
+      exports: extractExports3(content, filePath)
+    };
+  },
+  diff(oldResult, newResult) {
+    return computeSemanticDiff3(oldResult, newResult);
+  }
+};
+function extractDeclarations3(content, filePath) {
+  const declarations = [];
+  const lines = content.split(`
+`);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("package ") || trimmed.startsWith("import ")) {
+      i++;
+      continue;
+    }
+    if (trimmed === "import (") {
+      while (i < lines.length && !lines[i].trim().startsWith(")")) {
+        i++;
+      }
+      i++;
+      continue;
+    }
+    let match = trimmed.match(/^func\s+(\w+)\s*\(/);
+    if (match) {
+      const result = extractBraceBlock(match[1], "FunctionDef", lines, i, filePath);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = trimmed.match(/^func\s+\([^)]+\)\s+(\w+)\s*\(/);
+    if (match) {
+      const result = extractBraceBlock(match[1], "MethodDef", lines, i, filePath);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = trimmed.match(/^type\s+(\w+)\s+struct\b/);
+    if (match) {
+      const result = extractBraceBlock(match[1], "ClassDef", lines, i, filePath);
+      result.entity.children = extractStructFields(lines, i, result.endLine, match[1], filePath);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = trimmed.match(/^type\s+(\w+)\s+interface\b/);
+    if (match) {
+      const result = extractBraceBlock(match[1], "InterfaceDef", lines, i, filePath);
+      result.entity.children = extractInterfaceMethods(lines, i, result.endLine, match[1], filePath);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = trimmed.match(/^type\s+(\w+)\s+/);
+    if (match) {
+      const result = extractSingleOrBlock(match[1], "TypeAlias", lines, i, filePath);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    if (trimmed.startsWith("const ") || trimmed === "const (") {
+      if (trimmed === "const (") {
+        const endLine = findClosingParen(lines, i);
+        const rawText = lines.slice(i, endLine + 1).join(`
+`);
+        const consts = extractConstBlock(lines, i, endLine, filePath);
+        declarations.push(...consts);
+        i = endLine + 1;
+      } else {
+        match = trimmed.match(/^const\s+(\w+)/);
+        if (match) {
+          const result = extractSingleLine(match[1], "VariableDecl", lines, i, filePath);
+          declarations.push(result.entity);
+          i = result.endLine + 1;
+        } else {
+          i++;
+        }
+      }
+      continue;
+    }
+    if (trimmed.startsWith("var ") || trimmed === "var (") {
+      if (trimmed === "var (") {
+        const endLine = findClosingParen(lines, i);
+        const vars = extractVarBlock(lines, i, endLine, filePath);
+        declarations.push(...vars);
+        i = endLine + 1;
+      } else {
+        match = trimmed.match(/^var\s+(\w+)/);
+        if (match) {
+          const result = extractSingleLine(match[1], "VariableDecl", lines, i, filePath);
+          declarations.push(result.entity);
+          i = result.endLine + 1;
+        } else {
+          i++;
+        }
+      }
+      continue;
+    }
+    i++;
+  }
+  return declarations;
+}
+function extractBraceBlock(name, kind, lines, startLine, filePath) {
+  let depth = 0;
+  let foundOpen = false;
+  let endLine = startLine;
+  for (let i = startLine;i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === "{") {
+        depth++;
+        foundOpen = true;
+      } else if (ch === "}") {
+        depth--;
+      }
+    }
+    if (foundOpen && depth <= 0) {
+      endLine = i;
+      break;
+    }
+    if (i > startLine + 200) {
+      endLine = i;
+      break;
+    }
+    endLine = i;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId3(filePath, kind, name),
+      kind,
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature3(rawText),
+      children: []
+    },
+    endLine
+  };
+}
+function extractSingleOrBlock(name, kind, lines, startLine, filePath) {
+  const trimmed = lines[startLine].trim();
+  if (trimmed.includes("{")) {
+    return extractBraceBlock(name, kind, lines, startLine, filePath);
+  }
+  return extractSingleLine(name, kind, lines, startLine, filePath);
+}
+function extractSingleLine(name, kind, lines, startLine, filePath) {
+  const rawText = lines[startLine];
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId3(filePath, kind, name),
+      kind,
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature3(rawText),
+      children: []
+    },
+    endLine: startLine
+  };
+}
+function findClosingParen(lines, startLine) {
+  for (let i = startLine + 1;i < lines.length; i++) {
+    if (lines[i].trim() === ")")
+      return i;
+  }
+  return lines.length - 1;
+}
+function extractStructFields(lines, startLine, endLine, structName, filePath) {
+  const children = [];
+  for (let i = startLine + 1;i < endLine; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed === "{" || trimmed === "}")
+      continue;
+    const match = trimmed.match(/^(\w+)\s+/);
+    if (match) {
+      children.push({
+        id: makeEntityId3(filePath, "PropertyDef", `${structName}.${match[1]}`),
+        kind: "PropertyDef",
+        name: match[1],
+        scopePath: `${structName}.${match[1]}`,
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature3(trimmed),
+        children: []
+      });
+    }
+  }
+  return children;
+}
+function extractInterfaceMethods(lines, startLine, endLine, ifaceName, filePath) {
+  const children = [];
+  for (let i = startLine + 1;i < endLine; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed === "{" || trimmed === "}")
+      continue;
+    const match = trimmed.match(/^(\w+)\s*\(/);
+    if (match) {
+      children.push({
+        id: makeEntityId3(filePath, "MethodDef", `${ifaceName}.${match[1]}`),
+        kind: "MethodDef",
+        name: match[1],
+        scopePath: `${ifaceName}.${match[1]}`,
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature3(trimmed),
+        children: []
+      });
+    }
+  }
+  return children;
+}
+function extractConstBlock(lines, startLine, endLine, filePath) {
+  const entities = [];
+  for (let i = startLine + 1;i < endLine; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("//"))
+      continue;
+    const match = trimmed.match(/^(\w+)/);
+    if (match) {
+      entities.push({
+        id: makeEntityId3(filePath, "VariableDecl", match[1]),
+        kind: "VariableDecl",
+        name: match[1],
+        scopePath: match[1],
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature3(trimmed),
+        children: []
+      });
+    }
+  }
+  return entities;
+}
+function extractVarBlock(lines, startLine, endLine, filePath) {
+  return extractConstBlock(lines, startLine, endLine, filePath);
+}
+function extractImports3(content) {
+  const imports = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    let match = trimmed.match(/^import\s+"([^"]+)"/);
+    if (match) {
+      imports.push({
+        source: match[1],
+        specifiers: [match[1].split("/").pop()],
+        isDefault: true,
+        isNamespace: false,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+      continue;
+    }
+    if (trimmed === "import (") {
+      for (let j = i + 1;j < lines.length; j++) {
+        const impLine = lines[j].trim();
+        if (impLine === ")") {
+          i = j;
+          break;
+        }
+        if (!impLine || impLine.startsWith("//"))
+          continue;
+        const aliasMatch = impLine.match(/^(\w+)\s+"([^"]+)"/);
+        if (aliasMatch) {
+          imports.push({
+            source: aliasMatch[2],
+            specifiers: [aliasMatch[1]],
+            isDefault: true,
+            isNamespace: false,
+            rawText: impLine,
+            span: [0, impLine.length]
+          });
+          continue;
+        }
+        const dotMatch = impLine.match(/^\.\s+"([^"]+)"/);
+        if (dotMatch) {
+          imports.push({
+            source: dotMatch[1],
+            specifiers: ["*"],
+            isDefault: false,
+            isNamespace: true,
+            rawText: impLine,
+            span: [0, impLine.length]
+          });
+          continue;
+        }
+        const stdMatch = impLine.match(/^"([^"]+)"/);
+        if (stdMatch) {
+          imports.push({
+            source: stdMatch[1],
+            specifiers: [stdMatch[1].split("/").pop()],
+            isDefault: true,
+            isNamespace: false,
+            rawText: impLine,
+            span: [0, impLine.length]
+          });
+        }
+      }
+    }
+  }
+  return imports;
+}
+function extractExports3(content, filePath) {
+  const exports = [];
+  const decls = extractDeclarations3(content, filePath);
+  for (const d of decls) {
+    if (d.name[0] >= "A" && d.name[0] <= "Z") {
+      exports.push({
+        name: d.name,
+        isDefault: false,
+        rawText: d.rawText.split(`
+`)[0],
+        span: d.span
+      });
+    }
+  }
+  return exports;
+}
+function computeSemanticDiff3(oldResult, newResult) {
+  const patches = [];
+  const fileId = newResult.fileEntityId;
+  const oldDecls = new Map(oldResult.declarations.map((d) => [d.id, d]));
+  const newDecls = new Map(newResult.declarations.map((d) => [d.id, d]));
+  for (const [id, entity] of newDecls) {
+    if (!oldDecls.has(id)) {
+      const oldEntity = findRenamedEntity3(entity, oldResult.declarations, newDecls);
+      if (oldEntity) {
+        patches.push({ kind: "symbolRename", entityId: oldEntity.id, oldName: oldEntity.name, newName: entity.name });
+      } else {
+        patches.push({ kind: "symbolAdd", entity });
+      }
+    }
+  }
+  for (const [id, entity] of oldDecls) {
+    if (!newDecls.has(id)) {
+      const wasRenamed = findRenamedEntity3(entity, newResult.declarations, oldDecls);
+      if (!wasRenamed) {
+        patches.push({ kind: "symbolRemove", entityId: id, entityName: entity.name });
+      }
+    }
+  }
+  for (const [id, newEntity] of newDecls) {
+    const oldEntity = oldDecls.get(id);
+    if (oldEntity && oldEntity.signature !== newEntity.signature) {
+      patches.push({
+        kind: "symbolModify",
+        entityId: id,
+        entityName: newEntity.name,
+        oldSignature: oldEntity.signature,
+        newSignature: newEntity.signature,
+        oldRawText: oldEntity.rawText,
+        newRawText: newEntity.rawText
+      });
+    }
+  }
+  const oldImports = new Map(oldResult.imports.map((imp) => [imp.source, imp]));
+  const newImports = new Map(newResult.imports.map((imp) => [imp.source, imp]));
+  for (const [source, imp] of newImports) {
+    const oldImp = oldImports.get(source);
+    if (!oldImp) {
+      patches.push({ kind: "importAdd", fileId, source, specifiers: imp.specifiers, rawText: imp.rawText });
+    } else if (JSON.stringify(oldImp.specifiers.sort()) !== JSON.stringify(imp.specifiers.sort())) {
+      patches.push({ kind: "importModify", fileId, source, oldSpecifiers: oldImp.specifiers, newSpecifiers: imp.specifiers });
+    }
+  }
+  for (const [source] of oldImports) {
+    if (!newImports.has(source)) {
+      patches.push({ kind: "importRemove", fileId, source });
+    }
+  }
+  const oldExports = new Map(oldResult.exports.map((exp) => [exp.name, exp]));
+  const newExports = new Map(newResult.exports.map((exp) => [exp.name, exp]));
+  for (const [name, exp] of newExports) {
+    if (!oldExports.has(name)) {
+      patches.push({ kind: "exportAdd", fileId, name, rawText: exp.rawText });
+    }
+  }
+  for (const [name] of oldExports) {
+    if (!newExports.has(name)) {
+      patches.push({ kind: "exportRemove", fileId, name });
+    }
+  }
+  return patches;
+}
+function findRenamedEntity3(entity, candidates, existingIds) {
+  for (const candidate of candidates) {
+    if (candidate.kind !== entity.kind)
+      continue;
+    if (candidate.name === entity.name)
+      continue;
+    if (existingIds.has(candidate.id))
+      continue;
+    const normalizedOld = candidate.signature.replace(new RegExp(candidate.name, "g"), "___");
+    const normalizedNew = entity.signature.replace(new RegExp(entity.name, "g"), "___");
+    if (normalizedOld === normalizedNew)
+      return candidate;
+  }
+  return null;
+}
+function makeEntityId3(filePath, kind, name) {
+  return `${kind}:${filePath}:${name}`;
+}
+function normalizeSignature3(text) {
+  return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+}
+// src/semantic/rust-parser.ts
+var rustParser = {
+  languages: ["rust"],
+  parse(content, filePath) {
+    const fileEntityId = `file:${filePath}`;
+    return {
+      fileEntityId,
+      filePath,
+      language: "rust",
+      declarations: extractDeclarations4(content, filePath),
+      imports: extractImports4(content),
+      exports: extractExports4(content, filePath)
+    };
+  },
+  diff(oldResult, newResult) {
+    return computeSemanticDiff4(oldResult, newResult);
+  }
+};
+function extractDeclarations4(content, filePath) {
+  const declarations = [];
+  const lines = content.split(`
+`);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("use ") || trimmed.startsWith("extern ") || trimmed.startsWith("mod ") || trimmed.startsWith("#![")) {
+      i++;
+      continue;
+    }
+    const attrs = [];
+    const attrStart = i;
+    while (i < lines.length && lines[i].trim().startsWith("#[")) {
+      attrs.push(lines[i].trim());
+      i++;
+    }
+    if (i >= lines.length)
+      break;
+    const declLine = lines[i].trim();
+    const stripped = declLine.replace(/^pub(\s*\([^)]*\))?\s+/, "").replace(/^async\s+/, "").replace(/^unsafe\s+/, "").replace(/^const\s+(?=fn)/, "");
+    let match = stripped.match(/^struct\s+(\w+)/);
+    if (match) {
+      if (declLine.includes(";") && !declLine.includes("{")) {
+        const result = extractToSemicolon(match[1], "ClassDef", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+        declarations.push(result.entity);
+        i = result.endLine + 1;
+      } else {
+        const result = extractBraceBlock2(match[1], "ClassDef", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+        result.entity.children = extractStructFields2(lines, i, result.endLine, match[1], filePath);
+        declarations.push(result.entity);
+        i = result.endLine + 1;
+      }
+      continue;
+    }
+    match = stripped.match(/^enum\s+(\w+)/);
+    if (match) {
+      const result = extractBraceBlock2(match[1], "EnumDef", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = stripped.match(/^trait\s+(\w+)/);
+    if (match) {
+      const result = extractBraceBlock2(match[1], "InterfaceDef", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+      result.entity.children = extractTraitMethods(lines, i, result.endLine, match[1], filePath);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = stripped.match(/^impl(?:<[^>]*>)?\s+(?:(\w+)\s+for\s+)?(\w+)/);
+    if (match && stripped.includes("{")) {
+      const typeName = match[2];
+      const traitName = match[1];
+      const implName = traitName ? `${traitName} for ${typeName}` : typeName;
+      const result = extractBraceBlock2(implName, "ClassDef", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+      result.entity.children = extractImplMethods(lines, i, result.endLine, implName, filePath);
+      result.entity.id = makeEntityId4(filePath, "ClassDef", `impl:${implName}`);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = stripped.match(/^fn\s+(\w+)/);
+    if (match) {
+      const result = extractBraceBlock2(match[1], "FunctionDef", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = stripped.match(/^type\s+(\w+)/);
+    if (match) {
+      const result = extractToSemicolon(match[1], "TypeAlias", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = stripped.match(/^const\s+(\w+)/);
+    if (match) {
+      const result = extractToSemicolon(match[1], "VariableDecl", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = stripped.match(/^static\s+(?:mut\s+)?(\w+)/);
+    if (match) {
+      const result = extractToSemicolon(match[1], "VariableDecl", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = stripped.match(/^macro_rules!\s+(\w+)/);
+    if (match) {
+      const result = extractBraceBlock2(match[1], "FunctionDef", lines, attrs.length > 0 ? attrStart : i, i, filePath, attrs);
+      result.entity.id = makeEntityId4(filePath, "FunctionDef", `macro:${match[1]}`);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    if (attrs.length > 0) {
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return declarations;
+}
+function extractBraceBlock2(name, kind, lines, startLine, defLine, filePath, attrs) {
+  let depth = 0;
+  let foundOpen = false;
+  let endLine = defLine;
+  for (let i = defLine;i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === "{") {
+        depth++;
+        foundOpen = true;
+      } else if (ch === "}") {
+        depth--;
+      }
+    }
+    if (foundOpen && depth <= 0) {
+      endLine = i;
+      break;
+    }
+    if (i > defLine + 300) {
+      endLine = i;
+      break;
+    }
+    endLine = i;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId4(filePath, kind, name),
+      kind,
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature4(rawText),
+      children: []
+    },
+    endLine
+  };
+}
+function extractToSemicolon(name, kind, lines, startLine, defLine, filePath, attrs) {
+  let endLine = defLine;
+  for (let i = defLine;i < lines.length; i++) {
+    if (lines[i].includes(";")) {
+      endLine = i;
+      break;
+    }
+    endLine = i;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId4(filePath, kind, name),
+      kind,
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature4(rawText),
+      children: []
+    },
+    endLine
+  };
+}
+function extractStructFields2(lines, startLine, endLine, structName, filePath) {
+  const children = [];
+  let inBody = false;
+  for (let i = startLine;i <= endLine; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.includes("{")) {
+      inBody = true;
+      continue;
+    }
+    if (!inBody)
+      continue;
+    if (trimmed === "}" || !trimmed || trimmed.startsWith("//"))
+      continue;
+    const match = trimmed.match(/^(?:pub\s+)?(\w+)\s*:/);
+    if (match) {
+      children.push({
+        id: makeEntityId4(filePath, "PropertyDef", `${structName}.${match[1]}`),
+        kind: "PropertyDef",
+        name: match[1],
+        scopePath: `${structName}.${match[1]}`,
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature4(trimmed),
+        children: []
+      });
+    }
+  }
+  return children;
+}
+function extractTraitMethods(lines, startLine, endLine, traitName, filePath) {
+  return extractBlockMethods(lines, startLine, endLine, traitName, filePath);
+}
+function extractImplMethods(lines, startLine, endLine, implName, filePath) {
+  return extractBlockMethods(lines, startLine, endLine, implName, filePath);
+}
+function extractBlockMethods(lines, startLine, endLine, parentName, filePath) {
+  const children = [];
+  let depth = 0;
+  for (let i = startLine;i <= endLine; i++) {
+    const line = lines[i];
+    const depthBefore = depth;
+    for (const ch of line) {
+      if (ch === "{")
+        depth++;
+      else if (ch === "}")
+        depth--;
+    }
+    if (depthBefore === 1) {
+      const trimmed = line.trim().replace(/^pub(\s*\([^)]*\))?\s+/, "").replace(/^async\s+/, "").replace(/^unsafe\s+/, "").replace(/^const\s+(?=fn)/, "");
+      const match = trimmed.match(/^fn\s+(\w+)/);
+      if (match) {
+        const kind = match[1] === "new" ? "Constructor" : "MethodDef";
+        children.push({
+          id: makeEntityId4(filePath, kind, `${parentName}.${match[1]}`),
+          kind,
+          name: match[1],
+          scopePath: `${parentName}.${match[1]}`,
+          span: [0, 0],
+          rawText: line.trim(),
+          signature: normalizeSignature4(line.trim()),
+          children: []
+        });
+      }
+    }
+  }
+  return children;
+}
+function extractImports4(content) {
+  const imports = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed.startsWith("use ") && !trimmed.startsWith("pub use "))
+      continue;
+    let full = trimmed;
+    while (!full.includes(";") && i + 1 < lines.length) {
+      i++;
+      full += " " + lines[i].trim();
+    }
+    const cleaned = full.replace(/^pub\s+/, "").replace(/^use\s+/, "").replace(/;$/, "").trim();
+    const braceMatch = cleaned.match(/^(.+)::\{([^}]+)\}$/);
+    if (braceMatch) {
+      const source = braceMatch[1];
+      const specifiers = braceMatch[2].split(",").map((s) => s.trim().split("::").pop().replace(/\s+as\s+\w+/, "")).filter(Boolean);
+      imports.push({
+        source,
+        specifiers,
+        isDefault: false,
+        isNamespace: false,
+        rawText: full,
+        span: [0, full.length]
+      });
+      continue;
+    }
+    const simpleMatch = cleaned.match(/^(.+)::(\w+|\*)$/);
+    if (simpleMatch) {
+      const isWild = simpleMatch[2] === "*";
+      imports.push({
+        source: cleaned,
+        specifiers: [simpleMatch[2]],
+        isDefault: !isWild,
+        isNamespace: isWild,
+        rawText: full,
+        span: [0, full.length]
+      });
+      continue;
+    }
+    const aliasMatch = cleaned.match(/^(\S+)\s+as\s+(\w+)$/);
+    if (aliasMatch) {
+      imports.push({
+        source: aliasMatch[1],
+        specifiers: [aliasMatch[2]],
+        isDefault: true,
+        isNamespace: false,
+        rawText: full,
+        span: [0, full.length]
+      });
+      continue;
+    }
+    imports.push({
+      source: cleaned,
+      specifiers: [cleaned.split("::").pop() ?? cleaned],
+      isDefault: true,
+      isNamespace: false,
+      rawText: full,
+      span: [0, full.length]
+    });
+  }
+  return imports;
+}
+function extractExports4(content, filePath) {
+  const exports = [];
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("pub ") && !trimmed.startsWith("pub("))
+      continue;
+    const match = trimmed.match(/^pub(?:\s*\([^)]*\))?\s+(?:async\s+|unsafe\s+|const\s+)?(?:fn|struct|enum|trait|type|const|static)\s+(\w+)/);
+    if (match) {
+      exports.push({
+        name: match[1],
+        isDefault: false,
+        rawText: trimmed.split("{")[0].trim(),
+        span: [0, 0]
+      });
+    }
+  }
+  return exports;
+}
+function computeSemanticDiff4(oldResult, newResult) {
+  const patches = [];
+  const fileId = newResult.fileEntityId;
+  const oldDecls = new Map(oldResult.declarations.map((d) => [d.id, d]));
+  const newDecls = new Map(newResult.declarations.map((d) => [d.id, d]));
+  for (const [id, entity] of newDecls) {
+    if (!oldDecls.has(id)) {
+      const oldEntity = findRenamedEntity4(entity, oldResult.declarations, newDecls);
+      if (oldEntity) {
+        patches.push({
+          kind: "symbolRename",
+          entityId: oldEntity.id,
+          oldName: oldEntity.name,
+          newName: entity.name
+        });
+      } else {
+        patches.push({ kind: "symbolAdd", entity });
+      }
+    }
+  }
+  for (const [id, entity] of oldDecls) {
+    if (!newDecls.has(id)) {
+      const wasRenamed = findRenamedEntity4(entity, newResult.declarations, oldDecls);
+      if (!wasRenamed) {
+        patches.push({
+          kind: "symbolRemove",
+          entityId: id,
+          entityName: entity.name
+        });
+      }
+    }
+  }
+  for (const [id, newEntity] of newDecls) {
+    const oldEntity = oldDecls.get(id);
+    if (oldEntity && oldEntity.signature !== newEntity.signature) {
+      patches.push({
+        kind: "symbolModify",
+        entityId: id,
+        entityName: newEntity.name,
+        oldSignature: oldEntity.signature,
+        newSignature: newEntity.signature,
+        oldRawText: oldEntity.rawText,
+        newRawText: newEntity.rawText
+      });
+    }
+  }
+  const oldImports = new Map(oldResult.imports.map((imp) => [imp.source, imp]));
+  const newImports = new Map(newResult.imports.map((imp) => [imp.source, imp]));
+  for (const [source, imp] of newImports) {
+    const oldImp = oldImports.get(source);
+    if (!oldImp) {
+      patches.push({
+        kind: "importAdd",
+        fileId,
+        source,
+        specifiers: imp.specifiers,
+        rawText: imp.rawText
+      });
+    } else if (JSON.stringify(oldImp.specifiers.sort()) !== JSON.stringify(imp.specifiers.sort())) {
+      patches.push({
+        kind: "importModify",
+        fileId,
+        source,
+        oldSpecifiers: oldImp.specifiers,
+        newSpecifiers: imp.specifiers
+      });
+    }
+  }
+  for (const [source] of oldImports) {
+    if (!newImports.has(source)) {
+      patches.push({ kind: "importRemove", fileId, source });
+    }
+  }
+  const oldExports = new Map(oldResult.exports.map((exp) => [exp.name, exp]));
+  const newExports = new Map(newResult.exports.map((exp) => [exp.name, exp]));
+  for (const [name, exp] of newExports) {
+    if (!oldExports.has(name)) {
+      patches.push({ kind: "exportAdd", fileId, name, rawText: exp.rawText });
+    }
+  }
+  for (const [name] of oldExports) {
+    if (!newExports.has(name)) {
+      patches.push({ kind: "exportRemove", fileId, name });
+    }
+  }
+  return patches;
+}
+function findRenamedEntity4(entity, candidates, existingIds) {
+  for (const candidate of candidates) {
+    if (candidate.kind !== entity.kind)
+      continue;
+    if (candidate.name === entity.name)
+      continue;
+    if (existingIds.has(candidate.id))
+      continue;
+    const normalizedOld = candidate.signature.replace(new RegExp(candidate.name, "g"), "___");
+    const normalizedNew = entity.signature.replace(new RegExp(entity.name, "g"), "___");
+    if (normalizedOld === normalizedNew)
+      return candidate;
+  }
+  return null;
+}
+function makeEntityId4(filePath, kind, name) {
+  return `${kind}:${filePath}:${name}`;
+}
+function normalizeSignature4(text) {
+  return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+}
+// src/semantic/ruby-parser.ts
+var rubyParser = {
+  languages: ["ruby"],
+  parse(content, filePath) {
+    const fileEntityId = `file:${filePath}`;
+    return {
+      fileEntityId,
+      filePath,
+      language: "ruby",
+      declarations: extractDeclarations5(content, filePath),
+      imports: extractImports5(content),
+      exports: extractExports5(content)
+    };
+  },
+  diff(oldResult, newResult) {
+    return computeSemanticDiff5(oldResult, newResult);
+  }
+};
+function extractDeclarations5(content, filePath) {
+  const declarations = [];
+  const lines = content.split(`
+`);
+  const scopeStack = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      i++;
+      continue;
+    }
+    let match = trimmed.match(/^class\s+([A-Z]\w*(?:::\w+)*)/);
+    if (match) {
+      const name = match[1];
+      scopeStack.push(name);
+      const result = extractEndBlock(name, "ClassDef", lines, i, filePath, scopeStack);
+      result.entity.children = extractClassMembers3(lines, i, result.endLine, name, filePath);
+      declarations.push(result.entity);
+      scopeStack.pop();
+      i = result.endLine + 1;
+      continue;
+    }
+    match = trimmed.match(/^module\s+([A-Z]\w*(?:::\w+)*)/);
+    if (match) {
+      const name = match[1];
+      scopeStack.push(name);
+      const result = extractEndBlock(name, "ClassDef", lines, i, filePath, scopeStack);
+      result.entity.children = extractClassMembers3(lines, i, result.endLine, name, filePath);
+      declarations.push(result.entity);
+      scopeStack.pop();
+      i = result.endLine + 1;
+      continue;
+    }
+    match = trimmed.match(/^def\s+(self\.)?(\w+[?!=]?)/);
+    if (match) {
+      const name = match[1] ? `self.${match[2]}` : match[2];
+      const result = extractEndBlock(name, "FunctionDef", lines, i, filePath, scopeStack);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    match = trimmed.match(/^([A-Z][A-Z0-9_]*)\s*=/);
+    if (match) {
+      declarations.push({
+        id: makeEntityId5(filePath, "VariableDecl", match[1]),
+        kind: "VariableDecl",
+        name: match[1],
+        scopePath: match[1],
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature5(trimmed),
+        children: []
+      });
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return declarations;
+}
+function extractEndBlock(name, kind, lines, startLine, filePath, scopeStack) {
+  let depth = 0;
+  let endLine = startLine;
+  for (let i = startLine;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (isBlockOpener(trimmed))
+      depth++;
+    if (trimmed === "end" || trimmed.startsWith("end ") || trimmed.startsWith("end#"))
+      depth--;
+    if (depth <= 0 && i > startLine) {
+      endLine = i;
+      break;
+    }
+    endLine = i;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId5(filePath, kind, name),
+      kind,
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature5(rawText),
+      children: []
+    },
+    endLine
+  };
+}
+function isBlockOpener(trimmed) {
+  if (/^(class|module|def|do|begin|case)\b/.test(trimmed))
+    return true;
+  if (/^(if|unless|while|until|for)\b/.test(trimmed) && !trimmed.includes(" then "))
+    return true;
+  return false;
+}
+function extractClassMembers3(lines, startLine, endLine, parentName, filePath) {
+  const children = [];
+  let depth = 0;
+  for (let i = startLine;i <= endLine; i++) {
+    const trimmed = lines[i].trim();
+    const depthBefore = depth;
+    if (isBlockOpener(trimmed))
+      depth++;
+    if (trimmed === "end" || trimmed.startsWith("end ") || trimmed.startsWith("end#"))
+      depth--;
+    if (depthBefore === 1) {
+      const match = trimmed.match(/^def\s+(self\.)?(\w+[?!=]?)/);
+      if (match) {
+        const methodName = match[1] ? `self.${match[2]}` : match[2];
+        const kind = methodName === "initialize" ? "Constructor" : "MethodDef";
+        children.push({
+          id: makeEntityId5(filePath, kind, `${parentName}.${methodName}`),
+          kind,
+          name: methodName,
+          scopePath: `${parentName}.${methodName}`,
+          span: [0, 0],
+          rawText: trimmed,
+          signature: normalizeSignature5(trimmed),
+          children: []
+        });
+      }
+      const attrMatch = trimmed.match(/^attr_(accessor|reader|writer)\s+(.*)/);
+      if (attrMatch) {
+        const attrs = attrMatch[2].split(",").map((a) => a.trim().replace(/^:/, ""));
+        for (const attr of attrs) {
+          if (attr) {
+            children.push({
+              id: makeEntityId5(filePath, "PropertyDef", `${parentName}.${attr}`),
+              kind: "PropertyDef",
+              name: attr,
+              scopePath: `${parentName}.${attr}`,
+              span: [0, 0],
+              rawText: trimmed,
+              signature: normalizeSignature5(trimmed),
+              children: []
+            });
+          }
+        }
+      }
+    }
+  }
+  return children;
+}
+function extractImports5(content) {
+  const imports = [];
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    let match = trimmed.match(/^require\s+['"]([^'"]+)['"]/);
+    if (match) {
+      imports.push({
+        source: match[1],
+        specifiers: [match[1].split("/").pop()],
+        isDefault: true,
+        isNamespace: false,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+      continue;
+    }
+    match = trimmed.match(/^require_relative\s+['"]([^'"]+)['"]/);
+    if (match) {
+      imports.push({
+        source: match[1],
+        specifiers: [match[1].split("/").pop()],
+        isDefault: true,
+        isNamespace: false,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+      continue;
+    }
+    match = trimmed.match(/^(include|extend|prepend)\s+([A-Z]\w*(?:::\w+)*)/);
+    if (match) {
+      imports.push({
+        source: match[2],
+        specifiers: [match[2]],
+        isDefault: false,
+        isNamespace: true,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+    }
+  }
+  return imports;
+}
+function extractExports5(content) {
+  const exports = [];
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^module_function\s+:(\w+)/);
+    if (match) {
+      exports.push({
+        name: match[1],
+        isDefault: false,
+        rawText: trimmed,
+        span: [0, 0]
+      });
+    }
+    const pubMatch = trimmed.match(/^public\s+:(\w+)/);
+    if (pubMatch) {
+      exports.push({
+        name: pubMatch[1],
+        isDefault: false,
+        rawText: trimmed,
+        span: [0, 0]
+      });
+    }
+  }
+  return exports;
+}
+function computeSemanticDiff5(oldResult, newResult) {
+  const patches = [];
+  const fileId = newResult.fileEntityId;
+  const oldDecls = new Map(oldResult.declarations.map((d) => [d.id, d]));
+  const newDecls = new Map(newResult.declarations.map((d) => [d.id, d]));
+  for (const [id, entity] of newDecls) {
+    if (!oldDecls.has(id)) {
+      const oldEntity = findRenamedEntity5(entity, oldResult.declarations, newDecls);
+      if (oldEntity) {
+        patches.push({ kind: "symbolRename", entityId: oldEntity.id, oldName: oldEntity.name, newName: entity.name });
+      } else {
+        patches.push({ kind: "symbolAdd", entity });
+      }
+    }
+  }
+  for (const [id, entity] of oldDecls) {
+    if (!newDecls.has(id)) {
+      const wasRenamed = findRenamedEntity5(entity, newResult.declarations, oldDecls);
+      if (!wasRenamed) {
+        patches.push({ kind: "symbolRemove", entityId: id, entityName: entity.name });
+      }
+    }
+  }
+  for (const [id, newEntity] of newDecls) {
+    const oldEntity = oldDecls.get(id);
+    if (oldEntity && oldEntity.signature !== newEntity.signature) {
+      patches.push({
+        kind: "symbolModify",
+        entityId: id,
+        entityName: newEntity.name,
+        oldSignature: oldEntity.signature,
+        newSignature: newEntity.signature,
+        oldRawText: oldEntity.rawText,
+        newRawText: newEntity.rawText
+      });
+    }
+  }
+  const oldImports = new Map(oldResult.imports.map((imp) => [imp.source, imp]));
+  const newImports = new Map(newResult.imports.map((imp) => [imp.source, imp]));
+  for (const [source, imp] of newImports) {
+    const oldImp = oldImports.get(source);
+    if (!oldImp) {
+      patches.push({ kind: "importAdd", fileId, source, specifiers: imp.specifiers, rawText: imp.rawText });
+    } else if (JSON.stringify(oldImp.specifiers.sort()) !== JSON.stringify(imp.specifiers.sort())) {
+      patches.push({ kind: "importModify", fileId, source, oldSpecifiers: oldImp.specifiers, newSpecifiers: imp.specifiers });
+    }
+  }
+  for (const [source] of oldImports) {
+    if (!newImports.has(source)) {
+      patches.push({ kind: "importRemove", fileId, source });
+    }
+  }
+  const oldExports = new Map(oldResult.exports.map((exp) => [exp.name, exp]));
+  const newExports = new Map(newResult.exports.map((exp) => [exp.name, exp]));
+  for (const [name, exp] of newExports) {
+    if (!oldExports.has(name)) {
+      patches.push({ kind: "exportAdd", fileId, name, rawText: exp.rawText });
+    }
+  }
+  for (const [name] of oldExports) {
+    if (!newExports.has(name)) {
+      patches.push({ kind: "exportRemove", fileId, name });
+    }
+  }
+  return patches;
+}
+function findRenamedEntity5(entity, candidates, existingIds) {
+  for (const candidate of candidates) {
+    if (candidate.kind !== entity.kind)
+      continue;
+    if (candidate.name === entity.name)
+      continue;
+    if (existingIds.has(candidate.id))
+      continue;
+    const normalizedOld = candidate.signature.replace(new RegExp(candidate.name, "g"), "___");
+    const normalizedNew = entity.signature.replace(new RegExp(entity.name, "g"), "___");
+    if (normalizedOld === normalizedNew)
+      return candidate;
+  }
+  return null;
+}
+function makeEntityId5(filePath, kind, name) {
+  return `${kind}:${filePath}:${name}`;
+}
+function normalizeSignature5(text) {
+  return text.replace(/#[^\n]*/g, "").replace(/\s+/g, " ").trim();
+}
+// src/semantic/java-parser.ts
+var javaParser = {
+  languages: ["java"],
+  parse(content, filePath) {
+    const fileEntityId = `file:${filePath}`;
+    return {
+      fileEntityId,
+      filePath,
+      language: "java",
+      declarations: extractDeclarations6(content, filePath),
+      imports: extractImports6(content),
+      exports: extractExports6(content, filePath)
+    };
+  },
+  diff(oldResult, newResult) {
+    return computeSemanticDiff6(oldResult, newResult);
+  }
+};
+var MODIFIERS = /(?:(?:public|private|protected|static|final|abstract|synchronized|native|transient|volatile|strictfp|sealed|non-sealed|default)\s+)*/;
+var CLASS_RE = new RegExp(`^${MODIFIERS.source}(class|interface|enum|record|@interface)\\s+(\\w+)`);
+var METHOD_RE = new RegExp(`^${MODIFIERS.source}(?:<[^>]+>\\s+)?(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*\\(`);
+var FIELD_RE = new RegExp(`^${MODIFIERS.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*[;=]`);
+function extractDeclarations6(content, filePath) {
+  const declarations = [];
+  const lines = content.split(`
+`);
+  let i = 0;
+  while (i < lines.length) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("package ") || trimmed.startsWith("import ")) {
+      i++;
+      continue;
+    }
+    const annotations = [];
+    const annoStart = i;
+    while (i < lines.length && lines[i].trim().startsWith("@")) {
+      annotations.push(lines[i].trim());
+      i++;
+    }
+    if (i >= lines.length)
+      break;
+    const declLine = lines[i].trim();
+    const stripped = declLine;
+    const classMatch = stripped.match(CLASS_RE);
+    if (classMatch) {
+      const typeKind = classMatch[1];
+      const name = classMatch[2];
+      const kind = typeKind === "interface" || typeKind === "@interface" ? "InterfaceDef" : typeKind === "enum" ? "EnumDef" : "ClassDef";
+      const result = extractBraceBlock3(name, kind, lines, annotations.length > 0 ? annoStart : i, i, filePath);
+      result.entity.children = extractClassMembers4(lines, i, result.endLine, name, filePath);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    const methodMatch = stripped.match(METHOD_RE);
+    if (methodMatch && !stripped.includes(" class ") && !stripped.includes(" interface ") && !stripped.includes(" new ")) {
+      const name = methodMatch[1];
+      if (name !== "if" && name !== "for" && name !== "while" && name !== "switch" && name !== "catch") {
+        if (stripped.includes("{") || i + 1 < lines.length && lines[i + 1].trim() === "{") {
+          const result = extractBraceBlock3(name, "FunctionDef", lines, annotations.length > 0 ? annoStart : i, i, filePath);
+          declarations.push(result.entity);
+          i = result.endLine + 1;
+          continue;
+        }
+      }
+    }
+    if (annotations.length > 0) {
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return declarations;
+}
+function extractBraceBlock3(name, kind, lines, startLine, defLine, filePath) {
+  let depth = 0;
+  let foundOpen = false;
+  let endLine = defLine;
+  for (let i = defLine;i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === "{") {
+        depth++;
+        foundOpen = true;
+      } else if (ch === "}") {
+        depth--;
+      }
+    }
+    if (foundOpen && depth <= 0) {
+      endLine = i;
+      break;
+    }
+    if (i > defLine + 500) {
+      endLine = i;
+      break;
+    }
+    endLine = i;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId6(filePath, kind, name),
+      kind,
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature6(rawText),
+      children: []
+    },
+    endLine
+  };
+}
+function extractClassMembers4(lines, startLine, endLine, parentName, filePath) {
+  const children = [];
+  let depth = 0;
+  for (let i = startLine;i <= endLine; i++) {
+    const line = lines[i];
+    const depthBefore = depth;
+    for (const ch of line) {
+      if (ch === "{")
+        depth++;
+      else if (ch === "}")
+        depth--;
+    }
+    if (depthBefore !== 1)
+      continue;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("@") || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*"))
+      continue;
+    const classMatch = trimmed.match(CLASS_RE);
+    if (classMatch) {
+      const typeKind = classMatch[1];
+      const name = classMatch[2];
+      const kind = typeKind === "interface" ? "InterfaceDef" : typeKind === "enum" ? "EnumDef" : "ClassDef";
+      children.push({
+        id: makeEntityId6(filePath, kind, `${parentName}.${name}`),
+        kind,
+        name,
+        scopePath: `${parentName}.${name}`,
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature6(trimmed),
+        children: []
+      });
+      continue;
+    }
+    const ctorMatch = trimmed.match(new RegExp(`^${MODIFIERS.source}${parentName}\\s*\\(`));
+    if (ctorMatch) {
+      children.push({
+        id: makeEntityId6(filePath, "Constructor", `${parentName}.${parentName}`),
+        kind: "Constructor",
+        name: parentName,
+        scopePath: `${parentName}.${parentName}`,
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature6(trimmed),
+        children: []
+      });
+      continue;
+    }
+    const methodMatch = trimmed.match(METHOD_RE);
+    if (methodMatch) {
+      const name = methodMatch[1];
+      if (name !== "if" && name !== "for" && name !== "while" && name !== "switch" && name !== "catch" && name !== "return") {
+        children.push({
+          id: makeEntityId6(filePath, "MethodDef", `${parentName}.${name}`),
+          kind: "MethodDef",
+          name,
+          scopePath: `${parentName}.${name}`,
+          span: [0, 0],
+          rawText: trimmed,
+          signature: normalizeSignature6(trimmed),
+          children: []
+        });
+        continue;
+      }
+    }
+    const fieldMatch = trimmed.match(FIELD_RE);
+    if (fieldMatch) {
+      const name = fieldMatch[1];
+      if (name !== "return" && name !== "throw" && name !== "new") {
+        children.push({
+          id: makeEntityId6(filePath, "PropertyDef", `${parentName}.${name}`),
+          kind: "PropertyDef",
+          name,
+          scopePath: `${parentName}.${name}`,
+          span: [0, 0],
+          rawText: trimmed,
+          signature: normalizeSignature6(trimmed),
+          children: []
+        });
+      }
+    }
+  }
+  return children;
+}
+function extractImports6(content) {
+  const imports = [];
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^import\s+(static\s+)?([^;]+);/);
+    if (match) {
+      const isStatic = !!match[1];
+      const path = match[2].trim();
+      const isWildcard = path.endsWith(".*");
+      const source = isWildcard ? path.slice(0, -2) : path;
+      const lastPart = path.split(".").pop();
+      imports.push({
+        source,
+        specifiers: isWildcard ? ["*"] : [lastPart],
+        isDefault: !isWildcard && !isStatic,
+        isNamespace: isWildcard,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+    }
+  }
+  return imports;
+}
+function extractExports6(content, filePath) {
+  const exports = [];
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^public\s+(?:(?:abstract|final|sealed|static)\s+)*(class|interface|enum|record)\s+(\w+)/);
+    if (match) {
+      exports.push({
+        name: match[2],
+        isDefault: false,
+        rawText: trimmed.split("{")[0].trim(),
+        span: [0, 0]
+      });
+    }
+  }
+  return exports;
+}
+function computeSemanticDiff6(oldResult, newResult) {
+  const patches = [];
+  const fileId = newResult.fileEntityId;
+  const oldDecls = new Map(oldResult.declarations.map((d) => [d.id, d]));
+  const newDecls = new Map(newResult.declarations.map((d) => [d.id, d]));
+  for (const [id, entity] of newDecls) {
+    if (!oldDecls.has(id)) {
+      const oldEntity = findRenamedEntity6(entity, oldResult.declarations, newDecls);
+      if (oldEntity) {
+        patches.push({ kind: "symbolRename", entityId: oldEntity.id, oldName: oldEntity.name, newName: entity.name });
+      } else {
+        patches.push({ kind: "symbolAdd", entity });
+      }
+    }
+  }
+  for (const [id, entity] of oldDecls) {
+    if (!newDecls.has(id)) {
+      const wasRenamed = findRenamedEntity6(entity, newResult.declarations, oldDecls);
+      if (!wasRenamed) {
+        patches.push({ kind: "symbolRemove", entityId: id, entityName: entity.name });
+      }
+    }
+  }
+  for (const [id, newEntity] of newDecls) {
+    const oldEntity = oldDecls.get(id);
+    if (oldEntity && oldEntity.signature !== newEntity.signature) {
+      patches.push({
+        kind: "symbolModify",
+        entityId: id,
+        entityName: newEntity.name,
+        oldSignature: oldEntity.signature,
+        newSignature: newEntity.signature,
+        oldRawText: oldEntity.rawText,
+        newRawText: newEntity.rawText
+      });
+    }
+  }
+  const oldImports = new Map(oldResult.imports.map((imp) => [imp.source, imp]));
+  const newImports = new Map(newResult.imports.map((imp) => [imp.source, imp]));
+  for (const [source, imp] of newImports) {
+    const oldImp = oldImports.get(source);
+    if (!oldImp) {
+      patches.push({ kind: "importAdd", fileId, source, specifiers: imp.specifiers, rawText: imp.rawText });
+    } else if (JSON.stringify(oldImp.specifiers.sort()) !== JSON.stringify(imp.specifiers.sort())) {
+      patches.push({ kind: "importModify", fileId, source, oldSpecifiers: oldImp.specifiers, newSpecifiers: imp.specifiers });
+    }
+  }
+  for (const [source] of oldImports) {
+    if (!newImports.has(source)) {
+      patches.push({ kind: "importRemove", fileId, source });
+    }
+  }
+  const oldExports = new Map(oldResult.exports.map((exp) => [exp.name, exp]));
+  const newExports = new Map(newResult.exports.map((exp) => [exp.name, exp]));
+  for (const [name, exp] of newExports) {
+    if (!oldExports.has(name)) {
+      patches.push({ kind: "exportAdd", fileId, name, rawText: exp.rawText });
+    }
+  }
+  for (const [name] of oldExports) {
+    if (!newExports.has(name)) {
+      patches.push({ kind: "exportRemove", fileId, name });
+    }
+  }
+  return patches;
+}
+function findRenamedEntity6(entity, candidates, existingIds) {
+  for (const candidate of candidates) {
+    if (candidate.kind !== entity.kind)
+      continue;
+    if (candidate.name === entity.name)
+      continue;
+    if (existingIds.has(candidate.id))
+      continue;
+    const normalizedOld = candidate.signature.replace(new RegExp(candidate.name, "g"), "___");
+    const normalizedNew = entity.signature.replace(new RegExp(entity.name, "g"), "___");
+    if (normalizedOld === normalizedNew)
+      return candidate;
+  }
+  return null;
+}
+function makeEntityId6(filePath, kind, name) {
+  return `${kind}:${filePath}:${name}`;
+}
+function normalizeSignature6(text) {
+  return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+}
+// src/semantic/csharp-parser.ts
+var csharpParser = {
+  languages: ["csharp"],
+  parse(content, filePath) {
+    const fileEntityId = `file:${filePath}`;
+    return {
+      fileEntityId,
+      filePath,
+      language: "csharp",
+      declarations: extractDeclarations7(content, filePath),
+      imports: extractImports7(content),
+      exports: extractExports7(content)
+    };
+  },
+  diff(oldResult, newResult) {
+    return computeSemanticDiff7(oldResult, newResult);
+  }
+};
+var MODIFIERS_RE = /(?:(?:public|private|protected|internal|static|abstract|sealed|virtual|override|partial|readonly|async|extern|unsafe|volatile|new)\s+)*/;
+var TYPE_DEF_RE = new RegExp(`^${MODIFIERS_RE.source}(class|interface|struct|enum|record)\\s+(\\w+)`);
+var METHOD_RE2 = new RegExp(`^${MODIFIERS_RE.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*[(<]`);
+var PROP_RE = new RegExp(`^${MODIFIERS_RE.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*\\{`);
+var FIELD_RE2 = new RegExp(`^${MODIFIERS_RE.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*[;=]`);
+function extractDeclarations7(content, filePath) {
+  const declarations = [];
+  const lines = content.split(`
+`);
+  let i = 0;
+  while (i < lines.length) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("using ") || trimmed.startsWith("namespace ")) {
+      i++;
+      continue;
+    }
+    const attributes = [];
+    const attrStart = i;
+    while (i < lines.length && lines[i].trim().startsWith("[")) {
+      attributes.push(lines[i].trim());
+      i++;
+    }
+    if (i >= lines.length)
+      break;
+    const declLine = lines[i].trim();
+    const typeMatch = declLine.match(TYPE_DEF_RE);
+    if (typeMatch) {
+      const typeKind = typeMatch[1];
+      const name = typeMatch[2];
+      const kind = typeKind === "interface" ? "InterfaceDef" : typeKind === "enum" ? "EnumDef" : "ClassDef";
+      const result = extractBraceBlock4(name, kind, lines, attributes.length > 0 ? attrStart : i, i, filePath);
+      result.entity.children = extractTypeMembers(lines, i, result.endLine, name, filePath);
+      declarations.push(result.entity);
+      i = result.endLine + 1;
+      continue;
+    }
+    if (attributes.length > 0) {
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return declarations;
+}
+function extractBraceBlock4(name, kind, lines, startLine, defLine, filePath) {
+  let depth = 0;
+  let foundOpen = false;
+  let endLine = defLine;
+  for (let i = defLine;i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === "{") {
+        depth++;
+        foundOpen = true;
+      } else if (ch === "}")
+        depth--;
+    }
+    if (foundOpen && depth <= 0) {
+      endLine = i;
+      break;
+    }
+    if (i > defLine + 500) {
+      endLine = i;
+      break;
+    }
+    endLine = i;
+  }
+  const rawText = lines.slice(startLine, endLine + 1).join(`
+`);
+  const startOffset = lines.slice(0, startLine).join(`
+`).length + (startLine > 0 ? 1 : 0);
+  return {
+    entity: {
+      id: makeEntityId7(filePath, kind, name),
+      kind,
+      name,
+      scopePath: name,
+      span: [startOffset, startOffset + rawText.length],
+      rawText,
+      signature: normalizeSignature7(rawText),
+      children: []
+    },
+    endLine
+  };
+}
+var CONTROL_FLOW = new Set(["if", "for", "foreach", "while", "switch", "catch", "using", "lock", "try", "else", "return", "throw", "new", "yield", "await"]);
+function extractTypeMembers(lines, startLine, endLine, parentName, filePath) {
+  const children = [];
+  let depth = 0;
+  for (let i = startLine;i <= endLine; i++) {
+    const line = lines[i];
+    const depthBefore = depth;
+    for (const ch of line) {
+      if (ch === "{")
+        depth++;
+      else if (ch === "}")
+        depth--;
+    }
+    if (depthBefore !== 1)
+      continue;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("["))
+      continue;
+    const nestedMatch = trimmed.match(TYPE_DEF_RE);
+    if (nestedMatch) {
+      const typeKind = nestedMatch[1];
+      const name = nestedMatch[2];
+      const kind = typeKind === "interface" ? "InterfaceDef" : typeKind === "enum" ? "EnumDef" : "ClassDef";
+      children.push({
+        id: makeEntityId7(filePath, kind, `${parentName}.${name}`),
+        kind,
+        name,
+        scopePath: `${parentName}.${name}`,
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature7(trimmed),
+        children: []
+      });
+      continue;
+    }
+    const ctorMatch = trimmed.match(new RegExp(`^${MODIFIERS_RE.source}${parentName}\\s*\\(`));
+    if (ctorMatch) {
+      children.push({
+        id: makeEntityId7(filePath, "Constructor", `${parentName}.${parentName}`),
+        kind: "Constructor",
+        name: parentName,
+        scopePath: `${parentName}.${parentName}`,
+        span: [0, 0],
+        rawText: trimmed,
+        signature: normalizeSignature7(trimmed),
+        children: []
+      });
+      continue;
+    }
+    const propMatch = trimmed.match(PROP_RE);
+    if (propMatch) {
+      const name = propMatch[1];
+      if (!CONTROL_FLOW.has(name)) {
+        const restOfLine = trimmed.slice(trimmed.indexOf(name) + name.length).trim();
+        if (restOfLine.startsWith("{") && (restOfLine.includes("get") || restOfLine.includes("set") || restOfLine.includes("=>") || !restOfLine.includes("("))) {
+          children.push({
+            id: makeEntityId7(filePath, "PropertyDef", `${parentName}.${name}`),
+            kind: "PropertyDef",
+            name,
+            scopePath: `${parentName}.${name}`,
+            span: [0, 0],
+            rawText: trimmed,
+            signature: normalizeSignature7(trimmed),
+            children: []
+          });
+          continue;
+        }
+      }
+    }
+    const methodMatch = trimmed.match(METHOD_RE2);
+    if (methodMatch) {
+      const name = methodMatch[1];
+      if (!CONTROL_FLOW.has(name) && name !== parentName) {
+        children.push({
+          id: makeEntityId7(filePath, "MethodDef", `${parentName}.${name}`),
+          kind: "MethodDef",
+          name,
+          scopePath: `${parentName}.${name}`,
+          span: [0, 0],
+          rawText: trimmed,
+          signature: normalizeSignature7(trimmed),
+          children: []
+        });
+        continue;
+      }
+    }
+    const fieldMatch = trimmed.match(FIELD_RE2);
+    if (fieldMatch) {
+      const name = fieldMatch[1];
+      if (!CONTROL_FLOW.has(name) && name !== "var") {
+        children.push({
+          id: makeEntityId7(filePath, "PropertyDef", `${parentName}.${name}`),
+          kind: "PropertyDef",
+          name,
+          scopePath: `${parentName}.${name}`,
+          span: [0, 0],
+          rawText: trimmed,
+          signature: normalizeSignature7(trimmed),
+          children: []
+        });
+      }
+    }
+  }
+  return children;
+}
+function extractImports7(content) {
+  const imports = [];
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    let match = trimmed.match(/^using\s+([A-Z][\w.]+)\s*;/);
+    if (match) {
+      imports.push({
+        source: match[1],
+        specifiers: [match[1].split(".").pop()],
+        isDefault: false,
+        isNamespace: true,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+      continue;
+    }
+    match = trimmed.match(/^using\s+static\s+([A-Z][\w.]+)\s*;/);
+    if (match) {
+      imports.push({
+        source: match[1],
+        specifiers: [match[1].split(".").pop()],
+        isDefault: false,
+        isNamespace: false,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+      continue;
+    }
+    match = trimmed.match(/^using\s+(\w+)\s*=\s*([^;]+);/);
+    if (match) {
+      imports.push({
+        source: match[2].trim(),
+        specifiers: [match[1]],
+        isDefault: true,
+        isNamespace: false,
+        rawText: trimmed,
+        span: [0, trimmed.length]
+      });
+    }
+  }
+  return imports;
+}
+function extractExports7(content) {
+  const exports = [];
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^public\s+(?:(?:abstract|sealed|static|partial)\s+)*(class|interface|struct|enum|record)\s+(\w+)/);
+    if (match) {
+      exports.push({
+        name: match[2],
+        isDefault: false,
+        rawText: trimmed.split("{")[0].trim(),
+        span: [0, 0]
+      });
+    }
+  }
+  return exports;
+}
+function computeSemanticDiff7(oldResult, newResult) {
+  const patches = [];
+  const fileId = newResult.fileEntityId;
+  const oldDecls = new Map(oldResult.declarations.map((d) => [d.id, d]));
+  const newDecls = new Map(newResult.declarations.map((d) => [d.id, d]));
+  for (const [id, entity] of newDecls) {
+    if (!oldDecls.has(id)) {
+      const oldEntity = findRenamedEntity7(entity, oldResult.declarations, newDecls);
+      if (oldEntity) {
+        patches.push({ kind: "symbolRename", entityId: oldEntity.id, oldName: oldEntity.name, newName: entity.name });
+      } else {
+        patches.push({ kind: "symbolAdd", entity });
+      }
+    }
+  }
+  for (const [id, entity] of oldDecls) {
+    if (!newDecls.has(id)) {
+      const wasRenamed = findRenamedEntity7(entity, newResult.declarations, oldDecls);
+      if (!wasRenamed) {
+        patches.push({ kind: "symbolRemove", entityId: id, entityName: entity.name });
+      }
+    }
+  }
+  for (const [id, newEntity] of newDecls) {
+    const oldEntity = oldDecls.get(id);
+    if (oldEntity && oldEntity.signature !== newEntity.signature) {
+      patches.push({
+        kind: "symbolModify",
+        entityId: id,
+        entityName: newEntity.name,
+        oldSignature: oldEntity.signature,
+        newSignature: newEntity.signature,
+        oldRawText: oldEntity.rawText,
+        newRawText: newEntity.rawText
+      });
+    }
+  }
+  const oldImports = new Map(oldResult.imports.map((imp) => [imp.source, imp]));
+  const newImports = new Map(newResult.imports.map((imp) => [imp.source, imp]));
+  for (const [source, imp] of newImports) {
+    const oldImp = oldImports.get(source);
+    if (!oldImp) {
+      patches.push({ kind: "importAdd", fileId, source, specifiers: imp.specifiers, rawText: imp.rawText });
+    } else if (JSON.stringify(oldImp.specifiers.sort()) !== JSON.stringify(imp.specifiers.sort())) {
+      patches.push({ kind: "importModify", fileId, source, oldSpecifiers: oldImp.specifiers, newSpecifiers: imp.specifiers });
+    }
+  }
+  for (const [source] of oldImports) {
+    if (!newImports.has(source)) {
+      patches.push({ kind: "importRemove", fileId, source });
+    }
+  }
+  const oldExports = new Map(oldResult.exports.map((exp) => [exp.name, exp]));
+  const newExports = new Map(newResult.exports.map((exp) => [exp.name, exp]));
+  for (const [name, exp] of newExports) {
+    if (!oldExports.has(name)) {
+      patches.push({ kind: "exportAdd", fileId, name, rawText: exp.rawText });
+    }
+  }
+  for (const [name] of oldExports) {
+    if (!newExports.has(name)) {
+      patches.push({ kind: "exportRemove", fileId, name });
+    }
+  }
+  return patches;
+}
+function findRenamedEntity7(entity, candidates, existingIds) {
+  for (const candidate of candidates) {
+    if (candidate.kind !== entity.kind)
+      continue;
+    if (candidate.name === entity.name)
+      continue;
+    if (existingIds.has(candidate.id))
+      continue;
+    const normalizedOld = candidate.signature.replace(new RegExp(candidate.name, "g"), "___");
+    const normalizedNew = entity.signature.replace(new RegExp(entity.name, "g"), "___");
+    if (normalizedOld === normalizedNew)
+      return candidate;
+  }
+  return null;
+}
+function makeEntityId7(filePath, kind, name) {
+  return `${kind}:${filePath}:${name}`;
+}
+function normalizeSignature7(text) {
+  return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+}
+// src/engine.ts
+class JsonOpLog {
+  ops = [];
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  load() {
+    if (existsSync(this.filePath)) {
+      const raw = readFileSync(this.filePath, "utf-8");
+      try {
+        this.ops = JSON.parse(raw);
+      } catch (err) {
+        const backupPath = this.filePath + ".bak";
+        if (existsSync(backupPath)) {
+          const backupRaw = readFileSync(backupPath, "utf-8");
+          this.ops = JSON.parse(backupRaw);
+          writeFileSync(this.filePath, backupRaw);
+        } else {
+          throw new Error(`Corrupted ops.json and no backup found. Run \`trellis repair\` to attempt recovery.`);
+        }
+      }
+    }
+  }
+  append(op) {
+    this.ops.push(op);
+    this.flush();
+  }
+  readAll() {
+    return [...this.ops];
+  }
+  getLastOp() {
+    return this.ops.length > 0 ? this.ops[this.ops.length - 1] : undefined;
+  }
+  count() {
+    return this.ops.length;
+  }
+  flush() {
+    const dir = dirname(this.filePath);
+    if (!existsSync(dir))
+      mkdirSync(dir, { recursive: true });
+    if (existsSync(this.filePath)) {
+      const backupPath = this.filePath + ".bak";
+      try {
+        copyFileSync(this.filePath, backupPath);
+      } catch {}
+    }
+    writeFileSync(this.filePath, JSON.stringify(this.ops, null, 2));
+  }
+  static repair(filePath) {
+    if (!existsSync(filePath)) {
+      return { recovered: 0, lost: 0 };
+    }
+    const raw = readFileSync(filePath, "utf-8");
+    try {
+      const ops = JSON.parse(raw);
+      return { recovered: ops.length, lost: 0 };
+    } catch {}
+    const lastHash = raw.lastIndexOf('"hash": "trellis:op:');
+    if (lastHash === -1) {
+      const bakPath = filePath + ".bak";
+      if (existsSync(bakPath)) {
+        const bakRaw = readFileSync(bakPath, "utf-8");
+        try {
+          const ops = JSON.parse(bakRaw);
+          writeFileSync(filePath, bakRaw);
+          return { recovered: ops.length, lost: 0 };
+        } catch {}
+      }
+      writeFileSync(filePath, "[]");
+      return { recovered: 0, lost: -1 };
+    }
+    const endOfLine = raw.indexOf(`
+`, lastHash);
+    const closingBrace = raw.indexOf("  }", endOfLine);
+    if (closingBrace === -1) {
+      writeFileSync(filePath, "[]");
+      return { recovered: 0, lost: -1 };
+    }
+    const fixed = raw.slice(0, closingBrace + 3) + `
+]`;
+    try {
+      const ops = JSON.parse(fixed);
+      writeFileSync(filePath + ".corrupted", raw);
+      writeFileSync(filePath, fixed);
+      return { recovered: ops.length, lost: 0 };
+    } catch {
+      writeFileSync(filePath + ".corrupted", raw);
+      writeFileSync(filePath, "[]");
+      return { recovered: 0, lost: -1 };
+    }
+  }
+}
+function parseIgnoreFile(filePath) {
+  if (!existsSync(filePath))
+    return [];
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return content.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map((line) => line.replace(/\/$/, ""));
+  } catch {
+    return [];
+  }
+}
+function readIgnorePatterns(rootPath) {
+  return [
+    ...parseIgnoreFile(join2(rootPath, ".gitignore")),
+    ...parseIgnoreFile(join2(rootPath, ".trellisignore"))
+  ];
+}
+
+class TrellisVcsEngine {
+  config;
+  store;
+  opLog;
+  watcher = null;
+  ingestion = null;
+  agentId;
+  currentBranch = "main";
+  checkpointOpCount = 0;
+  checkpointThreshold = 100;
+  _pendingAutoCheckpoint = false;
+  _blobStore = null;
+  constructor(opts) {
+    const gitignorePatterns = readIgnorePatterns(opts.rootPath);
+    const mergedIgnore = [
+      ...new Set([
+        ...opts.ignorePatterns ?? DEFAULT_CONFIG.ignorePatterns,
+        ...gitignorePatterns
+      ])
+    ];
+    this.config = {
+      rootPath: opts.rootPath,
+      ignorePatterns: mergedIgnore,
+      debounceMs: opts.debounceMs ?? DEFAULT_CONFIG.debounceMs,
+      defaultBranch: opts.defaultBranch ?? DEFAULT_CONFIG.defaultBranch,
+      dbPath: opts.dbPath ?? DEFAULT_CONFIG.dbPath
+    };
+    this.agentId = opts.agentId ?? `agent:${process.env.USER ?? "unknown"}`;
+    this.store = new EAVStore;
+    this.opLog = new JsonOpLog(join2(this.config.rootPath, ".trellis", "ops.json"));
+  }
+  async initRepo() {
+    const trellisDir = join2(this.config.rootPath, ".trellis");
+    if (!existsSync(trellisDir)) {
+      mkdirSync(trellisDir, { recursive: true });
+    }
+    this._blobStore = new BlobStore(trellisDir);
+    const configPath = join2(trellisDir, "config.json");
+    const persistedConfig = {
+      rootPath: this.config.rootPath,
+      ignorePatterns: this.config.ignorePatterns,
+      debounceMs: this.config.debounceMs,
+      defaultBranch: this.config.defaultBranch,
+      agentId: this.agentId,
+      createdAt: new Date().toISOString()
+    };
+    writeFileSync(configPath, JSON.stringify(persistedConfig, null, 2));
+    this.opLog.load();
+    const branchOp = await createVcsOp("vcs:branchCreate", {
+      agentId: this.agentId,
+      previousHash: this.opLog.getLastOp()?.hash,
+      vcs: {
+        branchName: this.config.defaultBranch
+      }
+    });
+    this.applyOp(branchOp);
+    const scanner = new FileWatcher({
+      rootPath: this.config.rootPath,
+      ignorePatterns: [...this.config.ignorePatterns, ".trellis"],
+      debounceMs: this.config.debounceMs,
+      onEvent: () => {}
+    });
+    const events = await scanner.scan();
+    let opsCreated = 1;
+    for (const event of events) {
+      if (event.contentHash) {
+        try {
+          const absPath = join2(this.config.rootPath, event.path);
+          const content = await readFile2(absPath);
+          await this._blobStore.put(content);
+        } catch {}
+      }
+      const op = await createVcsOp("vcs:fileAdd", {
+        agentId: this.agentId,
+        previousHash: this.opLog.getLastOp()?.hash,
+        vcs: {
+          filePath: event.path,
+          contentHash: event.contentHash,
+          size: event.size
+        }
+      });
+      this.applyOp(op);
+      opsCreated++;
+    }
+    await this.flushAutoCheckpoint();
+    return { opsCreated };
+  }
+  open() {
+    this.opLog.load();
+    const trellisDir = join2(this.config.rootPath, ".trellis");
+    this._blobStore = new BlobStore(trellisDir);
+    const configPath = join2(this.config.rootPath, ".trellis", "config.json");
+    if (existsSync(configPath)) {
+      const raw = readFileSync(configPath, "utf-8");
+      const persisted = JSON.parse(raw);
+      this.agentId = persisted.agentId;
+      const filePatterns = readIgnorePatterns(this.config.rootPath);
+      this.config.ignorePatterns = [
+        ...new Set([...persisted.ignorePatterns, ...filePatterns])
+      ];
+      this.config.debounceMs = persisted.debounceMs;
+      this.config.defaultBranch = persisted.defaultBranch;
+    }
+    this.loadCurrentBranch();
+    const ops = this.opLog.readAll();
+    for (const op of ops) {
+      this.replayOp(op);
+    }
+    return { opsReplayed: ops.length };
+  }
+  watch() {
+    this.ingestion = new Ingestion({
+      agentId: this.agentId,
+      lastOpHash: this.opLog.getLastOp()?.hash,
+      onOp: (op) => this.applyOp(op)
+    });
+    this.watcher = new FileWatcher({
+      rootPath: this.config.rootPath,
+      ignorePatterns: [...this.config.ignorePatterns, ".trellis"],
+      debounceMs: this.config.debounceMs,
+      onEvent: async (event) => {
+        if ((event.type === "add" || event.type === "modify") && event.contentHash && this._blobStore) {
+          try {
+            const absPath = join2(this.config.rootPath, event.path);
+            const content = await readFile2(absPath);
+            await this._blobStore.put(content);
+          } catch {}
+        }
+        await this.ingestion.process(event);
+      }
+    });
+    this.watcher.scan().then(async (scanEvents) => {
+      const trackedPaths = new Set(this.trackedFiles().map((f) => f.path));
+      for (const event of scanEvents) {
+        if (!trackedPaths.has(event.path)) {
+          if (event.contentHash && this._blobStore) {
+            try {
+              const absPath = join2(this.config.rootPath, event.path);
+              const content = await readFile2(absPath);
+              await this._blobStore.put(content);
+            } catch {}
+          }
+          await this.ingestion.process(event);
+        }
+      }
+      this.watcher.start();
+    });
+  }
+  stop() {
+    this.watcher?.stop();
+    this.watcher = null;
+    this.ingestion = null;
+  }
+  getOps() {
+    return this.opLog.readAll();
+  }
+  getOpCount() {
+    return this.opLog.count();
+  }
+  getStore() {
+    return this.store;
+  }
+  getBlobStore() {
+    return this._blobStore;
+  }
+  status() {
+    const ops = this.opLog.readAll();
+    const fileEntities = this.store.getFactsByAttribute("type").filter((f) => f.v === "FileNode");
+    return {
+      branch: this.currentBranch,
+      totalOps: ops.length,
+      trackedFiles: fileEntities.length,
+      lastOp: ops[ops.length - 1],
+      recentOps: ops.slice(-10)
+    };
+  }
+  log(opts) {
+    let ops = this.opLog.readAll();
+    if (opts?.filePath) {
+      ops = ops.filter((op) => {
+        const vcs = op.vcs;
+        return vcs?.filePath === opts.filePath || vcs?.oldFilePath === opts.filePath;
+      });
+    }
+    if (opts?.limit) {
+      ops = ops.slice(-opts.limit);
+    }
+    return ops;
+  }
+  trackedFiles() {
+    const fileTypeFacts = this.store.getFactsByAttribute("type").filter((f) => f.v === "FileNode");
+    return fileTypeFacts.map((f) => {
+      const pathFacts = this.store.getFactsByEntity(f.e).filter((ef) => ef.a === "path");
+      const hashFacts = this.store.getFactsByEntity(f.e).filter((ef) => ef.a === "contentHash");
+      return {
+        path: pathFacts[0]?.v ?? f.e,
+        contentHash: hashFacts[0]?.v
+      };
+    });
+  }
+  getRootPath() {
+    return this.config.rootPath;
+  }
+  static isRepo(rootPath) {
+    return existsSync(join2(rootPath, ".trellis", "config.json"));
+  }
+  static repair(rootPath) {
+    const opsPath = join2(rootPath, ".trellis", "ops.json");
+    return JsonOpLog.repair(opsPath);
+  }
+  async createBranch(name) {
+    const op = await createBranch(this._ctx(), name, this.currentBranch);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  switchBranch(name) {
+    switchBranch(this._ctx(), name);
+    this.currentBranch = name;
+    saveBranchState(this.config.rootPath, { currentBranch: name });
+  }
+  listBranches() {
+    return listBranches(this._ctx(), this.currentBranch);
+  }
+  async deleteBranch(name) {
+    const op = await deleteBranch(this._ctx(), name, this.currentBranch);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  getCurrentBranch() {
+    return this.currentBranch;
+  }
+  async createMilestone(message, opts) {
+    const op = await createMilestone(this._ctx(), message, opts);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  listMilestones() {
+    return listMilestones(this._ctx());
+  }
+  async createCheckpoint(trigger = "manual") {
+    const op = await createCheckpoint(this._ctx(), trigger);
+    this.checkpointOpCount = 0;
+    return op;
+  }
+  listCheckpoints() {
+    return listCheckpoints(this._ctx());
+  }
+  setCheckpointThreshold(threshold) {
+    this.checkpointThreshold = threshold;
+  }
+  diffBranches(branchA, branchB) {
+    const ops = this.opLog.readAll();
+    const stateA = buildFileStateAtOp(ops);
+    const stateB = buildFileStateAtOp(ops);
+    return diffFileStates(stateA, stateB, this._blobStore);
+  }
+  diffOps(fromHash, toHash) {
+    return diffOpRange(this.opLog.readAll(), fromHash, toHash, this._blobStore);
+  }
+  diffFromOp(opHash) {
+    const ops = this.opLog.readAll();
+    const stateA = buildFileStateAtOp(ops, opHash);
+    const stateB = buildFileStateAtOp(ops);
+    return diffFileStates(stateA, stateB, this._blobStore);
+  }
+  mergeBranch(sourceBranch) {
+    const ops = this.opLog.readAll();
+    const branchOp = ops.find((o) => o.kind === "vcs:branchCreate" && o.vcs?.branchName === sourceBranch);
+    const forkHash = branchOp?.vcs?.targetOpHash;
+    const base = forkHash ? buildFileStateAtOp(ops, forkHash) : new Map;
+    const ours = buildFileStateAtOp(ops);
+    const theirs = buildFileStateAtOp(ops);
+    return threeWayMerge(base, ours, theirs, this._blobStore);
+  }
+  _parsers = [
+    typescriptParser,
+    pythonParser,
+    goParser,
+    rustParser,
+    rubyParser,
+    javaParser,
+    csharpParser
+  ];
+  parseFile(content, filePath) {
+    const ext = filePath.split(".").pop() ?? "";
+    const parser = this._parsers.find((p) => p.languages.some((lang) => {
+      if (lang === "typescript")
+        return ext === "ts";
+      if (lang === "javascript")
+        return ext === "js" || ext === "mjs" || ext === "cjs";
+      if (lang === "tsx")
+        return ext === "tsx";
+      if (lang === "jsx")
+        return ext === "jsx";
+      if (lang === "python")
+        return ext === "py" || ext === "pyi";
+      if (lang === "go")
+        return ext === "go";
+      if (lang === "rust")
+        return ext === "rs";
+      if (lang === "ruby")
+        return ext === "rb";
+      if (lang === "java")
+        return ext === "java";
+      if (lang === "csharp")
+        return ext === "cs";
+      return false;
+    }));
+    if (!parser)
+      return null;
+    return parser.parse(content, filePath);
+  }
+  semanticDiff(oldContent, newContent, filePath) {
+    const parser = this._parsers.find((p) => p.languages.some((lang) => {
+      const ext = filePath.split(".").pop() ?? "";
+      if (lang === "typescript")
+        return ext === "ts";
+      if (lang === "javascript")
+        return ext === "js" || ext === "mjs" || ext === "cjs";
+      if (lang === "tsx")
+        return ext === "tsx";
+      if (lang === "jsx")
+        return ext === "jsx";
+      if (lang === "python")
+        return ext === "py" || ext === "pyi";
+      if (lang === "go")
+        return ext === "go";
+      if (lang === "rust")
+        return ext === "rs";
+      if (lang === "ruby")
+        return ext === "rb";
+      if (lang === "java")
+        return ext === "java";
+      if (lang === "csharp")
+        return ext === "cs";
+      return false;
+    }));
+    if (!parser)
+      return [];
+    const oldResult = parser.parse(oldContent, filePath);
+    const newResult = parser.parse(newContent, filePath);
+    return parser.diff(oldResult, newResult);
+  }
+  _garden = null;
+  garden() {
+    if (!this._garden) {
+      this._garden = new IdeaGarden({
+        readAllOps: () => this.opLog.readAll(),
+        getMilestonedOpHashes: () => buildMilestonedOpHashes(this.opLog.readAll())
+      });
+    }
+    return this._garden;
+  }
+  async createIssue(title, opts) {
+    const op = await createIssue(this._ctx(), this.config.rootPath, title, opts);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async updateIssue(id, updates) {
+    const op = await updateIssue(this._ctx(), id, updates);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async startIssue(id) {
+    const issue = getIssue(this._ctx(), id);
+    if (!issue)
+      throw new Error(`Issue ${id} not found.`);
+    const slug = (issue.title ?? id).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+    const branchName = `issue/${id}-${slug}`;
+    await this.createBranch(branchName);
+    const op = await startIssue(this._ctx(), id, branchName);
+    this.switchBranch(branchName);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async pauseIssue(id, note) {
+    const op = await pauseIssue(this._ctx(), id, note);
+    this.switchBranch(this.config.defaultBranch);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async resumeIssue(id) {
+    const issue = getIssue(this._ctx(), id);
+    if (!issue)
+      throw new Error(`Issue ${id} not found.`);
+    if (!issue.branchName)
+      throw new Error(`Issue ${id} has no tracked branch.`);
+    const op = await resumeIssue(this._ctx(), id);
+    this.switchBranch(issue.branchName);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async closeIssue(id, opts) {
+    const result = await closeIssue(this._ctx(), id, opts);
+    if (result.op) {
+      await this.flushAutoCheckpoint();
+    }
+    return result;
+  }
+  async triageIssue(id) {
+    const op = await triageIssue(this._ctx(), id);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async reopenIssue(id) {
+    const op = await reopenIssue(this._ctx(), id);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  checkCompletionReadiness() {
+    return checkCompletionReadiness(this._ctx());
+  }
+  async assignIssue(id, agentId) {
+    const op = await assignIssue(this._ctx(), id, agentId);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async blockIssue(id, blockedById) {
+    const op = await blockIssue(this._ctx(), id, blockedById);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async unblockIssue(id, blockedById) {
+    const op = await unblockIssue(this._ctx(), id, blockedById);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async addCriterion(issueId, description, command) {
+    const op = await addCriterion(this._ctx(), issueId, description, command);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async setCriterionStatus(issueId, criterionIndex, status) {
+    const op = await setCriterionStatus(this._ctx(), issueId, criterionIndex, status);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  async runCriteria(issueId) {
+    return runCriteria(this._ctx(), issueId, this.config.rootPath);
+  }
+  listIssues(filters) {
+    return listIssues(this._ctx(), filters);
+  }
+  getIssue(id) {
+    return getIssue(this._ctx(), id);
+  }
+  getActiveIssues() {
+    return getActiveIssues(this._ctx());
+  }
+  async recordDecision(input) {
+    const op = await recordDecision(this._ctx(), this.config.rootPath, input);
+    await this.flushAutoCheckpoint();
+    return op;
+  }
+  queryDecisions(filter) {
+    return queryDecisions(this._ctx(), filter);
+  }
+  getDecisionChain(entityId) {
+    return getDecisionChain(this._ctx(), entityId);
+  }
+  getDecision(id) {
+    return getDecision(this._ctx(), id);
+  }
+  _ctx() {
+    return {
+      store: this.store,
+      agentId: this.agentId,
+      readAllOps: () => this.opLog.readAll(),
+      getLastOp: () => this.opLog.getLastOp(),
+      applyOp: (op) => this.applyOp(op)
+    };
+  }
+  applyOp(op) {
+    const decomposed = decompose(op);
+    if (decomposed.deleteFacts.length > 0) {
+      this.store.deleteFacts(decomposed.deleteFacts);
+    }
+    if (decomposed.deleteLinks.length > 0) {
+      this.store.deleteLinks(decomposed.deleteLinks);
+    }
+    if (decomposed.addFacts.length > 0) {
+      this.store.addFacts(decomposed.addFacts);
+    }
+    if (decomposed.addLinks.length > 0) {
+      this.store.addLinks(decomposed.addLinks);
+    }
+    this.opLog.append(op);
+    if (op.kind !== "vcs:checkpointCreate" && this.checkpointThreshold > 0) {
+      this.checkpointOpCount++;
+      if (this.checkpointOpCount >= this.checkpointThreshold) {
+        this._pendingAutoCheckpoint = true;
+      }
+    }
+  }
+  async flushAutoCheckpoint() {
+    if (this._pendingAutoCheckpoint) {
+      this._pendingAutoCheckpoint = false;
+      await this.createCheckpoint("op-count");
+    }
+  }
+  loadCurrentBranch() {
+    const state = loadBranchState(this.config.rootPath);
+    this.currentBranch = state.currentBranch;
+  }
+  replayOp(op) {
+    const decomposed = decompose(op);
+    if (decomposed.deleteFacts.length > 0) {
+      this.store.deleteFacts(decomposed.deleteFacts);
+    }
+    if (decomposed.deleteLinks.length > 0) {
+      this.store.deleteLinks(decomposed.deleteLinks);
+    }
+    if (decomposed.addFacts.length > 0) {
+      this.store.addFacts(decomposed.addFacts);
+    }
+    if (decomposed.addLinks.length > 0) {
+      this.store.addLinks(decomposed.addLinks);
+    }
+  }
+}
+
+export { FileWatcher, Ingestion, TrellisVcsEngine };